I should commit more often

blocks/drums.tidal

 setcps 0.8
 
+-- helico?
+d1 $ s "[a*4 ~] a*8"
+# note "-15 .. 15"
+
+-- DNB
+d1
+$ fast 2
+$ s "bd ~ sn:1 ~ ~ bd sn:1 <~ sn:1>"
+# gain 0.8
+
+
 d1 $ "<dr <dr*2 dr?*8>>" # s ( choose ["hh", "dr"])
 
 d2 $ euclid "<1 3>" 8
@@ -23,7 +34,7 @@ $ s "dr"
 d2 $ s "dr*2 ~ dr  ~ dr*8"
 
 d1
--- $ degrade
+$ degrade
 $ s "dr dr dr dr dr dr sn ~ dr dr dr dr sn"
 
 d1
@@ -52,4 +63,9 @@ $ euclid 3 8
 $ s "dr"
 # n 0
 
+
+d1 $ s "[a*4 ~] a*8"
+# note "-15 .. 15"
+# s "armora"
+
 d1 $ "jazz" # 3

blocks/melody.tidal

+setcps 0.5
 
 d2
 $ whenmod 8 6 (# gain 0)
@@ -7,3 +8,13 @@ $ every' 8 6 rev
 $ s "<arpy*8 ~>"
 # n (run 8)
 # gain 0.8
+
+d7
+$ someCycles (degrade . off 0.5 (|+ 0))
+$ s "~ dsynth(<4 3 5>,8)"
+-- $ off 0.25 (|- note 7)
+# note (scale "major" "0 7")
+|- note "<12 9 7 12 5>"
+# gain 0.7
+
+once $ s "arp" # n 0

blocks/noise.tidal

@@ -8,3 +8,6 @@ $ s "[bass3:9*8]"
 # release 1
 # note 0
 -- # gain 0
+
+-- Basse explosive se répandant
+"bass1:1"

copycat.tidal

@@ -4,6 +4,7 @@ hush
 
 -- Drums
 d1 $ s "~ sn:1 ~ sn:1"
+
 d2 $ s "[808bd*2 [~ bd*2] [~ bd bd ~] ~]"
 
 d1 $ s "808bd:12"

copycat/electric_fever.tidal

+setcps 1.03
+
+d1 -- bass
+-- $ whenmod 32 16 (# silence)
+$ slow 2
+$ note (
+  scale "major" (
+    cat [
+      " 1  1 ~ . ~ [~ 0]",
+      "0 [0 1] ~ ~ . ~  "
+    ]
+    + "[0, 7]" -- gamme
+  )
+)
+# s "bass3"
+# gain 0.8
+
+
+
+d2 -- hit roll
+$ s "<hh*4 hh*4 hh*4 [hh*4 ~]>"
+# s "hh"
+# release 0.5
+
+d3 -- claps
+$ s "<[~ cp] [~ cp] [~ cp] [~ cp . cp ~]>"
+# gain 0.9
+# n 1
+
+d4 -- fork
+$ off 0 ((# s "supergong") . (# gain 0.5) . (# release 0.5))
+$ s (cat [
+"~ f f*2 ~"
+, "f f ~ f"
+, "f*2 ~ f f"
+, "[f*4] ~"
+])
+# s "superfork" # n (scale "major" (-4))
+# release 0.5
+
+d5
+-- $ whenmod 32 16 (# silence)
+$ whenmod 32 4 (# gain 0.8)
+$ every 4 (# silence)
+$ s "reverbkick*2"
+# gain 0.7

hello.tidal

--- Pattern add
--- Structure 5:
---  *1*
---       4
---      3
---     2
--- 0
-
--- "808bd" Bass drum
--- 0 dry drum
--- 1 loud, bouncy bass
--- 2 semi-dry drum
--- 3 semi-dry bouncy drum
--- 4 loud, longer bounce bass
--- 4 loud bass
-
--- "808cy" Cymbal
--- 0-8: More and more echo
--- 9-16: Single, then several with echo
--- 9-16: Several until one with long echo
-
---  Structure 5:
---- 808lc Lourd Carillon (rond)
---- 808mc Milieu Carillon (rond)
---- 808hc Haut Carillon (rond)
---- 808lt Lourd Tuyau  (tac)
---- 808ht Milieu Tuyau  (tac)
---- 808ht Haut Tuyau  (tac)
---- 808oh Cymbale bruitée
--- 0: sec
----- 1: 1sec
----- 1: 0.5sec, sourdiné
----- 2-4: aigu-grave
-
--- 808sd  Cymbale + drum
---- 0:3 bas
---- 4:7 haut
-
--- bass Basse métallique
---- 0:4 notes harmoniques
-
--- bass3 Guitare basse
---  0 grave, ronde
---  1 moins grave, plus pincéee
---  2 comme 1 mais plus claire, moins bruitée
---  3 plus sèche
---  4 plus d'écho
---  5 grave, métallique
---  6 grave métallique sèche
---  7 grave, limite wob wob
---  8 aigue, métallique
---  9 Wob wob
--- 10 Wob wob chanté
-
--- bassdm Drum bas et roulant
-
--- blip: 8bit notes
-
--- ade Vibration genre post-gong
-
--- co Cymbale couverte
---- 0 tic-tshii
---- 1 tintshi
---- 2 tshii-tic
---- 3 tshii-
-
--- dr Drums variés
---- 0 titititi
---- 1 tatatata
---- 2 tintintin (sourdine, cuivree)
---- 3 zip
---- 4 zip zinp
---- 5 loud bass drum
---- 6 tata (plus cymbale que 1)
---- 7 bass drum + tin
---- 8 tata sourd
---- 9 tak tak bois
-
--- ulgab: 0 sale, 1 rebond, 2 crash, 3 crash joyeux, 4 idem rebond
-
--- rave
---- 0 are you ready
---- 1 whoo alright
---- 2 'cut' fast (normal speed 0.8)
---- 3 'a'
---- 4 'give it to them'*2
---- 5 our crow (echo)
---- 6 skat 'td ta'
---- 7 ow! (Jackson distordu)
-
--- hh high hat?
--- 0: tsii
--- 1: tsiing! (final)
--- 2: tawiit (zip scratché)
--- 3: ziip
--- 4: orchestra hit
--- 5: bass drum
--- 6: tok (bois)
--- 7: tsiing! (sourdiné)
--- 8: tsii (discret)
--- 9: maracas discrète
--- 10: petit ding
--- 11: tok métallique
--- 12: tok métal etouffé
-
--- glitch
--- 0 noise kick sec
--- 1 portail qui s'ouvre
--- 2 static doux
--- 3 static+bip d'oiseau
--- 4 static coupé sec
--- 5 static + attente téléphone
--- 6 bip oiseau sec pincé
--- 7 bass drum + static
--- 8 tom sec
-
--- Kicks
-
--- popkick
---- 0 sec bruité
---- 1 sec rond métal
---- 2 sec rond
---- 3 sec bruité ulgab
---- 4 sec explosion
---- 5 même avec toy final
---- 6 sec bruité toc
---- 7 rond tuyau
---- 8 aigu souris
---- 9 tuyau sable
-
--- clubkick
---- 0 sec métal
---- 1 un peu plus long
---- 2 sec plus grave?
---- 3 sec plus grave?
---- 4 sec plus aigu?
-
--- hardkick:
---- 0 bruité
---- 1
---- 2
---- 3
---- 4
---- 5
---- 6
---- 7
---- 8
---- 9
-
--- Piano notes:
-
-
--- Gammes
--- "0 2 4 5 7 9 11 12" Pentatonique
--- "0 2 3 4 5 6 7 9 10 11 12"  -- Blues
--- Playground
-
 setcps 0.1
 
 solo 2

live/FOSDEM/after.tidal

+setcps 0.40
+
+d1
+$ whenmod 32 30 (# silence)
+$ whenmod 32 24 (# gain 0.6)
+$ s "k k <k k k k*2> <k k*2 k k*2>"
+# s "kick808"
+# gain 0.8
+
+d2
+$ s "[d d] <d d d*2 d*4>]"
+# s "dr"
+# gain 0.7
+
+d3
+$ someCyclesBy 0.9 (# s "cp")
+$ (0.25 ~>)
+$ s "cp ~ <cp cp <cp cp*2> cp*2> ~"
+# gain 0.7
+# n "<0 [0 1]>"
+
+d5
+$ someCycles (rev)
+$ someCycles (# gain 0.7)
+$ every' 2 1 (# silence)
+$ sometimes (slow 2 . degradeBy 0.2 . (off 0.125 (|+ 7)) . (# gain 0.5))
+$ rarely (degrade . (# note (scale "major" "c'maj'2")))
+$ rarely (# note (choose [0, 7] + scale "major" "c'maj'"))
+$ arp "updown"
+$ s "superhammond*4"
+# note (4 + scale "major" "c'maj'")
+# gain 0.6
+
+
+d6
+$ whenmod 48 24 (# gain 0.5)
+$ jux rev
+$ off 0.125 (|+ n 12)
+$ off 0.25 (|+ n 7)
+$ note (scale "major" "c'maj'4")
+# sound "superpiano"
+# gain 0

live/FOSDEM/before.tidal

+setcps 0.5
+setcps (-1)
+
+d1
+$ s "k k <k k k k*2> <k k*2 k k*2>"
+# s "kick808"
+
+d2 $ s "{hh*3 hh*2}"
+
+d3
+$ off 0.125 ((|+ n 12) . (# gain 0.7))
+$ superimpose ((|-| 14) . (# s "superpiano") . (# gain 0.8))
+$ every 4 (rev)
+$ arp "updown"
+$ n "0'maj'4 e'min"
+# s "blip"
+
+d1 $ s "superpiano"

live/FOSDEM/sunday.tidal

+setcps 0.45
+
+d1
+$ whenmod 16 14 ((# s "foo:2") . (# gain 0.8))
+$ whenmod 16 12 (# gain 0.6)
+$ s "foo" # n 1
+# gain 0.8
+
+
+d2
+$
+whenmod 32 32 (# n 3) -- zip zip
+$ whenmod 32 28 (
+  fix (# n 1) (s "dr") -- harder drums
+)
+$ whenmod 32 16 (
+  degradeBy "0.8 0.1 0.5 0"
+)
+$ s "[dr,hh] hh hh [dr dr <dr ~> dr,hh*2]>"
+
+d3
+$ whenmod 64 32 (rev)
+$ whenmod 16 10 (degradeBy 0 . (# release 0.1) . (off 0 (|- 7)))
+$ whenmod 16 8 (degradeBy 0.2)
+$ someCycles (# release 0.2)
+$ off 0.125 (|+ note 7)
+$ s "b b*2 ~ [b*2 ~]"
+# release "1 0.5"
+# s "bass3"
+# note (scale "majPent" "0 1 3 4 5")
+# gain 0.7

live/FOSDEM/techno_du_soir.tidal

+setcps 1.00
+
+d1
+$ whenmod 32 30 (const
+  $ s "e:2 ~ [e:2 e:2] e:3 ~"
+  # s "electro1"
+  )
+$ whenmod 32 28 (# silence)
+$ someCyclesBy 0.05 (superimpose (fast 2) . (# gain 0.7))
+$ s "reverbkick(2,4)"
+# gain 0.9
+
+d2
+$ whenmod 32 24 (# silence)
+$ someCycles (# s "hh")
+$ s "<dr [dr*2 <~ dr*4>]>"
+
+d4
+$ whenmod 16 6 (# gain 0.8)
+$ whenmod 16 4 (# gain 0.7)
+$ whenmod 16 2 (# gain 0.6)
+$ whenmod 16 0 (# gain 0.4)
+$ off 0.25 ((|-| note 7) . (# gain 0.8))
+$ s "bass3(<1 3>,8)"
+# note (scale "major" "<0 <4 0> 0>")
+# release (0.5 + rand / 2)
+# gain 0
+
+
+d5
+$ whenmod 128 64 (jux rev)
+$ whenmod 32 24 (off 0.125 (|+ 0))
+$ every 2 (# gain 0.8)
+$ rarely (rev)
+$ sometimes (superimpose (|-| note 7))
+$ sometimes (superimpose (|+| note 14))
+$ chop 4 $ s "sax"
+# note (scale "major" "0 4 <7 0>")
+# cut 1
+# gain 0
+
+d6
+-- $ whenmod 32 31 (const $ s "moan" # gain 0.8 # crush 4)
+$ whenmod 4 3 (# gain 0.6)
+$ whenmod 4 0 (# gain 0)
+$ degradeBy 0.3
+$ superimpose (|+| note 7)
+$ sometimesBy 0.2 (jux rev)
+$ rev
+-- $ chop 2
+$ s "kurt"
+# crush 5
+# gain 0.6
+# pan (rand)
+
+
+once $ s "kurt:6"

live/FOSDEM/train.tidal

+setcps 1
+
+d1
+$ every 2 (off 0.125 (# gain 0.5))
+$ whenmod 8 6 (slow 2)
+$ euclid 2 4
+$ s "clubkick"
+# release 0.8
+# gain 0.9
+
+d2
+$ every 2 (swing 0.5)
+$ off 0.25 ((|-| note 7) . (# gain 0.6))
+$ s "bass3(3,8)"
+# release (0.5 + rand/2)
+# gain 0.7
+# note (scale "major" "<0 <4 0> 0>")
+
+d3
+$ whenmod 16 15 (# silence)
+$ whenmod 16 14 (degradeBy 0.8)
+$ whenmod 16 12 (degradeBy 0.6)
+$ whenmod 16 10 (degradeBy 0.4)
+$ whenmod 16 8 (degradeBy 0.2)
+$ every 8 (off 0.125 (superimpose ((|-| note 7) . (# s "superpiano") . (# velocity 0.6))))
+$ every 4 (sometimes degrade)
+$ s "[chin,blip]*8"
+# note "0 <1 2 1 7> 0"
+# gain 0.5
+
+d4 $ s "electro1:(3,4)"
+# n "2 3 4"

live/FOSDEM/train_du_soir.tidal

+setcps 0.44
+
+d1
+$ whenmod 8 4 (rev)
+$ every 8 ((# s "hh"). (# n "2 3") . (# gain 1))
+$ s "hh sn dr*4 <808cy 808cy 808cy 808cy*2>"
+# gain 0.8
+
+d2
+$ whenmod 8 7 ((# s "bd:1 hh:4") . (# gain 0.8))
+$ whenmod 16 10 (# silence)
+$ fast 4
+$ "bd:1 [sn,linnhats]:1"
+# gain 0.8
+
+d3
+$ whenmod 32 16 (rev)
+$ whenmod 16 15 (# gain 0.5)
+$ whenmod 16 12 (# silence)
+$ whenmod 16 10 (# release 0.1)
+$ whenmod 16  2 (# gain 0.8)
+$ whenmod 16  1 (# gain 0.7)
+$ whenmod 16  0 (# gain 0.6)
+--   [b  ] [b b]
+$ s "[b ~ b ~] [b ~ ~ ~] [b <~ b> <~ ~ ~ b> b] [~ b? ~ b?]"
+# s "bass3:5"
+# note "0          5     [[8   5] [8   <12 5>]]      0     "
+
+-- hh:2 scratch
+-- hh:4 final!
+
+-- bass3:
+-- 0
+-- 4: ronde courte
+-- 5: ronde longue
+-- 6: seche
+-- 7: profonde
+-- 8: electric, rare

live/bodgan2.tidal

-d1 $ s "dr(2,4)"
+d1 $ s "dr(<2 <8 1>>,4)"
 
 d1 $ s "bogdan"
 
-d2
-$ somecycles (slow 2)
-$ s "bogdan:7(1,4,1)"
-
 d1
 $ whenmod 8 4 (off 0.125 (|+ 0))
 $ s "bogdan(<<1 2> 4>, 2)"

live/briquets.tidal

@@ -3,9 +3,6 @@ once $ s "[lighter:6/2,pebbles]" # release 0.2 # speed 2 # attack 0.3
 
 setcps 1
 
-
-solo 8
-
 d1 -- briquet
 $ whenmod 64 57 ( -- silence
     const $ s "~"
@@ -33,18 +30,7 @@ $ s "lighter"
 # n (choose [0,1])
 # pan 0.3
 
-d3 -- tambours du progrès
-$ whenmod 64 56 (# gain 0.4)
-$ whenmod 64 48 (# s "hh")
-$ whenmod 64 48 (# n 0)
-$ whenmod 64 33 (off 0.25 (|+ 0))
-$ whenmod 64 33 (# n 2)
-$ whenmod 64 33 (# gain 0.5)
-$ whenmod 64 16 (# n 1)
-$ whenmod 64 5 (# gain 0.4)
-$ s "dr(<1 3>,4)" # n 0
-# gain 0
-# pan 0.8
+
 
 d2 -- guitare du feu!
 $ whenmod 64 56 ( const $ s "~" ) -- silence

live/briquets2.tidal

+setcps 0.5
+
+d1
+$ fast 2
+$ sometimes (off 0.5 (|+ 0)) -- retente
+$ almostNever (off 0.125 (|> 3)) -- dérape
+$ euclid "<1 2 4 8>" 8
+$ s "lighter"
+# n (choose [0,1])
+
+d3
+$ every' 4 3 (# silence)
+$ fast 2
+$ s "sitar:1"
+# up (-0.15)
+# note (scale "dorian" "<0 1 2 <0 4>>")
+-- # gain 0.6
+
+d5
+$ slow 2
+$ s "bass2"
+# speed 0.25
+
+d6 $ s "~ ~ dr:1 ~"
+--
+-- d7 $ s "[bd ~] ~ ~ [cp ~]"
+
+d7 $ s "<[bd ~ ~ [~ bd]] [[bd ~ bd bd] [~ bd bd ~] ~ bd]>"
+
+d8
+-- $ sometimes (off 0.125 (|+ 1))
+$ sometimes (off 0.125 (|+ 0))
+$ somecyclesBy 0.8 (fast 1.5) $ somecycles (slow 2)
+$ s "bass3(<2 4 2 6>,8)"
+# note (scale "minPent" "3 3 4 0")

live/chill/dub.tidal

+setcps 0.6
+
+d1 -- beat: default chill, run tous les 64
+$ whenmod 128 164 ( -- run
+  const $  "[r r?] r r [r r?]" # s "kick:5"
+  # release 0.8
+  # gain 0.8
+)
+$ euclid "<1 2>" 4
+$ s "<k k*2 <k*2 k> k>"
+# s "kick:5"
+# release 0.8
+-- # room 0.5
+-- # size 0.5
+
+d2 -- Carillons / Claps
+-- claps apparaissent et disparaissent
+-- $ whenmod 64 48 (fix (# gain "<0.9,0.025 .. 0.5>") (s "clap"))
+-- $ whenmod 64 32 (fix (# gain "<0.5,0.025 .. 0.9>") (s "clap"))
+$ whenmod 64 0 (fix (# gain "0") (s "clap"))
+$ fix (# n (wchoose [(0.8,0),(0.2,1)])) (s "clap")
+$ s "hh(<4 4 4 2>,4) clap" # n "8 8 8 <8 8 8 9> 3"
+
+d4 -- Basse
+-- $ rev
+$ jux degrade
+$ note (scale "aeolian"
+"<[<3 [4 3]> . ~ <0 3>] [<0 3?> 1 0 1]> . <~ ~ <0 1>? ~>~"
+)
+# s "bassWarsaw"
+# attack "3"
+# room 0.3
+# size 0.8
+|- note 30
+
+
+d5 -- Synth fou dub
+-- $ fast 2
+$ superimpose (|+ note "<5 5 3 3 0 0>")
+$ note (scale "major" "~ 0")
+# s "cheapPiano1"
+|- note 12
+# gain "<0.75 .. 1 1 .. 0.65>"
+# room "<0.2 .. 2 2 .. 0.2>"
+# size "<0.8 .. 0.2>"
+# dry "1,0.2 .. 4 5,0.5 .. 1"
+
+d6 -- lead harpe joyeuse
+-- $ jux rev
+-- $ sometimes (fast 2)
+-- $ sometimes (off 0.125 (|+ 5))
+$ "h?*8"
+# n (scale "aeolian" "0 2 4 <7 9> <0 -3>")
+# s "harpsichord2"
+# gain "<0.9,0.05 .. 0.7 0.7,0.05 .. 0.9>"
+
+d7
+$ someCycles (degrade . off 0.5 (|+ 0))
+$ s "~ dsynth(<4 3 5>,8)"
+-- $ off 0.25 (|- note 7)
+# note (scale "major" "0 7")
+|- note "<12 9 7 12 5>"
+# gain 0.7
+-- |- note "<5 10 12 10 5>"
+
+solo 5
+
+mute 4
+unmute 4

live/chill/melancolia.tidal

+setcps 0.5
+
+solo 9
+
+d1 -- batterie
+$ every 4 (# s "dr:2")
+$ s "[hh*2 dr:1 hh dr:1]"
+
+d2 -- drums
+$ whenmod 16 8 (# gain (1.2 * tri))
+$ whenmod 16 6 (# gain (1 * tri))
+$ whenmod 16 4 (# gain (0.9 * tri))
+$ whenmod 16 0 (# gain (0.8 * tri))
+$ "hh:12(<2 4 2 6>,<4 8>)"
+
+d3 -- basse
+$ someCycles (# reverb .2)
+$ someCycles (# attack 0.2)
+$ note (scale "major" "0(3,8) [<3 3 -6 -6> -2(<1 2 4>, 6)]" - 7)
+# s "bassWarsaw"
+# gain 0.9
+
+d4 -- lead piano
+$ someCycles (jux rev)
+$ whenmod 16 14 (|+ note 15)
+$ whenmod 16 10 (|- note 3)
+$ whenmod 4 2 (|- note 7)
+$ someCycles (off 0.125 (|+ 14))
+$ someCycles (off 0.25 (|- 5))
+$ note (scale "major" "~ [3,<8 7 5>,10]" - 7)
+# s "cheapPiano1"
+# sustain 2
+# attack 0.2
+
+d5 -- TODO lead?
+$ s "organReed(<1 3>,8)"

live/chill/swing.tidal

+setcps 0.5
+
+d1
+$ whenmod 16 8 (
+  superimpose (# s "defaultB") . (# gain 0.9) . (# release 0.5)
+)
+$ note ("<<0 3> <0 3> <0 -4> <0 -4>>" + "0 7 ~ 0 6 7 6 3")
+# s "bass3"
+# gain 0.8
+
+d2
+$ whenmod 16 8 (# gain 1)
+$ whenmod 16 4 (# gain 0.8)
+$ whenmod 16 0 (# gain 0.6)
+$ fast 2
+$ sometimes (# s "dr 808cy:5")
+$ s "dr*<2 4> [hh hh?]"
+
+d3
+$ someCycles ((off 0.625 (|+ 0)) . (# n "3"))
+$ off 0.125 (|+ 0)
+$ s "e"
+# s "electro1"
+# n "2"
+
+d4 $ silence-- TODO: gets annoying, do something
+$ chop 2
+$ s "sillyVoice" # cut 1
+# note "<0 0 3 0 0 3 7 0> <7 3>"
+# gain 1

live/china.tidal

+setcps 1
+
+d1
+$ every 4 (off 0.125 (# gain "1 <0 1> 1 0"))
+$ s "sd:1*4"
+
+d2
+-- $ off 0.125 (# note (scale "chinese" "3"))
+$ off 0.25 (
+  (# s "808lc") .
+  (# note (scale "chinese" "-1"))
+  )
+$ s "808hc*2"
+# note (scale "chinese" "0 <3 5> <5 3>")
+# gain (choose [0.7, 0.8, 0.9, 1])
+
+d3
+$ often (fast 2 . off 0.125 (|+ 0) . (# gain 0.6))
+$ s "bass3(<<2 3> 4>,4)"
+# note (scale "chinese" "0 1 3 5")
+# gain tri

live/contrevent.tidal

@@ -2,6 +2,9 @@ hush
 
 setcps 0.5
 
+solo 1
+solo 2
+
 d1 -- vents du haut
 $ chunk 4 (rev)
 $ rarely (rev)

live/digestion_roll.tidal

+setcps 1
+
+solo 1
+
+d1
+$ whenmod 16 14 (# silence)
+$ whenmod 16 8 (degradeBy "0.2 0")
+$ whenmod 4 1 (sometimes (off 0.25 (|+ 0)))
+$ every 4 (fast 2)
+$ s "kicklinn*2"
+# gain 0.9
+
+d2
+$ degradeBy 0.05
+$ whenmod 8 4 (off 0.125 (# s "808oh"))
+$ every' 4 3 (fast 8)
+$ every' 4 1 (off 0.125 (|+ 0))
+$ s "dr"
+
+d3
+$ whenmod 32 24 (# note (scale "minPent" "0 <<2 0> 1>"))
+$ whenmod 16 8 (# gain 0.7)
+$ whenmod 16 0 (# gain 0)
+$ every 4 (rev)
+-- $ degrad
+$ off (choose [0.25, 0.125]) (# note 0)
+$ s "bass3*4"
+# note (scale "<aeolian>" "0 2 1 <3 5>")
+
+
+d1
+$ s "superpiano*8"
+# gain 0.6
+# note (scale "bartok" "0..7")

live/friday2.tidal

+setcps 0.5
+
+d1
+$ someCyclesBy 0.1 (# silence)
+$ someCyclesBy 0.6 (fast 2)
+$ s "reverbkick*2"
+# gain "1 0.8"
+
+d2
+$ someCyclesBy 0.2 (const $ s "cp dr:0*8")
+$ s "~ <sn:3 ~>"
+
+d3
+$ s "glitch*8"
+# n 1
+# note "0 3 5 7 5 3 0 0"
+
+d4
+$ someCyclesBy 0.1 (degradeBy 0.8)
+$ someCyclesBy 0.1 (
+  fast 2 . (# note (scale "dorian" (7))) . (# s "superpiano")
+)
+$ someCyclesBy 0.1 (# attack (tri / 8)) -- cut sample
+$ whenmod 16 8 (# note (scale "dorian" "7 .. 0"))
+$ off 0.125 (# note "<0 7>")
+$ s "superpiano*4"
+# note (scale "dorian" "0 .. 7")
+# attack (tri)
+# gain 0.8
+
+d5
+$ someCyclesBy 0.1 (degradeBy 0.6)
+$ someCyclesBy 0.1 (
+  degradeBy 0.4 . fast 2 . (# note (scale "dorian" (-7))) . (# s "superpiano")
+)
+$ sometimes (off 0.25 (|+ 0))
+$ off 0.125 (
+  # note (scale "dorian" (-7) + "0 3 0")
+)
+$ s "superpiano*2"
+# note (scale "dorian" (-14) + "0 3 0")
+# gain 0.8
+# sustain 2
+
+
+d6
+$ degrade
+$ someCyclesBy 0.1 (fast 2)
+$ s "bass3(5,8)"
+# note (scale "dorian" "<0 3 0 3> 2 <0 0 3 3>")
+# gain 0.8

live/techno/blade-piano.tidal

+setcps (-1)
+
+setcps (0.5)
+
+d1
+$ whenmod 64 32 (# silence)
+$ whenmod 32 16 (rev)
+$ chop "1 4"
+$ s "cs80leadMH*2"
+# note (scale "major" "<[0 3] [3 5] [5 7] [7 10]>")
+# gain 0.9
+
+d2
+$ whenmod 64 48 (# silence)
+$ fast 2
+$ every 4 (off 0.75 (|+ 0))
+$ off 0.5 (|+ 0)
+$ s "kicklinn"
+
+d3
+$ whenmod 64 48 (# gain 0)
+$ whenmod 64 8 (# gain 1)
+$ fast 2
+$ every 2 (off 0.25 (|+ 0))
+$ s "~ cp"
+# s "realclaps"
+# pan 0.4
+# gain 0
+
+d4
+$ someCyclesBy 0.2 (fast 2)
+$ s "[dr*4 <dr*4 [dr*4 ~]>]"
+# pan 0.2
+
+d6
+$ whenmod 31 24 (|+ note 0)
+$ whenmod 31 16 (|- note 7)
+$ whenmod 31 8 (|+ note 0)
+$ whenmod 31 0 (|+ note 7)
+$ someCyclesBy 0.2 (off (1/16) (|+ 0))
+$ someCycles (off (1/8) (|- 7))
+$ swing 4
+$ note (
+  3 * (-7) +
+  (scale "major" "[0, 3, 5]") +
+  "<0 5 7 12>")
+# s "cheapPiano1"
+# gain 0.8
+
+d5
+$ whenmod 16 14 (# velocity 0.5)
+$ whenmod 16 10 (stut 8 0.5 0.1)
+$ whenmod 16 8 (off 0.25 ((|+ note 7) . rev))
+$ whenmod 16 0 (off 0.25 ((|+ note 7)))
+$ someCyclesBy 0.2 (# release 0.2)
+$ off 0.125 ((# s "superpiano") . (|- note 7))
+$ s "superpiano"
+# note (scale "major" "<[0 3] [3 5] [5 7] [7 10]>" - 7)
+# pan 0.8
+# velocity 0.5

live/techno/delic_jazz.tidal

+-- Based on Parov's Psychedelic jazz
+setcps 0.46
+
+d1 -- beat
+$ whenmod 16 16 (|+ gain 0.2)
+$ whenmod 16 15 (|+ gain 0.2)
+$ whenmod 16 14 (|+ gain 0.2)
+$ whenmod 16 12 (|- gain 0.2)
+$ whenmod 16 10 (|- gain 0.2)
+$ whenmod 16 8 (|- gain 0.2)
+$ s "tech:5*4" # note (-4)
+# gain 1.3
+
+d2
+$ s "[~ hh ~ <hh [hh ~ hh]>]*2"
+$ every 4 (const $ "[~ [hh,hh:8] ~ [hh ~ hh]]*2" # gain 1.2)
+# gain 1.2
+
+d3
+$ s "bd sn bd <cp cp cp cp*2>"
+
+d4 -- main gauche
+-- $ whenmod 32 24 (|+ note 7)
+$ s "superpiano"
+# note "<-20 [-19,-15] [-20,-16] ~>"
+# velocity "<0.7 0.5 0.6>"
+# sustain 3
+# gain 1.2
+
+d5 -- main droite
+$ whenmod 64 48 (
+  const
+  $ slow 4
+  $ sometimesBy 0.3 (off 0.125 (|+ 0))
+  $ "[p p p ~] [~ p p p] [~ ~ [p p?] ~] [p p? p? p] [p]"
+  # s "superpiano"
+  # n "[7 5 4 ~] [~ 4 2 0] [~ ~ 0 ~] [-1 -1 -1 0] [-1]"
+  # gain 0.7
+  # velocity 1
+  # sustain 2
+)
+$ whenmod 32 16 (# gain 0.8)
+$ whenmod 32 0 (# gain 0)
+$ every 4 ((>| s "superpiano*16") . (# note "6 <2 5> <2 1>"))
+$ someCycles (# sustain 3)
+$ s "[p?*3] . ~ . [p*2] . ~ [p? p] . ~"
+# s "superpiano"
+# note "<1 [2,6] [1,5] ~>"
+# velocity 0.8
+
+d5 -- white noise
+$ someCycles (# silence)
+$ sometimes (jux rev)
+$ (# speed (rand / 2))
+$ s "glitch:2" -- # n (run 8)
+# cut 1
+# gain 1.2
+
+d6
+$ someCyclesBy 0.2 (# gain 1)
+$ slow 2
+$ s "[~ jazz:2]*8"
+# gain 0

live/techno/friday_tired.tidal

+setcps 1
+
+d1
+$ sometimes (# gain "<0 0.9> 1")
+$ fast 2
+$ s "kick_electro electro1"
+# note ("0 -10")
+# gain 0.9
+
+d2
+$ whenmod 32 16 (# gain 0.8)
+$ whenmod 32 15 (# gain 0.7)
+$ whenmod 32 14 (# gain 0.6)
+$ whenmod 32 0 (# gain 0)
+$ every 4 (off 0.25 (|+ 0))
+$ s "~ [cp sn:1]"
+
+d3 -- TODO: Better drums
+$ someCycles (# silence)
+$ someCycles (slow 2)
+$ s "<[dr*4 ~ dr*2] [dr*2 ~ dr*2 ~]>"
+
+d4 -- TODO: Better bass
+-- $ off 0.125 (|+ note 12)
+
+-- play one per cycle
+d4
+-- $ off 0.25 (|+ note 7)
+-- $ off 0.125 (|+ 0) 
+$ note "<0(3,8) 3 5 12*2>"
+# s "bass3:2"
+# sustain 4
+-- |- note 7
+
+d5 -- lead piano synthe
+$ whenmod 32 16 (rev)
+$ jux rev
+$ slow 2
+$ off 0.125 (|+ 12)
+$ note (off 0.125 (|+ 7) "<c(3,4) a*2 f(3,4,2) <e e a e>*2>")
+# s "defaultB"
+# gain 0.6
+
+d6 -- lead blade
+$ whenmod 32 28 (degrade)
+$ whenmod 32 16 (|- 7)
+$ someCycles (|+ note 7) . (chop 4)
+$ slow 2
+$ s "cs80leadMH"
+# note "<c a f e>"
+# gain 0.9

live/techno/phazer.tidal

+d1
+-- $ whenmod 128 100 ((# gain "<0.7 0 0.7 [0 0.7]>") . (# lpq "1"))
+-- $ whenmod 128 1 (# gain "<0.8 1 0.8 [0.8 0.8]>")
+$ whenmod 64 32 ((|- note 7) . chop "2 0")
+$ whenmod 64 1 (|+ note 7)
+$ someCyclesBy 0.1 (chop 2 . superimpose (rev))
+$ off (1/8) (|+ 7)
+$ off (3/16) (|- 7)
+$ someCyclesBy 1 (<|
+  note (scale "major" "<0*2 2(3,<4 8>) 7(3,<4 8>,2) <5 5 4>*2>"))
+$ note (scale "major" "<0 2 7 <5 5 4>*2>")
+# s "phazer"
+# gain 0.7
+
+solo 1
+
+d2
+-- $ every 4 (# gain "0 1")
+-- $ whenmod 32 28 (fix (# gain tri) (s "arp"))
+-- $ whenmod 32 0 (# gain "0.8 1")
+-- $ whenmod 32 9 (fix (# gain 1) (s "bd"))
+-- $ whenmod 32 8 (fix (# gain (1 - tri)) (s "bd"))
+-- $ whenmod 32 16 (someCycles (fix (# silence) (s "electro1")))
+$ s "bd [electro1:2, arp]"
+# note "0"
+# gain "1 1"
+
+d3
+$ someCycles (# silence)
+$ sometimes (# gain 0.8)
+$ fast 4
+$ s "electro1:4"
+
+d4
+$ every 4 (jux rev)
+$ sometimes (off 0.125 (|+ 0))
+$ s "~ electro1:2"
+
+d5
+-- $ whenmod 32 16 (someCycles (off (1/16) (|+ 0)))
+$ s "~ ~ ~ glitch:2"
+
+
+d6
+$ whenmod 16 12 (# n 0)
+$ whenmod 16 0 (# n 1)
+$ note "c(5,8) a*2 f? <e e e c>(3,4)"
+# s "bass"

live/val.tidal

@@ -9,7 +9,7 @@ let a = "maj"
 d2 $
 superimpose (rev . (slow 2) . (|-| note 24)) $
 somecyclesBy 0.8 (fast 2) $ somecycles (slow 2) $
-s "superpiano" # note (scale a (irand 12))
+s "superpiano" # note (scale "aeolian" (irand 12))
 # velocity (0.5 + rand / 2)
 # sustain sine
 

study/anticipate.tidal

+-- scale function
+let major = scale "major"
+
+-- Begin / end
+-- cheeky bastard
+d1 $ s "bogdan:7*4" # begin 0.2 # end 0.5
+
+-- shape produces wave shaping distortion?
+once $ s "bogdan:6" # shape "0.5" # gain 0.6
+
+-- TODO: Use within to apply an effect to only a part of a pattern!
+-- TODO: Use fix to fix a specific kind of sample!
+--The fix function applies another function to matching events in a pattern of controls.
+-- For example:
+
+d1 $ slow 2 $ fix (# crush 3) (n "[1,4]") $ n "0 1 2 3 4 5 6" # sound "arpy"
+
+-- Anticipation: TODO
+setcps 1
+
+anticipate 3 silence
+
+xfadeIn 1 4 $ silence
+
+d1 $ sound "jvbass(3,8)"
+
+anticipate 1 $ sound "bd sn" # delay "0.5" # room "0.3"
+
+
+-- TODO: weave to spread a control pattern over a list, successively offset
+d1 $ weave 16 (pan sine)
+  [sound "bd sn cp",
+   sound "casio casio:1",
+   sound "[jvbass*2 jvbass:2]/2",
+   sound "hc*4"
+  ]
+
+
+
+d2 $ s "cp"
+
+-- TODO: ur pattern  of pattern
+-- Lets say you had three patterns (called 'a', 'b' and 'c'), and that you wanted to play them four cycles each, over twelve cycles in total. Here is one way to do it:
+--
+-- let pats =
+--       [
+--         ("a", stack [n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
+--                      n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
+--                     ]
+--         ),
+--         ("b", stack [n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
+--                      n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
+--                     ]
+--         ),
+--         ("c", stack [n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
+--                      n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
+--                     ]
+--         )
+--       ]
+-- in
+-- d1 $ ur 12 "a b c" pats []
+--
+-- In ur 12 "a b c" pats [], the 12 is the duration of the loop (in cycles), the "a b c" is the structure of named patterns, and pats is the lookup table, defined above. So the "a b c" pattern happens over the 12 cycles, with the a, b and c standing in for each of the three patterns given in the lookup table. Because there are three events in this pattern, and it happens over 12 cycles. then each event is four cycles long.
+--
+-- In the above, the fourth parameter is given as an empty list, but that is where you can put another lookup table, of functions rather than patterns this time. Here's an example:
+--
+-- let pats =
+--       [
+--         ("a", stack [n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
+--                      n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
+--                     ]
+--         ),
+--         ("b", stack [n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
+--                      n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
+--                     ]
+--         ),
+--         ("c", stack [n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
+--                      n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
+--                     ]
+--         )
+--       ]
+--     fx = [("reverse", (# (room 0.8 # sz 0.99 # orbit 1))),
+--           ("faster", fast 2)
+--          ]
+-- in
+-- d1 $ ur 12 "a b:reverb c:faster" pats fx
+--
+-- In the above, b has the function applied that's named as reverb, while c is made to go faster.
+--
+-- It's also possible to schedule multiple patterns at once, like in the following:
+--
+-- let pats = [("drums", s "drum clap*2"),
+--             ("melody", s "arpy:2 arpy:3 arpy:5"),
+--             ("craziness", s "clap:4*8" # speed ( sine + 0.5))
+--            ]
+--     fx = [("higher", (# speed 2))]
+-- in
+-- d1 $ ur 8 "[drums, melody] [drums,craziness,melody] melody:higher" pats fx

study/control.tidal

+-- See https://tidalcycles.org/index.php/Category:Control_Functions

study/piano.tidal

+setcps 1
+
+let scale = getScale (scaleTable ++ [("blues", [0, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12])])
+
+d1 $ s "dr(<2 2 2 4>,4)"
+# gain 0.8
+
+d2
+$ every 8 (# n "0 [7|1]>")
+$ every 4 (off 0.125 (|> 8))
+$ every 4 degrade
+$ every' 4 2 (# n 8)
+$ s "[hh [hh hh] ~]"
+# gain 0.6
+# pan 0.8
+
+d3
+$ someCycles (fast 2 . degradeBy 0.6 . (# gain 0.4))
+$ s "sn(<<1 3> 3>,8)"
+# n (choose [1,2,3])
+# gain 0.5
+# pan 0.2
+
+d4
+-- TODO: Now with blues scale, off/superimpose sounds bad. FIX!
+-- $ someCycles (degradeBy 0.2)
+-- $ superimpose ((slow 2) . (|-| note (0)))
+-- $ often ((|+| note 7) . (# velocity 0.5) . (fast 2))
+-- $ always (superimpose (|-| note 7) . (# velocity 0.4))
+-- $ superimpose ((fast 2) . (|-| note 14))
+$ s "superpiano*2"
+# note (scale "blues" ("<0 <3 3 2 3> 6 <10 8 8 10>>"))
+-- # note (scale "blues" ("<0 3 6 10>")) -- 1
+-- # note (scale "blues" ("<0 3 6 8>")) -- 2
+-- # note (scale "blues" ("<0 2 6 8>")) -- 3
+-- # note (scale "blues" ("<0 3 6 10>")) -- 4
+# velocity (0.6 + rand / 4)
+# sustain sine
+
+d3
+$ slow 2
+$ s "superpiano*12"
+# note (scale "blues" "0 .. 12")
+# velocity (0.5 + rand / 4)
+
+d1 $
+superimpose (rev . (slow 2) . (|-| note 24)) $
+somecyclesBy 0.8 (fast 2) $ somecycles (slow 2) $
+s "superpiano" # note (scale "aeolian" (irand 12))
+# velocity (0.5 + rand / 2)
+# sustain sine

study/randomness.tidal

+-- See https://tidalcycles.org/index.php/Category:Randomness_and_chance

study/santa.tidal

+d1 $ s "everythingrhodes"
+
+
+d3 $ s "~ cp"
+
+d1
+$ whenmod 32 16 rev
+$ note "0 3 5 7 <10 12>"
+# s "FMRhodes1*4"
+
+
+d2 $ s "[~ kick808]*2"
+
+d1
+$ s "cs80leadMH/8"
+# up 1
+# gain 0.8
+
+d1
+$ every 4 (degrade)
+$ s "<<c*2> <c*2 [c c*2]>>"
+# s "cymbal808"
+
+
+d2 -- lead blips
+$ someCycles (off 0.125 (rev))
+$ someCycles (off 0.125 (# gain 0.7))
+$ s "acidOto3092(<2 3>,8)"
+# note "<3 0 5> <0 7 5 0>"
+# gain 0.8
+
+d3
+-- $ whenmod 32 16 degrade
+-- $ always (off 0 (|- 12))
+-- $ always (off 0.125 (|+ 12))
+$ slow 2
+$ note ("0 <4 4 7 4> <7 7 4 7> <12 10 10 12>" - 12)
+# s "defaultB"
+# gain 0.7
+
+d1
+$ every' 4 0 (fast 2)
+$ every' 4 1 (fast 2)
+$ s "reverbkick"
+# gain 0.7
+
+d3
+$ s "<h h*2 ~> <h*2 h [~ h]>"
+# s "blueNoise"
+# gain 0.7

study/synths.tidal

+-- https://tidalcycles.org/index.php/Tutorial#Synths

study/time.tidal

+-- https://tidalcycles.org/index.php/Category:Time_Functions

study/transitions.tidal

+-- https://tidalcycles.org/index.php/Category:Transitions
+
+-- https://tidalcycles.org/index.php/Tutorial#Transitions_Between_Patterns
+
+-- https://tidalcycles.org/index.php/Quick_example_for_transition