Subtractive synthesis: from raw wave to shaped voice

This module builds toward the bread-and-butter skill of electronic music: dialing in a usable bass, lead, or pad on demand. In a live-coding or laptop-performance rig — where Surge XT or any softsynth sits behind your patterns — you rarely get to browse presets mid-set; you need to conjure “plucky bass” or “swelling pad” from a raw sawtooth in seconds, and that fluency is exactly what subtractive synthesis was built for, from Detroit techno basslines to synthwave leads.

The arc starts supported: you begin by tracing the classic VCO → VCF → VCA chain on a single patch, leaning on “Subtractive synthesis filters harmonically rich oscillator output to sculpt timbre” and the unit-generator idea that every voice is generators and modifiers wired together. Middle exercises hand you Welsh’s Cookbook-style recipes — named targets like strings or brass with suggested waveform, cutoff, and ADSR settings — so you practice the moves before inventing your own. When you add expressive playing, “Setting a synth to monophonic mode is required for portamento/glide” and the note-priority atom are your just-in-time pointers for making a lead sing rather than stutter. By the capstone, the recipes are gone: same oscillator, three contrasting voices, and a synth-agnostic signal-flow diagram for each.

The required atoms gate that capstone directly — the subtractive model, the signal-flow framing that makes your designs transfer beyond one UI, the contrast with FM that sharpens what “subtractive” means, and the mono-mode/glide/priority cluster for the lead. The supporting atoms enrich rather than gate: the Surge XT cluster grounds everything in one concrete free instrument (modulation routing, mono play modes, portamento options), while atoms on felt sound qualities, emulation limits, gear minimalism, and the cross-domain analogy of signal-flow versus canvas thinking in generative graphics give you taste and realism about what subtractive voices can and cannot do.

Walkthrough

Subtractive synthesis is one idea: start with a harmonically rich wave and carve it down with a filter, shaped by envelopes. The move that matters is that one oscillator becomes three completely different voices depending only on how you filter and envelope it. At strudel.cc, Ctrl-Enter plays, Ctrl-. stops. Each step is a complete program.

1 — the raw material. Every subtractive voice starts with a bright oscillator — a sawtooth has every harmonic, so there’s plenty for the filter to remove. On its own it’s buzzy and generic; that’s the point ([[subtractive-synthesis]], [[voltage-controlled-oscillator]]).

setcpm(110/4)
note("c2 c2 c2 c2").sound("sawtooth")

2 — subtractive means filtering. Add a low-pass and the buzz becomes a tone. This is subtractive synthesis: the filter subtracts harmonics you don’t want. The signal flow — oscillator → filter → amp — is the same in every synth you’ll ever touch ([[subtractive-synthesis-is-filtering]], [[subtractive-synthesis-signal-flow]], [[unit-generator-patch]]).

setcpm(110/4)
note("c2 c2 c2 c2").sound("sawtooth").lpf(800)

3 — voice one: a plucky bass. Give it a fast filter envelope (bright attack, quick decay to a low cutoff) and a short amp envelope. The result snaps and dies — a bass that punches. Same saw, shaped for impact ([[synth-agnostic-signal-flow]]).

setcpm(110/4)
note("c2 ~ eb2 g2").sound("sawtooth")
  .lpf(500).lpenv(3).lpattack(0.01).lpdecay(0.15).lpsustain(0.1)
  .attack(0.005).release(0.12).gain(0.9)

4 — voice two: a resonant lead. Higher cutoff, a strong resonance peak (lpq), and a slower filter envelope give a singing, aggressive lead. (True glide/portamento — pitch sliding between notes — is a mono-synth feature with no direct Strudel control; here resonance and the filter envelope supply the bite instead.) ([[synth-glide-portamento]], [[monophonic-voicing-enables-glide]], [[note-priority-in-monosynths]]).

setcpm(110/4)
note("c4 eb4 g4 bb4").sound("sawtooth")
  .lpf(1200).lpq(16).lpenv(4).lpattack(0.02).lpdecay(0.3).gain(0.6)

5 — voice three: a slow pad. Now the opposite of the pluck: a long amp attack and release so chords swell in and fade out, with a gentle mid cutoff. The same oscillator, now a warm bed ([[fm-vs-subtractive-synthesis-approach]]).

setcpm(110/4)
note("<[c3,eb3,g3] [ab2,c3,eb3]>").sound("sawtooth").attack(0.6).release(0.8).lpf(900).gain(0.5)

6 — three voices, one oscillator (the capstone). Bass, pad, and lead — all sawtooth, distinguished only by filter and envelope — layered into one patch. This is the whole claim of subtractive synthesis, and the signal-flow design transfers to any synth you pick up ([[subtractive-synthesis-signal-flow]]):

setcpm(110/4)
$: note("c2 ~ eb2 g2").sound("sawtooth")
    .lpf(500).lpenv(3).lpattack(0.01).lpdecay(0.15).attack(0.005).release(0.12).gain(0.9)
$: note("<[c3,eb3,g3] [ab2,c3,eb3]>").sound("sawtooth").attack(0.6).release(0.8).lpf(900).gain(0.4)
$: note("~ ~ <c5 g5> ~").sound("sawtooth").lpf(1400).lpq(14).lpenv(4).lpdecay(0.25).gain(0.4)

What good sounds like. Three voices should be unmistakably different — the bass tight and percussive, the pad soft and sustained, the lead cutting and vocal — yet you know they’re one oscillator, proof you’re shaping with filter and envelope, not swapping presets. The beginner failure is designing every voice at the same cutoff and attack, so they blur together. Draw each as a signal-flow diagram (osc → filter[env] → amp[env]) and the differences become a recipe you can rebuild on any synth. (Skill map: live-coder Domain B5 — sound design as signature; E2 — a curated palette that recurs.)

Now make it yours. Swap the saw for a square and rebuild all three — same envelopes, new character. Give the pad a slow filter LFO. Make the bass a pulse. Add a fourth voice: a stab (near-zero attack, short decay, high lpenv). Write each voice’s signal-flow as a one-line comment above it.

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}

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}

fm-timbre

note("c3").s("sine").fm(4).fmh(2).fmi(3)

_{strudel-0204 · CC0}

osc (midicps 24 * (1 ~~ 4 $ osc 110)) >> audio

_{punctual-0006 · CC0-1.0}

saturation-drive

d1 $ sound "bd*2" # shape 0.4

_{tidal-0033 · CC0}

{ (SinOsc.ar(110) * 5).tanh * 0.2 }.play

_{supercollider-0009 · CC0}