1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
-- region Lesson 1: starting with effects
-- Tidal has lots of effects we can use to change the way things sound.
-- vowel is a filter which adds a vowel sound
-- try a, e, i, o and u
d1 $ n "0 1 0 [2 4] 2 4 1*2 3" # s "cpu"
d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "a"
d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "o"
-- We can use the mini notation to create sequences of effects too:
d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "a o e"
-- Tidal does its best to map patterns across to one another.
-- You can add a non-vowel letter to pause the vowel effect
d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "a p"
-- 'squiz' is a nice distortion effect
d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # squiz "4 1 0 3"
-- With '#' structure comes from the left - try swapping the parameters around
d1 $ squiz "4 1 0 3" # n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu"
-- Now there are only four sounds per cycle, because there's four in the leftmost
-- 'squiz' pattern
-- We'll learn more about how things in patterns get matched up later!
-- 'gain' changes the volume of different sounds
d1 $ sound "kick kick snare snare" # gain "1 0.7 0.6 0.5"
d1 $ sound "[hh*16, kick:8 snare:4 [~ kick:8] snare]" # gain "[1 1.2]*8"
-- speed can be used to pitch samples
-- (we can also use 'note' to do this, but we'll look at that later)
-- speed changes the speed of playback,
-- e.g. 2 = play the sample twice as fast - which moves the note up an octave
d1 $ sound "numbers:1 numbers:2 numbers:3 numbers:4" # speed "1 1.5 2 0.5"
-- Or we can take the pattern from the speed parameter
d1 $ speed "1*2 2*2 4*6" # sound "jungbass:6"
-- pan allows us to create stereo effects - 0 = left, 0.5 = middle, 1 = right
d1 $ sound "numbers:1 numbers:2 numbers:3 numbers:4" # pan "0 0.5 1"
-- shape adds distortion (but be careful - it also makes the sound much louder)
d1 $ sound "kurt:4 kurt:4"
d1 $ sound "kurt:4(3,8)" # shape "0 0.98" # gain "0.7"
-- endregion
-- region Lesson 2 : Time to look at Time
-- "Music is the Time of Numbers"
-- setcps - change global tempo
-- Let's run two patterns at once:
d1 $ n "0 2 [3 5] [4 7]" # sound "cpu"
d2 $ n "0(3,8) 8*8" # sound "cpu2"
# squiz 5
-- Changing the cps (cycles per second) changes everything
setcps 0.7
setcps 0.3
-- Time as an effexct (!)
-- You can also set cps as an effect:
d2 $ n "0(3,8) 8*8" # sound "cpu2"
# squiz 5
# cps 0.5
-- It's still global though - setting it on one pattern will
-- change it everywhere
-- However, you can pattern it:
d2 $ n "0(3,8) 8*8" # sound "cpu2"
# squiz 5
# cps "0.5 1"
-- You can really mess with time in this way!
d2 $ n "0 [~ 1] 2*2 3 4*3 5 ~ 7" # sound "cpu2"
# cps "<0.5 2> [1 0.75] <2 1>"
-- Reset things before moving on..
hush
setcps 0.6
-- 'fast' and 'slow' functions
-- You can speed up / slow down an individual
-- pattern (or part of one) with "fast" and "slow"
d1 $ slow 2 $ n "0 2 [3 5] [4 7]" # sound "cpu"
d1 $ fast 2 $ n "0 2 [3 5] [4 7]" # sound "cpu"
-- You can also pattern this speed factor:
d1 $ slow "0.5 1" $ n "0 2 [3 5] [4 7]" # sound "cpu"
d1 $ slow "0.5 <1 2>" $ n "0 2 [3 5] [4 7]" # sound "cpu"
-- When patterning time in this way, you're switching
-- between different versions of the pattern, running
-- at different speeds.
-- We've already learned enough to create patterns with a
-- lot of variety in them, by mixing together several simple
-- manipulations
d1 $ slow "0.5 <1 2>" $
n "{0 2 [3 5] [4 <7 6>], 0*2 3*3 0}" # sound "cpu"
# squiz "<8 1 2>"
-- Note that the 'speed' effect changes the rate of playback
-- for each sample, but doesn't change the overall speed of the
-- pattern
d1 $ slow "0.5 <1 2>" $
n "{0 2 [3 5] [4 <7 6>], 0*2 3*3 0}" # sound "cpu"
# squiz "<8 1 2>"
# speed 2
-- I find things always sound better if you speed them up a little.
-- Your experience may vary :)
setcps 0.7
-- endregion
-- region Lesson 3 Combining patterns with arithmetic, plus the ‘hurry’ function
-- Ok, so what happens when we specify a 'control' pattern (like e.g. n,
-- sound, speed, or squiz) more than once?
-- Lets start with the handy 'numbers' sounds:
d1 $ n "0 1 ~ 2" # sound "numbers"
-- lets put than 'n' again, but with a different number:
d1 $ n "0 1 ~ 2" # sound "numbers" # n "4"
-- So.. you can hear that we still have the rhythmic structure from
-- the left, but all the values have been replaced with the one on the
-- right. That's what `#` does!
-- lets make that right hand pattern more complicated:
d1 $ n "0 1 ~ 2" # sound "numbers" # n "4 5"
-- Now the 0 and 1 have been replaced with the 4, and the 2 has been
-- replace with the 5.
-- This is because tidal matches them up for you, based on where they
-- are in the cycle. The 0 and 1 start inside the first half, so are
-- replaced with '4'. The 2 starts inside the second half, so is
-- replace by '5'.
-- # is actually shorthand, for '|>'. There's a whole family of these:
-- |> is structure from the left, values from the right
-- <| is values from the left, structure from the right
-- |< is structure from the left, values from the left
-- >| is structure from the right, values from the right
-- |<| is values from the right, structure from both sides
-- |>| is values from the left, structure from both sides
-- < points to where the values come from, and | goes on the side where the
-- rhythmic structure comes from.
-- Everything from the left:
d1 $ n "0 1 2 3" # sound "numbers" |< n "4 5"
-- Everything from the right:
d1 $ n "0 1 2 3" # sound "numbers" >| n "4 5"
-- Rhythmic structure from left, values from the right:
d1 $ n "0 1 2 3" # sound "numbers" |> n "4 5"
-- Values from the left, rhythmic structure from right:
d1 $ n "0 1 2 3" # sound "numbers" <| n "4 5"
-- Values from the left, rhythmic structure from both sides:
d1 $ n "0 1 2 3" # sound "numbers" |<| n "4 5"
-- The above use of |<| sounds the same as |<, because the rhythmic
-- structures line up.
-- This changes
d1 $ n "0 1 2" # sound "numbers" |>| n "4 5"
-- Some gotchas!
-- Even though you are taking everything from one side, something
-- still has to match up on the other side..
-- So this makes no sound:
d1 $ n "~" # sound "numbers" >| n "4 5"
-- Only the '4' sounds here:
d1 $ n "0 ~" # sound "numbers" >| n "4 5"
-- Most of the time you'll be fine forgetting all this, and just using
-- |> , and its alias # .
-- However, there are other things you can do!
-- Instead of taking values from one side, you can add the values together, by
-- using '+' instead of '>' or '<'.
-- This:
d1 $ n "0 1 2 3" # sound "numbers" |+ n "4 5"
-- adds up to:
d1 $ n "4 5 7 8" # sound "numbers"
-- This:
d1 $ n "0 1 2 3" # sound "numbers" +| n "4 5"
-- adds up to:
d1 $ n "4 7" # sound "numbers"
-- This is because the rhythm comes from the left, from the "4 5", and
-- so we start from that. The start of 4 matches with 0, and the start
-- of 5 matches with 2, and adding them up, we end up with 4+0=4, and
-- 5+2 = 7.
-- This all gets complicated, especially when you work with patterns
-- with different numbers of steps..
d1 $ n "0 1 2 3" # sound "numbers" |+ n "4 5 6"
-- But don't worry too much. You just have to say what you want to
-- add together, let Tidal worry about working it out for you!
-- Ok that's enough numbers, lets put this into action with some
-- interesting patterns.
-- Here's one adding together 'n' patterns, using |+| to take
-- structure from both sides. On the right hand side, it uses the < >
-- mininotation syntax to pick a different subsequence per cycle.
-- The result is an interesting, longer form pattern:
d1 $ n "0 1 2 [3 5]" # sound "cpu"
|+| n "<[4 5 3 2] [5 4 3] [6 5]>"
# squiz 2
-- I just added a bit of squiz there to make it sound nice.
-- Here's a simpler example, cycling between three 12 note octaves, one per cycle:
d1 $ n "7 5 [2 7] 0" # sound "superpiano"
|+ n "<-12 0 12>"
-- It's actually possible to apply these to patterns of numbers
-- _before_ they become control patterns, like this:
d1 $ n ("7 5 [2 7] 0" |+ "<-12 0 12>") # sound "superpiano"
-- You have to use parenthesis to make sure the two patterns are added
-- together, before being passed to the 'n'.
-- To be clear, this is a pattern of numbers:
-- "7 5 [2 7] 0"
-- This is a control pattern, because 'n' turns numbers into synthesiser
-- control patterns:
-- n "7 5 [2 7] 0"
-- This all works for effects too:
d1 $ n "0(5,8) [4 1]" # sound "drum"
# squiz "0 2 5"
|+ squiz "<0 2 3>"
-- Or again, you can add the number patterns, rather than the control
-- patterns. This is the same:
d1 $ n "0(5,8) [4 1]" # sound "drum"
# squiz ("0 2 5" |+ "<0 2 3>")
-- See which you prefer to do!
-- 'saw' is a pattern that slowly moves from 0 to 1 over a cycle. Here
-- I'm slowing it down so it lasts 4 cycles, slowing increasing the
-- speed over that time:
d1 $ n "[0 4 2] [4 1] 3 [2 0] 3 [3 1] 4 4" # sound "cpu"
# squiz 3
# speed "1 [2 3] 3"
|+ speed (slow 4 saw)