Procedural Subtractive Synthesis in Game Audio

By James Hartley · February 7, 2026

Procedural Subtractive Synthesis in Game Audio

1) Introduction: what you’ll build and why it matters

Procedural subtractive synthesis is the practice of generating game sounds in real time using classic synth building blocks (oscillators, filters, envelopes, modulation) and driving them with gameplay parameters. Instead of triggering a single static WAV for every action, you create a sound “instrument” that responds: footstep timbre shifts with surface type and speed, an energy weapon brightens as it overheats, a UI confirm sound subtly changes pitch based on menu depth.

This tutorial walks you through building a practical, reusable subtractive-synthesis patch for a common real-world scenario: a procedural mechanical servo/door sound that adapts to speed, load, and distance. You’ll learn how to structure a patch for consistency (so it still sounds like the same door), while allowing controlled variation (so repeated events don’t get fatiguing). The same approach transfers directly to engines, drones, monsters, sci‑fi devices, and UI systems.

2) Prerequisites / setup

Synth: Any subtractive synth that supports at least 2 oscillators, a noise source, a multimode filter, envelopes, LFOs, and modulation routing. Examples: Vital, Serum, Massive, Diva, Zebra, Phase Plant. (If your tool is inside an engine like Wwise + a synth plugin, the principles still apply.)
Host: DAW for testing (Reaper, Ableton, Logic) or a game audio tool that can audition RTPC-like parameters.
Metering: Spectrum analyzer and loudness meter recommended. Target peaks around -6 dBFS while designing to avoid clipping when randomized layers stack.
Control plan: You’ll map three parameters:
- Speed (0–1): how fast the mechanism moves
- Load (0–1): how strained it is (heavy door, damage, low power)
- Distance (meters): listener distance; you’ll use it to dull highs and reduce level

3) Step-by-step: build a procedural subtractive patch

1. Define the sound layers and what each one represents

Action: Split the sound into three synth layers: tonal motor, friction/noise, and transient ticks.

Why: Procedural sounds become controllable when each layer maps to a physical idea. The tonal layer carries identity and pitch perception; the noise layer communicates texture and surface; transients sell mechanical detail and timing. Keeping them separate avoids one modulation breaking everything.

Settings/techniques: In your synth, either use three separate instances or three layers/parts:
- Layer A: Motor tone (oscillators + filter)
- Layer B: Noise friction (noise source + filter)
- Layer C: Clicks/ticks (short envelope, often highpassed)
Common pitfalls: Trying to do everything with one oscillator+filter. You’ll end up modulating cutoff to create “texture,” which often just sounds like a synth sweep rather than mechanics.
2. Build the motor tone using two detuned oscillators

Action: Create a stable but lively “motor” using two oscillators and subtle detune.

Why: Real motors are not perfect sine waves; they have harmonic content and micro-instabilities. Two oscillators give you movement without needing chorus (which can smear transients and cause phase issues in mono).

Specific settings:
- Osc 1: Saw (or triangle if you need smoother), pitch = 60 Hz base (around B1) or set oscillator to +0 semitones and use note/pitch to land near 50–90 Hz.
- Osc 2: Pulse (square) with pulse width ~35–45%, pitch = Osc 1 + +12 semitones (one octave up).
- Detune: Osc 2 fine tune = +6 to +12 cents.
- Mix: Osc 1 at -6 dB, Osc 2 at -10 dB (motor fundamental should dominate).
Common pitfalls: Too much detune (more than ~20 cents) makes it sound like a musical pad. Also, if you start too bright (full saw at high level), later filtering won’t feel “mechanical,” it will feel like EQ.
3. Shape the motor with a lowpass filter and envelope for “start/stop”

Action: Route both oscillators through a lowpass filter, then use an envelope to create a believable ramp-in and ramp-out.

Why: Many mechanical actions are defined by how they energize and de-energize. A filter envelope mimics the system “waking up” (more harmonics) and settling (less harmonics), without needing a sample start transient.

Specific settings:
- Filter: LP24 (24 dB/oct) cutoff = 800 Hz, resonance = 0.15–0.25 (light emphasis).
- Amp envelope (Layer A): Attack 15 ms, Decay 120 ms, Sustain -3 dB, Release 120 ms.
- Filter envelope amount: +35% (or about +300–600 Hz depending on synth scaling).
- Filter envelope: Attack 20 ms, Decay 180 ms, Sustain 30%, Release 150 ms.
Common pitfalls: Zero-attack envelopes create clicks and exaggerate aliasing in digital synths. Too much resonance turns it into a “wah” sound and draws attention to the synth rather than the mechanism.

