Skip to content

T
Tidal
Unverified Commit 74e089ce by PLN (Algolia)
Options

update: from persistent_moog to funky beats

parent 5504f5d4
Showing with 2136 additions and 284 deletions
blocks/kicks.tidal
d8 -- macron gabber enGuerre
$ n "0(<3 <[3|5] [3|5|5] 5>>,8)"
# octer 2 # octersub 5 # octersubsub 2
# octer 0.5 # octersub 10 # octersubsub 12
# s "macron:0" # begin 0.5
# gain 0.8
blocks/once.tidal
......@@ -4,8 +4,13 @@
d1 -- snare rush
-- $ degradeBy "<0 [0 0.75 0.5 0.25]>"
$ fast (snowball 8 (+) (* 2) $ 2) $ s "sn:1"
# gain 0.6
# gain 0.8
d1 $ note (scale "minor" $ snowball 4 (+) (slow 2) $ (run 3))
d1
$ rev
$ note (
scale "minor"
$ snowball 1 (+) (slow 2) $
(run 3))
# sound "gtr"
# gain 0.7
# gain 0.9
live/chill/atm/batteur.tidal
......@@ -3,10 +3,10 @@ unmute 6
do
setcps 0.3
d1 $ s "k . ~ [<~ k> <~ k?>]" # s "reverbkick" # gain 0.35 # lpf 400
d2 $ s "~ snare:1" # gain 0.5 # delay 0.5
d3 $ often (stut 4 0.76 0.125) $ fast 4 $ s "~ . drum:8" # gain 0.5
d4 $ s "[ho(3,8),[~ ~ hc:2*[1|2|3|4] ~]]" # cut 4 # gain "0.5 0.6"
d1 $ s "k . ~ [<~ k> <~ k?>]" # s "reverbkick" # gain 0.5 # lpf 400
d2 $ s "~ snare:1" # gain 0.75 # delay 0.5
d3 $ often (stut 4 0.76 0.125) $ fast 4 $ s "~ . drum:8" # gain 0.8
d4 $ s "[ho(3,8),[~ ~ hc:2*[1|2|3|4] ~]]" # cut 4 # gain "0.75 0.86"
d5
$ whenmod 32 16 ( -- folie aigue
juxBy 0.25 ((0.125 ~>) . rev . fast 4 . (|+ note 12))
......@@ -14,7 +14,7 @@ do
$ off 0.25 (slow 2 . arp "updown")
$ note ("<d4'maj7 <d4'maj7 d5'maj7> d4'min7 d4'maj7>")
# s "superpiano"
# velocity (slow 100 $ range 0.2 0.34 sine)
# velocity (slow 100 $ range 0.42 0.54 sine)
# pan 0.7
d6
$ note ("d3"
......@@ -23,7 +23,7 @@ do
# s "supersaw" # voice 0.1
# release "2 0.8!7"
# gain (slow 88 $ range 0.25 0.5 cosine)
d7 $ s "hh(<1 3 5>,8)" # cut 7 # gain 0.6 # pan 0.2
d7 $ s "hh(<1 3 5>,8)" # cut 7 # gain 0.76 # pan 0.2
-- Intro atm
......
live/chill/atm/break_blue.tidal
-- BreakBlue: Breakbit nocturnal piano instrumental
-- Tags: Hip-Hop, piano, energique
-- Ready: 4/10
setcps (60/60/4)
......@@ -17,119 +20,45 @@ do
unsolo 6 -- Clap
solo 8 -- Maracas
do
setcps 0.4
let scale = getScale (scaleTable ++ [("blues", [0, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12])])
let gKick = 0.6
let gBreak = 0.47
let gBass = 0.7
let gClap = 0.7
let gMaracas = 1
let vPianoMin = 0.2
let vPianoGauche = 0.4
let vPiano = 0.5
d1
$ superimpose (const -- THE BEAT
$ slow 4 -- l'attente
$ s "k*1"
# s "jazz"
# lpf 50
# gain gKick
)
-- $ whenmod 64 32 (# gain 0)
$ loopAt 2
$ slice 8 (
whenmod 8 6 (|> "6!7 7")
"0 1*2 2 3 4*[1|2|4] 5 <6!3 7> 7"
)
$ s "break"
# gain 0.5
d3 -- Bassline
$ note (scale "blues"
("0. 2(3,8)")
- 24)
# s "supersaw"
# voice 0.05
# sustain "0.75 . 0.25 0.5"
# gain gBass
# hpf (slow 64 $ range 0 2500 sine)
d4 -- Piano aigu fou
$ mask "t(<1!4 2!4 4!24>,4)"
$ whenmod 32 16 (often (off 0.125 (|+ note "[0,7]")))
$ whenmod 4 3 (often (fast 2))
$ n "0*16"
# note (scale "blues" (
"<0!2 [0 1] 0!2 [0 -1 -4]>"
)
+ 24)
# s "superpiano"
# velocity (slow 64 $ range vPianoMin vPiano sine)
d5 -- Accords main gauche
$ stut' 4 (1/16) ((|+ 0). (|- velocity 0.05))
$ note (scale "blues" "[0,<3 2 1 3 2 5 1 1 3 1 0 ~>]")
# s "superpiano"
# velocity (vPianoGauche)
# sustain 2
d8 -- maracas hombre
$ whenmod 6 4 (fast 2)
$ s "m(<3 5>,8)" # speed "[0.8|0.86|0.92]"
# s "drum:3"
# room 0.2 # sz 0.4 # dry (slow 100 $ range 0 5 sine)
# gain gMaracas
d6
-- $ fast 2
$ s "~ clap:1"
# speed (slow 42 $ range 0.9 1.2 isaw)
# gain gClap
-- V1: Bleu casse
do
setcps 0.4
let scale = getScale (scaleTable ++ [("blues", [0, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12])])
let gKick = 0.65
let gBreak = 0.45
let gBass = 0.5
let gKick = 0.8
let gBreak = 0.47
let gBass = 0.7
let gClap = 0.7
let gMaracas = 0.8
let vPianoMin = 0.35
let gMaracas = 1
let vPianoMin = 0.2
let vPianoGauche = 0.4
let vPiano = 0.5
d1
$ superimpose (const -- THE BEAT
$ slow 4 -- l'attente
$ s "k*0"
-- $ slow 4 -- l'attente
$ s "k"
# s "jazz"
# lpf 50
# lpf 1500
# gain gKick
)
-- $ whenmod 64 32 (# gain 0)
$ loopAt 2
$ slice 8 (
whenmod 32 28 (|> "0*4 1!2 7 6 8 ~ 8")
$ whenmod 32 24 (|> "0 1 2!6")
$ whenmod 16 15 (|> "0!6 [8 7]")
$ whenmod 16 12 (|> "0 1 2 3*5")
"0 <1 2> <2 1> 3 4*<1!4 2!4 4!24> [5 5?] 6*<1 2 4> <7!3 6>"
whenmod 8 6 (|> "6!7 7")
"0 1*2 2 3 4*[1|2|4] 5 <6!3 7> 7"
)
$ s "break"
# gain gBreak
# gain 0.65
d3 -- Bassline
$ note (scale "aeolian" (run 8)
$ fast 2
$ note (scale "blues"
("<0!5 4 5 4> . 2(<3!3 5>,8)")
- 24)
# s "supersaw" # voice 0.01
# s "supersaw"
# voice 0.05
# sustain "0.75 . 0.25 0.5"
# gain gBass
-- # hpf (slow 64 $ range 0 2500 sine)
# hpf (slow 64 $ range 0 1000 sine)
d4 -- Piano aigu fou
$ mask "t(<1!4 2!4 4!24>,4)"
$ mask "t(<1!4 2!4 4!24>,12)"
$ whenmod 32 16 (often (off 0.125 (|+ note "[0,7]")))
$ whenmod 4 3 (often (fast 2))
$ n "0*16"
......@@ -139,6 +68,7 @@ do
+ 24)
# s "superpiano"
# velocity (slow 64 $ range vPianoMin vPiano sine)
d5 -- Accords main gauche
$ stut' 4 (1/16) ((|+ 0). (|- velocity 0.05))
$ note (scale "blues" "[0,<3 2 1 3 2 5 1 1 3 1 0 ~>]")
......@@ -158,6 +88,80 @@ do
# gain gClap
-- V1: Bleu casse
do
let scale = getScale (scaleTable ++ [("blues", [0, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12])])
let gKick = 0.65
let gBreak = 0.45
let gBass = 0.5
let gClap = 0.7
let gMaracas = 0.8
let vPianoMin = 0.35
let vPianoGauche = 0.4
let vPiano = 0.5
d1
$ superimpose (const -- THE BEAT
$ slow 4 -- l'attente
$ s "k*0"
# s "jazz"
# lpf 50
# gain gKick
)
-- $ whenmod 64 32 (# gain 0)
$ loopAt 2
$ slice 8 (
whenmod 32 28 (|> "0*4 1!2 7 6 8 ~ 8")
$ whenmod 32 24 (|> "0 1 2!6")
$ whenmod 16 15 (|> "0!6 [8 7]")
$ whenmod 16 12 (|> "0 1 2 3*5")
"0 <1 2> <2 1> 3 4*<1!4 2!4 4!24> [5 5?] 6*<1 2 4> <7!3 6>"
)
$ s "break"
# gain gBreak
d3 -- Bassline
$ note (scale "aeolian" (run 8)
- 24)
# s "supersaw" # voice 0.01
# sustain "0.75 . 0.25 0.5"
# gain gBass
-- # hpf (slow 64 $ range 0 2500 sine)
d4 -- Piano aigu fou
$ mask "t(<1!4 2!4 4!24>,4)"
$ whenmod 32 16 (often (off 0.125 (|+ note "[0,7]")))
$ whenmod 4 3 (often (fast 2))
$ n "0*16"
# note (scale "blues" (
"<0!2 [0 1] 0!2 [0 -1 -4]>"
)
+ 24)
# s "superpiano"
# velocity (slow 64 $ range vPianoMin vPiano sine)
d5 -- Accords main gauche
$ stut' 4 (1/16) ((|+ 0). (|- velocity 0.05))
$ note (scale "blues" "[0,<3 2 1 3 2 5 1 1 3 1 0 ~>]")
# s "superpiano"
# velocity (vPianoGauche)
# sustain 2
d8 -- maracas hombre
$ whenmod 6 4 (fast 2)
$ s "m(<3 5>,8)" # speed "[0.8|0.86|0.92]"
# s "drum:3"
# room 0.2 # sz 0.4 # dry (slow 100 $ range 0 5 sine)
# gain gMaracas
d6
-- $ fast 2
$ s "~ clap:1"
# speed (slow 42 $ range 0.9 1.2 isaw)
# gain gClap
once $ s "hh:9" # gain 1
d3
......
live/chill/atm/nightly.tidal 0 → 100644
do
setcps 0.4
d1
$ fast "<4!12 1!3 2>"
$ "jazz" # gain 0
d2 $ "~ c ~ ~" # "cp" # gain 0.9
d3 $ fast ("<1 2 4>" * 2) $ "drum:8" # gain 0.9
d5 $ n "0*8"
# note ("<4!2 0!2> <2 4> <0 4>")
# "hh"
# gain 0.8
d4 -- Moog dark
$ juxBy 0.75 (often rev . (# n 2) . (|- note 24))
$ scramble "[2|4]"
$ note (scale "aeolian" (run 8))
# "moog:1"
# gain 0.75
# cut 4
d7 -- Synth Metronome bip hopital
$ n ("c4 <f3 ff3 d3 <f3 c4>>")
# "rash"
# gain 0.5
live/chill/break/responsabilite.tidal 0 → 100644
-- Responsabilité: Breakbeat pas prise de tête
-- Tags: Hip-Hop, breaks, bass, hypnotique, instrumental
-- Ready: 5/10 (Melody=, Variations=, Parts=)
resetCycles
-- region Responsabilite
do
solo 4
setcps 0.5
d1
$ whenmod 16 10 (# hpf 6000)
$ loopAt 4
$ slice 4 (
whenmod 8 6 (|> "0")
"[0 <1 0> <0 2> <3 0 0*2 3*2>]")
$ "break" # gain 0.65
d3
$ rarely (jux rev)
$ n ("0(<4!2 5!2 8 [8 16] 8 [16 8]>,8)")
# note (scale "major" "0 0 -1 2")
# "dr:13"
# gain (slow 64 $ range 0.5 0.85 saw)
d4
-- $ mask "t(<1 2 3 4 1!4 4!4>,4)"
$ slice 4 "<0 .. 3> <3 .. 0>"
$ "bsbass:4"
# cut 3
# hpf (slow 4 $ range 50 500 sine) -- TODO superimpose?
# gain (slow 16 $ range 0.4 0.6 perlin)
d8 -- Falling coins
$ someCycles (# speed 0.5)
$ off (1/16) (|+ note (slow 4 "<[2|4] [0 -2]>"))
$ s "coins(<3!3 <5 8>>,8)"
# note (scale "aeolian" (irand 7))
# gain (slow 80 $ range 0.4 0.7 (sine + perlin/8))
d9 -- Orchestra hit
$ degradeBy "<1!3 0.5>"
$ "~ ~ brass:1 ~"
# note ("<0!4 -4!2 2 4>")
# release 0.85 # attack 5
# lpf (slow 16 $ range 20000 2000 saw)
# gain 0.65
# room 0.8
# size 0.8
# dry 2
-- endregion
-- region IRRESPONSABLE
-- IrResponsabilité: Du Breakbeat à la break-tech
-- Tags: Tech-Hop, breaks, bass, hypnotique, instrumental
-- Ready: ?/10 (Melody=, Variations=, Parts=)
resetCycles
do
setcps 0.5
d1
$ every' 4 3 (someCycles (# hpf 500))
$ whenmod 32 16 (mask "<[f t?]!8 f!7 t>")
$ superimpose (
const -- Kick
-- $ sometimesBy -- décalage
-- "0 <0!3 0.5> 0 <0 1>" ("e" ~>)
-- $ superimpose ((# "clubkick:5") . (# hpf 500))
$ "k k k <k!3 <~ [~ k] k*2>>"
# "kick:5"
# gain 0.5
)
$ loopAt 4
$ "break"
# gain 0.5
d3
$ rarely (jux rev)
$ n ("0(<4!2 5!2 8 [8 16] 8 [16 8]>,8)")
# note (scale "major" "0 0 -1 2")
# "dr:13"
# gain (slow 64 $ range 0.5 0.85 saw)
d4
-- $ mask "t(<1 2 3 4 1!4 4!4>,4)"
$ superimpose ( -- Attente
fast 2 . (|* 0.75) . (# hpf 0)
)
$ slice 4 "<0 .. 3> <3 .. 0>"
$ "bsbass:4"
# cut 3
# hpf (slow 4 $ range 1500 500 sine)
# gain (slow 16 $ range 0.4 0.6 perlin)
d8 -- Falling coins
$ someCycles (# speed 0.5)
$ off (1/16) (|+ note (slow 4 "<[2|4] [0 -2]>"))
$ s "coins(<3!3 <5 8>>,8)"
# note (scale "aeolian" (irand 7))
# gain (slow 80 $ range 0.4 0.7 (sine + perlin/8
live/chill/break_toys.tidal
-- Break Toys: Breakbeat + random toys/noise
-- Tags:
-- Ready: 5/10
do
unsolo 1 -- kick
unsolo 2 -- snares pistols
......@@ -63,3 +64,22 @@ do
d6 -- Glitchs randomises carres
$ often (stut' "[4|8]" 0.125 ((# crush 8) . (|* gain 0.9)))
$ s "~ glitch" # n (irand 8) # gain 0.7
-- SANDBOX
-- Scramblebeat:
do
d1 $ loopAt 4 $ shuffle 4 $ s "break" # gain 0.7
d2
$ superimpose (
every' 2 1 (off 0.5 (|+ note "[0|12]")
. whenmod 4 2 (off 0.125 id) -- Souvent double
. (|+ note 24) -- Aigu
. mask "t(1,4)" -- Base
)
)
$ degradeBy "0 0.25 0.5 0.75"
$ arpeggiate
$ note ("<c3'six!3 d3'six f3'six g3'six>")
# s "superpiano"
# velocity 0.45
live/chill/cloudy_afternoon.tidal
-- Cloudy afternoon: Piano dans l'espace
-- Tags: spacial, attente, echos
setcps 1
d1 -- Kick régulo-varié
d1 -- Kick techno rotatif régulo-varié
$ someCycles (degradeBy 0.2)
$ whenmod 32 24 (# silence) -- stop periodique
$ every 4 ( -- 4eme temps, decalage plus echo
$ every' 4 3 ( -- 4eme temps, decalage plus echo
someCyclesBy 0.25 ((0.25 ~>) . (stut 2 0.5 0.25))
)
$ s "kick:11*2"
# pan (slow 16 $ sine)
$ s "kick:11"
# pan (slow 16 $ range 0.4 0.6 sine)
# gain 0.8
d2 -- hh la résistance danse
$ s "~ <b> . b . <b> ~ . b"
# s "bshihat" # n "0|1"
$ s "~ b . b . b ~ . b"
# s "bshihat" # n "[0|1]"
# gain (slow 64 $ sine * 0.7 + 0.6)
# room (slow 64 $ 0.205 - sine * 0.2) # size 0.8
# gain (slow 16 $ sine * 0.5 + 0.4)
......@@ -25,19 +29,6 @@ $ n "<0 [0|1]>"
# s "bsperc"
# gain 0.65
d4 $ silence
d4
$ every 4 (someCycles (rev))
$ superimpose ((|+ note "<5 7 5 5 0 7 <0 5> <0 5>>"))
$ superimpose (rev . (|- note 12))
$ note (scale "major" "0 1 2 7")
# s "bassWarsaw"
-- # release (0.9)
# release (slow 16 $ sine * 0.8 + 0.2)
-- # attack (0.75 + rand / 4)
|- note 24
# gain 0.9
d5 -- piano spatial
$ whenmod 24 22 (|+ note 7)
......@@ -51,13 +42,13 @@ $ s "bsperc:2(3,8)"
# room 0.2 # size (slow 8 $ sine * 0.2 + 0.5)
# gain 0.6
d5 -- Carillons
d6 -- Carillons
$ someCycles (0.5 ~>)
$ s "hh?(<4 4 4 2>,4) ~" # n "8 8 8 <8 8 8 9> 3"
# gain (slow 16 $ sine * 0.5 + 0.4)
d7 --
d7 -- Vocals
$ whenmod 32 16 (# gain 0.8)
$ s "[~ bsvocals]/4"
# n "<2? 2? <3 3 3 [3|12]>? 2>"
......
live/chill/dub/mini_deconf.tidal
......@@ -3,7 +3,7 @@ do
setcps (60/60/2)
d1 -- Kick techno (mask 4) / trance (mask 12)
-- TODO: at 12, not really transe yet
$ mask "t(11,12)"
-- $ mask "t(11,12)"
$ whenmod 64 32 (|> n "[0 0 <0 ~>]*4")
$ s "k!3 . k <k ~> k . k!3 . k k <k!4 ~ ~ k k ~ k>"
# s "jazz"
......@@ -16,7 +16,7 @@ do
# pan ("<0.5!3 [0.25|0.75]*1>")
# lpf ((slow 19 $ range 2 20 sine) * 1000)
d3 -- Bassline
-- $ superimpose (fast 2 . (# crush 6))
$ superimpose (fast 2 . (# crush 6))
$ note (
slowcat [
"0 3 5 ~ <~ 5> <5 ~> 5 ~",
......
live/chill/powder_asmr.tidal
setcps 0.5
d4
-- $ someCycles (# silence)
$ someCyclesBy 1 (# room 0.2) . (# gain 0.5))
$ superimpose (rev . chop 16)
$ s "nass:1"
# gain 0.5
do
d1 $ "dr"
d4
$ someCycles (# silence)
$ someCyclesBy 1 ((# room 0.2) . (# gain 0.5))
$ superimpose (rev . chop 16)
$ s "nass:1"
# gain 0.9
d2 -- Vents mélodiques
$ whenmod 32 24 (juxBy 0.75 rev)
$ whenmod 32 16 (rev)
$ superimpose (|+ note "c'maj")
$ n (run 10) # "wind"
# speed (range 1 0.25 perlin)
# gain (range 0.4 0.6 perlin)
d2 $ s "wind"
d3 -- Mer
$ often (off 1 (# crush 5))
$ "seawolf/4" # n (irand 3) # gain 0.7
live/fusion/bottled_baby.tidal 0 → 100644
do
let gKick = 0.65
let gSnare = 0.6
let gDrums = 0.8
let gHats = 0.57
let vPiano = 0.35
let gCloches = 0.7
let gBass = 0.5
let gBrass = 0.5
setcps 0.45
solo 1 -- Kick
solo 2 -- Snare
solo 3 -- Drumroll
solo 4 -- Piano
solo 5 -- Bass
solo 6 -- Hats
solo 7 -- Cloches
solo 8 -- Brass
d1
$ whenmod 16 14 (slow "<2 [1 0.5]>")
$ whenmod 32 24 ( -- Pont solo basse
degradeBy "1!7 [1 . 1 0]"
)
$ s "k k k k*[1|2]"
# s "jazz" # hpf 100 # gain gKick
d2 -- Snares decroissants
$ whenmod 32 24 ( -- Pont solo basse
# silence)
$ often ( -- Echos filtre decroissant
stut' 4 0.125 (|* lpf 0.8)
)
$ fast "<1!7 [2 4]>"
$ s "~ snare:20"
# lpf 5000
# gain gSnare
d3
-- $ whenmod 32 24 ( -- Pont solo basse
-- # silence)
$ fast "8 <8!4 [8 16]!4> <8!8 16!8> [8 16]"
$ s "drum:8"
# gain gDrums
d4
$ whenmod 32 24 ( -- Pont solo basse
|+ gain "<0.1 0.2 0 -0.1 -0.2!4>"
)
$ (0.25 ~>)
$ off 0.125 (# lpf 250)
$ note (
"<f4'maj!3 f4'min f4'min!3 f4'maj>"
)
# s "superpiano"
# velocity vPiano
d5 -- Bassline
$ mask "t([1|2|4],8)"
$ superimpose -- Accélération 8-bit!
(fast 2 . (# crush 6))
$ note (
slowcat [
"0 3 5 ~ <~ 5> <5 ~> 5 ~",
"<5 ~> <~ 5> 5 5 <3!3 8> ~ <3!7 7> ~"
]
)
|- note 24
# s "supersaw"
# voice 0.2
# sustain "0.25!2 0.5 0.25"
# pan 0.6
# gain gBass
d6 -- Hats open-closing
$ s "ho(<1!3 2>,2) hc:2*<1!4 2!4 4!4 8!4>"
# n "[0|1] 3"
# cut 6
# gain gHats
d7 -- Accelerating Bells
$ superimpose (slow 2 . arp "<updown!3 downup>")
$ someCyclesBy "<0!8 0.5!4 0.75!4>" (fast 2)
$ note ("0(1,8)"
+ "<f3'min!3 f3'maj>"
)
# sustain 1
# s "superfork"
# gain gCloches
d8 -- Brass lancinant
$ whenmod 128 64 (# gain gBrass)
$ whenmod 32 24 (# note "<0!3 7>")
$ whenmod 64 32 (off 0.25 (# begin 0.75))
$ note ("~!7 <0!4 2 3 5 7>")
# begin 0.5
# room 0.6 # sz 0.8
# s "brass:6" # gain 0
once $ s "brass"
# n 6
# note
# begin 0.5
# gain 0.7
-- # speed 1.2
# cut 10
live/fusion/drunk_beat.tidal 0 → 100644
do
solo 1
solo 2
solo 3
solo 4
d1
$ whenmod 16 12 (mask "t(<0!2 1!2>,2)")
$ s "k . k(<3 1 2 3>,8)" # s "reverbkick"
# lpf 200 # gain 0.6
d2 -- Drumroll
$ every 4 (fast 2)
$ fast ("<1!3 2>" * 4)
$ s "drum:8" # gain 1.1
d3
$ superimpose (
off 0.125 (ply 2)
. fast 2
. (|+ 24)
)
$ note "<f4'maj f4'min f3'min f4'maj>"
# s "superpiano"
# velocity (slow 16 $ range 0.35 0.4 sine)
# gain (slow 64 $ range 0.5 1 saw)
d4 $ arp "pinkyup downup" $ note ("f2'maj")
# s "supersaw" # voice 0.3 # gain 0.4
do
setcps 0.5
d1 $ note "0 0 0 <0!3 <~ [~ 0]>>" # s "jazz" # gain 0.9
d2
$ every 4 (off 0.125 id)
$ whenmod 16 8 (fast 2)
$ s "~ cp" # lpf 4000
# gain 0.95
d3
$ every 8 (ply 2)
$ s "dr*<8!3 16>"
# gain (slow 16 $ range 0.7 1 perlin)
d4
$ whenmod 32 16 (mask "t(<1!8 3!4 4!4>,4)")
$ note (scale "aeolian" (
sometimes (7 -)
"0 ~ [4 <5 7> ~]"
) - 36)
# s "supersaw"
# voice 0.01
# gain 0.8
d7 -- synthe echos electrique
$ superimpose (
(# s "supercomparator") .
(# voice (slow 64 $ sine * 8)) . (|- note 12)
)
$ whenmod 16 8 (sometimes (juxBy 0.4 (|+ note 12))) -- jux eclairs!
$ degradeBy "<1 1 1 0> <[1 1 1 0] [1 0] 0>"
$ n "0*16"
# voice 0.1
# s "supersquare"
# note (scale "aeolian"
"<0 0 0 0 2 2 4 -2>")
# gain 0.55
live/fusion/faites_de_la_musique.tidal 0 → 100644
-- region Init
do
d1
$ whenmod 8 6 (mask "<f [f . f t]>")
$
-- "<k [~ k]> . k(<1 3>,8)" -- Attente hip
"k k k <k k? k [k? k]>" -- Techno
# "[jazz,cpu2,cpu2:1]"
d2
$ fast "<1!4 2!2 4 8>"
$ sometimesBy "0 0.5" (stut 4 0.75 "e")
$ "~ cpu2:2" # gain 0.7
# pan 0.7
d3
$ whenmod 16 8 (degradeBy "0 0.2 0.5 <0.75 0>")
$ fast "8 <16!3 <[8 4] [8 16]>>"
$ "dr:21"
# pan (slow 16 "<0.8 0.2>")
# gain (slow 32 $ range 0.4 0.8 saw)
d4
$ juxBy 0.25 rev
$ whenmod 4 2 (off "q" (|+ note 12) . (|* gain 0.8))
$ note (scale "lydian"
(slow 2 "[<c'maj!3 c'min>](3,8) ~ f*4 e*2")
)
# octave 3
# pan 0.3
# "supersaw" # voice 0.01
# gain 0.55
d6
$ swing 2
$ arp "up"
$ off "e" (|* gain 0.7)
$ note (scale "lydian" (
slow 2 "[<c'maj!3 e'maj>] ~ f*2 <e'maj!3 c'maj>*2"
))
# "superfork"
# octave 3
# legato 2
# gain 0.8
d7 $ "~ cp"
d5 -- Orchestra winds
$ every' 4 3 (jux rev)
$ whenmod 32 16 (|* gain (slow 2 "<1.1 0.9 0.8 0.7>"))
$ off "q" (|+ note 12)
$ off "e" (|+ note (slow 4 $ "<4 7>"))
$ "~ ~ brass:1 ~"
# note ("<c6'maj f6'maj f6'min f6'maj>")
# gain 0.75
# room 0.5
# size 0.2
# legato 2
# lpf (slow 64 $ range 200 500 sine)
-- endregion
-- region Techno-FONK
resetCycles
do
let mHats = "[<t t? [f|f|t] t>*2]"
let mBass = "<t t f t>"
let mGuitar = "<f t f t>"
setcps (104/60/4)
d1
$ euclid "<1!8 2!4 3!3 4 4!8 5!4>" 8
$ "[jazz,cpu2]" # gain 0.5
# lpf 5000
d2 -- Hats en mouvements
$ mask (slow 8 $ mHats)
$ ply "1 . 2"
$ loopAt 2
$ slice 4 "0 1 2 <3 [~ 3]>"
$ "break:7"
# gain (slow 16 $ range 0.35 0.55 saw)
# panbd (segment 8 $ range 0.2 0.8 perlin)
d4 -- Bass hypnotique
$ mask (slow 8 $ mBass)
$ bite 4 ("<3 0> <1 3> 2 3")
$ s "fbass:<2!3 1>"
# cut 2 # gain 0.65
d5 -- Guitare résolue
$ juxBy 0.8 id
$ whenmod 8 6 (sometimesBy "0 0.9" (# silence))
$ mask (slow 4 $ mGuitar)
$ bite 4 "0*2 <3!3 2>*4"
$ n "[<5!3 6>,~ . <4 7>]"
# "fguitar"
# cut 2
# gain 0.5
# pan (range 0.6 0.8 perlin)
d6 -- Claps!
$ whenmod 32 8 (# gain 0.55)
$ someCyclesBy "<0!3 0.9>" (stut 3 0.75 "[e|s]")
$ "~ ~ ~ clap"
# pan "0.3 0.7"
# gain 0
d7 -- Ready?
$ whenmod 16 12 (slice 2 "[0*4, 1*2]")
$ "rave"
# cut 7
# gain "<0!12 0.45!4>"
-- endregion
-- region Beat-FunkaLesson
once $ "reverbkick" # gain 0.8
setcps 0.5
-- This all works nicely with chopped-up loops:
do
unsolo 1 -- Kick
unsolo 2 -- Breakbeat
unsolo 3 -- Drumroll
unsolo 4 -- Bass
unsolo 5 -- Guitar
setcps (
70
/60/4)
d1
$ whenmod 16 8 (slow "<2!4 8!2 4 2>")
$ "k k k <k [~ k]>"
# "jungbass" # n "[0,4]"
# gain 0.9
# hpf 110
d2
$ every 2 ("e" <~)
$ every 3 (0.25 <~)
$ loopAt 2 $ chop 8 $ "break"
# gain 0.65
d3 -- Drum / Hats roll
$ sew "t(<5 7 1>,8)" "dr:21*16" "[dr:22 dr?]*[8|4]"
# gain 0.7
d4
$ whenmod 64 32 (# n "5")
$ whenmod 16 10 (mask "f(3,8)")
-- $ bite 4 "0(3,8)" # n "<2!3 3>"
$ n "<4!7 5>"
# "fbass" # cut 2
# gain 0.9
d5 -- Guitare
-- $ fast (slow 8 $ "<1 2 4!3 8>")
$ juxBy 0.25 (degrade . rev)
$ slice 4 (iter 2 $ run 4)
$ s "~ ~ ~ g"
# n (slow 16 $ "<1 2>")
# "fguitar"
# gain 0.65 # cut 5
d6
$ s "clap*2 ~!<7!3 3 7!2 3!2>"
# room 0.2 # dry 0.9
# djf (range 0.1 0.9 (slow 16 $ perlin))
d7 -- Gemissement nappé
$ arp "up"
$ chop 8
$ note ("<d5'maj <f5'min d6'maj>>")
# s "moan"
# crush (range 3 6 perlin)
# gain 0.4
d9 -- Numbers!
-- $ bite 4 "0 <1? 1> <2 2? ~ 2> 3?"
$ (0.75 ~>)
$ slice 2 "[0 1]"
$ s "toys:11"
# speed 0.8
# cut 10 # lpf 1200
# gain 0.95
d8 -- Whitenoise spatial
$ n "[2*<0 1?>]"
# "cosmicg"
# gain 0.65
# cut 8
-- Sandbox
d9
$ every 3 rev
$ off "e" (|+ note 7)
$ note ("<c4!3 f4>")
# "monsterb"
# gain 0.8
once $ s "cosmicg:3"
-- todo stitch
-- endregion
live/fusion/orleans_les_bains.tidal 0 → 100644
do
d1 $ s "bd" # gain 0.8
d2 $ ply ("<1!2 2 4>" * "<4!3 1>") $ s "drum:8"
d3 $ slice 8 ("0 1 2 3")
$ sound "break:8" # gain 0.95
d4
$ whenmod 8 6 (degrade)
$ superimpose (
every 2 (often (# silence))
. slow 2 . arp "updown" . (|- note 24))
$ struct "t([3|5|7],8,<0 4>)"
$ note ("<c'maj f'maj c'min c'maj>")
# s "superpiano" # velocity 0.45
-- TECHNO JAMBON FROMAGE SLICE
do
solo 1 -- kick
solo 2 -- drumroll
unsolo 3 -- bass
solo 4 -- clap simple
solo 5 -- piano
solo 6 -- Vocal British
unsolo 7 -- Vocal bev
solo 9 -- clap double echo
solo 10 -- Jambon fromage
setcps 0.5
d1
-- $ "k k k <k!3 [~ k]>"
$ "k . k(<3 <1 5 3 4>>,8)"
# s "reverbkick"
# lpf (slow 16 $ range 200 2000 perlin)
# gain 0.95
d2 -- Drumroll / hat regulo 8 accelere
$ superimpose ( -- Hats
const $ s "ho:[0|1](3,8,<2>)" # gain 0.8 # cut 2
)
$ whenmod 32 24 (degradeBy "0 0.5!7")
$ whenmod 32 16 (fast 2)
$ fast "16 8"
$ s "drum:8"
d2 -- Drumroll ternaire!
$ fast 4 $ s "d d*1 d*2"
# s "dr"
# note ("<0!12 -2 -4 -8 -10>")
d3 -- SMOKE ON THE BAD RYTHM
$ mask "t(1,4)"
$ superimpose ((|+ note 12) . (# gain 0.65))
$ note (slowcat
["c ds f ~", "c ds [fs f] ~", "c ds f [~ ds]", "~ c"]
- 24)
# s "supersaw"
# voice 0.1 # gain (slow 40 $ range 0.5 0.8 sine)
d3 -- Basse slow sonore
$ mask "t(<1!2 2!2 3!2 4!2>,4,<0 1 2 3>)"
-- $ chop "4"
$ note ("c <ds!4 gs!4> [g <f!3 gs>]") # octave 3
# s "supersaw" # voice 0.1 # gain 0.85
d4 $ s "cp"
# gain 0.8 # room 0.5 # dry 1
d5 -- Piano fou
$ superimpose (|> note ("c4'maj*12" + "<0 12 24>"))
$ note ("c!6 [c <ds f ds!2 f!3 [f c] [c f]>] ~")
# s "superpiano" # velocity 0.65
# gain (slow 100 $ range 0.6 0.9 cosine)
d6
$ often (# crush 16)
$ slice 4 "<0!3 1>*4" $ s "bsvocals"
# gain (slow 40 $ range 0.3 0.8 sine)
# cut 6
d7
$ slice 4 "0(<4!7 1>,8)" $ s "bev" # cut 7
# gain 1 # room 0.9 # sz 0.4
d9
$ every' 4 3 (off 0.125 id)
$ s "~ ~ ~ cp"
# room 0.8 # sz 0.5 # lpf 2000
d10
$ slice 4 ("<3!3 <0!3 1>>")
$ "macron:7" # gain 0.95
# cut 10
-- DUBIFICATION?
do
d1
$ s "jazz(3,8)"
d2
$ fast "<16!3 [4 <4 8>]>" $ s "drum:8"
d3
$ whenmod 32 24 (mask "t(1,4)")
$ note ("[0*2 <7!5 5!2 3!2 2>]*2")
# s "superpiano"
# octave 6
# velocity 0.4
# room 0.4 # sz 0.2
d4 -- Basse electrique
$ often (superimpose (# crush 4.5))
$ note (scale "aeolian" ("0 ~ . ~ 4 ~ 0(2,<2!2 4 8>)"))
# s "bassWarsaw" # octave 3
# gain (slow 16 $ range 0.75 0.9 sine)
d5
$ s "ho(<1 3 <5 7>>,8) hc([1|2|4],4)" # n "0 [2]"
# cut 5
# gain 0.75
-- Jazz-hop?
do
d1 $ "k . k(3,8)" # s "reverbkick" # gain 0.6
d2 $ "~ sn:1" # gain 0.8
d3 $ s "dr*4" # gain 0.7
d4
$ scramble "<4!4 8 2>"
$ note (scale "aeolian" (run 8))
# s "brass:13" # gain 0.5
do
d1 $ whenmod 32 24 (slow 2) $ "sequential:3*4"
d2 $ "~ sequential"
d3
$ jux rev
$ "sequential:2(6,8,<0 4>)"
# gain (slow 32 $ range 0.6 0.9 saw)
d4
$ superimpose ( -- Arpeges
superimpose ( -- Bassline
swing 2 . (|> "bassWarsaw")
. (# octave 2)
. (|* gain 1.3)
) .
arp "downup" . (|- note 12) . (# cut 41)
)
$ note ("<c7'maj'4 f7'maj'2 c7'min'4 c7'maj'2>") # "sax:6"
# gain 0.85
# cut 4
d5 $ ""
live/hip/beats.tidal
......@@ -12,6 +12,7 @@ do
$ s "h . ~ <~ l> . ~ [~|~|h] . <~ l> <l ~>"
|- note 2
# pan 0.2
# gain 0.6
d2 -- amen sur 8
$ whenmod 16 10 (# gain 0) -- break 1
$ whenmod 16 8 (off 0.125 (|+ n 7))
......
live/hip/hop.tidal deleted 100644 → 0
d1 $ s "<kick [~ kick]>"
# n 3
# gain 0.6
d2 $ s "~ snare:2"
# gain 0.6
d2 $ s "dr*4 ~ dr*2 ~"
# gain 0.8
d1
$ slow 4
$ n "0 .. 31" # s "amencutup"
# gain 0.8
d3
$ whenmod 16 10
d4
$ n "0 0 0 [0 0] 0 [0 0] 0"
# s "bass3"
# gain 0.9
-- o o u [o u] o [o u] u
live/hip/piano_fight.tidal
-- Battle de pianos!
-- Arène: Battle de piano
-- Tags: Hip-Hop, piano, energique
-- Ready: 8/10 (Melody+, Variations+, Parts+)
resetCycles
d3 $ s "dr*4"
do
setcps 0.5
d1 -- Kick basique
$ whenmod 32 24 ( -- Break silence
solo 1 -- Beat anticipateur
solo 2 -- Snare contretemps rushé
solo 3 -- Drumroll metronomique
solo 4 -- Toms+hats balancés (TODO less digital toms)
solo 5 -- Piano J1
solo 6 -- Piano J2
setcps (120/60/4)
d1 -- Kick écho décalé
$ whenmod 16 12 ( -- Break silence
mask "t(1,2)"
)
$ whenmod 4 3 (
(>| n "0(3,8) . ~")
. (|+ gain "0 0.05 0.1 0.15")
)
$ whenmod 16 4 (juxBy 0.25 ( -- Echo decale
(slow 4 "<0.5 0.125>" ~>) . (|* gain 0.85)
))
$ n "0"
# s "jazz" # gain 0.7
# s "reverbkick" # gain 0.85
# cut 1
d2 -- Snare contretemps
$ whenmod 32 24 ( -- Break silence
# lpf (slow 16 $ "<10000 5000 2500 1000>")
d2 -- Snare contretemps rush final
$ juxBy 0.7 (# crush 8)
$ whenmod 16 12 ( -- Break silence
fast "<0!4 1 2 4 8>"
)
$ s "~ snare:48"
# gain 0.8
# gain 0.7
# note (slow 2 "<0 1>" - 6)
d3 -- Metrono-roll
$ whenmod 32 24 ( -- Break silence
$ whenmod 16 12 ( -- Break silence
slow "<2!6 [0.5 0.25] 0.25>"
)
$ someCyclesBy "<0!3 <0.25!3 0.75>>" (fast "2 [2|4]")
$ s "dr*4" # gain 0.8 # pan 0.3
d4 -- Toms TODO variations sur rounds
$ juxBy 0.7 rev
$ s "[808lt(5,8),808mt:1(<3!3 5!3>,8,[0|3])]" # gain 0.5 -- todo toms?
$ someCyclesBy "<0!3 <0.5!3 0.75>>" (almostAlways $ fast "2 [2|4]")
$ s "dr*4" # gain 0.85
# pan "<0.3 0.7 [0.3 0.7] [0.7 0.3]>"
d4 -- Toms + Hats
$ superimpose (
someCycles (degradeBy "0 0.5!7")
. (# s "hh:0")
. (# note "<0!3 <-2 2>>")
. (# crush 16)
. (# pan (slow 2 $ range 0.4 0.6 sine))
)
$ every' 2 1 (often ((1/16) ~>))
$ whenmod 64 32 (juxBy 0.7 rev)
$ whenmod 32 16 (hurry 0.75 . fast 2)
$ s "[808lt(5,8,<0 4>),808mt:1(<3!3 5!3>,8,[0|3])]"
# gain 0.7
# pan 0.45
# lpf (slow 4 $ range 1200 600 sine)
d5 -- Piano J1
$ swingBy (slow 32 "<0!2 1/3 0.5>") 8
$ mask (slow 32 $ "<f t>") -- Rounds
$ swingBy (slow 16 "<0!2 1/3 0.5>") 8
$ mask (slow 16 $ "<f t>") -- Rounds
$ note (
"0!6 [~ 0] <-2!3 3 -2!2 3!3 7 9 7 5 3 -2!2>" -- rythme+melody 16
+ "d4")
# sustain (1/4)
# s "superpiano"
# velocity (0.75 - (perlin * 0.15))
# gain 0.8
# room 0.5 # sz 0.5 --TODO fine-tune reverb
# gain 0.75
# room 0.35 # sz 0.6
d6 -- Piano J2 accords fous !
$ sometimesBy "0 0.25" ("[1|2]/8" ~>)
$ mask (slow 32 $ "<f f t t>") -- Rounds
$ mask (slow 16 $ "<f f t t>") -- Rounds
$ note (
"[<0!15 0?> <0!7 ~> <~!3 0> 0]*4" -- rythme fou
+ "<d6'maj f6'maj c6'min d6'maj>")
# sustain (1/4)
# s "superpiano"
# velocity (0.6 + (perlin * 0.15))
# gain 0.8
# room 0.2 # sz 0.2 --TODO fine-tune reverb
d7 $ silence -- TODO BASS
once $ s "industrial:6" # gain 0.8
# gain 0.6
# room 0.3 # sz 0.8 # dry 1.1
live/late/good_morning_minneapolis.tidal
-- Good Morning Minneapolis
do
let melody = "<d4'min d4'min <a3'min g4'min e4'min> d4'min>"
let melodyFirst = "<d3 d3 <a3 g3 e3> d3>"
let gKick = 0.65
let gSnareL = 0.45
let gSnareH = 0.7
let gDrumsL = 0.65
let gDrumsH = 0.8
let vPiano = 0.45
let gBass = 0.55
let gSiren = 0.5
let gHitL = 0.5
let gHitH = 0.8
let gClap = 0.65
let gGunL = 0.35
let gGunH = 0.5
let gFire = 0.4
setcps 0.5
unsolo 1 -- Kick
unsolo 2 -- Snare
solo 1 -- Kick
solo 2 -- Snare
unsolo 3 -- Drumroll
solo 4 -- Piano
unsolo 5 -- Basse/Sirene
solo 5 -- Basse/Sirene
unsolo 6 -- Hit roll
unsolo 7 -- Claps fantomes
unsolo 8 -- Guns + Fire
d1
$ mask "t(1,4)"
$ sometimesBy "<0 0.1>" (# hpf 200)
$ s "k . k(<1 <3 5>>,8)" -- Hip beat
$ s "k . k(<1 <3 5>>,8,<0 4>)" -- Hip beat
-- $ whenmod 16 10 (slow "<4!4 2>") $ s "k k <k!2 ~ k> <k!3 k*2>" -- TECHNO
# "reverbkick" # lpf (slow 64 $ range 500 2500 sine)
# gain 0.65
# "reverbkick"
# lpf (slow 64 $ range 500 2500 sine)
# gain gKick
d2
$ every' 8 7 (mask "f t!3" . jux rev)
$ s "~ s(<1!3 3>,8)" # s "snare:20"
# gain (slow 32 $ range 0.5 0.7 saw)
# gain (slow 32 $ range gSnareL (gSnareH) saw)
# pan 0.3
d3 -- Drumroll opposé hit roll
-- $ fast "<4!3 <2 [2 <8 [8 16]>]>>" -- Waiting roll
$ fast "<16!3 [16 8]> [8 <8!3 16>]" -- Running roll
$ s "drum:8"
# gain (slow 40 $ range 0.5 0.75 sine)
# pan (slow 8 $ range 0.4 0.6 sine)
# gain (slow 40 $ range gDrumsL gDrumsH sine)
d6 -- Hit roll opposé drumroll
$ every' 4 3 ( -- acceleration + cymbale
fast "2 1" . (# n "0!3 1")
. (|* gain "1!3 <0.65 0.8>")
)
$ s "hh(<3!4 5!4>,8)"
# gain (slow 40 $ range 0.55 0.9 cosine)
# gain (slow 40 $ range gHitL gHitH cosine)
# pan 0.7
d4
$ degradeBy "0 0.9!8" -- OUTRO
-- $ degradeBy "0 0.9!7" -- OUTRO
$ mask "t(<1 2!2 4>,4)"
$ superimpose (
often (off 0.125 (|+ note "<0!3 12>"))
. arp (slow 8 $ "<up down updown downup>")
. (|+ note 36)
. (# sustain 0.5)
. (# velocity 0.4)
. (|* velocity 1.1)
. (# room 0.2)
. (# sz 0.8)
. (|+ pan 0.15)
)
$ note (melody)
# s "superpiano"
# velocity 0.3
# velocity vPiano
# sustain 1
# room 0.4 # size 0.2
# pan 0.5
d5 -- Basse + Sirene
$ whenmod 64 32 (
$ whenmod 64 0 (
superimpose (
slow 4
. (# s "supersiren")
. (|- note 12)
. (|* gain 1.1)
. (|- note 12) -- 24 when crushed
. (# gain gSiren)
. (# room 0.5)
))
-- $ chop 4 $ often (ply 4) $ (# crush 4) -- TECHNOPHILE
$ note (melodyFirst)
# s "supersaw" # voice 0.02
# gain 0.45
# gain gBass
# pan (slow 10 $ range 0.6 0.8 sine)
d7 -- Claps fantomes
$ s "~ cp"
# room (range 0.5 0.95 perlin)
# sz (range 0.2 0.9 perlin)
# dry 1.2
# gain 0.65
# gain gClap
# pan (slow 8 $ range 0.45 0.65 saw)
d8 -- Gunfire
$ sometimes (
......@@ -86,7 +100,7 @@ do
$ often (stut 4 0.9 (1/16)) -- échos
$ s "~ ~ ~ snare:57"
# speed (range 0.4 1.1 perlin)
# gain (range 0.45 0.6 rand)
# gain (range gGunL gGunH rand)
# cut 80
# pan (range 0.2 0.8 perlin)
)
......@@ -95,5 +109,6 @@ do
# begin (slow 4 "<0 0.2 0.5>")
# cut 8
# room 0.6 # size 0.4
# speed (range 0.8 1 perlin)
# gain 0.7
# speed (range 0.5 1 perlin)
# gain gFire
# delay 0.3 # delaytime (1/3) # delayfb 0.8
live/late/romain.tidal 0 → 100644
do
let mel = "<c4'maj c4'min e4'maj c4'maj>/4"
d1
$ s "reverbkick(<3 <5!2 7>>,8)" # gain 0.9
d2 $ fast 2 $ s "~ <s!3 s*2>" # s "snare:11"
# gain 0.9
d3 $ jux id $ fast "<8 16> <4!3 8>" $ s "dr"
d4
$ stut 8 0.8 0.5
$ note mel
# s "superpiano" # velocity 0.65
d5
-- $ chop (slow 2 $ "1 2 1")
$ note ("0" + mel - 12) # s "supersaw"
# voice 0.1 # gain 0.7
d6
$ swing 4
$ often (ply 2)
$ s "space"
# speed
# n "[1|2]" # gain 0.75
do
d1
$ whenmod 8 7 (# silence)
$ sometimesBy "1 0 0 0" (# lpf 200)
$ s "t t t <t!3 t*2>"
-- "t t t*2 [~ t]"
# s "jazz" # gain 1
d2 $ s "hh" # gain 1
d3
$ note ("<0!4 2!2 4 7>" + "d3'maj")
# s "supersaw" # gain 0.9
d4 $ s "~ ~ cp ~" # gain 0.7
# room (slow 10 $ range 0.3 0.9 sine)
# sz 0.4 # dry 1
d5
$ superimpose (
mask "t(3,4)"
. (# sustain "0.25 0.25 0.5 ~")
. (|+ note "12")
. arp "up"
. chop 4
)
$ note ("<0!4 2!2 4 7>" + "d3'maj")
# s "moogBass" # gain 0.9
once $ s "macron:7" # gain 1.1
do
let melody = "<c4'maj!2 c4'min f4'maj>"
d1 $ fast 4 $ s "jazz" # gain 0.5
d2 $ sound "t*2 . t t t" # s "dr" # gain 0.6
d3 $ chop "<4!3 8>" $ note (melody - 12) # s "supersaw" # voice 0.1 # gain 0.8
d4 $ note (melody) # s "superpiano" # velocity 0.5
live/techno/accel.tidal
-- Accel: get faster, yet calmer
-- Tags: Techno, dark bass, synthe, sirenes
-- Ready: 7/10 (Melody+, Variations=, Parts=)
resetCycles
-- region Part 1: setup accel vivant
do
solo 1 -- kick
unsolo 2 -- snare
unsolo 3 -- drumroll
solo 4 -- bass
unsolo 4 -- bass
unsolo 5 -- siren
unsolo 6 -- clap
solo 6 -- clap
solo 7 -- synth
-- let mKick = "<1!32 0!15 [0 1] 1!64 0.9!4 0.8!4 0.7!4 0.6!4>"
let gKick = 0.5 -- /128 On off semi-onon fadeout
let gSnare = 0.6
let gHats = 0.7
let gDrums = 0.5
let gBass = 0.5 * "<1!16 <[1 0]*4 [0 1]*4>!8 1!8>"
let gKick = 0.75 -- /128 On off semi-onon fadeout
let gSnare = 0.65
let gHats = 0.85
let gDrums = 0.75
let gBass = 0.65 * "<1!16 <[1 0]*4 [0 1]*4>!8 1!8>"
let gSiren = 0.85 * "<0!64 0.7!32 0.6!32 0.5!32 0.4!32>"
let gSynth = 0.5 * "<0!16 <[1 0]*4 [1? 1]*4>!16 1!32>"
let gClap = 0.6
let gSynth = 0.65
let gClap = 0.9
let melody = "<0 0 0 0 2 2 4 -2>"
setcps 0.5 -- TECHNOOO
d1 -- Kick
......@@ -110,18 +111,18 @@ once $ s "abstract:1" # cut 1 # gain 0.6
-- region Part 2: Dry Melancholia
do
solo 1 -- kick
solo 2 -- snare
solo 2 -- snare + h
solo 3 -- drumroll
solo 4 -- bass
solo 5 -- siren
solo 6 -- clap
solo 7 -- synth
let gKick = 0.6 -- /128 On off semi-onon fadeout
let gKick = 0.7 -- /128 On off semi-onon fadeout
let gSnare = 0.65
let gHats = 0.75
let gBass = 0.6
let gSiren = 0.6
let gSynth = 1 * "<0!16 <[1 0]*4 [1? 1]*4>!16 1!32>"
let gSynth = 0.9 * "<0!16 <[1 0]*4 [1? 1]*4>!16 1!32>"
let gClap = 0.8
let melody = "<0 0 0 0 2 2 4 -2>"
setcps 0.5 -- TECHNOOO
......@@ -176,9 +177,9 @@ do
-- region Part 3: Folie
do
solo 1 -- kick
solo 2 -- snare
unsolo 2 -- snare
unsolo 3 -- drumroll
unsolo 4 -- bass
solo 4 -- bass
unsolo 5 -- siren
solo 6 -- clap
solo 7 -- synth
......@@ -186,7 +187,7 @@ do
let gSnare = 0.65
let gHats = 0.75
let gBass = 0.6
let gSiren = 0.3 * "<0.7!32 0.6!32 0.5!32 0.4!32>"
let gSiren = 0.2 * "<0.7!32 0.6!32 0.5!32 0.4!32>"
let gSynth = 1.3 -- * "<0!16 <[1 0]*4 [1? 1]*4>!16 1!32>"
let gClap = 0.8
let melody = "<0 0 0 0 2 2 4 -2>"
......@@ -233,7 +234,7 @@ do
) - 36)
# s "supersiren"
# sustain 4
# gain 0.8
# gain gSiren
# cut 5
d7 -- synthe echos electrique
......@@ -253,13 +254,13 @@ $ n "0*12"
-- region Part 4: Résolution
do
solo 1 -- kick
unsolo 1 -- kick
unsolo 2 -- snare
unsolo 3 -- drumroll
unsolo 4 -- bass
unsolo 5 -- choeur
unsolo 6 -- clap
unsolo 7 -- synth
solo 3 -- drumroll
solo 4 -- bass
unsolo 5 -- choeur -- FIXME
solo 6 -- clap
solo 7 -- synth
let mKick = "<1!32 0!15 [0 1] 1!64 0.9!4 0.8!4 0.7!4 0.6!4>"
let gKick = 0.75 * mKick -- /128 On off semi-onon fadeout
let gSnare = 0.6
......@@ -333,22 +334,22 @@ d7 -- synthe echos electrique
# gain gSynth
-- endregion
-- region Part 5: Restart minimal
do
unsolo 1 -- kick
unsolo 2 -- claps
unsolo 3 -- drumroll
solo 4 -- bass
unsolo 4 -- bass
unsolo 5 -- Choeurs
unsolo 6 -- piano
unsolo 7 -- synth
unsolo 8 -- Pistolets
solo 7 -- synth
solo 8 -- Pistolets
setcps 0.5 -- TECHNOOO
d1 -- Kick
$ whenmod 16 14 (# silence) -- break frequent
$ n "0 0 <0!3 0?> 0" # s "reverbkick"
# lpf 500 # gain 0.9
# lpf 500
# gain 0.7
d2
$ whenmod 4 3 (sometimesBy "0 0.75" (ply 2))
$ fast 2 $ s "~ cp" # gain 0.8
......@@ -358,19 +359,21 @@ do
$ fast "1 <1!3 2>"
$ s "ifdrums:1*4"
-- # gain 0.9
d4 -- Basse nappes + arp aigues
d4 -- Basse nappes + arp aigues crushées
$ superimpose (
(# crush (range 1 3 perlin)) .
swing "<3 2>" .
fast 4 .
arp "<pinkyup>"
. (|+ gain 0.0)
. (|+ note 12)
arp "<pinkyup updown downup speedupdown>"
. (|* gain 0.8)
. every 2 (|+ note 12)
. (|+ note 12)
)
$ note (scale "lydian"
"<c4'maj e4'maj c4'maj e4'min>/4")
# s "supersaw"
# voice 0.01
# gain (slow 64 $ range 0.35 0.4 sine)
# gain (slow 64 $ range 0.45 0.5 sine)
d5 -- Choeurs
$ note (scale "lydian"
"<c4'maj e4'maj c4'maj e4'min>/4")
......@@ -398,21 +401,21 @@ do
-- region Part 6: Finish breakbeat
do
solo 1 -- kick
solo 2 -- claps
solo 3 -- drumroll
unsolo 4 -- bass
solo 5 -- Choeurs
unsolo 2 -- claps
unsolo 3 -- drumroll
solo 4 -- bass -- FIXME
unsolo 5 -- Choeurs
unsolo 6 -- piano
unsolo 7 -- synth
solo 8 -- Pistolets
setcps 0.5 -- TECHNOOO
d1
$ whenmod 4 3 (iter 4)
-- $ fast 4
$ loopAt 2
$ slice 8 "[0(3,8) 1]" -- finish [1]
-- $ slice 8 "[0(3,8) 1, 2(1,8)]" -- finish [1]
$ slice 8 "1" -- finish [1]
$ s "break"
# gain 0.8
# gain 0.75
d2
$ whenmod 4 3 (sometimesBy "0 0.75" (ply 2))
-- $ fast 2
......@@ -444,9 +447,9 @@ do
))
$ note (scale "lydian"
"<c4'maj e4'maj c4'maj e4'min>")
# s "superpiano" # velocity 0.65
# s "superpiano" # velocity 0.55
d8 -- Random pistolets fin boucle 64
$ whenmod 64 48 (sometimes (# gain 0.8))
$ whenmod 64 48 (sometimes (# gain 0.6))
$ every' 4 3 ((sometimes $ jux rev) . (fast 2))
$ sometimesBy "0 0.5" ((ply 2) . (|+ note "[-12|+6]"))
$ s "~ s(<3!3 5>,8,3)"
......
live/techno/acid_80s.tidal 0 → 100644
-- region Part 1 Breakbeato-bass
do
d1
-- BREAKBEAT!
$ s "jazz(2,4)" # lpf 1000
-- $ superimpose (
-- const
-- $ s "k(<1!7 3>,8) . k(<1 3 5>,8)"
-- # s "reverbkick"
-- # gain 0.5
-- )
-- $ loopAt 2 -- 4 slowdown
-- $ slice 4 "0? 1*2 3(3,8) ~"
-- $ s "break:1"
# gain 0.5
d2
$ fast "<4!2 8 16>"
$ s "ifdrums:1" # gain 0.5 # sz 0.5 # room 0.5
d5
$ note ("<0>"
+ "[0,<12 12?>](<3!3 5 3!3 5 3!3 5 8 10 5>,16)"
)
# s "bass3"
# gain 0.55
-- $ whenmod 32 16 (degradeBy "0 0.5!7 0")
$ superimpose (
(arp "up") . (|+ note 24)
. (# gain 0.35)
-- . (# crush (slow 16 $ range 0.75 8 sine))
)
$ s "t(<4!2 5!2>,<4!2 8!2>)"
# note ("<c3'min c3'maj c3'min7 c3'maj>")
# s "supersaw"
# voice 0.01 # gain 0.3
-- endregion
-- Techno tambourino piano
do
setcps 0.45
solo 1 -- Kick
unsolo 2 -- Drums gretsch contretemps chaloupé
solo 3 -- Drumroll aigu
unsolo 4 -- Piano fou
unsolo 5 -- Bass guitar 80s
unsolo 6 -- Noise
solo 7 -- Birds
d1
-- $ whenmod 32 28 (slow 4)
-- $ whenmod 8 7 (slow 2)
-- $ s "k k k [<k!3 k?> <~ k?>]"
$ whenmod 8 7 (>| n "0*4")
$ s "k . k(<1 3!2 5>,8)"
# s "jazz"
# gain (slow 128 $ range 0.35 0.6 cosine)
d2
$ n "1 . [[2,2](<4!3 3 4>,8)]"
# s "gretsch"
# gain (slow 30 $ range 0.4 0.8 sine)
d3
$ often (jux rev)
$ fast "<4!3 <8 [16 8]>> <8!3 16>"
$ s "gretsch:3"
# gain (slow 16 $ range 0.3 0.5 saw)
# room 0.6 # sz 0.9
d4
$ rev
$ superimpose (arp "[updown,downup?]"
. (stut "<2 3 4>" 0.8 0.125)
. (|+ note 12)
. (|* velocity 1.1)
)
$ note ("<g3'maj!3 g3'min g3'maj!2 g3'min g3'maj>")
# s "superpiano"
# velocity (slow 100 $ range 0.15 0.35 tri)
d5 -- Guitare synth 80s flamboyant
$ note (scale "hexMajor6"
"[g4(<3 5 3 3 5 3 3 5>,8)]"
-- + "[1 3 <1!4 <6 8 6 6>!4>]*4"
+ (whenmod 8 4 rev $ "[0 <5 3 2 -2>]")
)
# s "supersaw"
# voice 0.01
# gain (slow 80 $ range 0.25 0.45 sine)
# hpf 500 # hpq 0.4
d6 $ "glitch:2/4"
# speed (range 0.1 0.5 perlin)
# begin 0.1
# gain (slow 16 $ range 0.5 0.7 saw)
d7 -- Background birds
$ often (stut 4 0.75 0.5)
$ s "birds/4" # n (irand 7)
# note (-2)
# gain 0.45
# speed (range 0.5 1.5 rand)
live/techno/delic_jazz.tidal
......@@ -4,12 +4,12 @@ setcps 0.46
d1 -- beat
$ someCycles (0.125 ~>)
$ s "tech:5*4" # note (-4)
# gain (slow 16 $ sine * 0.6 + 0.4)
# gain (slow 16 $ range 0.7 0.9 sine)
d2
$ every 4 (const $ "[~ [hh,hh:8] ~ [hh ~ hh]]*2" # gain 1.2)
$ s "[~ hh ~ <hh [hh ~ hh]>]*2"
# gain 1.2
# gain 0.85
d3
$ s "bd sn bd <cp cp cp cp*2>"
......@@ -30,8 +30,7 @@ $ whenmod 64 48 (
$ "[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
# gain 0.45
# sustain 2
)
$ every 4 ((>| s "superpiano*16") . (# note "6 <2 5> <2 1>"))
......@@ -39,7 +38,7 @@ $ someCycles (# sustain 3)
$ s "[p?*3] . ~ . [p*2] . ~ [p? p] . ~"
# s "superpiano"
# note "<1 [2,6] [1,5] ~>"
# velocity 0.8
# velocity 0.5
d6 -- white noise
$ someCycles (# silence)
......@@ -47,7 +46,6 @@ $ sometimes (jux rev)
$ (# speed (rand / 2))
$ s "glitch:2" -- # n (run 8)
# cut 1
# gain 1.2
d7 -- ??? TODO: What is that supposed to be?
$ someCyclesBy 0.2 (# gain 1)
......
live/techno/faya.tidal 0 → 100644
do
unsolo 1
solo 2
unsolo 3
unsolo 4
unsolo 5
solo 6
unsolo 7
setcps (110/60/4)
d1 -- Kick
$ whenmod 16 12 (# silence)
$ s "k k k k" # s "jazz" # gain 0.8
d2 $ s "~ [<cp!3 cp*2> . ~]"
# lpf 4000 # room 0.9 # size 0.8 # dry 0.9
# gain (slow 8 $ range 0.55 0.9 saw)
d3
$ bite 4 "<0 1> <2 0> 2 <3 0>"
$ note (
scale "major" (run 8) + "c2'maj")
# s "moogBass" # gain 0.78
d4 $ fast "4 [8 <16!3 8>]"
$ note ("-2 -4") # s "hh:0"
# gain 0.8 # pan (slow 16 $ sine)
d5
$ arp "<updown!7 downup>"
$ note (scale "major" "c4'maj c4'maj c4'maj c4'maj")
# release (slow 64 $ range 0.2 0.8 sine)
# s "moog" # gain 0.75 # octave "<6!3 5>"
d6 -- Spliced bev
$ sometimesBy "<0 1> 0 0 0" (0.1 ~>)
$ slice 8 "<<<0 5>!7 2>!3 <3 7>>*4"
$ s "bev"
# cut 1
# gain 0.9 # room 0.5
live/techno/feeling_electric.tidal
setcps 1
d1 -- bass
-- $ whenmod 64 32 ((# gain 1) . (# room 0.2))
-- $ whenmod 32 16 (# silence)
$ slow 2
$ note (
scale "major" (
cat [
" 1 1 ~ . ~ [~ 0]",
"0 [0 1] ~ ~ . ~ "
]
+ "[0, 7]" -- gamme
)
)
# s "bass3"
do
solo 1 -- bass
solo 2 -- hit
solo 3 -- clap
solo 4 -- fork
solo 5 -- kick
solo 6 -- drums 80s
d1 -- autre Basse
$ whenmod 8 4 (|- n 2)
$ someCyclesBy 0.4 ((superimpose (|- 7)) . (|+ 7)) -- 2: matiere plastique
......@@ -24,6 +16,20 @@ do
|- 14
# s "subBass1"
# gain 0.9
d1 -- bass
-- $ whenmod 64 32 ((# gain 1) . (# room 0.2))
-- $ whenmod 32 16 (# silence)
$ slow 2
$ note (
scale "major" (
cat [
" 1 1 ~ . ~ [~ 0]",
"0 [0 1] ~ ~ . ~ "
]
+ "[0, 7]" -- gamme
)
)
# s "bass3"
d2 -- hit roll
$ sometimesBy "0 0.5" ((# gain 0.8) . (# s "dr:2"))
-- $ someCycles (# s "dr:1")
......@@ -52,7 +58,7 @@ do
# gain (slow 64 $ range 1.5 0.6 isaw)
# pan 0.8
d5 -- kick
$ fast 2
$ fast 4
$ every 4 degrade
$ s "kick:5"
# gain 0.9
......
live/techno/funk/layered_breaks.tidal 0 → 100644
-- Couches de Funk
-- Tags: Techno, bass, epiano , hypnotic
-- Ready: 4/10 (Répetitif, à équilibrer, à espacer, vocals?)
resetCycles
do
setcps 0.5
solo 1 -- Techno kick
solo 2 -- BreakBeat
solo 3 -- Claps
solo 4 -- Bassline!
solo 6 -- Electromad piano
d1 -- KICK
$ fast "<4!16 1 2 4 8 4!2>"
$ whenmod 16 15 (juxBy 0.9 rev)
$ whenmod 64 32 (
superimpose ((# "clubkick:7") . (# lpf 200))
. (|* gain 0.9)
)
$ "[cpu2,jazz]"
# lpf 5000
# gain 0.6
d2 -- Breakbeat
$ whenmod 8 4 (juxBy 0.5 rev)
$ whenmod 32 16 (
# djf (slow 16 $ range
(slow 32 "<0.4 0.1>")
(slow 32 "<0.6 0.9>") sine)
)
$ slice 8 (stack [
"0 . 0(<0!8 1!8 3!16>,8)",
"1(<3!3 5>,8,<0!4 3!4>)",
"~ 2(<<2 1> 4>,4,<0!4 2!4>)",
""]
) "break:8"
# gain ((slow 16 $ range 0.45 0.65 sine) - (slow 2 perlin * 0.2))
d3 -- Clap degressifs
$ juxBy 0.5 (0.125 ~>)
$ every' 8 7 (off "e" id) "~ cp"
# djf (slow 8 $ range 0.5 0.2 isaw)
# room 0.4 # sz 0.2 # dry 0.95
# gain 0.8
# pan 0.3
d4 -- Bassline hypnotique
-- $ slow 2 -- Cut sauf occasionnel par ralentissement
$ whenmod 64 32 (degradeBy "0.8!16 0.5!16")
$ slice 8 (
-- run 8 -- Le classic
-- fastcat [run "<2!3 4>", run "<4!3 2>"] -- Le loop-jump
-- fastcat [run 4, run 4] -- Le loopy
"4*[8 <8!3 16>]" -- GO ON
-- "4*2 3 2*[1|2] 1? 7 6 5*<1 2 4 8> 0*<1 4 1 2>" -- reverse jumpy
-- "4*8 . 0 [<5!4 7!4> 6 <7!4 5!4>]@3" -- glitch-funk
-- every' 2 1 (iter "[1 4!2 1]") $ "0*8 1(2,3) 2 <3 5> 4*2" -- Attente vibrée
)
$ "fbass/2"
-- # crush 5 -- ELECTRONIZE
-- # n 23
# n "<23!8 7!4>"
# cut 3
# gain 0.8
d6 -- Electro-MAD piano
$ whenmod 16 12 (
off "q" ( stut 4 0.5 "e"
. (|+ note "<12>") . (# sustain 0.7)
. (# room 0)
)
)
$ "fepiano/2"
# n (slow 4 $ "<20!4 21!2 22!2>")
-- # note (slow 2 "<-4 0>")
# room 0.6 # sz 0.5
# gain (slow 16 $ "<0.4 0.55 0.7 0.65>" * 0.8)
d8 -- Guitare conclusive
$ mask "t(<0!4 1!4 2!4 4!4>,4,<3!16 0!16>)" $ chop 8
$ "fguitar/2" # n "<20!3 7>" # gain 0.7
# cut 8
once "fpiano"
-- region Funk samples listing
-- region Bass
0 BassA_110E-01.wav
1 BassA_110E-02.wav
2 BassA_110E-03.wav
3 BassA_110E-04.wav
4 BassA_120G-01.wav
5 BassA_120G-02.wav
6 BassA_120G-03.wav
7 BassA_120G-04.wav
8 BassA_80D-01.wav
9 BassA_80D-02.wav
10 BassA_80D-03.wav
11 BassA_80D-04.wav
12 BassA_90C-01.wav
13 BassA_90C-02.wav
14 BassA_90C-03.wav
15 BassA_90C-04.wav
16 BassB_110C-01.wav
17 BassB_110C-02.wav
18 BassB_110C-03.wav
19 BassB_110C-04.wav
20 BassB_120A-01.wav
21 BassB_120A-02.wav
22 BassB_120A-03.wav
23 BassB_120A-04.wav
24 BassB_80E-01.wav
25 BassB_80E-02.wav
26 BassB_80E-03.wav
27 BassB_80E-04.wav
28 BassB_90B-01.wav
29 BassB_90B-02.wav
30 BassB_90B-03.wav
31 BassB_90B-04.wav
32 BassC_110A-01.wav
33 BassC_110A-02.wav
34 BassC_110A-03.wav
35 BassC_110A-04.wav
36 BassC_120E-01.wav
37 BassC_120E-02.wav
38 BassC_120E-03.wav
39 BassC_120E-04.wav
40 BassC_80C-01.wav
41 BassC_80C-02.wav
42 BassC_80C-03.wav
43 BassC_80C-04.wav
44 BassC_90D-01.wav
45 BassC_90D-02.wav
46 BassC_90D-03.wav
47 BassC_90D-04.wav
48 BassD_110D-01.wav
49 BassD_110D-02.wav
50 BassD_110D-03.wav
51 BassD_110D-04.wav
52 BassD_120G-01.wav
53 BassD_120G-02.wav
54 BassD_120G-03.wav
55 BassD_120G-04.wav
56 BassD_80C-01.wav
57 BassD_80C-02.wav
58 BassD_80C-03.wav
59 BassD_80C-04.wav
60 BassD_90A-01.wav
61 BassD_90A-02.wav
62 BassD_90A-03.wav
63 BassD_90A-04.wav
-- endregion
-- region Guitar
8 GuitarA_80D-01.wav
9 GuitarA_80D-02.wav
10 GuitarA_80D-03.wav
11 GuitarA_80D-04.wav
24 GuitarB_80E-01.wav
25 GuitarB_80E-02.wav
26 GuitarB_80E-03.wav
27 GuitarB_80E-04.wav
40 GuitarC_80C-01.wav
41 GuitarC_80C-02.wav
42 GuitarC_80C-03.wav
43 GuitarC_80C-04.wav
56 GuitarD_80C-01.wav
57 GuitarD_80C-02.wav
58 GuitarD_80C-03.wav
59 GuitarD_80C-04.wav
12 GuitarA_90C-01.wav
13 GuitarA_90C-02.wav
14 GuitarA_90C-03.wav
15 GuitarA_90C-04.wav
28 GuitarB_90B-01.wav
29 GuitarB_90B-02.wav
30 GuitarB_90B-03.wav
31 GuitarB_90B-04.wav
44 GuitarC_90D-01.wav
45 GuitarC_90D-02.wav
46 GuitarC_90D-03.wav
47 GuitarC_90D-04.wav
60 GuitarD_90A-01.wav
61 GuitarD_90A-02.wav
62 GuitarD_90A-03.wav
63 GuitarD_90A-04.wav
0 GuitarA_110E-01.wav
1 GuitarA_110E-02.wav
2 GuitarA_110E-03.wav
3 GuitarA_110E-04.wav
16 GuitarB_110C-01.wav
17 GuitarB_110C-02.wav
18 GuitarB_110C-03.wav
19 GuitarB_110C-04.wav
32 GuitarC_110A-01.wav
33 GuitarC_110A-02.wav
34 GuitarC_110A-03.wav
35 GuitarC_110A-04.wav
48 GuitarD_110D-01.wav
49 GuitarD_110D-02.wav
50 GuitarD_110D-03.wav
51 GuitarD_110D-04.wav
4 GuitarA_120G-01.wav
5 GuitarA_120G-02.wav
6 GuitarA_120G-03.wav
7 GuitarA_120G-04.wav
20 GuitarB_120A-01.wav
21 GuitarB_120A-02.wav
22 GuitarB_120A-03.wav
23 GuitarB_120A-04.wav
36 GuitarC_120E-01.wav
37 GuitarC_120E-02.wav
38 GuitarC_120E-03.wav
39 GuitarC_120E-04.wav
52 GuitarD_120G-01.wav
53 GuitarD_120G-02.wav
54 GuitarD_120G-03.wav
55 GuitarD_120G-04.wav
-- endregion
-- region Guitar
-- endregion
-- region fepiano
8 EPianoB_80E-01.wav
9 EPianoB_80E-02.wav
10 EPianoB_80E-03.wav
11 EPianoB_80E-04.wav
24 EPianoC_80C-01.wav
25 EPianoC_80C-02.wav
26 EPianoC_80C-03.wav
27 EPianoC_80C-04.wav
12 EPianoB_90B-01.wav
13 EPianoB_90B-02.wav
14 EPianoB_90B-03.wav
15 EPianoB_90B-04.wav
28 EPianoC_90D-01.wav
29 EPianoC_90D-02.wav
30 EPianoC_90D-03.wav
31 EPianoC_90D-04.wav
0 EPianoB_110C-01.wav
1 EPianoB_110C-02.wav
2 EPianoB_110C-03.wav
3 EPianoB_110C-04.wav
16 EPianoC_110A-01.wav
17 EPianoC_110A-02.wav
18 EPianoC_110A-03.wav
19 EPianoC_110A-04.wav
4 EPianoB_120A-01.wav
5 EPianoB_120A-02.wav
6 EPianoB_120A-03.wav
7 EPianoB_120A-04.wav
20 EPianoC_120E-01.wav
21 EPianoC_120E-02.wav
22 EPianoC_120E-03.wav
23 EPianoC_120E-04.wav
-- endregion
-- region Piano
-- endregion
-- region
-- endregion
-- region
-- endregion
live/techno/funk/work.tidal 0 → 100644
resetCycles
do
setcps 0.5
d1
$ degradeBy "<1!5 0!24 0!4>"
$ whenmod 16 12 (>| n "0 <~!2 0!2>")
$ "[jazz](<4!3 3>, 4, <0!3 <0 3>>)" # gain 0.8
d3
$ degradeBy "<1!2 [0 1]!2 0!31>"
$ whenmod 32 28 (fast "0.5 1")
$ fast "4 <4 8 [4 8] [8 4]>" $ "[~ drum:8]"
d4
$ whenmod 16 12 (# n 2)
$ slice 4 (
"0 <1!2 3!2>"
)
$ loopAt 2 $ "fbass"
# gain 0.95
# djf (slow 16 $ range 0.3 0.9 saw)
d5
$ degradeBy "<1!8 0!16 [0 0.5!7]!8>"
$ slice "<8!7 4>" ("<0!4 3!4> 1 <2!3 1> 3")
$ s "fguitar:10"
# gain (slow 40 $ range 0.5 0.8 (saw + perlin/10))
# cut 5 -- TODO: last bit when uncut worth looping?
d6
$ rarely (off (-0.125) id)
$ degradeBy "<1!8 0!24>"
$ s "~ ~ ~ clap:2"
# note ("<0!4 -2!2 -4!2>")
# gain (slow 16 $ range 0.5 0.8 saw)
# room (slow 16 $ range 0.4 0.8 sine)
# sz 0.8
live/techno/persistent_moog.tidal 0 → 100644
do
d1
$ whenmod 32 24 (mask "t(<0!4 1!4 2!4 8>, 8)")
$ fast 4 $ s "reverbkick" # lpf 200 # gain 0.8
d2
$ fast "8 [4|8] . <16!3 [16 8]>" $ s "dr"
# gain (0.7)
d3
$ every' 4 3 (often (off 0.125 id))
$ s "cp" # lpf 2000 # gain (slow 16 $ range 0.5 1 sine)
d4
$ whenmod 16 12 (# lpf 200)
$ scramble 4
$ note (scale "aeolian" (run 8))
# s "moog"
# n (slow 4 "<0 1 2>")
# gain 0.65
# cut 3
once $ s "cp"
notes.md
......@@ -25,9 +25,9 @@
--- 808lc Lourd Carillon (rond)
--- 808mc Milieu Carillon (rond)
--- 808hc Haut Carillon (rond)
--- 808lt Lourd Tuyau (tac)
--- 808ht Milieu Tuyau (tac)
--- 808ht Haut Tuyau (tac)
--- 808lt Lourd Tom (tac)
--- 808ht Milieu Tom (tac)
--- 808ht Haut Tom (tac)
--- 808oh Cymbale bruitée
-- 0: sec
---- 1: 1sec
......
samples.txt
808 (6) 808bd (25) 808cy (25) 808hc (5) 808ht (5) 808lc (5) 808lt (5) 808mc (5) 808mt (5) 808oh (5) 808sd (25) 909 (1)
ab (12) abstract (58) ade (10) ades2 (9) ades3 (7) ades4 (6) alex (2) alphabet (26) amencutup (32) armora (7) arp (2) arpy (11) auto (11)
baa (7) baa2 (7) bass (4) bass0 (3) bass1 (30) bass2 (5) bass3 (11) bassdm (24) bassfoo (3) battles (2) bd (24) bend (4) bev (2) bin (2) birds (10) birds3 (19) bleep (13) blip (2) blue (2) bottle (13) brass (38) break (33) breaks125 (2) breaks152 (1) breaks157 (1) breaks165 (1) breath (1) bsbass (9) bsguitar (19) bshihat (3) bskick (9) bsnoise (22) bsperc (7) bssnare (8) bsvocals (13) bubble (8)
can (14) casio (3) cb (1) cc (6) chin (4) circus (3) clak (2) clap (8) click (4) clubkick (5) co (4) coins (1) control (2) cosmicg (15) cp (2) cpu (23) cpu2 (29) cr (6) crow (4)
baa (7) baa2 (7) bass (4) bass0 (3) bass1 (30) bass2 (5) bass3 (11) bassdm (24) bassfoo (3) battles (2) bd (24) bend (4) bev (2) bin (2) birds (10) birds3 (19) bleep (13) blip (2) blue (2) bottle (13) brass (38) break (33) breaks125 (2) breaks152 (1) breaks157 (1) breaks165 (1) breath (1) bsbass (9) bsguitar (19) bshihat (3) bskick (9) bsnoise (22) bsperc (7) bssnare (8) bsvocals (13) bubble (8)
d (4) db (13) diphone (38) diphone2 (12) dist (16) dork2 (4) dorkbot (2) dr (42) dr2 (6) dr55 (4) dr_few (8) drum (6) drumtraks (13) dsynth (3)
e (8) east (9) electro1 (13) em2 (6) erk (1)
f (1) feel (7) feelfx (8) fest (1) fire (1) flick (17) fm (17) foo (27) future (17)
......
study/club/14april.tidal
......@@ -80,6 +80,6 @@ do
n (leftHand + key)
]
# "superpiano"
# velocity 0.5
# velocity 0.65
# octave "3"
# sustain "[2 0.7]*4"
study/club/w4.tidal 0 → 100644
-- region Lesson 1 - continuous patterns
-- 'Continuous functions' provide different kinds of waveforms.
-- There's a nice graphic showing sine, square, triangle and sawtooth
-- waves here: https://en.wikipedia.org/wiki/Waveform
-- Here's what the sine waveform sounds like applied to sample playback
-- speed:
d1 $ sound "bd*32" # speed sine
-- and to panning:
d1 $ sound "bd*32" # pan sine
-- and to waveshape distortion (gets loud):
d1 $ sound "bd*32" # shape sine
-- You can manipulate continuous patterns just like other kinds of
-- patterns, for example slowing down:
d1 $ sound "bd*32" # shape (slow 2 sine)
-- The waveforms all move between 0 and 1. So at its lowest point, sine
-- will be 0, and at its highest point it will be 1. Having a value
-- near 0 can be problematic with 'speed', as you can end up with
-- sounds played very slowly that take a long time to complete.
-- To get around this you can add to the sine:
d1 $ sound "bd*32" # speed (sine + 0.5)
-- Or use the 'range' function:
d1 $ sound "bd*32" # speed (range 0.5 1.5 sine)
-- Lets listen to triangle, sawtooth and square waves:
d1 $ sound "bd*32" # speed (range 0.5 1.5 tri)
d1 $ sound "bd*32" # speed (range 0.5 1.5 saw)
d1 $ sound "bd*32" # speed (range 0.5 1.5 square)
-- What happens if you put the continuous pattern on the left?
-- Remember that with '#', the rhythmic structure comes from the
-- left. Try this:
d1 $ speed (range 0.5 1.5 sine) # sound "bd"
-- Silence! Why's that?
-- It's because continuous functions don't actually contain any
-- events. They have values which continually change, without
-- triggering anything.
-- If we want to trigger events in a continuous pattern, we have
-- to explicitly sample values from it. One way to do that is with
-- the 'segment' function:
d1 $ speed (segment 32 $ range 0.5 2.5 sine) # sound "bd"
-- The above samples 32 values per cycle, generating discrete
-- events from them.
-- Another way to do this is with 'binary' or 'boolean' patterns,
-- using the 'struct' function:
d1 $ speed (struct "t(3,8)" $ slow 2 $ range 0.5 2.5 sine)
# sound "bd"
-- 't' stands for 'true'. So that euclidean rhythm is used to sample
-- events from the continuous sine function. We'll return to
-- binary patterns in another video.
-- You can also add or multiply continous patterns together:
d1 $ sound "bd*32" # speed (range 0.5 2.5 (sine + (slow 2 saw)))
d1 $ sound "bd*32" # speed (range 0.5 2.5 (sine * (slow 2 saw)))
-- I slowed the 'saw' down in the above patterns, so you end
-- up with a sine wave that rises in pitch over two cycles.
-- In Tidal, random functions are also often continous.
-- For example, rand works like sine, saw etc, but returns random
-- values:
d1 $ sound "bd(5,8)" # speed (range 1 3 rand)
-- Perlin is similar, but returns 'perlin noise'. In Tidal, this
-- means that the pattern smoothly transitions between random values,
-- every cycle:
d1 $ sound "bd(5,8)" # speed (range 1 3 perlin)
-- Lets try that with some reverb:
d1 $ sound "bd(7,16)"
# room 0.7
# sz (range 0.4 1 $ slow 4 perlin)
-- endregion
-- region Lesson 2 - rand, irand, scramble, shuffle, choose + more
-- Let's start with a look at the 'rand' waveform that we
-- met in the last lesson:
d1 $ n "1*8" # sound "drum"
# speed (range 1 8 rand)
-- The 'resetCycles' resets the cycle count to '0', as
-- though you'd just started Tidal:
resetCycles
-- If you run resetCycles while the above pattern is running,
-- you'll notice that you also reset the random stream. You
-- will always get the same 'random' numbers every time you
-- start or reset Tidal.
-- You can apply rand to any numerical effect, but might have
-- to adjust the range. For example with the low pass filter
-- that cuts out frequencies higher than the given amount:
d1 $ sound "drum:5(5,8,<0 4>)"
# lpf (range 200 8000 rand)
# lpq 0.2
-- 'irand' is similar to 'rand', but creates integers, or
-- whole numbers, from 0 up to (and not including) the given
-- number. This is particularly useful for the 'n' and
-- 'note' controls:
d1 $ sound "rash(5,8)" # n (irand 32)
# room 0.3 # sz 0.5
-- There are a couple of ways of doing random things in the
-- mininotation too. To randomly choose between subsequences,
-- put a | (vertical bar) between them
-- The second step in this sequence is a randomly pick from
-- four subsequences:
d1 $ n "0 [0|1*3|2*8|3 4 5] 2 3" # sound "cpu"
# speed 1.5
-- Also, ? randomly 'drops' an event. In the following the
-- second step has a 50-50 chance of being played.
d1 $ sound "kick clap? kick snare"
# delay 0.3 # delaytime (1/3) # delayfb 0.8 # speed 1.5
-- (I've added some echo delay to make it sound cool. Delay is the
-- amount of sound to be delayed, delaytime is the length of the
-- echo, delayfb is the feedback of the delay into itself)
-- You can adjust the probability of ? working with a decimal
-- (floating point) number. For example, to have an 80% chance
-- of dropping that clap (and therefore 20% chance of playing
-- it)
d1 $ sound "kick clap?0.8 kick snare"
# speed 1.5
-- If you apply ? to a subsequence, it'll work individually
-- on each value in the subsequence
d1 $ sound "kick [clap:4 off clap:5]? kick snare"
# speed 1.5
d1 $ sound "bd*8? clap:4"
-- Ok, onward to functions, starting with scramble. scramble
-- takes a number, which is the number of parts to equally
-- divide a pattern into. It'll then play those parts at
-- random.
d1 $ scramble 4 $ n "0 1 2 3 4 5 6 7" # sound "arpy"
# room 0.3 # sz 0.8
-- The above is divided into four parts, and there are
-- eight events in them, so they are played in pairs. This
-- means that 0 is always followed by 1, 2 is always followed
-- by 3, and so on.
-- shuffle takes the same parameters as scramble, and sounds
-- very similar. Can you hear the difference?
d1 $ shuffle 4 $ n "0 1 2 3 4 5 6 7" # sound "arpy"
# room 0.3 # sz 0.8
-- Whereas scramble picks part at random, shuffle plays the
-- parts in random order. The difference is that with shuffle,
-- every cycle, you'll hear each part exactly once. With
-- scramble, there's a (small) chance that you'll hear only
-- one part, played four times.
-- You can maybe hear this better if you play a clap at the
-- same time, to mark the start of the cycle. Then you can
-- hear that parts aren't repeating within the cycle.
d1 $ shuffle 4 $ n "0 1 2 3 4 5 6 7" # sound "arpy"
# room 0.3 # sz 0.8
d2 $ sound "clap"
-- The "choose" function is for when you want to pick between
-- single values. It produces a continuous stream, with no
-- structure, so the following won't produce any events:
d1 $ sound (choose ["bd", "arpy", "snare"])
-- You'll need to provide some structure, with a function like
-- 'segment', which in this case picks 8 values per cycle:
d1 $ sound (segment 8 $ choose ["bd", "arpy", "snare"])
-- Or 'struct', which picks values according to a binary pattern:
d1 $ sound (struct "t t ~ t" $ choose ["bd", "arpy", "kick"])
d1 $ sound (struct "t(5,8)" $ choose ["bd", "arpy", "kick"])
-- Or by combining it with a pattern that *does* have structure:
d1 $ squiz "0*2 4 2 5 0 6*2 4 7"
# sound (choose ["bd", "arpy", "kick"])
-- Another 'gotcha' - the parameters to choose are a list of values,
-- *not*, patterns, so you can't normally use mininotation there.
-- This *won't* work.
d1 $ squiz "0*2 4 2 5 0 6*2 4 7"
# sound (choose ["bd*5", "arpy*2", "kick clap"])
-- I'll try to fix this in a future version of tidal! There is a
-- workaround, which is to use the 'innerJoin' function. Then you
-- can choose between patterns:
d1 $ squiz "0*2 4 2 5 0 6*2 4 7"
# sound (innerJoin $ choose ["bd*5", "arpy*2", "kick clap"])
-- You can use choose with any parameter.
-- For example:
d1 $ sound "clap:4(3,8)"
# speed (choose [2,5,0.5])
-- The following example is a bit different to the above, because
-- a new value is chosen only once per cycle:
d1 $ sound "clap:4(3,8)"
# speed "[2|5|0.5]"
-- You could get the same behaviour from choose with 'segment'ing it
-- by a cycle:
d1 $ sound "clap:4(3,8)"
# speed (segment 1 $ choose [2,5,0.5])
-- The 'wchoose' function is like 'choose', but you can give
-- a 'weighting' for each possibility. So something with a weighting
-- of '4' would be twice as likely to be chosen as one with a weighting
-- of '2', for example:
d1 $ sound "clap*4" # speed (wchoose [(2, 4), (-2, 2)])
-- The above claps will play either with a speed of '2' , or '-2'.
-- You can hear that negative speeds cause sounds to play backwards!
-- '2' has a weighting of '4', and '-2' has a weighting of
-- '2', so is half as likely to play.
-- Here I've weighted things so you get a lot of kicks, occasional
-- claps, and rarer snares:
d1 $ squiz "1 4*8 8*2 0*3"
# sound (wchoose [("bd", 8), ("snare", 0.5), ("clap", 1)])
-- Ok one more thing! In Tidal, randomness is "deterministic". At
-- a certain cycle time, you will always get the same number. We
-- saw this at the start of the lesson, with resetCycles. That
-- resets the cycle count, as if you just started Tidal up. You
-- can then hear that the 'random' numbers are the same.
-- This can result in unexpected results.
-- Listen to this:
d1 $ sound "clap*2" # speed (range 0.1 2 rand) # pan rand
-- You can hear that on the left speaker, the 'speed' of the
-- sound is always low, and when it pans to the right, it's
-- always high. Strange! This is because the same 'random'
-- number stream is used for both the speed and the pan, so
-- they get the same numbers, and seem to interact.
-- This can be nice! But if you don't want this effect, you can
-- avoid it by manipulating the timeline of one of the random
-- patterns. For example:
d1 $ sound "clap*2" # speed (range 0.1 2 rand)
# pan (slow 1.001 rand)
-- I only slowed that 'rand' down by a tiny amount, but that's
-- enough to end up with totally different numbers.. So now
-- you're as likely to get lower speeds on the left as on the right.
-- endregion
-- region Lesson 3 - randcat, stripe, degrade, someX, randslice + more
-- randcat
-- randcat is a variant of cat, which we haven't actually looked at
-- yet, so lets start with that..
d1 $ sound (cat ["kick snare:4 [~ kick] snare:5", "kick snare:4 . hc(5,8)"])
-- So you can hear that cat 'concatenates' patterns - it plays them
-- one after the other, in order.
-- randcat on the other hand, plays them in random order:
d1 $ sound (randcat ["kick snare:4 [~ kick] snare:5", "kick snare:4 . hc(5,8)"])
-- You can give it as many patterns to choose from as you like:
d1 $ sound (randcat ["kick snare:4 [~ kick] snare:5",
"kick snare:4 . hc(5,8)",
"snare:3(9,16)"
]
)
-- You can use it to randomise control patterns other than sound,
-- e.g. the vowel effect:
d1 $ vowel (randcat ["a e*2 i o", "e o u", "o*8"])
# sound ("kick snare:4 clap:4")
-- wrandcat is to randcat, what wchoose is to choose. That is,
-- You can give the choices relative probabilities:
d1 $ sound (wrandcat [("bd sn:4(3,8)", 1),
("arpy clap", 0.5),
("cpu(5,8)", 0.25)
]
)
-- stripe is a weird one. Lets start with a rhythm with the
-- cpu2 samples:
d1 $ n "0 4*2 ~ 4 2 4 5 ~" # sound "cpu2"
# squiz 2
-- 'fast 2' would squeeze that into two cycles:
d1 $ fast 2 $ n "0 4*2 ~ 4 2 4 5 ~" # sound "cpu2"
# squiz 2
-- stripe is similar, but the cycles are random durations,
-- although still fit the cycle:
d1 $ stripe 2 $ n "0 4*2 ~ 4 2 4 5 ~" # sound "cpu2"
# squiz 2
-- It sounds random, but against a straight clap, you can hear
-- every other repetition still perfectly aligns with the cycle:
d2 $ sound "clap:4"
-- degrade - remember the ? mininotation modifier in the previous
-- video? It drops events at random:
d1 $ sound "bd*8?"
-- Degrade is a function that does the same:
d1 $ degrade $ sound "bd*8"
-- Just like this:
d1 $ sound "bd*8?0.6"
-- You can specify a probability, by using 'degradeBy'. E.g.,
-- to give each event a 60% chance of being 'lost':
d1 $ degradeBy 0.6 $ sound "bd*8"
-- 'sometimes' applies a function to a pattern, but only sometimes.
-- lets hurry this rhythm, but only sometimes:
d1 $ sometimes (hurry 2) $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
-- Here's the original, which sounds pretty boring in comparison:
d1 $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
-- You can use it to apply effects as well.
d1 $ sometimes (# crush 4) $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
-- There's also a 'sometimesBy' variant, for specifying a
-- probability:
d1 $ sometimesBy 0.3 (# crush 4) $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
-- There's some aliases for different probabilities:
{-
sometimes = sometimesBy 0.5
often = sometimesBy 0.75
rarely = sometimesBy 0.25
almostNever = sometimesBy 0.1
almostAlways = sometimesBy 0.9
-}
-- So you can do this:
d1 $ rarely (# crush 4) $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
-- somecycles is similar to sometimes, but works on whole
-- cycles at a time, rather than individual events:
d1 $ somecycles (hurry 2) $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
# speed 1.5
-- Again, there's a 'somecyclesBy' variant for being specific
-- about that probability. To apply the squiz, 90% of the time:
d1 $ somecyclesBy 0.9 (# squiz 4) $ n "0 ~ 3 1 5 2 ~ 5" # sound "cpu"
# speed 1.5
-- randslice is a bit like 'slice' that we met a couple of lessons
-- ago:
d1 $ slice 4 "0 1 2 3" $ sound "break:8"
-- Instead of taking a pattern of slices though, it picks slices at
-- random. So to play a random quarter of this break:
d1 $ randslice 4 $ sound "break:8"
-- We can use 'loopAt' to fit them to a cycle, just like we saw before
-- with 'chop' and 'striate':
d1 $ loopAt 1 $ randslice 4 $ sound "break:8*4"
-- We could also do the same sort of thing by giving 'slice' or 'splice'
-- a random pattern:
d1 $ splice 4 (segment 4 $ irand 4) $ sound "break:8"
-- endregion
-- region Exercises:
-- TODO Play with delay
# delay 0.3 # delaytime (1/3) # delayfb 0.8 # speed 1.5
-- TODO Play with negative speed, e.g. backward clap
once $ s "glitch:7" # gain 1.1
-- d5
d1 $ sound "[bd(5,8), [~ cp]]"
# speed (range 0.5 4 perlin)
# gain 0.8
-- Study: "Oh boy! So much fun applying the lessons learned so far."
setcps (75/60/4)
xfadeIn 1 8 $ jux (iter 2) $ loopAt 6 $ chop 1 $ striate 64 $ speed (struct "t(2,7)" $ range 0.7 1 sine) # sound "bev" # gain 0.7 # delay 1 # delaytime 0.675 # delayfb 0.8 # room 0.2
d2 $ juxBy 0 (iter 4) $ rev $ struct "t(5,8)" $ sound "tabla" # n "<21 24> <16 6> <4 12>" # gain 0.8
-- endregion
study/club/w5.tidal 0 → 100644
-- region Lesson 1 musical notes
-- If you 'run' a pattern by itself, without a 'd1' or so, then Tidal
-- will do its best at telling you what's in the first cycle. For
-- example:
note "3"
-- gives:
-- (0>1)|note: 3.0f
-- 0>1 tells you it's an event that starts at position 0 (the start of
-- the first cycle) and lasts up to 1 (the start of the next cycle).
-- note is the name of the 'control' or 'effect' 3.0f is the value
-- ('f' tells you that it's a floating point, decimal number).
note "3 ~ 5"
-- the above gives two events:
-- (0>⅓)|note: 3.0f
-- (⅔>1)|note: 5.0f
-- We can listen to them:
d1 $ note "3 ~ 5" # s "superpiano"
-- Great notes!
-- (.. if you don't hear any, you probably need to install "sc3plugins".)
-- Tidal can also understand note names, and turn them into numbers
-- for you.
-- For example 'c' is the same as '0'
note "c"
-- This:
note "a b c d e f g"
-- is the same as:
note "9 11 0 2 4 5 7"
-- What happened to 1, 3, 6, 8, and 10?
-- You can get to them by adding 's' for 'sharp', to add 1 to a note:
note "cs ds fs gs as"
-- or by using 'f' for 'flat' to subtract 1:
note "df ef gf af bf"
-- In theory, you can get to them all via really sharp 'c'
-- notes. These two notes are identical:
d1 $ note "csssssss g" # s "superpiano"
-- In practice, that surely doesn't make a lot of sense.
-- Normally, there are twelve notes in an octave. The default octave
-- is 5, you can pick notes from other octaves by adding a different
-- number:
note "c5 c6 c4 c6"
-- Lets have a listen
d1 $ note "c5 c6 c4 c6" # s "superpiano"
-- Lets think about the difference between 'note', 'n', synths and
-- samples.
-- There is no folder of samples called 'superpiano', the sounds you
-- hear are being synthesised on-the-fly.
-- With synths, you can use either 'note' or 'n' to specify notes,
-- they mean the same thing.
d1 $ n "c a f e" # s "superpiano"
d1 $ note "c a f e" # s "superpiano"
-- For samples, they mean something different. 'n' chooses a sample,
-- 'note' plays it at a different speed, corresponding to a note.
-- Different sounds:
d1 $ n "0 1" # sound "dsynth"
-- Different notes:
d1 $ note "0 1" # sound "dsynth"
-- If you pick a high note, then you'll notice the sound is a lot
-- shorter, because it's making it higher by playing it faster.
d1 $ note "0 24" # sound "dsynth"
-- You might feel that's not good, because it doesn't sound as natural
-- as a synthesiser
-- You might feel that's great, because nature is a myth and this is
-- how old school 'tracker' music from early rave music and the
-- demoscene works
-- You might change your mind on different days
-- You can still use note names in mininotation:
d1 $ note "c a f e" # sound "dsynth"
-- (Actually you can use do this in any control/effect pattern that
-- expects a number.. Tidal just treats them as numbers)
-- This dsynth sample is in 'c'. If it wasn't, the notes would
-- probably sound out of tune with another synth or samplebank.
-- The 'dbass' sample has three bass sounds, again in 'c', of
-- different lengths. So it makes sense to use *both* 'note' and 'n'
-- together, to pattern both the pitch and the sample that's used:
d1 $ note "c a f e" # sound "dbass" # n "<0 1 2>"
-- The 'rash' samplebank is organised differently.. There's a load of
-- samples, one for each note of 6 octaves. There's 12 notes in an
-- octave, so that's 72 samples. (actually there's 73, there's an
-- extra one note-084.wav which you could delete..) I sampled these
-- from my lovely Roland JV1080 synth.
-- So you can play notes as numbers using the 'n' instead of the
-- 'note' pattern. This sounds a bit more 'natural' than pitching them
-- up with 'note'.
d1 $ n "20 50" # sound "rash"
-- You can still use note names, but whereas for synths '0' is *middle*
-- c, with these samples that's right at the *bottom* of the scale.
d1 $ n "c a f e" # sound "rash"
-- So in this case you'll want to pick a higher octave
d1 $ n "c7 a7 f8 e7" # sound "rash"
-- I tend to add a few octaves like this:
d1 $ n "c a f e" # sound "rash"
|+ n 24
-- Adding notes together is fun :
d1 $ n "c a f e" # sound "rash"
|+ n 24
|+ n "<0 2 7 12>"
-- You can also do it this way, adding together number patterns
-- 'inside' a single control pattern
d1 $ n ("c a f e" |+ 24 |+ "<0 2 7 12>")
# sound "rash"
-- There's also an 'octave' control to jump up/down in twelves:
d1 $ note "c a f e" # sound "superpiano"
# octave "<4 6 3>"
-- endregion
-- region Lesson 2 chords / arpeggios / AlgoKaraoke
-- Ok chords! We can play a 'major' chord like this:
d1 $ n "'maj" # sound "supermandolin"
# legato 2 # gain 1.4
-- The default is c major, you can choose others like this, e.g. to
-- play c then e major:
d1 $ n "c'maj e'maj" # sound "supermandolin"
# legato 2 # gain 1.4
-- Karaoke (algoraoke) time
-- Lets take the chord from a well known song:
-- https://ukutabs.com/r/radiohead/creep/
d1 $ n "<g'maj b'maj c'maj c'min>" # s "supermandolin"
# room 0.6 # sz 0.9
-- and strum it a bit with struct:
d1
$ qtrigger 1
$ jux ((|- n "12") . rev)
$ struct "t(5,8,<0 4>)"
$ n "<g'maj b'maj c'maj c'min>" # s "supermandolin"
# room 0.6 # sz 0.9
-- You can get a list of all the chords like this:
import Sound.Tidal.Chords
chordList
-- Try some out:
d1 $ n "c'sevenFlat9 a'm9sharp5" # sound "supermandolin"
-- Here's the raw data:
chordTable
-- Again, this all ends up being turned into plain note numbers. These
-- two patterns are the same:
d1 $ n "c'sevenFlat9 a'm9sharp5" # sound "supermandolin"
d1 $ n "[0,4,7,10,13] [9,10,23]" # sound "supermandolin"
-- You can say how many notes you want in a chord, with another ' and
-- the number of notes you want.
-- If you ask for more notes than exist in the basic chord, it will go
-- up the octaves to find more notes, sounding more and more impressive:
d1 $ n "c'maj'4" # s "superpiano"
d1 $ n "c'maj'8" # s "superpiano"
d1 $ n "c'maj'4" # s "superpiano"
-- This is clearer when we start doing.. ARPEGGIOS
-- These are 'broken' chords, where instead of playing the notes at
-- once, they're played one after another:
d1 $ arpeggiate $ n "c'maj" # s "superpiano"
-- The arpeggio happens within the 'step' that the chord occupies:
d1 $ arpeggiate $ n "c'maj e'min7" # s "superpiano"
-- Above, you can hear major chords have three notes, and minor 7
-- chords have four. You can modify that with ' so they have the same
-- number, if you want:
d1 $ arpeggiate $ n "c'maj'4 e'min7'4" # s "superpiano"
-- "arpeggiate" has a shorter, but more flexible cousin "arp", that
-- allows you to specify a different way of breaking up the chord:
d1 $ arp "updown thumbup" $ n "<c'maj'4 e'min7'4>" # s "superpiano"
-- Here's the list of currently available arp styles to explore:
-- up, down, updown, downup, converge, diverge, disconverge, pinkyup,
-- pinkyupdown, thumbup thumbupdown
-- Lots of fun
d1 $ jux rev $ arp "<updown thumbup pinkyupdown converge diverge>"
$ n "<c4'maj'6 e4'min7'8 g5'maj'5 a5'maj'4>" # s "superpiano"
# room 0.3 # sz 0.7
-- endregion
-- region Lesson
-- endregion
-- region Lesson
-- endregion
-- region Lesson
-- endregion
-- region Exercises
do
d1 $ "jazz*4" # gain 0.6
d2 $ fast "<2 [4 8]>" $ s "drum:8"
d3 $ s "~ clap:3" # hpf (slow 40 $ range 1000 7500 sine)
d4 $ n ("<c4'maj!4 c4'min!4>") # s "rash" # gain 0.8
-- endregion
tools/solo.tidal
solo 1
solo 2
solo 3
solo 4
solo 5
solo 6
solo 7
solo 8
solo 9
solo 10
solo 11
do
solo 1
solo 2
solo 3
solo 4
solo 5
solo 6
solo 7
solo 8
solo 9
solo 10
solo 11
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment