DEV Community: naman

Every note node in Infinite: generative arpeggiators and algorithmic sequencing

naman — Wed, 11 Nov 2026 13:15:29 +0000

In traditional music production environments, MIDI is treated as a static piano roll. Notes are clicked onto a grid, quantised rigidly, and routed through a single linear track directly into a virtual instrument.

Infinite re-imagines MIDI and musical timing as an open, modular stream of discrete note events. Notes are not passive rows in an arrangement; they are first-class signals that flow through cables, branch across splitters, undergo algorithmic transformations, and drive both sound engines and 3D visual geometry in real time.

Infinite provides twenty-four dedicated note processing nodes, spanning hardware input bridges, rhythmic arpeggiators, Markov-chain phrase predictors, physics-based trigger simulations, scale quantizers, and programmable algorithmic note generators.

Here is an architectural guide to every note node in Infinite, how they process musical events, and how to patch generative music systems on the canvas.

1. MIDI Notes: hardware controller & MPE input bridge

The MIDI Notes node connects physical MIDI keyboards, pad controllers, and MPE (MIDI Polyphonic Expression) devices to the Infinite canvas.

How it works

Multi-channel routing: Listens on all channels (Omni) or binds to a specific MIDI channel (1 to 16).
MPE support: Full per-note polyphonic pitch bend, slide, and pressure/aftertouch tracking.
Port activity visualization: Real-time visual LEDs displaying active note-on gates, polyphonic voice count, and pitch numbers.
Event stream outputs: Outputs polyphonic note events cleanly buffered for sample-accurate scheduling.

Try it

Connect a USB MIDI keyboard, wire MIDI Notes into an Analog synth, and route per-note MPE pressure into the filter cutoff knob.

MIDI Notes -> Analog -> Audio Out

2. Keyboard: interactive on-screen playable piano

The Keyboard node provides a playable virtual piano keyboard directly inside the node canvas, supporting mouse clicks, multi-touch, and computer QWERTY keyboard typing.

How it works

Octave range navigation: Configurable key span with quick octave shift controls.
Musical scale highlighting: Highlights active scale notes across white and black keys, preventing accidental off-key inputs during live performance.
Velocity sensitivity: Clicking near the bottom of a key triggers high velocity (up to 127), while clicking near the top triggers soft pianissimo notes.

Try it

Select the Dorian scale in the inspector, highlight the scale keys, and jam melodies using your computer keyboard without opening external controllers.

Keyboard -> FM -> Reverb -> Audio Out

3. Note Filter: range, channel, and velocity gate

The Note Filter node acts as a selective filter for incoming note streams, allowing only notes meeting specific musical criteria to pass downstream.

How it works

Pitch key zones: Set minimum and maximum note limits (e.g. C1 to B2 for bass, C3 to C6 for leads) to create multi-instrument keyboard splits.
Velocity window: Filters notes by dynamics, passing only ghost notes (low velocity) or accents (high velocity).
Channel filtering: Strips out or isolates specific MIDI channels from multi-timbral controllers.

Try it

Wire one MIDI Notes output into two Note Filters: set filter 1 to notes below C3 for a sub bass synth, and filter 2 to notes above C3 for a shimmering lead.

MIDI Notes -> Note Filter (Low) -> Analog (Bass)
MIDI Notes -> Note Filter (High) -> Wavetable (Lead)

4. Note Transpose: chromatic and scale-aware pitch shifting

The Note Transpose node shifts the pitch of incoming note events by octaves and semitones while optionally constraining the shifted notes to a selected musical scale.

How it works

Octave & semitone offsets: Shift notes up or down by up to 4 octaves and 12 semitones.
Modulatable transposition: The semitone parameter is modulatable, allowing an LFO or step sequencer to modulate chord progressions automatically.
Scale snapping: Forces transposed notes onto the nearest valid scale degree to prevent dissonant pitch clashes.

Try it

Modulate Note Transpose with a Slow Step Sequencer to shift an arpeggio across root, fourth, and fifth chords every four bars.

Arpeggiator -> Note Transpose -> Wavetable -> Audio Out

5. Pitch Bend: expressive pitch deflection router

The Pitch Bend node routes and scales continuous pitch bend wheel messages and modulation signals for connected synthesizers.

How it works

Configurable bend range: Adjust the pitch bend semitone window from 1 semitone to a full octave (-12 to +12 semitones).
Bipolar modulation input: Accepts LFO or envelope modulation to produce automatic vibrato and dive bombs.
Smoothing: Built-in 14-bit interpolation prevents audible stepping during aggressive wheel movements.

Try it

Wire a slow triangle LFO into Pitch Bend to add subtle, expressive pitch wander to vintage synth leads.

LFO -> Pitch Bend -> Analog -> Audio Out

6. Velocity Curve: dynamic touch and curve response

The Velocity Curve node remaps the velocity dynamics of incoming note events, tailoring keyboard touch response to performance preferences.

How it works

Curve profiles: Linear, Exponential (emphasising soft touches), Logarithmic (punchy and responsive), and S-curve (compressed dynamics).
Min/max clamping: Sets minimum velocity floor and maximum ceiling limits.
Fixed velocity mode: Locks all incoming notes to a single uniform velocity level (such as 100 for consistent organ or synth-pop lines).

Try it

Apply an Exponential velocity curve to a physical Karplus-Strong String synth for natural acoustic response when playing delicate arpeggios.

MIDI Notes -> Velocity Curve (Exp) -> String -> Audio Out

7. Gate: rhythmic duration and articulation shaper

The Gate node controls the duration of active note events, turning sustained chords into short staccato bursts or stretching short taps into legato drones.

How it works

Time and beat modes: Set gate length in milliseconds (5ms to 2000ms) or metric musical divisions (1/16, 1/8, 1/4).
Fixed gate vs proportional: Choose between fixed note lengths or proportional scaling (e.g. 50% staccato of incoming note length).
Legato tie mode: Automatically bridges notes together when consecutive keys overlap.

Try it

Feed an Arpeggiator into Gate set to 15% length to transform an arpeggio into tight, robotic 16th-note staccato plucks.

Arpeggiator -> Gate (15%) -> FM -> Audio Out

8. Humanizer: micro-timing shuffle and organic dynamics

The Humanizer node injects subtle, natural human imperfections into rigid, computer-quantized note streams.

How it works

Timing jitter: Introduces microscopic Gaussian time offsets (from 0ms to 35ms) to note onsets, simulating the slight imprecisions of live human performance.
Velocity spread: Randomizes note velocity around the played value by a customizable percentage window.
Pitch drift: Adds minute micro-tuning offsets for analog acoustic warmth.

Try it

Place Humanizer between a rigid 16-step Note Sequencer and a drum machine or piano synth to make programmed patterns breathe naturally.

Note Sequencer -> Humanizer -> Sampler (Piano) -> Audio Out

9. Quantizer: musical scale and modal pitch snapping

The Quantizer node forces arbitrary pitch numbers, microtonal frequencies, and random pitch modulators onto chosen musical scales and temperaments.

How it works

Over 40 musical scales: Major, Minor, Dorian, Phrygian, Lydian, Mixolydian, Locrian, Harmonic Minor, Melodic Minor, Pentatonic, Blues, Hirajoshi, Insen, Raga, and microtonal modes.
Root note transposition: Set the tonic key to any pitch (C through B).
Snap algorithms: Snaps to the nearest scale degree either upward, downward, or to the absolute closest interval.

Try it

Feed a Random Modulator or CV voltage into Quantizer set to Japanese Hirajoshi, and pipe the output into a Metallic resonator for generative gamelan melodies.

Random -> Quantizer (Hirajoshi) -> Metallic -> Delay -> Audio Out

10. Glide: monophonic portamento and polyphonic slide

The Glide node produces smooth pitch glides between consecutive notes, featuring both classic analog monophonic portamento and multi-voice polyphonic slide.

How it works

Glide time: Continuous portamento rate control (0ms to 3000ms).
Legato-only mode: Glides only when two notes overlap in time, leaving non-overlapping notes with instant attack.
Constant time vs constant rate: Select whether pitch transitions take the same amount of time regardless of distance, or glide at a fixed semitones-per-second velocity.

Try it

Enable Legato Glide on a bass synth patch, hold a low note while tapping octaves higher, and enjoy smooth analog pitch slides.

MIDI Notes -> Glide (Legato) -> Analog (Acid Bass) -> Audio Out

11. Note Echo: algorithmic MIDI delay and rhythmic repeats

The Note Echo node creates rhythmic echoing MIDI notes, repeating incoming note events across musical intervals with decay and transposition.

How it works

Tempo-synced delay time: Set delay intervals to standard, dotted, or triplet metric divisions (1/16, 1/8d, 1/4t).
Feedback & count: Controls the number of echo repeats (1 to 32).
Velocity decay: Gradually scales down the velocity of successive repeats for natural fading.
Semitone pitch transpose: Shifts each repeat up or down by a set semitone interval, turning a single key press into an ascending or descending staircase.

Try it

Set Note Echo to a dotted 8th note (1/8d) with a +7 semitones (fifth) pitch shift, and play single notes to create layered arpeggiated patterns.

MIDI Notes -> Note Echo (1/8d, +7) -> Wavetable -> Audio Out

12. Note Router: dynamic keyboard splitting and voice dispatching

The Note Router node directs incoming notes across up to four separate output ports based on pitch thresholds, velocity ranges, or voice allocation.

How it works

Split mode: Routes notes below a split point to Output 1, and notes above to Output 2.
Velocity dispatch: Sends soft notes to an intimate electric piano, and hard accents to a brass synth.
Round-robin voice allocation: Cycles notes sequentially across Outputs 1, 2, 3, and 4, allowing four distinct synthesizers to share parts of a polyphonic phrase.

Try it

Set Note Router to Round-Robin and connect three different synths (Analog, FM, and String) to play dynamic hocketing melodies where every note has a unique timbre.

Arpeggiator -> Note Router (Round Robin) -> [Analog, FM, String]

13. Note Merge: unified polyphonic stream combiner

The Note Merge node combines multiple independent note streams into a single unified polyphonic stream with intelligent collision handling.

How it works

Multi-input bus: Combines up to four note sources into one stream.
Duplicate note suppression: Prevents hanging notes and double-trigger clicks when two input streams send the same pitch simultaneously.
Voice priority: Option to prioritize higher or lower notes during polyphony overflow.

Try it

Merge an algorithmic Arpeggiator pattern with live keyboard playing so you can play expressive solo counter-melodies over automated sequences.

[Arpeggiator, Keyboard] -> Note Merge -> Analog -> Audio Out

14. Note Switcher: modulated phrase selector

The Note Switcher node selects which of several incoming note streams passes downstream, controlled via a macro knob or logic trigger.

How it works

Multi-channel selector: Seamlessly switches between alternate note patterns without dropping active note-off events.
Modulatable selection index: Switch patterns automatically using a slow square LFO or timeline automation track.
Smooth transition handling: Sends clean note-off messages to active voices before switching to prevent stuck notes.

Try it

Wire a verse bassline into Input 1 and a chorus bassline into Input 2, then automate the selector with a Macro Toggle for arrangement transitions.

[Pattern A, Pattern B] -> Note Switcher -> Analog -> Audio Out

15. Arpeggiator: algorithmic pattern and chord engine

The Arpeggiator node takes held chords and breaks them into rhythmic, tempo-synced melodic sequences.

How it works

Directional modes: Up, Down, Up/Down, Down/Up, Random, Chord Repeat, and As-Played.
Octave span: Sweeps arpeggios across 1 to 4 octaves with cyclical or ping-pong octave progression.
Gate & swing: Adjusts note duration percentage and metric shuffle.
Hold toggle: Latches played chords so the arpeggio continues cycling after keys are released.

Try it

Hold a minor ninth chord, set Arpeggiator to Up/Down across 3 octaves at 1/16th notes, and route through an analog filter sweep.

Keyboard -> Arpeggiator (Up/Down) -> Analog -> Audio Out

16. Note Sequencer: 16-step polyphonic pitch & gate grid

The Note Sequencer node is a classic 16-step grid sequencer with per-step pitch, velocity, octave shift, and gate tie controls.

How it works

Interactive step matrix: 16 dedicated pitch knobs with visual semitone displays.
Per-step ties & mutes: Tie steps together for long sustained bass notes, or mute steps for syncopated rests.
Variable step length: Set pattern length from 1 to 16 steps to create odd-meter polyrhythms (such as 5/16 or 7/16).
Direction modes: Forward, Reverse, Ping-Pong, and Brownian random walk.

Try it

Set the sequencer length to 7 steps over 16th notes to produce a shifting polyrhythmic ostinato that cycles across the 4/4 bar line.

Note Sequencer (7 Steps) -> FM -> Delay -> Audio Out

17. Random Note Generator: constrained generative melody engine

The Random Note Generator node creates constrained melodic phrases and basslines algorithmically in real time.

How it works

Key & scale constraints: Restricts generated notes strictly to a selected musical key and scale.
Interval jump weighting: Biases random generation toward small melodic steps (seconds and thirds) rather than wide, disjointed leaps.
Rhythmic density: Controls the probability of active note triggers per clock tick, introducing musical rests.
Seed repeatability: Freeze the random seed to loop an inspiring generated phrase indefinitely.

Try it

Set the scale to Minor Pentatonic, set density to 60%, and pipe the generated notes into a Wavetable pad for an endless generative ambient performance.

Random Note Generator -> Wavetable -> Reverb -> Audio Out

18. MIDI File: standard MIDI file canvas player

The MIDI File node loads and plays standard .mid sequence files directly on the canvas, locked to the global transport clock.

How it works

Drag and drop loading: Drop standard Type 0 or Type 1 MIDI files directly onto the node body.
Track isolation: Choose which MIDI track to output, or sum all tracks into one polyphonic stream.
Transport synchronization: Automatically tracks project tempo, loop markers, and timeline playhead location.

Try it

Drag a complex classical piano MIDI file onto the canvas, route note outputs to a String synth, and use note velocities to drive 3D particle bursts.

MIDI File -> String -> Audio Out
MIDI File (Velocity) -> Particle System (Speed)

19. Chorder: single-note harmonizer and chord voicings

The Chorder node converts single incoming note taps into rich multi-voice polyphonic chords.

How it works

Pre-configured chord types: Major, Minor, Sus2, Sus4, Dominant 7th, Major 7th, Minor 7th, 9th, and Diminished.
Custom chord editor: Define custom interval offsets (e.g. [0, +7, +12, +16]) for signature chords.
Root-relative transposition: Voicings transpose across the keyboard relative to the incoming note pitch.

Try it

Select Minor 9th voicing, set Arpeggiator downstream, and play single bass notes to trigger sweeping impressionist arpeggios.

Keyboard -> Chorder (Min 9) -> Arpeggiator -> Wavetable -> Audio Out

20. Note Stack: interval and octave voice layering

The Note Stack node layers harmonic interval copies on top of played notes to thicken synth leads and basslines.

How it works

Up to 4 interval layers: Add octave below (-12), fifth above (+7), octave above (+12), or custom intervals.
Per-voice detuning: Applies subtle pitch detuning between stacked voices for rich chorus effects.
Velocity scaling: Scales the velocity of stacked intervals relative to the primary note.

Try it

Add an octave below (-12) and a fifth above (+7) to an analog saw lead to produce a classic vintage stadium rock synth sound.

MIDI Notes -> Note Stack (-12, +7) -> Analog -> Audio Out

21. Note Capturer: live performance buffer recorder

The Note Capturer node acts as a live MIDI scratchpad, recording incoming performances into a circular memory buffer for playback or loop export.

How it works

Retrospective recording: Keeps a continuous rolling buffer of your recent playing, allowing you to capture spontaneous improvisation after it occurs.
Bar quantization: Trims captured phrases cleanly to musical bar boundaries.
Loop playback: Plays captured takes in a continuous loop while leaving the keyboard free for additional layers.

Try it

Improvise freely on your keyboard, press Capture to grab the last 4 bars, and immediately loop the phrase while designing synth patches.

MIDI Notes -> Note Capturer (Loop) -> Analog -> Audio Out

22. Bouncing Balls: physics-based rhythmic trigger generator

The Bouncing Balls node runs an internal physics simulation where virtual spheres bounce inside a gravity well, triggering note events whenever a ball collides with the floor.

How it works

Gravity & elasticity: Balls bounce with physically realistic gravitational acceleration, bouncing rapidly as they reach the floor.
Multi-ball polyphony: Simulate up to 8 independent bouncing spheres with differing drop heights and restitution coefficients.
Collision pitch mapping: Map collision velocity to note velocity, and bounce frequency to musical pitch.

Try it

Route Bouncing Balls into a Metallic resonator or physical String synth to hear organic, accelerating acoustic impacts mimicking raindrops or dropped marbles.

Bouncing Balls -> Metallic Resonator -> Reverb -> Audio Out

23. Note Strum: realistic acoustic chord strumming

The Note Strum node emulates guitar and harp playing by staggering the onset times of notes in a polyphonic chord.

How it works

Strum speed: Sets the time delay between consecutive notes (2ms to 150ms).
Direction control: Down-strum (low notes to high notes), Up-strum (high notes to low notes), or Alternating.
Velocity decay: Gradually tapers velocity across the strum to emulate natural hand dynamics.

Try it

Place Note Strum between a Chorder and a String physical modeling synth for convincing nylon-string acoustic guitar chord strumming.

Keyboard -> Chorder -> Note Strum -> String -> Audio Out

24. Field Notes: programmable algorithmic note generation

The Field Notes node allows you to script custom generative algorithms, Markov-chain phrase models, and rhythmic logic directly in Infinite's bare-name Field language.

How it works

Event-driven execution: Executes on every clock tick or MIDI input trigger.
State registers: Retains history across steps to calculate Euclidean rhythms, Fibonacci sequences, or cellular automata.
Output note generation: Emits note pitch, velocity, and gate events directly to downstream synths.

Example: Fibonacci sequence arpeggiator

// registers: step_counter, prev_a, prev_b
state a = 1
state b = 1
state step = 0

// advance Fibonacci sequence modulo 12
let next_fib = (a + b) % 12
a = b
b = next_fib
step = step + 1

// map to minor pentatonic scale
let root = 60
let intervals = [0, 3, 5, 7, 10]
let note_out = root + intervals[next_fib % 5]

emit_note(note_out, 90, 120) // pitch, velocity, duration_ms

Try it

Drop a Field Notes node, enter your own algorithmic rules, and explore generative compositions impossible in conventional static DAWs.

Clock -> Field Notes -> FM -> Delay -> Audio Out

Modular note architecture

Because Infinite unifies note processing, audio synthesis, and visual rendering onto a single real-time execution graph, these note nodes can drive both sound and visual form simultaneously.

An Arpeggiator can trigger a synth lead while stepping through colors in an Audio Color Ramp, and the physical collisions of a Bouncing Balls node can displace 3D geometry meshes at the exact microsecond an acoustic chime rings out.

Drop any note node onto the canvas, cable it into an instrument, and build generative musical systems unconstrained by linear timelines.

Originally published at https://infinitedevices.org/blog/every-note-node-in-infinite-generative-sequencing-guide.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Every synthesizer node in Infinite: the complete sound design guide

naman — Wed, 11 Nov 2026 13:15:24 +0000

Most digital audio workstations isolate sound generation inside third-party plugins. You purchase an instrument, load a floating window, navigate vendor-specific preset systems, and route stereo audio into a rigid mixer channel.

Infinite approaches synthesis from a different foundation. Every synthesizer lives directly on the open canvas as a modular node. Notes, audio streams, modulation voltages, and visual textures share the same graph and memory space. A single LFO can sweep a wavetable position while warping a 3D geometry mesh, and a reaction-diffusion simulation can directly generate polyphonic audio timbre.

Infinite features twenty native synthesizer engines, spanning virtual analog, morphing wavetables, 4-operator frequency modulation, Karplus-Strong waveguides, granular cloud generators, extreme spectral time-stretchers, and per-sample programmable JIT kernels.

Here is an architectural breakdown of every synthesizer node in Infinite, how their sound engines work, and how to patch them.

1. Oscillator: dual-oscillator subtractive & FM engine

The Oscillator node is Infinite's foundational sound generator, built upon bandlimited anti-aliased wavetables with linear frequency modulation and phase synchronization.

How it works

Waveforms: Sine, Triangle, Sawtooth, and Square with variable Pulse Width (0.01 to 0.99).
Pitch controls: Coarse frequency (20 Hz to 8000 Hz), octave shift (-4 to +4), semitone offset (-12 to +12), and fine detune (-50 to +50 cents).
Linear FM input: An audio-rate fm_in pin enables modulation from a secondary oscillator, producing rich sidebands for metallic chimes, FM brass, and aggressive growls.
Portamento: Continuous glide parameter (0 to 2 seconds) providing constant-rate pitch transitions between notes.

Try it

Patch a secondary Oscillator set to a high octave into the fm_in port, modulate FM Depth with an Envelope, and route through an Audio Filter for crisp metallic bells.

Random Note Generator -> Oscillator -> Audio Filter -> Audio Out

2. Wavetable: 64-table morphing synth with unison

The Wavetable node is Infinite's flagship polyphonic wavetable instrument, featuring 64 factory wavetables that morph smoothly across eight distinct single-cycle frames.

How it works

2D table scanning: Continuous position interpolation across 8 frames per table, eliminating step clicks or boundary artifacts.
Unison detune & stereo spread: Stacks up to 8 voices per note with adjustable frequency detuning and wide stereo placement.
Sub-oscillator: Integrated sub-harmonic generator providing dedicated low-end weight independently of table morphing.
Modulatable position: The position parameter can be cabled directly to LFOs, envelope followers, or hand tracking modulators.

Try it

Wire an LFO into the table position input so the waveform continually evolves, then layer chorus for a lush cinematic pad.

Arpeggiator -> Wavetable -> Chorus -> Reverb -> Audio Out

3. Analog: polyphonic virtual analog with nonlinear filters

The Analog node models the physical circuit behaviour of vintage analog synthesizers, complete with subtle oscillator drift, saturation stages, and four distinct nonlinear filter topologies.

How it works

Twin drift-stabilized oscillators: Dual oscillators with saw, square, triangle, and sine options, pulse width modulation, sub-oscillator, and a pink/white noise source.
Circuit-modeled filters: Switchable between a 4-pole Moog transistor ladder, Korg MS-20 resonant lowpass, diode ladder, and state-variable filter (SVF).
4x oversampling: Drives and non-linear filter stages run at 4x internal oversampling to keep aliasing strictly under -80 dB across all octaves.
Dual ADSR envelopes: Dedicated amplitude and filter envelopes with exponential decay curves.

Try it

Stack three detuned unison voices, select the MS-20 filter model with medium resonance, and sweep cutoff with an envelope for an authentic acid bassline.

MIDI Notes -> Analog -> Delay -> Audio Out

4. FM: 4-operator frequency modulation synthesizer

The FM node delivers classic frequency modulation synthesis using four sine operators configured across eleven classic routing algorithms.

How it works

