Node Reference

Chromatic Tuner

Real-time pitch detection with note name and cents deviation display

Real-time pitch detection and tuning display. Reads spectral magnitudes from an upstream SpectralAnalyze node and identifies the fundamental frequency via harmonic product spectrum (HPS).

When detection confidence exceeds the Sensitivity threshold, the detected pitch is smoothed over time and output as V/Oct on the Pitch port; the Gate port goes high. When confidence drops below the threshold, the smoothed frequency resets to zero, V/Oct outputs 0.0, and the gate goes low. The optional Tuning input sets divisions-per-octave for note naming (defaults to 12-TET).

Clip Detector

Detects audio clipping with control output

Monitors audio for clipping by comparing per-sample amplitude against a configurable threshold. Passes audio through unchanged.

Both left and right channels are checked; if either exceeds the threshold the clip indicator fires. The Clip Signal output stays at 1.0 for the duration of the hold period after the last clipping sample, then drops to 0.0. Internally tracks total clip events, samples clipped, and peak amplitude for diagnostics. Returns early with no output if Audio In is disconnected.

Envelope Follower

Tracks amplitude envelope of audio signal

Extracts the amplitude envelope from an audio signal, producing a smooth control voltage that tracks the signal's loudness over time.

Stereo input is mono-downmixed and fed sample-by-sample into a peak detector with independent attack/release time constants. The resulting envelope level drives the Envelope Out control signal. A threshold comparator on the envelope generates gate events: the gate goes high on the sample where the envelope first exceeds the threshold and low on the sample where it drops below. Returns early with no output if Audio In is disconnected.

Oscilloscope

Real-time waveform visualization with trigger modes

Real-time waveform display for inspecting audio signals. Supports dual-channel comparison and configurable trigger modes.

Each stereo input is mono-downmixed for display. In Auto mode the trigger level is continuously derived from the signal's running min/max midpoint (works for bipolar and rectified signals); in Rising/Falling modes it uses the user-set Trigger Level. FreeRun captures continuously with no trigger gating. Discontinuity mode triggers on sudden sample-to-sample jumps by comparing the current delta against a running average — useful for catching clicks, pops, retrigger boundaries, and envelope attacks. When a trigger fires, samples fill the capture buffer until it reaches the configured time-scale width, then a snapshot is staged for the UI. In Auto and Discontinuity modes, a periodic fallback flush fires every 4096 frames if no trigger occurs. Audio is always passed through on both channels regardless of freeze or trigger state. Freezing pauses capture but not pass-through. Returns early with no output if Channel 1 is disconnected.

Peak Meter

Peak level measurement with hold and decay

Measures peak audio levels with hold and ballistic decay, outputting a control signal for driving level meters and VU displays.

Left and right channels are metered independently through separate PeakMeter DSP instances. The Peak Level control output is the maximum of L/R peaks each buffer. A poll response carries per-channel linear peaks, combined dB level, and a clipping flag (true when either channel >= 1.0). Audio is passed through unchanged. Returns early with no output if Audio In is disconnected. Meters are fully re-initialized on setup() when the sample rate changes.

Spectrum Analyzer

FFT-based frequency spectrum visualization with configurable analysis

FFT-based frequency spectrum display. Shows the frequency content of an audio signal in real time with configurable resolution, windowing, and spectral averaging.

Accepts two input paths: a Spectral port and an Audio port. When Spectral is connected, magnitudes arrive pre-computed from an upstream SpectralAnalyze node and the internal FFT is bypassed. When only Audio is connected, stereo input is mono-downmixed and accumulated into an FFT buffer with 50% overlap, then processed on a dedicated analysis thread to keep the audio thread real-time safe. Audio is always passed through unchanged regardless of which analysis path is active. Freezing pauses spectral capture but does not interrupt audio pass-through. The optional Tuning input sets divisions-per-octave for the note overlay gridlines (defaults to 12-TET when disconnected).

Waterfall

Scrolling spectrogram — frequency × time heatmap

Scrolling spectrogram that plots frequency content over time as a color-mapped heatmap. Each row is one FFT slice; the display scrolls so the most recent spectrum appears at the top.

Accepts two input paths: a Spectral port and an Audio port. When Spectral is connected, magnitudes arrive pre-computed and the internal FFT is bypassed. When only Audio is connected, stereo input is mono-downmixed and accumulated with 75% overlap for smooth scrolling, then processed on a dedicated analysis thread. Averaging is always disabled (each row is a single un-smoothed FFT frame). Audio is passed through unchanged regardless of which analysis path is active. Freezing pauses spectrogram scrolling but does not interrupt audio pass-through.

Allpass Filter

Phase rotation without amplitude change — building block for phasers and reverbs

Second-order allpass filter (RBJ biquad). Passes all frequencies at unity gain but rotates phase around the center frequency.

True stereo with independent filter state per channel. Frequency and Q are smoothed over 128 samples to prevent clicks during modulation.

Freq Mod overrides the Frequency property when connected (ControlFreq, value in Hz, clamped to 20-20,000 Hz). The CV fully replaces the knob value.

Chain several allpass filters in series to build a phaser. Place one in a feedback delay loop for dispersive reverb tails.

Amp Envelope

Amplitude envelope — shapes audio volume with a gate-triggered envelope

Combined envelope generator and VCA. Multiplies an audio input by a gate-triggered envelope curve, replacing the Envelope-into-VCA two-node pattern.

The Depth knob scales the envelope level before it is applied to the audio. DepthMod multiplies with Depth (disconnected defaults to 1.0), so effective depth = Depth * DepthMod. The Env output carries the effective envelope value clamped to 0.0-1.0 for downstream modulation. With no audio input connected, Audio Out produces silence but the envelope still advances.

Automation Curve

Transport-synced drawn curve for parameter automation

Transport-synced modulation source driven by a user-drawn keyframe curve. Evaluates against the beat timeline to produce parameter automation across six output formats.

The curve position is derived from the transport beat, looping over the configured bar length. Position input overrides the transport playhead when connected (0.0 = curve start, 1.0 = curve end). Depth input scales all outputs (disconnected defaults to 1.0). Frequency outputs use log-scale mapping between FreqMin and FreqMax. VOct is derived from the same frequency mapping relative to middle C (261.63 Hz). Gate goes high when the depth-scaled curve value reaches 0.5.

Biquad Filter

Second-order IIR filter with multiple types

Second-order IIR filter with seven modes: lowpass, highpass, bandpass, notch, peak, low shelf, and high shelf.

True stereo with independent filter state per channel — no crosstalk. All parameters are smoothed over 128 samples to avoid clicks during modulation.

Cutoff Mod overrides the Frequency property when connected (ControlFreq, value in Hz). Q Mod overrides the Q property (ControlNorm, 0.0-1.0 mapped linearly to Q 0.1-20.0). Both CV inputs fully replace the knob value — there is no additive modulation.

Gain only affects Peak, Low Shelf, and High Shelf modes. For LP/HP/BP/Notch it has no effect.

Chorus

Multi-voice chorus effect with LFO modulation

Multi-voice chorus with LFO-modulated delay lines. Thickens and widens the input by mixing it with detuned, time-varying copies.

Each voice has its own sine LFO with a phase offset evenly distributed across the cycle and a rate that increases by 10% per voice (voice 0 = base rate, voice 1 = 1.1x, etc.). Base delay also staggers by 3 ms per voice. The output is the average of all voices mixed with the dry signal. No feedback path, so the effect stays clean. RateMod CV uses an exponential 0.1..10 Hz mapping; DepthMod maps linearly to 0..20 ms; both replace the property value when connected.

Comb Filter

Short delay with feedback for metallic resonances, flanging, and bell tones

Comb filter with feedback, feedforward, and combined modes. A short tuned delay line that reinforces harmonics of its fundamental frequency, producing metallic resonances, bell tones, and Karplus-Strong-style plucks.

True stereo with independent delay buffers per channel. The delay line uses linear interpolation for fractional sample lengths. Frequency, feedback, and mix are all smoothed to prevent clicks.

Frequency Mod accepts both ControlFreq (direct Hz) and V/Oct inputs. V/Oct is relative to the Frequency property (0 = unison, +1 = octave up). If both types are connected, V/Oct takes priority.

Feedback Mod overrides the Feedback property. ControlNorm 0.0-1.0 is scaled to 0.0-0.99.

Damping places a one-pole lowpass in the feedback path. Higher values darken the decay — simulates string damping for physical modeling. Only affects Feedback and Both modes.

Compressor

Dynamic range compressor with optional sidechain

Dynamic range compressor with stereo-linked detection. Reduces the volume of signals that exceed the threshold, taming peaks and adding punch.

When the Sidechain input is connected, compression is keyed from that signal (converted to mono) instead of the main audio. The Sidechain takes full priority — there is no blend between internal and external detection. Use this for ducking (kick→bass) and pumping effects.

