Version: 1.0
Recipes: 50+ Common Patterns and Techniques
This cookbook provides practical examples and recipes for creating music with the TidalCycles-inspired DSL for Turmeric.
(import tidal tidal/synth scscm)
;; Connect to scsynth
(def session (scscm-connect))
;; Create a simple pattern
(def pattern (cycle 220.0 440.0 880.0))
;; Create a player
(def player (make-player session "sine" pattern 120.0))
;; Start playing
(player-start player)
;; Stop playing
(player-stop player)
(def track (stack
;; Bass
(slow 4 (note-pattern (cycle 36 40 43 48)))
;; Melody
(note-pattern (cycle 60 64 67 72))
;; Drums
(stack
(kick [0.0 2.0])
(snare [1.0 3.0])
(hat [0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5]))
))
(def player (make-player session "sine" track 120.0))
(player-start player)
(def basic-beat (stack
(kick [0.0 2.0])
(snare [1.0 3.0])
(hat [0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5])))
(def rock-beat (stack
(kick [0.0 2.0] :vel 120)
(kick [1.0 3.0] :vel 90) ;; Ghost notes
(snare [1.0 3.0] :vel 110)
(hat [0.0 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5 2.75 3.0 3.25 3.5 3.75] :vel 70)))
(def house-beat (stack
(kick [0.0 1.0 2.0 3.0] :vel 127)
(snare [1.0 3.0] :vel 100)
(hat [0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5] :vel 80)
(cymbal [4.0 8.0 12.0 16.0] :vel 90)))
(def techno-beat (stack
(kick [0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5] :vel 120)
(snare [1.0 3.0] :vel 100)
(hat [0.0 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5 2.75 3.0 3.25 3.5 3.75] :vel 60)
(cymbal [0.0 4.0 8.0 12.0] :vel 80)))
(def hiphop-beat (stack
(kick [0.0 1.0] :vel 127)
(kick [0.5 1.5] :vel 100)
(snare [1.0 3.0] :vel 110)
(hat [0.0 0.25 0.5 0.75 1.0 1.25 1.5 1.75] :vel 70)
(hat [0.375 0.625 0.875 1.125 1.375 1.625 1.875] :vel 60)))
(def euclid-beat (stack
(kick (euclid-to-beats (euclid 8 3)))
(snare (euclid-to-beats (euclid 8 2)))
(hat (euclid-to-beats (euclid 16 7)))))
;; Helper function
def euclid-to-beats [euclid-pat]
(filter some? (map (fn [i] (when (== (euclid-pat i) 1.0) i)) (range 0 (int (ceil (* 2 (len euclid-pat)))))))
(def beat-with-fill (stack
(kick [0.0 2.0])
(snare [1.0 3.0])
(hat [0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5])
(every 4 (stack
(snare [0.25 0.75 1.25 1.75 2.25 2.75 3.25 3.75] :vel 90)
(kick [0.5 1.5 2.5 3.5] :vel 100)) 0)))
(def melody (cycle 60 62 64 65 67 69 71 72))
(def arpeggio (arp-pattern (const [48 52 55 60]) 4.0))
;; C Major scale
(def c-major (cycle 0 2 4 5 7 9 11 12))
;; C Pentatonic scale
(def c-pentatonic (cycle 0 2 4 7 9))
;; C Minor scale
(def c-minor (cycle 0 2 3 5 7 8 10 12))
;; Whole tone scale
(def whole-tone (cycle 0 2 4 6 8 10))
;; Chromatic
(def chromatic (cycle (range 0 12)))
;; I - IV - V - I in C major
(def progression (seq
(chord-pattern (const 48) (const 52) (const 55)) ;; C major
(chord-pattern (const 53) (const 57) (const 60)) ;; F major
(chord-pattern (const 55) (const 59) (const 62)) ;; G major
(chord-pattern (const 48) (const 52) (const 55)))) ;; C major
;; Simple bass line
(def bassline (slow 4 (cycle 36 40 43 48)))
;; Walking bass
(def walking-bass (cycle 36 38 40 41 43 45 48 50))
;; Octave jumping bass
(def octave-bass (cycle 36 48 40 52 43 55 48 60))
;; Ascending then descending
(def mountain (seq
(cycle 60 62 64 65 67 69 71 72) ;; Up
(cycle 72 71 69 67 65 64 62 60))) ;; Down
;; Wave-like contour
(def wave-melody (add (const 64) (sine 0.25 8.0)))
;; Parallel fifths
(def fifths (stack
(cycle 48 50 52) ;; Root
(add (cycle 48 50 52) (const 7)))) ;; +7 semitones
;; Parallel thirds
(def thirds (stack
(cycle 48 50 52) ;; Root
(add (cycle 48 50 52) (const 4)))) ;; +4 semitones
;; Parallel octaves
(def octaves (stack
(cycle 48 50 52) ;; Root
(add (cycle 48 50 52) (const 12)))) ;; +12 semitones
;; Major triad
(def major-chord (stack
(cycle 48 50 52) ;; Root
(add (cycle 48 50 52) (const 4)) ;; Major third
(add (cycle 48 50 52) (const 7)))) ;; Fifth
;; Minor triad
(def minor-chord (stack
(cycle 48 50 52) ;; Root
(add (cycle 48 50 52) (const 3)) ;; Minor third
(add (cycle 48 50 52) (const 7)))) ;; Fifth
;; Seventh chord
(def seventh-chord (stack
(cycle 48 50 52) ;; Root
(add (cycle 48 50 52) (const 4)) ;; Major third
(add (cycle 48 50 52) (const 7)) ;; Fifth
(add (cycle 48 50 52) (const 10)))) ;; Minor seventh
;; Broken chord with 8th notes
(def broken-chord (arp-pattern (const [48 52 55]) 2.0))
;; Broken chord with 16th notes
(def fast-broken (arp-pattern (const [48 52 55 60]) 4.0))
;; Broken seventh chord
(def broken-seventh (arp-pattern (const [48 52 55 59]) 4.0))
;; First inversion (root in bass becomes third)
(def first-inversion (stack
(add (cycle 48 50 52) (const -12)) ;; Root down octave
(cycle 48 50 52) ;; Original root
(add (cycle 48 50 52) (const 4)))) ;; Third
;; Second inversion (third in bass becomes fifth)
(def second-inversion (stack
(add (cycle 48 50 52) (const -12)) ;; Root down octave
(add (cycle 48 50 52) (const -7)) ;; Fifth down octave
(add (cycle 48 50 52) (const 4)))) ;; Third
;; Slow down
(def half-speed (slow 2 melody))
;; Speed up
(def double-speed (fast 2 melody))
;; Triple time
(def triple-time (fast 3 melody))
;; Dotted rhythm (1.5x)
(def dotted (slow 0.6667 melody))
;; Delay
(def delayed (shift 0.5 melody))
;; Anticipation (negative shift)
(def anticipated (shift -0.25 melody))
;; Swing feel
(def swing (stack
(slow 1.1 (cycle 60 62 64)) ;; Even notes slightly delayed
(fast 0.9 (cycle 61 63 65)))) ;; Odd notes slightly anticipated
;; Double notes
(def double-notes (repeat 2 (cycle 60 62 64)))
;; Triple notes
(def triple-notes (repeat 3 (cycle 60 62)))
;; Tremolo effect
(def tremolo (repeat 8 (cycle 60)))
;; Group of 3 (triplet feel in 4/4)
(def triplet-group (slow 0.75 (cycle 60 62 64)))
;; Group of 5
(def quintuplet-group (slow 0.4 (cycle 60 62 64 65 67)))
;; Random pitch
(def random-pitch (jitter (cycle 60 62 64) 2.0 60.0))
;; Random velocity
(def random-vel (jitter (const 100) 20.0 100.0))
;; Random melody
(def random-melody (add (cycle 60 62 64) (jitter (const 0) 1.0 -1.0)))
(def random-walk-melody
(let [start 60]
(add (const start) (range (cycle 0 1 2 3 4) -10 10))))
;; 50% chance of playing
(def fifty-chance (when (cycle true false) melody 0))
;; 25% chance
(def twentyfive-chance (when (cycle true false false false) melody 0))
;; Random selection
(def random-notes (rand-select
(const 60)
(const 64)
(const 67)
(const 72)))
(def markov-melody
(let [base (cycle 60 62 64 67)]
(add base (jitter (const 0) 1.0 -1.0))))
;; 5 hits in 8 steps
(def euclid-5-8 (euclid 8 5))
;; 7 hits in 16 steps
(def euclid-7-16 (euclid 16 7))
;; With offset
(def euclid-offset (euclid 8 3 1))
;; Simple L-system inspired pattern
(def l-system-melody
(let [rules {"a" ["a" "b"] "b" ["a"]}]
(cycle 60 62 64 65 67 69)))
;; Fibonacci melody
(def fibonacci-melody
(let [fib [0 1 1 2 3 5 8 13 21]]
(cycle (map (fn [n] (+ 60 (mod n 24))) fib))))
;; Prime number melody
(def prime-melody
(let [primes [2 3 5 7 11 13 17 19 23]]
(cycle (map (fn [p] (+ 60 (mod p 12))) primes))))
;; 2 against 3
(def two-vs-three (stack
(polymeter 1.0 (cycle 60 62 64))
(polymeter 1.5 (cycle 67 69 71))))
;; 2 against 3 against 4
(def poly-complex (stack
(polymeter 1.0 (cycle 60 62))
(polymeter 1.5 (cycle 67 69))
(polymeter 2.0 (cycle 72 74))))
;; 4 voice canon
(def four-voice-canon (canon (cycle 60 62 64 65 67) 4 0.5))
;; 3 voice canon with different intervals
(def three-voice-canon (canon (cycle 60 64 67) 3 1.0))
;; Spread chord across stereo field
(def spread-chord (spread (chord-pattern (const 60) (const 64) (const 67)) 5 2.0))
;; 4/4 then 3/4
(def changing-meter (timesig (cycle 60 62 64) [(4.0 4) (3.0 4)]))
;; Multiple time signatures
(def complex-meter (timesig (cycle 60 62 64 65) [
(4.0 4) ;; 4 beats in 4/4
(3.0 4) ;; 3 beats in 3/4
(5.0 4) ;; 5 beats in 5/4
(7.0 8) ;; 7 beats in 7/8
])))
;; Pattern of patterns
(def nested-melody
(nest (cycle (const 60) (const 64) (const 67)) 2.0))
;; Sine wave vibrato
(def vibrato (sine 2.0 0.1))
;; Square wave tremolo
(def tremolo (square 4.0 0.5))
;; Sawtooth wave filter modulation
(def filter-mod (saw 0.5 1000.0 20000.0))
;; Vibrato + tremolo
(def modulated (stack
(add (const 64) (sine 2.0 0.1))
(mul (const 0.5) (square 4.0 0.5))))
;; Fast attack, slow release
(def pad-envelope (ar 0.001 1.0 (const true)))
;; ADSR for plucks
(def pluck-envelope (adsr 0.001 0.1 0.3 0.5 (const true)))
;; Crescendo
(def crescendo (range (phase 4.0) 0.0 1.0 0.1 1.0))
;; Diminuendo
(def diminuendo (range (phase 4.0) 0.0 1.0 1.0 0.1))
;; Swell
(def swell (range (phase 2.0) 0.0 1.0 0.0 0.5))
(def session (make-live-session 120.0))
(def player (make-player session "sine" (const 440.0) 120.0))
;; Update pattern live
(player-update player (cycle 220.0 440.0 880.0))
;; Update to transformed pattern
(player-update player (slow 2 (cycle 220.0 440.0 880.0)))
;; Set default pattern (d1)
(def d1-pattern (stack
(cycle 220.0 440.0)
(kick [0.0 2.0])))
(def d1 (swap-patterns player d1-pattern))
;; Silence all (hush)
(def hush (swap-patterns player (const 0)))
(def patterns {
:bass (slow 4 (cycle 36 40 43 48))
:melody (cycle 60 64 67 72)
:drums (stack (kick [0.0 2.0]) (snare [1.0 3.0]))
})
;; Swap to bass
(swap-patterns player (get patterns :bass))
;; Swap to melody
(swap-patterns player (get patterns :melody))
;; Use mini-notation for quick pattern entry
(player-update player (s "1 2 3 4"))
;; With operators
(player-update player (s "1*2 3*0.5"))
;; Drum notation
(player-update player (d "bd sd hh cp"))
;; Counter
(def counter (counter-pattern 10))
;; LFO with accumulating phase
(def lfo (make-stateful-pattern 0.0
(fn [phase time]
[(+ phase 0.01) (const (* 10.0 (math/sin phase)))])))
;; Use in live coding
(let [[new-state new-pat] (step-stateful counter 0.0)]
(player-update player (add (const 60) new-pat)))
;; Cache expensive patterns
(def cached-melody (cached (complex-generative-pattern) 1024))
;; Inline simple patterns
(def inlined (inline-pattern (slow 2 (cycle 1 2))))
;; Fuse consecutive operations
(def fused (fuse-pattern (slow 2 (fast 2 (cycle 1 2)))))
;; Pre-compute values
(def precomputed (const (map (fn [x] (* x 2)) (range 100))))
;; Use simple patterns when possible
(def simple (const 440.0)) ;; Faster than (cycle 440.0)
| Pattern | Code |
|---|---|
| Constant | (const x) or (P x) |
| Cycle | (cycle 1 2 3) or (P 1 2 3) |
| Phase | (phase) or (phase n) |
| Slow | (slow 2 p) |
| Fast | (fast 2 p) |
| Shift | (shift 0.5 p) |
| Sequence | (seq p1 p2 p3) |
| Stack | (stack p1 p2) |
| Sum | (sum p1 p2) |
| Every | (every 2 p 0) |
| Euclidean | (euclid 8 3) |
| Jitter | (jitter p amount base) |
| Sine | (sine freq amp) |
| Note | (note-pattern pitch vel dur gate) |
| Chord | (chord-pattern n1 n2 n3) |
| Arpeggio | (arp-pattern chord speed) |
| Kick | (kick [0 2]) |
| Snare | (snare [1 3]) |
| Hat | (hat [0 0.5 1 1.5]) |
Generated for Turmeric project - TidalCycles-like DSL Cookbook