Arranging a Track: Structure, Build and Break

You can already make an eight-bar loop that grooves — the prerequisite modules got you there. This module is about the jump that stalls most producers: turning that loop into a six-minute club track that a DJ could actually mix and a dancefloor could actually ride. In dance genres the drama does not come from verse/chorus contrast; it comes from a density arc — layers stacking into a buildup, thinning into a breakdown, peaking at the drop — so arranging here means planning blocks of time and their energy, not writing new melodies.

The arc of the module mirrors the capstone. You start supported: steal an arrangement blueprint by extracting a formal skeleton from a track you admire, so section lengths and the 8-bar phrase grammar are given, not guessed. Then you sidestep the blank canvas entirely — stack everything into one maximally dense section and sculpt downward, following the subtractive-arranging workflow to derive your quieter sections from the drop rather than building left to right. With the blocks in place, you refine the drama: assign each element a foreground, middleground or background role, and make transitions breathe using fuzzy clip boundaries, muted-kit drum variations, a trance-style snare roll, and the one-bar-early bass drop. Finally you commit to a deliberate opening and one of the three codified endings — unsupported, on your own material.

Every required atom is a gate: the capstone literally cannot be executed well without the skeleton, the dense-then-subtract procedures, the role assignments, and the transition devices. The supporting atoms deepen taste — Da Funk’s show-everything-early inversion, its single-note insistence texture, the hypnotic looped breakdown, restraint and erasure as compositional stances — enriching your choices without being demanded by the task.

Walkthrough

You can make a loop that grooves; arrangement is turning it into a track with a density arc — layers stacking and thinning over time. At strudel.cc (Ctrl-Enter play, Ctrl-. stop) we arrange by gating layers per bar and sequencing sections. Each step is a complete, playable program; let a few bars pass to hear the structure.

1 — the full, dense section. Don’t build left-to-right — stack everything first, then subtract. Here’s the maximal drop: kick, backbeat, hats, bass ([[maximal-density-arrangement]] if present).

setcpm(128/4)
$: sound("bd*4").bank("RolandTR909")
$: sound("~ sd ~ sd").bank("RolandTR909")
$: sound("hh*8").bank("RolandTR909").gain(0.5)
$: note("c2 ~ eb2 g2").sound("sawtooth").lpf(800)

2 — gate a layer per bar with mask. mask("<...>") turns a layer on/off per cycle (bar). Drop the bass out for two bars to carve a breakdown — subtraction, not new material, makes the section ([[layering-as-form]]).

setcpm(128/4)
$: sound("bd*4").bank("RolandTR909")
$: sound("~ sd ~ sd").bank("RolandTR909").mask("<1 1 1 1 0 0 1 1>")
$: note("c2 ~ eb2 g2").sound("sawtooth").lpf(800).mask("<1 1 1 1 0 0 1 1>")

3 — foreground / middle / background roles. Give each element a job: the kick is the foreground pulse, the bass the middleground, a filtered pad the background bed. Balance their gains so they sit in a hierarchy, not a pile ([[foreground-middleground-background]]).

setcpm(128/4)
$: sound("bd*4").bank("RolandTR909").gain(1)
$: note("c2 ~ eb2 g2").sound("sawtooth").lpf(800).gain(0.8)
$: note("<[c4,eb4,g4] [g3,bb3,d4]>").sound("sawtooth").lpf(600).gain(0.35)

4 — a buildup fill before the drop. Tension devices land on the bar before a section change: a snare roll that accelerates (sd*16 on the 8th bar) and a filter opening. This is the trance-style build ([[snare-roll-build]] if present).

setcpm(128/4)
$: sound("bd*4").bank("RolandTR909")
$: sound("sd*16").bank("RolandTR909").mask("<0 0 0 0 0 0 0 1>").gain(saw.range(0.2, 0.9))

5 — sequence sections over time with arrange. arrange([bars, pattern], ...) plays each section for N bars then moves on — an intro, a drop, a breakdown, the drop again. Now it’s a timeline, not a loop:

setcpm(128/4)
arrange(
  [4, sound("bd*4, hh*8").bank("RolandTR909")],
  [8, stack(sound("bd*4, ~ sd, hh*8").bank("RolandTR909"), note("c2 ~ eb2 g2").sound("sawtooth").lpf(800))],
  [4, note("c2 ~ eb2 g2").sound("sawtooth").lpf(500).room(0.4)]
)

