foret noire to riddim du dim

backlog.md

@@ -2,23 +2,41 @@
 ## Worksheet
 - Jazz noise: basis for jazzy drums / hip instru?
 
+## Lessons
+
+- Reread building up
+- Poetry
+- Weave / Snowball
+- W7 / W8
+- Melodies from forum
+
 ## Prod
+
+<!-- region TODO: Record! -->
+- [DNB] Sensation octobre Nass guitar
+
+<!-- endregion -->
 - Crapeau HipPo: Clav sur rythme hip-hop manuel
 - Break britafuninnique: boucle hip hop breatbeat piano attend un lead
 - Marche vertige: vertige vibration attend drum militaire
 
+- Wake the Funk: WIP techno funk résolue + hats
+
 - Morning flowers: breakbeat bassline funky
 
 - [Hardcore] Noise in the wires
+- [Transe] Tentative (Didgeri) Doo
 
-- Le naufrage! Funkpiano 110BPM
 
+- Le naufrage! Funkpiano 110BPM
 
+- Vertige expérientiel : Techno progressive+ résolue bass laggy+ forks
 - Cuba space program: Techno-clave + vibraphone, bonne montée attends drop!
 
 
 
 ## Copycat
+- 44 More
 - Bad guy: getting there!
 
 ## Remix

copycat/44.tidal

