update: study

live/chill/atm/board.tidal

+setcps 0.25
+
+d1
+$ every' 8 7 (fast 2)
+$ "k . k(<3 5>, 8)" # "kick:8"
+# lpf 2000
+# gain 0.7
+
+d2 $ "~ s" # "snare:2"
+# lpf 5000 # note (-8)
+# gain 0.7
+
+d3
+$ fast 2
+$ fast "<8!3 32> <16!3 [16 <8 [8 16]>]>"
+$ s "drum:8"
+# gain 0.9
+
+d4 $ s "h*3 h <h h*3> h*2" # "hh" # gain 0.8
+# pan (slow 16 $ sine)
+
+d4
+$ whenmod 32 16 (slow 2)
+$ swing 2
+$ note (scale "aeolian"
+"c3'major7" + "0 . 1 <2 0>"
+) # s "supersaw"
+# voice 0.1
+# gain 0.45
+
+d5
+$ note (
+  "0(12?,8)"
+) # s "superpiano"
+# velocity 0.35
+# pan 0.8
+# sustain 0.4

live/chill/atm/workroll.tidal

+setcps 0.5
+-- 2s / mesure
+-- MicroPomodoro = 5m = 5*60 = 20 * 15 = 300 secondes = 150 mesures
+-- Pomodoro = 25m = 25*60 = 100 * 15 = 1500 secondes = 750 mesures
+
+d1
+$ every' 2 1 (often (off 0.125 id))
+$ whenmod 750 375 (fast 2)
+$ whenmod 150 140 (# silence)
+$ whenmod 150 75  (fast 2)
+$ s "reverbkick" # lpf 400
+
+d2
+$ almostNever (fast 4)
+$ s "~ snare:11"
+
+d3
+$ whenmod 150 140 (# room 0.5) . (# dry "<0 0.5 1 2>")
+$ whenmod 150 130 (fast "8 . 2 4")
+$ whenmod 24 20 (fast 2)
+$ fast "<8 4 8 1>" $ s "drum:8"
+
+d4 -- Bass tendue/detendue
+$ whenmod 150 0 (off 0.125 (# crush 8))
+$ sometimesBy "<0.5 0> 0"  (chop "<4 2>")
+$ note (scale "aeolian" (
+  "0(3,<4 8>)" + "<0 2 0 5 0 4 0 5>"
+)
+- 24
+)
+# s "supersaw" # voice 0.1
+# sustain 0.5
+# gain 0.9
+
+d3 -- bass
+$ note ("<<0 3> <0 3> <0 -4> <0 -4>>" +
+"0 7 ~ 0 6 7 6 3")
+# s "bass3"
+# gain 0.8
+
+d6 $ s "birds/4" # n (irand 16)
+# speed (range 0.5 2 rand)
+# gain 0.7
+
+d9 -- Period end siren
+$ whenmod 150 130 (# gain 0.8)
+$ s "supersiren/16"
+# note (-12)
+# gain 0

live/chill/blue_mind.tidal

 setcps 0.4
 
 do
+  solo 1 -- Kick
+  solo 2 -- Snares
+  solo 3 -- Drums
+  solo 4 -- 
+  solo 5
+  solo 6
+  unsolo 7
+
+do
   d1 -- KICK TECHNOFICATION
     $ sometimesBy "0 0 0.1 0" (# silence) -- skip beat
-    $ s "k*4"
+    $ s "k*2"
     # s "jazz"
-    # gain 0.8
+    # gain 0.7
   d2
-    -- $ sometimes (fast 2)
-    -- $ whenmod 16 8 (sometimes (stut 2 0.7 (1/12)))
+    $ whenmod 16 8 (sometimes (stut 2 0.7 (1/12)))
     $ n "0(1,8,<1 .. 7>)"
     # s "snare:13"
     # gain 0.6
   d3
     -- $ rarely (fast 2)
-    -- $ sometimes (fast 2)
-    -- $ always (fast 2)
+    $ sometimes (fast 2)
+    $ always (fast 2)
     $ s "d*4"
     # s "drum:8"
-    # gain 0.9
-  d4 $ s "hh*4" # gain 0.6
+    # gain 0.8
+  d4 $ s "hh(6,16)" # gain 0.9 # n "<0!3 [0!3 1]>"
   -- Pianos
   -- Graves accords sustain
-  d5
+  d5 -- Basse
+    $ s "supersaw"
+    # note (scale "aeolian" (
+      "<c'maj e'maj [c'maj e'maj] [e'maj c'maj]>"
+      + "<<0!3 -1> 0 0 <2!3 1>>"
+    ) - 24
+    )
+    # voice 0.1
+    # gain 0.4
+  d7 -- Cloches
+    $ off 0.25 (|+ note "<12 0>")
     $ off 0.125 (|+ note 12)
     $ note (scale "aeolian" (
       "<c'maj e'maj>"
@@ -30,7 +48,7 @@ do
     ) - 24
     )
     # s "superfork"
-    # gain 0.7
+    # gain 0.6
   d6
     $ whenmod 64 32 (superimpose (-- Arps!
       whenmod 128 64 (swing 2)
@@ -49,16 +67,6 @@ do
     # s "supersaw"
     # velocity 0.3
     # gain 0
-  d7 -- Basse
-    $ s "supersaw"
-    # note (scale "aeolian" (
-      "<c'maj e'maj [c'maj e'maj] [e'maj c'maj]>"
-      + "<<0!3 -1> 0 0 <2!3 1>>"
-    ) - 24
-    )
-    # voice 0.1
-    # gain 0.4
-
 
 
 -- Setup: solennel, hip, calme

live/dnb/nass.tidal

@@ -12,13 +12,14 @@ setcps 0.65
 -- DNB
 d1
 $ fix (
-  (# s "[nass,cp]") .
+  -- nass
+  (# s "[nass,sn:1]") .
   (someCyclesBy 0.1 (# attack 0.5)) -- cut, presque scratch
 ) (s "t")
-$ fix (# s "[kick:8,kick:9]") (s "p")
+$ fix (# s "kick:8") (s "p")
 -- $ s "bd ~ s ~ ~ bd s <~ s>"
 $ s "p ~ t <~ t ~ ~> ~ p t <~ p>"
-# gain 0.9
+-- # gain 0.9
 
 
 d2 -- bass

live/dnb/vendredi_dnb.tidal

 -- Base: DNB Dansante!
-setcps 0.75
+setcps 0.6
+
 
 d1 -- Poum tchak
 $ whenmod 8 4 (someCycles (fast "1 2"))
@@ -10,28 +11,20 @@ $ fix (# s "[bskick,kicklinn]") (s "b")
 $ s "b? ~ s ~ ~ b s <~ <~ <~ s>>>"
 
 d3 -- drumroll
-$ rarely (off (1/16) id)
-$ sometimesBy 0.05 (# n 1)
-$ s "dr*8"
-# room (slow 16 $ sine * 0.3)
-# size 0.2
-# gain (slow 32 $ sine * 0.9 + 0.1)
-
-d5 $ s "brass:6" # note 0
-# gain 0.85
+$ fast "4 <8 16>" $ s "drum:2" # gain 0.9
 
 d6
 $ whenmod 32 24 ( -- final trompette!
-  superimpose (const $ s "~ ~ <b ~ b b?> ~"
-  # s "brass:6" # gain 0.95)
+  superimpose (const $ slow 2 $  s "~ ~ <b ~ b b?> ~"
+  # s "brass:6" # gain 0.6)
   )
 $ whenmod 8 4 (degradeBy 0.5)
 $ superimpose (|+ note 12)
 $ superimpose (|- note 12)
-$ s "brass:2"
+$ s "brass:2/2"
 # note "<0 0 0 <<12 5> 0>>"
+# gain 0.5
 # cut 1
-# gain 0.85
 
 d7 -- toys
 $ every' 16 15 ( -- petit coup
@@ -39,7 +32,12 @@ $ every' 16 15 ( -- petit coup
 $ every 16 ( -- intense!
   sometimes (superimpose (const $ s "~ ~ brass:10 ~")))
 $ s "~ brass:7/4 ~ brass:5/8"
-# gain 0.8
+# gain 0.45
+
+d4
+  $ note (scale "aeolian" "<0 5>(<3 5>,8)"
+  -24
+  ) #  s "supersaw" # voice 0.1 # gain 0.8
 
 d9 -- basse
 $ stut 4 0.75 0.125
@@ -48,8 +46,7 @@ $ (|+ note (scale "major" "7"))
 $ whenmod 8 4 (|+ note (scale "major" "5"))
 $ off 0.125 ((# room 0.2) . (# size 0.8))
 -- $ superimpose ((# s "bass3") . (|+ note 0))
-$ note "0"
-|- note 14
+$ note (-36)
 # gain 0.9
 # attack (0.5 + rand / 2)
 # s "bassWarsaw"

live/dnb/video_live.tidal

+do
+  solo 1
+  solo 2
+  solo 4
+  solo 7 -- bass
+  s
+
+d1
+$ fast "1"
+$ s "jazz(<4!3 <2 [2 4]>>,8)"
+# gain 0.8
+
+
+d1 $ s "k(<3!3 4 5 4>,8)" # s "clubkick"
+# gain 0.8
+# lpf (slow 16 $ range 4000 20000 sine)
+
+d2
+$ hurry "<1 [1|2]>"
+$ s "~ <s!3 [s s ~]>"
+# s "snare:20"
+# gain 0.9
+
+d3
+$ whenmod 32 4 (# gain 0.9)
+$ whenmod 32 0 (# gain 0)
+$ fast "4 [8 <1?*16 16>]" $ s "dr"
+# gain 0.9
+
+d5
+$ whenmod 32 31 (# gain "0!3 0.7")
+$ whenmod 32 16 (# gain "0")
+$ whenmod 16 8 rev
+$ bite 8
+-- "0 <1 2> <2 1> 3*2"
+"<0 <1 2> <2 1>>(<8!7 5>,8)"
+$ note (scale "aeolian" (run 8)
+- 24)
+# s "supersaw" # voice 0.1
+# gain 0.75
+
+d6 -- Piano second TODO REWORK
+-- $ every 4 (# gain 1)
+$ (0.5 ~>)
+$ stut' 2 0.25 (|+ note "~ . <0 +7>")
+$ sometimesBy "0 0.5" (ply 2) . (arp "~ . up down")
+$ note ("<c5'maj c5'min>*2")
+# s "superpiano"
+# velocity "0.5 0.4"
+# sustain 0.8
+# gain 0
+
+d8 -- Cymbales
+$ juxBy 0.5 rev
+$ fast 2
+$ s "h ~ h h ~ ~ ~" # s "hh"
+# gain 0.6
+
+
+d7 -- Basse lead :)
+  $ whenmod 16 20 (|> note "-12")
+  $ whenmod 20 10 (degrade . (stut 2 0.9 0.125))
+  $ note (scale "aeolian" "<0 5>(<3 5 8>,8)"
+  - (slow 8 $ "<24 12>")
+  ) #  s "supersaw" # voice 0.1
+  # gain (slow 16 $ range 0.5 0.7 saw)
+
+d4
+  $ note (scale "aeolian" "<0 5>(<3 5>,8)"
+  - 36
+  ) #  s "superfork" # accelerate 0.1
+  # gain 1
+
+-- outru
+
+do
+  solo 1
+  solo 2
+  solo 4
+  solo 7 -- bass
+  s
+
+d1
+$ fast "1"
+$ s "jazz(<4!3 <2 [2 4]>>,8)"
+# gain 0.8
+
+
+d1
+$ slow 2
+$ s "k(<3!3 4 5 4>,8)" # s "clubkick"
+# gain 0.6
+# lpf (slow 16 $ range 4000 20000 sine)
+
+d2
+$ hurry "<1 [1|2]>"
+$ s "~ <s!3 [s s ~]>"
+# s "snare:20"
+# gain 0.9
+
+d3
+$ whenmod 32 4 (# gain 0.9)
+$ whenmod 32 0 (# gain 0)
+$ fast "4 [8 <1?*16 16>]" $ s "dr"
+# gain 0.9
+
+d5
+$ whenmod 32 31 (# gain "0!3 0.7")
+$ whenmod 32 16 (# gain "0")
+$ whenmod 16 8 rev
+$ bite 8
+-- "0 <1 2> <2 1> 3*2"
+"<0 <1 2> <2 1>>(<8!7 5>,8)"
+$ note (scale "aeolian" (run 8)
+- 24)
+# s "supersaw" # voice 0.1
+# gain 0.75
+
+d6 -- Piano second TODO REWORK
+-- $ every 4 (# gain 1)
+$ (0.5 ~>)
+$ stut' 2 0.25 (|+ note "~ . <0 +7>")
+$ sometimesBy "0 0.5" (ply 2) . (arp "~ . up down")
+$ note ("<c5'maj c5'min>*2")
+# s "superpiano"
+# velocity "0.5 0.4"
+# sustain 0.8
+# gain 0
+
+d8 -- Cymbales
+$ juxBy 0.5 rev
+$ fast 2
+$ s "h ~ h h ~ ~ ~" # s "hh"
+# gain 0.6
+
+
+d7 -- Basse lead :)
+  $ whenmod 16 20 (|> note "-12")
+  $ whenmod 20 10 (degrade . (stut 2 0.9 0.125))
+  $ note (scale "aeolian" "<0 5>(<3 5 8>,8)"
+  - (slow 8 $ "<24 12>")
+  ) #  s "supersaw" # voice 0.1
+  # gain (slow 16 $ range 0.5 0.7 saw)
+
+d4
+  $ note (scale "aeolian" "<0 5>(<3 5>,8)"
+  - 36
+  ) #  s "superfork" # accelerate 0.1
+  # gain 1

live/fusion/you_may.tidal

@@ -3,21 +3,20 @@
 do
   solo 1
   solo 2
-  unsolo 3
-  unsolo 4
-  unsolo 5
-  unsolo 6
+  solo 3
+  solo 4
+  solo 5
+  solo 6
   solo 7
   solo 8
 
 
-
 do
   let cLaMin = "[4, 7, 12, 14]"
   let cReMin = "[2, 4, 8, 11]" -- le fameux sol dièse !
   let cMiMaj = "[2, 5, 7, 10]"
-  setcps 0.45
-  d1
+  setcps 0.45 -- rythme
+  d1 -- Kick grosse caisse
     $ jux rev
     $ whenmod 8 6 (fast 2)
     $ fast 2

live/techno/exutoire.tidal

+--T0:  Hip-hop chill exutoire
+
+do
+  d1 $ s "<k!3 [~ k]> . <~ k?>" # "reverbkick" # release 0.3 # gain 0.8
+  d2 $ hurry 0.5 $ degradeBy "<0 0 0.5>" $ s "~ s*<1 3 6>" # "sn:1" # gain 0.8 # hpf 500
+  d3 $ fast ("<4!3 [<4 12> 12]>") $ s "dr" # gain 0.5
+  d4
+    $ chop 2
+    $ note (scale "hexAeolian" "0 0*2 ~ <4!3 6> . <2 5 2 4>"
+    - 21
+    ) # s "supersaw" # voice 0.1
+    # gain 0.7
+
+  d5 $ silence
+    $ fast "1 . 1 <1!8 2!4 3!4>"
+    $ note (scale "hexAeolian" "0*2 ~ ~. <-1 2>"
+    + "<c4'maj7 c4'maj9>" -- progression accords
+    + (slow 8 $ "<12 0>") -- variations octave
+    ) # s "superpiano"
+    # velocity "0.5 0.4 ~ ~ . 0.5"
+    # sustain 1
+    # gain 0.6
+
+-- T1: Raté ! techno
+
+do
+  let bars4 = 128
+  let bars2 = 64
+  let bars = 32
+  let b2Mid = 48
+  let bMid = 16
+  let gKick = 0.8
+  d1 -- KICK! Sait se faire attendre
+    $ whenmod bars (bMid + 1) (# gain 0)
+    $ whenmod bars bMid       (# gain ("1 0!3" * gKick))
+    $ s "k k <<k [k|~k]> [k|~k]> <k k*2>" # "clubkick"
+    # gain 0.75
+    # lpf 1500
+    # pan (slow 8 $ range 0.5 0.4 sine)
+    # gain 0.8
+  d2 -- Snares ternaires hurried, finissant en rush carré
+    $ juxBy 0.6 rev
+    $ whenmod bars (bars + 999) (const
+      $ degradeBy (slow 2 $ "<0.5 0.25 0.125 0>") -- avance masqué
+      $ fast "<4 8 16 [8 16 24 32]>" -- snare rush classique
+      $ s "sn:1" # gain 0.8 # hpf 500
+    )
+    $ every' bars 0 (# gain 0)
+    $ hurry "0.5 [1|2]" $ degradeBy "<0 0 0.5>"
+    $ s "~ s*<1 3 6>"
+    # "sn:1"
+    # gain 0.8
+    # hpf 500
+    # pan 0.3
+  d3 -- Drumroll ternaire
+    $ fast ("<4!3 [<4 12> 12]>") $ s "dr"
+    # gain (slow 32 $ range 0.7 0.9 sine)
+  d4
+    $ whenmod bars2 b2Mid (chop 2)
+    $ note (scale "hexAeolian"
+    (
+      whenmod bars4 bars2 (0 -)
+      "0 0*2 ~ <4!3 6> . <2 5 2 4>"
+    |+| "<[0|2] [0 <0 2> 0] 0 [12|0]>")
+    - 24
+    ) # s "supersaw" # voice 0.1
+    # gain (slow 64 $ range 0.4 0.6 saw)
+    # pan 0.4
+  d8 -- Claps au pont
+    $ whenmod bars (bMid + 4) (# gain (slow (bMid - 4) $ range 0.5 1 saw))
+    $ s "~ c*<1 2>" # s "cp" # gain 0
+    # pan (range 0.25 0.75 rand)
+  d9 -- Choeurs nappes secondaires
+    $ whenmod bars4 bars2 (# gain 0.5)
+    $ superimpose ((mask "t f!8")
+    . (# sustain 2)
+    . (|- note (slow 4 $ "<12 15 19 10>")))
+    $ note (scale "hexAeolian"
+    (
+      "[0 0*2 ~ <4!3 6> . <2>]" + 7
+    |+| "<[0|2] [0 <0 2> 0] 0 [-12|0]>")
+    ) # s "moogBass"
+    # gain 0
+    # pan 0.8
+
+  d5 $ silence
+    $ fast "1 . 1 <1!8 2!4 3!4>"
+    $ note (scale "hexAeolian" "0*2 ~ ~. <-1 2>"
+    + "<c4'maj7 c4'maj9>" -- progression accords
+    + (slow 8 $ "<12 0>") -- variations octave
+    ) # s "superpiano"
+    # velocity "0.5 0.4 ~ ~ . 0.5"
+    # sustain 1
+    # gain 0.6

study/club/14april.tidal

@@ -7,7 +7,7 @@ do
       leftHand =  "[0 9 12 16] [4 12 16 19]   . [5 12 17 19] [2 12 17 16]"
       cutPreEnd = "1!4 1 <1!7 0> <1!3 0> 0"
       cutPostBegin = "[0 <1!3 0>] 1!7"
-  d1 -- Piano, with cutting progression
+  d6 -- Piano, with cutting progression
      $ slow bars
      $ degradeBy (slowcat [
        "1",
@@ -23,19 +23,24 @@ do
       n (leftHand + key)
       ]
      # "superpiano"
-     # velocity 0.35
+     # velocity 0.5
      # octave "3"
      # sustain "[2 0.7]*4"
-  d2  -- Beat slowly varying
-    $ slow (bars / (slow 16 $ "<1 2>"))
-    $ s "d(<[5 4] [3 8] 5 [4 16]>,8)"
-    # s "jazz"
-    # lpf (slow 16 $ range 500 15000 sine)
+  d1  -- Beat slowly varying
+    $ s "k(<3!3 5>,8,<0!4 3!3 0>)"
+    # s "kick:5"
+    # hpf (slow 16 $ range 50 150 sine)
+    # gain 0.6
+  d2
+    $ whenmod 8 6 (hurry 2)
+    $ whenmod 8 4 (often (stut 4 0.8 (1/16)))
+    $ s "~ . <s!3 s*2> ~"
+    # "snare:20"
     # gain 0.8
   d3 -- Drumroll
-    $ fast "16 <2!3 8> <4!3 8> <1!3 <4, 8>>"
+    $ fast "<<4!3 <16 32>> [16 <16 8>]>"
     $ s "drum:2"
-    # gain (slow 8 $ range 0.65 0.8 sine)
+    # gain (slow 8 $ range 0.8 1 sine)
   d4 -- Bass
     $ slow bars
     $ rarely rev
@@ -45,9 +50,9 @@ do
     $ note (leftHand + key)
     |- note 36
     # s "bassWarsaw"
-    # gain 0.7
+    # gain 0.9
   d5 -- Choir
-    $ whenmod 4 2 (superimpose (|+ note 12) . (|- gain 0.1))
+    $ whenmod 4 2 (|+ note 12)
     $ slow (bars * 2)
     $ bite 4 "0"
     $ note (leftHand + key)

study/club/course.md

+# Program
+
+- [x] Week 1
+- [ ] Week 2 : L3
+- [ ] Week 3
+- [ ] Week 4

study/club/melodic.tidal

+--TODO: Explore https://club.tidalcycles.org/t/melodic-examples-with-tidal/490/7
+
+d1 $ stut' 3 (1/12) (|+ note "<5 3 0 7>") $ s "superpiano"

study/club/w1.tidal

+-- REVISION TASKS
+
+-- Copy each of the following patterns in turn, and edit them so that they
+-- are shorter, using the "<>", "!", "[]" and/or "." introduced above.
+
+d1 $ sound "kick snare snare"
+d1 $ sound "kick snare!2"
+
+d1 $ sound "kick [snare snare]"
+d1 $ sound "kick snare*2"
+
+d1 $ sound "kick snare kick snare kick snare"
+d1 $ sound "[kick snare]*3"
+
+d1 $ n "0 [1 2 3]/3" # sound "cpu2"
+d1 $ n "0 {1 2 3}" # sound "cpu2"
+
+d1 $ n "[0 0 2] [4 5 6 7] [4 1] [0 3 0 3]" # sound "cpu2"
+-- TODO: Final exercises
+
+d1 $ sound "kick snare kick snare kick snare clap"
+
+d1 $ sound "[kick snare kick snare kick snare] clap"
+d1 $ sound "[kick snare]*3 clap"
+
+d1 $ sound "bd sd sd sd bd [sd sd sd]"
+
+
+-- Lesson 5
+d1 $ sound "clap(3,5,2)"

study/club/w2.tidal

+-- 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)

study/club/w3.tidal

+-- region Lesson 1: exploring the ‘every’ function, including tackling the meaning of ‘$’
+-- every
+
+-- 'every' is one of a family of Tidal functions, that takes another
+-- function as one of its inputs.
+
+-- Let's say we had a simple pattern like this:
+d1 $ sound "bd sd ~ cp"
+
+-- ... and we wanted to speed it up like this:
+d1 $ fast 2 $ sound "bd sd ~ cp"
+
+-- ... but only one cycle out of three.
+
+-- Here's how we'd use 'every' to do that:
+d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"
+
+-- You can read this as "every 3rd cycle, make 'sound "bd sd ~ cp"',
+-- go faster by a factor of two."
+
+-- We'll take this apart to work out why we sometimes use (), and
+-- sometimes '$' later. First, lets look at more, practical examples
+-- of using 'every'.
+
+-- We can use every with any function that takes single pattern as
+-- input (and returns a transformed version as output). For example,
+-- we can use 'hurry' instead of fast:
+d1 $ every 3 (hurry 2) $ sound "bd sd [~ bd] [cp bd*2]"
+
+-- Or use 'rev':
+d1 $ every 3 (rev) $ sound "bd sd [~ bd] [cp bd*2]"
+
+-- Because 'rev' is a single word, we don't actually need to put it in
+-- parenthesis:
+d1 $ every 3 rev $ sound "bd sd [~ bd] [cp bd*2]"
+
+-- Here's a trick with using effects as functions..
+-- Lets look at this:
+d1 $ sound "bd sd [~ bd] [cp bd*2]"
+   # squiz "5"
+
+-- We can treat the '# speed 5' bit as a function. If you think about
+-- it, it does something to a pattern, just like 'fast 2' does.
+
+-- So.. does this work?
+d1 $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]"
+
+-- Yes it does!
+
+-- You can also add more than one 'every' manipulation, giving them
+-- different periods for their first input, to create longer form
+-- variety:
+d1 $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]"
+
+d1 $ every 2 (hurry 2) $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]"
+
+-- keep going..
+d1 $ every 4 rev $ every 2 (hurry 2) $ every 3 (# squiz 5)
+   $ sound "bd sd [~ bd] [cp bd*2]"
+
+-- In Tidal, the pattern that a function is manipulating is generally
+-- its final input, which makes it easy to 'chain together' functions
+-- like this.
+
+-- Ok as promised, lets go back to our original, simple example:
+d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"
+
+-- Lets go through the three 'inputs' (also sometimes called
+-- 'parameters' or 'arguments') for every.
+
+-- [a] 3 - how often a function is applied
+-- [b] fast 2 - the function that is applied
+-- [c] sound "bd sd ~ cp" - the pattern that it's applied to.
+
+-- Looking again at this pattern, you can see that the inputs are
+-- given in three different ways:
+d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"
+
+-- '3' is just on its own. It's a single number so tidal has no
+-- problem knowing it's a single input.
+
+-- 'fast 2' is in parenthesis '(fast 2)'. Then the word 'fast' and
+-- number '2' are grouped together into a function, _before_ being
+-- passed to 'every' as its second input.
+
+-- 'sound "bd sd ~ cp"' has $ in front. We *could* have done this
+-- instead:
+d1 $ every 3 (fast 2) (sound "bd sd ~ cp")
+
+-- That works fine, but '$' does the same kind of job. It passes
+-- what's on its left, to the function on its right, as a single
+-- parameter. '$' has really low priority, which means everything on
+-- its right is worked out first before being passed to the left.
+d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"
+
+-- This saves you from having to match up ( and ) around a function's
+-- final input. It doesn't work with anything other than the final
+-- input, so unfortunately this _doesn't_ work
+
+d1 $ every 3 $ fast 2 $ sound "bd sd ~ cp"
+
+-- The above would work out 'fast 2 $ sound "bd sd ~ cp"' first, and
+-- would then try to pass that to 'every' as its second parameter,
+-- which doesn't make sense to tidal, so it returns an error.
+
+-- Note that when Tidal makes an error, if there was already a
+-- pattern running, it will keep that going. If you're live coding
+-- in front of an audience, you probably don't want an error to
+-- result in silence!
+
+-- endregion
+
+
+-- region Lesson 2: cut vs legato
+
+d1 $ jux rev $ speed "<1 0.5 0.75>(<3 5>,8)" # sound "bev" # cut 1
+  # room 0.4 # sz 0.9 # gain 1.3
+
+d2 $ jux rev $ sound "sax(3,8)" # legato 1 # n 3
+  # note "<[9 7] 5 [9 12]>" # djf 0.7 # sz 0.4 # room 0.4
+
+-- endregion
+
+
+-- region Lesson 3: slice and splice to for perfect spice
+setcps 0.6
+
+-- Hear it straight
+d1 $ splice 8 "0 1 2 3 4 5 6 7" $ sound "break:4"
+
+-- Now with a more messed-up pattern
+d1 $ splice 8 "6 1 [2 3] ~ 4 1 6*2 7" $ sound "break:4"
+
+-- Try changing the cps to hear it at different speeds
+
+-- Try manipulating the pattern of slices
+d1 $ splice 8 (fast "1 [0.5 0.75]" "6 1 [2 3] ~ 4 1 6*2 7")
+   $ sound "break:4"
+
+-- Now try all the above with 'slice' instead of 'splice'.
+-- Slice _doesn't_ do the pitching up/down thing to splice the
+-- sound to the step.
+
+-- Here I put six slices from a loop originally in 4/4, to create
+-- a 3/4 waltz
+d1 $ splice 8 ("0 1 2 3 4 5") $ sound "break:4" # gain 1.1
+d2 $ sound "kick snare*2 clap:4" # speed 2
+
+-- endregion
+
+-- region Lesson 4: chop and striate
+
+-- Let's take a nice break:
+once $ sound "break:8"
+
+-- We can use 'begin' and 'end' to only play part of the sound, in this
+-- case the final quarter of it:
+d1 $ sound "break:8*4" # begin 0.75 # end 1
+
+-- We can also use 'unit "c"' to change the behaviour of 'speed' so it
+-- changes the playback speed to match the cps
+d1 $ sound "break:8" # speed 1 # unit "c" # begin 0.75 # end 1
+
+-- Lets play four of those to fill the cycle
+d1 $ sound "break:8*4" # speed 1 # unit "c" # begin 0.75 # end 1
+
+-- Then play with the cps to hear it change, fitting the cps perfectly
+setcps 0.8
+
+-- Normally, I wouldn't use 'unit', 'begin' and 'end' by hand. Instead
+-- I'd use splice / slice from the previous lesson, or 'chop' to cut
+-- a sound into bits, and set the length of the loop in cycles with
+-- 'loopAt'
+d1 $ loopAt 2 $ chop 4 $ sound "break:8"
+
+-- The above sounds pretty continuous, but it is chopped into four parts.
+-- We can hear that by reversing the chopped up parts:
+d1 $ loopAt 2 $ rev $ chop 4 $ sound "break:8"
+
+-- If we slow the pattern we can hear each part separately:
+d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8"
+
+-- Here's a different sample:
+d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:9"
+
+-- Now what happens if we put both breaks in the sequence?
+d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8 break:9"
+
+-- With 'chop', it will play all the parts of break:8, followed by
+-- all the parts of 'break:9'.
+
+-- If we swap 'chop' for its friend 'striate', then parts from the
+-- two breaks are instead interlaced:
+d1 $ slow 2 $ loopAt 2 $ striate 4 $ sound "break:8 break:9"
+
+-- Play with that striate value for fun:
+d1 $ slow 2 $ loopAt 2 $ striate 32 $ sound "break:8 break:9"
+
+-- If you use the *same* loop multiple times with striate, it kind
+-- of stretches it:
+d1 $ slow 4 $ loopAt 1 $ striate 4 $ sound "break:1*4"
+
+-- Here's what that normally sounds like:
+once $ sound "break:1"
+
+-- 'bev' is an even longer sample..
+d1 $ loopAt 16 $ striate 32 $ sound "bev"
+
+d1 $ slow 4 $ jux rev $ loopAt 16 $ striate 128 $ sound "bev*4"
+
+-- Club: striate fun by @vin
+d2
+  $ every (irand 3) (degradeBy rand)
+  $ slow ((irand 4)+1)
+  $ loopAt ((irand 5) +1)
+  $ striate (irand 64)
+  -- $ slice 16 "0 1 5 4 8 6 1 0"
+  $ s "break:10"
+    # room 0.5
+    # cut 1
+    # att rand
+    # hold rand
+    # rel rand
+
+-- endregion
+
+-- TODO:
+
+-- HIHATS! ho hc
+-- (Cut though)
+
+-- Speed with unit 'c' to make things fit, whatever the cps

study/slicing.tidal

+d1
+$ s "jazz" # gain 0.8
+
+d2
+$ every 4 (linger (1 / choose[16,8]))
+$ every 3 (choose[1/4, 15/16, 1/2, 1/8, 3/4] <~)
+$ loopAt 2
+$ chop 32
+$ s "break:3"
+# gain 0.7
+
+d3 $ s "~ snare:24" # gain 0.7