6 — a full arrangement with a start and an ending (the capstone). A deliberate opening (drums ease in), a build, the full drop, a breakdown, and one of the codified endings — here a clean cut to a filtered tail. The whole density arc in one expression:

setcpm(128/4)
arrange(
  [4, sound("hh*8").bank("RolandTR909").gain(0.5)],
  [4, sound("bd*4, hh*8").bank("RolandTR909")],
  [8, stack(sound("bd*4, ~ sd, hh*8").bank("RolandTR909"), note("c2 ~ eb2 g2").sound("sawtooth").lpf(sine.range(500,1500).slow(8)))],
  [4, note("<[c4,eb4,g4] [g3,bb3,d4]>").sound("sawtooth").lpf(500).gain(0.4)],
  [8, stack(sound("bd*4, ~ sd, hh*8").bank("RolandTR909"), note("c2 ~ eb2 g2").sound("sawtooth").lpf(1200))],
  [2, note("c2").sound("sawtooth").lpf(400).gain(0.5)]
)

What good sounds like. A track that goes somewhere: energy should rise and fall in clear blocks, the drop should hit harder because a breakdown emptied the space before it, and every section boundary should feel intentional (a fill, a filter, a drop-out — never an abrupt change with no setup). If it feels flat, your sections are too similar (subtract more in the quiet ones); if it feels random, changes aren’t landing on 4- or 8-bar boundaries. Subtraction is the main tool — the drop is loud because the breakdown was empty. (Skill map: live-coder Domain B4 / C2 — arrangement and the set arc.)

Now make it yours. Change the section lengths in arrange. Add a one-bar-early bass drop (start the bass at bar 8 of the buildup). Swap the ending for a long reverb tail or a hard stop. Introduce a call-and-response by masking two layers with complementary patterns (<1 0> and <0 1>).

Runnable examples

Generated from the context/ instrument corpus by concept (redistributable idioms only). Do not edit — regenerate with gen-module-examples.mjs.

every-n-transform

s("bd sd hh cp").every(4, rev)

_{strudel-0028 · CC0}

d1 $ iter 4 $ sound "bd sn hh cp"

_{tidal-0045 · CC0}

lowpass-sweep

Noise n => LPF f => dac; 0.2 => n.gain;

_{chuck-0003 · MIT}

s("hh*8").lpf(sine.range(200,4000).slow(4))

_{strudel-0015 · CC0}

highpass-sweep

s("hh*8").hpf(saw.range(200,4000).slow(4))

_{strudel-0016 · CC0}

hpf (400 ~~ 4000 $ osc 0.1) 1 (saw 55) >> audio

_{punctual-0008 · CC0-1.0}

resonant-filter

SinOsc s => LPF f => dac; 400 => f.freq;

_{chuck-0002 · MIT}

play :e2, cutoff: 90, res: 0.9, release: 0.3

_{sonicpi-0022 · CC0}

call-and-response

cat(s("bd sd"), s("~ cp ~ cp"))

_{strudel-0025 · CC0}

d1 $ cat [sound "bd sn", sound "~ cp ~ cp"]

_{tidal-0024 · CC0}

layer-subtraction

s("bd*4, hh*8, ~ sd").mask("<1 1 1 0>")

_{strudel-0024 · CC0}

d1 $ mask "1 1 1 0" $ sound "bd*4, hh*8, ~ sn"

_{tidal-0023 · CC0}

build-up

out: arrange ~intro 4 ~main 8 >> mul 0.6

_{glicol-0014 · MIT}

SinOsc s => Envelope e => dac; e.duration(500::ms); e.keyOn();

_{chuck-0027 · MIT}

ratchet-retrigger

d1 $ ply 2 $ sound "bd sn"

_{tidal-0041 · CC0}

Pbind(\degree, Pstutter(2, Pseq([0, 4], inf)), \dur, 0.125).play

_{supercollider-0034 · CC0}

drop

s("bd*4, ~ sd, hh*8").mask("<0 0 0 1>")

_{strudel-0023 · CC0}

d1 $ mask "0 0 0 1" $ sound "bd*4, ~ sn, hh*8"

_{tidal-0022 · CC0}

strongly-timed-sequencing

1::samp => now;

_{chuck-0008 · MIT}