+do
+-- resetCycles
+setcps (130/60/4)
+d1
+  $ superimpose ((# "808bd:1") . (# cut 11)
+  . (|* gain 0.8)
+  . (# lpf 200)
+  )
+  $ cat [ -- Beat pattern
+  "k ~ ~ k ~ ~ k ~", "~ k k ~ k <~ ~ ~ k> <~ k> k"
+  ]
+  # "808bd"
+  -- # gain 0.9
+  -- # cut 1
+  -- # legato 0.5
+d9 $ "arpy/2" # gain 0.6
+d2 $ "~ cp" # lpf 2000 # gain 0.9
+d3
+  $ "dr*<8!3 [16 8!7]>"
+  # "drum:8"
+  # room 0.2
+  # size 0.2
+  # dry 2
+  # legato 0.5
+  # gain 0.5
+
+8 8 [16 8 . 8]
+
+once $ "[kick:3,reverbkick]" # gain 0.6 # lpf 1000 # legato 0.2
+#
+
+once $ note (arp "up" "c5'sevenSus4'5")
+  # "supersquare" # gain 0.8 # legato 8 # release 4

copycat/bad_guy.tidal

@@ -183,14 +183,13 @@ d4 -- Brass voice
   # legato "<0.75!7 1>"
   # room 0.2
   # gain 0.4
-
 d6 -- synth Chorus
   $ note (cat [
-    -- "","","","","","","","", -- Intro
-    -- "","","","","","","","", -- White shirt
-    -- "","","","","","","","", -- Bruises
-    -- "","","","","","","","", -- So you're a tough guy
-    -- "","", -- BAD GUY
+    "","","","","","","","", -- Intro
+    "","","","","","","","", -- White shirt
+    "","","","","","","","", -- Bruises
+    "","","","","","","","", -- So you're a tough guy
+    "","", -- BAD GUY
     "g d ~ g . df d df bf",
     "g d ~ g . df d df bf",
     "g d ~ g . df d df bf",

live/chill/dub/riddim_du_dim.tidal

+-- Dub du dim: A retravailler, cuivres/voices?
+
+do
+-- resetCycles
+setcps (120/60/4)
+let melody = "0 <0 <2 -2>>"
+d1 --Kick : un low et un high pour donner du relief
+  $ whenmod 32 16 (superimpose (
+    (|> "rave:6")
+    . (# cut 11)
+    . (# begin 0.75)
+    . (# gain 0.8)
+  ))
+  -- $ "k" -- Intro
+  $ "k <k!4 k?!4> k k*<1!3 <2 4>>"  -- RUN!
+  -- $ "k . k(3,8)"  -- Hip chaloupe
+  # "[jazz,kick:17]"
+  # gain 1
+  --Fx : kick étouffé, lpf Puis reverb
+  # lpf 1000
+  # room (0.8 * "<0!24 0.1 0.2 0.3 0.4 0.5!4>")
+  # dry 1 # sz 0.5
+d2 --Basse repetitive avec fort lpf
+  $ jux id
+  $ note ("c*<1 2> c*<1!3 2> c(<1!7 2 1!7 4 3!4 1!4>,8) [~ c]"
+  + melody
+  )
+  # "bass3:6"
+  # gain (slow 16 $ range 0.65 0.8 (saw + perlin/2))
+  # lpf (slow 32 $ range 2500 200 perlin)
+  # sz 0.5
+d3 -- clap si grave qu'on dirait un pas de géant distant
+  $ mask "<f!16 t!16>" $ "cp"
+  # note (-12)
+  # lpf 200
+  # room 0.2 # size 0.2 # dry 1
+  # gain (slow 16 $ range 0.8 1.6 saw)
+d8 -- Guitar second background coming loop
+  $ mask "<f!24 t!8>"
+  $ scramble "<1!2 [1 2]!2 8!4> . 4 1"
+  $ "fguitar:22" # gain 0.8 # cut 8
+  # gain (slow 8 $ range 0.2 0.5 saw)
+d4 -- Guitar lead contretemps!
+  $ note ("~ 0*<1!3 <2 1>> ~ 0*<1!7 2>"
+  + melody + "e'min'4"
+  )
+  # "bsguitar:3"
+  # gain (slow 16 $ range "<1!16 0.65!16>" "<0.5!16 0.65!16>" isaw)
+  # room (slow 16 $ range 0.3 0.7 saw)
+  # sz 0.4
+d7 -- Cuivres lancinants
+  $ mask "<t!8 f!56>"
+  $ swing 2
+  $ slow 2
+  $ arp (slow 4 "<down up>")
+  $ note (
+  "e2'min'2" |+ melody)
+  # "brass:4"
+  # legato 2
+  # room 0.8
+  # gain 0.5
+  # pan 0.6
+
+d9--- piano descente en conclusion`
+  $ mask "<f!60 t!4>"
+  $ "fepiano:7"
+  # cut 31
+  # gain 0.65
+
+
+  --- cuivres riff boucle courte
+
+-- Fguitar 20 chaleureuse breaks?
+
+-- region SANDBOX
+d6 -- Cuivre riff concluant!
+  -- $ mask "<f!14 t f f!12 t!4>"
+  -- $ whenmod 4 3 (slice 4 "0*<2 4>")
+  $ loopAt 2
+  $ "brass:24"
+  # gain (slow 24 $ range 0.2 0.4 saw)
+  # room 0.4
+  # cut 6
+  # pan 0.2
+
+
+-- # gain 0.5
+d4 -- Pluck melodie?
+  $ whenmod 4 2 (swing 4)
+  $ off "e" (|+| note "12 0(<1 3>,8)")
+  $ slow 4
+  $ arpeggiate
+  $ note ("c'7f10'8")
+  # "pluck:8" # gain 0.6
+
+
+
+once $ "fpiano:10" # cut 9 # gain 0.8
+
+once $ slice 4 (3) $ "rave:6"
+# gain 0.8
+# cut 21
+-- # note (-12)
+-- # room 0.8
+-- # dry 0.25
+
+-- TECHNO 2-sec :)
+do
+  d1 $ "jazz*4"
+  d2 $ "hh*8" # gain 0.8
+  d10 $ slice 8 (run 8) $ scramble 32 $ "bev" # gain 0.8 # cut 4
+
+--- synthé pont reprise mélodie
+--- toys space invaders :D

live/dnb/automne_electrique.tidal

+-- Sensation Octale
+-- DNB GUITAR
+-- Timeline | Intro > Montee > DropFull > PontGuitare > Montee > DropFullGuitar > Outro
+-- Measures |  0-7  > 8-31   > 32-63    > 64-71       > 72-95  > 16            > 16
+-- 1 Kick   |   ..     ..      XXXXXXX . X . . . . . . . . ...   XXXXXXXXXXXX X . ..X ..
+-- 2 drRoll | ...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+-- 3 Guitar |     .........................xxxxxxxxxxxxxxFFFFFFFxxxxxxxxxxxxxxxx...........
+-- 4 Bass   | bbbbbbbbbbbbbbbbbxxxxxxxxxxxxx.......................xxxxxxxxxxxxxxbbbbbbbbb
+do
+resetCycles
+setcps (160/4/60)
+d1 -- Poum tchak
+  $ mask "<f!8 f!23 [f t] t!32 f!8 f!23 [f t] t!32>" -- Orchestration
+  $ fix (
+    (# s "[sn:20,snare:8]")
+    . (# n (slow 4 $ "<2!3 20>"))
+    . (# note 4)
+    . (|* gain 1.1)
+  ) (s "s")
+  $ fix (# s "[bskick,jazz]") (s "b")
+  $ s "b? ~ s ~ ~ b s <~ <~ s>>"
+  # gain 1.1
+d2 -- drumroll
+  $ mask "<f!7 [f t] t!120>" -- Orchestration
+  $ whenmod 4 3 (jux (fast 2 . rev))
+  $ fast "4 <8 16>"
+  $ s "[drum:8,dr]"
+  # pan (slow 8 $ range 0.1 0.9 sine)
+  # gain (slow 16 $ range 0.65 0.95 sine)
+d3
+  $ mask "<f!8 f!24 f!32 t!8 t!24 t!32>" -- Orchestration
+  $ sometimesBy "<f!64 f!8 t!24 f!32>" (|* gain (slow 32 $ range 1 0.75 saw))
+  $ slice 8 (iter (slow 8 $ "[4|8]") $ run "<4!8 8!8>")
+  $ "fguitar"
+  # n ("<8!4 10!4 8 10 10 8>")
+  # cut 3
+  # gain 0.9
+  # room 0.3
+  # size 0.4
+  # dry 1
+  # pan 0.35
+d4 -- BASSLINE ELECTRIQUE
+  $ mask "<t!32 t!32 f!8 t!24 t!32>" -- Orchestration
+  $ sometimesBy "<f!8 t!24 f!32>" (|* gain (slow 24 $ range 1 1.2 saw))
+  $ slice 8 ("<0!3 4>" + run 8)
+  $ "fbass:10"
+  # pan 0.8
+  # cut 4
+  # crush "<16!28 12 10 9 8 5!32 5!32 5!12 8 9 10 12 16!16>"
+d10 -- Toys vent
+  $ mask "<f!7 [t f!2 <f t?>]!56>"
+  $ whenmod 16 12 (jux rev)
+  $ every 8 (# gain 0.9)
+  $ s "space:3"
+  # speed (range 0.15 0.3 perlin)
+  # gain (slow 16 $ range 0.25 0.45 saw)
+  # pan rand

live/fusion/cuba_space_program.tidal

@@ -3,29 +3,29 @@ solo 2
 
 -- TODO: Kick in at 8, current bass=kick
 -- Intro Bass in Kick in Bass cut/montee drop -- pont -- intro
--- 0     4       8        20             28      36      40/0
-
+-- 0     4       8        20             28       36      40/0
 
 do
-resetCycles
+-- resetCycles
 setcps 0.5
 d1
   $ mask "<f!4 t!16 f!8 t!8 f!4>" -- Orchestra/40
   $ "jazz*4"
-  # gain 0.65
+  # gain 0.95
 d2 -- Son clave cubain
   $ mask "<[t f!3] [t f!2] [t f] t t!16 [t f!3]!8 t!8 [t f!7]!4>" -- Orchestra/40
+  -- ^: FIXME Replace clave at drop with kick
   $ "c c ~ c ~ c c ~"
   # "808hc" # n "<0!8 3 3 0 0 0 0 3 3>"
   # room 0.1 # sz 0.3 # dry 1
-  # gain 0.8
+  # gain 0.5
 d3 -- Glitch clap dark
   $ mask ("<f!8 t!16 f!4 t!9 f!3>")
   $ whenmod 20 16 (# note "<0 -3 -7 -10>")
   $ "~ ~ ~ cp"
   # lpf 2000 # lpq 0.2
   # gain 0.9
-d4 -- Ritournelle 3/2 vibraphone
+d4 -- Ritournelle 3/2 vibraphone FIXME
   $ mask "<f!3 [t f]!2 [t!3 f] t!14 t!16 [t!3 f]!4>" -- Orchestra/40
   $ whenmod 40 36 (|* gain (slow 4 $ range 1 0.4 isaw))
   $ whenmod 8 6 (juxBy 0.5 (rev . (|* gain 0.4)))
@@ -36,7 +36,7 @@ d4 -- Ritournelle 3/2 vibraphone
   ))
   # "supervibe"
   # accelerate (0.01)
-  # gain 0.45
+  # gain (slow 16 $ range 0.05 0.35 saw)
 d5
   $ mask "<f!3 t!37>"
   $ jux id
@@ -67,7 +67,7 @@ d9 -- Montée Shepard!
   $ sometimesBy "1 0" (# gain (range 0 0.5 saw))
   $ sometimesBy "0 1" (# gain (range 1 0.5 isaw))
   $ "s"
-  # gain 0.5
+  # gain 0.75
 
 
 once $ "bev" # gain 0.6 # cut 21

live/hardcore/noise_in_the_wires.tidal

@@ -2,7 +2,7 @@
 -- TODO guitare
 
 do
-  -- resetCycles
+  resetCycles
   setcps (90/60/4)
   let masked = sometimes (degradeBy "0 0!6 <0!3 1>")
   d1

live/hip/chaude_civ.tidal

@@ -6,17 +6,16 @@ do
 setcps (90/4/60)
 d1 -- Kick base chaloupé ?
   $ mask "<f!8 [t f]!4 t!8 f!2 t f>"
-  $ juxBy 0.4 ((|* gain 0.8) . rev)
   $ "<k*2 k!7> ~ <k!2 k?> <k!3 <k? ~>> ~ k [k|k*2] k"
   # "reverbkick"
   # room 0.1 # sz 0.1
-  # gain (slow 32 $ range 0.5 0.65 saw)
+  # gain (slow 32 $ range 0.5 0.7 saw)
 d2 -- Breakbeat
   $ mask "<f!8 t!4 t f [f t]!2 t!3 f>"
   $ slice "<8!12 4 4 2 [4 . 8 4]>" ("<0!3 4>" + "0 1 2 3")
   $ loopAt 2
   $ "fbonus:9"
-  # gain 0.8
+  # gain 0.7
   # cut 2
 d3 -- Drumroll metal
   $ fast "<4 4 8 4 4 [4 . ~ 8] 8 <[16 8] 16>>"

live/remix/kanye_fly.tidal

-d1 $ "bd"
 
 once $ slice 32 "1*4" $ "kanye" # cut 21
 
@@ -70,8 +69,6 @@ d4 -- Kanye who?
   # gain 0.65
 
 
-
-
 once $ "kanye" # begin 0.835            -- Fly awayyyyy
 # cut 3
 -- 16
@@ -80,7 +77,6 @@ once $ "kanye" # begin 0.835            -- Fly awayyyyy
 
 
 
-
 do
 let b = 0.835
 let d = (10/60)
@@ -94,3 +90,46 @@ d4
   $ "kanye/4"
   # cut 21
   # gain 0.8
+
+
+
+-- region GLAD To Fly Techno
+do
+  setcps (120/60/4)
+  -- resetCycles
+  -- Loop 0  4  8  12  16  20  24  32   40      48  52 60 68 72 80  88
+  --      Intro    | Wild+ |Fly+   |Ah++|WildFLY|Ah-|Fly|A-a-a-away EOF
+  d1
+    $ mask "<f!4 <f f f t>!4 <f f t t>!4 t!16 f!12 t!8 t f!3 t!8 t!6 f f t!4 t(1,4)!4 f!8>"
+    $ fast "<4!3 <2!3 [8 4]>>"
+    $ "[jazz,techno]"
+    # gain 0.8
+  d2
+    $ jux rev
+    -- $ sometimesBy "<t!8 f!80>" (slow 4 . (|* gain (slow 8 saw)))
+    $ "hh(<5!4 3 3 5 3>,8) ho"
+    # n "0 <0 0 1 2 3 4 5 6>"
+    # gain 0.9
+  d4 $ slice 8 (cat [
+    "", "", "0", "", -- 0 One glad morning
+    "0/4", "", "", "", -- 4 One glad morning, when this life is over
+    "0/4", "", "", "", -- 8 One glad morning, when this life is over
+    "~ 1", "1*2", "1*4", "1*[8 2]", -- 12 Wild
+    "1", "1*2", "1*4", "1*[8 2]", -- 16 Wild
+    "1/4", "", "", "",  -- 20 WILD, Fly away...
+    2, 2, 2, "2*4", 2, 2, 2, "2*2", -- 24 Ooh euh
+    3, 3, "3*4", 3, "3*[4 2]", "3*[8 4]", "3*16", "3*[16 1]", -- 32 AaAaAaAaAa piano fou!
+    4, 4, "4*2", 4, "4*4", "4*4", "4*8", "4*[16 2]", -- 40 Wild - Fly - WILD WILD WILD WILD Fly
+    5, 5, 5, 5, -- 48 Fly.. ah
+    5, 5, 5, 5, "", "", "", 5, -- 52 Fly.. ah fly away
+    "", "", "", 5, "", "", "", 5, -- 60 Fly.. ah fly away
+    "", 5, "", "", -- 68 Fly away, Fly away
+    7, 7, 7, 7, "", 7, 7, "7/4", -- 72 Ah ah ah fly away
+    "7/2", "", "7/4", "", "7/2", "7/4", "7/4", "7/4" -- 80 Ah ah ah fly away
+    -- 88 EOF1
+    ]) $ "kanye"
+    # gain 0.9
+    # legato 2
+    # cut 4
+
+    -- delay / delaytime / delayfeedback / cutoff / resonance / room / size

live/techno/foret_noire.tidal

+
+do
+let melody = "<c5'maj c5'min c5'sevenSus4'2 c5'sevenSus4'3 c5'sevenSus4'3 c5'sevenSus4'4 c5'sevenSus4'5 c5'sevenSus4'5>"
+setcps (120/60/4)
+d1 $ "jazz*4" -- Rythme des tambours
+d2 -- Hypnose des mains
+  $ "~ cp"
+  # note ("<0!3 <2 -2>>")
+  # room 0.4
+  # dry 1
+  # gain 0.9
+d4 -- Chant lunaire
+  $ note "0(<4!3 <3 5>>,8)"
+  # note (arp "up" (slow 4 melody))
+  # "supersquare"
+  # gain 0.6
+  # legato 8 # release 4

live/techno/funk/naufrage.tidal

@@ -2,9 +2,10 @@
 -- Tags: Techno, funk, piano
 -- Ready: 5/10
 -- Intro lead piano
-resetCycles
+-- TODO: "Grande theorie" avant drop kick
 
 do
+  -- resetCycles
   solo 1 -- KICK!
   solo 2 -- Hats rolling
   solo 3 -- LEAD piano
@@ -21,7 +22,7 @@ do
     $ superimpose (const
       $ stut' 4 "<s s e s>" (("q" <~) . (|* gain 0.85))
       $ "ho" # n "<[2|4|5] 1>"
-      # gain (slow 16 $ range 0.5 0.95 saw)
+      # gain (slow 16 $ range 0.5 0.85 saw)
     )
     $ juxBy "<<0.2 0.8> 0.5>" (rev . (hurry 2))
     $ note (stack [

live/transe/doo.tidal

@@ -26,6 +26,7 @@ d3 -- Snare roll
   # note "<0!8 -2!4 -4!2 -8!2>"
   # gain (slow 16 $ range 0.65 1.2 sine)
   # pan (slow 4 $ range 0.2 0.8 sine)
+
 d4 -- Saxeridoo
   $ juxBy 0.8 rev
   $ whenmod 64 8 (slice 8 (run "<2!4 8!3 16>"))
@@ -38,6 +39,7 @@ d4 -- Saxeridoo
   # gain (slow 16 $ range 0.9 1.25 perlin)
   # room (slow 64 $ range 0.1 0.4 sine) # sz 0.3
   # cut 4
+
 d5
   $ superimpose (off "h" (|+ note "<0!4 12!4>"))
   $ note ("c3'maj" + "<c!3 <<c6!4 g!12> g>>")

study/club/fotw/snowball.tidal

+-- snowball takes a pattern, applies the function to it (the third argument),
+-- then applies it again to the result, and again to the result of that, and
+-- so on, the number of times given in the first argument. Then it
+-- combines all the results together pairwise, with the function given in
+-- the second argument.
+
+-- Lets start with a simple tom pattern:
+d1 $ s "lt mt ht ~"
+
+-- Then apply 'hurry 2' to it each time, to a depth of 4 'recursions'
+d1 $ snowball 4 (overlay) (hurry 2) $ s "lt mt ht ~"
+
+-- You can hear the 'hurried' layers built up. The first time you hear the
+-- original pattern, then that pattern combined with itself (so it sounds
+-- louder), then you start hearing the 'hurried' layers added over the third
+--  and fourth cycle.
+
+-- This doesn't work too well really - I don't think it should be combined
+-- with itself that second time. Here's an alternate version that doesn't
+-- do that:
+snowball' :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
+snowball' depth combinationFunction f pattern = cat $ take depth $
+  scanl combinationFunction pattern $ drop 1 $ iterate f pattern
+
+d1 $ snowball' 4 (overlay) (hurry 2) $ s "lt mt ht ~"
+
+-- Instead of 'overlay' to play the layers on top of each other, we
+-- can use a function to combine them. For example using '+' on a
+-- snowballed number pattern, to add the layers together:
+d1 $ n (scale "major" $ snowball 4 (+) (slow 1.5) "0 1 2 3")
+   # s "supermandolin"
+   # legato 3
+
+d1 $ n (snowball 4 (+) (slow 1.5) "0 1 2 3 4 5 6 7")
+  # s "cpu"
+  # speed 2
+
+d1 $ (note $ scale "hexPhrygian" $ "0 . 2 3 ~ . 0 1 . -1 -2") #s "gtr"
+
+d1 $ (note $ scale "hexPhrygian" $
+   snowball 4 (+) (slow 2) "0 . 2 3 ~ . 0 1 . -1 -2") #s "gtr"

study/club/fotw/weave.tidal

+d1 $ weave 16 (pan sine)
+  [sound "bd sn cp",
+   sound "casio casio:1",
+   sound "[jvbass*2 jvbass:2]/2",
+   sound "hc*4"
+  ]
+
+
+-- Function of the Week: "weave" !
+
+-- Weave is an interesting one. It's used to 'weave together' a list
+-- of patterns, using an additional control pattern. So it's a bit
+-- like the warp and weft of a textile weave.
+
+-- Lets start with some numbers:
+d1 $ n "0 1 2 3" # s "numbers"
+
+-- Lets first understand what happens if you use weave on a single
+-- pattern:
+d1 $ weave 4 (pan saw)
+  [n "0 1 2 3" # s "alphabet"]
+
+-- You can hear the pattern panning from left to right over four
+-- cycles.
+
+-- In the above, the '4' is used to slow down the 'pan saw' effect,
+-- before it's applied to the 'n "0 1 2 3" # s "numbers"' pattern. It
+-- sounds identical to the following:
+
+d1 $ n "0 1 2 3" # s "numbers"
+  # pan (slow 4 saw)
+
+-- So why not just do that - what's the point of the weave function?
+-- Lets hear what happens when you use it with two patterns:
+
+d1 $ weave 4 (pan saw)
+  [n "0 1 2 3" # s "numbers",
+   n "0 1 2 3" # s "alphabet"
+  ]
+
+-- Aha! You should be able to hear that the patterns are placed at
+-- different parts of the panning effect. So 'weave' is acting a bit
+-- like a wacked-out 'stack'. The patterns are stacked up, each with
+-- the 'pan' control pattern applied, but with the pan control shifted
+-- so that one is at the start of the pan, the other is halfway
+-- through. They're kind of chasing after each other across the pan.
+
+-- The following sounds identical to the above:
+
+d1 $ stack [n "0 1 2 3" # s "numbers"
+            # pan (slow 4 saw),
+            n "0 1 2 3" # s "alphabet"
+            # pan (2 <~ (slow 4 saw))
+           ]
+
+-- Here's a more musical example:
+d1 $ weave 4 (pan saw)
+  [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2,
+   fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2"
+  ]
+
+-- If we add another pattern, so that we now have 3, things go
+-- a bit off-kilter:
+d1 $ weave 4 (pan saw)
+  [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2,
+   fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2",
+   sound "~ clap:3*2" # speed 2
+  ]
+
+-- That's because three events are spreading out over four cycles, so
+-- they're out by four thirds of a cycle, which sounds like being out
+-- by a third of a cycle. Sounds interesting!
+
+-- Once we add a fourth, things fall back into a 4:4 structure:
+d1 $ weave 4 (crush saw)
+  [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2,
+   fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2",
+   sound "~ clap:3*2" # speed 2,
+   sound "bd(3,8,<0 2>)" # shape 0.85
+  ]
+
+-- 'saw' gives a smooth, linear movement from left to right. Some more
+-- to experiment with (replace `pan saw` for one of these):
+
+-- pan "0 0.25 0.5 0.75"
+-- pan sine
+
+-- It works for things other than panning, too, try:
+-- crush (saw * 8)
+-- vowel "a e i o u"
+
+-- It works with global effects like reverb too, but you have to put
+-- each pattern on its own 'orbit', so that they have separate global
+-- effects:
+d1 $ weave 8 (room saw # sz saw)
+  [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2 # orbit 0,
+   fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2" # orbit 1,
+   sound "~ clap:3*2" # speed 2 # orbit 2,
+   sound "bd(3,8,<0 2>)" # shape 0.85 # orbit 3
+  ]
+
+-- Things get especially weird when you swap things round so that it's
+-- the samples/notes that are being applied to effect patterns.
+
+d1 $ weave 8 (note "c e f g" # s "supermandolin" # legato 2)
+  [vowel "a e i"] # gain 1.3
+
+-- and with more patterns:
+d1 $ weave 8 (every 2 rev $ n (scale "ritusen" "0 .. 7")
+              # s "rash"
+             )
+  [vowel "a e i",
+   vowel "o(5,8,<0 2>)",
+   squiz "0 3*2 4 7"
+   room "0 0.25 0.7 0.99" # orbit 3
+  ] |+ n 24
+
+
+-- There's also a function 'weaveWith', which works with functions,
+-- rather than control patterns..
+d1 $ weaveWith 8 (every 2 rev $ n (scale "ritusen" "0 .. 7")
+                  # s "rash"
+                 )
+  [(+| vowel "a e i*2"),
+   (+| n "0 12*2 0 12"),
+   hurry 2,
+   off 0.25 (|+ n "-24") . struct "t(5,8,<0 2>)" . hurry 4
+  ] |+ n 24

study/club/melodies.tidal

+do
+  let dascale = "hirajoshi"
+  let chord = "'maj"
+  let melo = "0 3 4 7"
+  let root = "<e4 d4 c4>"
+  d1 $ n (scale dascale (chord + melo) + (root + "<-12 -7>"))
+      # s "superpiano"
+  -- d1 $ every 3 (rev) $ n (scale dascale (melo) + root) # s "superpwm"
+  d1 $ every 2 (arpeggiate)
+          $ n (scale dascale (chord + melo) + (root + "<-12 -7>"))
+          # s "superpiano"
+
+do
+let tonal root mode = note . (|+ root) . scale mode
+d1 $ tonal "<0 3>" "major" $ "0 2 4 7"

study/club/poetry.tidal

+
+d3 $ s "cpu2:9*4"
+   # gain (range 0.7 0.8 rand)
+   # smear (range 0 2 rand)
+   # delay 2 # dt "x"
+
+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

study/club/w7.tidal

+-- Composing patterns together
+
+-- We've already looked at different ways of composing patterns
+-- together. Something as simple as this is a composition:
+
+d1 $ fast "1 2 3 4" $ sound "lt mt ht bd*2"
+
+-- Not a super interesting one, but it composes together a pattern of
+-- densities, and a pattern of sounds, to create a new pattern that is
+-- more than the sum of its parts.
+
+-- In this lesson though we're going to look at ways to compose what
+-- you could call 'independent' patterns, where one isn't used to
+-- manipulate the other.
+
+-- Tidal is often used in live situations, but there are some
+-- functions that help you assemble multiple patterns into something
+-- like a complete 'piece', such as a structured four-minute track.
+
+-- Before we get to that, lets look at some extra-simple ways of
+-- composing patterns together.. as they can be surprisingly useful
+
+-- First, there's `overlay` that simply plays the two given patterns
+-- at the same time:
+d1 $ overlay (fast "1 2 3 4" $ sound "lt mt ht ~")
+             (sound "clap:4(3,8)" # speed 2)
+
+-- Similar to this is `stack`, which lets you overlay any number of
+-- patterns on top of each other. People tend to use this rather than
+-- `overlay`, as it's more flexible:
+d1 $ stack [(fast "1 2 3 4" $ sound "lt mt ht ~"),
+            (sound "clap:4(3,8)" # speed 2),
+            sound "[kick:5(5,8), snare:3(7,16,3)]"
+           ]
+
+-- The above composes a list of three patterns together. You can see that
+-- a list is given using square brackets ('[' and ']'), with the patterns
+-- in the list separated by commas (','). You have to remember *not* to
+-- put a comma at the end of the list, only between the elements.
+
+-- The above might not seem too useful, as you could do the same with
+-- separate patterns. This sounds exactly the same as the above:
+d1 $ fast "1 2 3 4" $ sound "lt mt ht ~"
+d2 $ sound "clap:4(3,8)" # speed 2
+d3 $ sound "[kick:5(5,8), snare:3(7,16,3)]"
+
+-- Remember though that stack combines everything into a single
+-- pattern. This is useful as you can manipulate all those patterns as
+-- one. For example:
+d1 $ chunk 4 (hurry 2) $
+  stack [(fast "1 2 3 4" $ sound "lt mt ht ~"),
+         (sound "clap:4(3,8)" # speed 2),
+         sound "[kick:5(5,8), snare:3(7,16,3)]"
+        ]
+
+-- Or adding a parameter that applies to the whole stack:
+d1 $ stack [(fast "1 2 3 4" $ sound "lt mt ht ~"),
+            (sound "clap:4(3,8)" # speed 2),
+            sound "[kick:5(5,8), snare:3(7,16,3)]"
+           ] # squiz "<0 2>"
+
+-- So `overlay` and `stack` stack things up, so that they happen at
+-- the same time. Howabout sticking things together over time, so they
+-- happen one after another?
+
+-- Like overlay and stack, there is one function, 'append' for
+-- composing two patterns together, and another, 'cat' for composing a
+-- list of patterns together.
+
+-- For two patterns:
+d1 $ append (fast "1 2 3 4" $ sound "lt mt ht ~")
+            (sound "clap:4(3,8)" # speed 2)
+
+-- For a list of patterns:
+d1 $ cat [fast "1 2 3 4" $ sound "lt mt ht ~",
+          sound "clap:4(3,8)" # speed 2,
+          sound "[kick:5(5,8), snare:3(7,16,3)]"
+         ]
+
+-- Again, you'll see `cat` used more often than `append`.
+
+-- `append` and `cat` maintain the original 'density' of the patterns,
+-- taking one cycle per cycle.
+
+-- There are variants `fastappend` and `fastcat`, that take a cycle
+-- from each of the patterns, and squash them all into a single cycle:
+
+-- For two patterns:
+d1 $ fastappend (fast "1 2 3 4" $ sound "lt mt ht ~")
+  (sound "clap:4(3,8)" # speed 2)
+
+-- For a list of patterns:
+d1 $ fastcat [fast "1 2 3 4" $ sound "lt mt ht ~",
+              sound "clap:4(3,8)" # speed 2,
+              sound "[kick:5(5,8), snare:3(7,16,3)]"
+             ]
+
+-- That's fine, but what if you don't want to loop between patterns a
+-- cycle at a time, but have something between a `stack` and a `cat`,
+-- where you can have the patterns overlap? `seqPLoop` is one answer.
+
+-- With `seqPLoop`, you say when each pattern starts and stops.
+-- Lets first emulate the `cat` from earlier, by having each
+-- pattern last one cycle.
+d1 $ seqPLoop [(0, 1, fast "1 2 3 4" $ sound "lt mt ht ~"),
+               (1, 2, sound "clap:4(3,8)" # speed 2),
+               (2, 3, sound "[kick:5(5,8), snare:3(7,16,3)]")
+              ]
+
+-- Now let's adjust the starts and stops, so the first two overlap by
+-- a pattern, then there's a gap of a cycle before the last one plays:
+d1 $ seqPLoop [(0, 2, fast "1 2 3 4" $ sound "lt mt ht ~"),
+               (1, 3, sound "clap:4(3,8)" # speed 2),
+               (5, 6, sound "[kick:5(5,8), snare:3(7,16,3)]")
+              ]
+
+-- If you want to use the same pattern more than once, you can give it a name
+--, like this:
+let florence = fast "1 2 3 4" $ sound "lt mt ht ~"
+in
+d1 $ seqPLoop [(0, 2, florence),
+               (1, 3, sound "clap:4(3,8)" # speed 2),
+               (3, 4, sound "[kick:5(5,8), snare:3(7,16,3)]"),
+               (3, 5, florence # coarse 5)
+              ]
+
+-- If you don't want the pattern sequence to loop, then use
+-- seqP. You'll need to use something like `qtrigger`, so it starts
+-- from cycle 0
+d1 $ qtrigger 1 $ seqP [(0, 2, fast "1 2 3 4" $ sound "lt mt ht ~"),
+                        (1, 3, sound "clap:4(3,8)" # speed 2),
+                        (5, 6, sound "[kick:5(5,8), snare:3(7,16,3)]")
+                       ]
+
+-- Don't forger you can stack seqPLoop:
+d3 $ stack [
+    seqPLoop [
+    (0, 2, s "[bd*2] hh bd sn:8"),
+    (1, 3, s "[hh*4] bd bd sn:8"),
+    (2, 4, s "bd bd sn:8 sn:8"),
+    (4, 5, s "bd sn:8 [bd*2] sn:8")
+    ],
+    seqPLoop [
+    (0, 2, s "jvbass(3,8)"),
+    (2, 4, s "jvbass(5,8)"),
+    (4, 5, s "jvbass*4" # speed 1.1)
+    ]
+]

study/club/w8.tidal

+-- region Lesson 1 SHIFTING TIME
+
+-- Lets start with a rhythm:
+d1 $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2"
+
+-- That's repeating nicely. Keep it running, then run this:
+d1 $ 0.25 <~ (n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2")
+
+-- If you switch between them, you can hear the pattern is shifting in
+-- time. The `0.25` means it's shifting by a quarter of a cycle.
+
+-- You only hear any difference between them at the point where you
+-- switch to the other one. You're jumping forward / backward in time,
+-- but once you're there, nothing has changed. (!)
+
+-- Ok, time travel is difficult to talk about.
+
+-- Lets visualise this, compare these two:
+drawLine "a b c d"
+
+drawLine $ 0.25 <~ "a b c d"
+
+-- You can see the a b c d sequence is the same, but in the latter
+-- case, the cycle begins on the 'b'.
+
+-- So '<~' has moved us _forward_ into the future. So shouldn't it be
+-- '~>', rather than '<~'?? Well, we might have moved into the future,
+-- but it's all relative - from the perspective of the pattern, it's
+-- moved backwards into the past. Furthermore, while we like to think
+-- about us moving forwards into the future, from the perspective of
+-- the future, it's moving backwards into the past. Furthermore
+-- different human cultures think about time in different ways.
+
+-- Anyway, '~>' does indeed exist, compare these two:
+
+drawLine $ 0.25 <~ "a b c d"
+
+drawLine $ 0.25 ~> "a b c d"
+
+-- Time is most interesting if you keep jumping around
+-- For example jump every 3 cycles:
+d1 $ every 3 (0.25 <~) $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2"
+  # crush 4
+
+-- Jumping in the other direction has quite a different feel:
+d1 $ every 3 (0.25 ~>) $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2"
+  # crush 4
+
+-- You can also use a pattern for the time shift amount:
+d1 $ "<0 0.25 0.75>" ~>
+  (n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2" # crush 4)
+
+-- Even with this straightforward shifting, things quickly start
+-- sounding 'random', until your ears lock on to the longer loop..
+
+-- SIDETRACK - a note on syntax..
+
+-- Unfortunately this use of the dollar *doesn't work*:
+d1 $ "<0 0.25 0.75>" ~> $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]"
+  # sound "cpu2" # crush 4
+
+-- This is because like all operators, you can't use a dollar to group
+-- together a pattern to send to `~>` in this way. haskell gets
+-- confused about seeing two operators ('$' and '~>') next to each
+-- other.
+
+-- So you have to use parenthesis:
+d1 $ "<0 0.25 0.75>" ~> (n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]"
+  # sound "cpu2" # crush 4)
+
+-- Or another way around this is to wrap the *operator* in
+-- parenthesis, then you can use it like a normal function:
+d1 $ (~>) "<0 0.25 0.75>" $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]"
+  # sound "cpu2" # crush 4
+
+-- Or wrap the first input and the operator in parenthesis:
+d1 $ ("<0 0.25 0.75>" ~>) $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]"
+  # sound "cpu2" # crush 4
+
+-- This all works nicely with chopped-up loops:
+d1 $ every 2 ("e" <~) $ every 3 (0.25 <~) $
+  loopAt 1 $ chop 8 $ sound "break:8"
+
+-- endregion
+
+-- region Lesson 2 Binary patterns
+
+-- The patterns you send to SuperDirt tend to contain values of type
+-- String (for words), Double (for decimal numbers) or Int (for whole
+-- numbers). One pattern type you probably won't send to SuperDirt is
+-- of type Bool - short for Boolean.
+
+-- Boolean values can be either True or False. You've probably seen
+-- then used with with 'struct', e.g.:
+
+d1 $ struct "t f t t f t f f" $ sound "snare:4"
+
+-- 'struct' provides structure for the pattern on the right; whenever
+-- there's a 't' (i.e., a true value) in the boolean pattern, the
+-- snare fires.
+
+-- It works with euclidean syntax too:
+d1 $ struct "t(3,8)" $ sound "snare:4"
+
+-- The above creates a new pattern with three events per cycle,
+-- according to a Euclidean pattern.
+
+-- Lets have a look at that euclidean pattern:
+drawLine $ struct "t(3,8)" "a"
+
+-- So what do you think would happen if you changed that 't' (for
+-- true) for an 'f' (for false)? Lets try:
+drawLine $ struct "f(3,8)" "a"
+
+-- Lets listen to that structure too:
+d1 $ struct "f(3,8)" $ sound "snare:4"
+
+-- You can see and hear that the *inverse* of the Euclidean pattern is
+-- played. What was true, is now false, and vice-versa.. It's the
+-- 'empty' steps which get the true values, and which we end up
+-- hearing.
+
+-- This is clearer if we play a t(3,8) against an inverted f(3,8):
+d1 $ stack [struct "t(3,8)" $ sound "kick:4",
+            struct "f(3,8)" $ sound "snare:4"
+           ]
+
+-- You can hear that the snares are 'filling in' where the kicks
+-- aren't playing - they never play at the same time.
+
+-- Filling in patterns like this is a lot of fun, and there's a
+-- function called 'stitch' that makes it easier:
+d1 $ stitch "t(3,8)" (sound "kick:4") (sound "snare:4")
+
+-- You only have to give the boolean pattern once, 'stitch' takes care
+-- of inverting the pattern for the second pattern. It's called
+-- 'stitch', because it's like going up and down to stitch two things
+-- together.
+
+-- You can make more complicated boolean patterns to quickly get some
+-- fun patterns going:
+d1 $ stitch "t(<3 5>,8,<0 2 3>)" (sound "kick:4") (sound "hc")
+
+d1 $ stitch "t(<3 5>,<8 8 8 6>,<0 2 4>)" (sound "kick:4") (sound "hc")
+
+-- Actually it'd be less typing do the stitching _inside_ the sound
+-- control pattern:
+d1 $ sound (stitch "t(<3 5>,<8 8 8 6>,<0 2 4>)" "kick:4" "hc")
+
+-- In the above, I only have to write 'sound' once, because the
+-- 'stitch' is working on patterns of words, not patterns of sounds.
+
+-- You can also alternate between patterns of true, and patterns of false
+-- values:
+drawLine $ struct "<t f>(3,8)" "a"
+
+-- If you prefer you can use '1' or '0' instead of 't' and 'f', the
+-- result is exactly the same:
+drawLine $ struct "<1 0>(3,8)" "a"
+
+d1 $ struct "<1 0>(3,8)" $ sound "clap"
+
+-- You don't have to use the Euclidean syntax, you can just right them
+-- out by hand:
+d1 $ stitch "t f t t f f t f" (sound "kick:4") (sound "hc")
+
+-- .. and use the usual mininotation syntax:
+d1 $ stitch "t f t [t f]*2 f ~ t f" (sound "kick:4") (sound "hc")
+  # room 0.2 # sz 0.8
+
+-- With stitch, the rhythmic structure comes from the boolean
+-- pattern. It has a synonym friend called 'sew', which instead
+-- preserves the structure of the patterns it's sewing together.
+
+-- Lets try it:
+d1 $ sew "t f" (sound "kick") (sound "clap:4")
+
+-- Oh! We only hear the kick. That's because the 'f' only switches to
+-- the second pattern for the second half of the cycle, and no new
+-- 'clap's happen then.
+
+-- If we have four claps spread over the cycle, we hear the second two
+-- of them:
+d1 $ sew "t f" (sound "kick") (sound "clap:4*4")
+
+-- Sew can be really nice for blending together two more complicated
+-- patterns. Lets have a listen to them individually first:
+
+d1 $ chunk 4 (hurry 2) $ n "0 .. 7" # sound "cpu"
+
+d1 $ n "0 .. 7" # sound "cpu2" # speed 1.5 # squiz 2
+
+-- And now sewn:
+d1 $ sew (iter 4 "t f")
+  (chunk 4 (hurry 2) $ n "0 .. 7" # sound "cpu")
+  (n "0 .. 7" # sound "cpu2" # speed 1.5 # squiz 2)
+
+-- In the above I have a really simple "t f" binary pattern, but use
+-- 'iter 4' so that it shifts by a quarter every cycle.. So you get
+-- different parts of the sewn patterns coming through.
+
+-- endregion

study/nova/disco_punk.tidal

+-- Exp #2: Le Disco Punk
+-- https://www.youtube.com/watch?v=sNzhxE45mGE
+
 setcps 0.6
 
 d10 -- metronome

study/weave.tidal

-d1 $ weave 16 (pan sine)
-  [sound "bd sn cp",
-   sound "casio casio:1",
-   sound "[jvbass*2 jvbass:2]/2",
-   sound "hc*4"
-  ]