Aether Rhai Scripting Guide

Complete reference for scripting in Aether using the Rhai language. Scripts automate graph construction, sequencer programming, and live performance. Run scripts from the console (bottom panel), the script editor (Cmd+E), or headless (aether-headless --script file.rhai).

Quick Start

// Build a simple synth patch
let sink = AudioSink.first();
let synth = Polysynth.add("synth");
let reverb = Reverb.add("reverb");

synth.output("Audio Out").port().connect(reverb.input("Input").port());
reverb.output("Output").port().connect(sink.input("Audio In").port());

synth.waveform("Sawtooth");
reverb.room_size(0.7);
reverb.mix(0.3);

play();

Key Concepts

• Node types are global constants - Oscillator, Mixer, Filter, etc. Typos fail at parse time.
• Type.add("label") creates a node. With a label, it's idempotent - rerunning returns the existing node.
• Type.first() returns the first existing node of that type (e.g. AudioSink.first()).
• Typed property methods - each node type has generated methods like osc.frequency(440.0).
• node.set("Property", value) string-based setter also works for all properties.
• output.port().connect(input.port()) wires nodes together. Duplicate connections are ignored.
• Typed port properties - mix.input("Input 0").gain(0.5) for per-port properties.

Type System

Every node type gets its own Rhai type, generated by the graph_node! proc macro. Each type has per-property setter methods and per-port property methods.

Methods on All Node Handles

Every node handle (regardless of type) has these shared methods:

• show() - print node details to console
• help() - print properties, ports, and methods for this type
• set(key, value) - set property by string name
• get(key) - get property by string name
• input(name) - get typed input port handle
• output(name) - get typed output port handle
• delete() - remove the node
• label(name) - set display label
• select() - select on canvas

Methods on All Port Handles

Every port handle has:

• show() - print port details
• help() - print port type, per-port properties, and methods
• port() - convert to ScriptPortRef for connecting
• disconnect() - disconnect (input ports only)
• Per-port-property methods (e.g. gain(), pan() on Mixer inputs)

Discovering the API: .help()

Every registered type - macro-generated handles, typed port handles, and the hand-written types (ScriptCurve, ScriptEnvelope, etc.) - responds to .help(). In the console it auto-prints; in scripts pass it to print():

Oscillator.help();                     // node type: add/find/first
let osc = Oscillator.add("osc");
osc.help();                            // properties, ports, methods
osc.output("Audio Out").help();        // port type + methods
let c = curve();
c.help();                              // ScriptCurve builder methods

Style Guide

Use Typed Property Methods

Each node type has generated setter methods for its properties. Method names are snake_case of the property variant name (e.g. DelayTime → delay_time(), MasterGain → master_gain()). This is the preferred way to set properties - it's type-safe and validated per node type.

// Preferred - typed, validated per node type
osc.frequency(440.0);
osc.waveform("Sawtooth");
filter.cutoff(2400.0);
delay.delay_time(0.375);
delay.feedback(0.35);
mix.master_gain(0.5);

// Fallback - string-based, resolves by name
osc.set("Frequency", 440.0);

Label Everything

Always pass a label to .add(). This makes scripts idempotent and self-documenting.

// Good - labeled, rerunnable
let filter = Biquad.add("main filter");

// Avoid - creates a new node every run
let filter = Biquad.add();

Use show() to Discover Names

When unsure of a property or port name:

let osc = Oscillator.add("osc");
osc.show();
// Prints: type, all ports, all properties with current values
// For ArrangerEditor/SequencerEditor: also prints tracks, regions, notes

osc.input("Frequency Mod").show();   // port details
mix.input("Input 0").show();          // port properties (gain, pan)

Name Resolution

String-based set()/get() and port names use fuzzy resolution:

Port Names

1. Exact match - "Audio Out"
2. Case-insensitive - "audio out"
3. Underscores as spaces - "audio_out"
4. Substring - "audio" (matches the first port containing that text)

Property Names (for set()/get())

1. Exact property ID - "MasterGain"
2. Case-insensitive property ID - "mastergain"
3. Case-insensitive display name - "master gain"

Enum Properties

osc.waveform("Sawtooth");            // typed method
osc.set("Waveform", "Sawtooth");     // string-based
osc.set("Waveform", 2);              // by index

Function Reference

Arranger Region

Arranger Track

Connections

Curve

Debugging

Edit

Envelope

Files

Help

Inspection

Journal

Nodes

Properties

Sequencer

Sequencer Note

Sequencer Track

Shared

Shared Track

Timing

Tour

Transport

Values

View

Node Reference

Analysis

Chromatic Tuner (ChromaticTuner)

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

let node = ChromaticTuner.add("my_chromatictuner");

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).

Properties:

Inputs:

Outputs:

Clip Detector (ClipDetector)

Detects audio clipping with control output

let node = ClipDetector.add("my_clipdetector");

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.

Properties:

Inputs:

Outputs:

Envelope Follower (EnvelopeFollower)

Tracks amplitude envelope of audio signal

let node = EnvelopeFollower.add("my_envelopefollower");

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.

Properties:

Inputs:

Outputs:

Oscilloscope (Oscilloscope)

Real-time waveform visualization with trigger modes

let node = Oscilloscope.add("my_oscilloscope");

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.

Properties:

Inputs:

Outputs:

Peak Meter (PeakMeter)

Peak level measurement with hold and decay

let node = PeakMeter.add("my_peakmeter");

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.

Properties:

Inputs:

Outputs:

Spectrum Analyzer (SpectrumAnalyzer)

FFT-based frequency spectrum visualization with configurable analysis

let node = SpectrumAnalyzer.add("my_spectrumanalyzer");

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).

Properties:

Inputs:

Outputs:

Waterfall (Waterfall)

Scrolling spectrogram - frequency × time heatmap

let node = Waterfall.add("my_waterfall");

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.

Properties:

Inputs:

Outputs:

Effect

Allpass Filter (AllpassFilter)

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

let node = AllpassFilter.add("my_allpassfilter");

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.

Properties:

Inputs:

Outputs:

Amp Envelope (AmpEnvelope)

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

let node = AmpEnvelope.add("my_ampenvelope");

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.

Properties:

Inputs:

Outputs:

Automation Curve (AutomationCurve)

Transport-synced drawn curve for parameter automation

let node = AutomationCurve.add("my_automationcurve");

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.

Properties:

Inputs:

Outputs:

Biquad Filter (Biquad)

Second-order IIR filter with multiple types

let node = Biquad.add("my_biquad");

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.

Properties:

Inputs:

Outputs:

Chorus (Chorus)

Multi-voice chorus effect with LFO modulation

let node = Chorus.add("my_chorus");

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.

Properties:

Inputs:

Outputs:

Comb Filter (CombFilter)

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

let node = CombFilter.add("my_combfilter");

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.

Properties:

Inputs:

Outputs:

Compressor (Compressor)

Dynamic range compressor with optional sidechain

let node = Compressor.add("my_compressor");

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.

Properties:

Inputs:

Outputs:

DeClicker (DeClicker)

Active click and pop removal via derivative detection and interpolation repair

let node = DeClicker.add("my_declicker");

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.

Properties:

Inputs:

Outputs:

Delay (Delay)

Audio delay with optional time modulation

let node = Delay.add("my_delay");

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.

Properties:

Inputs:

Outputs:

Distortion (Distortion)

Waveshaping and harmonic distortion with multiple types

let node = Distortion.add("my_distortion");

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.

Properties:

Inputs:

Outputs:

Envelope (Envelope)

ADSR envelope generator

let node = Envelope.add("my_envelope");

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.

Properties:

Inputs:

Outputs:

Filter (Filter)

One-pole lowpass filter with cutoff modulation

let node = Filter.add("my_filter");

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.

Properties:

Inputs:

Outputs:

Flanger (Flanger)

Short modulated delay with feedback - classic flanger effect

let node = Flanger.add("my_flanger");

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.

Properties:

Inputs:

Outputs:

Granular (GranularProcessor)

Live granular effects processor with freeze and pitch control

let node = GranularProcessor.add("my_granularprocessor");

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.

Properties:

Inputs:

Outputs:

LFO (LFO)

Low-frequency oscillator for modulation

let node = LFO.add("my_lfo");

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.

Properties:

Inputs:

Outputs:

Low-Pass Gate (LowPassGate)

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

let node = LowPassGate.add("my_lowpassgate");

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.

Properties:

Inputs:

Outputs:

Phaser (Phaser)

Multi-stage allpass sweep - classic phaser effect

let node = Phaser.add("my_phaser");

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.

Properties:

Inputs:

Outputs:

Pitch Envelope (PitchEnvelope)

Gate-triggered frequency sweep for percussive pitch control

let node = PitchEnvelope.add("my_pitchenvelope");

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.

Properties:

Inputs:

Outputs:

Reverb (Reverb)

Room simulation reverb with Schroeder algorithm

let node = Reverb.add("my_reverb");

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.

Properties:

Inputs:

Outputs:

Ring Modulator (RingModulator)

Carrier × modulator ring modulation with dry/wet mix

let node = RingModulator.add("my_ringmodulator");

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.

Properties:

Inputs:

Outputs:

Sample Rate Reducer (SampleRateReducer)

Lo-fi aliasing effect - reduces effective sample rate

let node = SampleRateReducer.add("my_sampleratereducer");

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.

Properties:

Inputs:

Outputs:

Transient Shaper (TransientShaper)

Independent attack and sustain gain reshaping

let node = TransientShaper.add("my_transientshaper");

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.

Properties:

Inputs:

Outputs:

Vocoder (Vocoder)

Channel vocoder - spectral envelope transfer from modulator to carrier

let node = Vocoder.add("my_vocoder");

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.

Properties:

Inputs:

Outputs:

fBm Noise (FbmNoise)

Fractal Brownian Motion noise - organic modulation source

let node = FbmNoise.add("my_fbmnoise");

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.

Properties:

Inputs:

Outputs:

Interface

Bipolar Knob (BipolarKnob)

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

let node = BipolarKnob.add("my_bipolarknob");

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.

Properties:

Outputs:

Control Knob (ControlKnob)

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

let node = ControlKnob.add("my_controlknob");

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.

Properties:

Outputs:

Control Panel (ControlPanel)

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

let node = ControlPanel.add("my_controlpanel");

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.

Properties:

Control Source (ControlSource)

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

let node = ControlSource.add("my_controlsource");

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.

Properties:

Outputs:

Gate Button (GateButton)

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

let node = GateButton.add("my_gatebutton");

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.

Properties:

Outputs:

Keyboard (Keyboard)

Interactive MIDI keyboard with monitoring and visualization

let node = Keyboard.add("my_keyboard");

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.

Properties:

Inputs:

Outputs:

Patch Input (PatchInput)

Source node inside a patch - data injected by PatchInstance

let node = PatchInput.add("my_patchinput");

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 (PatchInstance)

Instantiated patch - contains a nested subgraph

let node = PatchInstance.add("my_patchinstance");

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 (PatchOutput)

Sink node inside a patch - data extracted by PatchInstance

let node = PatchOutput.add("my_patchoutput");

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.

Outputs:

MIDI

ABC File Loader (AbcFileLoader)

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

let node = AbcFileLoader.add("my_abcfileloader");

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.

Inputs:

Outputs:

Arpeggiator (Arpeggiator)

Converts held MIDI notes into arpeggiated patterns

let node = Arpeggiator.add("my_arpeggiator");

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.

Properties:

Inputs:

Outputs:

Arranger (Arranger)

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

let node = Arranger.add("my_arranger");

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.

Properties:

Inputs:

Outputs:

Arranger Editor (ArrangerEditor)

Visual arrangement editor. Click to open arranger panel.

let node = ArrangerEditor.add("my_arrangereditor");

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.

Properties:

Inputs:

Outputs:

Chord Generator (ChordGenerator)

Generates chords from single MIDI notes

let node = ChordGenerator.add("my_chordgenerator");

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.

Properties:

Inputs:

Outputs:

Chord Progression (ChordProgressionGenerator)

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

let node = ChordProgressionGenerator.add("my_chordprogressiongenerator");

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.

Properties:

Inputs:

Outputs:

Generative Melody (GenerativeMelody)

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

let node = GenerativeMelody.add("my_generativemelody");

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.

Properties:

Inputs:

Outputs:

Lookahead Sequencer (LookAheadSequencer)

MIDI sequencer with lookahead for visualization and practice features

let node = LookAheadSequencer.add("my_lookaheadsequencer");

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.

Properties:

Inputs:

Outputs:

MIDI Channel Splitter (MidiChannelSplitter)

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

let node = MidiChannelSplitter.add("my_midichannelsplitter");

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.

Properties:

Inputs:

Outputs:

MIDI File Loader (MidiFileLoader)

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

let node = MidiFileLoader.add("my_midifileloader");

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.

Inputs:

Outputs:

MIDI Input (MidiInput)

Receives MIDI events from a virtual MIDI device

let node = MidiInput.add("my_midiinput");

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.

Properties:

Outputs:

MIDI Mixer (MidiMixer)

Merges multiple MIDI input streams into a single output stream.

let node = MidiMixer.add("my_midimixer");

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.

Properties:

Inputs:

Outputs:

MIDI Remap (MidiRemap)

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

let node = MidiRemap.add("my_midiremap");

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.

Properties:

Inputs:

Outputs:

MIDI Sample & Hold (MidiSampleHold)

Latch polyphonic MIDI note state on gate trigger

let node = MidiSampleHold.add("my_midisamplehold");

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.

Properties:

Inputs:

Outputs:

MIDI Voice Splitter (MidiVoiceSplitter)

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

let node = MidiVoiceSplitter.add("my_midivoicesplitter");

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.

Properties:

Inputs:

Outputs:

MIDI ➔ CV (MidiToCv)

Converts MIDI notes to VOct pitch CV and gate signals

let node = MidiToCv.add("my_miditocv");

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.

Properties:

Inputs:

Outputs:

Polysynth (Polysynth)

Polyphonic MIDI synthesizer with configurable waveform and envelope

let node = Polysynth.add("my_polysynth");

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.

Properties:

Inputs:

Outputs:

Polysynth V2 (PolysynthV2)

Polyphonic MIDI synthesizer with configurable waveform and envelope

let node = PolysynthV2.add("my_polysynthv2");

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.

Properties:

Inputs:

Outputs:

Scale Quantizer (ScaleQuantizer)

Quantizes MIDI notes to a musical scale

let node = ScaleQuantizer.add("my_scalequantizer");

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.

Properties:

Inputs:

Outputs:

Sequencer (Sequencer)

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

let node = Sequencer.add("my_sequencer");

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.

Properties:

Inputs:

Outputs:

Sequencer Editor (SequencerEditor)

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

let node = SequencerEditor.add("my_sequencereditor");

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.

Properties:

Inputs:

Outputs:

Voice Mixer (VoiceMixer)

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

let node = VoiceMixer.add("my_voicemixer");

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.

Properties:

Inputs:

Outputs:

Sink

Audio Sink (AudioSink)

Audio output point with optional well-known label

let node = AudioSink.add("my_audiosink");

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.

Inputs:

Outputs:

Source

Audio Input (AudioInput)

Hardware audio capture (microphone, line in)

let node = AudioInput.add("my_audioinput");

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.

Properties:

Inputs:

Outputs:

Audio Looper (AudioLooper)

Gate-triggered audio loop recorder with overdub

let node = AudioLooper.add("my_audiolooper");

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.

Properties:

Inputs:

Outputs:

Drone Oscillator (DroneOscillator)

Detuned beating sines for ambient drone textures

let node = DroneOscillator.add("my_droneoscillator");

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.

Properties:

Inputs:

Outputs:

Drum Voice (DrumVoice)

All-in-one percussion synthesizer with multiple drum modes

let node = DrumVoice.add("my_drumvoice");

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.

Properties:

Inputs:

Outputs:

FM Operator (FmOperator)

Frequency modulation synthesis operator with external modulation and feedback

let node = FmOperator.add("my_fmoperator");

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.

Properties:

Inputs:

Outputs:

Formant Oscillator (Formant)

Vowel-like sounds via resonant formant filters with morph control

let node = Formant.add("my_formant");

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.

Properties:

Inputs:

Outputs:

Frequency Control (FrequencyControl)

Constant frequency control source in Hz

let node = FrequencyControl.add("my_frequencycontrol");

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.

Properties:

Outputs:

Granular Voice (GranularVoice)

Micro-grain playback with textural, evolving sound

let node = GranularVoice.add("my_granularvoice");

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.

Properties:

Inputs:

Outputs:

Harmonic Oscillator (HarmonicOscillator)

16-partial additive synthesis with spectral tilt and inharmonicity

let node = HarmonicOscillator.add("my_harmonicoscillator");

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.

Properties:

Inputs:

Outputs:

Karplus-Strong (KarplusStrong)

Physical modeling of plucked strings using delay line synthesis

let node = KarplusStrong.add("my_karplusstrong");

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.

Properties:

Inputs:

Outputs:

Modal Body (ModalBody)

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

let node = ModalBody.add("my_modalbody");

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.

Properties:

Inputs:

Outputs:

Noise Filter Bank (NoiseFilterBank)

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

let node = NoiseFilterBank.add("my_noisefilterbank");

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.

Properties:

Inputs:

Outputs:

Noise Generator (Noise)

White, pink, and brown noise generator

let node = Noise.add("my_noise");

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.

Properties:

Inputs:

Outputs:

Organ (Organ)

Hammond-style drawbar organ with 9 harmonics and key click

let node = Organ.add("my_organ");

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.

Properties:

Inputs:

Outputs:

Oscillator (Oscillator)

Waveform generator with frequency modulation

let node = Oscillator.add("my_oscillator");

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.

Properties:

Inputs:

Outputs:

Phase Distortion (PhaseDistortion)

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

let node = PhaseDistortion.add("my_phasedistortion");

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.

Properties:

Inputs:

Outputs:

Sample Player (SamplePlayer)

Gate-triggered sample playback with stereo output

let node = SamplePlayer.add("my_sampleplayer");

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.

Properties:

Inputs:

Outputs:

Sample Recorder (SampleRecorder)

Records audio input to the project sample library

let node = SampleRecorder.add("my_samplerecorder");

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.

Properties:

Inputs:

Outputs:

Shepard Tone (ShepardTone)

Continuously ascending/descending pitch illusion

let node = ShepardTone.add("my_shepardtone");

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.

Properties:

Inputs: