live: HelloFi

live/hip/lofi/hellofi.tidal

+resetCycles
+
+-- Hellofi: Major chill electrized beat
+do
+setcps (60/60/4)
+let modIndex = pF "modIndex"
+let mix = pF "mix"
+let prog = "<a g f g>"
+let chords = "c'maj'4 c'major7'2"
+let len = 64
+let outLen = 16
+let brk = 32
+let whenOut pat = whenmod len (len - outLen) pat
+let whenIn  pat = someCyclesBy "<16!8 0!48>" pat
+let whenPt1 pat = someCyclesBy "<1!32 0!32>" pat
+let whenPt2 pat = someCyclesBy "<0!32 1!32>" pat
+let whenPt2Begin pat = someCyclesBy "<0!32 1!8 0!20>" pat
+let loopLPF = (whenmod brk (brk - 8) (# lpf ("<12 10 10 8 8 5 5 2>" * 100)))
+let whenInFade  = whenIn  (|* gain (slow outLen $ range 0.8 1   saw))
+let whenOutFade = whenOut (|* gain (slow outLen $ range 1 0.2   saw))
+let whenOutHPF  = whenOut (|* hpf  (slow outLen $ range 0 10000 saw))
+let g = loopLPF
+d1 $ g -- Kick
+  $ whenIn (mask "<f!7 [f t] t(2,4)!4 t(3,4) t(5,8) t(6,8) t>")
+  $ whenOutFade
+  $ whenPt2Begin (degradeBy "<1!3 [1!3 0.5] 0.5!3 [1!3 0]>")
+  $ whenPt2 (fast 2 . (<| "k . <[k ~ <k k*2> <k ~>] . k(<3!3 5>,8)>"))
+  $ whenPt1 (<| "k [~|k*4] . ~ [<k <~ k>> <~ k>]")
+  $ "jazz"
+  # attack 0.97
+  # gain 3
+d2 $ g -- Clap contretemps
+  $ whenIn (mask "<f!7 t f!4 t!4>")
+  $ whenOutFade
+  $ whenPt2Begin (# room (slow 8 $ range 0.4 0 saw))
+  $ superimpose ( -- Equalize
+    (# hpf 2000) . (# lpf 10000) . (|* gain 1.1)
+  )
+  $ "~ cp"
+  # lpf 500
+  # gain (slow 4 $ range 0.5 0.95 saw)
+  # dry 1
+  # pan 0.6
+d3 $ g -- Drumroll léger
+  $ whenIn (mask "<f!3 t!13>" . slow "16 [8 4] 4 [4 2] 2!4 [2 1]!4 [2 1!3]!3 1")
+  $ whenOutFade
+  $ whenPt2Begin (degradeBy (1 - (slow 8 cosine)))
+  $ whenmod 8 7 (|* gain "1.05 1.1")
+  $ sometimesBy "<0.1 0.125 0.25 0.5>" (ply "<2!4 4!4>")
+  $ someCycles (degradeBy "0 0.25" . fast 2)
+  $ "dr*8" # hpf 150 # hpq 0
+  # room 0.8 # sz 0.5 # dry 1
+  # gain (slow 8 $ range 0.5 0.8 saw)
+  # pan  (slow 4 $ range 0.3 0.5 saw)
+d4 $ g -- Bassline doublée
+  $ whenIn (mask "<f!4 t!12>")
+  $ whenOutFade
+  $ whenOut ((# lpf 5000) . (# lpq 0.2))
+  $ whenmod 4 3 (swingBy (1/3) "8")
+  $ whenPt2 (whenmod 4 3 (# cut 4))
+  $ juxBy 0.75 rev -- JUX REV DOUBLE
+  $ sometimesBy "<0 0.25 0.5 1>" (off "0.125" id)
+  $ arp "up"
+  $ note (prog |+| "c2'maj*4")
+  # "bassWarsaw"
+  # gain 0.75
+  # room (slow 32 $ range 0 0.8 saw)
+  # sz 0.5
+d5 $ g -- FMRhodes base
+  $ whenInFade
+  $ whenOutHPF
+  $ whenmod 16 4 (superimpose (# modIndex 5))
+  $ note (
+    prog
+    |+| "<0 0 [0 . ~ ~ <-5 ~> -3] [0 . ~ ~ 0]>"
+    |+| "0 . 0(3,8)"
+    - 12
+  )
+  # "FMRhodes1"
+  # cut 42
+  # room 0.4
+  # gain 0.95
+  # pan 0.3
+  # mix 1.15
+  # modIndex 0
+d6 $ g -- FMRhodes arps électriques
+  $ whenIn (mask "f!8 t!8")
+  $ whenInFade
+  $ whenOutHPF
+  $ whenmod 32 16 (# modIndex (slow 8 $ range 0 3 perlin))
+  $ note (prog
+    + "0 . 0*<1 2 4 [8 4]> 0"
+    + ( -- Remplissage accords
+      slow (slow 4 "<16 8 4 4 4 2 2 1>") $ -- Éclairci
+      arp "updown" chords)
+    + "0 12 0"
+    - 24
+  )
+  # "FMRhodes2"
+  # mix 1.15
+  # gain 0.9
+  # pan 0.2
+d7 -- Carillons back
+  $ g
+  $ whenIn (slow "<4!8 2!8>")
+  $ whenInFade
+  $ whenOutHPF
+  $ juxBy 0.5 (rev . fast 4)
+  $ fix ((# "808hc:0") . (|* gain 0.85)) "h"
+  $ fix (# "808mc:<4 3 2 3>") "m"
+  $ fix ((# "808lc") . (# n (slow 4 "<0 0 0 2>"))) "l"
+  $ "~ l <~ [~ ~ ~ <h!3 m>]> l"
+  # room 0.5 # sz 0.8 # dry 0.8
+  # gain (slow 16 $ range 0.5 0.8 saw)
+d8 $ g -- Final choirs
+  $ whenOut (# gain (0.8 * (slow outLen $ range 0.5 1 saw)))
+  $ someCyclesBy "0!3 1 0 1!3" (superimpose (
+    (|+ note 24)
+    . degradeBy "0 1!7"
+    . (# legato 2)
+    . (|* gain 0.87)
+    . (|+ pan 0.3)
+    ))
+  $ someCyclesBy "0!4 1 0 0 1" (juxBy 0.6 (
+    arp "up!3 down" . ply "2 4" . (|+ note 12)
+    . (|* gain 0.6)
+  ))
+  $ note (prog
+    |+| chords
+    + "-24"
+  )
+  # "moogBass"
+  # gain 0

live/midi/nova/dnb/lucy_rode.tidal

 import Sound.Tidal.ParVagues.Control
 
+once "dr"
+
 resetCycles
-setcps (80/60/4)
+setcps (60/60/4)
 
 -- Lucy Rode
 do
-  let g = id
   let chord = "ds3'major7'6"
   let chorus = pF "chorus"
   let mix = pF "mix"
   let modIndex = pF "modIndex" -- 0.2
+  let vibrato = pF "vibrato"
   let gDJF = midiDJF "^49" 100 9900 0 1500
-  let g = gDJF
-  d1 $ g -- Beat
-    $ midiOn "^41" (<| fast 2 "k k k k")
-    $ midiOn "^41" (<| fast 2 "k k k k")
-    $ midiNo "^41" "^42" (<| fast 2 "<k <k*2 k(3,8)>>")
-    $ "jazz" # midiG' "^78" 0 1.5
+  let gFreqL = (# lpq (range 0 1 "^30"))
+  let gFreqH = (# hpq (range 0 (1/16) "^29"))
+  let gFreqs = (gFreqH . gFreqL)
+  let g = gDJF . gFreqs
+  d1
+    $ g -- Beat
+    $ fast 2
+    $ midiOn "^41" (<|  "k k k k")
+    $ midiOn "^42" (<| "k . k <~ [<~ k> <k ~>]>")-- RubADub
+    $ midiNo "^41" "^42" (<| "<k <k*2 k(3,8)>>")
+    $ "jazz"
+    # midiG' "^78" 0 1.5
   d2 $ g -- Break
     $ loopAt 1
+    $ midiOn "^43" (scramble 4 . often (ply 2))
     $ midiOn "^75" (struct "t*[8 16]")
     $ slice 4 (run 4)
     $ "fbreak80:4"
@@ -56,10 +65,31 @@ do
       "<ds3'major7'4!2 <ds3'major7'4 [ds3'major7'4|ds3'major7'6]> ds3'major7'8>")
     ))
     # "bassWarsaw"
-    # midiG' "^81" 0 1.2
     # crush (range 10 2 "^53")
     # room 0.4
     # pan 0.2
+    # midiG' "^81" 0 1.3
+  d7 $ g -- Hammond
+    $ ("0.125" ~>)
+    $ fast 2
+    $ midiOn "^59" (
+      sometimesBy "^35" (superimpose
+        (# voice 7) . (|* gain 0.8)
+        . (|- note 12)
+      )
+      . sometimesBy (1 - "^35") (|* gain 0.65)
+      . fast 2
+      . (|+ note 12)
+    )
+    $ note (("[0 12 0 <~!6 12!2>]" |+ (slow 2 $ arpeggiate chord)))
+    # "superhammond"
+    # voice 6
+    # octave 6
+    # room 0.5 # sz 0.6
+    # pan 0.74
+    # sustain (range 0.125 0.5 "^55")
+    # midiG' "^83" 0 1
+
 
 
   d2