Strudel

Strudel

Strudel is TidalCycles in JavaScript. A track is one expression that describes a cycle; the REPL plays that cycle forever until you change it. You write one file, track.strudel, and the pane plays it — a save hot-swaps the pattern on the next cycle without stopping the transport.

The whole file is evaluated as ECMAScript 2022 (top-level await allowed), so JavaScript syntax rules apply: balanced brackets, balanced quotes, // and /* */ comments. There is no module loader — never write import or require. Everything Strudel offers is already in scope.

Check after every save:

python3 "$STRUDEL_TOOLCHAIN/verdict.py"          # track.strudel
python3 "$STRUDEL_TOOLCHAIN/verdict.py" b.strudel

It parses the file with the same parser the REPL uses, checks offline sound sources, and writes .harness/verdict.json, which is what the pane header shows. It does not listen to the music. Playing is the pane's job; musical quality needs listening and judgment.

Offline first: use synths, not samples

The REPL preloads sample maps from GitHub at start and fetches each .wav the first time it is triggered. So s("bd sd hh") needs the internet, twice. These sound sources need nothing:

Build drums out of those: s("sbd*4") is the kick, short noise is the snare and the hats.

stack(
  s("sbd*4").decay(0.24).lpf(280),
  s("~ white ~ white").decay(0.11).sustain(0).hpf(1200).gain(0.5),
  s("white*8").decay(0.03).sustain(0).hpf(7000).gain("[0.3 0.14]*4")
)

Reach for bd sd hh oh rim cp and .bank("RolandTR909") only when the user wants real drum machines and has a connection. Say so when you do; the verdict warns about it too.

If you set note() and no s(), the sound defaults to triangle — already offline.

Mini-notation

Everything inside a double-quoted string is mini-notation. Single quotes are a plain string, not a pattern.

s("bd [hh hh] sd [hh bd]")                      // subdivision
note("<c2!2 g1!2 as1!2 f1!2>(3,8)").s("sawtooth") // 8 bars of euclidean bass
s("[bd sd]*2, white*8")                          // two voices in one string
n("<4 [3@3 4] [<2 0> ~] ~>").scale("d4:minor")   // weights and nesting

Notes, scales, chords

• note("c3 e3 g3") — letters a–g, b/#, optional octave 0–9, default octave 3. MIDI numbers work too (note("48 55"), 69 = A4).
• n("0 2 4").scale("c4:minor") — degrees of a scale, zero-indexed, negatives wrap backwards. The scale name takes no spaces: "c:minor", "f#4:mixolydian", "a:harmonic:minor".
• [c3,eb3,g3] inside a pattern is a chord — a stack of notes in one slot.
• n("0 1 2 3").chord("<C Am F G>").voicing() builds voicings from chord symbols.
• .arp("0 [0,2] 1 [0,2]") spreads a stacked chord over time. It takes a pattern of indices, not mode names like "up".

note("<[c3,ds3,g3] [g2,as2,d3] [as2,d3,f3] [f2,gs2,c3]>")
  .s("supersaw").unison(5).spread(0.45).attack(0.5).release(1.2).room(0.6)

Shaping the sound

• Envelope attack/att, decay/dec, sustain/sus, release/rel, or all four at once as .adsr(".1:.1:.5:.2"). clip (alias legato) multiplies note length.
• Filter lpf (aliases cutoff, lp), hpf, bpf; resonance is lpq (alias resonance, 0–50), hpq, bpq. ftype picks 12db / ladder / 24db.
• Filter envelope lpattack lpdecay lpsustain lprelease lpenv (short: lpa lpd lps lpr lpe). lpenv is the depth and may be negative.
• Space room (0–1) with roomsize (alias rsize/size, 0–10 — change it sparsely); delay, delaytime/dt, delayfeedback/dfb. orbit(n) gives a voice its own reverb and delay bus; patterns on the same orbit share one.
• Colour distort (prefer it over the deprecated shape), crush (1 crunchy … 16 clean), coarse, vowel("<a e i o u>"), phaser.
• Level and place gain, postgain, pan (0 left … 1 right).

Many of these take several values through : — lpf("1000:10") is cutoff and resonance, delay("0.65:0.25:0.9") is level, time and feedback, room("0.9:4") is level and size.

note("c3 bb2 f3 eb3").s("sawtooth").lpf(600).adsr(".1:.1:.5:.2")
note("c2 e2 f2 g2").s("sawtooth").lpf(300).lpa(0.5).lpenv("<4 2 1 0 -1 -2 -4>/4")

Moving the pattern

rev palindrome iter(4) chunk(4, f) ply(2) off(1/16, f) superimpose(f) layer(f) jux(rev) juxBy(0.5, f) segment(16) struct("x ~ x x") mask("1 0") degradeBy(0.3) sometimes(f) sometimesBy(0.4, f) often (0.75) rarely (0.25) almostAlways (0.9) someCyclesBy(p, f) every(4, f) slow(2) fast(2) euclid(3,8) euclidRot(3,8,1) euclidLegato(3,8) add(note("12")) echo(3, 1/8, 0.5) linger swingBy(1/3, 4) hurry(2).

n("0 1 [4 3] 2 0 2 [~ 3] 4").s("triangle").jux(rev)
s("white*8").sometimesBy(0.4, x => x.hpf(2000).gain(0.4))
n("0 [4 <3 2>] <2 3> [~ 1]".off(1/16, x => x.add(4))).scale("c5:minor").s("triangle").dec(0.1)

Signals as modulators

sine cosine saw isaw tri square rand perlin run 0…1 (the …2 variants, sine2 saw2 rand2, run −1…1); irand(n) is called as a function. Shape them with .range(lo, hi) (or .rangex for exponential) and slow them with .slow(n).

note("<[c2 c3]*4 [bb1 bb2]*4>").s("sawtooth").lpf(sine.range(100, 2000).slow(4))
n(saw.range(0, 8).segment(8)).scale("c:major")
n(irand(8)).struct("x x*2 x x*3").scale("c:minor")

The catch worth knowing: a signal is sampled once per event, not continuously. A pad held for a whole cycle gets one filter value per note, not a sweep. Add events to hear the movement:

s("supersaw").seg(16).lpf(tri.range(100, 5000).slow(2))

Envelopes are continuous in time: attack/decay/release, the pitch envelope (penv, pattack, pdecay), the filter envelopes, tremolo, phaser, vib.