Bass sound design: sub, Reese, and genre bass recipes

In UK bass music — dubstep, grime, DnB — the bassline is the track: it is what a club sound system reproduces physically at 40 Hz and what a phone speaker must still convey as weight. This module builds the whole task of designing a small family of basses that work in both worlds: a sub you can trust, a Reese that moves, and one genre-defining patch, all of which survive the mono sum of a club centre feed or a vinyl cut.

The arc starts supported. First exercise: a bare sine sub, following the recipe of a pure sine plus EQ, then two guided fixes — high-pass filtering below ~40 Hz to remove flabby subsonic energy, and adding distortion so small speakers hear the harmonics as bass weight. Next, the Reese: detune two oscillators until they beat, then discover the signature morph by overlapping glide notes that trigger portamento, and route the Reese itself through a filter to derive a sub that follows its movement rather than sitting static beneath it. Finally, learners pick one genre recipe — the LFO-driven dubstep wobble, the eskibeat pulse-wave patch with mono glide, or a DnB sub stacked with harmonics — and execute it unassisted for the capstone. Every deliverable is then summed to mono and checked, because most real listening — phone speakers, club centre feeds — happens in near-mono conditions.

The required atoms gate the capstone directly: each of the three deliverable basses is assembled entirely from them, from pitch-drop attack transients to mid-frequency cuts that leave mix space for snares, through the final mono-compatibility check. Supporting atoms enrich judgment rather than procedure — why vinyl forces bass to mono, why jungle deliberately left a mid-range gap, when saturation warms rather than wrecks, and character-extenders like flanging a Reese or the hardstyle reverse bass. The drills (sine sub setup, sub-40 Hz high-passing, glide-note overlap, LFO wobble assignment) recur in every bass you will ever patch; practise them inside full patches until they are automatic.

Walkthrough

In bass music the bassline is the track — it has to move a club at 40 Hz and still read as weight on a phone. We’ll design three basses in strudel.cc (Ctrl-Enter play, Ctrl-. stop). Play these on headphones or speakers with real low end — laptop speakers can’t reproduce a sub. Each step is a complete, playable program.

1 — a clean sine sub. A pure sine at a low octave (c1 ≈ 33 Hz) is the foundation: all weight, no character. It’s what the club feels but a phone can’t hear — which step 2 fixes ([[sine-wave-sub-bass-design]]).

note("c1 ~ c1 eb1").sound("sine").gain(0.9)

2 — tighten and translate. Two fixes: .hpf(30) removes flabby subsonic energy below hearing (tightens the low end), and layering a filtered sawtooth an octave up adds harmonics so small speakers convey the pitch as bass — the sub’s “translation” ([[high-pass-filter-sub-bass-tightness]], [[sub-bass-distortion-translation]]).

$: note("c1 ~ c1 eb1").sound("sine").hpf(30).gain(0.9)
$: note("c2 ~ c2 eb2").sound("sawtooth").lpf(800).gain(0.35)

3 — a Reese (detune + movement). The classic DnB/dubstep bass: two detuned sawtooths beating against each other. .detune() spreads them; a slow filter makes it churn. Route it through .lpf so the timbre moves ([[reese-bass-detuning]] if present).

note("<c1 c1 eb1 g1>").sound("sawtooth").detune(0.18).lpf(sine.range(300, 1100).slow(4)).gain(0.7)

4 — a mid cut for mix space. A bass that fills the mids buries the snare. Carve a notch / roll the top so the bass owns the low end and leaves room above — the jungle “mid-gap” ([[bass-mid-frequency-cut]] if present).

note("<c1 c1 eb1 g1>").sound("sawtooth").detune(0.18).lpf(700).gain(0.75)

5 — a genre patch: the dubstep wobble. An LFO on the filter cutoff is the wobble — sine.range(200, 1500).fast(2) opens and closes the filter twice a bar. Change the LFO rate and you change the wobble’s rhythm ([[lfo-wobble-bass]] if present).

note("c1").sound("sawtooth").lpf(sine.range(200, 1500).fast(2)).gain(0.8)

6 — three basses, mono-checked (the capstone). The family in one program — sub, Reese, wobble, each in its own register with .hpf keeping the low end clean. Add .distort() on the sub for extra small-speaker translation (audible on strudel.cc). Sum to mono with .pan(0.5) and confirm nothing hollows out — most listening is near-mono ([[mono-compatibility-check]] if present):

setcpm(140/4)
$: note("c1 ~ ~ c1 ~ ~ eb1 ~").sound("sine").hpf(30).pan(0.5).gain(0.9)
$: note("<c2 eb2>").sound("sawtooth").detune(0.15).lpf(sine.range(400, 1200).slow(4)).pan(0.5).gain(0.4)
$: sound("bd*4").bank("RolandTR909").gain(0.9)

What good sounds like. A sub you feel more than hear, that still translates on a phone (that’s the harmonic layer working), and a moving bass whose motion is musical, not noise. If it disappears on small speakers, add the octave-up harmonic layer or .distort(); if it’s muddy against the kick, .hpf it and carve the mids; if it hollows out in mono, two detuned voices are phase-cancelling — narrow the detune. The kick and sub must not fight — sidechain or interleave them in time. (Skill map: live-coder Domain B2/B5 — bass sound design and mix space.)

Now make it yours. Change the wobble LFO to .fast(3) or a patterned rate "<1 2 4>". Widen/narrow the Reese detune and hear mono behaviour change. Add .distort(1.5) to the sub for grit. Give the sub a pitch-drop attack with a fast downward glide. Stack a third harmonic for a DnB sub.

Runnable examples

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

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}

amplitude-lfo

osc 440 * lftri 1 >> audio

_{punctual-0003 · CC0-1.0}

s("bd*4").gain(sine.range(0.5,1).fast(4))

_{strudel-0040 · CC0}

bitcrush

s("bd*4").crush(4)

_{strudel-0022 · CC0}

d1 $ sound "bd*4" # crush 4

_{tidal-0021 · CC0}

stereo-panning

d1 $ pan (slow 2 sine) # sound "hh*8"

_{tidal-0037 · CC0}

SinOsc s => Pan2 p => dac; -0.7 => p.pan;

_{chuck-0042 · MIT}

sub-bass

osc 27.5 >> audio

_{punctual-0002 · CC0-1.0}

synth :subpulse, note: :e1, sustain: 0.4, amp: 1.4

_{sonicpi-0016 · CC0}

pitch-drop

s = play 84, note_slide: 0.1, sustain: 0.5; control s, note: 36

_{sonicpi-0037 · CC0}

{ SinOsc.ar(EnvGen.kr(Env([400, 50], [0.1], \exp)), 0, EnvGen.kr(Env.perc(0.001, 0.3), Impulse.kr(2))) * 0.3 }.play

_{supercollider-0018 · CC0}

mono-bass

mono (saw [110,220,330]) >> audio

_{punctual-0013 · CC0-1.0}

reese-bass

use_synth :dsaw; play :e1, detune: 0.3, cutoff: 70, release: 0.4

_{sonicpi-0039 · CC0}