Threshold Mod overrides the Threshold property when connected. The CV is scaled linearly: 0.0 maps to -60 dB, 1.0 maps to 0 dB. The override is smoothed to prevent clicks.

GR Out reports the maximum gain reduction across L/R channels, normalized so 60 dB of reduction reads as 1.0.

DeClicker

Active click and pop removal via derivative detection and interpolation repair

Active click and pop removal via derivative-based detection and interpolation repair.

Incoming audio is delayed by Lookahead samples through a ring buffer. First- and second-order derivatives are computed per sample; spikes exceeding the Threshold are marked as damaged. If a consecutive damage run exceeds the Sensitivity duration cutoff (Gentle=2, Normal=4, Aggressive=8 samples), it is classified as a musical transient and left untouched. Damaged regions within the cutoff are repaired using Hermite or linear interpolation from the surrounding undamaged context. The Monitor output carries only the removed material (original minus repaired) for audible verification. The Gate output pulses high whenever clicks are detected in a buffer.

Delay

Audio delay with optional time modulation

Stereo delay line with feedback and wet/dry mix. Creates echoes and repeats of the input signal.

Feedback feeds the delayed output back into the delay buffer (input + delayed * feedback), producing decaying repeats. The range is capped at 99% to prevent runaway oscillation, but values above ~90% sustain almost indefinitely. Delay time changes are smoothed over 256 samples to avoid pitch glitches from read-head jumps; connect a slow CV source to the DelayTimeMod port for chorus and vibrato effects. When the DelayTimeMod CV is connected it replaces the property value directly (in seconds), while FeedbackMod and MixMod scale their respective ControlNorm 0..1 ranges into the parameter range.

Distortion

Waveshaping and harmonic distortion with multiple types

Waveshaping distortion with seven selectable algorithms. Drive pushes the signal into saturation; tone and mix shape the final character.

The signal is multiplied by Drive before entering the selected waveshaper. Algorithm differences: HardClip clips at +/-1.0 (harsh, buzzy); SoftClip and Tanh both use soft_clip (smooth saturation); Tube uses asymmetric tube simulation; Fuzz doubles the drive into soft_clip for aggressive saturation; Wavefold folds the signal back at +/-1.0 (adds dense upper harmonics); Bitcrush quantizes to the Bits setting (lo-fi, stepped). The Bits property only affects the Bitcrush algorithm. DriveMod CV maps 0..1 to 1..20x drive; MixMod maps 0..1 directly to wet/dry.

Envelope

ADSR envelope generator

General-purpose gate-triggered envelope generator. Outputs the envelope level as a stereo audio signal for use as a VCA control or any parameter modulation source.

The envelope shape is drawn via keyframes and tangents, with an optional hold point that sustains the level while the gate is held. Gate rising edge triggers attack from the start of the curve; falling edge triggers release from the hold point onward. The envelope advances per sample for smooth output.

Filter

One-pole lowpass filter with cutoff modulation

Simple one-pole lowpass filter. Smoothly attenuates frequencies above the cutoff with a gentle 6 dB/octave slope.

True stereo with independent filter state per channel. The cutoff is smoothed to prevent clicks during modulation.

Cutoff Mod overrides the Cutoff property when connected (ControlFreq, value in Hz). The CV fully replaces the knob value — there is no additive modulation. When disconnected, the property value is used.

For steeper filtering or resonance control, use the Biquad Filter.

Flanger

Short modulated delay with feedback — classic flanger effect

Classic flanger effect. A short delay modulated by a sine LFO and fed back into itself, producing a sweeping comb-filter tone.

The modulated delay time equals base_delay * (1 + LFO * depth), clamped to the 10 ms hardware maximum. Feedback feeds the delayed output back into the delay buffer (input + delayed * feedback). Negative feedback values invert the signal before feeding back, shifting the comb peaks to produce a hollower, more nasal character. No CV modulation inputs; use the property controls. No parameter smoothing, so abrupt changes to delay or rate may click.

Granular

Live granular effects processor with freeze and pitch control

Live granular effects processor. Records audio into a circular buffer and spawns overlapping grains that read back from configurable positions with pitch shifting and stereo spread.

Grains are scheduled at the Density rate (Hz). Each grain reads from Position (0 = most recent, 1 = oldest) in the circular buffer, with Jitter randomizing position, size, and pitch per grain. Grains use linear interpolation for fractional read positions and a morphable window envelope (Texture: 0 = rectangular, 0.5 = Hann, 1.0 = narrow Gaussian). The Freeze gate stops buffer recording so grains read from a frozen snapshot; unfreezing resumes recording from where the write head left off. Active grains are averaged (not summed) when more than one is playing. CV inputs are additive offsets to the property values, not replacements. PitchMod is ControlBipolar and scales by the full +/-24 semitone range.

LFO

Low-frequency oscillator for modulation

Low-frequency oscillator for cyclic modulation of any parameter. Produces synchronized outputs in multiple formats: audio, normalized, bipolar, and gate.

FrequencyMod overrides the Frequency knob entirely when connected (it does not add to it). DepthMod overrides the Depth knob's smoother target when connected. All outputs are scaled by the effective depth. The Gate output goes high on the positive half of the waveform cycle.

Low-Pass Gate

Combined VCA + lowpass with vactrol-style decay — Buchla LPG

Combined VCA and lowpass filter with vactrol-style decay. The Buchla signature sound: strike it with a gate and it opens briefly, then closes with an organic, woody decay.

A gate rising edge snaps the internal vactrol level to 1.0. It then decays exponentially, with a sqrt curve applied to model the fast-open, slow-close photoresistor response. The CV Level input can also drive the vactrol; it takes the maximum of the current vactrol level and the CV value, so holding CV high keeps the gate open. VCA Amount controls how much the vactrol affects amplitude (0 = unity gain, 1 = full gating). LPF Amount controls cutoff sweep depth; the cutoff tracks the vactrol level on a log scale from 20 Hz to just below Nyquist. With both VCA and LPF at 1.0 the sound starts bright and loud, then dims and quiets together.

Phaser

Multi-stage allpass sweep — classic phaser effect

Multi-stage phaser effect. Chains allpass filters whose center frequency sweeps via an internal LFO, carving moving notches through the spectrum.

The LFO sweeps logarithmically between MinFreq and MaxFreq, scaled by Depth. The allpass chain output feeds back into its own input (input + chain_output * feedback) to deepen the notches. More stages produce more notches; the step size is 2 so the count is always even. RateMod CV scales the base rate multiplicatively: effective_rate = rate * (1 + cv * 4), so at CV=1.0 the rate is 5x faster.

Pitch Envelope

Gate-triggered frequency sweep for percussive pitch control

Gate-triggered frequency sweep for percussive pitch effects. Outputs ControlFreq directly, eliminating the need for an Envelope into a frequency mapper chain.

The drawn curve maps 0.0 to StartFreq and 1.0 to EndFreq using log-space interpolation for perceptually even pitch movement. The default curve fires a fast attack to EndFreq then decays back to StartFreq with no hold point (fire-and-forget). The envelope is sampled once per buffer, not per sample.

Reverb

Room simulation reverb with Schroeder algorithm

Schroeder reverb with true stereo output. Simulates room reflections from tight rooms to vast halls.

The input is downmixed to mono before entering the reverb engine. Parallel damped comb filters produce late reflections, then series allpass filters add diffusion. Left and right channels use decorrelated delay lines for stereo imaging, controlled by the Width parameter. Pre-delay inserts a fixed gap between the dry sound and the onset of the reverb tail; changing pre-delay or room size rebuilds the internal filter network (may click during live adjustment). CV inputs for room size, damping, and mix all replace the property value directly via smoothers.

Ring Modulator

Carrier × modulator ring modulation with dry/wet mix

Ring modulator -- multiplies a carrier and modulator signal together, producing sum and difference frequencies for inharmonic, bell-like, or robotic timbres.

Both Carrier and Modulator audio inputs are required; disconnecting either silences the output. The wet signal is carrier * modulator (per-channel); the Mix control crossfades between the dry carrier and the ring-modulated result. Unlike SignalMath's Multiply mode, this node provides explicit carrier/modulator labeling and a dedicated dry/wet mix.

Sample Rate Reducer

Lo-fi aliasing effect — reduces effective sample rate

Lo-fi aliasing effect that reduces the effective sample rate by holding each input sample for multiple output cycles.

Uses a phase accumulator: the input is sampled only when the phase wraps past 1.0, then that value is held until the next wrap. This creates staircase artifacts and harsh aliasing distinct from bitcrushing. The RateMod CV scales linearly from 100 Hz (at cv=0) to the configured target rate (at cv=1), replacing the property value when connected.

Transient Shaper

Independent attack and sustain gain reshaping

Reshapes the attack and sustain portions of a signal independently. Boost the attack to add punch, or pull it back to soften transients.

Uses dual envelope followers per channel: a fast follower (~1 ms attack) that catches transients, and a slow follower (4x the Speed setting) that tracks the sustain level. The difference (fast - slow) isolates the transient component. Each sample's gain is a weighted blend of the Attack and Sustain gains based on the transient ratio. Both gain controls are in dB and converted to linear internally. No CV modulation inputs. Speed affects both the fast follower's release and the slow follower's time constant, so increasing it widens the transient detection window.

Vocoder

Channel vocoder — spectral envelope transfer from modulator to carrier

Channel vocoder that transfers the spectral envelope of a modulator onto a carrier signal, producing the iconic robot-voice effect.

The modulator (voice, drums) is split into frequency bands; an envelope follower on each band extracts how loud that frequency region is. Those envelopes are applied to the same bands of the carrier (synth, noise), so the carrier "speaks" with the modulator's tonal shape.

Both inputs are required. Without a modulator the output is silence because the envelope followers produce zero. A carrier alone produces nothing — the modulator's envelope gates it.

Sibilance detection measures the energy ratio of the top quarter of bands to the total. When high-frequency energy dominates, unfiltered modulator audio is blended into the output, preserving consonant sounds like "s", "t", and "sh" that the band filters would otherwise smear.

The Freq Tilt curve applies per-band gain using a log-frequency axis (20 Hz to 20 kHz). Each band's center frequency is mapped onto this curve. A rising curve brightens the output; a falling curve warms it.

fBm Noise

Fractal Brownian Motion noise — organic modulation source

Fractal Brownian Motion noise source for organic, evolving modulation. Sums multiple octaves of smooth value noise to produce natural-feeling movement.

Audio and control outputs are the raw fBm value scaled by Amplitude. RateMod maps 0.0-1.0 to a 1x-4x rate multiplier (exponential via 2^(mod*2)); disconnected defaults to 1x. Gate rising edge jumps to a new region of the noise field (each retrigger lands at a different position). The Gate output goes high on the positive half of the noise signal.

Bipolar Knob

Constant ControlBipolar (-1..+1) source — dial a value and patch it

Bipolar knob that outputs a constant value in the -1..+1 range.

The value is set via the on-node slider, a property change, or a ControlKnobCommand from the UI. The output is written every process() call as a ControlBipolar. A state snapshot is sent back to the UI each frame for the custom renderer.

Control Knob

Constant ControlNorm (0..1) source — dial a value and patch it

Unipolar knob that outputs a constant value in the 0..1 range.

The value is set via the on-node slider, a property change, or a ControlKnobCommand from the UI. The output is written every process() call as a ControlNorm. A state snapshot is sent back to the UI each frame for the custom renderer.

Control Panel

Configurable bank of labeled control and gate outputs with per-channel type selection

Configurable bank of labeled control and gate outputs. Each channel independently selects its type via an inline dropdown on the node face.

Uses custom topology -- output port count and types are dynamic. Control-type channels produce one ControlNorm, ControlBipolar, or Control port. Gate-type channels produce a Gate + Velocity (ControlNorm) port pair. Changing a channel's kind or adjusting the channel count triggers a port remap that the editor uses to rewire existing connections. Gate edge events are emitted only on state transitions (toggled on/off via SetToggle or pad press/release via SetGate). Always processes so initial state reaches the UI even without downstream connections.

Control Source

Constant Control (unbounded) source — for tempo, delay time, or any raw value

Unbounded control source that outputs a raw floating-point value.

Unlike the normalized knobs, this carries real-world units (BPM, milliseconds, semitones, etc.). The value is not clamped on set; ControlKnobCommand writes the raw float directly. The output is written every process() call as a Control value. Min and max config fields exist for UI display hints but do not constrain the output.

Gate Button

UI-controlled gate source with momentary and toggle modes. Outputs velocity on a separate control port.

Manual gate source with momentary and toggle modes. Click or hold the button to fire a gate signal; velocity is output on a separate control port.

Two input paths: UI commands (SetGate) set the gate directly with velocity 1.0, while MIDI-style property writes (Gate property) follow a toggle state machine. On a rising edge, if the value >= ToggleThreshold the gate latches on; below threshold it acts as momentary (gate follows press/release). A second press while latched marks the gate for unlatch on release. The Velocity output holds the press value while the gate is high and resets to 0.0 on gate-off. Gate edge events are emitted only on state transitions.

Keyboard

Interactive MIDI keyboard with monitoring and visualization

Interactive 88-key MIDI keyboard that generates and monitors MIDI note events with optional visual effects.

Operates in three modes depending on connections: generator (no MIDI In -- UI clicks produce notes), monitor (MIDI In connected -- input events are visualized and passed through), or hybrid (both). In Hold mode, clicking a key latches it on; clicking again toggles it off. Latched keys persist across save/load via the held_notes config. When Hold is active and MIDI In is connected, incoming note-offs for UI-latched keys are suppressed in both the visualization and the MIDI output. Disabling Hold clears all latched notes immediately. Visual effects (particles, fire, etc.) are selected per-node and reported to the UI each frame alongside active key state.

Patch Input

Source node inside a patch — data injected by PatchInstance

Entry point for signals coming into a patch. Lives inside the patch's inner graph and exposes one output per port defined on the patch interface.

Has no audio-thread inputs of its own. Before each inner-graph pull, PatchInstanceNode calls inject() to stage port data from the parent graph. process() then copies the staged data to outputs. Uses custom topology -- output count and types are derived from the ports config, which can be mutated at runtime via PatchInputCommand (add, remove, rename, reorder ports).

Patch Instance

Instantiated patch — contains a nested subgraph

A single node in the parent graph that encapsulates an entire subgraph, making the patch behave like one composite node.

Each process() call runs a four-phase cycle: (1) collect parent input port data and inject it into the inner PatchInputNode, (2) advance the inner engine's time via process_subgraph, (3) pull the inner PatchOutputNode to drive inner-graph processing, (4) extract captured output data and copy it to this node's outputs. Uses custom topology -- input and output port counts and types mirror the PatchInterface definition. The inner engine's default AudioSink is removed on setup since PatchOutput serves as the pull target. If the inner engine, PatchInput ID, or PatchOutput ID is missing, process() returns immediately with no output.

Patch Output

Sink node inside a patch — data extracted by PatchInstance

Exit point for signals leaving a patch. Lives inside the patch's inner graph and exposes one input per port defined on the patch interface.

process() captures all input port data into a staging buffer. After the inner-graph pull, PatchInstanceNode calls extract() to retrieve the captured data and copy it to the parent graph's outputs. The Sink output port serves as the pull target for the inner graph engine (same pattern as AudioSink). Uses custom topology -- input count and types are derived from the ports config, mutated at runtime via PatchOutputCommand.

ABC File Loader

Loads ABC notation files and converts to sequencer configuration. Supports file paths or raw ABC text.

Loads ABC notation and produces a MidiSequencer on its output for downstream playback.

Accepts an AbcSource (file path or raw text), a ConstantValue file path, or a full AbcFileLoaderConfig via the Config input. When no Config input is connected, falls back to the embedded source property. Parsing only runs when the config changes (detected via a string key). The Sequencer Out streams the cached MidiSequencer every frame. Timing Out carries BPM and time signature extracted from the ABC notation.

Arpeggiator

Converts held MIDI notes into arpeggiated patterns

Turns held MIDI chords into rhythmic arpeggiated patterns using an internal sample-accurate clock.

Feed it notes and it cycles through them at a configurable rate with selectable direction (up, down, up-down, random), octave range, gate length, and swing. Uses NoteOn velocity=0 as NoteOff. The internal clock derives step timing from the Rate property; swing delays every other step by a fraction of the step duration. Gate length determines when each note-off fires within the step. The Reset input resets the arpeggiator to the first note and kills any currently sounding note. With Latch enabled, notes remain in the pattern even after key release -- new notes replace the latched set. All output MIDI is on channel 1.

Arranger

Song arrangement with per-track ControlNorm outputs for enabling/controlling downstream nodes

Song-level arrangement player that outputs per-track level controls synchronized to the graph transport.

Receives an Arrangement via Config In and advances a tick-based playhead. Each arrangement track maps to an unbounded ControlNorm output: the value is the region's level (0.0--1.0) when the playhead is inside a region, otherwise 0.0. Muted, disabled, or non-soloed (when any track is soloed) tracks output 0.0. The Timing input overrides BPM; tempo changes reset the sample accumulator. Enabled gate (disconnected = enabled) forces all outputs to 0.0 when low. Transport seek events resync the tick position. Loop wraps to the start when the arrangement ends. The End gate pulses on loop or completion. Hot-swapping the Config input preserves playhead position and state. Tracks property sets a floor on output count; it also grows to match the arrangement's track count.

Arranger Editor

Visual arrangement editor. Click to open arranger panel.

Visual editor for song-level arrangements.

Holds the authoritative Arrangement data (tracks, regions, tempo, time signature) and outputs it via Data port to an Arranger node each frame. The UI sends incremental ArrangerCommand edits (add/remove/move regions, track management, BPM, time signature, loop) through the message bus. In-flight regions (being dragged) are tracked but do not block region output. The Update gate pulses whenever an edit is applied. Timing output carries BPM and time signature. The Import input accepts an external Arrangement for future import support.

Chord Generator

Generates chords from single MIDI notes

Harmonizer that turns single MIDI notes into full chords.

Each incoming note-on becomes the root of a chord built from the selected type (major, minor, seventh, etc.) with configurable voicing and inversions. On note-off, all chord tones for that root are released. Non-note MIDI messages pass through unchanged. Active chords are tracked per root note, so multiple simultaneous roots produce independent chords. Notes are clamped to 0--127 after transposition; inversions raise lower tones by an octave. Open voicing raises inner tones +12; Drop-2 lowers the second-from-top tone by 12. Third inversion only has an effect on seventh chords or larger.

Chord Progression

Per-layer curve-driven chord progression generator with polymetric support

Generates chord progressions with per-layer curves for tension, velocity, and style.

Each layer defines its own bar count and chords-per-bar, enabling polymetric progressions. Generation blends user-drawn curves with fBm noise (controlled by the Mix knob) to select chord degree, velocity, and voicing style per chord slot. Generation runs on a background thread -- property changes queue a request (when auto-regen is enabled) and only the latest request is processed. Connect Sequencer Out to a Sequencer Editor to import and edit the result. The Loaded gate pulses once after each completed generation triggered by the Regenerate command. The Timing input overrides BPM and time signature from the transport.

Generative Melody

Marbles-style clocked random note/gate generator with scale quantization

Clocked random note and gate generator with scale quantization, inspired by Mutable Instruments Marbles.

Each rising edge on the Clock input generates a new pitch from a bell-curve distribution shaped by Bias (center) and Spread (width), quantized to the selected scale. Gate density controls the probability that a clock step produces a note; gate length sets the duration as a fraction of the measured clock period. Jitter adds random timing offset to gate events. The Lock parameter controls sequence recall: at 0.0 every step is fully random; at 1.0 the cached sequence replays deterministically. Intermediate values probabilistically replace cached steps. The cache size equals the Steps property. Bias, Spread, and Density can be modulated via CV inputs that override the corresponding properties. VOct output is constant across the buffer (updated on each clock step). The Tuning port overrides 12-EDO divisions and applies a V/Oct offset.

Lookahead Sequencer

MIDI sequencer with lookahead for visualization and practice features

MIDI sequencer with a lookahead window for score visualization and practice features.

Plays back a MidiSequencer with sample-accurate timing while also computing upcoming notes (1--16 bars ahead) that the UI renders as a grand staff or scrolling notation. The Timing input overrides BPM from the transport. An optional count-in metronome plays before the sequence starts. The lookahead buffer is sent to the UI via poll_response each process cycle. Config In accepts a MidiSequencer from a file loader or sequencer editor; when first loaded the sequence auto-plays. The Restart gate restarts from the beginning; End of Sequence pulses when the sequence finishes.

MIDI Channel Splitter

Routes MIDI events by channel to separate outputs. Each output receives events from one MIDI channel.

Demultiplexes a multi-channel MIDI stream into separate per-channel outputs.

Each event is routed to the output matching its MIDI channel (channel 0 to output 0, channel 1 to output 1, etc.). Events on channels beyond the configured output count are silently dropped. The number of outputs is controlled by the Channels property and capped at 16.

MIDI File Loader

Loads Standard MIDI Files and converts to sequencer configuration. Supports file paths or raw bytes with optional tempo override.

Loads a Standard MIDI File (.mid) and produces a MidiSequencer on its output for downstream playback.

Accepts a MidiSource (file path or raw bytes), a ConstantValue file path, or a full MidiFileLoaderConfig via the Config input. When no Config input is connected, falls back to the embedded source and tempo properties. An optional tempo override rescales all event timestamps proportionally (original_tempo / new_tempo). Parsing only runs when the config changes (detected via a string key including tempo). The Loaded gate pulses once when a file is successfully parsed. Timing Out carries BPM and time signature from the loaded file.

MIDI Input

Receives MIDI events from a virtual MIDI device

Receives live MIDI from a hardware controller or virtual port via the MIDI Device Manager pub/sub system.

Set the Device property to a VirtualDeviceId to subscribe; the audio thread establishes the subscription and injects a crossbeam receiver. Events are drained from the receiver each process cycle. System messages (clock, start, etc.) always pass through; channel messages are filtered by the Channel property (0 = all). When Device is 0 (none) the node produces no output. Changing the Device property clears stale subscriptions immediately.

MIDI Mixer

Merges multiple MIDI input streams into a single output stream.

Merges multiple MIDI streams into a single time-ordered output.

All events from all connected inputs are collected, sorted by sample offset, and written to a single output buffer. The number of input ports is controlled by the Inputs property and also grows dynamically via topology overrides as cables are connected.

MIDI Remap

Remaps MIDI channel, transposes notes, scales velocity, and filters note range

MIDI transformer that remaps channels, transposes notes, scales velocity, and filters by note range.

Processing order: source channel filter, then transpose, then note range filter, then velocity scale, then target channel remap. Events that fail the source channel or note range filters are silently dropped (not passed through). Transpose is applied to NoteOn, NoteOff, and polyphonic Aftertouch messages. Velocity scaling clamps to 1--127 (never produces velocity 0). Non-note messages (CC, pitch bend, etc.) pass through with only channel remapping applied.

MIDI Sample & Hold

Latch polyphonic MIDI note state on gate trigger

Latches polyphonic MIDI note state on each gate trigger.

In Trigger mode, incoming MIDI notes are tracked silently via MidiNoteTracker. On each Trigger rising edge, the tracker diffs the current input state against the held output state and emits the minimal note-off/note-on set to transition cleanly. Between triggers the output holds the captured snapshot -- stuck notes are impossible because the tracker manages all diffing. The Reset input flushes all held notes (all note-offs). In Pass mode, events pass through transparently (bypass). Disconnecting the MIDI input flushes the tracker silently. Max Notes limits the snapshot size; oldest notes are dropped when full.

MIDI Voice Splitter

Splits polyphonic MIDI into monophonic voices. Voice count determined by connected outputs.

Splits polyphonic MIDI into separate monophonic voice outputs with oldest-note voice stealing.

Each NoteOn is assigned to the first idle output; when all outputs are busy, the oldest voice is stolen (NoteOff sent before the new NoteOn). NoteOff is routed to whichever output holds that note. Non-note messages (CC, pitch bend, etc.) are broadcast to all outputs. All output events are on channel 1 regardless of the input channel. The Voices property controls the number of outputs.

MIDI ➔ CV

Converts MIDI notes to VOct pitch CV and gate signals

Converts MIDI note events into modular-style CV signals for driving oscillators, envelopes, and modulation sources.

Outputs volt-per-octave pitch, a gate, normalized velocity, channel/poly aftertouch, and mod wheel (CC 1). In Last mode every note passes through (classic mono last-note priority with note stack -- releasing a note restores the previous pitch). In Exclusive mode the node claims one note at a time and strips it from the Thru output; chain several Exclusive nodes for manual polyphonic voice allocation. The Channel MIDI output always carries all channel-matched events regardless of voice mode. Non-note events (CC, aftertouch) are never claimed in Exclusive mode and always appear on Thru. When the Tuning port is connected it overrides divisions-per-octave and applies a V/Oct offset to the pitch output.

Polysynth

Polyphonic MIDI synthesizer with configurable waveform and envelope

Self-contained polyphonic synthesizer that receives MIDI and outputs stereo audio directly.

Up to 8 simultaneous voices, each with its own oscillator and ADSR envelope. Voice allocation prefers idle voices; when all are busy the oldest active voice is stolen with velocity smoothing and a cosine fade-in to prevent clicks. NoteOff is reference-counted: if the same note is triggered multiple times it only releases when all matching note-offs arrive. Output is the sum of all voices divided by max_voices, then scaled by Master Gain. Disconnecting the MIDI input releases all active voices. The Tuning port overrides 12-EDO divisions and applies a V/Oct offset.

Polysynth V2

Polyphonic MIDI synthesizer with configurable waveform and envelope

Polyphonic synthesizer with up to 16 voices and smooth frequency crossfades on voice steal.

Same voice allocation strategy as Polysynth (idle-first, then oldest-note steal) but adds a 16-sample linear crossfade when stealing to smooth frequency discontinuities. Voices are re-initialized at the audio thread's actual sample rate in setup(). NoteOff is reference-counted. Output is the sum of all voices divided by voice count, then scaled by Master Gain. Disconnecting the MIDI input releases all active voices. The Tuning port overrides 12-EDO divisions and applies a frequency offset at note-on time.

Scale Quantizer

Quantizes MIDI notes to a musical scale

Snaps MIDI note pitches to the nearest degree in a selected musical scale.

NoteOn pitches are quantized and the original-to-quantized mapping is cached for the corresponding NoteOff, so note-offs always match their note-ons. Changing the Scale or Root Note property flushes all active notes (sends note-offs on channel 1 at sample offset 0) before clearing the mapping cache. Non-note messages pass through unchanged. Snap mode determines the quantization direction: Nearest picks the closest scale degree, Up always rounds up, Down always rounds down. The mapping cache avoids recomputing scale lookups for repeated pitches.

Sequencer

MIDI sequencer that outputs timed MIDI events. Uses graph transport for tempo and play state.

MIDI playback engine synchronized to the graph transport.

Receives a MidiSequencer via Config In and plays back timed MIDI events. The merged MIDI Out carries events with their original channel assignments; per-track outputs (unbounded) carry the same events remapped to channel 1. Tempo comes from the Timing input when connected, otherwise from the graph transport; tempo changes flush stuck notes. The Enabled gate (disconnected = enabled) gates playback and flushes notes on transitions. Restart resets the playhead; Reload hot-swaps the config without resetting position. When Reload is not connected, Config In is polled continuously. Transport seek events cause an immediate seek-and-flush. Loop wraps playback to the loop region when enabled; if loop_end is at the default it auto-extends to cover the entire sequence. The Tracks property sets a floor on output count -- it also grows to match the loaded sequence's track count.

Sequencer Editor

Visual MIDI sequencer editor with piano roll interface. Click to open editor panel.

Visual MIDI sequencer editor with a piano-roll interface.

Holds the authoritative MidiSequencer state and outputs it via Data port to a Sequencer node each frame. The UI sends incremental SequencerCommand edits (add, move, resize, delete notes; track mute/solo/channel changes; BPM and time signature updates). The node maintains a note_map as the single source of truth and rebuilds track MIDI events from it. In-flight notes (being dragged) are excluded from events until they land. The Import input accepts a MidiSequencer from an external source (file loader, chord progression); use the ImportFromInput command to merge it. Audition MIDI (note preview during editing) is output on the MIDI Out port on the configured audition channel. The Update Gate pulses whenever an edit is applied. Timing output carries BPM and time signature from the editor's properties.

Voice Mixer

MIDI-controlled polyphonic mixer with per-voice ADSR envelopes and voice stealing

MIDI-controlled polyphonic voice mixer with per-voice ADSR envelopes and voice stealing.

Allocates MIDI notes to voice slots (idle-first, then oldest-note steal). Each slot gates one unbounded audio input with an independent ADSR envelope, velocity smoothing, and cosine fade-in. All gated voices are summed, divided by the connected voice count (fixed denominator -- not the number of active voices), then scaled by Master Gain. NoteOff is reference-counted. The slot pool resizes dynamically to match the number of connected audio inputs. Disconnecting the MIDI input releases all active slots.

Audio Sink

Audio output point with optional well-known label

Final destination for audio in the graph. Connect any stereo audio source here to route it to the hardware output.

Every graph has exactly one AudioSink that the engine pulls from each buffer cycle. process() copies the stereo input buffer directly to the Sink output with no transformation. If Audio In is disconnected the output buffer is left silent. The Sink port type marks this node as the pull target for the graph engine's demand-driven processing.

Audio Input

Hardware audio capture (microphone, line in)

Captures live audio from a hardware input device (microphone, line in, audio interface) and injects it into the graph.

Device names come from the OS audio subsystem. "Default" uses the system default input. Streams open at stereo regardless of the device's native channel count; multi-channel interfaces route through the OS stereo bus.

Gain uses exponential scaling above unity: 0.0 = silent, 0.5 = unity, 1.0 = +12 dB. Defaults to unity (0.5) when the Gain input is disconnected.

The internal ring buffer holds ~100 ms at 48 kHz. If the graph cannot keep up, the oldest input samples are dropped. This node does not record -- use Audio Looper or Sample Recorder downstream for capture.

Audio Looper

Gate-triggered audio loop recorder with overdub

Gate-triggered loop recorder with multi-layer overdub. Hold Record to capture; the first recording defines the loop length and all subsequent overdubs wrap within it.

Two recording inputs: Record (hold to record, release to stop) and Record Latch (rising edge toggles record on/off for hands-free or foot pedal use). When Record Latch is connected, it overrides the Record gate.

With Layers set to 1, overdubs mix directly into the base buffer. Feedback is applied during playback (not just overdub): at 1.0 the loop plays forever, below 1.0 the buffer decays each pass like a delay line. With Layers > 1, each overdub is stored on a separate layer; Clear removes the most recent layer (undo), and Feedback is ignored to preserve undo integrity.

Freeze holds the current position, sustaining audio as a crossfaded micro-loop around the freeze point. Freeze Scrub picks where in the loop you are frozen (ignored without Freeze). Freeze Width sets the size of the micro-loop window.

Speed uses exponential scaling (0.25x-4x). Reverse plays the loop backwards. Quantize defers record start/stop to the next beat boundary using transport position. Monitor passes input audio through to the output during recording to prevent latency surprise. Max Duration pre-allocates the buffer and cannot be changed while a loop is loaded.

Drone Oscillator

Detuned beating sines for ambient drone textures

Layers multiple tightly-detuned sine waves to produce slow beating and interference patterns — the foundation for ambient pads and drones.

Voices are spread symmetrically around the center frequency with sub-Hz offsets determined by the Beat Rate. For N voices, offsets range from `-beat_rate/2` to `+beat_rate/2` Hz. Warmth blends in a second harmonic (one octave up) at half amplitude per voice. Beat Rate CV maps 0.0-1.0 linearly to 0.01-5.0 Hz and overrides the property. The output is normalized by voice count.

Drum Voice

All-in-one percussion synthesizer with multiple drum modes

All-in-one percussion synthesizer with selectable drum modes. Each mode uses a different internal topology of oscillators, noise, filters, and envelopes tuned for that drum sound.

Triggering: a rising edge on the Gate input or a MIDI NoteOn resets all envelopes, oscillator phases, and filter state. Both trigger sources are additive — either one fires the drum. The voice auto-deactivates when its amplitude envelope completes, zeroing the remaining output buffer for efficiency.

Pitch is the sum of the Pitch property, MIDI note offset (note - 60 in octaves), and the V/Oct input. The combined value maps to a frequency multiplier via 2^pitch, so +1 = one octave up, -1 = one octave down. Decay CV, Tone Mod, and Snap Mod each replace their respective property value when connected (not additive). Drive applies tanh soft clipping with gain ranging from 1x to 9x.

Mode-specific topologies: Kick uses a sine oscillator with pitch sweep plus noise click. Snare combines a sine body with bandpass-filtered noise. Hihat runs white noise through highpass and bandpass filters. Tom is similar to kick but higher pitch and less sweep. Clap fires three rapid bandpass-filtered noise bursts. Rimshot blends two detuned sine oscillators with a noise transient. Cowbell uses two detuned clipped-sine oscillators through a bandpass filter.

FM Operator

Frequency modulation synthesis operator with external modulation and feedback

Single FM synthesis operator that works as both carrier and modulator. Chain operators by connecting one's Mod Out to another's Modulator In for classic DX-style patches.

Audio Out and Mod Out carry the same signal (both scaled by Output Level); use Audio Out for final output and Mod Out for chaining into other operators. Ratio multiplies the carrier frequency to set the operator's actual oscillation frequency. FM Index CV and Feedback CV each add to their respective property values via smoothers. The operator DSP is reconstructed each process call, so property changes take effect immediately. No dedicated Gate input — phase reset is triggered only via MIDI note-on.

Formant Oscillator

Vowel-like sounds via resonant formant filters with morph control

Produces vowel-like vocal sounds by running a carrier waveform through resonant bandpass filters tuned to formant frequencies. Pick two vowel shapes and sweep between them with the Morph knob.

The carrier waveform (Saw, Pulse, or Noise) excites the formant filter bank; Resonance controls how sharp the vowel peaks are. Morph CV adds to the property value, clamped 0.0-1.0, and bypasses the smoother when connected. The Resonance property has no CV input and applies uniformly to all formant bands.

Frequency Control

Constant frequency control source in Hz

Outputs a constant frequency value in Hz as a ControlFreq signal. Use it to drive filter cutoffs, oscillator frequencies, or any parameter that accepts ControlFreq.

Pure source node with no inputs — the output is the Frequency property value written directly to the control port each frame.

Granular Voice

Micro-grain playback with textural, evolving sound

Granular synthesis voice that continuously fills a circular buffer from an internal oscillator or external audio, then spawns overlapping micro-grains from that buffer to produce textural, evolving timbres.

The buffer is always being written to. Grains spawn at a rate set by Density and read from a position relative to the write head (Position = 0 reads the oldest sample, 1 reads the newest). Each grain gets independent randomized pitch offset, stereo pan, and optional reverse playback. The output is the normalized sum of all active grains, divided by the number currently sounding.

Gate (from the Gate port or MIDI NoteOn) resets the write head and spawn accumulator but does not start or stop grain generation — grains run continuously regardless of gate state. MIDI also sets oscillator frequency and emits gate/velocity on the output ports.

When Source is set to Input, the Audio In signal is written into the buffer instead of the internal oscillator. The oscillator frequency is ignored in this mode, but Frequency still affects MIDI-driven pitch tracking on the output.

Harmonic Oscillator

16-partial additive synthesis with spectral tilt and inharmonicity

Additive oscillator with 16 independently controllable sine partials. Sculpt timbres by drawing the harmonic spectrum directly — set each partial's amplitude and frequency ratio via node commands.

Tilt applies a dB-per-octave brightness slope across all partials: positive boosts upper partials, negative attenuates them. Tilt CV maps 0.0-1.0 to the full -1.0 to +1.0 range and overrides the property. Stretch shifts partial ratios toward inharmonic spacing using the formula `ratio * (1 + stretch * (ratio - 1) * 0.01)`, so higher partials are displaced more. The output is normalized by the count of active (non-zero amplitude) partials.

Karplus-Strong

Physical modeling of plucked strings using delay line synthesis

Plucked-string physical model using delay line synthesis. A noise burst or impulse excites a tuned delay line that feeds back through a lowpass filter, producing realistic guitar, harp, and bell-like tones.

Trigger via Gate input or MIDI. MIDI NoteOn plucks at the given pitch and passes gate/velocity to the output ports. When both MIDI and V/Oct are connected, MIDI sets the base pitch and V/Oct adds an offset. V/Oct alone multiplies the Frequency property. ControlFreq directly sets frequency in Hz. Pitch is locked at trigger time in the delay line DSP.

Damping CV maps 0.0-1.0 to the 0.9-0.9999 feedback range. When disconnected, the Damping property is smoothed. Brightness CV is additive with the property value and clamped to 0.0-1.0. When disconnected, it is also smoothed.

Modal Body

Struck body physical model — bells, marimbas, glass, metal, wood

Physical model of struck objects using a bank of damped resonators. Simulates bells, marimbas, glass, metal plates, and wood blocks.

Trigger via Gate input or MIDI. MIDI NoteOn strikes the body at the given pitch and passes gate/velocity to the output ports. When both MIDI and V/Oct are connected, MIDI sets the base pitch and V/Oct adds an offset. V/Oct alone multiplies the Frequency property. ControlFreq directly sets frequency in Hz.

Material, Brightness, Decay, and Inharmonicity are sampled at trigger time to configure the resonator bank. Brightness and Decay CV inputs are evaluated at trigger time; changing them mid-ring does not alter the decay envelope.

Noise Filter Bank

Noise through parallel bandpass filters with per-band envelopes for percussion synthesis

Noise source routed through four parallel bandpass filters, each with its own gain and exponential decay envelope. Designed for metallic percussion: hihats, cymbals, snare noise layers.

On a gate rising edge, all four band envelopes reset to zero and filter state is cleared. Each band runs an independent exponential decay (exp(-5t)) whose duration comes from the preset's per-band decay time multiplied by the Decay Scale property. A band is considered finished when its envelope time exceeds 3.0 (approximately -65 dB). When all four bands have finished, the voice deactivates and zeros the remaining output buffer for efficiency.

The Tone property shifts all four band center frequencies together as a power-of-two multiplier (2^tone octaves). Brightness scales the filter Q values (0.5 + brightness * 2.0), so higher brightness produces tighter, more resonant bands. The output is the sum of all four filtered bands, scaled by the Accent input.

Noise Generator

White, pink, and brown noise generator

Continuous noise source with selectable color. White has equal energy at all frequencies; pink has equal energy per octave (1/f via Voss-McCartney); brown rolls off at 1/f-squared (leaky integrator of white noise).

No MIDI or pitch input — this is a free-running generator. Amplitude CV overrides the property entirely (sets the smoother target to the CV value, ignoring the knob). When disconnected, the smoothed property value is used.

Organ

Hammond-style drawbar organ with 9 harmonics and key click

Hammond-style tonewheel organ with nine drawbar harmonics and optional key click. Each drawbar controls the level of a sine partial at a specific footage ratio (16' through 1').

Gate and MIDI note-on both reset the internal oscillator phases and trigger the key click transient (edge-triggered). Key Click CV adds to the property value, clamped 0.0-1.0; it bypasses the smoother when connected. Drawbar levels are integers 0-8 mapping to the traditional Hammond registration scale.

Oscillator

Waveform generator with frequency modulation

General-purpose waveform generator with sine, saw, square, triangle, and pulse shapes. Use as a sound source, LFO, or modulator.

Pitch priority: MIDI sets the base pitch and VOct offsets it; VOct alone scales the Frequency knob exponentially; ControlFreq overrides the knob with an absolute Hz value. Detune applies on top of all three as an exponential octave offset. Gate and MIDI note-on both reset phase on the rising edge (edge-triggered, not level-sensitive). Gate Out and Velocity Out only emit when MIDI is connected.

Phase Distortion

CZ-style phase distortion oscillator — saw, square, resonant, pulse timbres

Casio CZ-style oscillator that warps a sine wave's phase to produce saw, square, resonant, and pulse timbres from a single core. Sweep the Depth knob from zero (pure sine) to full for dramatically changing harmonic content.

Depth CV adds to the property value and clamps to 0.0-1.0; when disconnected the smoothed property value is used. The Mode selector chooses the phase transfer function — each mode produces a different harmonic structure at the same depth setting.

Sample Player

Gate-triggered sample playback with stereo output

Gate-triggered sample playback from the project library. Supports one-shot and looping modes with adjustable start/end points and pitch control.

Samples are borrowed from the resource cache each process call, so hot-swapped samples are picked up automatically. Stereo samples produce true stereo output; mono samples are duplicated to both channels. Linear interpolation is used between sample frames.

The Sample data input overrides the Sample property when connected. The Pitch input controls playback speed as a multiplier (1.0 = normal, 2.0 = double speed/octave up); negative values play in reverse. Defaults to 1.0 when disconnected.

Sample Recorder

Records audio input to the project sample library

Records audio input into the project sample library. Gate-on starts recording, gate-off saves the result. Can be inserted inline without breaking the signal chain -- audio passes through unchanged to the Thru output.

Create mode adds a numbered sample each recording (e.g. "recording_001"). Overwrite mode replaces an existing sample by key. The Sample data input overrides both mode and target property: when connected, recordings always overwrite that key regardless of mode setting.

Audio is downmixed to mono internally before saving. Recording auto-stops when Max Length is reached.

Shepard Tone

Continuously ascending/descending pitch illusion

Creates the auditory illusion of a pitch that rises (or falls) forever. Multiple sine voices spaced one octave apart are faded with a Gaussian window centered on the mid-range, so entering and leaving voices are inaudible.

The sweep position advances continuously in octaves and wraps at 1.0 (one full octave cycle). Each voice's frequency is `base_freq * 2^(voice_index + sweep_position)`. The Spread property controls the Gaussian window width in octaves — smaller values create a narrower audible band. Speed CV maps 0.0-1.0 linearly to 0.01-2.0 oct/s and overrides the property. Gate and MIDI note-on both reset sweep position and all phases.

Spectral Painter

Image-based drawable spectrogram — outputs spectral data

Drawable spectrogram that converts painted pixel brightness into spectral magnitude data. Paint directly on the canvas in the UI to sculpt frequency content over time.

Each image column represents one spectral frame. The playhead advances with the transport, stepping one column per rows-per-beat subdivision, so timing is tempo-synced. Pixel Y maps to frequency on a logarithmic scale (bottom = 20 Hz, top = Nyquist). Pixel brightness (max of RGB channels) maps through a -90 dB to 0 dB range into linear magnitude.

When the Position CV is connected, it overrides the transport-driven playhead — the CV value selects the column directly as a normalized position across the canvas width. Depth CV scales all output magnitudes (defaults to 1.0 when disconnected).

The Reference input accepts spectral data from another source and renders it as an onion-skin overlay on the canvas, useful for tracing existing sounds. The onion skin can be shifted, captured, and cleared via commands. The canvas pixel buffer is persisted in the project file as an RGBA blob.

Speech Synth

Text-to-speech formant synthesis with enhanced playback features

Formant speech synthesizer based on the SAM (Software Automatic Mouth) engine. Type text and trigger playback with a gate to produce per-sample speech audio.

Gate triggers playback from the beginning. The Loop property auto-retriggers on completion. Gate Out goes high on play start and low on finish; with Loop on, it emits off+on at each loop boundary.

CV modulation inputs (Speed/Pitch/Mouth/Throat Mod) compute effective values without mutating config properties -- property values restore automatically on disconnect. CV maps 0.0-1.0 across the full parameter range.

External oscillator inputs (F1/F2/F3 Osc) replace the built-in oscillator for that formant. SAM still controls amplitude, frequency tracking, and glottal timing.

Scrub overrides linear playback: CV directly sets frame position. An LFO on Scrub creates cyclic vowel scanning. Freeze holds the current frame while oscillator phases and glottal pulse continue running. Freeze Drift adds random formant frequency wobble while frozen, creating evolving pad textures.

V/Oct overrides glottal pitch while preserving formant shapes (vowel identity). Morph crossfades between Text A and Text B frame data (requires both text inputs connected).

Supersaw

Multiple detuned sawtooth oscillators for unison lead and pad sounds

Stack of up to seven detuned sawtooth oscillators for massive unison sounds. The signature trance/EDM lead and pad tone.

Spread sets the total detuning width in cents across all voices; mix crossfades between the center voice alone (0.0) and the full chorus (1.0). When Spread CV is connected it adds `cv * 100` cents to the property value; Mix CV adds directly. Both are clamped to their property range. Pitch priority follows the standard chain: MIDI+VOct combined, VOct alone, ControlFreq, then the Frequency knob.

Sync Oscillator

Hard-sync oscillator — aggressive, harmonically rich lead sounds

Hard-sync oscillator with a master/slave pair. The slave resets its phase every time the master completes a cycle, producing aggressive, harmonically rich timbres. Sweep the ratio for the classic sync-lead sound.

Frequency sets the master pitch; the slave runs at `frequency * ratio`. Ratio CV adds `cv * 15` to the property value, clamped 1.0-16.0, and bypasses the smoother when connected. Gate and MIDI note-on both reset master and slave phases together (edge-triggered).

Wavetable Oscillator

Morphable wavetable oscillator with multiple waveform frames

Scans through a table of stored waveform frames, interpolating between them for smoothly evolving timbres. Sweep the Position knob to morph through the wavetable; connect an audio signal to FM Input for linear frequency modulation.

FM is linear: the FM Input audio value is multiplied by FM Amount (in Hz) and added directly to the current frequency each sample. Position CV adds to the property value and clamps to 0.0-1.0; when disconnected, the smoothed property value is used. Detune is a static cents offset converted via `2^(cents/1200)` and applied as a final frequency multiplier.

Phase Sculptor

Per-bin phase manipulation — scatter, coherence, drift, freeze, transfer, smear

Per-bin phase manipulation with six modes for reshaping spectral phase relationships.

**Scatter**: replaces inst_freq with random offsets (regenerated on Gate rising edge). Destroys pitch, creates diffuse textures. **Coherence**: locks inst_freq to deterministic mathematical patterns (Zero, Linear, Alternating, Quadratic). Creates metallic, robotic, or glassy timbres. **Drift**: adds a slow random walk to inst_freq per bin, creating evolving detuned textures. Rate controls walk speed, Amount limits max offset. **FreezeDrift**: captures magnitudes on Gate rising edge (or Freeze toggle), then applies Drift to the frozen spectrum. Gate toggles freeze state. **Transfer**: crossfades inst_freq toward a Reference spectral input. Holds last received reference when disconnected. **Smear**: blurs inst_freq across neighboring bins using a triangular kernel of Width radius. Amount at 0 bypasses all modes (passthrough). The Amount Mod and Rate Mod CV inputs add to their respective knob values.

Pitch Correct

Auto-tune — pitch detection + scale snapping + spectral correction

Automatic pitch correction (auto-tune). Detects the fundamental pitch via Harmonic Product Spectrum, snaps it to the nearest note in the configured scale, and shifts the spectrum to correct.

Pitch detection runs on the first channel of the last spectral frame. The detected MIDI note is smoothed (0.7 EMA) to filter frame-to-frame jitter, then snapped to the nearest in-scale note. The correction amount is the difference between the snapped target and the smoothed detection. Speed controls convergence: at 0 the correction applies instantly (hard-tune effect), at 1 it glides very slowly (transparent correction). Notes further from the nearest scale tone than Range semitones are left uncorrected. The spectral shift uses the same bin interpolation as Spectral Shift. Detected pitch is output as V/Oct for free pitch tracking. Correction amount is output as bipolar CV (clamped to one semitone).

Spectral Analyze

Audio to spectral data (forward FFT with phase vocoder)

Converts stereo audio into spectral data using forward FFT with phase vocoder analysis. This is the entry point for the spectral processing chain.

Connect the output to any spectral effect, then into Spectral Synthesize to return to audio. FFT Size trades frequency resolution for latency: 512 = ~11 ms, 1024 = ~21 ms, 2048 = ~43 ms, 4096 = ~85 ms at 48 kHz. Higher overlap (4x vs 2x) produces smoother results at more CPU cost. Low Freq and High Freq set the analysis range and are baked into every downstream SpectralBuffer so nodes like Spectral Split and Spectral Rotate inherit them automatically. The analyzer rebuilds when FFT Size or Overlap change.

Spectral Cross

Morph or vocode between two spectral sources

Morphs between two spectral sources. In Blend mode, crossfades magnitudes, phases, and frequencies for smooth timbral transitions. In Vocoder mode, crossfades magnitudes while locking phase and frequency to input B.

Requires both inputs for crossfading. If only one input is connected, that signal passes through unmodified. Both inputs must share the same bin count — a mismatch produces silence with a logged error. Mix at 0.0 gives pure A; at 1.0 gives pure B. The Mix Mod CV input adds to the Mix knob (clamped 0-1). Output Gain is applied to the crossfaded magnitudes. In Vocoder mode, A provides the spectral envelope (magnitude) and B provides the pitch structure (phase + inst_freq), enabling spectral vocoding at full FFT resolution without band quantization.

Spectral Delay

Per-bin frequency-dependent delay with feedback

Delays individual frequency bins independently, creating "frequency waterfall" effects impossible with conventional delay.

Each bin has its own delay line sized from the hop rate. The Time property sets the base delay for all bins. Spread offsets delay time linearly across the spectrum: positive values delay low frequencies more (bin_frac < 0.5 gets added time), negative values delay high frequencies more. Feedback mixes the delayed magnitude back into the delay line tail, building resonant spectral echoes (capped at 0.95 to prevent runaway). Phases and instantaneous frequencies pass through undelayed. The Time Mod CV input scales 0-1 to 0-2 seconds and adds to the Time knob. Delay lines rebuild whenever the upstream bin count or channel count changes.

Spectral Denoise

Noise profile capture + spectral subtraction

Removes steady-state noise via spectral subtraction. Capture a noise profile during a noise-only passage, then the node continuously subtracts that profile from the signal.

Workflow: connect Signal, optionally connect Reference, trigger Learn Gate (or toggle Learn) during noise-only audio, then release to apply. The noise profile is accumulated using EMA smoothing from the Reference input — or from Signal if Reference is disconnected. Subtraction always applies to Signal. Each bin's magnitude is reduced by (noise_profile * Reduction) and clamped to Floor to prevent musical noise artifacts. Before a profile is captured, Signal passes through unchanged. Phases and instantaneous frequencies are unmodified.

Spectral Freeze

Gate captures the current spectrum and holds it indefinitely

Captures the current spectrum and holds it indefinitely, producing a sustained drone from any input.

On the rising edge of the Freeze toggle or Gate input, magnitudes from the first available frame are captured and held. While frozen, these captured magnitudes replace the live signal's magnitudes every frame. Phases and instantaneous frequencies pass through unmodified, so the downstream synthesizer's phase accumulator keeps evolving — producing a naturally shifting texture rather than a static buzz. Output Gain is applied to magnitudes during freeze; when not frozen, signal passes through unchanged. The Gate input overrides the Freeze toggle: a rising edge activates freeze regardless of the toggle state.

Spectral Granular

Spectral-domain granular processor with frame buffer and pitch shifting

Spectral-domain granular processor. Captures spectral frames into a circular buffer and replays them as overlapping grains with per-grain pitch shifting.

Sits in the standard Analyze -> Effect -> Synthesize chain. Grains are scheduled at the Density rate and last for Size spectral frames. Each grain reads from a jittered Position in the frame buffer with pitch shifting via bin interpolation (same technique as Spectral Shift). Multiple grains are mixed by summing magnitudes (divided by active grain count) with winner-take-all phase selection — the grain with the highest magnitude at each bin determines the output phase and instantaneous frequency. Grain envelopes use a raised cosine window controlled by Blend (0 = rectangular, 1 = maximum fade). The Freeze gate stops recording into the buffer, letting grains play from a fixed snapshot. When the buffer is empty, input passes through directly.

Spectral Join

Recombines per-band spectral data from Spectral Split

Recombines per-band spectral data into a single full spectrum. The dual of Spectral Split — connect processed band outputs here to merge them back into one spectral stream for Spectral Synthesize.

For each bin, the input with the highest magnitude wins (winner-take-all): phase and instantaneous frequency come from that same input. When bands from Spectral Split do not overlap, each bin comes from exactly one input with no ambiguity. The output uses metadata (FFT size, sample rate, frequency range) from the first connected input.

Spectral Mask

Drawable per-bin frequency filter with live spectrum overlay

Drawable frequency filter that multiplies each bin's magnitude by a user-drawn curve. Sculpt the spectrum to boost, cut, or isolate any frequency region.

The mask curve is drawn on a logarithmic frequency axis (20 Hz - 20 kHz) in the Band Curve Editor. Each FFT bin is mapped to its LogFreqT position and the curve is evaluated there, so the resolution follows the FFT size. Values above 1.0 boost that frequency region; 0.0 silences it. The curve is recomputed whenever upstream FFT parameters change (bin count, sample rate, FFT size). A live spectrum overlay displays the first channel's magnitudes in real time. Output Gain is multiplied into each bin alongside the mask value.

Spectral Rotate

Circular bin rotation on the spectral bus

Circular rotation of FFT bins by band-aligned offsets. Creates inharmonic, metallic textures or repositions the spectrum before Spectral Split.

Uses the same log-spaced band mapping as Spectral Split (derived from the upstream SpectralBuffer's frequency range and FFT size), so rotating by N shifts by exactly N Split bands worth of bins. Rotation wraps circularly — bins shifted past Nyquist reappear at DC. Magnitudes are scaled by Output Gain during rotation. Phases and instantaneous frequencies move with their bins unmodified. The Rotate Mod input is bipolar, scaled to the band count, and added to the Rotate property. Zero rotation passes through without processing.

Spectral Shift

Pitch shift via spectral bin shifting (±24 semitones)

Pitch-shifts the spectrum by moving FFT bins up or down without changing playback speed.

Computes a frequency ratio from the semitone shift (2^(st/12)), then for each output bin, reads from a fractional source bin using linear interpolation on magnitudes. Instantaneous frequencies are taken from the nearest source bin and scaled by the ratio. Bins that would read beyond the spectrum stay zeroed. When shift is near zero and gain is unity, the signal passes through without processing. The Shift Mod input adds a bipolar offset scaled to the full range.

Spectral Smear

Temporal magnitude smoothing for ambient textures

Applies temporal smoothing to per-bin magnitudes, blurring the spectrum over time. Low values add subtle sustain; high values create evolving ambient washes.

Uses an exponential moving average per bin: each frame blends the stored average with the incoming magnitude using the Smear factor as the EMA coefficient. At maximum, approaches infinite hold similar to Spectral Freeze but with gradual accumulation rather than a hard capture. When Smear is near zero, averages are reset and signal passes through. Phases and instantaneous frequencies are unmodified. The Smear Mod CV input adds to the Smear knob value (clamped 0-1).

Spectral Split

Partitions spectral data into N frequency bands

Partitions spectral data into N logarithmically-spaced frequency bands. Patch any effect between Split and Join to make it spectral — delay becomes spectral delay, distortion becomes spectral distortion.

Each output carries a SpectralBuffer with only that band's bins populated (all others zeroed). Pure spectral routing — no FFT/IFFT happens here. The typical chain is Spectral Analyze -> Split -> per-band effects -> Join -> Spectral Synthesize. Band boundaries use log-frequency spacing derived from the upstream Analyze node's Low Freq, High Freq, and FFT Size. Inherent latency equals the upstream FFT size in samples (~21 ms at 1024/48 kHz).

Spectral Synthesize

Spectral data to audio (inverse FFT with phase vocoder)

Converts spectral data back into stereo audio using inverse FFT with overlap-add reconstruction. This is the exit point of the spectral processing chain.

Accepts one or many spectral inputs and produces a matching number of stereo audio outputs. Each input/output pair runs its own synthesizer, but all share FFT plans for efficiency. Synthesizers are lazily created on first data — FFT parameters (size, overlap) come from the upstream SpectralBuffer. Set the Channels property to match the number of spectral inputs you intend to connect.

Audio ➔ Control

Converts audio-rate signals to control-rate by sampling first sample of buffer

Samples the first stereo frame of each audio buffer, downmixes to mono ((L+R)/2), and outputs the result as a control-rate value.

Only the first sample of each buffer is used -- subsequent samples are ignored. The output updates once per buffer at whatever the graph's block size is. Useful for driving parameters from audio-rate signals like envelopes or LFOs running through the audio bus.

Burst Generator

Single trigger → N evenly-spaced trigger pulses with acceleration

Fires a rapid burst of gate pulses from a single trigger.

Each rising edge on Trigger starts a burst of Count pulses at the configured Rate. Pulses have a 50% duty cycle. Acceleration divides each successive interval: >1.0 speeds up (accelerando), <1.0 slows down (ritardando), 1.0 is even spacing. A retrigger during an active burst restarts from the beginning. The minimum interval is clamped at 5 ms to prevent degenerate pulse widths.

Clipper

Audio clipping and saturation with hard and soft modes

Clips or saturates a stereo audio signal. Each stereo channel is processed independently per sample.

In Hard mode the signal hits a symmetric brick wall at +/- threshold. In Soft mode tanh saturation provides a warmer overdrive character that smoothly approaches the ceiling. The threshold is per-sample smoothed to prevent clicks when adjusted. Lower threshold values clip harder.

Clock

Generates precise timing gate signals

Free-running clock source that emits gate pulses at a configurable frequency.

Each cycle begins with the gate going high for the pulse width duration, then low for the remainder of the period. The pulse width is capped at 90% of the period to guarantee a falling edge even at high frequencies. A Rate Mod CV replaces the Frequency property with an exponential mapping from 0--1 across 0.01--1000 Hz. A Reset rising edge zeros the phase for sync.

Clock Div/Mult

Divide or multiply incoming clock triggers by an integer ratio

Divides or multiplies an incoming clock by an integer ratio.

In Divide mode, a rising edge passes through every N-th input trigger; falling edges only pass when the counter is at zero. In Multiply mode, the node measures the period between incoming triggers and emits N evenly-spaced subdivisions within that period, each with a 50% duty cycle. The first incoming trigger establishes the period -- no subdivisions are emitted until the second trigger arrives. A Reset rising edge zeros the counter.

Comparator

Threshold comparison on continuous signals, outputs gate

Compares a continuous control signal against a threshold and outputs a gate. Schmitt trigger hysteresis prevents chattering.

The hysteresis creates a dead band: for > and >= modes, the gate turns on when the input exceeds threshold + hysteresis/2 and stays on until it drops below threshold - hysteresis/2 (and vice versa for < and <=). A Threshold Mod CV replaces the property value when connected. The input defaults to 0.0 when disconnected.

Constant

Outputs a constant value as configuration data

Outputs a fixed value as structured data on every buffer.

Set the type (Number, String, Bool, FilePath, or Resource) and the corresponding value, then wire the Data output to any node that expects configuration. Changing the type resets the value to a default for that type. The output is a boxed `ConstantValue` enum on a Data port.

Control Converter

Converts between control signal types with proper range mapping

Accepts any control-family signal and produces correctly converted outputs for every signal type simultaneously.

The node detects the source port type at process time and applies proper conversion math. Norm uses linear 0--1 mapping; Bipolar maps -1..1 to 0..1 linearly; ControlFreq uses log-scale normalization across 20--20000 Hz. Generic Control is treated as already 0--1 for Norm and clamped to -1..1 for Bipolar.

Audio output is dual-mono stereo from the normalized value. V/Oct is derived by converting through frequency first (relative to middle C at 261.63 Hz). Gate goes high when the normalized value reaches 0.5 and low when it drops below, with edge detection. The raw Control output passes through unchanged.

Control Mapper

Maps control signals from one range to another

Linearly rescales a control signal from one range to another.

The input value is normalized against the Input Min/Max range, then mapped to the Output Min/Max range. If the input range has zero width the output defaults to Output Min. With Clamp enabled, the output is constrained to the output bounds. With Clamp off, values outside the input range extrapolate beyond the output range. Inverted ranges (min > max) are supported for reverse mapping.

Control Math

Two-input control math: add, subtract, multiply, min, max, crossfade

Two-input math on control-rate signals. Combine, compare, or crossfade a pair of normalized control values.

Disconnected inputs default to 0.0. Add and Subtract results are clamped to 0.0--1.0. Multiply, Min, and Max are unclamped. Crossfade uses the Mix property: 0.0 = all A, 1.0 = all B. Unlike SignalMathNode this operates at control rate (one value per buffer, no per-sample smoothing on Mix).

Control Scale

Scales normalized control (0-1) to frequency range in Hz

Scales a normalized 0--1 control value to a frequency range in Hz using linear interpolation between Min Hz and Max Hz.

The input is clamped to 0--1 before scaling. Min Hz must be less than Max Hz. Useful for converting LFO or knob output into a frequency modulation signal for oscillators and filters.