Functions
Vortex contains most of the basic TidalCycles functions. Here is a comprehensive list of all the functions currently defined in the Python codebase. Take some time to discover them all.
Concatenative operations
These functions typically take up to n patterns to form a single pattern that contains them all, making a sequence.
slowcat
: make a single pattern out of multiple patterns without speeding up. The pattern will thus span over multiple cycles.
d1 * slowcat(
s('bd*2 sn'), s("jvbass*3"),
s("drum*2"), s("ht mt")
)
fastcat
: make a single pattern out of multiple patterns but mashing all of them into a single cycle. Be careful with long / rich patterns :)
d1 * fastcat(
s('bd*2 sn'), s("jvbass*3"),
s("drum*2"), s("ht mt")
)

append
: synonym offastcat
. 
timecat
: Likefastcat
except that you provide proportionate sizes of the patterns to each other for when they're concatenated into one cycle. The larger the value in the list, the larger relative size the pattern takes in the final loop. If all values are equal then this is equivalent tofastcat
.
d1 * timecat((1, s("bd*4")), (1, s("hh27*8"))))
randcat
: Pick patterns in a random order.
d1 * randcat(
s('bd*2 sn'), s("jvbass*3"),
s("drum*2"), s("ht mt")
)
struct
: Restructure the pattern according to a binary pattern (false values are dropped).
# add an example
stack
: Pile up patterns orstack
patterns. Useful to group some patterns together.
# add an example
Superposition and layering
jux
: a complex function. It takes your pattern, makes two versions of them, one playing on the left channel, the other on the right channel. It then applies a function but only on the righthand channel.
# On the right channel: reversed and filtered
d1 * s('bd jvbass bd sn').jux(lambda p : p.rev().hpf(500))
superimpose
: superpose a modified version of a pattern on the top of the original pattern. They are played at the same time, thus superimposed.
d1 * s('hh cp hh cp').superimpose(lambda p: p.fast(2).rev())
layer
: Layer up multiple functions on one pattern. For example, the following will play two versions of the pattern at the same time, one reversed and one at twice the speed.
d1 * s("arpy [~ arpy:4]").layer(rev, lambda p: p.fast(2)])
If you want to include the original version of the pattern in the layering, use the id
function:
d1 * s("arpy [~ arpy:4]").layer(id, rev, lambda p: p.fast(2)])
Pattern degradation
degrade
: randomly removes events from pattern, by 50% chance.
d1 * s('[bd(5,8), hh(7,8), sn(2,8)]').degrade()
degrade_by
: Simlar todegrade
but you can control the percentage of events that are removed withby
.
d1 * s('[bd(5,8), hh(7,8), sn(2,8)]').degrade_by(0.2)
undegrade
: Same asdegrade
, but random values represent percentage of events to keep, not remove, by 50% chance.
d1 * s('[bd(5,8), hh(7,8), sn(2,8)]').undegrade()
undegrade_by
: Similar todegrade
but you can control the percentage of events that are removed withby
.
d1 * s('[bd(5,8), hh(7,8), sn(2,8)]').undegrade_by(0.2)
Sometimes family
The sometimes
family of function can sometimes apply a function to a pattern... but only sometimes :) There is a large family of functions and helper functions to manipulate probabilities.
always
: will always apply the function, similar to not using the function and applying directly.
d1 * s('drum(5,8)').n('1 2 3 4').always(fast(2))
almostAlways
: will apply the function 90% of the time, at random.
d1 * s('drum(5,8)').n('1 2 3 4').almostAlways(fast(2))
often
: will apply the function 75% of the time, at random.
d1 * s('drum(5,8)').n('1 2 3 4').often(fast(2))
sometimes
: Applies a function to pattern, around 50% of the time, at random.
d1 * s('drum(5,8)').n('1 2 3 4').sometimes(fast(2))

sometimes_by
: Applies a function to pattern sometimes based on specifiedby
percentage, at random.by
is a number between 0 and 1, representing 0% to 100% chance of applying function. 
sometimes_pre
: Similar tosometimes
but applies a function to the pattern before filtering events 50% of the time, at random. 
rarely
: will apply the function 25% of the time, at random.
d1 * s('drum(5,8)').n('1 2 3 4').rarely(fast(2))
almostNever
: will apply the function 10% of the time, at random.
d1 * s('drum(5,8)').n('1 2 3 4').almostNever(fast(2))
never
: will apply the function 0% of the time, at random. The function will thus never be applied.
d1 * s('drum(5,8)').n('1 2 3 4').never(fast(2))
The every family and friends
every
: allows you to apply a function based on a condition. You need a function to determine when the function should be applied (e.g. a number n to apply the function every n cycles). You also need a transformation such asrev
(reverse a pattern) orfast
(make a pattern faster).
d1 * s('[bd(5,8), jvbass(3,8)]').every(3, lambda p: p.superimpose(fast 2))
somecycles
: Apply a function on certain cycles (e.g on cycle3
) ???
# add an example
somecycles_by
: Apply a function on certain cycles with a change factor ???
# add an example
Operators
The Haskell version of TidalCycles uses a lot of overloaded operators. Python is not really flexible in that regard. You can't really define new operators such as $
or +
but most of the base operators have been overloaded to denote a particular pattern transformation. They are used to denote a particular application of a pattern over another pattern.
+

*
/
//
**
>>
<<
Time manipulation
rev
: This function can be used to reverse a pattern. Very useful!
# Normal
d1 * s('bd hh sn hh')
# Reversed
d1 * s('bd hh sn hh').rev()
fast
:fast
is a function used to speed up a pattern.fast(2)
will play the pattern twice as fast.fast(0.5)
will play the pattern twice as slow. You can pattern the value as well.
d1 * s('bd hh sn hh').fast(2)
slow
:slow
is a function used to slow down a pattern. It is a mirror offast
.slow(2)
will play the pattern twice as slow,slow(0.5)
will play a pattern twice as fast.
d1 * s('bd hh sn hh').slow(2)
early
: Equivalent of Tidal's<~
operator. This function can shift an event earlier in time, nudging it a little bit before the moment where it was initially supposed to play.
d1 * s('[tabla drum] cp').early('0.2 0.1')
late
: Equivalent of Tidal's~>
operator. This function can shift an event later in time, nudging it a little bit after the moment where it was initially supposed to play.
d1 * s('[tabla drum] bd cp').late('0.2 0.1')

off
: Combination of thestack
function withearly
. Will play the same pattern twice, one version of it will be played slightly earlier. 
compress
: Squeeze pattern within the specified time span.
# add an example
fastgap
: Similar tofast
but maintains its cyclic alignment. For example,p.fastgap(2)
would squash the events in patternp
into the first half of each cycle (and the second halves would be empty). The factor should be at least 1.
# add an example
Conditional application
when
: Applies functionfunc
on each event of pattern ifboolean_pat
is true. You will have to feed a pattern of boolean values (1
or0
) using another function.
# add an example
when_cycle
: Applies functionfunc
to pattern only iftest_func
returnsTrue
on each cycle. Similar towhen
, but instead of working with a boolean pattern, this evaluates a boolean function with the cycle number and applies (or not) transformation on each cycle.
# add an example
Iteration over patterns
iter
: Divides a pattern into a given number of subdivisions, plays the subdivisions in order, but increments the starting subdivision each cycle. The pattern wraps to the first subdivision after the last subdivision is played.
d1 * s("bd hh sn cp").iter(4)
 reviter
: Same as iter
but in the other direction.
d1 * s("bd hh sn cp").reviter(4)
striate
 mask
 euclid
Signals and Generators
Signal functions are functions generating streams of values to apply to a pattern. They are very useful to create lowfrequency oscillators or continuously evolving stream of values. These functions should be manipulated to your liking using segment
and range
: scaling the stream of generated values, getting the desired granularity/precision of the stream).
Signal manipulation functions
range
: Rescales values to the range[min, max]
. Assumes pattern is numerical, containing unipolar values in the range[0, 1]
.rangex
: Rescales values to the range [min, max] following an exponential curve. Assumes pattern is numerical, containing unipolar values in the range[0, 1]
.segment
: Samples the pattern at a rate ofn
events per cycle. Useful for turning a continuous pattern into a discrete one.
sine().segment(8).range(4, 8)
Generators
sine2
: Bipolar sinusoïdal oscillator: negative and positive values.sine
: Unipolar sinusoïdal oscillator.cosine2
: Similar tosine2
but the phase is shifted (e.g. cosinus function).cosine
: Similar tosine
but the phase is shifted (e.g. cosinus function).saw2
: Bipolar sawtoothlike oscillator: negative and positive values.saw
: Unipolar sawtoothlike oscillator.isaw2
: Inverted Bipolar sawtoothlike function.isaw
: Inverted unipolar sawtoothlike function.tri2
: Bipolar triangular oscillator: negative and positive values.tri
: Unipolar triangular oscillator.square2
: Bipolar square wave oscillator: negative and positive values.square
: Unipolar square wave oscillator.rand
: Generate a continuous pattern of pseudorandom numbers between0
and1
.irand
: Generate a pattern of pseudorandom whole numbers between0
ton1
inclusive.
# generates a pattern of 8 events per cycle
# with values ranging from 0 to 15 inclusive.
irand(16).segment(8)
perlin
: 1D Perlin (smooth) noise, works likerand
but smoothly moves between random values each cycle.
perlin().segment(8)
Combinators

run

scan

choosewith
choose

choose_cycles

wchoose