11 routing algorithms: Ranging from a pure vertical cascade (4 -> 3 -> 2 -> 1) for complex harmonic teeth, to parallel carriers for additive electric pianos.
Harmonic frequency ratios: Per-operator integer and fractional frequency multipliers (0.5x to 32x).
Feedback loop: Operator 4 includes self-modulation feedback, transitioning from smooth sines to saw waves and broadband noise.
Per-operator envelopes: Individual envelope generators shaping the modulation index over time.

Try it

Select algorithm 5 (two parallel carrier-modulator stacks), tune operator 2 to a 3.5x non-harmonic ratio, and add a brief decay envelope for a crystalline mallet sound.

Arpeggiator -> FM -> Reverb -> Audio Out

5. Partials: 64-harmonic additive formant resynthesis

The Partials node performs real-time additive resynthesis, tracking harmonic partials and reproducing acoustic instruments and voices without pitch artifacts.

How it works

Formant preservation: When transposing incoming audio across octaves, Partials keeps the spectral formant envelope locked in place, avoiding the unnatural "chipmunk" timbre common to conventional samplers.
Spectral tilt & odd/even balance: Continuous control over harmonic roll-off slope and the ratio between even and odd harmonics.
Inharmonic stretching: Stretches partial frequencies away from integer multiples for bell and metallic timbres.
Residual noise tracking: Models the turbulent air and breath left behind by harmonic analysis.

Try it

Load a vocal syllable or acoustic cello sample into Partials, trigger it across three octaves, and hear natural vocal character preserved across the entire keyboard.

MIDI Notes -> Partials -> Convolution Reverb -> Audio Out

6. String: Karplus-Strong physical modeling waveguide

The String node models the physical acoustics of vibrating strings stretched over a resonating wooden body using Karplus-Strong waveguide synthesis.

How it works

Physical waveguide loop: A delay line length tuned exactly to the note's fundamental frequency, coupled with an internal lowpass reflection filter.
Three exciter modes:
- Pluck: Impulse burst simulating a guitar plectrum or finger pick.
- Bow: Continuous friction noise simulating a violin or cello bow.
- Strike: Felt hammer excitation simulating an acoustic piano or hammered dulcimer.
Body resonance & pickup position: Configurable acoustic body model and spatial pickup location along the string length.

Try it

Set the exciter mode to Bow, slow the attack time slightly, and play sustained chords for a lush acoustic string ensemble.

Chorder -> String -> Reverb -> Audio Out

7. Wave Terrain: topographic image-to-sound synthesis

The Wave Terrain node turns any 2D image, video capture, reaction-diffusion simulation, or procedural texture into a continuous 3D acoustic terrain surface z = T(u, v).

How it works

Audio-rate orbital paths: An oscillator traces a closed orbital trajectory (u(t), v(t)) across the image (circle, ellipse, Lissajous curve, or lemniscate).
Surface height as amplitude: As the orbital scan travels across pixels, the image luminance z becomes the instantaneous audio amplitude.
10-level Fourier MIP antialiasing: Sampling raw image pixels causes harsh aliasing; Infinite computes an internal Real Discrete Fourier Transform (RDFT) MIP pyramid across 10 octaves, ensuring pristine, alias-free polyphonic synthesis across all 8 octaves.

Try it

Feed a live Reaction Diffusion texture into Wave Terrain, route an LFO to orbit radius, and listen to the sound morph as the organic visual pattern blooms.

Reaction Diffusion -> Wave Terrain -> Saturator -> Audio Out

8. Equation Synth: Desmos-style mathematical synthesis

The Equation Synth node evaluates custom mathematical expressions y = f(x, a, b, c, d) directly at 48kHz audio rates, turning formulas into playable instruments.

How it works

Inline formula parsing: Type formulas directly using standard mathematical functions (sin, cos, tan, pow, abs, tanh, floor).
Real-time parameter knobs: Four continuous parameters (knobA, knobB, knobC, knobD) exposed as modulation pins.
Compile-time bandlimiting: Evaluated curves are compiled into bandlimited wavetable mipmaps, preventing mathematical sharp edges from creating audible foldback distortion.

Try it

Type sin(x) + a * sin(x * 3) + b * sin(x * 5), wire an LFO to knobA, and listen to third and fifth harmonics fade in and out with algebraic purity.

MIDI Notes -> Equation Synth -> Formant Filter -> Audio Out

9. Spectral Synth: real-time spectrogram resynthesis

The Spectral Synth node scans an image or visual canvas horizontally as a spectrogram, converting visual pixels into audible frequencies.

How it works

Horizontal scan line: A playhead travels across the texture from left to right at tempo-synced rates.
Vertical frequency mapping: The vertical $y$-axis maps to acoustic frequency (low frequencies at the bottom, high frequencies at the top), while pixel brightness sets partial amplitude.
Spectral freeze: Freeze the playhead at any point along the image to produce an indefinite, unmoving spectral chord.

Try it

Draw three horizontal brush strokes in a Draw node at low, mid, and high positions, patch the texture into Spectral Synth, and hear your sketch played back as a triad.

Draw Canvas -> Spectral Synth -> Delay -> Audio Out

10. Metallic: modal physical resonator for bells and plates

The Metallic node models the physical vibrations of acoustic metal and glass objects struck by hard or soft mallets using a bank of coupled two-pole bandpass resonators.

How it works

8 material presets: Steel, Brass, Bell Bronze, Aluminium, Glass, Wood, Ceramic, and Titanium.
Modal dispersion: Modes follow non-integer frequency ratios corresponding to the physical vibration equations of circular plates and rectangular bars.
Stiffness & decay: Stiffness controls modal frequency clustering, while decay adjusts the acoustic damping rate across high versus low modes.
Strike hardness: Blends from a soft felt mallet impulse to a sharp metal point impact.

Try it

Trigger Metallic from the Bouncing Balls note generator for an acoustic gamelan performance where notes ring and decay naturally in space.

Bouncing Balls -> Metallic -> Reverb -> Audio Out

11. Sampler: polyphonic multisample engine

The Sampler node provides polyphonic sample playback with precision loop boundaries, pitch tracking, and real-time live audio recording.

How it works

Playback modes: One-Shot, Forward Loop, Reverse Loop, and Ping-Pong bidirectional loop.
Live buffer recording: An audio record_in port allows capturing incoming microphone feeds, guitar inputs, or synth stems straight into memory.
Root pitch tracking: Tracks MIDI keyboard pitch relative to a configurable base key with crossfade loop smoothing.
Envelope shaping: Built-in ADSR envelope for smooth sample transitions.

Try it

Record an ambient field recording through record_in, set the loop mode to Ping-Pong with a 100ms crossfade, and play rich chords across the keyboard.

Microphone -> Sampler (Record In) -> MIDI Notes -> Sampler -> Audio Out

12. Slicer: transient-detecting beat chopper

The Slicer node analyzes incoming audio loops, detects transient attacks, and slices the recording into individual hits mapped across MIDI notes.

How it works

Onset detection: High-precision transient peak detection algorithm automatically finding drum hits and percussive transients.
Metric grid fallback: Option to slice by strict musical divisions (1/8, 1/16, or 1/32 notes) locked to transport BPM.
Per-slice control: Individual start/end offsets, pitch offsets, and reverse triggers per slice.
MIDI pad mapping: Slices automatically map upward from MIDI note C1 for instant pad controller performance.

Try it

Feed a drum break into Slicer, connect an Arpeggiator with a random pattern, and generate an endless supply of breakbeat permutations.

Drum Loop -> Slicer -> Arpeggiator -> Slicer -> Audio Out

13. PaulStretch: extreme spectral time-stretching

The PaulStretch node implements the legendary Paul Nasca spectral time-stretch algorithm, expanding audio recordings from 10x to 1000x their original length without pitch shifts.

How it works

Windowed FFT analysis: Deconstructs incoming audio into heavily overlapping spectral windows (typically 0.25 to 2.0 seconds wide).
Phase randomization: Completely randomizes the phase angle of every frequency bin while preserving original magnitude, eliminating comb filtering and phase cancellation.
Extreme stretch factors: Stretches a 3-second vocal sample into a 5-minute ambient drone that retains acoustic warmth.
Unison & detune: Adds multi-voice spectral unison for shimmering cinematic textures.

Try it

Load a short acoustic piano chord into PaulStretch, set Stretch to 50x, open the FFT window to 1.5 seconds, and send the result into a Limiter for an ambient soundscape.

Piano Sample -> PaulStretch (50x) -> Limiter -> Audio Out

14. Molder: harmonic partial decomposition and waveshaping

The Molder node decomposes incoming audio into tracked sinusoidal partials and residual noise, then applies nonlinear wavefolding and dynamic mutation curves.

How it works

Sinusoidal tracking: Extracts frequency tracks and energy envelopes from any incoming sample.
Mutation roll: The Roll button mutates frequency tracks, introducing harmonic permutations and metallic shifts.
Nonlinear folding: Compresses partial amplitudes through polynomial folding curves, producing grit and analog saturation.

Try it

Send a clean acoustic vocal recording into Molder, trigger the Roll parameter via a macro button, and listen to the voice transform into alien harmonic drones.

Sampler -> Molder -> Chorus -> Audio Out

15. Grain Molder: granular feature sorting and risers

The Grain Molder node chops an audio buffer into thousands of overlapping micro-grains, analyzes their acoustic properties (loudness, spectral centroid, or pitch), and sorts them in ascending or descending order.

How it works

Micro-grain slicing: Deconstructs buffers into grains between 20ms and 150ms with Hann window envelopes.
Acoustic feature classification: Measures root-mean-square (RMS) energy, brightness, and pitch density for every grain.
Sorting engine: Reorders grains along the playback timeline according to the chosen metric.
Amount slider: Morphs continuously from original chronological playback to fully sorted granular order.

Try it

Load a busy drum break, set Sort Mode to Level, and automate the Amount slider from 0% to 100% over four bars to produce a natural granular riser.

Drum Loop -> Grain Molder (Amount) -> Audio Filter -> Audio Out

16. Granular: real-time polyphonic granular cloud engine

The Granular node shreds recorded or live audio into micro-sound grains (10ms to 500ms), scattering them across space and time to produce granular clouds, textures, and pitch-shifted shimmers.

How it works

Grain density & size: Generates up to 64 simultaneous overlapping grains with customizable duration and emission rate.
Position scrub & spray: Controls the center read head position in the buffer, while Spray introduces random time offsets.
Pitch randomization: Randomly scatters grain playback speeds across customizable semitone windows.
Freeze toggle: Instantly locks the read head to sample an infinitesimal sliver of sound indefinitely.

Try it

Pipe a live guitar input into Granular, hit Freeze during a sustained chord, and widen Pitch Spray to turn a single strum into an ethereal cloud of sound.

Audio In -> Granular (Freeze) -> Stereo Delay -> Audio Out

17. Field Synth: programmable per-sample JIT DSP kernel

The Field Synth node is Infinite's most flexible sound engine: a polyphonic synthesizer whose entire voice algorithm is written in Infinite's bare-name Field language and compiled directly into native machine code.

How it works

Bare-name syntax: Write DSP code with plain algebraic expressions (freq, phase, out) without sigils or boilerplate.
Per-sample execution: Runs on the audio thread at 48kHz with zero garbage collection or allocation overhead.
Dynamic user knobs: Define custom parameters in code that automatically expose modulatable pins on the node body.
Polyphonic voice architecture: The engine handles note allocation, voice stealing, and per-voice registers automatically.

Example: resonant dual-oscillator kernel

// inputs: f (frequency), t (time), gate (0..1)
state p1 = 0.0
state p2 = 0.0

// phase accumulators
let inc = f * (6.2831853 / 48000.0)
p1 = p1 + inc
if p1 > 6.2831853 { p1 = p1 - 6.2831853 }

p2 = p2 + inc * 1.005 // slight detune
if p2 > 6.2831853 { p2 = p2 - 6.2831853 }

// soft-clipped sum
let raw = sin(p1) * 0.5 + sin(p2) * 0.5
out = tanh(raw * 1.5) * gate

Try it

Drop a Field Synth, paste the kernel above, connect MIDI Notes, and immediately enjoy a clean, detuned analog lead with zero external dependencies.

MIDI Notes -> Field Synth -> Limiter -> Audio Out

18. Drum Sequencer: 16-step polyphonic drum engine

The Drum Sequencer node is an integrated 8-track, 16-step drum machine combining analog drum synthesis circuits with an intuitive pattern grid.

How it works

8 synthesized drum voices: Dedicated circuits for Kick, Snare, Closed Hat, Open Hat, Clap, Low Tom, High Tom, and Percussion.
Individual audio outputs: Includes a master stereo mix output plus eight individual audio outs (1 to 8) for per-channel external processing and mixing.
Step velocity & swing: Per-step velocity sliders with configurable shuffle percentage.
Transport lock: Automatically locks to Infinite's global BPM and timeline transport.

Try it

Wire individual output 1 (Kick) to an Audio Analyze node, and use its bass energy output to drive the scale of a 3D Sphere in sync with the beat.

Drum Sequencer (Kick Out) -> Audio Analyze -> 3D Sphere (Scale)

19. MPC: 16-pad vintage sampling groovebox

The MPC node captures the tactile immediacy and groove feel of classic 16-pad hardware samplers.

How it works

16 dynamic sample pads: Drag and drop audio files onto any of the 16 pads.
16-level velocity mode: Spreads either volume or pitch across all 16 pads for expressive melodic playing of a single sample.
Note repeat: Hold a pad while pressing Note Repeat to generate rhythmic rolls quantized to 1/8, 1/16, or 1/32 triplets.
Choke groups: Assign pads to mutually exclusive mute groups (such as open and closed hi-hats).

Try it

Load a vocal chop onto pad 1, turn on 16-Level Tuning, and play pitched vocal melodies straight from a MIDI keyboard or pad controller.

MIDI Notes -> MPC -> Saturator -> Audio Out

20. Looper: multi-layer live performance phrase looper

The Looper node is designed for live improvisation, enabling bar-quantized audio phrase recording, seamless overdubbing, and speed manipulation.

How it works

Bar-quantized punch-in: Automatically rounds start and stop commands to the nearest bar boundary (1, 2, 4, 8, or 16 bars).
Non-destructive overdubbing: Layer takes indefinitely with an adjustable decay feedback control to prevent buildup.
Reverse & half-speed: Instant reverse toggle and half-speed playback for tape-style pitch drop effects.
Boundary crossfades: Applies 5ms micro-crossfades across loop seams, eliminating clicks on imperfect takes.

Try it

Record a 2-bar guitar or vocal loop, hit Dub to add counter-melodies, and toggle Reverse for an immediate backwards psychedelic texture.

Audio In -> Looper -> Stereo Delay -> Audio Out

Synthesis on a unified graph

Because Infinite shares a single execution graph across audio, 2D compositing, and 3D geometry, these twenty synthesizers are not confined to traditional DAW audio tracks.

You can drive a Wavetable position from a particle system's average kinetic energy, strike a Metallic resonator whenever a 3D bouncing sphere collides with a floor plane, or scan a generative reaction-diffusion texture through Wave Terrain at 48kHz.

Drop any synthesizer onto the canvas, wire it up, and explore sound design unconstrained by plugin windows.

Originally published at https://infinitedevices.org/blog/every-synthesizer-node-in-infinite-sound-design-guide.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Granular synthesis in modular audio: soundscapes and grain clouds

naman — Wed, 11 Nov 2026 13:15:18 +0000

Granular synthesis in modular audio transforms continuous recorded sound into swarms of microscopic acoustic quanta. Rather than playing back an audio recording as a fixed linear timeline, granular synthesis deconstructs source audio into tiny acoustic fragments called grains, typically lasting between 5 and 100 milliseconds. By controlling the density, duration, pitch transposition, spatial distribution, and playback position of hundreds of simultaneous grains, sound designers can stretch time to infinity, dissolve field recordings into shimmering ambient clouds, or restructure rhythmic loops into completely new acoustic textures.

In Infinite, granular processing is not confined to an isolated plugin window or a static offline bounce. Granular processing operates directly on the real-time node canvas, where per-sample DSP, modulation signals, and GPU graphics interact within a single unified graph. Audio from microphones, live instruments, or loaded audio samples can be continuously streamed into granular buffers, modulated by low-frequency oscillators and rhythmic sequencers, and patched simultaneously into spatial delay networks and reactive visual shaders.

This guide explores the technical foundations of real-time granular synthesis, the mathematics of grain windowing and energy normalisation, the architecture of Infinite's native Granular and Grain Molder nodes, and practical routing recipes for experimental sound design.

Principles of micro-sound and granular synthesis

The physical concept of micro-sound originates in the pioneering work of physicist Dennis Gabor and composer Iannis Xenakis, later formalized by Curtis Roads in Microsound. Gabor demonstrated that any continuous acoustic signal can be represented as a two-dimensional matrix of time-frequency quanta, analogous to quantum wave packets in quantum mechanics.

A single isolated grain lasting 20 milliseconds is too short for the human auditory system to perceive as a continuous musical tone. When heard alone, a micro-grain sounds like a dry click or brief tap. However, when dozens or hundreds of grains are scheduled in rapid succession or layered simultaneously, a psychoacoustic transformation occurs:

Quasi-synchronous grain streams: when grains are emitted at strictly regular periodic intervals, the repetition rate introduces a perceived fundamental pitch equal to the emission frequency ($f_0 = 1 / \Delta t$). At low rates (1 to 20 Hz), the listener hears a rapid train of distinct impulses or rhythmic ratchets. As the emission density exceeds 30 to 40 Hz, the individual grains fuse into a continuous pitched tone, a phenomenon known as pulsar synthesis.
Asynchronous grain clouds: when grain onset times, durations, and read positions are perturbed by stochastic jitter, the periodic pulse dissolves. The ear no longer tracks individual events or synthetic pitch pulses; instead, it perceives a diffuse, textural acoustic cloud. By modulating the variance of read offsets (position spray) and pitch jitter, a sound designer can smoothly transition from pristine sample playback to lush, cinematic drones.

Time-domain representation of grain emission:

Periodic Train (Pulsar):
  +---+     +---+     +---+     +---+     +---+
  | g |     | g |     | g |     | g |     | g |     --> Perceived fundamental pitch
  +---+     +---+     +---+     +---+     +---+
  |<-- Delta t -->|

Stochastic Cloud (Asynchronous):
     +-----+         +---+
     | g1  |         |g3 |       +------+
     +-----+         +---+       |  g5  |           --> Diffuse ambient texture
        +-------+          +--+  +------+
        |  g2   |          |g4|
        +-------+          +--+

Controlling this transformation requires precise real-time scheduling. In traditional tape-based composition, cutting and splicing thousands of microscopic fragments was a laborious manual task. In modern digital audio environments, digital signal processors generate, interpolate, envelope, and accumulate hundreds of active grains per audio buffer without latency or dropouts.

Anatomy of a grain: windows and envelopes

Extracting a raw slice of digital audio creates abrupt discontinuities at the start and end boundaries. If a grain begins or ends away from a natural zero-crossing, the instantaneous voltage step creates high-frequency spectral splatter, perceived as harsh clicks and buzzing.

To eliminate boundary clicks, every grain must be multiplied by a smooth windowing envelope $w(t)$ over its normalized lifespan $t \in [0, 1]$. The shape of this window determines both the temporal attack and the harmonic colour of the grain cloud:

Window function comparison:

Hann:            Gaussian:        Exponential Decay:
    .-'-.            .---.            |\
  .'     '.        .'     '.          | \
 /         \      /         \         |  \..__
'-----------'    '-----------'        '-------'
Smooth spectrum  Optimal focus        Snappy strike

Infinite provides five distinct window functions within its native granular DSP engine:

1. Hann window

The raised cosine window is the standard choice for smooth time-stretching and ambient texture generation:

$$w(t) = 0.5 \cdot (1 - \cos(2\pi t))$$

The Hann window provides gentle attack and release slopes, with spectral sidelobes falling off at 18 dB per octave. It eliminates all transient clicks while preserving the harmonic purity of melodic source material.

2. Gaussian window

The Gaussian curve offers optimal mathematical localisation in both the time and frequency domains:

$$w(t) = \exp\left(-8 \cdot (2t - 1)^2\right)$$

Because the Gaussian curve approaches zero smoothly without abrupt truncation, it produces minimal spectral smearing. Grains windowed with a Gaussian envelope retain focused transient clarity, making it ideal for vocal textures and acoustic instruments.

3. Triangle window

The Bartlett or triangular window applies symmetric linear ramps:

$$w(t) = 1 - 2 \cdot |t - 0.5|$$

With sharper transitions at the apex and boundaries, the triangle window introduces subtle high-frequency harmonic edge, lending a bright, crystalline character to dense grain clouds.

4. Exponential decay window

Unlike symmetric windows, the exponential decay window mimics natural acoustic impact envelopes:

$$w(t) = \sin(\pi t) \cdot \exp(-3t) \cdot 2.3$$

This envelope combines a rapid, snappy onset with a curved decay tail. When applied to granular playback, it transforms sustained audio buffers into percussive micro-bursts, rain droplets, and metallic scatter.

5. Trapezoid window

The trapezoid window features steep linear attack and decay slopes (12% of total grain duration) flanking an 88% flat sustain plateau:

$$w(t) = \max\left(0, \min\left(1, \min\left(\frac{t}{0.12}, \frac{1 - t}{0.12}\right)\right)\right)$$

This envelope preserves the natural uncoloured amplitude of the source material for the majority of the grain duration, applying brief micro-fades only at the boundaries. It is particularly effective for granular loop slicing and stutter effects.

High-order fractional interpolation

When grains are pitch-shifted or played back at arbitrary speed ratios, the read position rarely aligns with discrete integer sample indices. Truncating to the nearest sample or using simple linear interpolation introduces noticeable aliasing and high-frequency noise.

Infinite's granular engine employs 4-point, 3rd-order Hermite cubic interpolation (ReadSampleHermite) for every sample lookup. Hermite interpolation fits a smooth cubic polynomial across four neighbouring sample points ($y_{-1}, y_0, y_1, y_2$), matching both position and first-order derivatives. This ensures continuous, artifact-free playback across pitch transpositions spanning multiple octaves.

Real-time engine architecture in Infinite

Executing granular synthesis in real time requires strict concurrency control and zero-allocation memory discipline. In Infinite, the granular subsystem separates duties between two core components:

GranularNode (main UI thread): manages sample loading, waveform cache rendering, start and end trim markers, parameter serialisation to .inf patch files, and user interaction.
AudioGranularNode (real-time audio thread): executes inside the high-priority OS audio callback, advancing the master scan playhead, spawning active grains, computing Hermite interpolation, and accumulating stereo output buffers.

+-----------------------------------------------------------------+
|                           MAIN THREAD                           |
|                                                                 |
|  [GranularNode]                                                 |
|         |                                                       |
|         +---> Sample file loading (.wav, .flac, .aif)           |
|         +---> Waveform peak cache generation                    |
|         +---> Visual start/end trim drag handles                |
|         +---> ParamRef registration for modulation cables       |
+-----------------------------------------------------------------+
                                |
                   Lock-free SampleSlot & Atomic Params
                                |
                                v
+-----------------------------------------------------------------+
|                          AUDIO THREAD                           |
|                                                                 |
|  [AudioGranularNode]                                            |
|         |                                                       |
|         +---> Live recording stream from Audio In pin           |
|         +---> Master scan playhead accumulator                  |
|         +---> Pre-allocated Grain pool (kMaxGrains = 64)        |
|         +---> Stochastic RNG for jitter & pitch spray           |
|         +---> Hermite 4-point cubic interpolation               |
|         +---> Power-preserving energy normalisation             |
|         +---> Constant-power stereo panning                     |
+-----------------------------------------------------------------+
                                |
                   Lock-free Visual Snapshot Ring
                                |
                                v
+-----------------------------------------------------------------+
|                         VIEWPORT / UI                           |
|                                                                 |
|  Real-time grain dots rendering at 60 fps over waveform         |
+-----------------------------------------------------------------+

Pre-allocated grain pools and zero allocation

The audio thread must never allocate heap memory (malloc or new) or block on mutexes. Infinite pre-allocates a fixed pool of grain structures (kMaxGrains = 64) when the node is instantiated. When the spawn timer expires, the engine scans the pool for an inactive slot or reclaims the oldest finished grain.

If a new audio file is loaded during playback, the audio thread swaps sample buffers via an atomic lock-free SampleSlot. The old buffer is safely released on the background thread only after the audio thread has released its reference, preventing audio glitches.

Power-preserving energy normalisation

In granular synthesis, changing grain density or grain length dramatically alters the number of overlapping grains. At low density (e.g. 5 grains per second of 20 ms duration), overlap is minimal. At high density (e.g. 80 grains per second of 300 ms duration), twenty or more grains may sound simultaneously.

Summing twenty overlapping grains without compensation causes severe digital clipping and distortion. Conversely, dividing the output by the maximum theoretical grain count leaves sparse grain streams inaudibly quiet.

Infinite solves this using automatic power-preserving energy normalisation. For each spawned grain, the engine calculates the overlap factor based on duration and spawn interval:

$$\text{overlapFactor} = \max\left(1.0, \frac{\text{totalFrames}}{\text{intervalFrames}}\right)$$

$$\text{grainGain} = \frac{1}{\sqrt{\text{overlapFactor}}}$$

By scaling each grain inversely by the square root of the overlap factor, the engine maintains constant root-mean-square (RMS) acoustic energy across radical density and length automations.

The Granular node: clouds, spray and freeze

The native Granular node provides a complete suite of controls for sculpting micro-sound clouds:

Playhead positioning and scan speed

position [0.0 to 1.0]: sets the base playback read position within the sample buffer. When patched to an external modulation source, such as an LFO or envelope, this acts as a precision scrubbing control.
scan [-2.0x to +2.0x]: enables autonomous playhead movement. Positive values scrub forward at fractional or accelerated speeds; negative values scrub backward. When set to 0.0, the playhead remains stationary, sustaining a micro-slice indefinitely.
start and end [0.0 to 1.0]: visual trim markers that constrain grain emission to a specific region of interest. When loop is active, the scan playhead and spawned grains wrap seamlessly between these boundaries.

Dispersion and stochastic jitter

Uniform grain emission sounds robotic and synthetic. To create organic, living textures, Granular provides dedicated dispersion controls:

randomPos (Position spray): adds Gaussian stochastic jitter to the spawn position of each grain. Small amounts (5% to 15%) introduce subtle acoustic shimmer; large amounts (50% to 100%) scatter grains across the entire buffer, dissolving temporal structure into an ambient wash.
randomLength: introduces random variation to individual grain durations, preventing repetitive flutter rhythms.
randomPitch [0 to 24 semitones]: applies random pitch transposition to each grain. Setting this to 12 semitones produces wide harmonic octave clouds; micro-tuning settings (0.2 to 0.5 semitones) create lush natural chorusing.
randomPan and width: scatters grains across the stereo field using constant-power equal-energy panning ($pan_L = \cos\theta, pan_R = \sin\theta$).
reverseProb [0.0 to 1.0]: sets the probability that an individual grain will play backward. Mixing 20% to 30% reverse grains adds ethereal spectral backwards tails without reversing the master playback direction.

Freeze mode and live buffer capture

Toggling freeze halts advancement of the master scan playhead. The engine continues spawning overlapping grains from the current position with all active spray and pitch jitter parameters intact. This captures an infinite, stationary drone from any transient sound.

Additionally, Granular includes a dedicated audio input pin (record in). Sound designers can route live microphone signals, modular synth patches, or drum tracks directly into the node. Toggling record captures incoming audio into the internal ring buffer in real time, allowing immediate granular manipulation of live performance inputs.

The Grain Molder node: topological sorting and scrambling

While standard granular engines process audio chronologically, the Grain Molder node introduces a radically different paradigm: time-domain grain sorting.

Grain Molder slices incoming audio buffers into overlapping grains (10 to 500 ms) and evaluates an acoustic metric for every slice:

Level (RMS amplitude): calculates the root-mean-square energy of each grain. Sorting by level arranges the audio from quietest grains to loudest grains, or vice versa.
Brightness (Spectral centroid): calculates the high-frequency energy distribution or zero-crossing rate. Sorting by brightness groups dark, low-frequency segments together, transitioning progressively into sharp, bright transients.
Random: generates a deterministic, seed-based pseudo-random permutation of grain indices.

Grain sorting process in Grain Molder:

Original chronological order:
[G1: quiet] [G2: loud] [G3: medium] [G4: peak] [G5: silent]

Sorted by Level (ascending order):
[G5: silent] [G1: quiet] [G3: medium] [G2: loud] [G4: peak]  --> Natural riser

The Amount control: continuous order interpolation

The defining control of Grain Molder is the amount slider [0.0 to 1.0]. Rather than snapping abruptly between original playback and sorted order, amount provides a continuous morph:

At 0.0, the buffer plays back in its original chronological sequence.
At 1.0, the buffer plays back in strictly sorted metric rank order.
At intermediate values (e.g. 0.45), grains undergo continuous partial scrambling, introducing subtle rhythmic dislocations while preserving the overarching melodic contour.

When applied to complex acoustic material such as acoustic drum loops or orchestral recordings, automating the amount slider from 0.0 to 1.0 over four bars produces a natural, glitch-free build-up or riser without requiring volume automation or pitch risers.

Modular routing: modulation, effects and visuals

The power of granular synthesis expands exponentially when connected to Infinite's modular canvas. Because parameters in Infinite are exposed as typed ParamRef targets, any slider can be modulated by external control signals.

Modular canvas signal flow:

  [Audio In] --------> (record in)
                           |
  [LFO / Random] ----> (position)
                           |
  [Step Sequencer] --> (pitchShift)
                           |
                     [ Granular ]
                           |  (Stereo Audio Out)
                           +------------------------+
                           |                        |
                           v                        v
                    [ Stereo Delay ]        [ AudioTexture ]
                           |                        |
                    [ Reverb ]              [ AudioDisplacement ]
                           |                        |
                    [ Audio Out ]           [ Render 3D ]

Patch 1: Ambient orchestral shimmer cloud

Drop an audio sample containing acoustic strings or piano into a Granular node.
Set grainLength to 140 ms, density to 35 Hz, and select the Gaussian window shape.
Set scan to 0.05x for ultra-slow forward progression.
Set randomPos to 20%, randomPitch to 12 semitones, and randomPan to 85%.
Wire a slow sine LFO (0.05 Hz) into position to gently wander across the sample.
Connect the stereo audio output of Granular into a Stereo Delay node, followed by a lush Reverb.
Engage freeze during dense chords to lock the texture into an infinite, evolving ambient pad.

Patch 2: Granular drum break scrambler

Load a classic breakbeat into a Grain Molder node.
Set grainMs to 60 ms and choose the Level sorting mode.
Wire a synchronized ramp LFO running at 1/2 bar into the amount parameter.
As the LFO ramps from 0% to 100%, the break progressively reassembles itself from quiet ghost notes into clustered snare and kick peaks, creating an automated rhythmic fill.
Route the output into an AudioMeter to observe peak levels, ensuring the mix sits cleanly inside your master bus.

Patch 3: Synaesthetic granular audiovisuals

Granular synthesis produces intricate acoustic micro-transients that are ideally suited for driving real-time computer graphics. In Infinite, audio and visuals share the same memory space:

Tap the stereo audio cable exiting Granular and patch it into an AudioTexture node.
The AudioTexture converts time-domain grains and spectral bands into a dynamic GPU texture.
Connect the texture into an AudioDisplacement node deforming a high-density Mesh Sphere.
As grains trigger and scatter across the stereo field, the 3D sphere ripples and pulses in direct synchronisation with individual grain windows.
Pipe the deformed geometry into a Render 3D node to view the resulting particle mesh in the live viewport.

For broader procedural routing possibilities, explore Infinite's node library and our companion architectural guide on node-based DAW workflows.

Comparing granular synthesis and spectral stretching

While both granular synthesis and spectral processing manipulate audio in non-linear ways, they operate on different mathematical principles:

Parameter	Granular Synthesis (`Granular`)	Spectral Stretching (`PaulStretch`)
Domain	Time-domain windowed micro-quanta	Frequency-domain STFT phase randomisation
Grain duration	5 ms to 1000 ms	2048 to 65536 FFT sample bins
Pitch manipulation	Per-grain Hermite rate transposition	Spectral bin frequency shifting
Transient response	Preserves micro-attacks with tight windows	Diffuses all transients into glassy pads
Memory model	Lock-free sample ring buffers	Overlap-add IFFT synthesis buffers
Primary application	Clouds, texture scatter, live glitch, stutter	Extreme ambient stretching (10x to 1000x)

For extreme time-stretching exceeding 50x duration, spectral algorithms such as PaulStretch excel at eliminating all perceived grain repetition. For rhythmic manipulation, micro-sound scattering, and interactive live performance, real-time granular synthesis remains unmatched.

Technical limits and performance considerations

When authoring complex granular patches in Infinite, several practical engineering limits apply:

Voice ceiling and CPU load: the AudioGranularNode engine tracks up to 64 simultaneous active grains (kMaxGrains). Each active grain performs four Hermite cubic sample reads and window evaluation calculations per sample. On modern Apple Silicon and x86_64 multi-core processors, running two to four granular engines consumes less than 3% CPU. However, pushing multiple instances to maximum density (100 Hz with 1000 ms length) will saturate the pre-allocated grain pool.
Buffer capacity: the live recording buffer captures up to 60 seconds of uncompressed 32-bit floating point audio at 44.1 or 48 kHz. Recording beyond this duration sets the internal overflow flag and halts writing to prevent memory exhaustion.
Stand-alone and host architecture: Infinite is a standalone application and modular plugin host; it does not ship as an AAX plugin for Avid Pro Tools. It hosts native VST3 and AU plugins, routes MIDI and audio bidirectionally, and exports rendered compositions headless via its command-line interface.

Summary

Granular synthesis bridges the gap between micro-sound physics and musical sound design. By combining high-order Hermite interpolation, flexible window envelopes, stochastic spray generators, and topological metric sorting within a unified modular canvas, Infinite provides an expressive platform for real-time acoustic exploration.

To begin building your own granular clouds, download the latest release of Infinite, open the canvas, and patch an audio sample into Granular.

Originally published at https://infinitedevices.org/blog/granular-synthesis-modular-audio-sound-design.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

L-system procedural 3D branching and fractal generation

naman — Wed, 11 Nov 2026 13:15:13 +0000

An l-system procedural 3d branching architecture brings the algorithmic elegance of formal rewriting grammars into real-time computer graphics and modular audiovisual performance. In traditional generative design, procedural geometry often relies on explicit loops, mathematical trigonometric functions, or Perlin noise fields. While noise produces organic displacement and sine waves yield predictable oscillation, neither method captures the developmental morphology of living organisms: structured self-similarity, hierarchical vascular branching, and recursive form unfolding across space and time.

In modular workstations like Infinite, the Lindenmayer system bridges formal language theory, three-dimensional geometry, and live sound design. By evaluating production rules inside a native L-System node, creative coders can grow intricate botanical canopies, generate procedural coral and crystal formations, and modulate geometric growth parameters live using incoming audio frequencies.

Here is how Lindenmayer grammars operate, how three-dimensional turtle geometry navigates space, how branch strands are swept into watertight polygonal tubes, and how to patch audio-reactive procedural trees on a unified canvas.

Formal grammars and parallel rewriting

The mathematical foundation of Lindenmayer systems was developed in 1968 by Hungarian theoretical biologist and botanist Aristid Lindenmayer. Originally formulated to study the growth patterns of multicellular algae, mosses, and vascular plants, L-systems belong to the family of formal rewriting grammars.

In classical Chomsky grammars used across compiler design, production rules are applied sequentially, replacing one non-terminal symbol at a time. In contrast, an L-system applies its replacement rules in parallel across every symbol in the string simultaneously. This parallel replacement reflects biological cell division, where multiple biological structures grow and divide at the same physical instant.

A deterministic context-free L-system (known formally as a DOL-system) is defined by three components:

Alphabet: A finite set of formal symbols V containing characters that can be replaced or walked by a geometry interpreter.
Axiom: An initial seed string omega of symbols chosen from V that defines the starting state of the organism.
Production rules: A mapping P that associates predecessor characters with successor replacement strings.

Consider the canonical branching plant grammar:

Axiom: X
Rules: X = F+[[X]-X]-F[-FX]+X; F = FF

During generation zero, the system state consists solely of the axiom X. In the first generation, the production rule replaces X with its successor:

Generation 0: X
Generation 1: F+[[X]-X]-F[-FX]+X
Generation 2: FF+[[F+[[X]-X]-F[-FX]+X]-F+[[X]-X]-F[-FX]+X]-FF[-FFF+[[X]-X]-F[-FX]+X]+F+[[X]-X]-F[-FX]+X

As iterations advance, the length of the string increases exponentially. In the native L-System node inside Infinite, string expansion is governed by safety caps:

The maximum number of generations is bounded by kMaxIterations = 10.
The total rewritten symbol buffer is capped at kMaxSymbols = 200000.

If a grammar expands beyond the symbol limit, rewriting terminates cleanly and issues a diagnostic notification. This safety ceiling guarantees that complex grammars never exhaust host memory or block real-time rendering during live performances.

Turtle geometry in three dimensions

Once a string of symbols is rewritten, it must be translated into spatial form. This translation is performed by a three-dimensional turtle geometry interpreter, extending Seymour Papert's original two-dimensional Logo turtle into Cartesian space.

The turtle maintains an internal state consisting of a spatial position (px, py, pz) and three mutually orthogonal unit vectors that form an orthonormal frame in three dimensions:

Heading vector H: points in the direction the turtle is currently facing and moving forward.
Left vector L: points to the local left side of the turtle.
Up vector U: points along the local normal vector perpendicular to the heading and left vectors.

The orientation triad satisfies the cross-product relationship:

H x L = U

As the interpreter parses the rewritten symbol string from left to right, each character commands the turtle to move or reorient its local frame:

F: Move forward by the current step length while drawing geometry.
f: Move forward by the current step length without drawing geometry, creating intentional structural gaps.
+: Turn left by the branching angle, spinning vectors H and L around axis U.
-: Turn right by the branching angle, spinning vectors H and L in the opposite direction around axis U.
&: Pitch down by the branching angle, spinning vectors H and U around axis L.
^: Pitch up by the branching angle, spinning vectors H and U in the opposite direction around axis L.
\: Roll left by the branching angle, spinning vectors L and U around axis H.
/: Roll right by the branching angle, spinning vectors L and U in the opposite direction around axis H.
|: Reverse direction by 180 degrees, inverting the heading vector.

Because repeated floating-point matrix rotations accumulate subtle numerical errors over thousands of symbols, Infinite executes an orthonormal renormalisation step following each rotation:

void Renormalize(Turtle& t)
{
   float* v[3] = { t.h, t.l, t.u };
   for (float* x : v)
   {
      const float len = std::sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
      if (len > 1e-6f)
         for (int i = 0; i < 3; i++)
            x[i] /= len;
   }
}

This normalisation guarantees that the turtle orientation vectors never shear or collapse, maintaining geometric fidelity across deep recursive iterations.

Branching stacks and hierarchical state

Botanical forms require branching structures where subsidiary twigs diverge from parent boles while preserving the original growth trajectory. In L-systems, this hierarchy is encoded through pushdown automata symbols:

[: Push the current turtle state onto a lifo stack. The saved state includes spatial coordinates (px, py, pz), orientation frame vectors H, L, U, current branch radius, and current step length. The branch radius is then multiplied by radiusScale, and the step length is multiplied by lengthScale.
]: Terminate the active branch and pop the saved turtle state from the stack, restoring the parent branch position, frame orientation, radius, and step length.

Through this stack mechanism, a single linear string encodes complex tree canopies with nested sub-branches of proportional thickness and length.

Tube extrusion and branching radii

Drawing wireframe polylines produces an informative schematic, but visual rendering demands solid three-dimensional geometry with surface normals, cross-sectional volume, and UV mapping for material shaders.

The native L-System node solves this by sweeping each continuous branch strand into a watertight polygonal cylinder via MeshOps::TubeAlong.

Strand points -> Cylindrical cross-sections -> Triangular quad strips -> Watertight mesh

Key physical parameters govern this mesh synthesis:

sides: Controls the radial polygon count of the cross-sections, adjustable between 3 (producing low-poly crystalline trunks) and 24 (producing smooth organic boughs).
radius: Sets the absolute base radius of the primary trunk.
radiusScale: The geometric multiplier applied to radius each time a sub-branch is pushed with [. A value of 0.75 ensures parent limbs are sturdier than daughter branches, mirroring Leonardo da Vinci's botanical rule of trees.
taper: Governs linear narrowing along the length of each strand segment, ensuring branches taper toward their terminal buds rather than ending abruptly as blunt cylinders.
length and lengthScale: Control the physical reach of the primary trunk and the rate at which daughter twigs shorten toward the perimeter.

To prevent GPU memory saturation during live performances, Infinite enforces a hard cap of kMaxStrands = 6000 extruded tubes. Any additional branches beyond this limit remain present in the polyline curve but are excluded from polygonal mesh extrusion.

Dual mesh and polyline representations

A distinctive design decision of the L-System node is its dual output contract: it concurrently provides both a three-dimensional polygonal Mesh and a continuous three-dimensional Polyline.

L-System Node
  ├── GetMesh()  -> Watertight 3D polygonal geometry (tubes, vertices, normals, UVs)
  └── GetCurve() -> Continuous 3D polyline path (reconstructed traversal points)

This dual pipeline opens versatile creative workflows:

Polygonal mesh rendering: The mesh connects directly to standard 3D rendering pipelines, accepting PBR materials, casting shadow maps, and responding to scene lighting.
Path tracking and camera choreography: The Polyline output connects to the Path node. Because the turtle traverses the tree in deterministic order, a Camera 3D can be constrained to glide along the polyline path, flying smoothly through the interior vascular channels of the fractal tree canopy.
Particle flow guides: Downstream simulation nodes can distribute emitters or flow particles along the polyline curve, creating glowing sap rising through procedural veins.

Real-time audio modulation and kinetic foliage

Because Infinite evaluates its node graph in real time, the parameters of the L-System node can be dynamically modulated by audio analysis or control signals. Unlike pre-rendered 3D assets, a procedural grammar can breathe and pulse in direct synchronisation with music.

Consider the following audio-reactive modulation pairings:

Modulating branching angles with frequency bands

By connecting the low-frequency band of an Audio Analyze node to the angle parameter of L-System, the physical divergence of the tree branches expands and contracts in response to bass transients:

At quiet moments (angle = 18.0), branches align closely with the primary trunk, producing a slender, dormant cypress form.
On heavy kick drum or bass hits (angle = 38.0), branches fan outward into an open, blossoming canopy.

Because changing the branching angle preserves the total number of vertices and triangles, angle modulation incurs zero memory allocation overhead, running at full display frame rates without dropped frames.

Modulating length and scale with melodic envelopes

Connecting mid-range or high-frequency energy to lengthScale dynamically alters the density of the outer foliage. When a synth arpeggio or percussion roll plays, outer branches extend outward and recoil, giving the tree an organic breathing kinetic presence.

Modulating growth iterations across musical sections

The iterations parameter governs structural complexity. Routing a slow step sequencer or an arrangement automation curve to iterations allows a seed to sprout at generation 1 during an ambient intro, expand to generation 3 in the first verse, and erupt into a fully unfurled generation 5 fractal canopy at the musical drop.

Composing procedural scenes in Infinite

To assemble a finished audiovisual composition, the L-System node is wired into the standard 3D rendering graph alongside lighting and camera nodes.

Audio In ──────────> Audio Analyze ──[Low Band]──> Math ──> L-System (angle)
                                                               │
                                                         [Mesh Output]
                                                               │
Light 3D ──> Scene 3D ─────────────────────────────────────> Material ──> Render 3D ──> Viewport
                                                                            ▲
Camera 3D ──────────────────────────────────────────────────────────────────┘

Here is the step-by-step assembly process:

Add the audio chain: Place an Audio In node, wire it into Audio Analyze, and extract the low output band. Route this through a Math node to map incoming zero-to-one signal ranges into the desired angular span, such as 20.0 to 40.0 degrees.
Add the generator: Place an L-System node. Connect the scaled audio signal into the angle parameter input. Set the axiom to X and rules to X=F+[[X]-X]-F[-FX]+X;F=FF. Set iterations to 4 or 5.
Apply materials: Wire the mesh output into a Material node. Assign a deep organic albedo colour, set roughness to 0.65 for natural wood scattering, and configure a subtle emissive tint modulated by high-frequency audio energy.
Set up lighting and camera: Connect the material into a Render 3D node. Add a Camera 3D positioned at (0.0, 1.5, 4.0) targeting the centre of the tree canopy. Add two Light 3D nodes: a warm directional key light and a cool cyan rim light to highlight branch contours against the dark ground.
Combine with shaders: In Infinite, you can pair 3D geometry with 2D post-processing. Take the render output and composite it with background gradients or real-time GLSL shaders for depth of field and atmospheric haze.

To explore pre-configured templates and community patches featuring procedural geometry, visit the patch library.

Algorithmic variations and botanical grammars

The flexibility of Lindenmayer systems lies in their grammatical versatility. By modifying the axiom and replacement rules, the exact same node architecture generates fundamentally distinct natural forms.

Classic 3D bush

This classic grammar produces balanced spherical shrubbery with uniform outward branching:

Axiom: A
Rules: A = [&+F[A]][&-F[A]][^+F[A]][^-F[A]]; F = FF
Angle: 28.0

The four-way branch split combines pitch (&, ^) and yaw (+, -) rotations, producing full three-dimensional volumetric foliage.

Monopodial pine tree

For coniferous trees where a dominant central trunk continues upward while subordinate whorls emerge at regular intervals:

Axiom: !(1)F(100)/(45)A
Rules: A = [&(30)B]F(10)/(45)A; B = [&(30)F(20)]F(10)/(45)B
Angle: 25.0

Here, the primary trunk maintains vertical dominance while lateral branch clusters spiral radially around the central stem.

3D Hilbert space-filling curve

L-systems are not limited to biological plants; they also describe space-filling fractals and recursive mathematical curves:

Axiom: X
Rules: X = ^\XF^/XFX-F^//XFX&F+//XFX-F/X-
Angle: 90.0

When evaluated with 90-degree turning angles, this grammar weaves a single continuous polyline through every sub-cube of a three-dimensional lattice. When swept into tubes and modulated with audio, it creates intricate kinetic geometric sculptures.

For broader techniques combining mathematical deformation with procedural meshes, see our guide on procedural 3D geometry nodes.

Summary

L-system procedural 3D branching provides an expressive bridge between theoretical linguistics, computer graphics, and live music performance. By encoding complex natural structures into concise symbolic grammars, artists can generate organic botanical forms that remain entirely deterministic, mathematically pure, and lightweight.

Through Infinite's native L-System node, these formal grammars live inside an interactive modular graph. Artists can manipulate branch cross-sections, route geometry along motion paths, and modulate angles and lengths in real time to the rhythm of incoming audio. The result is a procedural instrument where mathematics, sound, and visual form grow together on a single canvas.

Originally published at https://infinitedevices.org/blog/l-system-procedural-3d-branching-fractals.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Drum and bass Reese bass sound design in modular synthesisers

naman — Wed, 11 Nov 2026 13:15:05 +0000

Few sounds define underground electronic music as completely as the Reese bass. Originating on the Casio CZ-1 synthesiser under Kevin Saunderson's Reese moniker in 1988, the patch became the sonic cornerstone of jungle, drum and bass, techstep, and neurofunk. Producers from Renegade Soundwave to Ed Rush, Optical, Dillinja, and Noisia transformed what began as a simple pair of detuned oscillators into an evolving, multi-band instrument of pressure and texture.

Achieving authentic drum and bass Reese bass sound design requires understanding the acoustic physics of phase cancellation, harmonic saturation, and multi-band routing. In conventional digital audio workstations, setting up this architecture requires dozens of plugin windows, complex auxiliary buses, and clunky phase-alignment utilities.

In Infinite, the entire signal path lives directly on a unified node canvas. You can route audio, control voltages, and real-time graphics without latency penalties or auxiliary routing bottlenecks. Here is a step-by-step engineering breakdown of how to construct a professional, club-ready Reese bass from scratch.

Acoustic foundations of the Reese bass

At its core, a Reese bass is generated by the physical phenomenon of acoustic beating. When two periodic waveforms with nearly identical frequencies f_1 and f_2 are summed together, their phase relationship continuously shifts between constructive interference and destructive interference.

The resulting composite waveform pulsates at a beat frequency determined by the absolute difference between the two oscillators:

f_beat = |f_1 - f_2|

If an oscillator plays an F1 note at 43.65 Hz and a second oscillator is detuned sharp by +9 cents (approximately 43.88 Hz), the beat frequency is:

f_beat = |43.88 - 43.65| = 0.23 Hz

This 0.23 Hz differential produces a slow, hypnotic swelling cycle every 4.3 seconds. If the detune is widened to +25 cents, the beating accelerates into an aggressive growl.

The sub-bass phase cancellation trap

While acoustic beating sounds rich across the midrange, it introduces a severe physical defect in the sub-bass register below 90 Hz. When the two detuned saw waves drift into anti-phase (180 degrees apart), their fundamental frequencies cancel each other out completely.

On a large club sound system, this cancellation causes the low end to collapse periodically. The dancefloor feels a momentary drop in kinetic weight every time the waveforms cross zero. To build a Reese bass that translates powerfully across large subwoofers, you must decouple the sub fundamental from the detuned mid band using multi-band frequency splitting.

Dual oscillator core in the Analog node

The foundation of the patch begins with the Analog node. Rather than using pre-recorded wavetables or sample loops, Infinite generates anti-aliased analogue waveforms in real time using band-limited step correction.

[ Note In ] ---> pitch ---> [ Analog Node ]

Oscillator configuration

Oscillator 1: Set the waveform to Sawtooth. Set the octave to 0 and the coarse pitch to 0 semitones. This oscillator serves as our pitch reference.
Oscillator 2: Set the waveform to Sawtooth. Set the coarse pitch to 0 semitones and the fine tune control to +8.5 cents. The subtle pitch disparity creates our primary acoustic beating.
Sub oscillator: Configure the internal sub oscillator to a pure Sine wave, pitched exactly -1 octave down (-12 semitones). We will extract this pure sine during the band-split phase to serve as our mono sub anchor.
Phase mode: Ensure phase sync is disabled so both oscillators run free. Synchronising oscillator phase on every note-on event produces an artificial, static attack. Free-running oscillators guarantee that every note triggers with a slightly different phase alignment, mimicking vintage analogue hardware.
Glide and legato: Set polyphony to Mono Legato and dial in a glide time between 35 ms and 55 ms. Smooth pitch portamento between notes is essential for drum and bass basslines.

You can inspect pre-configured synthesiser templates in the Infinite Library to see how monophonic glide circuits are wired into note graphs.

Multi-band crossover: isolating the sub fundamental

To resolve the phase cancellation dilemma, we split the output of the Analog node into two discrete frequency bands at 110 Hz:

Sub band (20 Hz to 110 Hz): Contains only the solid, monophonic fundamental frequency. This band bypasses all distortion, modulation, and spatial effects to remain completely mono and phase-stable.
Grit band (110 Hz to 20 kHz): Contains the rich detuned saw harmonics. This band is aggressively saturated, filtered, and widened.

We implement this split using two Filter nodes operating in parallel.

                     +---> [ Filter: Lowpass 110 Hz ] ---> (Sub Bus: Mono)
                     |
[ Analog Output ] ---+
                     |
                     +---> [ Filter: Highpass 110 Hz ] ---> [ Distortion Node ]

Configuring the crossover filters

Sub filter: Set filter topology to 4-pole Butterworth Lowpass (24 dB per octave rolloff). Set the cutoff frequency to 110 Hz with zero resonance (Q = 0.707).
Grit filter: Set filter topology to 4-pole Butterworth Highpass (24 dB per octave rolloff). Set the cutoff frequency identically to 110 Hz with zero resonance (Q = 0.707).

Because both filters share matching 24 dB per octave Butterworth responses at identical corner frequencies, their phase shifts align smoothly at the crossover point without phase cancellation or comb-filter notches across the 110 Hz boundary.

Nonlinear waveshaping and harmonic saturation

With the sub fundamental safely isolated, we can subject the highpassed grit band to heavy nonlinear processing without compromising the low end.

We patch the highpass output directly into the Distortion node. In drum and bass production, clean saw waves sound thin and dated. Squeezing them through asymmetric clipping generates complex odd and even harmonics that fill out the 300 Hz to 4 kHz frequency band.

The mathematics of asymmetric saturation

A standard symmetric waveshaper clips positive and negative signal peaks identically:

f(x) = tanh(k * x)

Symmetric clipping generates only odd harmonics (3rd, 5th, 7th), resulting in a hollow, square-wave tonality. To produce the snarling, guttural character characteristic of neurofunk, we introduce a DC bias offset before saturation. This asymmetry generates prominent even harmonics (2nd, 4th, 6th):

f(x) = tanh(k * (x + bias)) - tanh(k * bias)

Parameter settings in the Distortion node

Drive: Increase drive to +14 dB to push the detuned saw beating into hard saturation. As the beating waveforms periodically crest, the distortion unit saturates them into dense square-like plateaus.
Mode: Select Asymmetric Tube Fold.
Bias: Set bias to +0.22. This introduces even-order harmonic sweetness.
Oversampling: Engage 4x oversampling. Hard nonlinear distortion creates harmonic energy that can exceed the Nyquist frequency (24 kHz at a 48 kHz sample rate). 4x oversampling suppresses aliasing artifacts, preserving high-frequency clarity.
Post-tilt equaliser: Add a gentle +2.5 dB high-shelf boost starting at 2.2 kHz to compensate for high-frequency energy lost during saturation.

For a deeper exploration of custom mathematical waveshaping kernels, consult our technical guide on per-sample DSP audio kernels in Field language.

Formant sweeps with modulated twin notch filters

The signature vocal quality of modern Reese basses is created by sweeping notch and comb filters across the saturated spectrum. When an audio signal with dense harmonic content passes through narrow rejection notches, human ears perceive vowel-like vocal formants (such as "ow", "ah", and "ee").

We insert a second Filter node after the distortion stage, configured in twin-notch rejection mode.

[ Distortion Out ] ---> [ Filter: Twin Notch ] ---> [ Chorus Node ]
                               ^
                               |
                        [ Modulator LFO ]

Wiring the modulator LFO

To bring the sound to life, we patch a Modulator node to animate the filter cutoff frequency:

Modulator shape: Select a morphed triangle-to-sine wave or a slow chaotic random walk.
Sync rate: Synchronise the LFO to the global transport, selecting 1/2 bar or 1/4 dotted divisions.
Slew rate: Set a 12 ms slew filter on the LFO output to prevent abrupt parameter jumps from causing audible clicks.
Modulation depth: Map the LFO output to the notch filter cutoff parameter with a modulation depth of 65 percent. As the bassline sustains, the notches sweep dynamically between 400 Hz and 3.2 kHz, producing the iconic moving vowel resonance.

Stereo widening and mono compatibility on club systems

In professional sound design, width creates perceived size. However, spreading low frequencies across the stereo field is catastrophic in club venues, where subwoofer arrays are driven in mono. If out-of-phase low-frequency information reaches a mono subwoofer summing amplifier, the sound cancels itself out in the room.

Because we established a multi-band split earlier in our patch, we can apply aggressive stereo expansion exclusively to the highpassed grit band, leaving the sub fundamental completely untouched in mono.

[ Sub Filter: Lowpass 110 Hz ] ------------------------+---> [ Audio Out: Left (Mono Sum) ]
                                                       |
[ Grit: Saturated & Notched ] ---> [ Chorus Node ] ---+---> [ Audio Out: Stereo Width ]

Configuring the Chorus node

Haas delay spread: Introduce a small micro-delay between the left and right channels (0.0 ms on the left channel, +14.2 ms on the right channel). This exploits the psychoacoustic Haas effect to stretch the perceived stereo image far beyond the physical speaker positions.
Modulation depth: Keep chorus modulation gentle (rate at 0.28 Hz, depth at 25 percent) to avoid disorienting pitch warble.
Dry and wet balance: Set wet mix to 60 percent.

Verifying phase correlation with the Audio Meter

To ensure our stereo width does not cause phase issues when summed to mono, we connect the master output into an Audio Meter node.

The Audio Meter displays a real-time goniometer and phase correlation coefficient:

+1.0: Perfect mono correlation (identical left and right channels).
0.0: Wide stereo separation with healthy decorrelation.
-1.0: Total anti-phase cancellation (summing to mono will result in complete silence).

With our band-split architecture, the phase correlation meter remains pinned between +0.88 and +0.96. The sub-110 Hz foundation is completely vertical and mono, while the high-frequency grit spreads wide across the stereo perimeter.

Audio-reactive visual modulation on the unified canvas

One of Infinite's most compelling design capabilities is that audio synthesis and real-time graphics share the same underlying execution engine. In standard production workflows, synchronising visuals to a bassline requires rendering an audio file, importing it into TouchDesigner or Blender, running an offline FFT, and tweaking sensitivity curves by hand.

In Infinite, we can tap the exact modulation signals driving our Reese bass and route them straight into visual shaders and 3D geometry nodes in real time.

                           +---> [ Filter: Twin Notch ] ---> [ Audio Out ]
                           |
[ Modulator LFO ] ---------+
                           |
                           +---> [ Audio Texture ] ---> [ Render 3D: Mesh Displacement ]

Patching audio-reactive graphics

Audio Texture node: We cable the output of the highpassed grit band directly into an Audio Texture node. The node converts the instantaneous audio waveform and frequency spectrum into a 512x1 floating-point GPU texture buffer.
Render 3D node: We pipe the Audio Texture into a Render 3D node to displace the vertices of a high-density geometric icosphere or wireframe terrain.
Direct beat coupling: Because the visual vertex shader samples the actual audio waveform buffer at 60 frames per second, the 3D geometry pulses and ripples in physical lockstep with the acoustic beating frequencies of the detuned saw waves. Every time the oscillators slip into constructive interference, the geometry expands.

To learn more about bridging sound and procedural visuals, read our companion guide on making your first audio-reactive visual in Infinite.

Summary parameter reference and routing checklist

Here is a quick reference table of every node, parameter, and cable connection in this Reese bass architecture:

Node name	Parameter	Value	Purpose
`Analog`	Oscillator 1	Sawtooth (0 st, 0 ct)	Pitch root reference
`Analog`	Oscillator 2	Sawtooth (0 st, +8.5 ct)	Acoustic beating generator
`Analog`	Oscillator 3	Sine (-12 st, 0 ct)	Pure sub fundamental anchor
`Analog`	Portamento	Mono Legato (45 ms)	Authentic glide between bassline notes
`Filter` (Sub)	Topology	4-pole Lowpass (110 Hz)	Isolates monophonic low end
`Filter` (Grit)	Topology	4-pole Highpass (110 Hz)	Extracts midrange for saturation
`Distortion`	Drive & Bias	+14.5 dB Drive, +0.22 Bias	Asymmetric even/odd harmonic fold
`Distortion`	Oversampling	4x Polyphase IIR	Prevents Nyquist aliasing harshness
`Filter` (Notch)	Topology	Twin Notch (Q = 4.8)	Dynamic vocal formant resonances
`Modulator`	Rate & Shape	1/2 Bar Sync, Slew 12 ms	Sweeps notch filters smoothly
`Chorus`	Haas Offset	+14.2 ms Right Channel	Wide stereo imaging on high band
`Audio Meter`	Correlation	Minimum +0.85 Target	Confirms mono club sound safety
`Audio Texture`	Buffer	512x1 Float16 GPU Buffer	Bridges acoustic beat into visual shaders

Engineering limits and practical considerations

When deploying complex multi-band synthesis graphs in production, keep the following practical engineering guidelines in mind:

Headroom management: Asymmetric distortion and resonant notch filtering introduce gain peaks. Always leave at least -3 dBFS of digital headroom on the Reese track before it hits the master limiter. Excessive peak levels into the master bus can trigger inter-sample clipping when converted to lossy streaming formats like AAC or MP3.
Crossover frequency tuning: While 110 Hz is the standard crossover frequency for drum and bass, adjust this boundary based on your track's root key. For tracks in F (fundamental at ~43 Hz, second harmonic at ~87 Hz), 100 Hz to 110 Hz works cleanly. For tracks in A (fundamental at ~55 Hz, second harmonic at ~110 Hz), shift the crossover down to 85 Hz to prevent the second harmonic from splitting awkwardly across both filters.
Equaliser carve for kick drums: A dense Reese bass occupies significant energy between 80 Hz and 200 Hz. Use an envelope or sidechain compressor keyed to your kick drum to duck the Reese by 4 dB to 6 dB during the initial 40 ms of the kick transient.

By building your bass sound design on a unified modular graph, you eliminate plugin latency drift, retain absolute control over low-end phase integrity, and create instruments that bridge sound and visuals into a single cohesive performance.

Explore ready-to-run synthesiser patches and creative coding instruments in the Infinite Library, or review our tutorial on sub bass, pluck, and ambient pad sound design.

Originally published at https://infinitedevices.org/blog/drum-and-bass-reese-bass-sound-design.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Audio-reactive 3D particle systems in real time

naman — Wed, 11 Nov 2026 13:14:58 +0000

An audio reactive particle system transforms live musical transients and spectral frequencies into streams of kinetic points in three-dimensional space. From gentle dust motes drifting across an ambient soundscape to explosive shockwaves synchronised with sub-bass kick drums, particle systems provide an organic bridge between acoustic energy and computer graphics.

In real-time visual engines and audiovisual workstations like Infinite, audio and geometry share a unified execution graph. Rather than rendering pre-baked animations or relying on loose open sound control messages across network sockets, simulation nodes evaluate physical differential equations directly alongside audio-rate buffers. This enables deterministic, frame-accurate responses to rhythm and spectral timbre.

Here is how real-time particle mechanics operate under the hood, how numerical integration handles drag and velocity, how procedural 3D turbulence vector fields create fluid motion, and how to patch an audio-reactive particle pipeline using native nodes.

What makes particle systems feel musical

A common pitfall in generative music visualisation is mapping raw audio volume directly to particle count or size. When overall loudness drives everything, the visual output becomes a muddy, fluttering cloud that feels detached from the rhythmic structure of the music.

Musicality in a particle system requires separating three physical aspects of sound:

Rhythmic transients: Sudden bursts of energy (such as kick drums, snare rimshots, and hi-hat attacks) should trigger discrete physical events: spawning a cluster of new particles or imparting an instantaneous impulse shockwave.
Harmonic spectral balance: Sustained tonal components (such as basslines, synth pads, or vocals) should influence persistent environmental force fields: shaping gravity, drag, curl noise turbulence, and orbital attraction.
Temporal decay and resonance: Particle lifetimes and trail lengths should correspond to musical tempo divisions, ensuring kinetic movement breathes in sync with the song rather than piling up into visual noise.

By decoupling instantaneous onset triggers from continuous vector fields, particles behave like physical matter reacting to sound waves propagating through a medium.

Numerical physics: fixed-step Euler integration

At the core of any particle engine is numerical integration: advancing position and velocity forward across discrete steps in time.

In Infinite, the Particle System node maintains an internal state array of particle records. Each particle stores position, velocity, remaining lifetime, initial lifetime, and scalar seed data.

To prevent simulation instability when frame rates vary during heavy rendering passes, the physics simulation runs on a fixed timestep:

kFixedStep = 1.0f / 120.0f;  // 120 Hz internal physics update

If a frame takes longer than usual (for example, during a window resize or shader compilation), the accumulator advances in discrete 120 Hz sub-steps up to a hard cap, preventing explosive time-step jumps.

The equations of motion

For each active particle at time t, the simulator computes acceleration by summing directional gravity g, external atmospheric forces, and fluid turbulence:

F_total = g + F_turbulence + F_external

The updated velocity v(t + dt) applies acceleration and accounts for atmospheric drag:

v(t + dt) = (v(t) + F_total * dt) * (1.0 - drag * dt)

Position p(t + dt) then advances along the newly computed velocity vector:

p(t + dt) = p(t) + v(t + dt) * dt

Linear drag acts as a damping factor: without it, particles in an active turbulence field would continuously gain kinetic energy until flying off to infinity. Setting drag between 0.05 and 0.2 creates a natural terminal velocity reminiscent of smoke particles or underwater sediment.

3D turbulence and procedural vector force fields

Static directional gravity produces predictable fountain effects. To create organic, swirling motion where particles dance like embers or schooling fish, simulations apply procedural 3D noise vector fields.

Rather than sampling expensive perlin noise textures across memory, real-time particle kernels compute value noise and pseudo-curl fields analytically:

inline float Noise3D(float x, float y, float z)
{
    const float v = std::sin(x * 12.9898f + y * 78.233f + z * 37.719f) * 43758.5453f;
    return (v - std::floor(v)) * 2.0f - 1.0f;
}

In the Particle System node, turbulence is evaluated in three spatial dimensions:

float nx = Noise3D(p.x * turbScale, p.y * turbScale, p.z * turbScale + time);
float ny = Noise3D(p.x * turbScale + 19.1f, p.y * turbScale, p.z * turbScale);
float nz = Noise3D(p.x * turbScale, p.y * turbScale + 31.7f, p.z * turbScale);

F_turbulence = Vec3(nx, ny, nz) * turbulenceAmount;

When turbulence is modulated by an audio feature (such as spectral flux or mid-frequency energy), complex vortex structures suddenly twist and expand whenever an instrument enters the mix, returning to laminar flow during quiet breakdowns.

Isolating audio transients for explosive particle bursts

To create tight rhythmic synchronisation, incoming audio must pass through envelope extraction before reaching the particle emitter.

In a modular graph, the Audio In node captures multi-channel audio from your interface, system sound, or DAW routing. This feeds directly into an Audio Analyze node, which divides the audio spectrum into frequency bands and tracks both peak amplitudes and transient envelopes:

Sub-bass band (20 Hz to 120 Hz): Isolates kick drums and bass stabs. Connecting this output to the particle emitter's rate / sec parameter creates explosive bursts on downbeats.
Spectral flux: Measures the rate of change across frequency bins. A sudden brass chord or snare strike produces a high spectral flux value, ideal for driving turbulence or spread.
High-frequency envelope (6 kHz to 16 kHz): Tracks hi-hats, shakers, and cymbal sizzle. Modulating particle start size or speed random with high frequencies adds crisp kinetic shimmer to rapid rhythmic passages.

Because modulation values update at UI and block intervals without latency, particle emission synchronises tightly with what the audience hears.

Point trails, ribbon geometry, and GPU rendering

Individual floating points can look sparse on large display projections. To give particles visual weight and continuity, Infinite pairs the Particle System with downstream geometry generators and compositing nodes.

Turning points into continuous ribbons with `Point Trails`

The Point Trails node samples point positions across successive frames and extrudes them into continuous triangle strips. As particles whip through turbulent vortices, their trajectories form luminous ribbons through space.

Key controls in Point Trails include:

trail length: Determines the historical sample depth (from 4 to 64 steps). Shorter trails produce comet tails; longer trails create intricate calligraphic ribbons.
ribbon width: Defines the cross-sectional geometry size in world space.
fade alpha: Tapers opacity exponentially towards the tail so older segments dissolve smoothly into the background.

Point sprite rendering in `Render 3D`

Both raw particles and ribbon meshes connect directly into the Render 3D node. For dense point clouds containing tens of thousands of elements, Render 3D uses hardware-accelerated point sprites. Rather than drawing individual quad polygons, a single vertex shader call computes screen-space point sizes while fragment shaders evaluate circular alpha falloffs and depth fading.

Adding a Bloom node downstream extracts specular highlights from high-density particle clusters, wrapping them in a natural optical glow. A subtle Color Adjustments pass allows fine-tuning contrast and grading the colour palette to match the mood of the performance.

You can also explore how audio-reactive shaders compare to geometric pipelines in our guide to audio-reactive GLSL shaders.

Complete example patch

Here is a complete, reproducible Infinite patch demonstrating an audio-reactive 3D particle system. It sets up an audio input, transient analysis, a high-capacity particle generator, point trails, a 3D camera renderer, optical bloom, and screen output.

You can paste this plain text directly into an .inf file or inspect it to understand the node connections:

infinite-patch 1
rev 2
# Audio-Reactive 3D Particle System: transient bursts, curl turbulence, and bloom

node 1 Audio Audio In
  id audio_in
  pos 120 280
end

node 2 Audio Audio Analyze
  id analyze
  pos 380 280
end

node 3 Modulator LFO
  id lfo_sway
  pos 380 460
  param shape 0
  param frequency 0.15
end

node 4 3D Particle System
  id particles
  pos 700 280
  param max_particles 30000
  param rate 180
  param shape 1
  param radius 0.25
  param lifetime 3.5
  param speed 1.8
  param spread 0.45
  param dir_y 1.0
  param gravity_y -1.2
  param drag 0.12
  param turbulence 2.2
  param turb_scale 1.4
  param start_size 0.05
  param end_size 0.01
end

node 5 3D Point Trails
  id trails
  pos 1020 280
  param length 18
  param width 0.03
  param fade 0.85
end

node 6 3D Render 3D
  id renderer
  pos 1320 280
  param fov 45.0
  param cam_dist 4.2
  param shading 1
end

node 7 Image Bloom
  id bloom_fx
  pos 1600 280
  param threshold 0.60
  param radius 2.0
  param intensity 1.4
end

node 8 Image Color Adjustments
  id color_grade
  pos 1860 280
  param contrast 1.15
  param saturation 1.25
end

node 9 Utility Output
  id out_screen
  pos 2120 280
end

# Wiring
cable analyze 0 audio_in 0
cable particles 1 analyze 1        # Kick transient envelope -> Particle Emit Rate
cable particles 11 analyze 2       # Spectral flux -> Turbulence intensity
cable particles 9 lfo_sway 0       # Slow LFO -> Gravity Y drift
geo trails 0 particles
geo renderer 0 trails
cable bloom_fx 0 renderer 0
cable color_grade 0 bloom_fx 0
cable out_screen 0 color_grade 0

When live audio plays through Audio In, kick transients trigger dense bursts of new points while spectral changes continuously alter the curl turbulence, causing the trails to swirl in synchrony with the music.

Performance and buffer limits

Running tens of thousands of particles in real time alongside audio DSP requires keeping CPU and GPU overhead predictable:

Particle capacity: On modern hardware, Particle System comfortably simulates 20,000 to 50,000 particles at 120 frames per second. If your project targets portable laptops or high-resolution multi-projector setups, keeping max particles between 15,000 and 25,000 ensures plenty of GPU headroom for post-processing shaders.
Lifetimes and garbage collection: Shorter particle lifetimes (between 2.0 and 4.0 seconds) cycle dead particles out of the buffer quickly, preventing memory bloat during prolonged high-tempo sections.
Trails depth: Point Trails creates geometric triangle meshes for each particle. If particle counts exceed 30,000, consider reducing length to 8 or 12 points to minimise vertex memory bandwidth.

For ready-to-run templates, generative synths, and community visual rigs, visit the Infinite library. You can download Infinite for macOS, Windows, and Linux from the download page and begin patching generative audiovisual instruments immediately.

Originally published at https://infinitedevices.org/blog/audio-reactive-particle-systems-in-real-time.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Wave terrain synthesis: audio from 3D surfaces

naman — Wed, 11 Nov 2026 13:14:52 +0000

Wave terrain synthesis is one of the most expressive, mathematically elegant methods for generating sound from visual geometry. Instead of reading through one-dimensional wavetables or computing traditional trigonometric oscillator formulas, a wave terrain synthesiser treats sound generation as a particle travelling across a three-dimensional topographic landscape.

As an orbital trajectory scans across the contours, ridges, and valleys of this surface at audio rates, the instantaneous height of the terrain produces an acoustic waveform. When the landscape shifts or the trajectory rotates, the harmonic spectrum morphs continuously, producing organic timbres that range from acoustic woodwinds to evolving crystalline drones.

Although conceptualised decades ago by researchers including Mitsuhashi and Curtis Roads, real-time wave terrain synthesis remained rare in traditional digital audio workstations. The technique requires simultaneous high-resolution two-dimensional image processing and sample-accurate numerical audio digital signal processing. In Infinite, audio synthesis and computer graphics share a single execution graph, making native wave terrain synthesis available directly on the modular canvas.

Here is an analysis of how wave terrain synthesis operates, the mathematics of two-dimensional orbital scanning, how discrete Fourier transform mip pyramids eliminate Nyquist aliasing, and how to patch an audio-visual wave terrain instrument using native nodes.

What is wave terrain synthesis

Traditional wavetable synthesis reads through a sequence of one-dimensional periodic arrays: $s(t) = W(\phi(t))$, where $\phi(t)$ represents the normalised phase accumulator advancing from zero to one. While wavetable position modulation allows timbral movement, the sound remains constrained to a linear path through pre-recorded cycles.

Wave terrain synthesis expands this concept into two spatial dimensions. A two-dimensional terrain function $z = T(u, v)$ defines a continuous surface over the normalised coordinate plane $(u, v) \in [0, 1] \times [0, 1]$. An orbital path generator computes a closed two-dimensional trajectory $(u(t), v(t))$ that repeats at the fundamental frequency $f_0$ of the played musical note:

s(t) = T(u(t), v(t))

The resulting audio waveform $s(t)$ depends on two independent factors:

The topography of the terrain: The static shape or dynamic motion of the surface $T(u, v)$, including its gradients, crests, and saddle points.
The geometry of the orbit: The shape, scale, centre offset, and orientation of the path $(u(t), v(t))$ traced across the surface.

This decoupling gives sound designers two distinct modulation axes. Modulating the orbit changes the harmonic balance and formant character of each note. Modulating the underlying terrain changes the underlying timbre and physical presence of the entire patch.

The mathematics of wave terrains: functions and image rasters

In mathematical theory, a wave terrain can be defined by explicit continuous equations, such as polynomials, sums of sine products, or saddle functions:

T(u, v) = cos(2π u) · sin(2π v) + 0.5 · sin(4π (u + v))

In modular creative coding environments like Infinite, terrains can also be derived directly from dynamic image textures. Video feeds, procedural noise, reaction-diffusion simulations, and generative pixel shaders can all serve as live wave terrains.

When an image texture supplies the terrain, the continuous coordinate $(u, v)$ must be sampled from a discrete raster of pixels with width $W$ and height $H$. To prevent steppy, noisy distortion when the orbit moves between discrete pixel centres, the synthesiser applies bilinear interpolation:

fx = u · W - 0.5
fy = v · H - 0.5

x0 = floor(fx),  x1 = x0 + 1
y0 = floor(fy),  y1 = y0 + 1

tx = fx - x0
ty = fy - y0

T(u, v) = (1 - tx)(1 - ty)c00 + tx(1 - ty)c10 + (1 - tx)ty c01 + tx ty c11

Here, $c_{00}, c_{10}, c_{01}, c_{11}$ represent the scalar values extracted from the four nearest neighbouring pixels. In Infinite's Wave Terrain node, the wtChan parameter determines how multi-channel colour data maps to surface elevation:

Luminance: Computes perceived brightness using standard colourimetric weighting: $0.299 R + 0.587 G + 0.114 B$. Smooth gradients produce warm, rounded harmonic spectra.
Red, green, blue, and alpha: Solos a single colour channel. Useful when complex multi-pass shaders encode distinct mathematical data into separate colour channels.
Edge magnitude: Computes the absolute gradient from median luminance: $|Luminance - 0.5| \times 2.0$. This mode isolates high-contrast boundaries in textures, generating bright, metallic overtones with punchy attacks.

Because texture coordinates wrap periodically, orbital paths that exceed the unit boundary seamlessly loop around the terrain edges without clicks or discontinuity.

Kinematic scanning: orbital trajectories in two dimensions

The path $(u(t), v(t))$ determines which contours of the terrain are read during each audio cycle. For a note with fundamental frequency $f_0$, the normalised phase $t$ advances across $[0, 1)$ at rate $f_0 / f_s$, where $f_s$ is the audio sampling rate (typically 48,000 Hz).

Infinite provides five distinct orbital geometries, each offering unique harmonic characteristics:

1. Elliptical orbits (`kOrbitCircle`)

The simplest trajectory is an ellipse centred at $(c_x, c_y)$ with radii $(r_x, r_y)$ and phase offset $\phi$:

u(t) = cx + rx · cos(2π t)
v(t) = cy + ry · sin(2π t + 2π φ)

When $r_x = r_y$ and $\phi = 0$, the orbit traces a circle. Increasing or decreasing the radii scales the amplitude of modulation across the terrain, acting similarly to the modulation index in frequency modulation synthesis. Small radii inspect local, gentle slopes, yielding warm sine-like tones. Large radii traverse steep peaks and troughs, producing complex spectra rich in high-order harmonics.

2. Lissajous figures (`kOrbitLissajous`)

Lissajous trajectories introduce harmonic ratio multipliers $\text{ratioA}$ and $\text{ratioB}$ on the horizontal and vertical axes:

u(t) = cx + rx · sin(2π t · ratioA + 2π φ)
v(t) = cy + ry · sin(2π t · ratioB)

When $\text{ratioA}$ and $\text{ratioB}$ form integer proportions such as 3:2, 4:3, or 5:4, the orbit loops through intricate figure-eight and braided geometries. Because the path revisits different parts of the terrain at sub-harmonic intervals, Lissajous orbits generate vocal formants and bell-like inharmonic overtones reminiscent of complex wavefolding.

3. Lemniscate of Bernoulli (`kOrbitLemniscate`)

The lemniscate traces a continuous infinity loop across the terrain:

denom = 1 + sin²(2π t)
u(t) = cx + rx · cos(2π t) / denom
v(t) = cy + ry · sin(2π t) · cos(2π t) / denom

The lemniscate features an inflection point at the centre of the loop where velocity reaches its maximum. When scanned across a non-linear terrain, this velocity profile creates rich acoustic asymmetry, producing hollow, woody resonances similar to acoustic clarinets and bowed strings.

4. Archimedean spirals (`kOrbitSpiral`)

The spiral trajectory expands outwards over multiple rotations before cycling:

rFactor = 0.2 + 0.8 · t
u(t) = cx + rx · rFactor · cos(2π t · turns)
v(t) = cy + ry · rFactor · sin(2π t · turns)

Spirals cross concentric contours, generating sweeping spectral motion even on static terrains.

5. Scanline rasterisation (`kOrbitScanline`)

The scanline orbit sweeps linearly across the horizontal axis while stepping the vertical coordinate across discrete frames. This produces biting, digital wavetable-style timbres ideal for aggressive basslines.

Eliminating aliasing: discrete Fourier transform mip levels

A major challenge in wave terrain synthesis is digital aliasing. When an orbit traces across sharp cliffs, high-frequency noise, or steep gradients on a terrain, the resulting waveform $s(t)$ contains harmonics that can extend far beyond the Nyquist limit ($f_s / 2 = 24,000\text{ Hz}$). Without band-limiting, these harmonics fold back across the Nyquist threshold, creating unmusical, harsh intermodulation distortion.

To solve this, Infinite's real-time digital signal processing engine uses a Cooley-Tukey Radix-2 fast Fourier transform (FFT) pipeline with an exact 10-level mip pyramid.

The 1024-point Radix-2 FFT pipeline

During preparation, the synthesiser pre-samples the selected orbit across 8 morph frames into 1024-sample wavetable buffers. Each buffer undergoes a forward discrete Fourier transform:

// Forward Cooley-Tukey Radix-2 FFT (N = 1024)
Radix2FFT::Instance().Forward(realBuffer, imagBuffer);

Once in the frequency domain, the spectrum consists of 512 discrete harmonic bins. The engine computes 10 band-limited mip levels, where each successive level halves the maximum allowable harmonic index:

Mip 0: Contains all 512 harmonics. Used for low bass notes ($20\text{ Hz} - 90\text{ Hz}$) where the 512th harmonic remains below 24,000 Hz.
Mip 1: Band-limited to 256 harmonics ($90\text{ Hz} - 180\text{ Hz}$).
Mip 2: Band-limited to 128 harmonics ($180\text{ Hz} - 370\text{ Hz}$).
Mip 3: Band-limited to 64 harmonics ($370\text{ Hz} - 750\text{ Hz}$).
...
Mip 9: Band-limited to a single fundamental harmonic (pure sine wave) for high soprano registers above 10,000 Hz.

For each mip level, harmonics above the cutoff threshold are zeroed out, and an inverse FFT reconstructs a clean, alias-free time-domain cycle:

Radix2FFT::Instance().Inverse(realBuffer, imagBuffer);

During real-time voice rendering, the audio engine calculates the exact continuous pitch of the note, determines the fractional mip level, and blends between the two adjacent mip tables using cubic Hermite interpolation. This guarantees more than 80 dB of aliasing suppression across all 8 octaves of the keyboard.

Polyphony, unison voicing, and filtering

The Wave Terrain node in Infinite includes full performance architecture built into the DSP engine:

8-voice polyphony

The node maintains eight independent polyphonic voices. Each voice tracks its own MIDI note number, note frequency, phase accumulator, and four-stage ADSR envelope (attack, decay, sustain, release). When a chord is played, each voice samples the terrain at its own independent playback speed, preserving harmonic clarity across complex intervals.

Unison detuning and stereo spreading

For thick lead sounds and wide ambient textures, the engine supports up to 8 unison sub-voices per note:

Detune: Spreads unison voice frequencies apart by up to 100 cents using calibrated logarithmic detune curves.
Stereo width: Pans unison voice pairs symmetrically across the stereo field from -1.0 (hard left) to +1.0 (hard right).

Multi-mode resonant filter

After terrain evaluation and unison summing, the signal passes into an internal state-variable filter. The filter offers 12 dB, 24 dB, and 36 dB slopes in lowpass, highpass, bandpass, and notch modes, controllable via cutoff, resonance, and drive.

Patching wave terrain synthesis in Infinite

Connecting a wave terrain synthesiser on Infinite's canvas takes less than a minute. Because image cables, note cables, and audio cables all coexist on the same workspace, visual and acoustic nodes link directly together.

[Reaction-Diffusion] (texture) ──> (texture) [Wave Terrain] ──> [Audio Out]
                                          ▲
[Keyboard / Sequencer] (notes) ───────────┘

Step 1: Add the terrain source

Add a generative visual node to supply the landscape:

Press Shift+A and select Visuals > Reaction-Diffusion.
Set the algorithm parameters to generate organic Turing patterns: feed = 0.054, kill = 0.062.
Adjust the simulation speed to 0.25 so the visual patterns slowly pulse and drift over time.

Step 2: Add the Wave Terrain synthesiser

Press Shift+A and select Synths > Wave Terrain.
Connect the out (picture) pin of Reaction-Diffusion to the texture input of Wave Terrain.
Set wtOrbit to Lemniscate.
Set wtChan to Luminance.
Set unison to 3 and detune to 14 cents for subtle chorus movement.

Step 3: Trigger notes and monitor output

Press Shift+A and select Notes > Keyboard (or Random Note Generator for automated generative playback).
Connect the note output to the note input of Wave Terrain.
Connect the audio output of Wave Terrain to an Audio Out node.

When you play notes, you will hear a rich, resonant tone. As the reaction-diffusion pattern morphs on the canvas, the acoustic timbre shifts in tandem.

Example patch file

Infinite saves patches in human-readable plain text .inf files. Here is the starting patch:

infinite-patch 1
rev 2
node 1 Visuals Reaction-Diffusion
  id rdiff
  pos 120 240
  param feed 0.054
  param kill 0.062
end
node 2 Notes Keyboard
  id keys
  pos 120 440
end
node 3 Synths Wave Terrain
  id wt
  pos 420 300
  param wtOrbit 2
  param wtChan 0
  param radiusX 0.45
  param radiusY 0.45
  param unison 3
  param detune 14
  param cutoff 8500
end
node 4 Audio Audio Out
  id out
  pos 740 300
end
cable rdiff texture -> wt texture
cable keys notes -> wt note
cable wt audio -> out in

Sound design recipes: evolving drones, aggressive bass, and ambient pads

Here are three practical production recipes using the Wave Terrain engine:

1. Organic morphing drone

Terrain source: Noise node with simplex noise and slow octaves evolution.
Orbit: kOrbitLemniscate with radiusX = 0.65, radiusY = 0.40.
Modulation: Connect a slow sine LFO (0.08 Hz) to the rotation parameter of Wave Terrain.
Filter: 24 dB lowpass with cutoff = 3200 Hz and subtle resonance.
Character: As the rotation rotates the infinity loop across the noise field, the harmonic overtone balance shifts without sudden timbre jumps, creating an evolving drone suitable for film scoring.

2. Aggressive industrial Reese bass

Terrain source: High-contrast geometric shapes from a Shape or Glitch node.
Orbit: kOrbitLissajous with ratioA = 3.0, ratioB = 2.0, and wtChan = Edge Magnitude.
Unison: 5 voices, detune = 28 cents, stereoWidth = 0.85.
Filter: 24 dB lowpass with moderate drive to saturate the summed unison output.
Character: The edge detection mode reads hard transitions as intense harmonic spikes. Coupled with the 3:2 Lissajous trajectory and unison detuning, this produces a ferocious, roaring bass sound with distinctive stereophonic movement.

3. Shimmering ambient glass pad

Terrain source: Live video feed from a webcam or liquid video loop via Video.
Orbit: kOrbitSpiral with radiusX = 0.85, radiusY = 0.85.
Envelope: attack = 1200 ms, release = 2400 ms.
Modulation: Route the high-frequency band from an Audio Analyze node back into radiusX, creating an acoustic feedback loop where brightness opens the spatial scan.
Character: Delicate, shimmering, crystalline pads that breathe dynamically in response to room sound and video luminance.

Summary and exploration

Wave terrain synthesis transforms the relationship between visual graphics and electronic sound. By viewing sound synthesis as spatial kinematics across topographic surfaces, artists can design instruments that are visually expressive and sonically complex.

With built-in 1024-point discrete Fourier transform anti-aliasing, eight-voice polyphony, and unison spreading, Infinite makes wave terrain synthesis reliable for live performance and studio composition.

Explore ready-to-run wave terrain patches in the Infinite Library, inspect the full control specifications in the Wave Terrain node documentation, or download Infinite to start sculpting sound from two-dimensional landscapes.

Originally published at https://infinitedevices.org/blog/wave-terrain-synthesis-in-real-time.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Physical modelling string synthesis in real time

naman — Wed, 11 Nov 2026 13:14:43 +0000

Physical modelling synthesis generates sound by simulating the actual physical mechanics of vibrating matter rather than playing static wavetables or filtering raw geometric waveforms. While traditional subtractive synthesis uses mathematical approximations like saw and square waves, and sample libraries replay pre-recorded audio recordings of instruments, physical modelling calculates the physical wave propagation, boundary reflections, internal material damping, and structural resonance of acoustic objects in code.

When you pluck, strike, or bow an acoustic string, its sonic timbre evolves dynamically across every note. The attack transient reflects the pick position along the string length, the mechanical stiffness produces subtle inharmonic frequency shifts across higher partials, and the wooden instrument body colours the acoustic radiation through dozens of coupled resonant modes.

In real-time audiovisual environments like Infinite, physical modelling provides an expressive foundation for both sound design and generative visuals. Because the underlying physical variables (such as string velocity, bridge displacement, and energy dissipation) are evaluated directly on the audio thread, they can be routed seamlessly into 3D geometry deformation and real-time shaders.

Here is an in-depth examination of how digital waveguide physical modelling operates, how fractional allpass filters maintain pitch accuracy, how dispersion creates natural inharmonicity, how exciter mechanics simulate plucking, striking, and bowing, and how to patch a complete physical modelling instrument using native nodes.

What physical modelling solves in computer music

The central challenge with electronic instruments is acoustic realism and continuous expressiveness. A sampled acoustic guitar or cello can capture the timbre of an isolated note, but it struggles with real-time articulation. When a performer alters bow pressure, slides between frets, or alternates between fingerpicking and a sharp plectrum, a sample library must crossfade between distinct recordings. This often creates phase cancellation, unnatural chorusing, or static, repetitive transients known as the machine-gun effect.

Subtractive synthesis offers continuous modulation through filters and envelopes, but its harmonic structure remains synthetic. An oscillator running through a resonant lowpass filter lacks the complex modal distribution and material losses of real wood and vibrating steel.

Physical modelling solves this by simulating the physical acoustic system from first principles. When you alter a parameter like string stiffness or bow velocity, you are not adjusting an artificial audio filter: you are modifying the physical differential equation governing wave motion. The resulting acoustic response reacts organically, producing natural transients, sympathetic resonance, and expressive feedback.

Digital waveguides: bidirectional delay lines and wave propagation

The foundation of modern string modelling is the digital waveguide, formulated by Julius O. Smith (1992) as an extension of the pioneering Karplus-Strong plucked string algorithm (1983).

The physical motion of an ideal vibrating string is governed by the one-dimensional acoustic wave equation:

d^2 y / dt^2 = c^2 * (d^2 y / dx^2)

Where y represents transverse displacement, t is time, x is the spatial coordinate along the string, and c is the wave propagation speed determined by string tension T and linear mass density mu (c = sqrt(T / mu)).

D'Alembert showed that any solution to this differential equation can be decomposed into two independent travelling waves moving in opposite directions:

y(x, t) = y_plus(t - x/c) + y_minus(t + x/c)

Here, y_plus represents a wave travelling to the right (towards the bridge), and y_minus represents a wave travelling to the left (towards the nut).

Discretisation into digital delay lines

In a computer simulation, continuous spatial wave propagation is discretised into two tapped delay lines. The total round-trip propagation time corresponds to the period of the fundamental frequency f_0:

Period T = 1.0 / f_0
Delay samples N = f_s / f_0

Where f_s is the digital sample rate (such as 44,100 Hz or 48,000 Hz).

At the string boundaries, the travelling waves undergo physical reflections:

The nut (fret boundary): Assumed to be rigid. The string displacement must be zero at x = 0, forcing an inverting reflection with reflection coefficient R_0 = -1. The wave reflects with inverted phase.
The bridge: The string terminates at a bridge that transfers energy to the resonant instrument body. The bridge reflection is modelled by an inverting reflection combined with a frequency-dependent loop filter H_loop(z) that accounts for energy loss and phase delay.

When a pulse is injected into the bidirectional delay loop, it travels back and forth between the nut and bridge. Each round trip corresponds to one cycle of the fundamental pitch, producing a rich harmonic spectrum.

Tuning and fractional delay: solving the phase allpass filter

In a naive digital delay line, the buffer length is constrained to integer sample counts N = floor(f_s / f_0).

This creates a serious musical problem: pitch quantization. For high notes, the integer rounding error causes severe out-of-tune intonation. For instance, at a sample rate of 48 kHz:

A note at 1000 Hz requires 48000 / 1000 = 48.0 samples.
The next semitone up (1059.25 Hz) requires 48000 / 1059.25 = 45.315 samples.
Rounding to 45 samples produces 1066.67 Hz, an unacceptable tuning error of over 12 cents.

To achieve exact microtonal and chromatic intonation, the delay loop must support fractional sample delays.

The first-order allpass filter

In the native String node in Infinite, fractional delay is implemented using a first-order allpass filter:

A(z) = (a + z^-1) / (1.0 + a * z^-1)

An allpass filter has a flat magnitude frequency response of exactly 1.0 across all frequencies, but its phase response introduces a controllable group delay without causing any artificial attenuation or damping in the loop.

The phase delay D(w) of the allpass filter at angular frequency w radians per sample is:

D(w) = - (atan2(-sin(w), a + cos(w)) - atan2(-a * sin(w), 1.0 + a * cos(w))) / w

Because delay decreases monotonically as coefficient a rises, the engine solves for the exact coefficient a using a numerical bisection solver across 40 iterations on every parameter update chunk:

double SolveAllpass(double delay, double w)
{
   double lo = -0.95, hi = 0.95;
   for (int it = 0; it < 40; it++)
   {
      const double mid = 0.5 * (lo + hi);
      if (AllpassDelay(mid, w) > delay)
         lo = mid;
      else
         hi = mid;
   }
   return 0.5 * (lo + hi);
}

By subtracting the fractional delay of the allpass filter and loop filter from the total delay requirement, the fundamental pitch f_0 remains mathematically exact, regardless of how other controls like decay, tone, and stiffness are adjusted.

Dispersion and stiffness: inharmonicity across higher partials

In a purely flexible, mathematical string, all harmonic partials are exact integer multiples of the fundamental frequency: f_k = k * f_0.

Real physical strings (such as piano wire, bass guitar strings, or harp strings), however, possess inherent bending stiffness. A stiff wire resists bending, introducing an additional restoring force governed by the Euler-Bernoulli beam equation:

d^2 y / dt^2 = c^2 * (d^2 y / dx^2) - kappa^2 * (d^4 y / dx^4)

Where kappa is the stiffness parameter.

The consequence of this fourth-order derivative is dispersion: higher-frequency waves travel along the string faster than lower-frequency waves. As a result, the higher partials are displaced upwards in frequency, following the inharmonicity formula:

f_k = k * f_0 * sqrt(1.0 + B * k^2)

Where B is the inharmonicity coefficient.

Modelling dispersion with allpass cascades

Without stiffness, a plucked digital string sounds sterile and electronic, resembling a simple comb-filtered pulse. When stiffness is introduced, the upper partials ring with the distinct metallic attack and organic complexity heard in real acoustic instruments.

In Infinite's String node, dispersion is implemented using a cascade of four first-order allpass filters placed directly in the feedback path of the bridge. Each allpass stage adds frequency-dependent phase delay, slightly advancing the arrival time of higher harmonics relative to the fundamental.

Modulating the stiffness parameter shifts the string character from a warm, flexible nylon classical guitar string to a taut, clanging steel piano wire or metallic bass string.

Exciter mechanics: pluck, hammer strike, and bow friction

A physical string model requires an excitation source to inject kinetic energy into the delay lines. The nature of this excitation dictates whether the instrument sounds plucked, struck, or bowed.

The String node features three distinct physical exciter models:

1. Pluck excitation

A plectrum or finger plucks a string by displacing it at a specific normalised position x_rel (from 0.0 at the bridge to 1.0 at the nut). When released, the initial triangular displacement splits into two identical half-amplitude pulses propagating in opposite directions towards the nut and bridge.

The point of excitation introduces comb filtering. Plucking near the bridge (position = 0.1) suppresses low frequencies and emphasizes sharp, nasal upper harmonics. Plucking near the centre (position = 0.5) eliminates even harmonics, producing a hollow, clarinet-like tone.

The hardness parameter controls the pulse duration. A hard pick generates an instantaneous sharp spike, exciting high-frequency energy up to the Nyquist frequency. A soft finger widens the pulse up to tenfold, naturally rounding and softening the transient attack.

2. Strike excitation

A strike models a piano or dulcimer felt hammer hitting the string. Unlike an instantaneous pluck, a felt hammer has physical mass and compliant elasticity.

The interaction is non-linear: a soft strike compresses the felt gently, resulting in a prolonged contact duration and a warm, mellow tone. A heavy strike compresses the felt rapidly into its dense wooden core, drastically shortening the contact duration and releasing a burst of bright, forceful upper partials.

In code, the pulse length scales dynamically with incoming note velocity:

pulseLen = max(2, round(sampleRate * (0.004 - 0.003 * velocity)));

3. Bow excitation (Smith's friction junction)

Bowing a string is a continuous, self-oscillating non-linear process driven by friction between sticky rosin-coated horsehair and the string.

The bow moves at a constant speed v_bow. The interaction alternates rapidly between two phases:

Stick phase: Static friction holds the string against the bow hair, dragging the string along with the bow until tension forces overcome friction.
Slip phase: The string breaks free and snaps backwards towards its resting point under dynamic friction.

This stick-slip mechanism is modelled using a non-linear friction characteristic curve:

F_friction(v_rel) = sign(v_rel) * (mu_dynamic + (mu_static - mu_dynamic) * exp(-c * |v_rel|)) * F_bow

Where v_rel = v_bow - v_string is the relative velocity between bow and string, and F_bow is normal bow pressure.

The String node implements bow friction with oversampled integration (up to 8x internal oversampling for high notes) to eliminate digital limit cycles. Modulating the pressure and noise parameters allows you to recreate authentic string scrapes, raspy rosin friction, and the smooth transition into pure sustained Helmholtz bowing.

Acoustic radiation: mode tables and modal bodies

An isolated vibrating string has very little surface area. In an acoustic instrument, virtually all audible sound radiates from the resonant wooden soundboard and body cavity (the body of a guitar, violin, or cello).

The instrument body acts as a complex acoustic filter with dozens of closely spaced resonant peaks. Rather than running a static graphic equaliser, Infinite couples the string output to a shared modal resonator bank (DenseBody).

The body simulation evaluates ten parallel second-order modal bandpass resonators, each configured with an exact centre frequency, bandwidth, and amplitude mode table:

y_body(t) = sum_{m=1}^{10} A_m * exp(-alpha_m * t) * sin(omega_m * t + phi_m)

Infinite includes five calibrated body profiles fitted from acoustic measurements of real instruments:

Body profile	Key acoustic resonances	Sonic character
Box	Helmholtz cavity (98 Hz) and primary plate mode (204 Hz)	Small hollow acoustic box with dry, woody decay
Guitar	Air mode A0 (99 Hz), top plate T(1,1) pair (199 Hz, 392 Hz)	Warm, balanced acoustic dreadnought and classical guitar
Harp	Soundboard resonance (211 Hz) and pillar modes (325 Hz)	Open, airy, resonant decay with singing sustain
Violin	Air mode A0 (281 Hz), corpus corpus modes B1-/B1+ (445 Hz, 535 Hz)	Focused, expressive acoustic projection with bite
Cello	Deep cavity mode (105 Hz) and body resonances (199 Hz, 320 Hz)	Rich, woody, authoritative low-frequency resonance

Because all active polyphonic voices feed into the same shared body filter, notes interact acoustically, vibrating the simulated soundboard and creating natural sympathetic depth.

Building an audiovisual physical modelling patch in Infinite

In Infinite, sound synthesis and visual rendering run on the same unified graph. You can patch an expressive physical modelling instrument and use its internal acoustics to deform 3D meshes in real time.

+----------------+      note       +------------------+      audio      +------------------+
| Note Sequencer | --------------> | String (Synth)   | --------------> | Resonator Bank   |
+----------------+                 +------------------+                 +------------------+
                                            ^                                    |
                                            | pressure mod                       | audio
+----------------+                          |                                    v
| LFO            | -------------------------+                           +------------------+
+----------------+                                                      | Audio Analyze    |
                                                                        +------------------+
                                                                                 |
                                                                                 | spectral RMS
                                                                                 v
+----------------+      mesh       +--------------------+      mesh     +------------------+
| Cylinder Wire  | --------------> | Audio Displacement | ------------> | Render 3D        |
+----------------+                 +--------------------+               +------------------+

Step 1: Create the note driver and exciter

Add a Note Sequencer node to the canvas. Set division to 1/16 sync and program an arpeggiated melodic line.
Add a String node. Connect the green note output of the Note Sequencer to the notes input of the String node.
On the String node, select exciter: Bow and choose bodyType: Cello.
Set decay to 2.4 s, stiffness to 0.30, and tone to 0.75.

Step 2: Add dynamic expressive modulation

Add an LFO node. Set the shape to Triangle and tempo-sync the rate to 1/2 bar.
Connect the LFO output cable to the pressure parameter of the String node. As the LFO oscillates, the simulated bow pressure increases and relaxes, moving naturally between gentle whispers and raspy, full-bodied string sustains.
Add a second slow LFO (or an envelope follower) routed to position, moving the bowing point between the bridge (sul ponticello) and the fingerboard (sul tasto).

Step 3: Route through the modal resonator and analysis

Connect the audio output of String to a Resonator Bank node to introduce room resonance and spatial depth.
Connect the output to an Audio Analyze node. This extracts real-time amplitude envelopes, spectral RMS energy, and pitch tracking data on every audio buffer.

Step 4: Deform 3D geometry in Render 3D

Add a Cylinder mesh primitive and set it to wireframe mode to represent a vibrating physical string.
Add an Audio Displacement node. Connect the mesh output into its geometry input, and connect the spectralRms output from Audio Analyze to the displacement amplitude.
Wire the resulting geometry into Render 3D.

When a note is bowed, the 3D string geometry physically vibrates with travelling wave deformations matching the exact frequency, damping, and decay of the acoustic digital waveguide.

Performance characteristics and real-time execution

Running complex numerical differential equations and allpass filter cascades in real time requires strict computational discipline:

Eight-voice polyphony: The String node supports up to 8 polyphonic voices. Unused voices are culled instantaneously when their decay envelope drops below -96 dB, conserving CPU cycles.
Chunked parameter updates: Heavy mathematical operations (such as the 40-iteration allpass phase solver and modal coefficient recalculations) run once every 32 samples (0.7 ms at 48 kHz). Sample-rate audio buffers interpolate these values using lock-free atomic parameter mailboxes, avoiding audio dropouts or zipper noise.
SIMD vectorisation: The modal body filter bank evaluates multiple biquad modes in parallel using AVX2 and ARM Neon vector instructions.
Zero dynamic memory allocations: All waveguide ring buffers, allpass delay lines, and mode state arrays are statically pre-allocated at startup. The audio thread executes without heap allocations or mutex contention.

By combining the physical mathematics of acoustic wave propagation with real-time modular execution, physical modelling synthesis delivers responsive instruments that feel alive under your fingers and on screen.

Explore native sound design and modular synthesis in the Infinite Library, inspect the full Node Reference, or read our deep dive on audio-reactive GLSL shaders.

Originally published at https://infinitedevices.org/blog/physical-modelling-string-synthesis-in-real-time.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Delaunay triangulation and Voronoi geometry in real time

naman — Wed, 11 Nov 2026 13:14:33 +0000

In computational geometry and procedural graphics, delaunay triangulation real time algorithms provide a method to generate clean, dynamic 3D meshes directly from shifting point clouds. While static meshes rely on pre-baked vertex index buffers that remain rigid during performance, dynamic triangulation reconstructs the topological connectivity between vertices on every frame. When combined with its mathematical dual, the Voronoi diagram, artists can transform particle clouds, audio waveforms, and spatial simulations into fluid geometric surfaces, faceted crystalline shells, and organic cellular tessellations.

In real-time audiovisual environments like Infinite, dynamic triangulation links sound synthesis with procedural 3D form. Because audio signals can displace spatial coordinates at frame rates, recalculating Delaunay triangles and Voronoi cells on the fly allows the topology of a mesh to split, merge, and reform in direct response to acoustic energy.

Here is an in-depth examination of the mathematical principles behind Delaunay triangulation, the Bowyer-Watson cavity insertion algorithm, dual Voronoi cell generation with polygon insetting, 3D heightfield lifting, and how to patch an audio-reactive mesh using native nodes.

Dynamic topology versus static meshes in computer graphics

Most 3D models in computer graphics are defined by two arrays: a vertex array containing spatial positions (x, y, z), normals, and texture coordinates, and an index array containing triplets of integers that reference those vertices to form triangular faces. In standard rendering pipelines, the index array is static. When a vertex shader or physics engine deforms the model, the vertices move, but the edges between them remain fixed.

This rigidity works well for character meshes and rigid bodies, but it limits generative and reactive art. If a cloud of particles expands, contracts, or swirls under turbulent forces, stretching static triangles produces long, distorted needles known as slivers. Slivers cause severe rendering artefacts, including rasterisation bottlenecks, pixel flickering, and erratic surface normals under directional lighting.

Dynamic triangulation solves this by recomputing the triangle index buffer on every cook cycle. As points drift, separate, or enter the scene, the algorithm evaluates spatial proximity and reconfigures the edge connections. When two particles move apart, their connecting edge dissolves, and new edges form between closer neighbours. This produces a continuous, surface-like manifold that adapts to whatever spatial distribution the simulation generates.

The empty circumcircle criterion and Bowyer-Watson insertion

A triangulation of a planar point set P is a collection of non-overlapping triangles whose vertices are in P and whose union covers the convex hull of P. For any set of three non-collinear points in the Cartesian plane, there exists a unique circle that passes through all three points: the circumcircle.

In 1934, Boris Delaunay proved that a triangulation is optimal if and only if the circumcircle of every triangle contains no points of P in its interior. This condition is the empty circumcircle criterion:

For every triangle T(a, b, c) in the triangulation:
Distance(p, Centre(T)) >= Radius(T)  for all points p in P

The empty circumcircle property possesses a critical geometric consequence: it maximises the minimum interior angle of all triangles in the mesh. By avoiding skinny, acute angles, Delaunay triangulation produces the most equiangular, well-proportioned triangles possible for any given distribution of vertices.

Computing the circumcircle in double precision

Given three 2D vertices a, b, and c, we can translate vertex a to the origin:

bx = b.x - a.x,   by = b.y - a.y
cx = c.x - a.x,   cy = c.y - a.y

The circumcentre offset (ux, uy) from a is found by solving the intersection of the perpendicular bisectors of sides ab and ac. The system determinant D is:

D = 2.0 * (bx * cy - by * cx)

If abs(D) is close to zero, the three vertices are collinear, and no finite circumcircle exists. Otherwise, using the squared lengths b2 = bx*bx + by*by and c2 = cx*cx + cy*cy, the circumcentre (cx_circ, cy_circ) and radius squared r2 are:

ux = (cy * b2 - by * c2) / D
uy = (bx * c2 - cx * b2) / D

cx_circ = a.x + ux
cy_circ = a.y + uy
r2 = ux * ux + uy * uy

A point (px, py) violates the Delaunay criterion for this triangle if:

(px - cx_circ)^2 + (py - cy_circ)^2 < r2 * (1.0 - 1e-12)

The small epsilon tolerance 1e-12 prevents numerical instability when points lie almost exactly on the circumcircle boundary.

The Bowyer-Watson incremental algorithm

The Bowyer-Watson algorithm (developed independently by Adrian Bowyer and David Watson in 1981) inserts points one by one into an existing Delaunay triangulation:

Initialise with a super-triangle: construct an artificial, expansive triangle that completely encloses the bounding box of the point set. This guarantees that all real points fall within at least one valid triangle.
Find bad triangles: when inserting point p, scan the existing triangle list and identify every triangle whose circumcircle encloses p.
Form the cavity: delete all bad triangles. The union of these deleted triangles forms a star-shaped polygonal cavity containing p. The boundary of this cavity consists of all edges that belonged to exactly one bad triangle.
Sew new triangles: connect each edge of the cavity boundary to the new point p, creating a set of new triangles that satisfy the empty circumcircle criterion.
Remove super-triangle vertices: once all points are inserted, discard every triangle that shares any vertex with the initial super-triangle. The remaining triangles form the Delaunay triangulation of the input points.

To maintain real-time performance at 60 FPS, the implementation in Infinite sorts points along a grid-snake spatial curve prior to insertion. Because sequentially inserted points are spatially adjacent, the set of invalid triangles remains local, allowing rapid cavity extraction. Furthermore, dead triangles are periodically compacted in memory to prevent the traversal loop from scanning discarded entries.

Building the Voronoi dual and polygon insetting

Every Delaunay triangulation has a unique geometric dual: the Voronoi diagram (first studied by Georgy Voronoy in 1908). While Delaunay triangulation partitions space into triangles connecting neighbouring sites, the Voronoi diagram partitions space into convex polygonal cells, where each cell contains all spatial locations closer to its generating site than to any other site.

The duality between the two structures is exact:

Each circumcentre of a Delaunay triangle becomes a vertex of the Voronoi diagram.
Each edge in the Delaunay triangulation corresponds to a shared boundary edge in the Voronoi diagram, running perpendicular to the Delaunay edge.
Each site in the Delaunay triangulation is surrounded by a Voronoi polygon whose vertices are the circumcentres of the Delaunay triangles sharing that site.

Extracting Voronoi cells from triangle fans

To construct Voronoi cells from the triangulated mesh, the Voronoi Cells node in Infinite executes the following steps:

Count edge usage: iterate through all Delaunay triangles and count how many times each undirected edge appears. Edges that appear exactly once form the convex hull of the point cloud.
Prune hull vertices: sites that lie on the convex hull have unbounded Voronoi cells that extend to infinity. These are flagged and skipped so that only well-defined, closed interior cells are generated.
Assemble triangle fans: for each interior site, collect the indices of all triangles meeting at that site.
Sort circumcentres radially: calculate the circumcentre of each triangle in the fan and compute its polar angle relative to the site: angle = atan2(cy - site_y, cx - site_x). Sorting the circumcentres by angle arranges the vertices of the Voronoi cell in counter-clockwise order.
Cap sliver circumcentres: triangles near the outer boundary can occasionally have circumcentres that lie far outside the cloud. The engine clamps the distance of any circumcentre to at most twice the maximum radius of the triangle, preventing spikes from rupturing the cell layout.

Polygon insetting for architectural and cellular aesthetics

A flat tessellation where all cells touch edge-to-edge can look monolithic. The Voronoi Cells node includes an inset parameter (ranging from 0.0 to 0.95) that scales each cell towards its generating site:

inset_vertex = site + (circumcentre - site) * (1.0 - inset)

When inset is zero, cells share mutual boundaries. As inset increases, channels open up between adjacent cells, revealing negative space. The node triangulates each inset cell by creating a central vertex at the site position and generating a fan of triangular faces connecting the centre to each pair of adjacent perimeter vertices.

This insetting mechanism enables diverse creative styles, ranging from stained-glass windows and architectural ceiling cassettes to cracked desert mud and microscopic cellular membranes.

Projecting planes and lifting back to three dimensions

While 2D Delaunay algorithms are mathematically robust and computationally tractable in real time, many generative audiovisual scenes require 3D geometry. Calculating true 3D Delaunay tetrahedralisation is substantially more expensive, $O(n^2)$ to $O(n^4)$, and yields solid 3D tetrahedra rather than a hollow, renderable 2D surface manifold.

To solve this, Infinite uses a 2.5D projection and lifting architecture in DelaunayMeshNode:

Projection: the user selects a projection plane via the plane parameter (0: XY, 1: XZ, 2: YZ). The 3D coordinates (px, py, pz) of each site are projected onto the selected 2D plane:
- For XY, the projected coordinates are (u = px, v = py), facing normal (0, 0, 1).
- For XZ, the projected coordinates are (u = pz, v = px), facing normal (0, 1, 0).
- For YZ, the projected coordinates are (u = py, v = pz), facing normal (1, 0, 0).
Planar triangulation: the 2D projected coordinates are triangulated using the Bowyer-Watson engine. Texture coordinates (u, v) are normalised across the bounding box of the cloud to enable texture mapping.
Elevation lifting: once the triangle topology is established, the original third unprojected coordinate is restored for each vertex.

When a point cloud has elevation, such as an audio-displaced particle grid or terrain heights, the 2D triangulation acts as a surface mesh lifted into 3D space. The resulting surface bends, folds, and undulates with the underlying simulation, creating an expressive terrain that never tears or overlaps unnaturally.

Patching an audio-reactive mesh in Infinite

Building a complete real-time audiovisual patch using Delaunay and Voronoi nodes involves connecting audio analysis, procedural point generation, geometry operations, and 3D rendering.

Here is a recommended node graph layout:

[Audio Input] -> [Audio Analyze]
                       |
               (FFT low / mid / high)
                       |
                       v
[Point Distribution] -> [Audio Displacement] -> [Delaunay Mesh] -> [Material] -> [Render 3D]
                                                     |
                                            (or [Voronoi Cells])

1. Generating the point cloud

Add a Point Distribution node to spawn the initial site positions. You can set the distribution mode to a 2D Poisson disc distribution or a random planar scatter. Alternatively, a Particle System node can be used to simulate floating particles driven by curl noise and velocity damping.

Set the point count to approximately 800 to 1,500 points. This provides high geometric detail while leaving headroom for other synthesis and graphics nodes on the canvas.

2. Audio displacement

Wire the audio output from a synth, sampler, or live audio track into an Audio Analyze node. The node extracts an 8-band FFT spectrum and transient onset detectors.

Patch the point cloud from Point Distribution into the geometry input of an Audio Displacement node. Map the low-frequency bass band to the vertical displacement axis. When a kick drum hits, the points push upward in world space.

3. Mesh construction with Delaunay Mesh

Connect the displaced points into a Delaunay Mesh node. Configure its parameters:

plane: select XZ so the triangulation occurs across the horizontal ground plane while the audio displacement lifts vertices along the Y axis.
aliveOnly: enable this toggle when using particles so that dead particles are excluded before triangulation.
maxPoints: set to 2000 to protect the rendering loop against unexpected particle bursts.

As the points move under the influence of the audio signal, the Delaunay engine dynamically recalculates the triangle indices. If you switch the node to Voronoi Cells and set inset to 0.20, the mesh transforms into an array of floating, isolated tiles that pulse and tilt with the sound.

4. Shading and rendering

Wire the mesh output into a Material node. Set the roughness to 0.3 and metallic to 0.8 to give the facets a reflective, polished finish.

Connect the material into a Render 3D node alongside a Directional Light and a Camera 3D. As the facets shift their orientation each frame, specular highlights glint across the changing edges, producing a visual response synchronized to the music.

For further exploration of shader uniforms and procedural deformation techniques, refer to our guide on procedural 3D geometry nodes and audio deformation and our walkthrough of audio-reactive particle systems in real time.

Computational complexity, spatial sorting, and point budgets

Understanding the computational performance of dynamic triangulation is essential for maintaining a stable 60 FPS frame rate in live performances.

Time complexity and memory compaction

A naive implementation of the Bowyer-Watson algorithm tests every inserted point against all existing triangles, resulting in an $O(n^2)$ worst-case time complexity. For 1,000 points, this requires approximately 1,000,000 circumcircle checks.

To optimise this for real-time operation, Infinite uses a grid-snake spatial sort. By sorting points into a 2D spatial grid prior to insertion, each point is placed into the mesh immediately adjacent to the triangles created by its spatial predecessor. This keeps the cavity search local and reduces average-case execution time towards $O(n \log n)$.

Furthermore, during cavity deletion, bad triangles are marked dead. In a long insertion loop, dead triangles can clutter memory and slow down linear scans. Infinite's core Delaunay implementation checks when the triangle array exceeds 4,096 entries and automatically compacts the array by copying live triangles into contiguous memory.

Practical point budgeting

For real-time graphics at 60 FPS, a frame budget is roughly 16.6 milliseconds. In a combined audiovisual patch, audio processing typically takes 1 to 2 ms, GPU shader passes take 4 to 8 ms, leaving approximately 3 to 5 ms for CPU geometry calculations.

Based on benchmark tests across Apple Silicon and x86_64 architectures:

300 to 600 points: cook time is under 0.6 ms. This is ideal when multiple meshes are active simultaneously or when running complex GLSL post-processing effects.
1,000 to 1,800 points: cook time is 1.2 to 2.4 ms. This produces dense, intricate geometric surfaces with crisp silhouette details.
2,500 to 5,000 points: cook time reaches 4.5 to 9.0 ms. While viable on dedicated desktop machines, it approaches the limit of real-time responsiveness and should be used cautiously in live VJ contexts.

Infinite enforces a configurable maxPoints cap (defaulting to 2,000 points) on both Delaunay Mesh and Voronoi Cells. If an upstream particle emitter exceeds this threshold, the node systematically subsamples the sites to maintain real-time stability rather than dropping frames.

Practical creative workflows and aesthetic applications

Dynamic Delaunay and Voronoi geometry opens up distinct visual aesthetics that are difficult to achieve with standard polygonal modeling:

Low-poly crystalline landscapes: by displacing an XZ particle grid with Perlin noise and audio low-end, Delaunay triangulation forms a faceted, low-poly mountain range where polygons continuously adapt to the contours.
Shattered glass and Voronoi fracture: mapping an audio onset trigger to the inset control creates the illusion of an impact crater, where a smooth surface abruptly fractures into hundreds of receding tiles when a snare drum fires.
Cellular lifeforms and organic membranes: pairing Voronoi Cells with curl-noise particle flow simulates the movement of microscopic cells drifting under fluid currents.
Dynamic wireframe webs: extracting the edges of the Delaunay mesh and rendering them as geometric lines yields a retro-futuristic radar web that connects points when they approach each other and severs links when they diverge.

You can inspect ready-to-run audiovisual patches and templates in the Infinite Library, or explore the core architecture on the Infinite home page. Dynamic triangulation bridges the gap between chaotic point distributions and ordered 3D surfaces, turning raw mathematical coordinates into living generative visuals.

Originally published at https://infinitedevices.org/blog/delaunay-triangulation-and-voronoi-geometry-in-real-time.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Reaction-diffusion simulation in real-time GLSL

naman — Thu, 29 Oct 2026 09:13:07 +0000

A reaction-diffusion simulation in real-time GLSL brings the organic complexity of natural morphogenesis directly into creative coding and live visual performance. From the spots on a leopard and the stripes on a zebrafish to coral formations and cellular colonies, biological patterns are rarely drawn with static geometry. Instead, they grow out of non-linear chemical interactions where substances spread, react, and compete across space.

In audiovisual environments like Infinite, reaction-diffusion simulations can run entirely on the GPU, updating at high frame rates while reacting to incoming sound. By coupling partial differential equations to real-time audio analysis, artists can guide chemical morphogenesis with musical rhythm, using bass frequencies to seed new matter and high frequencies to trigger cell division.

Here is how the underlying chemistry works, how to discretise the equations for GLSL execution, and how to patch an audio-reactive reaction-diffusion pipeline using both native nodes and custom Field kernels.

The morphogenesis equations of Alan Turing and `Gray-Scott`

The mathematical foundation of biological pattern formation was introduced in 1952 by Alan Turing in his paper The Chemical Basis of Morphogenesis. Turing demonstrated that a system of two reacting chemicals with different diffusion rates, initially distributed almost uniformly, can spontaneously break symmetry and produce stable spatial patterns: spots, stripes, and whorls.

The most widely adopted model in computer graphics and creative coding is the Gray-Scott reaction-diffusion formulation, developed in 1983. In this model, two hypothetical chemical substances, chemical A and chemical B, diffuse across a two-dimensional grid while undergoing an autocatalytic reaction.

Chemical A represents a nourishing substrate that is constantly replenished at a feed rate F. Chemical B represents an active catalyst that consumes chemical A to duplicate itself through the reaction:

2B + A -> 3B

As chemical B reproduces, it also decays and is removed from the system at a kill rate k. The continuous system is governed by two coupled partial differential equations:

dA / dt = D_a * ∇²A - A * B² + F * (1.0 - A)
dB / dt = D_b * ∇²B + A * B² - (F + k) * B

Here:

D_a and D_b are the spatial diffusion rates of substances A and B. For pattern formation to occur, substance A must diffuse significantly faster than substance B, typically with D_a = 1.0 and D_b = 0.5.
∇² is the Laplacian operator, which computes the second spatial derivative of chemical concentration: measuring whether a point has a higher or lower concentration than its surrounding neighbourhood.
A * B² is the non-linear reaction term representing the conversion of substrate A into catalyst B in the presence of two units of B.
F * (1.0 - A) represents the replenishment of chemical A toward its maximum saturation level of 1.0.
(F + k) * B represents the depletion of chemical B through natural decay and dilution.

The delicate balance between the feed rate F and the kill rate k determines the resulting morphological pattern. Small changes in these two numbers move the simulation between distinct visual regimes:

Coral growth (F = 0.054, k = 0.062): slender dendritic branches that expand outward and weave together.
Mitosis and dividing cells (F = 0.036, k = 0.065): individual circular spots that grow, deform into dumbbells, and divide into autonomous pairs.
Soliton waves (F = 0.030, k = 0.062): pulsating spots and traveling ripples that interact elastically.
Labyrinthine maze (F = 0.029, k = 0.057): dense fingerprint-like ridges and interconnected loops that fill the canvas.

Discretising the continuous Laplacian on a GPU pixel grid

To execute the Gray-Scott model on modern graphics hardware in real time, the continuous spatial derivatives must be discretised onto a discrete two-dimensional grid of texels.

The Laplacian operator ∇² measures the divergence of the gradient: the net flow of chemical into or out of a local area. On a discrete square grid with texel spacing Δx = 1.0, we compute the Laplacian using a two-dimensional convolution kernel evaluated over each pixel and its eight immediate neighbours:

∇²U(x, y) ≈ 
    0.05 * U(x - 1, y - 1) + 0.20 * U(x, y - 1) + 0.05 * U(x + 1, y - 1) +
    0.20 * U(x - 1, y)     - 1.00 * U(x, y)     + 0.20 * U(x + 1, y) +
    0.05 * U(x - 1, y + 1) + 0.20 * U(x, y + 1) + 0.05 * U(x + 1, y + 1)

Notice the arithmetic structure of this 9-point stencil:

The orthogonal direct neighbours (top, bottom, left, right) each receive a weight of +0.20.
The diagonal corner neighbours receive a weight of +0.05.
The central pixel receives a weight of -1.00.
The sum of all nine weights equals exactly 0.0.

This zero-sum constraint guarantees that in an area of uniform concentration where all neighbouring pixels have identical values, the Laplacian evaluates to zero: no spurious chemical diffusion is created out of nothing.

Because the numerical simulation must feed its own output back into its input on subsequent time steps, real-time GPU implementations allocate two 32-bit floating-point textures (an RG32F ping-pong framebuffer pair). Channel R stores the concentration of chemical A, while channel G stores the concentration of chemical B.

In each rendering pass, the fragment shader samples the current state texture, computes the discrete Laplacian, evaluates the reaction equations, and writes the updated (A, B) values to the secondary texture. On the next step, the roles of the two textures are swapped.

To maintain temporal stability while avoiding spatial aliasing, multiple integration substeps are evaluated per displayed video frame: typically between 4 and 16 iterations per frame with a time step dt = 1.0.

Simulating reaction-diffusion with the native node

Infinite provides a native GPU-accelerated compositing node designed specifically for this physical process: the Reaction Diffusion node.

The node runs an optimised multi-pass fragment shader pipeline on the graphics card, giving access to the full Gray-Scott parameter space without requiring manual framebuffer setup or ping-pong buffer management.

The node exposes several key controls:

preset: quick access to canonical Morphogenesis regimes including Coral, Mitosis, Maze, Spots, Worms, and Holes.
feed: the replenishment rate of substrate A (ranging from 0.01 to 0.09).
kill: the decay rate of catalyst B (ranging from 0.03 to 0.08).
diffuse A: spatial propagation speed of substrate A (default 1.0).
diffuse B: spatial propagation speed of catalyst B (default 0.5).
steps / frame: number of numerical substeps executed per video frame (ranging from 1 to 32, defaulting to 8).
source influence: blends incoming image or video frames directly into chemical concentrations, allowing live cameras or video clips to deposit catalyst B onto the grid.

When wired into an output chain, the scalar concentration of chemical B represents the biological pattern. By connecting the output of Reaction Diffusion to a Color Ramp node, artists can map the continuous chemical gradients onto rich palettes, from iridescent oceanic hues to high-contrast monochrome prints.

Writing custom reaction-diffusion in Field Pixel

For artists and developers who require complete control over the mathematical formulation, Infinite includes Field, a domain-specific kernel language that compiles directly to GLSL.

Using a Field Pixel node, you can write the full reaction-diffusion kernel in concise code. The state keyword declares persistent frame-to-frame memory cells that automatically allocate ping-pong GPU textures under the hood.

Here is a complete, self-contained Gray-Scott reaction-diffusion kernel written in Field:

// Field Pixel: Gray-Scott Reaction-Diffusion Kernel
param float feed = 0.037 [0.01, 0.08]
param float kill = 0.060 [0.03, 0.08]
param float diffA = 1.0  [0.2, 1.5]
param float diffB = 0.5  [0.1, 1.0]

// Declare persistent chemical concentration buffers
state vec2 chem = vec2(1.0, 0.0)

// 1. Initialise small central seed perturbations
if (frame < 2) {
    vec2 p = uv - vec2(0.5);
    if (dot(p, p) < 0.002) {
        chem = vec2(0.5, 0.25);
    } else {
        chem = vec2(1.0, 0.0);
    }
} else {
    // 2. Sample 9-point Laplacian from previous frame state
    vec2 texel = 1.0 / resolution;

    vec2 lap = -1.0 * chem;
    lap += 0.20 * chem_prev(uv + vec2(-texel.x, 0.0));
    lap += 0.20 * chem_prev(uv + vec2( texel.x, 0.0));
    lap += 0.20 * chem_prev(uv + vec2(0.0, -texel.y));
    lap += 0.20 * chem_prev(uv + vec2(0.0,  texel.y));
    lap += 0.05 * chem_prev(uv + vec2(-texel.x, -texel.y));
    lap += 0.05 * chem_prev(uv + vec2( texel.x, -texel.y));
    lap += 0.05 * chem_prev(uv + vec2(-texel.x,  texel.y));
    lap += 0.05 * chem_prev(uv + vec2( texel.x,  texel.y));

    // 3. Evaluate non-linear reaction terms
    float a = chem.x;
    float b = chem.y;
    float reaction = a * b * b;

    float da = (diffA * lap.x) - reaction + feed * (1.0 - a);
    float db = (diffB * lap.y) + reaction - (feed + kill) * b;

    // 4. Update concentrations and clamp within physical bounds
    chem = clamp(vec2(a + da, b + db), vec2(0.0), vec2(1.0));
}

// 5. Output chemical B mapped to visual colour
col = vec3(chem.y * 2.8, chem.y * 1.4, chem.y * 3.5);

To explore more examples of shader development in Field, refer to the guide on audio-reactive GLSL shaders and the comprehensive Field language manual.

Modulating feed and kill rates with live audio spectrum bins

The most compelling aspect of running physical simulations in a unified audiovisual workstation is modulation. In Infinite, modulation is not an afterthought handled over slow network bridges: audio analysis, visual synthesis, and parameter controls share one lock-free evaluation graph.

To build an audio-reactive reaction-diffusion system:

Insert an audio source, such as an Oscillator, Analog synth, or Audio File node.
Connect the audio signal to an Audio Analyze node. The node splits the incoming sound into eight isolated frequency bands: sub-bass, bass, low-mid, mid, high-mid, presence, brilliance, and air.
Patch the sub-bass pin directly into the feed parameter of the Reaction Diffusion node. As heavy kick drums or bass notes trigger, the feed rate temporarily spikes upward. This floods the grid with fresh substrate A, stimulating aggressive outward branch growth and pattern expansion.
Patch the high-mid or presence pin into the kill parameter with an inverted modulation amount. When sharp snare hits or hi-hats land, the kill rate momentarily drops, allowing catalyst B to survive in regions where it would normally decay. This causes solid labyrinth ridges to fracture into clusters of dividing mitotic cells in step with the beat.
Alternatively, patch the Audio Analyze output into a Noise node, and connect the resulting texture to the input pin of Reaction Diffusion. By setting source influence to 0.2, transient acoustic energy injects localized bursts of catalyst directly onto the canvas, nucleating new self-replicating organisms at the sound of each musical event.

Mapping chemical concentrations to 3D surfaces and shaders

Reaction-diffusion is not restricted to flat two-dimensional video planes. The chemical density field can serve as a procedural displacement map, roughness texture, or volumetric density function for three-dimensional geometry.

In Infinite, you can wire the output of Reaction Diffusion directly into the input of a Displacement node. When applied to a high-density primitive such as a Sphere, Torus Knot, or subdivided Plane:

The scalar concentration of chemical B drives vertex displacement along the surface normal vectors. Labyrinthine ridges rise out of the geometry like organic coral reefs or carved bone.
The same texture is routed into a Material node to control roughness and metallic sheen. Valleys where catalyst B is depleted remain glossy and smooth, while displaced ridges take on tactile matte finishes.
Placing directional and point lights with subtle ambient occlusion transforms the abstract mathematical output into realistic, physical sculptures that appear to breathe and morph in real time.

A selection of ready-to-use procedural patches and generative templates is available in the free Infinite Library.

Headless validation and batch rendering

Because Infinite features a robust headless command-line interface, reaction-diffusion patches can be verified, inspected, and rendered to lossless ProRes or MP4 video without ever opening a graphical window.

Here is a minimal, complete patch file defining an audio-reactive reaction-diffusion network. Save this plain text as reaction_diffusion.inf:

infinite-patch 1
rev 2
node 1 Source Audio File
  id audio
  s path "drums.wav"
end
node 2 DSP Audio Analyze
  id analyze
end
node 3 Compositing Reaction Diffusion
  id rd
  i preset 2
  f feed 0.037
  f kill 0.060
  i stepsPerFrame 8
end
node 4 Compositing Color Ramp
  id ramp
end
node 5 Utility Output
  id out
end
cable analyze 0 audio
cable rd 0 analyze
cable ramp 0 rd
cable out 0 ramp
mod rd feed analyze 0 0.01 0.08 0.4
mod rd kill analyze 4 0.04 0.07 -0.3

You can validate the patch syntax and ensure all cable connections are strictly legal using the command line:

Infinite --validate reaction_diffusion.inf

To render stills at specific time stamps and inspect the organic pattern evolution:

Infinite --frame reaction_diffusion.inf 1.0,2.5,5.0 output/ --contact-sheet sheet.png

To render the finished audiovisual composition to a video file:

Infinite --render reaction_diffusion.inf render.mp4 --duration 15.0 --fps 60

Detailed instructions on command-line flags, render automation, and CI integration can be found in the Headless User Guide.

By uniting non-linear differential equations, GPU fragment pipelines, and zero-latency audio modulation, reaction-diffusion in Infinite turns abstract biochemical morphogenesis into an expressive, interactive instrument for generative art.

Originally published at https://infinitedevices.org/blog/reaction-diffusion-simulation-in-real-time-glsl.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Real-time fluid simulation in GLSL: Navier-Stokes and dye advection

naman — Thu, 29 Oct 2026 09:12:52 +0000

Implementing real-time fluid simulation in GLSL provides creative coders and visual artists with an organic medium for live performance, interactive installations, and audiovisual synthesis. Unlike particle-based systems or static procedural distortions, a Navier-Stokes fluid solver models the conservation of mass and momentum across a continuous vector field. When applied to visual media, live video feeds and generative graphics become dynamic dyes that swirl, fold, and disperse according to physical laws.

In real-time audiovisual software such as Infinite, fluid dynamics can be driven directly by incoming sound and camera motion. Because audio frequency bands and optical flow vectors can be mapped to velocity injection points, the fluid reacts with zero perceptible delay to live musical performance.

This guide walks through the complete mathematical and architectural implementation of an Eulerian fluid solver on the GPU: the staggered Marker-and-Cell (MAC) grid layout, unconditionally stable semi-Lagrangian advection, geometric multigrid Poisson solvers for incompressibility, vorticity confinement for preserving turbulence, and live audio-reactive modulation.

What is real-time fluid simulation in GLSL

Computer graphics divides fluid simulation into two primary paradigms: Lagrangian and Eulerian.

The Lagrangian approach treats the fluid as a discrete collection of moving particles, commonly implemented via Smoothed Particle Hydrodynamics (SPH). Each particle carries its own position, velocity, and mass. While intuitive, particle methods require expensive spatial hashing and neighbour search routines on the GPU, making high-resolution simulations computationally heavy.

The Eulerian approach fixes the coordinate frame in space and observes fluid quantities flowing through a stationary grid of cells. Each cell tracks local velocity, pressure, and passive dye concentration. Because GPU fragment shaders and framebuffers operate natively on two-dimensional pixel grids, the Eulerian formulation maps directly to hardware textures:

Velocity field: a two-component floating-point texture storing horizontal velocity u and vertical velocity v.
Pressure field: a single-component scalar texture storing local hydrostatic pressure p.
Dye field: an RGBA colour texture storing graphic media, video, or synthetic pigmentation carried passively by the flow.

By executing successive rendering passes across offscreen framebuffer objects (FBOs), the graphics card computes each phase of the fluid equations in parallel for millions of cells at sixty frames per second.

The Navier-Stokes equations and grid discretisation

Incompressible fluid flow is governed by the Navier-Stokes equations:

∂u/∂t = -(u · ∇)u - (1/ρ)∇p + ν∇²u + f
∇ · u = 0

Here:

u is the velocity vector field (u, v).
-(u · ∇)u represents advection, the transport of velocity along itself.
-(1/ρ)∇p is the pressure gradient force that accelerates fluid from high to low pressure regions.
ν∇²u accounts for kinematic viscosity, causing momentum to diffuse across adjacent layers.
f denotes external body forces, such as gravity, user mouse stirrers, or audio impulses.
∇ · u = 0 enforces incompressibility, meaning the volume of any parcel of fluid remains strictly constant over time.

Solving these partial differential equations on a discrete grid requires careful cell alignment. In a naive collocated grid, both velocity components (u, v) and pressure p are stored at the exact centre of each cell. When central differences are computed to evaluate pressure gradients and velocity divergence, adjacent cells skip their immediate neighbours:

∂p/∂x ≈ (p[i+1, j] - p[i-1, j]) / (2 * Δx)

This causes an odd-even decoupling known as the checkerboard instability, where high-frequency oscillatory pressure fields register a false divergence of zero.

To eliminate this artifact without artificial damping, production solvers employ a staggered Marker-and-Cell (MAC) grid layout:

The horizontal velocity component u is stored on the vertical cell faces between cell (i-1, j) and (i, j).
The vertical velocity component v is stored on the horizontal cell faces between cell (i, j-1) and (i, j).
The pressure p and passive dye c are stored at the geometric centre of cell (i, j).

On a staggered grid, divergence is evaluated across immediate face values:

div[i, j] = (u_face[i+1, j] - u_face[i, j]) / Δx + (v_face[i, j+1] - v_face[i, j]) / Δy

Every face velocity couples directly to the pressure of the two cells sharing that face. The resulting discretisation guarantees that when the pressure Poisson equation converges, the velocity field leaves zero divergence behind.

Semi-Lagrangian advection and velocity transport

Advection describes how moving fluid transports both external properties (such as colour and temperature) and its own velocity. Standard explicit finite-difference schemes suffer from the Courant-Friedrichs-Lewy (CFL) stability condition: if the fluid velocity multiplied by the time step exceeds the cell width (|u| * Δt > Δx), the numerical scheme explodes into floating-point infinities.

In 1999, Jos Stam introduced unconditionally stable semi-Lagrangian advection to computer graphics. Rather than asking where a parcel of fluid will travel in the future, semi-Lagrangian advection looks backward in time.

For every grid cell x, the solver traces a virtual particle backward along the current velocity field to determine its origin point x_prev at the previous time step:

x_prev = x - u(x) * Δt

The new value at cell x is then sampled from the previous state at position x_prev using bilinear interpolation:

// GLSL fragment shader for semi-Lagrangian advection
#version 150

uniform sampler2D uVelocity;
uniform sampler2D uSource;
uniform float uDeltaTime;
uniform vec2 uTexelSize;

in vec2 vUv;
out vec4 fragColor;

void main()
{
    // Sample the current velocity at this location
    vec2 vel = texture(uVelocity, vUv).xy;

    // Backtrack along the velocity vector
    vec2 prevPos = vUv - vel * uDeltaTime * uTexelSize;

    // Sample the transported quantity with bilinear hardware filtering
    fragColor = texture(uSource, prevPos);
}

Because bilinear texture sampling on modern graphics hardware is executed directly inside fixed-function texture units, semi-Lagrangian advection runs with minimal shader cost. Even under extreme velocities and large time steps, the algorithm cannot diverge, as the interpolated value is always bounded by the minimum and maximum values of the surrounding texels.

The inherent trade-off of semi-Lagrangian advection is numerical dissipation. Repeated bilinear interpolation acts as an unintended low-pass filter, gradually smoothing out sharp velocity gradients and subtle eddies over time.

Making the flow divergence-free with pressure projection

After advection and the application of external forces, the provisional velocity field w is generally divergent (∇ · w ≠ 0). Compressible fluid would bunch up or create vacuums; an incompressible liquid must satisfy ∇ · u = 0.

The Helmholtz-Hodge decomposition theorem states that any smooth vector field w can be uniquely resolved into the sum of a divergence-free vector field u and the gradient of a scalar potential p:

w = u + ∇p

Taking the divergence of both sides yields the Poisson equation for pressure:

∇ · w = ∇ · u + ∇²p
∇²p = ∇ · w    (since ∇ · u = 0)

Once the scalar pressure field p is obtained by solving this Poisson system, the final divergence-free velocity field is calculated by subtracting the pressure gradient:

u = w - ∇p

Multigrid V-cycles versus standard Jacobi relaxation

On a discrete two-dimensional grid, the Laplacian operator ∇²p is approximated by a five-point stencil:

(p[i+1, j] + p[i-1, j] + p[i, j+1] + p[i, j-1] - 4 * p[i, j]) / (Δx²) = div[i, j]

Rearranging this formula yields the standard Jacobi relaxation step:

p_new[i, j] = 0.25 * (p[i+1, j] + p[i-1, j] + p[i, j+1] + p[i, j-1] - Δx² * div[i, j])

Simple Jacobi iteration dampens high-frequency error quickly, but eliminates low-frequency, long-wavelength pressure differences very slowly. Resolving pressure across a 1920x1080 grid using Jacobi relaxation alone requires between 80 and 150 render passes per frame, which places severe strain on GPU memory bandwidth.

Infinite solves this bottleneck using a geometric multigrid V-cycle solver across five hierarchical grid levels (kMaxLevels = 5):

Pre-smoothing: two Jacobi relaxation passes are performed on the finest simulation grid (Level 0).
Residual calculation: the remaining error r = div - ∇²p is computed.
Restriction: the residual and obstacle masks are downsampled to a half-resolution grid (Level 1).
Recursive descent: this restriction repeats down through Level 4, where the entire screen is represented by a coarse 120x68 grid.
Coarse solve: at the lowest level, long-wavelength pressure modes span only a handful of pixels, allowing ten Jacobi iterations to propagate pressure across the entire domain.
Prolongation: the coarse correction is bilinearly upsampled, added back to the finer level, and followed by two post-smoothing Jacobi passes.

A single five-level multigrid V-cycle with twenty total iterations achieves tighter divergence-free convergence than 120 brute-force Jacobi iterations, leaving ample GPU headroom for real-time video compositing and audio DSP.

Preserving turbulence with vorticity confinement

Because semi-Lagrangian advection introduces numerical dissipation, fine vortices and turbulent swirls tend to decay quickly. In creative coding and visual effects, this loss of rotational energy makes fluids look like thick syrup rather than water or air.

To restore this lost turbulence without destabilising the solver, Infinite employs vorticity confinement, originally formulated by Steinhoff and Underhill and adapted for graphics by Ronald Fedkiw.

Vorticity measures the local rotation or spin of the fluid:

ω = ∇ × u = (∂v/∂x - ∂u/∂y)

In two dimensions, vorticity is a scalar quantity. The gradient of the absolute vorticity points toward the centre of local vortices:

η = ∇|ω| / (|∇|ω| + 1e-5)

The normal vector η is perpendicular to the vortex axis. The confinement force is calculated as the cross product of η and the vorticity vector:

f_vort = ε * (η × ω) * Δx

In GLSL, this evaluates to:

// GLSL fragment shader for vorticity confinement
#version 150

uniform sampler2D uVelocity;
uniform float uVorticityStrength;
uniform vec2 uTexelSize;

in vec2 vUv;
out vec4 fragColor;

void main()
{
    // Compute local curl (vorticity)
    float uT = texture(uVelocity, vUv + vec2(0.0, uTexelSize.y)).x;
    float uB = texture(uVelocity, vUv - vec2(0.0, uTexelSize.y)).x;
    float vR = texture(uVelocity, vUv + vec2(uTexelSize.x, 0.0)).y;
    float vL = texture(uVelocity, vUv - vec2(uTexelSize.x, 0.0)).y;

    float curl = 0.5 * ((vR - vL) - (uT - uB));

    // Sample curl magnitude in neighbouring cells
    float cT = abs(texture(uVelocity, vUv + vec2(0.0, uTexelSize.y)).z);
    float cB = abs(texture(uVelocity, vUv - vec2(0.0, uTexelSize.y)).z);
    float cR = abs(texture(uVelocity, vUv + vec2(uTexelSize.x, 0.0)).z);
    float cL = abs(texture(uVelocity, vUv - vec2(uTexelSize.x, 0.0)).z);

    // Find the gradient of curl magnitude
    vec2 eta = 0.5 * vec2(cR - cL, cT - cB);
    float len = length(eta);
    if (len < 1e-5) {
        fragColor = vec4(0.0);
        return;
    }
    eta /= len;

    // Confinement force: F = epsilon * (eta_y, -eta_x) * curl
    vec2 force = uVorticityStrength * vec2(eta.y, -eta.x) * curl;
    fragColor = vec4(force, curl, 1.0);
}

Applying this corrective force before the pressure projection step injects angular momentum back into emerging eddies. Fine rotational details remain crisp and swirling indefinitely without causing instability.

Solid boundaries and obstacle interaction

To allow fluid to flow naturally around visual elements, text, or logos, the solver must handle solid obstacles.

In Infinite, obstacles are provided as a single-channel luminance texture where bright pixels represent solid barriers. Two physical boundary conditions must be satisfied at obstacle surfaces:

No-penetration condition: fluid cannot flow through a solid wall. The velocity normal to the wall must be zero (u · n = 0).
Free-slip or no-slip tangential condition: for low-viscosity aesthetic fluids, free-slip boundaries (where tangential velocity slides unhindered) produce clean, non-sticky circulation.

In the staggered MAC grid, wall boundaries are enforced during the divergence and pressure solve passes. When evaluating the divergence of cell (i, j), any face touching a solid cell or the outer boundary of the texture is flagged as a wall:

bool solidAt(sampler2D obs, ivec2 q, ivec2 sz) {
    if (q.x < 0 || q.y < 0 || q.x >= sz.x || q.y >= sz.y) return true;
    return texelFetch(obs, q, 0).r > 0.5;
}

float faceU(sampler2D vt, sampler2D obs, ivec2 p, ivec2 sz) {
    bool wall = solidAt(obs, p, sz) || solidAt(obs, p - ivec2(1, 0), sz);
    return wall ? 0.0 : texelFetch(vt, p, 0).x;
}

In the pressure solve, the pressure gradient across a solid face is set to zero (∂p/∂n = 0), ensuring that the projection pass does not reintroduce flow into solid barriers. The fluid cleanly wraps around obstacle contours, creating realistic wake patterns and stagnation points.

Audio-reactive forces and optical flow injection in Infinite

A fluid simulation becomes truly compelling in creative performance when connected to sound and real-time motion.

In Infinite, the node canvas combines audio synthesis, DSP analysis, 3D graphics, and 2D GLSL compositing within a single executable timeline. The Fluid node exposes three primary inputs:

image: the passive dye carried by the flow. Video clips, generative Shader nodes, or live webcam streams can be cabled here.
force: a two-component velocity vector field that stirs the fluid each frame.
obstacles: an image mask defining impenetrable solid surfaces.

Coupling with the Optical Flow node

One of the most expressive ways to drive the fluid is through the Optical Flow node. Based on pyramidal Lucas-Kanade feature tracking (Bouguet 2001), Optical Flow computes the instantaneous motion between consecutive video frames across multiple resolution levels.

When set to raw output mode, Optical Flow writes horizontal motion into the red channel and vertical motion into the green channel as floating-point pixels per frame. Cabled into the force pin of the Fluid node, dancer movements, camera gestures, or animated geometric shapes physically push and stir the fluid dye with zero manual calibration.

Modulating fluid physics with audio analysis

To synchronise fluid dynamics with electronic music, audio frequency content is extracted via the Audio Analyze node:

[Audio In / Synth] ---> [Audio Analyze (8-Band FFT)]
                             |
                             +---> band 0 (sub-bass) ---> [Fluid].forceGain
                             |
                             +---> band 3 (snare/mid) ---> [Fluid].vorticity
                             |
                             +---> band 7 (high hat)  ---> [Fluid].stirrerStrength

Sub-bass punch: cabling the lowest FFT band into forceGain amplifies the velocity response on kick drum transients, causing sudden outward explosive bursts.
Vorticity modulation: connecting the snare or mid-frequency transient band to vorticity triggers intricate curling smoke patterns on snare hits, which relax back into smooth laminar flow during quiet passages.
Built-in stirrer automation: the Fluid node includes built-in rotational stirrers (Orbit, Pulse, Spin). By modulating stirrerStrength with a tempo-synced LFO or Envelope node, the entire fluid volume sustains an organic ambient circulation even when external forces pause.

Because Infinite computes parameter modulation, audio DSP, and GPU frame rendering synchronously within the same tick loop, there is zero buffer latency between audio peaks and graphical reaction.

Building the real-time node network in Infinite

Setting up this audiovisual pipeline in Infinite requires five nodes cabled together on the canvas:

Add a Video or Shape node to provide visual content. Connect its output to the image pin of a Fluid node.
Add a Video In node receiving a live camera stream. Cable its output into an Optical Flow node.
Set Optical Flow parameter view to 0 (Raw motion vectors) and cable its output into the force pin of Fluid.
Add an Audio In node patched into an Audio Analyze node.
In the modulation matrix or by dragging modulation cables:
- Map FFT Band 0 (sub-bass) to Fluid parameter forceGain (range 0.5 to 3.0).
- Map FFT Band 2 (low-mids) to Fluid parameter vorticity (range 0.1 to 0.6).
- Map an LFO node running at a 1/2-bar division to Fluid parameter stirrerStrength.
Add an Output node and connect Fluid's output to project the final rendered artwork.

To view alternative internal states during rehearsal, the Fluid node's view parameter allows switching the display from Dye to Velocity (visualised as colour hue and brightness), Pressure gradients, or Obstacles.

The resulting patch and dozens of related creative coding templates are available to explore in the Infinite patch library.

Honest technical limits and GPU performance

While real-time Eulerian fluid simulation in GLSL produces striking visuals, practical production environments have distinct constraints:

Memory bandwidth and fillrate: Eulerian simulations are memory-bandwidth bound. A full-resolution 4K (3840x2160) grid requires reading and writing tens of gigabytes per second across multiple FBO passes. In practice, setting the resolution parameter to 1 (half-resolution simulation grid) allows the velocity and pressure solves to run at 960x540 while the passive dye advection pass remains at full 1080p, preserving sharp visual edges while cutting GPU compute cost by 75 percent.
Two-dimensional planar flow: A 2D simulation does not account for vortex stretching, a three-dimensional physical phenomenon responsible for the energy cascade from large eddies down to microscopic scales. While 2D fluids produce convincing swirling sheets and marbling effects, they cannot simulate three-dimensional smoke plumes or tumbling spherical vortices.
Incompressible assumption: The solver assumes the medium has uniform, constant density. Sound waves (acoustic compression waves) do not propagate through the simulated fluid itself. The audio reactivity described here is achieved by external parametric coupling rather than physical acoustic simulation.

Summary and patch architecture

Real-time fluid simulation in GLSL transforms standard video feeds and generative graphics into dynamic, physics-based audiovisual instruments.

By combining the staggered MAC grid layout with unconditionally stable semi-Lagrangian advection, geometric multigrid Poisson projection, and vorticity confinement, high-resolution fluid dynamics can run smoothly at sixty frames per second on modern hardware. When modulated by live optical flow vectors and audio frequency analysis, the fluid responds organically to music and motion with zero latency.

To experiment with native fluid dynamics, real-time shaders, and modular sound design, download Infinite and explore our detailed guides on raymarching signed distance fields and audio-reactive GLSL shaders.

Originally published at https://infinitedevices.org/blog/real-time-fluid-simulation-in-glsl.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.

Raymarching signed distance fields in real-time GLSL

naman — Thu, 29 Oct 2026 09:12:45 +0000

Building a system for raymarching signed distance fields in real-time GLSL provides a powerful alternative to traditional polygonal rasterisation. While standard 3D rendering pipelines rely on vertex buffers, index arrays, and triangle meshes, raymarching computes three-dimensional surfaces procedurally inside a fragment shader. Every geometric volume, smooth Boolean blend, and fractal surface is evaluated mathematically for every individual pixel on the screen.

In modern audiovisual software such as Infinite, raymarching allows visual artists and audio producers to bridge the gap between mathematical graphics and low-latency audio synthesis. Because signed distance fields are defined purely through mathematical equations, parameters such as scale, repetition, twisting, and morphing can be cabled directly to live audio frequency bands, envelope followers, and LFO modulators without regenerating vertex buffers or stalling the graphics pipeline.

Here is an architectural walkthrough of how sphere tracing works, how to construct signed distance functions (SDFs) for common 3D primitives, how to blend geometry organically with polynomial smooth minimums, and how to wire a complete audio-reactive raymarching pipeline inside Infinite.

What is sphere tracing and how the ray steps

Traditional raymarching steps through 3D space along a view ray using small, uniform increments. While simple to implement, uniform stepping suffers from severe trade-offs: if the step size is too large, the ray can skip thin geometry entirely, producing visual holes and aliasing artifacts; if the step size is too small, performance drops precipitously.

Sphere tracing, introduced by John C. Hart in 1996, solves this inefficiency by exploiting the fundamental mathematical property of a signed distance field.

A signed distance function f(p) takes any point p in three-dimensional space and returns the shortest Euclidean distance from that point to the nearest surface in the scene:

f(p) > 0  : The point p is located outside the object.
f(p) = 0  : The point p lies exactly on the boundary surface.
f(p) < 0  : The point p is located inside the object.

Because f(p) yields the absolute minimum distance to the closest boundary, a sphere of radius R = f(p) centred at p is guaranteed to be completely empty of any geometry. Therefore, a view ray starting at p can safely advance along its direction vector by the full distance R in a single step without any risk of overshooting or penetrating a surface.

To construct the view ray for each pixel, we map normalised screen coordinates uv into a camera origin ro and a normalised direction vector rd:

vec3 rayDirection(vec2 uv, vec3 eye, vec3 target, float fov) {
    vec3 forward = normalize(target - eye);
    vec3 right = normalize(cross(forward, vec3(0.0, 1.0, 0.0)));
    vec3 up = cross(right, forward);
    return normalize(uv.x * right + uv.y * up + forward * fov);
}

With the ray direction established, the sphere tracing loop evaluates the scene's signed distance function iteratively:

float raymarch(vec3 ro, vec3 rd, float minDistance, float maxDistance) {
    float distanceTravelled = minDistance;

    for (int step = 0; step < 128; step++) {
        vec3 currentPosition = ro + rd * distanceTravelled;
        float distanceToSurface = map(currentPosition);

        // Surface hit detected within threshold epsilon
        if (distanceToSurface < 0.001) {
            return distanceTravelled;
        }

        distanceTravelled += distanceToSurface;

        // Ray escaped into empty background
        if (distanceTravelled >= maxDistance) {
            break;
        }
    }

    return -1.0; // Miss
}

Notice how this algorithm naturally adapts to the spatial complexity of the scene: in vast regions of open space, the distance to the nearest surface is large, allowing the ray to take massive strides across thousands of units in a handful of steps. Near surfaces and delicate geometric silhouettes, the steps automatically shrink to sub-millimetre precision, capturing razor-sharp edges.

Primary SDF geometric primitives

Every scene evaluated in a raymarcher is described by an overall distance function, typically named map(vec3 p). Complex scenes are constructed by combining simple mathematical primitives.

Here are the canonical signed distance functions for fundamental 3D solids:

1. Sphere

The sphere is the simplest primitive in distance field mathematics. The distance from point p to the surface of a sphere centred at the origin with radius r equals the Euclidean length of p minus r:

float sdSphere(vec3 p, float r) {
    return length(p) - r;
}

2. Box

An axis-aligned box with half-dimensions b requires computing the component-wise distance outside the boundary and combining it with the internal signed distance:

float sdBox(vec3 p, vec3 b) {
    vec3 q = abs(p) - b;
    return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0);
}

3. Torus

A torus lying on the XZ plane with major radius t.x and minor tube radius t.y is derived by projecting p onto the circular core:

float sdTorus(vec3 p, vec2 t) {
    vec2 q = vec2(length(p.xz) - t.x, p.y);
    return length(q) - t.y;
}

4. Cylinder

A vertical cylinder centred along the Y axis with radius h.x and half-height h.y:

float sdCylinder(vec3 p, vec2 h) {
    vec2 d = abs(vec2(length(p.xz), p.y)) - h;
    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
}

Spatial domain operations

One of the great advantages of signed distance fields over triangle meshes is that geometric transformations are performed by transforming the input coordinate space p before evaluating the primitive, rather than modifying millions of stored vertices:

Translation: Evaluating sdSphere(p - offset, r) moves the sphere to position offset.
Rotation: Multiplying p by a rotation matrix rotates the geometry. For example, rotating around the Y axis by angle theta:

  vec3 rotateY(vec3 p, float theta) {
      float c = cos(theta);
      float s = sin(theta);
      return vec3(c * p.x + s * p.z, p.y, -s * p.x + c * p.z);
  }

Infinite domain repetition: By wrapping coordinates with modulo arithmetic, an artist can duplicate an object infinitely across 3D space with zero memory cost:

  vec3 repeatDomain(vec3 p, vec3 cellSpacing) {
      return mod(p + 0.5 * cellSpacing, cellSpacing) - 0.5 * cellSpacing;
  }

Constructive solid geometry and polynomial smooth blending

Constructive Solid Geometry (CSG) combines multiple primitive distance fields using Boolean logic. In signed distance fields, Boolean operations map directly to basic arithmetic functions:

float opUnion(float d1, float d2)        { return min(d1, d2); }
float opIntersection(float d1, float d2) { return max(d1, d2); }
float opSubtraction(float d1, float d2)  { return max(-d1, d2); }

While standard CSG produces hard, sharp seams where surfaces intersect, creative coding and natural forms frequently demand organic, continuous transitions.

The polynomial smooth minimum, formulated by Inigo Quilez, creates an organic fillet between two distance fields. The smoothing factor k controls the radius of the organic bridge:

float opSmoothUnion(float d1, float d2, float k) {
    float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
    return mix(d2, d1, h) - k * h * (1.0 - h);
}

float opSmoothSubtraction(float d1, float d2, float k) {
    float h = clamp(0.5 - 0.5 * (d2 + d1) / k, 0.0, 1.0);
    return mix(d2, -d1, h) + k * h * (1.0 - h);
}

When two spheres or geometric shapes pass through one another with opSmoothUnion, they blend seamlessly like drops of liquid mercury or metaballs. In live audiovisual performance, modulating the parameter k with audio amplitude causes sharp geometric structures to dissolve into fluid organic masses on heavy musical accents.

Surface normals and Blinn-Phong lighting

Because signed distance fields do not carry pre-computed vertex normals, we estimate the surface normal vector directly from the spatial gradient of the distance field.

The gradient ∇f(p) points in the direction where the distance increases most rapidly. On a surface boundary where f(p) = 0, this gradient vector points directly perpendicular to the surface. We approximate the gradient using finite differences with a tiny offset e:

vec3 calculateNormal(vec3 p) {
    vec2 e = vec2(0.001, 0.0);
    return normalize(vec3(
        map(p + e.xyy) - map(p - e.xyy),
        map(p + e.yxy) - map(p - e.yxy),
        map(p + e.yyx) - map(p - e.yyx)
    ));
}

This central differences technique samples the scene six times around point p and yields a smooth, accurate unit normal.

Shading and illumination

With the surface normal normal and view direction viewDir calculated, we compute standard Blinn-Phong shading:

vec3 computeLighting(vec3 p, vec3 normal, vec3 viewDir, vec3 lightPos, vec3 baseColour) {
    vec3 lightDir = normalize(lightPos - p);
    vec3 halfwayDir = normalize(lightDir + viewDir);

    // Ambient illumination
    vec3 ambient = 0.15 * baseColour;

    // Diffuse Lambertian reflection
    float diff = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = diff * baseColour;

    // Specular highlight
    float spec = pow(max(dot(normal, halfwayDir), 0.0), 32.0);
    vec3 specular = vec3(0.8) * spec;

    // Soft shadow attenuation
    float shadow = computeSoftShadow(p + normal * 0.002, lightDir, 0.02, 10.0, 16.0);

    return ambient + (diffuse + specular) * shadow;
}

Raymarched soft shadows

Raymarching offers an elegant way to compute realistic penumbra soft shadows with zero shadow maps. As a secondary shadow ray travels from surface point p toward the light source, we record the minimum ratio of distance to travel distance:

float computeSoftShadow(vec3 ro, vec3 rd, float mint, float maxt, float k) {
    float res = 1.0;
    float t = mint;

    for (int i = 0; i < 48; i++) {
        float h = map(ro + rd * t);
        if (h < 0.0005) {
            return 0.0; // In full shadow
        }
        res = min(res, k * h / t);
        t += clamp(h, 0.02, 0.25);
        if (t >= maxt) {
            break;
        }
    }

    return clamp(res, 0.0, 1.0);
}

The parameter k controls shadow softness: smaller values yield wide, blurry penumbras resembling diffuse studio lighting, while larger values produce crisp direct sunlight.

Building an audio-reactive raymarcher in Infinite

To run this pipeline inside Infinite, we write our complete GLSL kernel inside a Field Pixel node. Infinite's built-in Field language compiles short text kernels into native GPU fragment shaders without extra wrapper boilerplate.

1. Declaring modulatable parameters

In Field, parameters are declared directly at the top of the kernel script. Each parameter automatically turns into an interactive knob on the node and exposes an input pin on the canvas:

param float u_bass = 0.0 [0.0, 1.0]
param float u_morph = 0.0 [0.0, 1.0]
param float u_twist = 0.5 [0.0, 2.0]
param float u_smooth = 0.3 [0.05, 1.0]

2. Defining the scene distance map

We define a dynamic scene combining a central sphere, a rotating torus, and an organic twist distortion:

float map(vec3 p) {
    // Audio-reactive spatial twist
    float angle = p.y * u_twist + t * 0.4;
    float cosA = cos(angle);
    float sinA = sin(angle);
    p.xz = mat2(cosA, -sinA, sinA, cosA) * p.xz;

    // Primitive 1: Central pulsing sphere driven by bass
    float sphereRadius = 1.0 + u_bass * 0.45;
    float dSphere = sdSphere(p, sphereRadius);

    // Primitive 2: Outer torus morphed by midrange frequencies
    vec2 torusDims = mix(vec2(1.8, 0.35), vec2(2.2, 0.15), u_morph);
    float dTorus = sdTorus(p, torusDims);

    // Smooth organic blend
    return opSmoothUnion(dSphere, dTorus, u_smooth);
}

3. Assembling the canvas patch

The visual half of the patch connects as follows:

Add a Field Pixel node and paste the raymarching kernel.
Cable the image output pin of Field Pixel into a Bloom node to introduce subtle optical glow on high specular reflections.
Cable the output of Bloom into the Output node to send the rendered picture to your display or projector.

The audio half of the patch provides the real-time modulation streams:

Add an Analog or Wavetable synth node, or connect live audio through an Audio In node.
Route the audio signal to an Audio Out node for playback and into an Audio Analyze node.
The Audio Analyze node decomposes the audio stream into frequency bands: low, mid, and high.
Cable the low pin of Audio Analyze to the u_bass input pin of Field Pixel. When a kick drum hits, the central sphere expands dynamically.
Cable the mid pin of Audio Analyze to u_morph. Snare hits and synth melodies cause the torus geometry to morph in radius and thickness.
Add an LFO node configured to a slow sine wave and cable its output into u_twist. This guarantees that the geometric lattice continually drifts and rotates even during quiet musical breakdowns.

For ready-to-use patch setups, browse the free templates in the Library.

Performance optimisation for real-time framerates

Evaluating up to 128 distance queries for every pixel at 1080p or 4K resolution requires careful attention to GPU execution:

Bounding volume tests: Before evaluating an expensive geometric calculation or infinite repetition array, wrap the object in a simple bounding sphere. If the ray step indicates that the distance to the bounding sphere is positive, return that distance immediately, bypassing complex inner math.
Step budget constraints: In a live performance setting running at 60 FPS, cap ray iterations between 64 and 96 steps. This prevents GPU thermal throttling while maintaining clean visual results.
Avoid branch divergence: Avoid placing conditional branching statements (if/else) inside distance functions. Instead, prefer arithmetic blending functions like mix(), step(), and clamp().
Over-relaxation: Standard sphere tracing steps by exactly f(p). Over-relaxation techniques scale each step by a relaxation factor omega (typically around 1.2 to 1.5), speeding up ray travel through long open corridors without skipping boundaries.

To explore further techniques in real-time shader authoring, read our audio-reactive GLSL shaders guide.

Summary and where to experiment next

Raymarching signed distance fields transforms the fragment shader into a full 3D geometric engine. By replacing stored polygon meshes with analytic distance functions, artists gain complete procedural control over form, repetition, lighting, and soft shadows.

When integrated into Infinite's unified audiovisual node canvas, these distance fields become reactive physical instruments. Kick drums displace space, melodies morph geometric topology, and LFOs twist coordinate domains in real time, all running on the GPU with zero audio-thread latency.

Originally published at https://infinitedevices.org/blog/raymarching-signed-distance-fields-in-real-time-glsl.html. Infinite is a free, open-source DAW for visuals, music and code: infinitedevices.org.