How sound works: pressure, spectrum, and the anatomy of a tone

Every sound-design decision you will ever make on stage — pulling a filter open mid-drop, layering a sub under a lead, taming a harsh resonance in the club PA — depends on one skill: hearing a sound and knowing what its spectrum looks like, and vice versa. This module builds that skill to the point where you can look at an analyzer, point at the partials, and say why the tone sounds the way it does. That fluency is what separates dialing presets from designing sound in a live-coded set, where you have seconds to diagnose “why does this patch sound thin?”

The arc starts fully supported: play pure sine tones and watch them on an analyzer, grounding the idea that sound is pressure the cochlea transduces into the percepts of pitch, loudness, and timbre, and that frequency, amplitude, and waveform are the whole story for a steady tone. From there, exercises stack partials by hand — “Harmonics are the standing waves at integer multiples of a fundamental” and “Fourier’s theorem decomposes any periodic sound into sinusoidal partials” are the JIT pointers here — until a sawtooth emerges from sines and its 1/n amplitude recipe stops being trivia and becomes something you built. Then support drops away: unlabeled spectrograms, real instrument recordings, evolving spectra where the envelope and the attack transients carry the identity.

The required atoms gate the capstone directly: without the harmonic series, waveform-to-harmonic mappings, the partial/harmonic/overtone vocabulary, the three-parameter framing that ties spectrum to what you hear, and the envelope concept, the three-tone annotation task is guesswork. Supporting atoms enrich the picture — decibels and equal-loudness explain why the analyzer disagrees with your ears, beats and critical bands explain roughness between close partials, and the missing fundamental explains bass you hear but cannot see. Drill the waveform-recipe recall until it is instant; everything downstream in subtractive synthesis assumes it.

Walkthrough

The theory here is about spectrum; the fastest way to own it is to hear it. At strudel.cc (Ctrl-Enter play, Ctrl-. stop) we hold one pitch fixed and change only its timbre — so every difference you hear is the spectrum moving, nothing else. Each step is a complete, playable program.

1 — a pure tone. A sine is the one waveform with no harmonics — a single partial at the fundamental. It sounds hollow, flute-like, “pure.” This is your reference: everything richer is this plus overtones ([[sound-three-parameters]]).

note("c3").sound("sine")

2 — add the harmonics. Same note c3, same loudness — swap to sawtooth and it turns buzzy and bright. Nothing about the pitch changed; the sawtooth just stacks every harmonic (1/n amplitudes) on top of the fundamental. That difference is timbre ([[timbre-waveform-relation]], [[waveform-harmonic-content]]).

note("c3").sound("sawtooth")

3 — the waveform family, by harmonic richness. <...> plays one per cycle. Sine (no harmonics) → triangle (weak odd harmonics) → square (strong odd harmonics) → sawtooth (all harmonics). You’re hearing the spectrum fill in, low to high richness, at constant pitch ([[harmonic-series-integer-multiples]]).

note("c3").sound("<sine triangle square sawtooth>")

4 — carve the spectrum with a filter. Start from the full sawtooth and cut the top with a low-pass filter. .lpf removes harmonics above its cutoff — open it stepwise and you hear the upper partials switch back on, dark → bright, with the fundamental untouched. This is subtractive synthesis in one line ([[waveform-harmonics-relationship]]).

note("c3").sound("sawtooth").lpf("<300 600 1200 2400 4800>")

5 — shape it in time. A tone isn’t static — its spectrum and level evolve. An .attack of 0.2 swells the note in slowly (a pad); a near-zero attack makes it a pluck. The envelope is the fourth thing your ear uses to identify a sound, after the three steady-state parameters ([[sound-envelope-concept]]).

note("c3 ~ c3 ~").sound("sawtooth").lpf(1200).attack(0.2).release(0.3)

6 — design a bass, in context (the capstone). Put it together: a sawtooth (rich harmonics), a low-pass that opens across the phrase (moving spectrum), a short envelope (plucky), under a plain beat so you hear it in a mix. Every knob traces to a spectral feature — waveform = harmonics present, lpf = which survive, attack/release = how they arrive and leave:

$: note("c2 ~ eb2 c2 ~ g2 ~ ~").sound("sawtooth").lpf("<800 1600>").attack(0.01).release(0.15).gain(0.8)
$: sound("bd*4, ~ sd, hh*8").bank("RolandTR909").gain(0.6)

What good sounds like. A bass that’s present but not harsh: enough harmonics to hear on small speakers (a pure sine bass vanishes on a phone), but the lpf reined in so it doesn’t fizz against the hats. If a patch sounds thin, it usually needs a richer waveform or a more open filter; if it sounds harsh, close the lpf or soften the attack. Diagnosing “why does this sound thin/harsh?” in seconds is the whole point of the skill. (Skill map: live-coder Domain B2/B5 — sound selection and sound design.)

Now make it yours. Swap sawtooth for square and hear the hollow, clarinet-ish colour. Widen the filter move to "<400 3200>" for a bigger sweep. Add .room(0.2) for space. Give the bass a slow filter swell by pairing a long .attack with a low static .lpf. Try sine for the bass and notice how it disappears in the mix — that’s the missing-harmonics problem, live.