Troubleshooting: If you hear a click at note-on, increase amp attack to 25–35 ms and ensure no modulation is instantly slamming pitch or cutoff.
4. Add micro-instability: slow LFO to pitch and cutoff

Action: Apply subtle modulation that never becomes vibrato.

Why: Perfectly static tone reads as a loop. Small pitch drift and cutoff wander create “machinery under load” and reduce ear fatigue during repeated triggers.

Specific settings:
- LFO 1: Sine, rate = 0.6–1.2 Hz, phase random = on.
- Route to Osc 1+2 pitch: depth = ±3 cents.
- Route to filter cutoff: depth = about ±80 Hz (small).
Common pitfalls: Syncing LFO to tempo or using high depth makes it musical. Also, fixed LFO phase can make every trigger start the same, which defeats variation. Enable random phase or retrigger behavior that suits your engine.

Troubleshooting: If it sounds “seasick,” reduce pitch modulation to ±1–2 cents and move more variation into cutoff or noise instead.
5. Create friction/noise layer and band-limit it like real recordings

Action: Add a noise source and filter it into a controllable “scrape/air” band.

Why: Many mechanical sounds are noise-dominated in the midrange. Raw white noise is too bright and fake; filtering it creates believable texture and gives you a parameter to tie to speed and distance.

Specific settings (Layer B):
- Noise: white or pink (pink is often smoother).
- Filter: Bandpass 12 dB/oct, center = 1.6 kHz, resonance/Q moderate (Q ~ 0.7 or resonance ~0.2–0.3).
- Amp envelope: Attack 10 ms, Decay 100 ms, Sustain -6 dB, Release 90 ms.
- Level: start low, around -18 dB relative to motor, then bring up until it’s audible on small speakers.
Common pitfalls: Leaving noise full-spectrum causes hiss that won’t sit in a mix, especially after compression in-game. Another pitfall is making noise too loud; it masks the motor tone and removes perceived “mass.”

Troubleshooting: If noise disappears on phone speakers, raise bandpass center to 2.2–2.8 kHz slightly and increase level by 2–4 dB.
6. Synthesize mechanical ticks with a transient-focused design

Action: Build a short, repeatable tick that can be triggered periodically or by speed.

Why: Ticks provide temporal detail: gear teeth, relay chatter, stepper motor impulses. In gameplay, these are what players subconsciously use to judge speed changes.

Specific settings (Layer C):
- Oscillator: triangle or sine at 1.2 kHz (or set +24 semitones then tune by ear).
- Optional: add a tiny amount of noise (-24 dB) for bite.
- Highpass filter: HP12 cutoff = 600 Hz (prevents low-end pops).
- Amp envelope: Attack 0.5 ms, Decay 25 ms, Sustain -inf, Release 10 ms.
- Pitch envelope: amount = +12 semitones, decay = 18 ms (creates a “click” rather than a tone).
Common pitfalls: Too much low end (no highpass) makes ticks sound like digital clicks. Too long decay turns it into a beep. Also watch polyphony: if ticks overlap, the sound can get spitty.

Troubleshooting: If the tick is harsh, reduce pitch envelope amount to +7 semitones or shorten decay to 10–12 ms.
7. Map gameplay parameters: Speed, Load, Distance

Action: Set up modulation so the patch responds musically to game variables without changing identity.

Why: The goal is “same object, different conditions.” Speed should increase brightness and tick rate; load should increase strain (more noise, slightly lower pitch, more modulation); distance should reduce highs and level.

Suggested mappings (use your synth macros):
- Speed (0–1):
  - Motor pitch: +0 to +3 semitones across full range (small range keeps it non-musical).
  - Motor filter cutoff: 800 Hz → 2.2 kHz.
  - Noise level: -18 dB → -12 dB.
  - Tick rate: if your system allows retriggering, map to 6 Hz → 18 Hz. (If not, simulate with an LFO gating amplitude.)
- Load (0–1):
  - Motor pitch: 0 to -2 semitones (heavier load slightly droops pitch).
  - LFO pitch depth: ±3 cents → ±7 cents (more instability under strain).
  - Noise bandpass center: 1.6 kHz → 1.2 kHz (duller, heavier scrape).
  - Filter resonance: 0.20 → 0.30 (subtle emphasis without “wah”).
- Distance (0–30 m):
  - Overall lowpass: 10 kHz at 0 m → 2.5 kHz at 30 m (gentle slope, 12 dB/oct).
  - Overall gain: 0 dB at 0 m → -18 dB at 30 m (adjust for your game’s attenuation curve).
Common pitfalls: Mapping speed to too much pitch range makes the door “play notes.” Also, driving distance with only volume makes far sounds still too bright and fake. Always dull highs with distance.

Troubleshooting: If parameter changes feel jumpy, add smoothing: 50–150 ms interpolation on RTPCs (especially Speed). Without smoothing, filter cutoff stepping can sound like zipper noise.
8. Add controlled randomization so repeats don’t clone

Action: Randomize a few small parameters per trigger while keeping the overall signature.

Why: In real gameplay, you may trigger the same door 20 times in a level. Subtle randomization prevents the “machine gun” effect without losing recognizability.

Specific random ranges:
- Motor pitch: random ±10 cents per trigger.
- Noise level: random ±2 dB per trigger.
- Tick tone frequency: random ±5% (or ±80 Hz around 1.2 kHz).
- Start offset/phase randomization on oscillators/LFOs: enabled.
Common pitfalls: Randomizing filter cutoff too widely makes the same object sound like different objects. Keep randomization narrower than your Speed/Load ranges.
9. Gain stage and limit: keep headroom for layering in-engine

Action: Balance layers and set safe output levels.

Why: In games, multiple instances can stack (two doors, multiple bots, reverb sends). A patch that peaks at -0.1 dBFS in solo will distort in context.

Specific targets:
- Per-layer peaks: Motor around -10 dBFS, Noise around -16 dBFS, Ticks around -14 dBFS (ticks can be spiky; watch true peak).
- Master peak while auditioning: -6 dBFS.
- Optional gentle limiter: ceiling -1.0 dB, threshold so you see 1–2 dB gain reduction only on loudest moments.
Common pitfalls: Over-limiting to make it “finished.” You’ll remove dynamics that communicate speed and load. Use minimal limiting; let the engine mix handle the rest.

4) Before and after: expected results

Before (typical static approach): A single door/servo sample plays the same every time. At slow speeds it feels wrong, at fast speeds it feels disconnected, and repetition becomes obvious. If you pitch-shift the sample to fake speed, artifacts appear and transient timing doesn’t match motion.

After (procedural subtractive patch): The motor tone stays recognizable while brightness and tick density scale with Speed. Load introduces strain (slight pitch droop, more noise, more instability). Distance naturally dulls high frequencies. Repeated triggers vary subtly without losing identity. In a real scenario (a sci‑fi door in a corridor), the close sound has texture and detail; at 20–30 meters it becomes a muted mechanical presence rather than a hissy, full-band sample.

5) Pro tips to take it further

Add “end-stop” impacts: When the door reaches fully open/closed, trigger a separate transient: a short low thump (sine at 120 Hz, 40 ms decay) plus a high clack (noise through HP at 2 kHz, 20 ms decay). Keep it event-driven, not continuous.
Use saturation before filtering: A mild drive (5–10%) into the motor filter creates richer harmonics so cutoff changes sound physical rather than like EQ automation.
Mid/side distance trick (when applicable): As distance increases, reduce stereo width by 30–60%. Many engines downmix or narrow far sounds; doing it intentionally keeps the mix coherent.
Prevent aliasing on bright settings: If Speed opens the filter to 2.2 kHz and your oscillators are bright, consider band-limiting (use “analog” or high-quality oscillator modes) or cap the cutoff to 1.8 kHz for this specific asset.
Audit in context: Test under common game mix conditions: with music, with reverb sends, and with multiple instances. A patch that sounds perfect solo may mask dialogue or UI if its noise band is too strong around 2–4 kHz.

6) Wrap-up: build muscle memory through small variations

The skill here is not memorizing one patch; it’s learning to translate physical ideas (motor, friction, impacts) into subtractive components, then tying them to meaningful parameters with sensible ranges. Rebuild this patch for two more cases: a small servo (raise motor base to ~120 Hz, reduce noise), and a heavy industrial door (lower base to ~45 Hz, slower envelopes, more load influence). Keep notes of your ranges and what breaks first. After a few iterations, you’ll be able to design procedural systems that ship well: stable, mixable, and responsive to gameplay.