Lucy's Favourite Functions (aka Tidal the Heavy Lifting way)

Hi all

In the live stream I said I'd post some info about my favourite functions and effects and how I approach live performances. For now I'm not going to do too much explanation since @yaxu will be covering everything in his videos, but if you want to find out more you can check out the Tidal documentation. I've divided these into a few rough sections based on what I use them for.


  • fast/slow (if you watch any of my videos you'll probably see me using density sometimes, which is the same as fast - it used to be called that and I can't quite break the habit of using it!)
  • jux - applies a transformation in one speaker only, creating neat stereo effects
  • iter - starts the pattern on a different foot each cycle
  • rev - plays the pattern in reverse - jux (rev) is a really easy way to create variety
  • {} - technically part of the mininotation but I use {} and overlapping patterns A LOT
  • range (sine, tri and saw) - continuous patterns are a really handy way of automating values
  • every - I use every a lot to pattern changes and to create structure (using a lot of overlapping patterns can get a bit muddy sometimes, so patterning things every 4 or every 8 helps add clarity)


  • loopAt - is a good way to manipulate samples (particularly long ones) - Tidal will change the speed of the sample playback to match the number of cycles you specify - e.g. loopAt 4 will stretch or squash a sample to repeat every 4 cycles. Good for happy hardcore and also noise/drone (v versatile function)
  • chop - chops the sample into bits
  • striate - chops the samples into bits and rearranges them


  • shape - waveshape distortion. I use this a lot on drums.
  • pan - pans the sound left and right
  • lpf/hpf - low pass/high pass filter
  • speed - always fun to manipulate the speed of samples (try using negative numbers to play stuff backwards)
  • vowel - applies a vowel filter


  • randslice - chops the samples into bits and plays back a random bit each cycle. Good for getting a long sample and using it like a short one (try it with pebbles for a kindof hi hat sound)
  • rand - generates a random number between 0 and 1
  • irand - generates a random integer between 0 and the number specified
  • sometimes - randomly applies the transformation. I can't remember the % chance but think it's 50%? You can use sometimesBy to dictate how often something might happen e.g. sometimesBy 0.2 (slow 2) will slow the pattern down 20% of the time
  • degradeBy - removes elements of the pattern at a rate of chance you dictate (e.g. degradeBy 0.1 has a 10% chance of removing an element). Good for weird fadeouts. I probably overuse it to be honest.


  • hurry - hurry is a combination of fast and speed so e.g. hurry 2 will play a pattern back twice as fast while also doubling the playback speed of each sample. I'll typically pattern hurry to occur only sometimes - e.g. sometimes (hurry 2) or every 4(hurry "0.5 2")

Phew, that's a bit long! Feel free to give me a shout with any questions. In a later post I'll talk about how I prepare for a live performance and some other performance techniques and tools I find helpful :slight_smile:


Nice one Lucy! We haven't covered most of this yet, but will go through all these classics in the next weeks. Just in case anyone's panicking!


Hi Lucy, first of all thank you for this. I've just printed it out to keep handy as I explore. I would love it if you expanded a bit on how you use {}, as your description of overlapping patterns sounds right up my alley, but I think I need to see an example of how that is applied.
Thanks again,


Hey @flaminggarlic no problem, hope you find it helpful.

So I really like to overlap patterns of varying length, and {} is a great way to break out of the cycle while still keeping everything in a tight rhythm (there are lots of other ways to do this too, which I'm sure we will meet later).

So as an example:

d1 $ n "{1 ~ 1 ~, ~ 2 ~, ~ ~ 3 3 3}" # sound "cpu"

This creates three patterns of different length, the 1 pattern has four steps, the 2 pattern has three steps, and the 3 pattern has five steps.

However, because we are using the curly braces the pulse for each pattern will be the same. In this case the 1 pattern of four steps is first, and so this determines the pulse (four beats per cycle).

So we end up with some overlap, something like this:


This is a simple example, but you can already see how it creates variation over time, with a kind of 'rotating' sound, but with everything still locked into the grid to keep it anchored.

I really recommend playing about with {} in this way to create these kind of patterns. This is really a key technique for me, as once you have something set up just a tiny tweak (for example adding in an extra event or two) can really change the character of a pattern.

Here I add an extra rest in the 3 pattern:
d1 $ n "{1 ~ 1 ~, ~ 2 ~, ~ ~ 3 3 ~ 3}" # sound "cpu"

And you get something with a lot more regular feel: