// ZPWR-DAW - MODULE REFERENCE

zpwr-daw v0.1.0 · 2095 modules · 25 categories · AU / VST3 / CLAP / Standalone · generated from the live module registry

Hub GitHub

>_MODULE REFERENCE

A two-view DAW (Arrangement + Session) where every track is a patch graph: the full audio-effect pack (filters, distortion, dynamics, delay, reverb, modulation - minus raw oscillators) on audio tracks, and the note-stream pack (arps, chords, sequencers, generators) on MIDI tracks. Every patch block with its inputs and parameters, grouped by category. Use the chapter index or Ctrl+F for a specific name.

Signal Sources

External sources you can cable into any block input or modulation route.

1 In L 2 In R 3 Noise 1 MIDI In 3 Random Mod Wheel Pitch Bend Aftertouch Velocity Expression Sustain MPE Bend MPE Pressure MPE Slide

Categories

Filter

201 modules

# Vocoder 2 inputs

Analysis/synthesis vocoder (Pigments-style): splits the carrier at in0 and modulator at in1 into log-spaced bandpass bands, tracks each modulator band envelope, and multiplies the matching carrier band by it before summing, all blended by Mix against the dry carrier. Bands sets the number of analysis bands (4 to 40 - more bands give more intelligible speech imprinting), Q sets band sharpness, Attack sets the envelope follower attack time in ms (shorter tracks transients tighter), Mode picks the band character (Vintage soft to 6 kHz / Modern bright to 10 kHz / Dirty saturated), and Shift formant-shifts the carrier synthesis bands against the modulator analysis bands for chipmunk or deep-throat colours.

ParamRangeDefaultUnit
Bands4 – 4016—
Q1 – 166—
Attack1 – 505ms
Mix0 – 11—
ModeVintage · Modern · Dirty—
Shift0.25 – 41—

# PZFilter 1 input

Drawable magnitude-response filter: samples a frequency-to-gain curve drawn in node config at 16 log-spaced bands and bakes one peaking-EQ biquad per band, passing the input at in0 through the series to reproduce the drawn shape. Amount morphs between the dry input and the fully filtered output. Draw boosts and cuts across the spectrum to build custom EQ curves or resonant filter shapes.

ParamRangeDefaultUnit
Amount0 – 11—

# PeakFilter 1 input

A biquad peaking EQ band that boosts a single frequency region, followed by a tanh soft limiter to tame the boosted peaks. Freq sets the center frequency (40..16000 Hz), Gain sets the boost amount (0..18 dB), Edge sets the band Q/sharpness, and Mix blends the filtered signal against dry. Useful for emphasizing a resonant frequency without hard clipping when pushed.

ParamRangeDefaultUnit
Freq40 – 160001000Hz
Gain0 – 189dB
Edge0.5 – 123Q
Mix0 – 11—

# FilterLFO 1 input

A 4-pole resonant ladder lowpass swept by an internal LFO that morphs between triangle and sawtooth shapes. Rate sets the LFO speed (Hz), Range sets the sweep depth around the cutoff (~60 Hz..15.6 kHz), Reso sets the resonant feedback, Shape morphs the LFO from triangle to saw, and Mix blends wet against dry. High Reso adds squelch while Shape changes the sweep from symmetric to ramped.

ParamRangeDefaultUnit
Rate0.02 – 120.5Hz
Range0 – 10.7—
Reso0 – 10.5—
Shape0 – 10—
Mix0 – 11—

# LowPassGate 2 inputs

Buchla west-coast low-pass gate: a vactrol couples a VCA and VCF so a ping opens both with the characteristic nonlinear ringing decay. Mode picks VCA / VCF / both.

ParamRangeDefaultUnit
Ping0.01 – 20.4s
Color0 – 10.5—
Mode0 – 22—
Level0 – 10.8—

# SplitEQ 1 input

A peaking EQ that knows transients from tone: a fast/slow envelope split weighs the band gain toward the attack or the sustain, so you can brighten transients without harshening the body.

ParamRangeDefaultUnit
Freq40 – 160002000Hz
Transient-18 – 184dB
Tonal-18 – 180dB
Q0.3 – 81.5—
Mix0 – 11—

# Mini 1 input

Minimoog-style 4-pole transistor ladder: per-stage saturation thins the bass as resonance climbs to self-oscillation.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0 – 10.3—
Mod0 – 40oct
Drive1 – 81—

# Jup-8 1 input

Jupiter-8-style 4-pole OTA ladder: per-stage OTA transconductance saturation with smooth resonance that keeps the low end (no Moog bass loss).

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0 – 10.3—
Mod0 – 40oct
Drive1 – 81—

# MS-20 1 input

MS-20-style 2-pole Sallen-Key low-pass: input op-amp saturation and a saturated resonance integrator plus diode clipping in the resonance path - screams and distorts at high resonance.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0 – 10.3—
Mod0 – 40oct
Drive1 – 81—

# SEM 1 input

Oberheim SEM-style 2-pole state-variable filter: VCA-transistor saturation in the resonance integrator, continuously morphing low-pass through notch to high-pass.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0 – 10.3—
Mod0 – 40oct
Morph0 – 10—

# EMS 1 input

EMS VCS3-style 3-pole (18 dB) diode ladder: asymmetric diode shaping gives a sharp, acidic resonance.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0 – 10.4—
Mod0 – 40oct
Drive1 – 81—

# Wasp 1 input

EDP Wasp-style 12 dB multimode filter: the CMOS-inverter gain-stage outputs hard-clip at the rails for a fizzy, gritty bite. Mode 0 LP / 1 BP / 2 HP.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0 – 10.4—
Mod0 – 40oct
ModeLP · BP · HP—

# Acido 1 input

TB-303-style 4-pole diode ladder: per-stage diode soft-clip and a diode-shaped feedback stage for high-resonance acid squelch.

ParamRangeDefaultUnit
Cutoff20 – 18000800Hz
Reso0 – 10.6—
Mod0 – 40oct
Drive1 – 81.5—

# Pultec 1 input

Pultec EQP-1A-style passive EQ: low boost and cut use offset corners so they do not cancel (the boost-with-dip trick), plus gentle tube warmth.

ParamRangeDefaultUnit
Low Boost0 – 140dB
Low Cut0 – 170dB
Low Freq20 – 15060Hz
High Boost0 – 180dB
High Freq3000 – 160005000Hz
High Cut0 – 160dB

# API550 1 input

API 550-style 3-band EQ with proportional-Q (bands widen at low boost, tighten at high boost) and op-amp soft-clip bite.

ParamRangeDefaultUnit
Low-12 – 120dB
Low Freq30 – 400100Hz
Mid-12 – 120dB
Mid Freq200 – 5000800Hz
High-12 – 120dB
High Freq2500 – 200008000Hz

# N1073 1 input

Neve 1073-style EQ: fixed 12 kHz HF shelf, sweepable mid bell and LF shelf, into an iron-core transformer whose flux saturates the low frequencies first for genuine LF harmonic warmth.

ParamRangeDefaultUnit
Low-16 – 160dB
Low Freq35 – 22060Hz
Mid-18 – 180dB
Mid Freq360 – 72001600Hz
High-16 – 160dB

# SSLE 1 input

SSL E-series-style 4-band parametric EQ: constant-Q (bandwidth stays put as you boost or cut) for a clean, surgical response.

ParamRangeDefaultUnit
Low-15 – 150dB
Low Freq30 – 45080Hz
LMF-15 – 150dB
LMF Freq200 – 2500500Hz
HMF-15 – 150dB
HMF Freq600 – 70003000Hz
High-15 – 150dB

# SSLG 1 input

SSL G-series-style 4-band parametric EQ: proportional-Q (the more you boost or cut, the narrower the band) for a musical, self-limiting curve.

ParamRangeDefaultUnit
Low-15 – 150dB
Low Freq30 – 45080Hz
LMF-15 – 150dB
LMF Freq200 – 2500500Hz
HMF-15 – 150dB
HMF Freq600 – 70003000Hz
High-15 – 150dB

# Manley 1 input

Manley Massive Passive-style EQ: wide bandwidth limits the available gain (opposite of proportional-Q), passive LC curves into an output transformer with LF-flux iron harmonics.

ParamRangeDefaultUnit
Low-11 – 110dB
Low Freq22 – 1000100Hz
Bandwidth0 – 10.5—
High-11 – 110dB
High Freq560 – 200008000Hz

# BBE 1 input

BBE Sonic Maximizer-style processor: a phase-alignment network advances the highs ahead of the (allpass-delayed) lows and adds exciter-style HF harmonics for clarity and punch.

ParamRangeDefaultUnit
Process0 – 10.4—
LoContour0 – 10.3—
Mix0 – 11—

# Helios 1 input

Helios Type 69-style console EQ: a low bell, a switchable peak-or-trough mid at stepped frequencies, and a 10 kHz high shelf - punchy and musical.

ParamRangeDefaultUnit
Low-15 – 150dB
Low Freq60 – 400100Hz
Mid-10 – 150dB
Mid Freq700 – 60001400Hz
High-16 – 120dB

# GML 1 input

GML 8200-style parametric EQ: ultra-clean, transparent constant-Q bands with no saturation - the surgical reference where boost and cut cancel exactly.

ParamRangeDefaultUnit
Low-15 – 150dB
Low Freq30 – 800120Hz
Mid-15 – 150dB
Mid Freq120 – 80001000Hz
High-15 – 150dB
High Freq1000 – 200008000Hz

# Trident 1 input

Trident A-Range-style console EQ: four fixed musical bands (LF shelf, two mid bells, HF shelf) with an aggressive, forward voicing.

ParamRangeDefaultUnit
Low-15 – 150dB
Lo Mid-15 – 150dB
Hi Mid-15 – 150dB
High-15 – 150dB

# Chandler 1 input

Chandler Curve Bender-style EQ (EMI/Abbey Road): musical stepped bands with transformer/valve harmonic colour.

ParamRangeDefaultUnit
Low-15 – 150dB
Low Freq30 – 30060Hz
Mid-15 – 150dB
Mid Freq200 – 60001000Hz
High-15 – 150dB
High Freq3000 – 2000010000Hz

# API560 1 input

API 560-style graphic EQ: fixed octave bands with proportional-Q so adjacent bands sum smoothly (4-band).

ParamRangeDefaultUnit
31 Hz-12 – 120dB
125 Hz-12 – 120dB
1 kHz-12 – 120dB
8 kHz-12 – 120dB

# MEQ5 1 input

Pultec MEQ-5-style midrange passive EQ: a low-mid boost, a mid dip and a high-mid boost for vocal/guitar presence.

ParamRangeDefaultUnit
Low Mid0 – 120dB
Dip0 – 120dB
Hi Mid0 – 120dB

# Maag 1 input

Maag EQ4-style EQ: musical low and mid bands plus the famous Air Band - a very high shelf for open, silky top.

ParamRangeDefaultUnit
Low-10 – 100dB
Mid-10 – 100dB
Mid Freq200 – 50001000Hz
Air0 – 100dB

# Avalon 1 input

Avalon VT-737-style tube channel EQ: clean, musical bell and shelf bands with gentle tube warmth.

ParamRangeDefaultUnit
Low-14 – 140dB
Low Freq30 – 30080Hz
Mid-14 – 140dB
Mid Freq200 – 60001000Hz
High-14 – 140dB
High Freq3000 – 2000010000Hz

# Matrix12 1 input

Oberheim Xpander / Matrix-12 multimode VCF (CEM3372): a 4-pole OTA ladder whose Mode taps a binomial mix of the four pole outputs to produce low-pass, high-pass and band-pass responses at 1-, 2- and 4-pole slopes from a single filter -- the signature Oberheim pole-mixing the SEM's 2-pole SVF cannot do. Per-stage tanh models the OTA soft clip and Reso feeds the 4-pole output back for resonance up to self-oscillation. Cutoff sweeps it, Drive pushes the stages.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0 – 10.3—
Mode4P LP · 2P LP · 1P LP · 4P HP · 2P HP · 1P HP · 2P BP · 4P BP—
Drive1 – 81—

# Polivoks 1 input

Soviet Polivoks 2-pole OTA filter: its resonance path clips like a comparator, so at high Reso it does not ring sweetly -- it slams into a hard square-wave self-oscillation and screams. A 2x-oversampled two-integrator SVF whose band-pass feedback is hard-clipped (not soft tanh) gives that brutal, buzzy Eastern-bloc character no Moog/SEM filter has. Cutoff, Reso, Drive into the core, and Mode taps LP / BP / HP.

ParamRangeDefaultUnit
Cutoff20 – 16000800Hz
Reso0 – 10.4—
Drive1 – 162—
ModeLP · BP · HP—

# CS80 1 input

Yamaha CS-80 dual resonant filter: a 2-pole resonant high-pass in series with a 2-pole resonant low-pass, each swept independently for the lush, vocal, brass-and-strings voice (Vangelis / Blade Runner) a single multimode filter cannot make. HP Cutoff lifts the bottom, LP Cutoff closes the top, Reso peaks both corners (soft-saturated, musical -- not a screaming self-oscillator), Drive pushes the input.

ParamRangeDefaultUnit
LP Cutoff60 – 160004000Hz
HP Cutoff20 – 600080Hz
Reso0 – 10.3—
Drive1 – 81—

# Odyssey 1 input

ARP Odyssey 2-pole filter (4023): brighter and reedier than the 4-pole ladders, with a loud, aggressive resonance that bites and sings -- the thin, vocal ARP lead voice. A soft-saturated 2-pole state-variable filter tapping LP / BP / HP via Mode. Cutoff sweeps it, Reso peaks the corner toward self-oscillation, Drive pushes the input.

ParamRangeDefaultUnit
Cutoff30 – 160001200Hz
Reso0 – 10.4—
ModeLP · BP · HP—
Drive1 – 122—

# ARP2600 1 input

ARP 2600-style 4072 four-pole ladder: aggressive, clean self-oscillating resonance with a brighter, wetter bite than a Moog ladder.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0 – 10.4—
Mod0 – 40oct
Drive1 – 81—

# Polysix 1 input

Korg Polysix-style SSM2044 four-pole low-pass: gentle OTA saturation gives a smooth, creamy resonance that stays musical right up to self-oscillation.

ParamRangeDefaultUnit
Cutoff20 – 180001100Hz
Reso0 – 10.4—
Mod0 – 40oct
Drive1 – 81—

# Korg35 1 input

Korg MS-10-style Korg35 Sallen-Key low-pass: hard diode-clipped resonance that screams and squares up at high settings - more aggressive than the later MS-20 OTA revision.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0 – 10.4—
Mod0 – 40oct
Drive1 – 81—

# Synthacon 1 input

Steiner-Parker Synthacon-style diode multimode filter: an asymmetric diode-clipped resonance path gives a snarly, vocal bite, and Mode sweeps the output continuously LP -> BP -> HP - rougher than a clean SVF.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0 – 10.4—
Mod0 – 40oct
Mode0 – 20—
Drive1 – 81—

# VactrolLPG 1 input

Buchla 292-style low-pass gate: a vactrol (LED + photocell) opens a 2-pole low-pass and a VCA together, and the photocell's slow nonlinear light-decay gives the plucky 'bongo' ring as transients fade. Mode picks gate (VCF+VCA), filter-only, or amp-only.

ParamRangeDefaultUnit
Cutoff100 – 160006000Hz
Decay20 – 2000300ms
Amount0 – 11—
ModeBoth · VCF · VCA—

# MuTron3 1 input

Mu-Tron III-style envelope auto-wah: an OTA state-variable filter whose cutoff is swept by an envelope follower of the playing dynamics. Sens sets the sweep depth, Direction flips up/down, Peak sets resonance, Mode picks LP/BP/HP.

ParamRangeDefaultUnit
Sens0 – 10.5—
Peak0 – 10.5—
Range200 – 2000500Hz
DirectionUp · Down—
ModeLP · BP · HP—

# CEM3320 3 inputs

Curtis CEM3320-style 4-pole OTA filter (Prophet-5 rev3 / SH-101 / Pro-One): four OTA integrator poles with per-stage soft clip and a bass-compensated resonance path, so it stays fat where a Moog ladder thins out - cleaner, brighter, more aggressive into self-oscillation. Cutoff, Reso to self-osc, Mod-CV depth (in 3), Drive pushes the cells.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0 – 10.3—
Mod0 – 40oct
Drive1 – 61—

# CryBaby 1 input

Dunlop Cry Baby / Vox inductor wah: a resonant inductor-cap band-pass swept by Pedal over the throaty 350 Hz - 2.2 kHz range, with the Q peaking through mid-sweep the way a real wah inductor does and falling at the heel/toe. Pedal sets the position (modulate it for auto-wah), Q the bite, Mix the blend.

ParamRangeDefaultUnit
Pedal0 – 10.5—
Q0 – 10.6—
Mix0 – 11—

# VaractorFilter 1 input

Varactor-tuned filter: a varactor (voltage-controlled capacitance) sets the cutoff, so the cutoff RISES with the instantaneous signal voltage - modulating at audio rate, not via an LFO or envelope. The filter intermodulates the signal with itself, adding gritty, phase-coherent partials no static filter or envelope-wah makes (a clean linear SVF whose tuning is the only nonlinearity). Cutoff sets the base, Depth the varactor sensitivity (self-modulation amount), Reso the resonance, Drive the level into the varactor, Level the output.

ParamRangeDefaultUnit
Cutoff50 – 16000800Hz
Depth0 – 82—
Reso0 – 10.3—
Drive1 – 82—
Level0 – 10.6—

# SpectraTilt 1 input

One-knob spectral tilt: a single control rotates the whole spectrum around a pivot frequency, boosting lows while cutting highs (or vice versa) from one shared low-pass state.

ParamRangeDefaultUnit
Tilt-1 – 10—
Pivot100 – 6000900Hz
Level0 – 21—

# MedianClean 1 input

Running-median filter: replaces each sample with the median of the last N (odd) samples, removing impulse clicks and crackle while preserving edges in a way a linear filter cannot.

ParamRangeDefaultUnit
Window3 – 95—
Mix0 – 11—

# CombMorph 1 input

Morphing comb filter: one control sweeps continuously from a feed-forward (FIR, notch) comb to a feedback (IIR, resonant) comb at the same tuned delay, with fractional-delay tuning in Hz.

ParamRangeDefaultUnit
Freq20 – 2000200Hz
Morph0 – 10.5—
Feedback0 – 0.950.5—
Mix0 – 10.5—

# SlapComb 1 input

Tuned resonator comb: a damped feedback comb tuned in Hz rings the input like a plucked string (Karplus-style damping in the loop); decay sets sustain, mix blends the resonance with the dry signal.

ParamRangeDefaultUnit
Pitch40 – 2000220Hz
Decay0 – 0.980.7—
Mix0 – 10.5—

# HarmonicTrap 1 input

Pitch-tracking harmonic notch: detects the input period from zero crossings and places a feed-forward comb notch on a chosen harmonic of it, removing (or isolating) that overtone as the pitch moves.

ParamRangeDefaultUnit
Harmonic1 – 82—
Depth0 – 10.8—
Mix0 – 11—

# MetalComb 1 input

Inharmonic dual-tap comb: two detuned feed-forward taps off one delay line place non-integer-spaced notches, giving a metallic, bell-like coloration distinct from a single tuned comb.

ParamRangeDefaultUnit
Pitch40 – 1000220Hz
Detune0 – 0.10.02—
Depth0 – 10.6—
Mix0 – 10.5—

# CombSweep 1 input

Envelope-swept comb: the comb's tuned frequency rides the input envelope between two limits, so transients sweep the notches automatically - auto-flange driven by dynamics rather than an LFO.

ParamRangeDefaultUnit
Min50 – 1000100Hz
Max100 – 40001500Hz
Time1 – 20020ms
Mix0 – 10.5—

# PingBP 1 input

Pinged bandpass: a high-resonance state-variable bandpass rings on every transient that hits it, turning clicks and percussive input into tuned, decaying tones (a resonator you excite by playing into it).

ParamRangeDefaultUnit
Freq50 – 3000400Hz
Reso0.5 – 0.990.9—
Level0 – 10.7—

# FormantBP 1 input

Dual formant filter: two independent resonant bandpass peaks impose vowel-like formant coloration on any input, the spectral signature of a vocal tract applied as an effect.

ParamRangeDefaultUnit
F1200 – 1200500Hz
F2800 – 30001500Hz
Q1 – 208—
Mix0 – 11—

# SpectraTiltDyn 1 input

Dynamic spectral tilt: the brightness tilt around a pivot scales with the input envelope, so the tone opens up as you play harder and darkens when soft - dynamics-linked spectral balance.

ParamRangeDefaultUnit
Pivot200 – 4000900Hz
Amount-1 – 10.5—
Time1 – 20030ms
Level0 – 11—

# TalkVowel 1 input

Vowel formant morpher: three resonant bandpass formants interpolate across the A-E-I-O-U vowel set with one knob, making any input speak vowels - a talk-box-style spectral overlay.

ParamRangeDefaultUnit
VowelA · E · I · O · U—
Q2 – 208—
Mix0 – 11—

# CrossComb 2 inputs

Cross-fed comb: the comb taps a delayed copy of a second input rather than itself, so one signal carves tuned notches into another (cross-synthesis), with the delay set in Hz.

ParamRangeDefaultUnit
Freq20 – 2000200Hz
Amount0 – 0.950.5—
Mix0 – 10.5—

# CombChord 1 input

Chordal comb: three feed-forward comb taps tuned to a triad of pitches place harmonically-spaced notch sets at once, coloring the input with a chord's worth of comb resonance.

ParamRangeDefaultUnit
Pitch40 – 1000110Hz
Depth0 – 10.6—
Mix0 – 10.5—

# BodyResonator 1 input

Acoustic body resonator: three high-Q bandpass modes scaled by a Size knob stamp the boxy, woody resonant signature of an instrument body onto any input, like playing it through a guitar/violin shell.

ParamRangeDefaultUnit
Size0.5 – 21—
Q2 – 3015—
Mix0 – 10.5—

# VowelSweep 1 input

Auto vowel sweep: an internal LFO slides the formant filter continuously through the A-E-I-O-U vowels, making the input talk/sweep on its own - a hands-free talking filter.

ParamRangeDefaultUnit
Rate0.05 – 40.3Hz
Q2 – 208—
Mix0 – 11—

# EnvWah 1 input

Envelope auto-wah: the input envelope sweeps a resonant bandpass up and down, so playing dynamics open and close the wah - the funk envelope-filter sound, no pedal needed.

ParamRangeDefaultUnit
Range200 – 30001500Hz
Q1 – 125—
Sens0 – 41—

# MultiMode 1 input

Morphing multimode filter: a single state-variable core whose output crossfades continuously from low-pass through band-pass to high-pass with one Mode knob - all three responses from one resonant filter.

ParamRangeDefaultUnit
Cutoff30 – 120001000Hz
Reso0 – 0.950.3—
Mode0 – 20—

# MoogLadder 1 input

Transistor ladder low-pass: four cascaded one-pole stages with a tanh-saturated global feedback path model the Moog ladder's fat, self-oscillating 24 dB/oct resonance.

ParamRangeDefaultUnit
Cutoff30 – 120001000Hz
Reso0 – 10.3—
Level0 – 10.9—

# SKFilter 1 input

Sallen-Key low-pass: the 2-pole active-filter topology (as in the MS-20 / Korg35) with its own resonant peak and gentle clip, a 12 dB/oct voice distinct from the ladder.

ParamRangeDefaultUnit
Cutoff30 – 120001000Hz
Reso0 – 0.950.3—
Level0 – 10.9—

# DispDelay 1 input

Dispersive resonator: an all-pass in the feedback loop makes high partials travel at a different speed than lows, so the comb rings with the stretched, inharmonic, metallic timbre of a stiff string or bar.

ParamRangeDefaultUnit
Pitch40 – 2000220Hz
Disperse0 – 0.90.5—
Decay0 – 0.950.7—
Mix0 – 10.5—

# NotchBank 1 input

Triple notch bank: three independently-spread band-reject notches carve fixed nulls out of the spectrum (the complement of a formant bank), useful for de-essing, feedback control or hollow, phasey coloration.

ParamRangeDefaultUnit
Base200 – 4000800Hz
Spread1 – 31.8—
Depth0 – 10.8—
Mix0 – 11—

# PeakEQ 1 input

Parametric bell EQ: boosts or cuts a band around a centre frequency with adjustable width by adding a scaled band-pass back to the dry signal - one fully-sweepable parametric EQ band.

ParamRangeDefaultUnit
Freq50 – 120001000Hz
Gain-1 – 10.5—
Q0.5 – 123—

# ShelfHi 1 input

High shelf EQ: splits the signal at a corner frequency and applies gain to everything above it, the treble tilt/air control of a mixing console as a single block.

ParamRangeDefaultUnit
Freq500 – 120003000Hz
Gain-1 – 10.5—

# UniversalComb 1 input

Universal comb: one tuned delay with separate feed-forward and feedback gains, so a single block morphs between FIR comb, IIR comb, all-pass and flat - the general comb topology from which the others are special cases.

ParamRangeDefaultUnit
Freq20 – 2000200Hz
FF-1 – 10.7—
FB-0.9 – 0.90.3—
Mix0 – 11—

# CombResonator 1 input

Tuned comb resonator: a damped feedback comb makes any input (noise, clicks, drums) ring at a chosen pitch, the Karplus-Strong damping filter applied as an effect to turn percussive sources into tones.

ParamRangeDefaultUnit
Pitch40 – 2000220Hz
Decay0 – 0.970.85—
Damp0 – 10.3—
Mix0 – 10.6—

# DynamicEQ 1 input

Dynamic EQ band: a parametric bell whose gain is driven by the energy in its own band, so it only cuts (or boosts) when that frequency gets loud - surgical, level-dependent tone control a static EQ can't do.

ParamRangeDefaultUnit
Freq50 – 120001000Hz
Thresh0.01 – 10.2—
Range-1 – 1-0.6—
Q0.5 – 123—

# DiodeLadder303 1 input

Acid diode ladder: a four-stage filter with the asymmetric diode-ladder feedback and gain compensation of the TB-303, giving the rubbery, squelchy resonance that defines acid bass lines.

ParamRangeDefaultUnit
Cutoff30 – 8000800Hz
Reso0 – 10.6—
Level0 – 10.9—

# Biquad 1 input

RBJ biquad: the textbook second-order filter with a type selector (low-pass, high-pass, band-pass, notch) and a resonance/Q control - the general-purpose EQ/filter primitive computed from the standard cookbook coefficients.

ParamRangeDefaultUnit
Freq30 – 120001000Hz
Q0.5 – 121—
TypeLP · HP · BP · Notch—

# SpeakerSim 1 input

Speaker cabinet sim: a low-pass roll-off plus two resonant peaks approximate a guitar speaker's frequency response, taming fizz and adding body so a raw distortion sounds like a miked cabinet.

ParamRangeDefaultUnit
Body0.5 – 21—
Cut2000 – 80004500Hz
Mix0 – 11—

# ResHP 1 input

Resonant high-pass: the high-pass output of a state-variable filter with a resonant peak at the corner, for thinning out low end while adding an emphasised whistle at the cutoff - the counterpart to a resonant low-pass.

ParamRangeDefaultUnit
Cutoff20 – 8000500Hz
Reso0 – 0.950.3—
Level0 – 10.9—

# OnePoleAP 1 input

First-order all-pass: passes every frequency at full level but rotates phase, crossing 90 degrees at its tuned frequency - a phase-alignment / diffusion building block and the cell phasers are built from.

ParamRangeDefaultUnit
Freq20 – 120001000Hz
Mix0 – 11—

# BuchlaLPG 2 inputs

Low-pass gate: a gate input charges a simulated vactrol whose slow, asymmetric response simultaneously opens an amplitude VCA and a low-pass filter, the plucky, organic 'bongo' dynamics of a Buchla LPG.

ParamRangeDefaultUnit
Response5 – 50080ms
Depth0 – 11—

# LinkwitzRiley 1 input

Linkwitz-Riley crossover: cascaded fourth-order low/high splits at two corner frequencies isolate a low, mid or high band with the flat-summing, phase-coherent response used in real multiband splitters and speakers.

ParamRangeDefaultUnit
LowCut80 – 1000250Hz
HighCut1000 – 80002500Hz
BandLow · Mid · High—

# ConvolveCab 1 input

Short convolution: convolves the input with a fixed 16-tap impulse response (a tiny cabinet/early-reflection signature), the genuine FIR-convolution method real cabinet/IR loaders use, in miniature.

ParamRangeDefaultUnit
Tone0 – 10.5—
Mix0 – 11—

# FreqWarpAP 1 input

Frequency warper: a chain of tunable first-order all-passes warps the effective frequency axis (the bilinear/Laguerre warp used in warped filtering), shifting where the spectrum's detail concentrates - a phasey, formant-bending coloration.

ParamRangeDefaultUnit
Warp-0.8 – 0.80.4—
Stages1 – 43—
Mix0 – 11—

# GoertzelTone 1 input

Goertzel detector: a leaky single-bin Goertzel recurrence tracks how much energy the input holds at one target frequency and outputs that magnitude as a CV - the efficient tone/DTMF detector used when you only care about one frequency.

ParamRangeDefaultUnit
Freq50 – 8000440Hz
Q0.9 – 0.9990.995—
Sens0 – 82—

# DCBlocker 1 input

DC blocker: the standard one-pole/one-zero high-pass (y = x - x_prev + R*y_prev) that removes any constant offset or sub-sonic drift while leaving the audband untouched - essential after rectifiers and asymmetric distortion.

ParamRangeDefaultUnit
Cutoff1 – 8020Hz

# ZdfSvf 1 input

Zero-delay-feedback SVF: Zavalishin's topology-preserving-transform state-variable filter solves the feedback loop implicitly each sample, so cutoff and resonance stay accurate right up to Nyquist and it self-oscillates cleanly - a far more analog-faithful SVF than the naive one.

ParamRangeDefaultUnit
Cutoff20 – 120001000Hz
Reso0 – 0.970.3—
ModeLP · BP · HP—

# ZdfLadder 1 input

TPT ladder filter: four topology-preserving one-pole stages with a tanh-saturated resonance feedback model the Moog ladder with the zero-delay-feedback method, holding tuning and resonance accurate where the plain Euler ladder droops.

ParamRangeDefaultUnit
Cutoff30 – 120001000Hz
Reso0 – 10.3—
Level0 – 10.9—

# KeytrackFilter 1 input

Key-tracking filter: detects the input's pitch from its zero crossings and sets a resonant low-pass cutoff to a chosen multiple of it, so the filter follows the note and the timbre stays constant across the range - automatic filter keytracking.

ParamRangeDefaultUnit
Ratio1 – 83—
Reso0 – 0.950.4—
Level0 – 10.9—

# CombKeytrack 1 input

Pitch-tracking comb: detects the input period and tunes a comb filter's notches to a chosen harmonic of it in real time, so the comb coloration locks to the note being played rather than a fixed frequency.

ParamRangeDefaultUnit
Harmonic1 – 81—
Depth0 – 10.7—
Mix0 – 10.6—

# SympResonator 1 input

Sympathetic resonators: four tuned feedback combs at chord ratios ring in sympathy with whatever you feed them (like a sitar's drone strings or an undamped piano with the pedal down), adding a shimmering resonant halo.

ParamRangeDefaultUnit
Root50 – 500110Hz
Decay0 – 0.970.85—
Mix0 – 10.4—

# SpectralSmear 1 input

Allpass smear: six first-order allpass sections in series, fed back on themselves, rotate phase so hard the transients dissolve into a flat-magnitude metallic wash - diffusion without a delay line.

ParamRangeDefaultUnit
Smear0 – 0.950.7—
Feedback0 – 0.90.4—
Mix0 – 10.6—

# ResoSweepFilter 1 input

Envelope-swept resonant filter: a state-variable low-pass whose cutoff jumps open on each transient and decays back down, with resonance high enough to self-oscillate - an auto-wah/laser-zap that tracks your dynamics.

ParamRangeDefaultUnit
Base40 – 4000300Hz
EnvMod0 – 10.6—
Reso0 – 0.950.7—
Decay5 – 500120ms

# KarplusComb 1 input

Tuned comb resonator: a fractional-delay feedback comb tuned in Hz with a damping low-pass in the loop, so whatever you feed it rings at the set pitch like a struck string or metal bar - excitation in, pitched metallic resonance out.

ParamRangeDefaultUnit
Tune50 – 2000220Hz
Feedback0 – 0.980.9—
Damp0 – 0.950.3—
Mix0 – 10.5—

# FoldbackComb 1 input

Foldback comb: a tuned feedback comb whose recirculating signal is wavefolded each pass, so as the resonance rings it folds into ever-brighter inharmonic overtones - a self-animating metallic drone that gets spikier the harder it is driven.

ParamRangeDefaultUnit
Tune50 – 1000150Hz
Feedback0 – 0.990.85—
Fold1 – 41.5—
Mix0 – 10.5—

# NoiseModFilter 1 input

Random-warble filter: the lowpass cutoff wanders continuously over a smoothed white-noise control, so the tone breathes and shifts unpredictably - an organic, never-repeating filter motion distinct from an LFO-swept or sample-and-hold filter.

ParamRangeDefaultUnit
Base100 – 60001000Hz
Depth0 – 10.6—
Mix0 – 11—

# CombFlutter 1 input

Fluttering comb: a tuned feedback comb whose delay length wobbles a few percent under an LFO, detuning the resonant peaks continuously so the metallic comb tone shimmers and choruses instead of sitting at a fixed pitch.

ParamRangeDefaultUnit
Tune50 – 1500200Hz
Feedback0 – 0.950.8—
Rate0.1 – 83Hz
Mix0 – 10.5—

# EnvCombFilter 1 input

Envelope-swept comb: the comb's tuned resonance sweeps up with the input's loudness, so each transient drives the metallic peaks higher and they fall back as the note decays - a dynamic, vowel-like comb motion that tracks how hard you play.

ParamRangeDefaultUnit
Base50 – 2000300Hz
EnvMod0 – 10.6—
Feedback0 – 0.950.7—
Mix0 – 10.5—

# ChaosLfoFilter 1 input

Chaos-swept filter: a logistic-map chaos generator (updated at the set rate) drives the lowpass cutoff, so the tone lurches through deterministic-yet-unpredictable jumps - more structured than random noise modulation, more alive than an LFO sweep.

ParamRangeDefaultUnit
Base100 – 60001200Hz
Depth0 – 10.6—
Rate0.001 – 0.50.05—
Mix0 – 11—

# DynamicComb 1 input

Dynamic comb: a tuned comb whose resonant feedback rises with the input's loudness, so soft passages pass nearly dry and loud hits ring into a sharp metallic resonance - a level-dependent comb intensity, distinct from a comb whose pitch is swept.

ParamRangeDefaultUnit
Tune50 – 1000200Hz
MaxFb0 – 0.970.9—
EnvMod0 – 10.7—
Mix0 – 10.5—

# LpHpMorph 1 input

Morphing SVF: a single Morph knob crossfades the state-variable filter's outputs continuously from low-pass (0) through band-pass (1) to high-pass (2), so one control sweeps the entire filter character at a shared cutoff and resonance - no discrete mode switch.

ParamRangeDefaultUnit
Cutoff40 – 120001000Hz
Reso0 – 0.90.3—
Morph0 – 20—

# NotchFilter 1 input

Notch filter: a state-variable band-reject that removes a narrow band around the cutoff while passing everything else, computed as input minus the band-pass - Reso sets how narrow and deep the notch is. For taming a resonance, removing hum, or as a fixed phaser-style scoop.

ParamRangeDefaultUnit
Freq40 – 120001000Hz
Reso0 – 0.950.5—
Mix0 – 11—

# RegaliaMitraEQ 1 input

Regalia-Mitra shelving EQ: realizes a first-order shelf as 0.5*((1+Gain)*x + (1-Gain)*A(x)) where A is a tunable first-order allpass - the classic allpass-decomposition topology in which the corner frequency (allpass coefficient) and the boost/cut amount are fully independent. Gain=1 is flat, >1 boosts, <1 cuts.

ParamRangeDefaultUnit
Freq20 – 180001000Hz
Gain0 – 41—
Level0 – 10.8—

# LatticeFilter 1 input

Lattice (Gray-Markel) filter: a two-stage all-pole lattice parameterized directly by reflection coefficients K1, K2 instead of biquad coefficients - the structure used in speech LPC, where each coefficient stays in (-1,1) for guaranteed stability and maps to a resonant pole pair. A different, numerically robust way to dial in two-pole resonance.

ParamRangeDefaultUnit
K1-0.99 – 0.990.5—
K2-0.99 – 0.990.5—
Level0 – 10.5—

# DericheGaussian 1 input

Recursive Gaussian filter: the Young-van Vliet 3rd-order IIR whose impulse response approximates a true Gaussian of width Sigma samples, giving a maximally smooth lowpass with no ringing - distinct from one-pole and biquad lowpasses, which have exponential or resonant impulse responses. Sigma sets the smoothing radius. Unity DC gain.

ParamRangeDefaultUnit
Sigma0.5 – 304—
Level0 – 11—

# BesselLowpass 1 input

Bessel lowpass: a 2nd-order IIR filter tuned to the Bessel family Q of 1/sqrt(3), which gives maximally flat group delay - so transients pass through with the least possible phase smearing, at the cost of a gentler magnitude rolloff than Butterworth. The filter family of choice when waveform shape matters more than steep cutoff.

ParamRangeDefaultUnit
Freq20 – 180001000Hz
Level0 – 11—

# ChebyshevLowpass 1 input

Chebyshev type-I lowpass: a 2nd-order IIR whose pole Q is derived from the chosen passband Ripple (in dB), trading a flat passband for a steeper rolloff than Butterworth - more ripple buys a sharper knee and a more resonant edge. The Q comes from the real Chebyshev pole formula, so it is a true filter-family response, not a waveshaper.

ParamRangeDefaultUnit
Freq20 – 180001000Hz
Ripple0.1 – 61dB
Level0 – 11—

# MatchedZLowpass 1 input

Matched-Z lowpass: the analog 2-pole prototype is mapped to the digital domain by placing each pole directly at z=e^(s*T) and the zeros at Nyquist (z=-1), instead of the usual bilinear transform - so there is no frequency warping and the resonant peak lands exactly where the analog pole sits. Resonance sets the pole Q.

ParamRangeDefaultUnit
Freq20 – 180001000Hz
Reso0.5 – 80.707—
Level0 – 11—

# ImpulseInvariantLowpass 1 input

Impulse-invariant lowpass: the analog 2-pole resonator is discretized so its digital impulse response samples the analog one exactly (partial-fraction residues -> a single feed-forward term, no Nyquist zeros). Unlike the bilinear transform it preserves time-domain shape and group delay but can alias, giving a subtly different resonant colour. Resonance sets the pole Q.

ParamRangeDefaultUnit
Freq20 – 120001000Hz
Reso0.5 – 80.707—
Level0 – 10.7—

# KalmanFilter 1 input

Scalar Kalman filter: a smoother whose gain adapts every sample from an estimate of signal vs measurement variance - when the input moves fast the gain rises and it tracks, when steady the gain falls and it denoises. Process sets how quickly the model expects change, Measurement sets assumed input noise. A self-tuning one-pole, not a fixed cutoff.

ParamRangeDefaultUnit
Process0 – 0.50.01—
Measurement0.001 – 10.1—
Level0 – 11—

# HampelDeclicker 1 input

Hampel declicker: over a 7-sample sliding window it finds the median and the median absolute deviation, and replaces the centre sample with the median only when it lies more than Threshold MADs away - so impulsive clicks and digital spikes are removed while the rest of the waveform passes through untouched. A robust despiker, not a lowpass. Adds 3 samples latency.

ParamRangeDefaultUnit
Threshold1 – 83—
Level0 – 11—

# BilateralSmoother 1 input

Bilateral smoother: averages a 7-sample window but weights each neighbour by how close its amplitude is to the centre sample (a Gaussian range kernel of width Range), so smooth regions are denoised while sharp transients - whose neighbours differ a lot - are left intact. A transient-preserving lowpass, unlike a plain moving average. Adds 3 samples latency.

ParamRangeDefaultUnit
Range0.01 – 10.2—
Level0 – 11—

# AlphaTrimFilter 1 input

Alpha-trimmed-mean filter: sorts a 7-sample window, discards the Trim lowest and Trim highest values, and averages what remains - Trim=0 is a plain moving average, Trim=3 is the median, and values in between blend Gaussian-noise rejection with impulse rejection. A tunable bridge between linear smoothing and rank filtering.

ParamRangeDefaultUnit
Trim0 – 31—
Level0 – 11—

# SavitzkyGolay 1 input

Savitzky-Golay smoother: convolves a 5-sample window with the exact least-squares quadratic kernel (-3,12,17,12,-3)/35, which fits a parabola through the window and reads off its centre - so it removes noise while preserving the height and width of peaks far better than a moving average. The classic spectroscopy smoother. Adds 2 samples latency.

ParamRangeDefaultUnit
Level0 – 11—

# GeometricMeanFilter 1 input

Geometric-mean filter: averages the magnitudes of a 7-sample window in the log domain (exp of the mean of log|x|) and restores the centre sample's sign - because the log domain weights small values more heavily, it pulls toward the quieter samples and tames bursts differently from an arithmetic average. A log-mean smoother. Adds 3 samples latency.

ParamRangeDefaultUnit
Level0 – 11—

# WinsorizedMean 1 input

Winsorized-mean filter: sorts a 7-sample window and pulls the Limit most extreme values on each end inward to the nearest surviving value before averaging - unlike the alpha-trimmed mean, which discards them, so outliers are tamed while still contributing. Limit=0 is a moving average, Limit=3 is the median. A robust smoother with a softer outlier response. Adds 3 samples latency.

ParamRangeDefaultUnit
Limit0 – 31—
Level0 – 11—

# FractionalDerivative 1 input

Fractional-order calculus filter: applies the truncated Grunwald-Letnikov operator (an 8-tap FIR with binomial weights) to compute a derivative of fractional Order - positive values differentiate (a tunable +6dB/oct*Order high-boost), negative values integrate (low-boost), and values in between give spectral tilts no integer-order filter can. Distinct from fractional-delay: this changes magnitude slope, not time.

ParamRangeDefaultUnit
Order-1 – 10.5—
Gain0.2 – 82—
Level0 – 11—

# SmithAngellResonator 1 input

Smith-Angell resonator: the classic two-pole resonator improved with zeros at DC and Nyquist (numerator 1 - z^-2), which flattens the skirts and keeps the peak gain nearly constant as the centre frequency sweeps - unlike a plain two-pole resonator whose peak level drifts with tuning. Resonance sets the pole radius (sharpness).

ParamRangeDefaultUnit
Freq20 – 12000800Hz
Reso0.8 – 0.9990.97—
Level0 – 10.7—

# ComplexResonator 1 input

Complex resonator: a one-pole filter with a complex coefficient R*e^(j*omega), iterating z = p*z + x so the state spirals as a phasor - the real part is a clean resonance and the two state variables are inherently in quadrature. The building block of the sliding DFT and Mathews' phasor filter, distinct from real-coefficient biquads. Resonance sets the pole radius.

ParamRangeDefaultUnit
Freq20 – 12000800Hz
Reso0.9 – 0.9990.98—
Level0 – 10.8—

# EmphasisFilter 1 input

Emphasis filter: in Pre mode it applies the speech-coding pre-emphasis y=x-Coeff*x[n-1], a single-zero FIR that boosts highs ~6dB/oct to flatten a falling spectrum; in De mode it applies the exact inverse IIR y=(1-Coeff)x+Coeff*y[n-1] to restore it. The classic record/playback tilt pair, distinct from a pole-zero shelf. Coeff sets the corner.

ParamRangeDefaultUnit
Coeff0.5 – 0.990.95—
ModePre · De—
Level0 – 11—

# CicFilter 1 input

CIC filter: two cascaded boxcar averages of length Taps, giving the sinc^2 magnitude response of a 2-stage cascaded-integrator-comb - a steep, multiply-free lowpass with deep spectral nulls at every multiple of the sample rate over Taps. Sharper rolloff and stronger notches than a single moving average; the workhorse anti-alias filter of decimators.

ParamRangeDefaultUnit
Taps2 – 74—
Level0 – 11—

# TrimeanFilter 1 input

Trimean filter: smooths using Tukey's trimean (Q1 + 2*median + Q3)/4 of a 7-sample window - a robust estimate of the centre that weights the median but still uses the quartiles, so it rejects outliers like a median yet tracks the signal more smoothly and efficiently. A middle ground between the median and the mean. Adds 3 samples latency.

ParamRangeDefaultUnit
Level0 – 11—

# ButterworthLowpass 1 input

Butterworth lowpass: a true 4th-order maximally-flat-magnitude lowpass built from two cascaded biquads at the Butterworth Q pair (0.541, 1.307) - the flattest possible passband with a clean 24 dB/oct rolloff and no peak at cutoff. Completes the IIR filter family alongside the Bessel (flat group delay) and Chebyshev (rippled, steeper) lowpasses, for tone shaping where any resonant bump would colour the sound.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Level0 – 21—

# RIAAFilter 1 input

RIAA phono EQ: the standard vinyl playback equalization curve - the inverse of the bass-cut/treble-boost used when cutting a record - realized as a bilinear-transformed biquad from the three RIAA time constants (3180/318/75 us, i.e. poles at 50 Hz & 2122 Hz, a zero at 500 Hz). Boosts the lows and rolls off the highs, normalized to unity at 1 kHz. A genuine 'make it sound like a record' tone curve, not a generic shelf.

ParamRangeDefaultUnit
Level0 – 21—

# AWeighting 1 input

A-weighting filter: the standardized IEC 61672 / ANSI S1.4 frequency response that approximates the ear's sensitivity at moderate levels - a steep low-cut, a gentle presence rise around 2-4 kHz and a high roll-off - built as the exact 6th-order analog prototype (poles at 20.6, 107.7, 737.9, 12194 Hz) bilinear-transformed and normalized to 0 dB at 1 kHz. Thins a signal to its 'perceptually loud' band; the classic SPL-meter weighting as an audio filter.

ParamRangeDefaultUnit
Level0 – 21—

# KWeighting 1 input

K-weighting filter: the two-stage pre-filter at the heart of the ITU-R BS.1770 / EBU R128 loudness (LUFS) standard - a +4 dB high-frequency shelf (the 'head' filter modelling a head in the soundfield) followed by a ~38 Hz high-pass (the RLB curve). Sample-rate-correct via RBJ biquads rather than the usual hard-coded 48 kHz coefficients. A distinct broadcast-loudness colour, brighter and bass-light, different from the A-weighting curve.

ParamRangeDefaultUnit
Level0 – 21—

# CWeighting 1 input

C-weighting filter: the standardized IEC 61672 / ANSI S1.4 response for peak and high-level sound measurement - nearly flat across the midband with gentle -3 dB roll-offs at 31.5 Hz and 8 kHz (a double pole at 20.6 Hz and 12194 Hz, the same outer corners as A-weighting but WITHOUT its midrange emphasis). Keeps the low end A-weighting throws away, so it reads bass-heavy material far closer to flat - the cinema/peak-level counterpart to the A curve.

ParamRangeDefaultUnit
Level0 – 21—

# AdaptiveNotch 1 input

Adaptive notch: a constrained second-order IIR notch whose centre frequency is steered by normalized-gradient descent on the output power, so it hunts down and removes a single steady whistle, hum or feedback tone wherever it sits - no reference input or manual tuning. Distinct from the reference-based LMS/NLMS cancellers (which need a copy of the noise) and from a fixed notch (which can't track). InitFreq seeds the search, Width the notch sharpness, Adapt the tracking speed.

ParamRangeDefaultUnit
InitFreq50 – 50001000Hz
Width0.9 – 0.9990.97—
Adapt0 – 0.50.05—
Level0 – 21—

# LineEnhancer 1 input

Adaptive line enhancer (ALE): an NLMS predictor fed a decorrelation-delayed copy of the input learns to predict only the part that stays correlated across the delay - the periodic, narrowband content - while broadband noise (uncorrelated past the delay) cancels out. The output is the cleaned-up tone, the dual of the adaptive notch. No reference input needed: it references a delayed version of itself. Delay sets the decorrelation gap, Taps the predictor length, Adapt the convergence speed.

ParamRangeDefaultUnit
Delay1 – 84—
Taps4 – 3224—
Adapt0.005 – 0.50.05—
Level0 – 21—

# MS20Filter 3 inputs

Korg MS-20-style Sallen-Key lowpass: a screaming, aggressive resonant filter. Drive pushes the input into a tanh stage before the filter and Reso climbs into self-oscillation - the gritty, acidic MS-20 squelch. in1 modulates cutoff, in2 modulates resonance.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0.5 – 142Q
Drive0 – 246dB
Mix0 – 11—

# SteinerParker 2 inputs

Steiner-Parker / Synthacon-style multimode filter: a snappy, vocal-sounding 12 dB filter with lowpass, bandpass, highpass and notch modes (Mode), diode-asymmetric soft clipping in the path. Distinct, reedy character versus the ladder filters. in1 modulates cutoff.

ParamRangeDefaultUnit
Cutoff20 – 180001000Hz
Reso0.3 – 91.5Q
ModeLP · BP · HP · Notch—

# OberheimSEM 2 inputs

Oberheim SEM-style state-variable filter: a smooth, creamy 12 dB multimode (lowpass / bandpass / highpass via Mode) with gentle resonance and the warm, rounded SEM character - the classic fat, musical filter for pads and leads. in1 modulates cutoff.

ParamRangeDefaultUnit
Cutoff20 – 180001400Hz
Reso0.3 – 60.9Q
ModeLP · BP · HP—

# WaspFilter 2 inputs

EDP Wasp-style CMOS filter: a digital-gate lowpass that distorts hard and dirty as it is driven - the buzzy, gnarly, lo-fi Wasp grind. Drive sets how viciously the CMOS stage clips; Reso adds a sharp, edgy peak. in1 modulates cutoff.

ParamRangeDefaultUnit
Cutoff20 – 16000900Hz
Reso0.5 – 102Q
Drive0 – 3010dB
Mix0 – 11—

# Buchla292 2 inputs

Buchla 292-style vactrol lowpass gate: a combined lowpass filter + VCA where a control voltage on in1 opens both together through a slow, organic vactrol response - the soft, bongo-like 'bonk' and gentle plucks of West Coast synthesis. Response sets the vactrol attack/decay sluggishness.

ParamRangeDefaultUnit
Cutoff50 – 120004000Hz
Response0.001 – 0.50.05s
Mix0 – 11—

# Acid303 2 inputs

TB-303-style acid filter: a smooth, squelchy 18 dB resonant lowpass that screams and 'wows' as Reso climbs - the liquid, rubbery acid-bassline character. Drive overdrives the input for grit, Reso self-oscillates near max. in1 modulates cutoff for that classic envelope-swept squelch.

ParamRangeDefaultUnit
Cutoff30 – 12000500Hz
Reso0.5 – 186Q
Drive0 – 244dB
Mix0 – 11—

# AllpassFilter 1 input

Cascaded allpass: passes all frequencies at unity gain but shifts their phase, building the swirling notches of a phaser when mixed with the dry signal or smearing transients on its own. Freq sets the centre, Stages the number of allpass sections (steeper phase), Mix the dry/wet for phasing.

ParamRangeDefaultUnit
Freq50 – 12000800Hz
Stages1 – 84—
Mix0 – 10.5—

# CombBank 1 input

Tuned comb filter: feeds the input through a short delay with feedback so it resonates at a pitch (and its harmonics), turning noise into tuned tones and adding a metallic, flange-like comb colour to audio. Freq sets the pitch, Feedback the resonance/ring length, Mix the wet. Distinct from the single Comb in its long-feedback resonant tuning.

ParamRangeDefaultUnit
Freq30 – 4000200Hz
Feedback0 – 0.970.7—
Mix0 – 10.7—

# MorphFilter 2 inputs

Continuously-morphing state-variable filter: one Morph knob sweeps smoothly from lowpass through bandpass to highpass on a single resonant Chamberlin core, so the filter *type* itself can be automated - dark to open to thin - without switching blocks. Cutoff sets the corner, Reso the resonance, and in1 modulates the cutoff.

ParamRangeDefaultUnit
Cutoff30 – 12000800Hz
Reso0 – 0.950.3—
Morph0 – 10—

# FilterFM 2 inputs

Audio-rate filter FM: a resonant lowpass whose cutoff is frequency-modulated at audio rate by in1, producing metallic, bell-like and clangorous timbres that slow filter sweeps can't reach - the filter becomes a sound source. Cutoff sets the centre, Depth the FM amount in octaves, Reso the resonance.

ParamRangeDefaultUnit
Cutoff30 – 8000600Hz
Depth0 – 63oct
Reso0.5 – 123Q

# FixedFilterBank 1 input

Fixed filter bank (Moog 914): three parallel fixed bandpass bands - low, mid and high - each with its own level, a graphic-EQ-style spectral sculptor for formant and tonal shaping. Low / Mid / High set the band gains. in0 = Audio.

ParamRangeDefaultUnit
Low0 – 21—
Mid0 – 21—
High0 – 21—

# TripleResonator 1 input

Triple resonator (Polymoog/Serge): three sharply-tuned resonant peaks laid over the input, ringing out formant-like tones from any source - feed it noise for vowels, audio for metallic body. F1 / F2 / F3 set the three resonance pitches. in0 = Audio.

ParamRangeDefaultUnit
F150 – 4000250Hz
F250 – 4000800Hz
F350 – 40002200Hz
Mix0 – 10.7—

# PingFilter 2 inputs

Pinged resonant filter: a high-resonance bandpass struck by triggers on in0, ringing out a tuned, decaying tone - the classic 'pinged filter' tuned-percussion / pluck trick. Freq sets the pitch, Reso the ring length, Level the output. Trigger on in0, in1 = Pitch CV.

ParamRangeDefaultUnit
Freq40 – 4000300Hz
Reso2 – 3014Q
Level0 – 10.6—

# Sallen 2 inputs

Sallen-Key 2-pole resonant lowpass: the smooth, gently-saturating 12 dB filter of the Korg MS-10/MS-20 and Wasp lineage, growling as Reso climbs into self-oscillation. Cutoff sets the corner, Reso the resonance, Drive the input saturation. in1 modulates cutoff.

ParamRangeDefaultUnit
Cutoff30 – 12000800Hz
Reso0 – 0.970.3—
Drive1 – 81.5—

# PolivoksFilter 2 inputs

Polivoks filter: the harsh, screaming Soviet 2-pole resonant filter (Vladimir Kuzmin's design), whose resonance distorts into a raw, biting howl unlike any Western filter. Cutoff, Reso, Mode picks lowpass or bandpass. in1 modulates cutoff.

ParamRangeDefaultUnit
Cutoff30 – 12000700Hz
Reso0.5 – 208Q
Mode0 – 10—

# ResonantEQ 1 input

Resonant EQ band: a single sharp, high-Q peak added to the signal - a surgical resonant filter for ringing out or carving one frequency. Freq sets the band, Gain boosts (+) or cuts (-), Q the sharpness.

ParamRangeDefaultUnit
Freq30 – 120001000Hz
Gain-1 – 10.5—
Q0.5 – 204—

# VowelBank 1 input

Vowel formant bank: three resonant peaks that morph through the A-E-I-O-U vowels as Vowel sweeps, turning any source into a talking, singing voice. Vowel selects the vowel, Q the sharpness, Mix the wet. in0 = Audio.

ParamRangeDefaultUnit
Vowel0 – 10.5—
Q2 – 126—
Mix0 – 10.8—

# CryWah 2 inputs

Wah pedal: a resonant bandpass swept by the Pedal control, the vocal 'wah' of a guitar pedal - rock the pedal (or in1) for the talking sweep. Pedal sweeps the peak, Reso the sharpness, Mix the wet. in1 = Pedal CV.

ParamRangeDefaultUnit
Pedal0 – 10.5—
Reso1 – 84Q
Mix0 – 11—

# TripleComb 1 input

Triple comb resonator: three tuned feedback combs in parallel, ringing the input at three pitches at once for a chordal, metallic resonance - feed it noise for a struck chord. Root sets the base pitch, Chord the interval spread, Feedback the ring. in0 = Audio.

ParamRangeDefaultUnit
Root40 – 2000200Hz
Chord1 – 21.5—
Feedback0 – 0.970.8—
Mix0 – 10.7—

# Talkbox 1 input

Vowel formant filter (talkbox-style): passes the input through three resonant formant band-passes whose centre frequencies morph across the A-E-I-O-U vowels, imposing a singing/talking vocal colour on any sound so a guitar, synth or drum loop 'speaks' a vowel. Vowel selects and morphs the formant, Res sets the formant sharpness, and Mix blends against the dry. Single-input (unlike the Vocoder, which needs a separate modulator) and it resonates the formants rather than shifting existing ones.

ParamRangeDefaultUnit
VowelA · E · I · O · U—
Res1 – 2010—
Mix0 – 11—

# Cluster 1 input

Cluster filter (Pigments-style): places up to five resonant band-pass filters around a single Cutoff, fanned outward by Spread, and sums them into one animated, vowel-like comb of peaks. Sweeping Cutoff glides the whole cluster; widening Spread pulls the peaks apart from a single resonance into a chord of formants; Reso sharpens each peak toward self-oscillation; Mix blends against dry. Distinct from the harmonic SMR bank (whose bands track a fundamental's overtones) - here the peaks are symmetric octave-spread satellites of one cutoff.

ParamRangeDefaultUnit
Cutoff40 – 8000600Hz
Spread0 – 10.5—
Bands1 – 55—
Reso1 – 308—
Mix0 – 11—

# LoFi 1 input

Lo-fi filter (Pigments-style): degrades the signal by undersampling (Downsample sample-and-holds the input at a reduced rate for aliasing grit), bit-reducing (Bits quantises the amplitude for digital crunch), injecting Noise (a hiss/dirt floor), then smoothing with a Cutoff low-pass - from subtle vintage-sampler warmth to extreme broken-converter mangling. Mix blends against dry. A degradation filter rather than a resonant one: use it to age pads, crush drums or add converter character.

ParamRangeDefaultUnit
Cutoff200 – 160006000Hz
Downsample1 – 504—
Bits2 – 1612—
Noise0 – 10.1—
Mix0 – 11—

# Sherman 2 inputs

Sherman Filterbank (circuit model): a faithful model of the Belgian dual analog filter / distortion box. The input hits a VCA-overdrive stage (asymmetric soft clip -> even-harmonic grind, hotter Drive = more distortion and a stronger envelope), then TWO two-integrator (Chamberlin) state-variable filters whose resonance feedback path is saturated, so high Reso screams and self-oscillates instead of blowing up - the Sherman's signature. A rectifier + RC envelope follower tracks the (hot) input and sweeps the cutoff by Env, Freq sets filter 1's base cutoff, Harmonics offsets filter 2 in semitones, and Mode routes the pair Serial (1->2 LP/BP/HP), Parallel (LP+HP or BP+BP) or Ring (the two band-passes ring-modulated). in1 is the FM input (patch an LFO/envelope/audio to frequency-modulate the cutoff). Mix is the Bypass/Effect blend.

ParamRangeDefaultUnit
Drive1 – 648—
Freq40 – 8000600Hz
Reso0 – 10.7—
Env-1 – 10.5—
Harmonics-24 – 2412st
ModeSerial LP · Serial BP · Serial HP · Par LP+HP · Par BP · Ring—
Mix0 – 11—

# XMF 1 input

Cross-modulation filter (u-he Zebra XMF-style): two resonant state-variable filters run in parallel, but each one's cutoff is modulated by the OTHER filter's output, so they chase each other into FM-like sidebands, growl and screaming resonant textures a single filter cannot make. Cutoff sets the base frequency, Spread offsets the two filters, XMod the cross-modulation depth, Reso the resonance, and Mix the wet blend. At high XMod and Reso it self-oscillates into metallic, vocal, clangorous tones.

ParamRangeDefaultUnit
Cutoff40 – 8000800Hz
Spread0 – 247st
XMod0 – 10.3—
Reso0 – 0.950.5—
Mix0 – 11—

# Pipe 1 input

Waveguide pipe resonator (Absynth Pipe-style): a tuned feedback comb that rings at the Tune frequency, switchable between an Open pipe (full harmonic series, positive feedback) and a Closed pipe (only odd harmonics, inverted feedback) for a hollow, clarinet-like colour. Feedback sets the resonance and ring time, Damp rolls off the highs in the loop for a softer pipe, and Mix blends the resonated signal against the dry input. Excite it with a transient or noise burst for plucked/blown-tube tones.

ParamRangeDefaultUnit
Tune40 – 4000220Hz
Feedback0 – 0.990.9—
ModeOpen · Closed—
Damp0 – 10.3—
Mix0 – 10.5—

# Filter 3 inputs

Multimode state-variable (TPT) filter switchable between low-pass, high-pass and band-pass via Mode. Cutoff tracks an exponential mod input (in 3) scaled by Mod in octaves, while Reso sets the Q up to self-oscillation and an optional pre-Drive (tanh) dirties the resonance. Mix blends the filtered result back against the dry signal.

ParamRangeDefaultUnit
Cutoff20 – 200001000Hz
Reso0.1 – 100.7Q
Mode0 – 20—
Mod0 – 40oct
Drive0 – 240dB
Mix0 – 11—

# SMR 1 input

Spectral multiband resonator (4ms SMR): six resonant band-pass filters tuned in a harmonic series excite the in0 input into a ringing, vocal chord - an oscillator bank, resonator and vocoder-like effect in one. Tune sets the lowest band, Spread the spacing of the six bands (harmonic to stretched), Reso the resonance/ring time of each band, and Mix the wet blend. Feed it drums or noise for struck metallic chords, or audio for formant/vocoder colour. Distinct from the single-band Resonator and the modal Rings.

ParamRangeDefaultUnit
Tune40 – 2000110Hz
Spread0.5 – 31—
Reso0 – 10.7—
Mix0 – 10.8—

# ThreeSisters 1 input

Triple resonant filter (Mannequins Three Sisters): three filters - Low, Centre, High - move together by Freq while Span spreads their cutoffs apart. Quality sweeps from a gentle resonant emphasis up to self-oscillating ringing sine tones (a three-voice resonance choir); Mode switches between the spread filter and a Formant voicing. Feed it audio for sweepable formants and resonant drones. Distinct from the single-band filters and the SMR resonator bank.

ParamRangeDefaultUnit
Freq30 – 8000500Hz
Span0 – 10.4—
Quality0 – 10.3—
ModeFilter · Formant—

# HeadGapLoss 1 input

Head-gap loss: a tape/disk playback head can't resolve wavelengths shorter than its gap, so the response has a comb of nulls starting at the gap frequency - this models that with a feed-forward comb whose first null tracks the Gap, progressively hollowing and darkening the top end the way a worn or wide-gap head does. Gap sets the loss frequency, Depth how deep the nulls cut, Mix the blend.

ParamRangeDefaultUnit
Gap20 – 800120us
Depth0 – 10.7—
Mix0 – 11—

# AirAbsorb 1 input

Air absorption: models how the atmosphere swallows high frequencies over DISTANCE - a gentle, physically-shaped low-pass that gets progressively darker the farther away the source is, the cue your ear uses to hear depth. Stack it for distance/perspective without reverb. Distance sets how far, Mix the blend.

ParamRangeDefaultUnit
Distance0 – 10.4—
Mix0 – 11—

# Pinch 1 input

Pinch: a notch at Freq that DEEPENS as the level rises, so loud passages get a hollow scooped pinch in the spectrum while quiet ones pass full - a level-keyed dynamic notch, the inverse of a resonant boost. Freq sets where it pinches, Amount the maximum scoop, Mix the blend.

ParamRangeDefaultUnit
Freq100 – 5000800Hz
Amount0 – 10.7—
Mix0 – 11—

# Erode 1 input

Erode: high frequencies wear away the longer a note is held - a low-pass whose cutoff slides down as the signal sustains, so attacks stay bright but tails erode into darkness, recovering in silence. Rate sets the erosion speed, Mix the blend.

ParamRangeDefaultUnit
Rate0 – 10.5—
Mix0 – 11—

# EddyBrake 1 input

Eddy-current brake: damping that grows with the signal's VELOCITY - the faster the waveform moves, the harder it is braked, like a conductive disc dragged through a magnetic field. Fast transients are slugged while slow motion passes, a velocity-dependent low-pass quite unlike a fixed filter. Brake sets the drag strength, Mix the blend.

ParamRangeDefaultUnit
Brake0 – 10.5—
Mix0 – 11—

# NasalFormant 1 input

Nasal formant: adds a nasal pole-zero pair - a resonant peak with a paired anti-resonance just above it - so the tone takes on the pinched, honking 'talking through the nose' colour that a simple band-pass formant can't produce. Freq sets the nasal centre, Amount the nasality, Mix the blend.

ParamRangeDefaultUnit
Freq800 – 30001400Hz
Amount0 – 10.6—
Mix0 – 11—

# CapSag 1 input

Coupling sag: an AC-coupling high-pass whose corner frequency rises with level, so loud low-end momentarily loses its bottom and then 'sags' back as a thump when the signal drops - the bass pumping of an under-sized coupling capacitor. Amount sets the sag, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# ContactMic 1 input

Contact mic: the boxy, midrange-honk colour of a piezo disc stuck to a surface - a narrow band-pass plus structure-borne rumble that swells with how fast the signal moves (handling noise), so everything sounds like it was picked up through the body of an object rather than the air. Body sets the rumble, Mix the blend.

ParamRangeDefaultUnit
Body0 – 10.4—
Mix0 – 11—

# MudSquelch 1 input

Mud squelch: a resonant low-pass whose cutoff wanders on a slow random walk, dragging the tone through a wet, gloopy, squelching filter sweep - the sound of something sinking into mud. Cutoff sets the centre of the wander, Mix the blend.

ParamRangeDefaultUnit
Cutoff80 – 4000500Hz
Mix0 – 11—

# AutoWah 1 input

Envelope-following resonant band-pass (auto-wah): the input level sweeps a band-pass from Base upward by Range, with Sens setting how strongly playing dynamics open it and Attack the follow speed. Reso sets the peak sharpness and Mix the blend. Funky on guitar, clav and bass; raise Reso for a vocal quack.

ParamRangeDefaultUnit
Sens0 – 10.6—
Base100 – 2000400Hz
Range200 – 80003000Hz
Reso0.3 – 83Q
Attack1 – 20015ms
Mix0 – 11—

# Formant 1 input

Morphing vowel filter: three parallel band-pass resonators tuned to formant frequencies are swept continuously across the A-E-I-O-U vowels by Vowel, with Q setting the formant sharpness and Mix the blend. Produces talking, vocal timbres. Sweep Vowel with an LFO or envelope for a wah-like vowel morph.

ParamRangeDefaultUnit
Vowel0 – 40—
Q2 – 2010—
Mix0 – 11—

# EQ 1 input

Single parametric peaking EQ band (RBJ biquad): Gain boosts or cuts a bell centred at Freq, with Q setting its width - narrow for surgical notches, wide for broad tone shaping. Chain several for a full parametric EQ. See GraphicEQ for fixed bands and the analog pack (Pultec/Neve/SSL) for coloured curves.

ParamRangeDefaultUnit
Freq30 – 180001000Hz
Gain-18 – 180dB
Q0.3 – 81—

# ParaEQ 2 inputs

Fully-parametric EQ band with stereo / mid-side / L / R processing - stack several for an Ableton EQ-Eight-style mid-side parametric EQ. Type selects the RBJ filter shape (low cut, low shelf, bell, high shelf, high cut, notch), Freq the centre/corner, Gain the boost or cut (shelf/bell), Q the width, and Mode whether the band acts on the full Stereo signal, only the Mid, only the Side, or one channel (L/R). Out picks L or R. Reads in0 = L, in1 = R; place two instances (Out=L and Out=R) for a stereo band.

ParamRangeDefaultUnit
TypeLow Cut · Low Shelf · Bell · High Shelf · High Cut · Notch—
Freq20 – 200001000Hz
Gain-24 – 240dB
Q0.1 – 101—
ModeStereo · Mid · Side · L · R—
Out0 – 10—

# Ladder 3 inputs

Moog-style 4-pole transistor-ladder low-pass: four cascaded one-poles with a tanh input Drive and global resonance feedback that self-oscillates near maximum Reso. Cutoff tracks an exponential mod input (in 3) in octaves. Warmer and more characterful than the clean Filter - push Drive into the ladder for growl; see the Mini analog model for a Minimoog-voiced variant.

ParamRangeDefaultUnit
Cutoff20 – 180001200Hz
Reso0 – 10.3—
Mod0 – 40oct
Drive1 – 81—

# Shelf 1 input

Low- or high-shelf EQ (RBJ shelving biquad; Type selects low or high): boosts or cuts everything below/above Freq by Gain at a fixed slope. Use for broad tonal tilt - warming the lows or adding air to the highs. Pair two for a tilt curve, or see TiltEQ for a single-knob version.

ParamRangeDefaultUnit
Freq30 – 180002000Hz
Gain-18 – 180dB
Type0 – 10—

# DJFilter 3 inputs

One-knob DJ filter: with Cutoff at centre the signal is open, turning down sweeps in a low-pass and turning up sweeps in a high-pass, while Reso adds bite at the corner. The Mod input (in 3) offsets the knob for automation. The classic build-and-drop sweep on a single control.

ParamRangeDefaultUnit
Cutoff0 – 10.5—
Reso0.1 – 80.7Q
Mod-1 – 10—

# Notch 1 input

Band-reject (notch) filter that removes a narrow band around Freq, with Q setting its width and Mix the blend. Use it to kill hum, a resonance or a feedback frequency, or sweep it for phaser-like effects. Narrow Q for surgical removal, wider for broad scooping.

ParamRangeDefaultUnit
Freq30 – 180001000Hz
Q0.3 – 164—
Mix0 – 11—

# Wah 3 inputs

Manually-swept resonant band-pass: Pedal sweeps the peak across Range, with Reso setting the quack and Mix the blend. Drive Pedal from the mod input (in 3) - an LFO, envelope or mod wheel - for auto-wah, talk-box or pedal-wah effects. See AutoWah for a built-in envelope follower.

ParamRangeDefaultUnit
Pedal0 – 10.5—
Range200 – 30001800Hz
Reso1 – 105Q
Mod-1 – 10—
Mix0 – 11—

# TiltEQ 1 input

One-knob spectral tilt that splits the signal at a pivot frequency with a one-pole low-pass and rocks the low and high halves in opposite directions. Tilt sets the slope from -1 (low band up, high band down) through 0 (flat) to +1 (high band up, low band down), Freq places the pivot the split happens around, and Range scales the maximum boost/cut in dB applied to each half. Useful as a fast tone balancer for brightening or warming a source without reaching for a full EQ.

ParamRangeDefaultUnit
Tilt-1 – 10—
Freq100 – 80001000Hz
Range0 – 126dB

# Telephone 1 input

Band-limits the input to roughly 300 Hz-3.4 kHz by cascading a one-pole low-pass at 3.4 kHz into a one-pole high-pass at 300 Hz, leaving only the narrow midrange band that survives a phone line. Mix crossfades between the dry signal and the band-passed result. Use it for lo-fi telephone, intercom and AM-radio voice effects.

ParamRangeDefaultUnit
Mix0 – 11—

# SallenKey 3 inputs

Resonant low-pass built on a TPT state-variable core taking the low-pass output, with the cutoff frequency exponentially modulated by in 3 scaled by Mod in octaves. Cutoff sets the corner, Reso raises the Q toward self-oscillation, and Mix blends the filtered low-pass back against the dry input. The Sallen-Key topology gives a smooth, gentle resonance suited to warm synth and bass filtering.

ParamRangeDefaultUnit
Cutoff20 – 200001000Hz
Reso0 – 10.3—
Mod0 – 40oct
Mix0 – 11—

# Steiner 1 input

Steiner-Parker style multimode filter whose TPT core derives low-pass, high-pass, band-pass and notch responses simultaneously, with Mode selecting which one is output. Cutoff sets the corner frequency, Reso controls the Q toward self-oscillation, and Mix crossfades the selected response against the dry signal. Switching modes covers everything from dark sweeps to hollow notch tones for synth and effect duty.

ParamRangeDefaultUnit
Cutoff20 – 200001000Hz
Reso0 – 10.3—
Mode0 – 30—
Mix0 – 11—

# Crossover 1 input

Two-band splitter that derives a low band from two cascaded one-pole low-passes (an LR2 response) and forms the high band by subtracting it from the input, outputting one band at a time. Freq sets the split frequency and Band chooses whether the low band or the high band is passed. Use it to route or isolate a frequency region, or to feed separate processing chains per band.

ParamRangeDefaultUnit
Freq50 – 5000800Hz
Band0 – 10—

# Resonator 1 input

High-Q band-pass tuned to a musical pitch, converting the Pitch parameter in semitones to a centre frequency and ringing the input through it like a struck body. Pitch sets the resonant note, Reso sets the Q (sharpness and ring length), and Mix blends the doubled resonant output against the dry signal. Drive it with transients or noise for tuned percussion, pinged-body and comb-resonance textures.

ParamRangeDefaultUnit
Pitch24 – 10860st
Reso1 – 4012Q
Mix0 – 11—

# Fizz 1 input

Resonant TPT band-pass filter whose output is mixed with a rectified copy of itself, adding fizzy upper harmonics that grow with resonance. Cutoff sets the band centre (100-12000 Hz), Reso sets both the filter Q and the amount of rectified harmonic content, and Mix blends the result against the dry signal. Use it to add bright, buzzy edge and emphasis to a narrow frequency band.

ParamRangeDefaultUnit
Cutoff100 – 120002000Hz
Reso0 – 10.6—
Mix0 – 11—

# Rasp 1 input

Resonant TPT band-pass filter followed by an asymmetric tanh waveshaper that drives positive half-cycles harder than negative ones, producing a rasping, lopsided distortion. Cutoff sets the band centre (100-12000 Hz), Reso sets the Q and scales the drive so higher resonance increases the snarl, and Mix blends against the dry signal. Ranges from a soft growl at low settings to an aggressive scream at high resonance.

ParamRangeDefaultUnit
Cutoff100 – 120001500Hz
Reso0 – 10.6—
Mix0 – 11—

# Ripple 1 input

Tuned comb resonator built from a short delay line whose length tracks a musical pitch, with a low-passed feedback path that makes it ring at that frequency. Pitch sets the resonant note as a MIDI value (24-108 st), Reso sets the feedback amount up to 0.98 for longer, sharper ringing, Damp sets the high-frequency damping in the feedback path (a darker, woodier ring as it rises), and Mix blends the resonant tone against the dry signal. Pushes input toward a pitched, metallic ring keyed to the chosen note.

ParamRangeDefaultUnit
Pitch24 – 10860st
Reso0 – 0.980.7—
Mix0 – 11—
Damp0 – 10.8—

# PrimeResonator 1 input

Prime-tuned resonator bank (a first as a synth block): runs the input through a bank of sharp resonators tuned to the PRIME harmonics of Base (Base*2, *3, *5, *7, *11...), so whatever you feed it - noise, a drum loop, a voice - rings out as a pitched drone whose overtones are the primes, the hollow bell-organ colour of the prime spectrum imposed on any source. Sharpness sets the resonance Q (how long each prime rings), and Mix blends the resonated tone against the dry. A number-tuned resonator distinct from a plain comb or formant filter.

ParamRangeDefaultUnit
Base20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Partials2 – 128—
Mix0 – 10.7—

# FibResonator 1 input

Fibonacci-tuned resonator bank (a first as a synth block): rings the input through resonators tuned to the Fibonacci harmonics of Base (Base*1, *2, *3, *5, *8, *13...), so any source is recoloured into a drone whose overtones widen by the golden ratio - the warm, glassy Fibonacci spectrum imposed on whatever passes through. Sharpness sets the resonance Q and Mix the wet/dry blend. A golden-spaced resonator distinct from the prime-tuned and harmonic resonators.

ParamRangeDefaultUnit
Base20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Partials2 – 128—
Mix0 – 10.7—

# OddResonator 1 input

Odd-harmonic resonator bank (a first as a synth block): rings the input through resonators on the ODD harmonics of Base only (Base*1, *3, *5, *7, *9...), the spectrum of a square wave or a stopped pipe, so any source takes on a hollow, woody, clarinet-like resonance with no even overtones. Sharpness sets the resonance Q and Mix the wet/dry blend. An odd-harmonic resonator distinct from the prime and Fibonacci banks.

ParamRangeDefaultUnit
Base20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Partials2 – 128—
Mix0 – 10.7—

# OctaveResonator 1 input

Octave-stack resonator bank (a first as a synth block): rings the input through resonators tuned to pure octaves of Base (Base*1, *2, *4, *8, *16...), so any source is pulled toward a single strongly-reinforced pitch with the bright, hollow body of an organ stop - every resonance an octave of the last, nothing in between. Sharpness sets the resonance Q and Mix the wet/dry blend. A pure-octave resonator distinct from the dense harmonic and prime banks.

ParamRangeDefaultUnit
Base20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Partials2 – 106—
Mix0 – 10.7—

# GoldenResonator 1 input

Golden-ratio resonator bank (a first as a synth block): rings the input through resonators spaced by powers of the golden ratio (Base, Base*1.618, Base*2.618, Base*4.236...) - an INHARMONIC bank, so no resonance is a simple multiple of another and the source is recoloured into a shimmering, metallic, bell-like resonance that hangs between a pitch and a clangour. Sharpness sets the resonance Q and Mix the wet/dry blend. The inharmonic counterpart of the prime and octave resonators, ideal for turning drums or noise into struck-metal textures.

ParamRangeDefaultUnit
Base20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Partials2 – 128—
Mix0 – 10.7—

# DrumheadReson 1 input

Drumhead resonator (a first as a synth block): rings the input through a bank tuned to the modes of a circular DRUM MEMBRANE - the inharmonic Bessel-function overtones (1, 1.59, 2.14, 2.30, 2.65...) that give a struck skin its pitch-ambiguous, tom-like 'boing' rather than a clear note. Drop a drum loop, voice or noise through it and the source takes on the body of a tuned membrane. Freq sets the membrane pitch, Sharpness the ring time, Mix the wet/dry blend.

ParamRangeDefaultUnit
Freq20 – 2000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# BarReson 1 input

Bar resonator (a first as a synth block): rings the input through the modes of a free-free metal or wooden BAR - the widely-stretched overtones (1, 2.76, 5.40, 8.93...) of a marimba, glockenspiel or music-box tine. Because the partials leap apart so fast it imposes a clear, bright, struck-mallet pitch on whatever passes through, turning drums or noise into tuned-percussion tones. Freq sets the bar's pitch, Sharpness the ring time, Mix the wet/dry blend.

ParamRangeDefaultUnit
Freq20 – 2000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# PlateReson 1 input

Plate resonator (a first as a synth block): rings the input through the dense, inharmonic modes of a vibrating METAL PLATE (about 1, 2.08, 3.41, 3.89, 5.00, 6.45) - the crowded overtone field behind plate reverbs and the shimmer of a cymbal or gong. Its many close, non-integer partials smear any source into a bright metallic wash. Freq sets the plate's tuning, Sharpness the ring time, Mix the wet/dry blend. A 2-D plate spectrum distinct from the 1-D bar and string resonators.

ParamRangeDefaultUnit
Freq20 – 2000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# BellReson 1 input

Bell resonator (a first as a synth block): rings the input through the partials of a cast BELL - the hum, prime, tierce, quint and nominal tones (0.5, 1, 1.2, 1.5, 2, 2.5, 3) whose deliberately-tuned MINOR THIRD gives a bell its dark, mournful clang. Feeding a source through it casts that bronze, struck-bell colour over it. Freq sets the strike tone, Sharpness the ring time, Mix the wet/dry blend. A tuned-bell spectrum distinct from the bar and plate resonators.

ParamRangeDefaultUnit
Freq20 – 2000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# GlassReson 1 input

Glass resonator (a first as a synth block): rings the input through the sparse, nearly-pure modes of a rubbed wine GLASS or glass-harmonica bowl (about 1, 2.32, 4.25, 6.63, 9.38) - a few widely-spaced, slow-decaying partials that give glass its clear, singing, almost-sine voice. Passing a source through it lends that fragile crystalline ring. Freq sets the glass pitch, Sharpness the (long) ring time, Mix the wet/dry blend. A glassy sparse spectrum distinct from the dense plate and bell resonators.

ParamRangeDefaultUnit
Freq20 – 2000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# MajorReson 1 input

Major-scale resonator (a first as a synth block): rings the input through a bank of resonators tuned to the seven notes of a MAJOR scale (plus the octave), so any source - a drum loop, noise, a voice - is pulled into a bright, consonant, major-key wash, an instant ambient pad. Root sets the key, Sharpness the ring time (turn it up for a sustaining drone), and Mix the wet/dry blend. A scale-tuned resonator distinct from the harmonic and object resonators.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# MinorReson 1 input

Minor-scale resonator (a first as a synth block): rings the input through resonators tuned to the seven notes of a NATURAL MINOR scale (plus the octave), recolouring any source into a darker, melancholic, minor-key drone. Root sets the key, Sharpness the ring time, Mix the wet/dry blend. The minor counterpart of the major resonator, ideal for turning drums or noise into a brooding ambient pad.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# PentatonicReson 1 input

Pentatonic resonator (a first as a synth block): rings the input through resonators tuned to the five notes of a MAJOR PENTATONIC scale (across two octaves) - the gap-toothed, no-semitone scale of folk and gamelan that has no dissonant intervals, so ANYTHING fed through it comes out consonant and open. Root sets the key, Sharpness the ring time, Mix the wet/dry blend. The most foolproof scale resonator for instant harmonious drones from any source.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# WholeToneReson 1 input

Whole-tone resonator (a first as a synth block): rings the input through resonators tuned to the six equal WHOLE-TONE steps (plus the octave) - the symmetrical, rootless scale of Debussy and dream sequences, with no perfect fifths to anchor it. Any source takes on a floating, ambiguous, shimmering quality with no clear home note. Root sets the centre, Sharpness the ring time, Mix the wet/dry blend. A symmetrical scale resonator distinct from the major and minor banks.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# ChromaticReson 1 input

Chromatic resonator (a first as a synth block): rings the input through resonators tuned to all twelve equal-tempered SEMITONES of the octave - a comb of every chromatic pitch, so it imposes a fixed twelve-tone pitch grid on whatever passes through, quantising noise or percussion toward an equal-tempered cluster. Root sets the lowest note, Sharpness the ring time, Mix the wet/dry blend. The densest scale resonator, a chromatic pitch-grid distinct from the consonant major/minor/pentatonic banks.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Sharpness0.9 – 0.9990.99—
Mix0 – 10.7—

# SympatheticStrings 1 input

Sympathetic-string bank (a first as a synth block): rings the input through a bank of tuned, plucked-string loops (Karplus-Strong) set to a major chord, so any source - a drum hit, a breath, a noise burst - excites the strings into a rich, sustaining sympathetic resonance, the way the undamped tarab strings of a sitar or sarangi shimmer behind every note. Unlike the thin 2-pole resonators each string rings its WHOLE harmonic series, giving a dense, lively, plucked-metal sustain. Root sets the chord, Decay the sustain, Damp the brightness, Mix the wet/dry blend.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Decay0.8 – 0.9990.98—
Damp0 – 0.90.4—
Mix0 – 10.6—

# Tanpura 1 input

Tanpura-drone string bank (a first as a synth block): rings the input through four sympathetic strings tuned to the classic Indian tanpura drone (Sa, Sa, Pa, high Sa), so any source sets off the endless, buzzing, overtone-rich Sa-Pa-Sa drone that underpins all Hindustani music. The long feedback loops and gentle damping give the characteristic shimmering, never-quite-decaying jivari sustain. Root sets the tonic, Decay the (long) drone length, Damp the brightness, Mix the wet/dry blend. A specific drone tuning distinct from the chordal sympathetic bank.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Decay0.8 – 0.9990.98—
Damp0 – 0.90.4—
Mix0 – 10.6—

# HarpReson 1 input

Harp-string bank (a first as a synth block): rings the input through eight plucked-string loops tuned to a full DIATONIC scale (a whole octave of harp strings), so any source ripples across the strings and rings back as cascading, scale-tuned harp resonance - feed it transients and it answers in glissando-like washes. Root sets the key, Decay the string sustain, Damp the brightness, Mix the wet/dry blend. A diatonic string bank distinct from the chordal and drone banks.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Decay0.8 – 0.9990.98—
Damp0 – 0.90.4—
Mix0 – 10.6—

# KotoReson 1 input

Koto-string bank (a first as a synth block): rings the input through nine plucked-string loops tuned to a PENTATONIC scale across two octaves, the open, gap-toothed tuning of a Japanese koto or a guzheng. Because the pentatonic scale has no dissonant intervals, any source - even noise - comes back as a consonant, bright, plucked-string cascade. Root sets the key, Decay the string sustain, Damp the brightness, Mix the wet/dry blend. A pentatonic string bank distinct from the diatonic harp and chordal banks.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Decay0.8 – 0.9990.98—
Damp0 – 0.90.4—
Mix0 – 10.6—

# PluckReson 1 input

Single-string resonator (a first as a synth block): rings the input through ONE tuned plucked-string loop (Karplus-Strong), turning any source into a sustained, pitched, plucked-string resonance at the Root note - a string reverb. Transients excite the string into a clear plucked ring; sustained input drives it like a bowed or e-bowed string. Root sets the pitch, Decay the sustain (toward infinite at the top), Damp the brightness, Mix the wet/dry blend. The single-string core of the sympathetic banks, a tuned string-reverb distinct from the multi-string drones.

ParamRangeDefaultUnit
Root20 – 1000110Hz
Decay0.8 – 0.9990.98—
Damp0 – 0.90.4—
Mix0 – 10.6—

# LPG 2 inputs

Vactrol-style low-pass gate: the control input (in 2) simultaneously opens a low-pass filter and a VCA, so brightness and level rise together as the control climbs. Response curves the control law from snappy to sluggish, emulating the vactrol's lag, and Mix blends against dry. Driven by an envelope or trigger it gives the plucky, organic dynamics of Buchla-style patches.

ParamRangeDefaultUnit
Response0 – 10.5—
Mix0 – 11—

# GraphicEQ 1 input

Three-band graphic EQ: one-pole filters at 250 Hz and 4 kHz split the input into low, mid and high bands, each scaled by its own +/-12 dB gain and summed back. Low, Mid and High set the per-band gain in dB and Mix blends against dry. A simple tonal shaping tool for broad low/mid/high balance rather than surgical correction.

ParamRangeDefaultUnit
Low-12 – 120dB
Mid-12 – 120dB
High-12 – 120dB
Mix0 – 11—

# Rings 1 input

Modal resonator bank: three TPT band-pass resonators tuned around a base pitch are excited by the input, summed to produce a struck/plucked resonant body. Pitch sets the fundamental in semitones, Structure morphs the partial spacing from harmonic (1, 2, 3) to inharmonic (1, 2.76, 5.40), Decay sets the resonator Q (ring length), and Bright scales the summed output level. Mix blends the resonant tone with the dry signal for physical-modeling and bell/string textures.

ParamRangeDefaultUnit
Pitch24 – 9648st
Structure0 – 10.3—
Decay0 – 0.990.9—
Bright0 – 10.5—
Mix0 – 10.5—

# Wobble 1 input

Tempo-coherent resonant low-pass wobble: an LFO phased from c.time sweeps a TPT low-pass cutoff between 150 Hz and roughly 6 kHz for dubstep-style movement. Rate sets the LFO frequency, Depth scales the cutoff sweep range, Reso sets the filter resonance, and Shape selects sine, ramp or square LFO contour. Mix blends the wobbled output with the dry signal.

ParamRangeDefaultUnit
Rate0.25 – 82Hz
Depth0 – 10.8—
Reso0.5 – 158—
Shape0 – 20—
Mix0 – 11—

# Sweep 1 input

Onset-triggered filter sweep: an amplitude envelope detects input onsets and restarts a ramp that drives a TPT low-pass cutoff from 100 Hz upward for riser/faller effects. Time sets the ramp duration, Range scales how far the cutoff travels, Reso sets the filter resonance, and Dir flips the ramp between rising and falling. Mix blends the swept output with the dry signal.

ParamRangeDefaultUnit
Time0.1 – 51s
Range0 – 11—
Reso0.5 – 153—
Dir0 – 10—
Mix0 – 11—

Distortion

225 modules

# Array 1 input

Drawable waveshaper: maps the input at in0 (folded from bipolar into a 0 to 1 index) through a transfer curve drawn in node config via linear interpolation, then back to bipolar, blended by Mix against the dry input. The drawn breakpoints define the input-to-output mapping and Mix sets the wet/dry balance. A diagonal curve is a clean pass-through while steeper or folded curves act as custom distortion and waveshaping.

ParamRangeDefaultUnit
Mix0 – 11—

# Mulholland 1 input

Tanh overdrive feeding a resonant Chamberlin state-variable lowpass, with a slow internal LFO wobbling the cutoff. Drive sets the input gain into the saturator (1..30), Cutoff sets the filter frequency (~80 Hz..14 kHz), Reso sets the filter Q, Mod sets how much the LFO modulates cutoff, and Mix blends wet against dry. Goes from gentle filtered grit to a screaming self-resonant squeal as Drive and Reso climb.

ParamRangeDefaultUnit
Drive1 – 308—
Cutoff0 – 10.5—
Reso0.5 – 126—
Mod0 – 10.2—
Mix0 – 11—

# NevePre 1 input

Neve 1073-style preamp: a class-A triode gain stage (grid conduction) into an iron-core output transformer whose LF flux saturates first - the bass 'sings' with iron warmth.

ParamRangeDefaultUnit
Drive1 – 122—
Bias0 – 0.30.08—
Tone2000 – 1800012000Hz
Mix0 – 11—

# ApiPre 1 input

API 312-style preamp: a discrete 2520 op-amp (level-dependent knee) into an API output transformer with LF-flux iron, plus a bright top; the harmonic tilt shifts upward as level rises.

ParamRangeDefaultUnit
Drive1 – 122—
Bias0 – 0.20.04—
Tone3000 – 160008000Hz
Mix0 – 11—

# TubePre 1 input

Vintage tube console-style preamp: two cascaded triode stages with an interstage coupling cap (2nd-harmonic-dominant asymmetric clipping) and a warm low shelf.

ParamRangeDefaultUnit
Drive1 – 163—
Bias0 – 0.40.15—
Tone0 – 62dB
Mix0 – 11—

# BusSat 1 input

SSL bus-style VCA saturation into an output transformer: a thin 'glue' veneer for the mix bus - subtle thickening, not obvious distortion.

ParamRangeDefaultUnit
Drive0 – 10.3—
Bias0 – 0.20.06—
Mix0 – 10.25—

# Studer 1 input

Studer A800-style tape: magnetic hysteresis (B/H saturation + remanence), a firm low-frequency head bump and gentle head-gap HF loss - punchy track-level glue (pro deck: flutter negligible by design).

ParamRangeDefaultUnit
Drive1 – 82—
Head Bump0 – 84dB
HF Loss4000 – 1800012000Hz
Mix0 – 11—

# Ampex 1 input

Ampex ATR-102-style mastering tape: gentle magnetic hysteresis (B/H + remanence), a soft wide head bump and smooth head-gap HF roll-off - subtle mix-bus polish (pro deck: flutter negligible by design).

ParamRangeDefaultUnit
Drive1 – 61.5—
Head Bump0 – 62dB
HF Loss6000 – 1800014000Hz
Mix0 – 10.7—

# TubeScreamer 1 input

Ibanez Tube Screamer-style overdrive: a real op-amp feedback diode clipper - the mid-focused clean gain is clamped by an antiparallel Shockley diode pair, Newton-solved and 4x oversampled (not a tanh) - with the famous ~720 Hz mid hump. Asym mismatches the two diodes for the asymmetric-clip mod, adding the even harmonics a symmetric clipper can't.

ParamRangeDefaultUnit
Drive1 – 5015—
Tone1000 – 50002500Hz
Level0 – 10.5—
Asym0 – 10—

# RAT 1 input

ProCo RAT-style distortion: an LM308-slewed gain stage into a Newton-solved silicon diode pair clamping to ground (the real shunt clipper, 4x oversampled - not a hard jlimit), tamed by a single low-pass Filter knob.

ParamRangeDefaultUnit
Drive1 – 8020—
Filter500 – 60003000Hz
Level0 – 10.4—

# BigMuff 1 input

Big Muff Pi-style fuzz: two cascaded silicon diode clipping stages (Newton-solved Shockley pairs, 4x oversampled) that square up into a wall of sustain, with a scooped-mid tone.

ParamRangeDefaultUnit
Sustain1 – 4015—
Tone0 – 10.5—
Level0 – 10.5—

# FuzzFace 1 input

Fuzz Face-style germanium fuzz: two cascaded germanium common-emitter transistor stages (Ebers-Moll, 4x oversampled) whose asymmetric cutoff/saturation gives the gated, spitty fuzz; Bias starves the second stage toward the splatty/gated voicing, and it cleans up as you lower Input - just like rolling back the guitar volume.

ParamRangeDefaultUnit
Fuzz1 – 6020—
Bias0.4 – 0.90.65—
Input0 – 11—
Level0 – 10.5—

# Klon 1 input

Klon Centaur-style overdrive: a Newton-solved germanium diode pair (4x oversampled) summed back with the clean signal - 'transparent' via the dual-path blend, not soft clipping.

ParamRangeDefaultUnit
Gain1 – 308—
Treble0 – 62dB
Blend0 – 10.6—
Level0 – 10.6—

# DS1 1 input

Boss DS-1-style distortion: a Newton-solved symmetric silicon diode pair (4x oversampled - the real shunt clipper, not a hard jlimit) with an active tilt-tone control - brash and cutting.

ParamRangeDefaultUnit
Dist1 – 6020—
Tone0 – 10.5—
Level0 – 10.4—

# MXRDist 1 input

MXR Distortion+-style overdrive: a Newton-solved ASYMMETRIC germanium diode pair (4x oversampled) - mismatched diodes give the even-harmonic, woolier-than-a-DS-1 crunch - with an output low-pass.

ParamRangeDefaultUnit
Dist1 – 5015—
Level0 – 10.5—

# Octavia 1 input

Octavia-style octave-up fuzz: 4x-oversampled full-wave rectification doubles the pitch, then heavy fuzz - the ring-mod-like upper-octave scream.

ParamRangeDefaultUnit
Drive1 – 4015—
Tone1000 – 80003500Hz
Level0 – 10.5—

# Rangemaster 1 input

Dallas Rangemaster-style treble booster: a high-pass into a real germanium common-emitter transistor stage (Ebers-Moll, Newton-free closed form, 4x oversampled) - its asymmetric cutoff/saturation adds the bright, singing even+odd harmonics on top of the dry signal.

ParamRangeDefaultUnit
Boost1 – 206—
Range200 – 2000700Hz
Level0 – 10.6—

# Aphex 1 input

Aphex Aural Exciter-style enhancer: a tuned high-pass side chain into an asymmetric class-A harmonic generator (2nd+3rd) and a phase-shift network, blended back for air and presence.

ParamRangeDefaultUnit
Tune1000 – 80003000Hz
Harmonics0 – 10.4—
Mix0 – 10.5—

# SuperFuzz 1 input

Univox Super-Fuzz-style octave fuzz: 4x-oversampled full-wave rectification for the octave-up into hard germanium square clipping, with a switchable 1 kHz mid-scoop notch.

ParamRangeDefaultUnit
Drive1 – 4018—
ToneFlat · Scoop—
Level0 – 10.5—

# OCD 1 input

Fulltone OCD-style overdrive: 4x-oversampled asymmetric MOSFET hard clipping (smooth-edged) with a bright/dark voicing switch.

ParamRangeDefaultUnit
Drive1 – 4012—
Tone1500 – 90004000Hz
VoicingLP · HP—
Level0 – 10.5—

# MetalZone 1 input

Boss MT-2 Metal Zone-style high-gain distortion: two 4x-oversampled clip stages into an active dual-peak mid scoop with a sweepable parametric mid.

ParamRangeDefaultUnit
Gain1 – 6030—
Mid Freq240 – 5000800Hz
Mid Level-15 – 150dB
Scoop0 – 10.6—
Level0 – 10.4—

# HeliosPre 1 input

Helios console-style preamp: punchy class-A transistor saturation into a console transformer (LF-flux iron) with an asymmetric Bias and a forward ~1.5 kHz midrange push. Drive sets the grit, Tone rolls the top, Mix blends dry/wet - aggressive British-console colour.

ParamRangeDefaultUnit
Drive1 – 122—
Bias0 – 0.20.05—
Tone2000 – 160009000Hz
Mix0 – 11—

# V76 1 input

Telefunken V76-style tube preamp: two cascaded tube stages with interstage coupling into an output transformer - rich, warm 2nd-harmonic saturation with a low-mid body.

ParamRangeDefaultUnit
Drive1 – 163—
Bias0 – 0.40.18—
Body0 – 62dB
Mix0 – 11—

# ChandlerPre 1 input

Chandler TG2-style preamp (EMI/Abbey Road): an input stage into an iron-core transformer (LF flux saturation) - punchy with a distinctive forward presence.

ParamRangeDefaultUnit
Drive1 – 122—
Bias0 – 0.20.06—
Tone2000 – 160008000Hz
Mix0 – 11—

# ToneBender 1 input

Tone Bender MkII germanium fuzz: three cascaded germanium transistor stages, each asymmetric (germanium clips harder on one rail) with interstage coupling-cap high-pass between them, for the thick, sustaining, slightly-broken vintage fuzz. Bias starves the supply so quiet/decaying notes GATE into the famous spitty sputter; Drive sets the gain, Tone the output roll-off, Level the volume. Distinct from FuzzFace (2 transistors) and Big Muff (4 silicon stages + diodes).

ParamRangeDefaultUnit
Drive1 – 6020—
Bias0 – 10.3—
Tone700 – 90003000Hz
Level0 – 10.7—

# CultureVulture 1 input

Thermionic Culture Vulture valve distortion: Triode mode is an asymmetric, even-harmonic soft saturation (warm, musical thickening); Pentode mode is a harder odd-harmonic clip with a push-pull crossover dip near zero for the snarling, aggressive 'P' destruction. Bias shifts the valve operating point (asymmetry / gate), Drive pushes it from fattening to full disintegration, Tone tilts the output, Level trims it. A valve character/destruction unit, not a pedal or amp.

ParamRangeDefaultUnit
Drive1 – 406—
ModeTriode · Pentode—
Bias0 – 10.3—
Tone-12 – 120dB
Level0 – 10.7—

# UA610 1 input

Universal Audio 610 tube preamp (Bill Putnam): a 12AX7 valve gain stage between input and output transformers. Push Drive to overdrive the tube into warm asymmetric saturation while Level pads the output -- the '610 move' of cranking the valve and taming the volume -- with transformer low-end thickening and the 610's Low/High program EQ. Distinct from the generic tube preamp by the transformer saturation and the gain/level interaction.

ParamRangeDefaultUnit
Drive1 – 404—
Low-12 – 120dB
High-12 – 120dB
Level0 – 10.7—

# Hiwatt 1 input

Hiwatt DR103 amp (full circuit): three could-be-cleaner cascaded triode stages with a stiff power supply and a bright, high-headroom voice -- the clean-but-LOUD British military-grade tone (Townshend / Gilmour) that stays articulate where a Marshall breaks up. Gain drives the preamp, Tone tilts the stack, Master pushes the power stage, Level trims. Cascaded triode transfer + voiced tone stack + supply sag, not a single tanh + fixed EQ.

ParamRangeDefaultUnit
Gain0 – 10.5—
Tone-1 – 10—
Master0 – 10.5—
Level0 – 10.7—

# Orange 1 input

Orange OR-series amp (full circuit): mid-forward, thick and woody with more preamp gain and a spongier supply than the Hiwatt -- the chunky British crunch. Gain, Tone, Master, Level. Shares the cascaded-triode + voiced-tone-stack + supply-sag circuit model, voiced for Orange's mid push.

ParamRangeDefaultUnit
Gain0 – 10.55—
Tone-1 – 10—
Master0 – 10.5—
Level0 – 10.7—

# Dumble 1 input

Dumble Overdrive Special amp (full circuit): smooth, singing high-gain with a spongy supply for bloom and sustain -- the holy-grail boutique lead voice. Gain, Tone, Master, Level. Same cascaded-triode + voiced-tone-stack + supply-sag model, voiced for Dumble's compressed sustain.

ParamRangeDefaultUnit
Gain0 – 10.6—
Tone-1 – 10—
Master0 – 10.5—
Level0 – 10.7—

# MarkIIC 1 input

Mesa/Boogie Mark IIC+ amp (full circuit): tight, scooped, high-gain lead with a stiff supply for fast attack and a singing sustain (the 80s metal lead voice). Gain, Tone, Master, Level. Same cascaded-triode + voiced-tone-stack + supply-sag model, voiced for the Mark's tight low end and scooped mids -- distinct from the looser, fatter Rectifier.

ParamRangeDefaultUnit
Gain0 – 10.7—
Tone-1 – 10—
Master0 – 10.5—
Level0 – 10.7—

# SD1 1 input

Boss SD-1 Super Overdrive: an op-amp gain stage into an ASYMMETRIC soft clipper (two diodes one way, one the other) for a more open, even-harmonic crunch than the symmetric Tube Screamer, with the familiar mid-hump tone that cuts through a band. Drive sets the gain, Tone the mid/treble balance, Level the output.

ParamRangeDefaultUnit
Drive1 – 5012—
Tone0 – 10.5—
Level0 – 10.6—

# JC120 1 input

Roland JC-120 Jazz Chorus (solid-state clean): the transistor clean platform -- a stiff power supply (no sag), big bright headroom that stays glassy and articulate, and a harder, more brittle clip when finally pushed, unlike the soft, compressing tube amps. Drive sets the gain, Tone the brightness, Level the output. Pair with a Chorus block for the full JC stereo shimmer.

ParamRangeDefaultUnit
Drive0 – 10.4—
Tone0 – 10.6—
Level0 – 10.7—

# Peavey5150 1 input

Peavey 5150 / 6505 amp (full circuit): tight, aggressive, high-gain crunch with a stiff supply for percussive attack -- the metalcore / Van Halen rhythm and lead standard. Gain, Tone, Master, Level. Shares the cascaded-triode + voiced-tone-stack + supply-sag model, voiced for the 5150's tight low end and biting upper mids.

ParamRangeDefaultUnit
Gain0 – 10.75—
Tone-1 – 10—
Master0 – 10.5—
Level0 – 10.7—

# SunnModelT 1 input

Sunn Model T amp (full circuit): fat, dark, high-headroom and loose -- the wall-of-low-end doom / sludge / stoner voice, the opposite of a tight bright amp. Gain, Tone, Master, Level. Same cascaded-triode + voiced-tone-stack + supply-sag model, voiced for huge bass, dark top and a spongy, blooming low end.

ParamRangeDefaultUnit
Gain0 – 10.5—
Tone-1 – 10—
Master0 – 10.5—
Level0 – 10.7—

# HM2 1 input

Boss HM-2 Heavy Metal ('Swedish chainsaw'): a high-gain hard clipper into the HM-2's scooped dual-band Color EQ. Turn Color up and it guts the mids while pushing a resonant low end and a fizzy top into the unmistakable buzzsaw wall of Swedish death metal (Entombed). Dist sets the gain, Color sweeps flat -> full chainsaw scoop, Level the output. Distinct from the mid-scoop MetalZone by the dual-band buzzsaw voicing.

ParamRangeDefaultUnit
Dist1 – 6030—
Color0 – 10.8—
Level0 – 10.5—

# FZ1 1 input

Maestro FZ-1 Fuzz-Tone: the first fuzz pedal (the 'Satisfaction' buzz). Three germanium stages give a thin, splatty, ripped-speaker square-wave fuzz that GATES hard as the note decays into the famous sputtering decay. Thinner, harder and more gated than the thick Tone Bender or the FuzzFace. Attack sets the gain, Bias starves the supply (more gate/sputter), Level the output.

ParamRangeDefaultUnit
Attack1 – 6025—
Bias0 – 10.4—
Level0 – 10.5—

# EP3 1 input

Echoplex EP-3 preamp: the Echoplex's FET preamp section, famous as an always-on tone boost (Page, Van Halen). A touch of FET saturation plus a presence bump and slightly tightened lows make whatever runs through it fuller, clearer and more present -- a buffer/boost with character, not a distortion or amp. Gain sets the boost, Bright the presence bump, Level the output.

ParamRangeDefaultUnit
Gain1 – 102.5—
Bright0 – 10.5—
Level0 – 10.8—

# BlueBox 1 input

MXR Blue Box-style octave fuzz: cascaded flip-flops divide the pitch down two octaves into a gritty square sub-octave, blended with a fuzzed dry signal - the synthetic, glitchy -2-octave fuzz.

ParamRangeDefaultUnit
Drive1 – 4012—
Sub0 – 10.6—
Tone800 – 60002500Hz
Level0 – 10.5—

# FuzzFactory 1 input

Z.Vex Fuzz Factory-style two-transistor fuzz: massive asymmetric gain into a hard clip, with Gate choking the decay into a sputtery rip and Stab starving the bias toward a self-oscillating squeal that ducks under the note - the pinched, gated, velcro fuzz. 4x-oversampled.

ParamRangeDefaultUnit
Drive1 – 6020—
Gate0 – 10.3—
Stab0 – 10—
Tone800 – 60002800Hz
Level0 – 10.5—

# Percolator 1 input

Interfax Harmonic Percolator-style fuzz: mixed germanium/silicon asymmetric clipping generates strong even-order harmonics for a wooly, octave-tinged thickness unlike symmetric fuzzes. Balance skews the asymmetry from even-rich to odd-rich. 4x-oversampled.

ParamRangeDefaultUnit
Drive1 – 5014—
Balance-1 – 10.4—
Tone700 – 60002600Hz
Level0 – 10.5—

# SansAmp 1 input

Tech 21 SansAmp-style amp/cab DI: a Character tilt into cascaded asymmetric soft-clipping (4x oversampled) and a speaker-cabinet low-pass, giving the recorded amp tone direct with no mic. Drive sets the gain into the stages, Character tilts presence vs warmth, Level the output.

ParamRangeDefaultUnit
Drive1 – 408—
Character0 – 10.5—
Level-24 – 120dB

# BluesDriver 1 input

Boss BD-2 Blues Driver-style overdrive: a JFET-buffered asymmetric soft-clipper that stays bright, dynamic and amp-like - cleans up with pick attack, breaks up when pushed. Gain sets the drive, Tone the top-end tilt, Level the output.

ParamRangeDefaultUnit
Gain1 – 6010—
Tone0 – 10.5—
Level-24 – 6-6dB

# Guvnor 1 input

Marshall Guv'nor-style distortion: hard symmetric diode clipping after a Marshall-voiced mid push with an active treble tilt - the 'amp in a box' crunch-to-roar. Gain sets the clipping, Tone the brightness, Body the low-mid push, Level the output.

ParamRangeDefaultUnit
Gain1 – 8020—
Tone0 – 10.5—
Body0 – 10.5—
Level-30 – 6-8dB

# Timmy 1 input

Paul C Timmy-style transparent overdrive: low-gain op-amp soft clipping with cut-only Bass and Treble shaped BEFORE the gain (so it tightens and de-fizzes without adding colour) - clean, dynamic, amp-like. Gain sets the drive, Bass/Treble cut, Level the output.

ParamRangeDefaultUnit
Gain1 – 306—
Bass0 – 11—
Treble0 – 11—
Level-18 – 6-3dB

# Fulldrive 1 input

Fulltone Fulldrive-style overdrive: a TS-derived circuit opened up with less mid-hump and more gain on tap, asymmetric soft clipping that stays articulate when pushed, plus a cleaner Boost stage. Gain sets the drive, Tone the brightness, Boost stacks gain, Level the output.

ParamRangeDefaultUnit
Gain1 – 6014—
Tone0 – 10.5—
Boost0 – 10—
Level-24 – 6-6dB

# JfetStage 1 input

JFET common-source overdrive (true square-law device model, ckt::jfetId): the signal swings the gate of a J201-style JFET and its drain current Id = Idss(1-Vgs/Vp)^2 forms the output, which clips ASYMMETRICALLY - compressing toward zero-bias, cutting off at pinch-off - for the even-harmonic, dynamic, 'amp-like' warmth of a FET preamp stage. Drive sets the gate swing, Bias the operating point (asymmetry / edge of breakup), Tone a post treble tilt, Level the output.

ParamRangeDefaultUnit
Drive1 – 5010—
Bias-1.1 – -0.25-0.6—
Tone0 – 62dB
Level0 – 10.5—

# ZenerClip 1 input

Back-to-back Zener shunt clipper (Newton-solved, 4x oversampled): two Zeners anode-to-anode clip symmetrically at about +/-3.3 V - far more headroom than a silicon diode pair - so the signal passes clean until it slams into a hard knee. Louder and punchier than soft diode overdrive, the 'stays clean then cracks' character of high-headroom Zener/LED clipping stages. Drive sets the gain into the clipper, Tone a tilt around 1.2 kHz, Level the output.

ParamRangeDefaultUnit
Drive1 – 6018—
Tone0 – 10.5—
Level0 – 10.4—

# RectifierSag 1 input

Tube-rectifier power-supply sag: a model of the B+ supply drooping under load and recovering with the reservoir cap's RC time. Loud transients momentarily collapse the headroom (duck/compress) then BLOOM back as the supply recovers - the springy, touch-sensitive 'sag' of a tube amp with a 5U4/GZ34 rectifier, distinct from a feed-forward compressor. Drive sets the stage gain, Sag the droop depth, Recover the supply recovery time, Level the output.

ParamRangeDefaultUnit
Drive1 – 204—
Sag0 – 0.90.5—
Recover20 – 400120ms
Level0 – 10.6—

# EF86 1 input

EF86 pentode preamp (Vox AC15/AC30, Matchless front end): a pentode gain stage modeled by the 3/2-power Child-Langmuir plate law with a sharp cutoff (ckt::pentodeIp) - far more gain and a harder, faster-compressing grind than the triode stages in the amp models, with the asymmetric even-harmonic colour of a single tube stage. Drive sets the grid swing, Bias the operating point (edge of breakup / asymmetry), Tone a post treble tilt, Level the output.

ParamRangeDefaultUnit
Drive1 – 408—
Bias-2.4 – -0.6-1.3—
Tone0 – 62dB
Level0 – 10.5—

# OD1 1 input

Boss OD-1 OverDrive-style pedal: the original asymmetric soft-clipper (two diodes one way, one the other) for a smooth, warm, even+odd-harmonic break-up - lower gain and rounder than a Tube Screamer, with no mid hump. Drive sets the overdrive, Level the output (the real OD-1 has no tone knob).

ParamRangeDefaultUnit
Drive1 – 408—
Level-24 – 6-6dB

# Zendrive 1 input

Hermida Zendrive-style overdrive: a smooth, mid-focused 'Dumble-in-a-box' with singing sustain and a touch-sensitive, vocal break-up. Gain sets the drive, Tone the top end, Voice the upper-mid focus (the Dumble cut), Level the output.

ParamRangeDefaultUnit
Gain1 – 5012—
Tone0 – 10.5—
Voice0 – 10.5—
Level-24 – 6-6dB

# WoolyMammoth 1 input

ZVex Wooly Mammoth-style gated fuzz: a huge, square-wave synth-bass fuzz with the signature Pinch control - a starve/gate that chokes the low-level tail into a spluttery, ripped-speaker gate while keeping a massive low end. Wool sets the fuzz, Pinch the gate/starve, EQ the tone, Level the output.

ParamRangeDefaultUnit
Wool1 – 6025—
Pinch0 – 10.4—
EQ0 – 10.5—
Level-24 – 6-6dB

# ODR1 1 input

Nobels ODR-1-style natural overdrive: an op-amp soft-clipper with the signature Spectrum control that scoops the mids while bumping bass and treble together for a transparent, open, amp-like break-up - the Nashville session staple. Drive sets the gain, Spectrum the bass+treble vs mid balance, Level the output.

ParamRangeDefaultUnit
Drive1 – 5012—
Spectrum0 – 10.5—
Level-24 – 6-6dB

# AsymFold 1 input

Asymmetric triangle wavefolder: positive and negative excursions fold against a biased threshold for even-harmonic content, with a leaky DC servo that recenters the folded output.

ParamRangeDefaultUnit
Drive1 – 162—
Asym-1 – 10.3—
Level0 – 10.6—

# SlewShape 1 input

Slew-rate distortion: separate rise and fall step limits soften fast edges asymmetrically (TIM-style), generating triangular, program-dependent harmonics; mix blends the slewed and dry signals.

ParamRangeDefaultUnit
Rise0.01 – 10.3—
Fall0.01 – 10.3—
Mix0 – 11—

# NoiseShapeQuant 1 input

Noise-shaped quantizer: crushes the sample value to N levels but feeds the quantization error forward into the next sample, pushing the crush noise up out of the band a plain bit-crusher leaves it in.

ParamRangeDefaultUnit
Levels2 – 648—
Shape0 – 10.8—
Mix0 – 11—

# RectMorph 1 input

Rectifier morph: sweeps continuously from half-wave to full-wave rectification, generating octave-up and even-harmonic content; dry blend keeps the fundamental.

ParamRangeDefaultUnit
Morph0 – 10.5—
Dry0 – 10—
Level0 – 11—

# WaveWrap 1 input

Sinusoidal wavefolder: drives the signal through sin() so that increasing index folds it through multiple sine lobes (Serge-style), staying perfectly bounded while adding rich symmetric harmonics.

ParamRangeDefaultUnit
Index0 – 81—
Level0 – 10.8—

# DualBandDrive 1 input

Two-band saturator: a single crossover splits low and high bands that are tanh-driven independently before recombining, so you can grit the highs without muddying the lows (or the reverse).

ParamRangeDefaultUnit
Split100 – 4000600Hz
LoDrive1 – 102—
HiDrive1 – 102—
Level0 – 10.6—

# ChebyShaper 1 input

Chebyshev harmonic shaper: a Chebyshev polynomial of order N maps a sine input to its Nth harmonic exactly, letting you dial a specific overtone (2nd..6th) instead of a generic distortion smear.

ParamRangeDefaultUnit
Harmonic2 – 63—
Drive0 – 10.5—
Mix0 – 11—

# FoldSine 1 input

Phase-warped sine folder: folds through sin() like a sinusoidal folder but pre-warps the phase with a second-harmonic term, breaking the pure odd-harmonic symmetry to give a brighter, asymmetric fold spectrum.

ParamRangeDefaultUnit
Fold1 – 123—
Sym0 – 10.5—
Level0 – 10.8—

# CrossFold 2 inputs

Cross-modulated wavefolder: the fold threshold is set live by a second input, so one signal carves the folding ceiling of another - audio-rate fold-threshold modulation for spectra that move with the modulator.

ParamRangeDefaultUnit
Drive1 – 122—
Level0 – 10.7—

# DiodeClip 1 input

Antiparallel-diode clipper: the exponential Shockley curve (1 - e^-|x|) soft-clips with the smooth, rounded knee of a real diode pair rather than a hard or tanh limiter.

ParamRangeDefaultUnit
Drive1 – 204—
Level0 – 10.6—

# WaveMirror 1 input

Reflecting waveshaper: excursions past a slowly DC-tracked threshold are mirrored back down by an adjustable amount, folding ring-like overtones that recenter as the signal's bias drifts.

ParamRangeDefaultUnit
Amount0 – 10.5—
Level0 – 10.8—

# ChaosDrive 1 input

Chaos-modulated drive: a logistic-map iterator nudges the saturation gain every sample, so the distortion shimmers and never sits perfectly still - controlled instability between clean and crushed.

ParamRangeDefaultUnit
Drive1 – 124—
Chaos0 – 10.5—
Level0 – 10.6—

# AsymSat 1 input

Asymmetric saturator: positive and negative half-cycles are tanh-driven by independent amounts, producing even-harmonic, tube-like asymmetry you dial per polarity.

ParamRangeDefaultUnit
Pos1 – 123—
Neg1 – 125—
Level0 – 10.7—

# RectFold 1 input

Rectify-then-fold: full-wave rectification followed by triangle folding stacks octave-up rectifier content with fold harmonics for a dense, aggressive shaper unlike either stage alone.

ParamRangeDefaultUnit
Drive1 – 123—
Level0 – 10.7—

# AuralExciter 1 input

Aural exciter: high-passes the signal, generates new upper harmonics through a soft nonlinearity, high-passes again and adds them back - restoring air and presence without an EQ boost.

ParamRangeDefaultUnit
Freq1000 – 80003000Hz
Amount0 – 10.5—
Level0 – 10.8—

# AmpScan 1 input

Amplitude wave-scanner: the instantaneous level indexes a position in a single-cycle waveform, so louder samples read further through the cycle - a 1-D wave-terrain shaper with offset scanning, distinct from a direct sine folder.

ParamRangeDefaultUnit
Scans1 – 82—
Level0 – 10.8—

# BiasBreath 1 input

Breathing bias saturator: the signal envelope drives a DC offset into the input before a tanh stage (and removes it after), so the harmonic asymmetry swells with playing dynamics - quiet stays clean, loud goes asymmetric.

ParamRangeDefaultUnit
Drive1 – 103—
Breath0 – 10.5—
Level0 – 10.7—

# SlewFold 1 input

Tracking wavefolder: the fold threshold slews toward the signal level, so the fold density pumps and breathes with dynamics rather than staying fixed - a self-adjusting fold.

ParamRangeDefaultUnit
Drive1 – 123—
Track0 – 10.5—
Level0 – 10.7—

# BitLogic 1 input

Bitwise logic shaper: quantizes the sample to an integer and combines it with a bit-shifted copy of itself via AND/OR/XOR (the bytebeat trick), producing harsh digital staircase artifacts no analog circuit makes.

ParamRangeDefaultUnit
Bits2 – 168—
OpAND · OR · XOR—
Level0 – 10.6—

# SlewCrush 1 input

Slew + crush: a slew-rate limiter rounds the fast edges, then a noise-shaped quantizer drops the bit depth - the combined softening and grit of a cheap converter feeding a slow line.

ParamRangeDefaultUnit
Slew0.01 – 10.3—
Bits2 – 166—
Level0 – 10.8—

# TanhLadder 1 input

Cascaded tanh stages: several tanh gain stages in series compound their soft saturation, building the progressive, harmonically dense overdrive of a multi-stage tube preamp rather than a single clip.

ParamRangeDefaultUnit
Drive1 – 82—
Stages1 – 53—
Level0 – 10.6—

# AsymFuzz 1 input

Asymmetric fuzz: a bias offset pushes the signal into a hard clip that ceilings the two polarities at different levels, the gated, sputtery, even-harmonic snarl of a starved-bias fuzz pedal.

ParamRangeDefaultUnit
Drive1 – 408—
Bias-0.5 – 0.50.2—
Level0 – 10.6—

# WaveCrush 1 input

Crush-then-fold: a low-bit quantizer's staircase is fed straight into a triangle folder, so the quantization steps themselves get folded - a layered digital-plus-fold timbre neither stage makes alone.

ParamRangeDefaultUnit
Bits2 – 124—
Fold1 – 62—
Level0 – 10.7—

# EnvBitcrush 1 input

Dynamic bit-crusher: the quantizer's bit depth rides the input envelope, so loud passages stay clean and quiet tails crumble into lo-fi grit (or the reverse) - level-dependent digital decay.

ParamRangeDefaultUnit
MinBits2 – 83—
MaxBits4 – 1612—
Time1 – 20030ms
Level0 – 10.9—

# ZeroCrush 1 input

Zero-cross sample-hold: latches the input value at each rising zero crossing and holds it until the next, reducing the waveform to one stair-step per pitch period - a pitch-synced lo-fi staircase.

ParamRangeDefaultUnit
Mix0 – 11—
Level0 – 10.9—

# WaveMix 1 input

Blended waveshaper: one knob crossfades the transfer curve from soft tanh saturation to sinusoidal folding, sweeping the harmonic character from warm clip to bright fold in a single stage.

ParamRangeDefaultUnit
Shape0 – 10.5—
Drive1 – 62—
Level0 – 10.7—

# MuLaw 1 input

Mu-law compander: the logarithmic mu-law curve from telephone codecs squashes the dynamics nonlinearly, adding the gritty, level-dependent quantization grain of an 8-bit phone line.

ParamRangeDefaultUnit
Mu1 – 255100—
Mix0 – 11—
Level0 – 10.8—

# BitReverse 1 input

Bit-reversal scrambler: quantizes the sample and reverses the order of its bits, so the most and least significant bits swap roles - a violent, structured digital distortion with no analog analogue.

ParamRangeDefaultUnit
Bits2 – 128—
Mix0 – 11—
Level0 – 10.7—

# GrayFold 1 input

Gray-code folder: quantizes the sample and XORs it with its own Gray code (v ^ (v>>1)), refracting the waveform into a self-similar staircase of digital harmonics.

ParamRangeDefaultUnit
Bits2 – 128—
Level0 – 10.6—

# FoldCascade 1 input

Cascaded wavefolder: drives the signal through several fold stages at progressively tighter thresholds, multiplying the fold density into a dense, West-Coast complex-oscillator timbre.

ParamRangeDefaultUnit
Drive1 – 83—
Stages1 – 42—
Level0 – 10.7—

# ExpShaper 1 input

Exponential waveshaper: maps the signal through an exponential transfer curve so small signals stay small and large ones swell sharply, an aggressive convex distortion unlike the concave tanh.

ParamRangeDefaultUnit
Amount0 – 10.5—
Level0 – 10.7—

# ChebyBank 1 input

Chebyshev harmonic bank: generates harmonics 2..5 simultaneously via Chebyshev polynomials and mixes them by a spread control, sculpting a precise additive harmonic spectrum from a single waveshaper.

ParamRangeDefaultUnit
Spread0 – 10.5—
Drive0.5 – 21—
Level0 – 10.7—

# LorenzDrive 1 input

Lorenz-modulated drive: the Lorenz attractor's wandering x coordinate continuously bends the gain of a tanh saturator, so the distortion character drifts chaotically and organically as the signal passes through.

ParamRangeDefaultUnit
Drive1 – 103—
Speed0.001 – 0.020.006—
Level0 – 10.7—

# CrossDist 1 input

Multiband distortion: two crossovers split the signal into low, mid and high bands that are each saturated independently before recombining, so you can grind one band hard while keeping the others clean.

ParamRangeDefaultUnit
LoDrive1 – 102—
MidDrive1 – 103—
HiDrive1 – 102—
Level0 – 10.6—

# AbsShaper 1 input

Odd/even harmonic blender: crossfades between a tanh stage (odd harmonics, symmetric) and a rectifying stage (even harmonics, octave-up), letting you dial the exact odd-vs-even harmonic balance of the distortion.

ParamRangeDefaultUnit
Drive1 – 82—
Even0 – 10.5—
Level0 – 10.7—

# RingFuzz 1 input

Ring fuzz: ring-modulates the input against an internal sine, then slams the result into a hard fuzz clip, stacking clangorous inharmonic sidebands with gated fuzz spit for a destroyed, robotic tone.

ParamRangeDefaultUnit
Freq20 – 2000200Hz
Drive1 – 308—
Mix0 – 10.7—

# OctFuzz 1 input

Octave fuzz: blends a straight hard fuzz with a full-wave-rectified fuzz (an octave above), the classic Octavia/octave-up fuzz voice that screams an octave over the note when pushed.

ParamRangeDefaultUnit
Drive1 – 3010—
Oct0 – 10.6—
Level0 – 10.6—

# GatedFuzz 1 input

Gated fuzz: a hard fuzz clip followed by a fast noise gate, so the fuzz collapses into stuttering, velcro-ripping decay as notes die - the dying-battery / starved fuzz sound.

ParamRangeDefaultUnit
Drive1 – 4012—
Gate0 – 0.50.08—
Level0 – 10.6—

# TapeMachine 1 input

Tape machine: combines soft tape saturation, a slow wow pitch wobble via a modulated delay, and a hint of hiss into one block - the glued, warm, slightly-unstable character of analog tape.

ParamRangeDefaultUnit
Drive1 – 62—
Wow0 – 10.3—
Hiss0 – 10.1—

# LockhartFold 1 input

Lockhart wavefolder: the closed-form transfer curve of the Lockhart transistor folding cell (the heart of many West-Coast folders), giving smooth, analog-accurate fold harmonics rather than a piecewise reflection.

ParamRangeDefaultUnit
Drive0.5 – 83—
Level0 – 10.7—

# SergeFold 1 input

Serge wave multiplier: six folding cells at staggered offsets sum into the dense, bright, vocal-formant-like spectrum of a Serge VCM, a richer fold than a single threshold reflection.

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.6—

# TriToSine 1 input

Triangle-to-sine shaper: the soft-clipping transfer that classic analog VCOs use to round a triangle into a near-perfect sine, useful for warming any signal or deriving a sine from a triangle core.

ParamRangeDefaultUnit
Shape0 – 10.7—
Level0 – 10.8—

# TransformerSat 1 input

Transformer saturation: a hysteresis loop (the output lags and remembers, like a magnetized iron core) plus soft clipping models an audio transformer's low-end thickening and gentle history-dependent distortion.

ParamRangeDefaultUnit
Drive1 – 62—
Hyst0 – 10.4—
Level0 – 10.8—

# CrossoverDist 1 input

Crossover distortion: introduces a dead-band notch around zero like an underbiased class-B push-pull amplifier, adding the gritty, buzzy artefact that appears on low-level signal near the zero crossing.

ParamRangeDefaultUnit
Width0 – 0.40.1—
Level0 – 10.8—

# PowShaper 1 input

Power-law shaper: raises the signal's magnitude to a variable exponent (preserving sign), sweeping the transfer curve from expanding/concave below 1 to compressing/convex above - continuous control of harmonic content.

ParamRangeDefaultUnit
Exp0.3 – 41.5—
Level0 – 10.8—

# LogShaper 1 input

Logarithmic shaper: a log transfer curve lifts quiet detail steeply and compresses loud peaks, the opposite curvature of the exponential shaper - a bright, dense, low-level-emphasizing distortion.

ParamRangeDefaultUnit
Amount0.5 – 205—
Level0 – 10.7—

# AnalogClip 1 input

Variable clipper: one knob morphs the clipping knee from a smooth soft-clip to a hard brick wall, with an asymmetry/bias control for even harmonics - a general-purpose analog-flavored clipper covering the whole soft-to-hard range.

ParamRangeDefaultUnit
Drive1 – 123—
Hardness0 – 10.5—
Bias-0.3 – 0.30—
Level0 – 10.7—

# HarmonicMul 1 input

Harmonic multiplier: passes the signal through the Nth Chebyshev polynomial, which maps a sine to its exact Nth harmonic - a precise single-harmonic generator (octave at N=2, fifth-of-octave at N=3, etc.) for additive coloring.

ParamRangeDefaultUnit
N2 – 82—
Mix0 – 10.5—
Level0 – 10.8—

# AdaaTanh 1 input

Anti-aliased tanh: applies 1st-order antiderivative anti-aliasing (ADAA) to a tanh saturator, evaluating the average of the nonlinearity's integral across each sample step - hot drive without the harsh aliasing naive tanh produces.

ParamRangeDefaultUnit
Drive1 – 123—
Level0 – 10.7—

# OverdriveOS 1 input

Oversampled overdrive: linearly upsamples 2x, applies tanh saturation at the higher rate and averages back down, so the alias products generated by the distortion fall mostly above the audible band - cleaner high-gain tone.

ParamRangeDefaultUnit
Drive1 – 154—
Level0 – 10.7—

# AdaaHardClip 1 input

Anti-aliased hard clip: applies 1st-order antiderivative anti-aliasing to a brick-wall clipper, so the brutal clipping edges generate far less aliasing than a naive hard clip - aggressive yet clean digital clipping.

ParamRangeDefaultUnit
Drive1 – 204—
Level0 – 10.7—

# AdaaFold 1 input

Anti-aliased wavefolder: a sinusoidal folder with 1st-order antiderivative anti-aliasing, so hard driving into many folds generates far less of the harsh aliasing that plagues naive digital folders.

ParamRangeDefaultUnit
Drive0.5 – 83—
Level0 – 10.7—

# AdaaCubic 1 input

Anti-aliased cubic clip: the classic cubic soft-clip (1.5x - 0.5x^3, flat past unity) with 1st-order antiderivative anti-aliasing, giving warm odd-harmonic overdrive without the aliasing of the naive cubic.

ParamRangeDefaultUnit
Drive1 – 82—
Level0 – 10.7—

# ADAAsym 1 input

Anti-aliased asymmetric drive: a diode-like curve that saturates the two polarities differently (even + odd harmonics) with 1st-order antiderivative anti-aliasing, so the asymmetry's bright harmonics do not fold back as aliasing.

ParamRangeDefaultUnit
Drive1 – 103—
Asym0 – 10.5—
Level0 – 10.7—

# EnvFold 1 input

Envelope-driven wavefolder: the drive into a triangle folder rises with the input envelope, so quiet passages stay clean and loud ones fold into ever-brighter harmonics - dynamics-dependent folding with a DC servo.

ParamRangeDefaultUnit
Drive1 – 82—
EnvDepth0 – 10.5—
Level0 – 10.6—

# ChaosCrush 1 input

Chaotic bitcrusher: a logistic-map chaos generator wobbles the quantizer's bit depth on every decimated sample, so the crush noise floor wanders unpredictably instead of sitting at a fixed grit - a living, never-repeating lo-fi.

ParamRangeDefaultUnit
Bits2 – 168—
Chaos0 – 10.5—
Rate0.01 – 10.3—
Mix0 – 11—

# RectFuzzGate 1 input

Gated rectifier fuzz: full-wave rectification feeds a hard tanh fuzz (octave-up, even harmonics) that only opens when the envelope crosses a threshold, with a touch of crackle on the gate - a spitty, gated octave-fuzz.

ParamRangeDefaultUnit
Drive1 – 103—
Thresh0 – 0.50.05—
Level0 – 10.5—

# ZeroCrossGlitch 1 input

Zero-cross sample-hold: tracks the signed peak within each half-cycle and freezes the output to it until the next zero crossing, rebuilding the waveform as flat plateaus that snap on every crossing - a PWM-like, octave-rich square reconstruction.

ParamRangeDefaultUnit
Mix0 – 11—
Level0 – 10.8—

# HystShaper 1 input

Backlash distortion: the output only moves once the driven input pulls beyond a deadband around its last position, modelling mechanical play / relay hysteresis - it sticks then jumps, adding memory-dependent grit unlike any clip or fold.

ParamRangeDefaultUnit
Drive1 – 62—
Width0.01 – 0.60.15—
Level0 – 10.7—

# OctaveDivider 1 input

Analog-style sub-octave: a flip-flop toggles on every rising zero crossing of the input, producing a square one octave below that tracks the pitch; scaled by the input's own envelope so it follows dynamics, then blended under the dry signal for a thick sub.

ParamRangeDefaultUnit
Sub0 – 10.5—
Level0 – 10.8—

# FeedbackSaturator 1 input

Feedback saturation: the saturated output is low-passed and fed back into the saturator's input, so the distortion compounds on itself and the harmonics bloom and self-bias the way a cranked amp with a feedback loop does - richer and more compressed than a single tanh stage.

ParamRangeDefaultUnit
Drive1 – 163—
Feedback0 – 0.950.5—
Tone200 – 80003000Hz
Level0 – 10.6—

# SlewFuzz 1 input

Slew-then-fuzz: a slew-rate limiter rounds the fast edges (program-dependent triangular softening) before a hot tanh fuzz, so the fuzz bites on sustained energy but the rounded transients keep it from fizzing - a thick, controlled gnarl.

ParamRangeDefaultUnit
Rate0.005 – 0.50.08—
Drive1 – 205—
Level0 – 10.6—

# HermiteShaper 1 input

Hermite waveshaper: maps the input through a probabilist's Hermite polynomial He_n of selectable order, generating a specific harmonic (like Chebyshev shaping but on the Hermite basis), then tanh-limited - a precise, order-selectable harmonic adder.

ParamRangeDefaultUnit
Drive0.2 – 21—
Order2 – 53—
Level0 – 10.5—

# WaveshapeMorph 1 input

Morphing waveshaper: one knob crossfades the drive curve from a tanh saturator (odd harmonics, soft clip) to a sine wavefolder (dense fold harmonics), sweeping continuously from warm overdrive to bright metallic folding on the same input.

ParamRangeDefaultUnit
Drive1 – 123—
Morph0 – 10.5—
Level0 – 10.6—

# CrushFold 1 input

Crush-then-fold: the signal is bit- and sample-rate-crushed, then the stepped result is driven into a triangle wavefolder, so the quantization steps become hard fold edges - a harsh, aliased, digital-destruction timbre neither stage makes alone.

ParamRangeDefaultUnit
Bits2 – 166—
Rate0.05 – 10.4—
Fold1 – 41.5—
Level0 – 10.5—

# MultibandFold 1 input

Two-band wavefolder: a crossover splits the signal into low and high bands that are wavefolded with separate drive amounts, so the bass can stay clean while the highs shred (or vice versa) - frequency-selective folding that a full-band folder cannot do.

ParamRangeDefaultUnit
Cross100 – 4000800Hz
LowDrive1 – 62—
HighDrive1 – 63—
Level0 – 10.5—

# TiltDistort 1 input

Tilt-weighted saturation: the spectrum is tilted before a tanh stage and tilted back after, so the distortion bites hardest on the boosted band - dial Tilt positive to fizz only the highs, negative to grind only the lows, while the overall balance is restored.

ParamRangeDefaultUnit
Tilt-1 – 10.5—
Drive1 – 123—
Level0 – 10.6—

# TransientFold 1 input

Transient-keyed folder: a fast-minus-slow envelope detector measures the attack of each event and opens a wavefolder only on those transients, so the body of a sound stays clean while every hit cracks with a burst of fold harmonics - percussive brightening, not sustained grind.

ParamRangeDefaultUnit
Drive1 – 62—
Depth0 – 10.6—
Level0 – 10.6—

# ResonantFold 1 input

Resonant folder: a state-variable low-pass with adjustable resonance feeds a triangle wavefolder, so the resonant peak is driven into folding and rings into a screaming formant of fold harmonics - a vocal, whistling distortion that tracks the cutoff.

ParamRangeDefaultUnit
Cutoff60 – 60001000Hz
Reso0 – 0.90.5—
Drive1 – 62—
Level0 – 10.5—

# FractalFold 1 input

Recursive folder: the folded output is fed back into the folder's input, so each sample folds against a memory of the last fold - the harmonics build into a self-similar, evolving, fractal-like spectrum that a single-pass folder cannot make.

ParamRangeDefaultUnit
Drive1 – 82—
Feedback0 – 0.90.5—
Level0 – 10.5—

# MishShaper 1 input

Mish waveshaper: the self-gated neural activation x*tanh(ln(1+e^x)) used as a transfer curve - nearly linear for loud positive signal but with a smooth non-monotonic dip just below zero, adding a soft asymmetric saturation with subtle even harmonics distinct from tanh.

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.6—

# GeluShaper 1 input

GELU waveshaper: the Gaussian-error-linear-unit transfer 0.5x(1+tanh(sqrt(2/pi)(x+0.0447x^3))), which gates the signal by an approximate Gaussian CDF - a soft, slightly dipping asymmetric saturation that fades small signals and passes large ones, a gentler-than-Mish self-gate.

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.6—

# SoftplusShaper 1 input

Softplus waveshaper: the centred softplus ln(1+e^x)-ln2 as a transfer curve - it passes positive signal almost linearly but smoothly compresses negative excursions toward a floor, an asymmetric soft half-wave shaper rich in even harmonics (octave-up colour).

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.6—

# EluShaper 1 input

ELU waveshaper: the exponential-linear-unit transfer passes positive signal linearly but bends negative excursions through alpha*(e^x-1) toward a soft floor at -Alpha - a strongly asymmetric saturation that adds even harmonics and a tube-like one-sided compression.

ParamRangeDefaultUnit
Drive0.5 – 62—
Alpha0.5 – 31—
Level0 – 10.6—

# SoftsignShaper 1 input

Softsign waveshaper: the rational sigmoid x/(1+|x|), a soft clipper that saturates far more gradually than tanh and never quite reaches the rails - a smooth, gentle overdrive with a softer knee and longer transition than transcendental saturators.

ParamRangeDefaultUnit
Drive0.5 – 102—
Level0 – 10.7—

# SignedSquare 1 input

Signed square: sign(x)*x^2, which squares the magnitude while keeping the sign - so loud parts are pushed louder and quiet parts quieter (a downward expander curve) without the octave-up of a plain square, adding odd-harmonic edge as it expands.

ParamRangeDefaultUnit
Drive0.5 – 41.5—
Level0 – 10.6—

# ALawShaper 1 input

A-law companding: the telecom A-law transfer (linear below 1/A, logarithmic above), which heavily compresses level and lifts quiet detail - a gritty, lo-fi logarithmic saturation distinct from mu-law, with a hard knee at the 1/A breakpoint.

ParamRangeDefaultUnit
A2 – 10087.6—
Level0 – 10.7—

# Nroot 1 input

Signed nth root: sign(x)*|x|^(1/N), which lifts low-level signal toward unity while leaving the sign intact - so quiet detail is brought up (the opposite of squaring), brightening and thickening as N rises, a continuously-tunable root-law shaper.

ParamRangeDefaultUnit
N1 – 62—
Level0 – 10.6—

# SmoothClamp 1 input

Smooth clamp: passes the signal linearly until it reaches the Knee, then smoothly tanh-saturates the excess toward the +/-1 rails - a soft-knee limiter with a genuinely flat (undistorted) centre, distinct from a plain tanh that curves everywhere.

ParamRangeDefaultUnit
Knee0 – 0.950.6—
Level0 – 10.8—

# AsinShaper 1 input

Arcsine waveshaper: maps the clamped input through asin(x)/(pi/2), the inverse of a sine - so it steepens toward the rails and expands the mid-level (the opposite curvature of a sine soft-clip), brightening and adding odd harmonics as Drive pushes into the clamp.

ParamRangeDefaultUnit
Drive0.3 – 1.51—
Level0 – 10.6—

# CoshShaper 1 input

Cosh expander: sign(x)*(cosh(|x|*drive)-1), normalized, which grows faster than a square so loud signal is pushed up hard while quiet signal is suppressed - an aggressive upward-expansion shaper that adds odd harmonics and exaggerates dynamics, the opposite of a soft clip.

ParamRangeDefaultUnit
Drive0.5 – 31.5—
Level0 – 10.6—

# GudermannianShaper 1 input

Gudermannian waveshaper: maps the input through the Gudermannian gd(x)=2*atan(e^x)-pi/2, a transcendental soft-clip with a gentler knee than tanh and a softer approach to the rails - a smooth, transparent saturation that adds subtle odd harmonics without harsh edges.

ParamRangeDefaultUnit
Drive0.5 – 82—
Level0 – 10.6—

# AlgSigmoidShaper 1 input

Algebraic-sigmoid waveshaper: the rational soft-clip x/sqrt(1+(Drive*x)^2), which saturates faster than softsign but more gradually than a hard clip and is cheap to compute (no transcendentals) - a clean, neutral overdrive with a smooth rail approach.

ParamRangeDefaultUnit
Drive0.5 – 102—
Level0 – 10.7—

# ParabolicSatShaper 1 input

Parabolic-saturation waveshaper: passes the signal through x*(2-|x|) up to unity then hard-limits, so the approach to the rails is a smooth parabola rather than a tanh curve - a punchy soft-clip with a distinct second-harmonic-tinged knee, then a clean ceiling.

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.6—

# SinhExciter 1 input

Sinh exciter: shapes the signal through sinh(Drive*x)/sinh(Drive), an expanding transfer curve that is the mirror image of tanh saturation - instead of squashing peaks it pushes mid and high levels outward, exaggerating dynamics and adding bright odd harmonics. A de-compressing exciter rather than a soft-clipper. Normalized so unity input stays unity.

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.7—

# LangevinShaper 1 input

Langevin waveshaper: shapes the signal through the Langevin function L(x)=coth(x)-1/x, the saturation curve of paramagnetic and ferrofluid magnetization - a sigmoid that approaches the rails more gently than tanh and with a softer knee, giving a smooth, magnetic-style saturation. Normalized so unity input maps to full scale at the chosen Drive.

ParamRangeDefaultUnit
Drive0.5 – 82—
Level0 – 10.7—

# BentIdentityShaper 1 input

Bent-identity shaper: passes the signal through (sqrt(x^2+1)-1)/2 + x, a curve that is almost a straight line but bends slightly and asymmetrically around zero - so it stays near-transparent while adding a touch of low-order (mostly even) harmonic warmth. A subtle console-style colour rather than an overt distortion. Drive sets the bend amount.

ParamRangeDefaultUnit
Drive0.5 – 41—
Level0 – 10.6—

# GompertzShaper 1 input

Gompertz waveshaper: shapes the signal through the asymmetric double-exponential sigmoid 2*e^(-e^(-Drive*x))-1, which approaches its lower and upper rails at different rates - unlike the symmetric tanh, this lopsidedness injects strong even harmonics and a tube-like asymmetry. A distinctly coloured saturation; a transfer-curve use of the Gompertz growth function.

ParamRangeDefaultUnit
Drive0.5 – 62—
Level0 – 10.6—

# VirtualBass 1 input

Virtual bass / missing-fundamental enhancer: isolates the sub-bass band, rectifies it to synthesize a harmonic series (2f, 3f, 4f...) of the fundamental, then mixes those upper-bass harmonics back with the dry signal. The ear fuses the harmonics into the residue pitch of the absent fundamental, so a small speaker that cannot reproduce 50 Hz still seems to - the MaxxBass/psychoacoustic-bass principle. Distinct from a sub-octave generator, which adds a lower octave the speaker still cannot play.

ParamRangeDefaultUnit
Freq40 – 250100Hz
Drive0 – 41.5—
Mix0 – 10.6—
Level0 – 21—

# Waveset 1 input

Waveset distortion (Trevor Wishart, 'Audible Design'): slices the in0 signal into wavesets - the segments between upward zero-crossings - and plays each one Repeat times before moving on, dropping the input in between. Repeating every waveset time-stretches and drops the pitch in gritty, vowel-like steps that track the signal's own period, not a fixed grid - the classic granular-but-pitch-synchronous Wishart sound. Repeat sets how many times each waveset loops, Mix blends dry/wet. in0 = Audio In.

ParamRangeDefaultUnit
Repeat1 – 163—
Mix0 – 11—

# Saturator 1 input

Multi-mode saturator: drives the in0 signal into one of four waveshaping curves - tanh, soft tube, sigmoid or hard clip - with Tone tilting the result darker/brighter, output-level compensation, and a dry/wet Mix. A clean, controllable distortion stage distinct from the modeled fuzz/amp circuits.

ParamRangeDefaultUnit
Drive1 – 324—
ModeTanh · Tube · Sigmoid · Hard—
Tone0 – 10.6—
Mix0 – 11—

# Decimator 1 input

Bit-crusher + sample-rate reducer: quantises the in0 signal to Bits resolution and holds each sample for Downsample steps, for everything from gentle lo-fi grit to full 8-bit / telephone destruction. Mix blends against the clean signal. Distinct from Bitcrush in adding the sample-rate-reduction (aliasing) stage.

ParamRangeDefaultUnit
Bits1 – 168—
Downsample1 – 644—
Mix0 – 11—

# Wavemult 1 input

West-coast wave multiplier (Serge/Buchla-style): cascades several triangle wavefolders so the signal is folded again and again as Drive rises, multiplying the harmonics far beyond a single Wavefolder for ringing, metallic, formant-rich timbres. Drive sets the fold depth, Stages the number of cascaded folders (more = denser), Bias the fold asymmetry, and Mix the dry/wet blend.

ParamRangeDefaultUnit
Drive0 – 102—
Stages1 – 42—
Bias-1 – 10—
Mix0 – 11—

# Roar 1 input

Feedback waveshaper (Ableton Roar-style): drives the signal through a selectable saturation curve, but wraps it in a resonant feedback loop - the distorted output is band-passed at Color and fed back into the input, so it rings, blooms and self-oscillates into the gnarly 'roar' that plain saturation can't make. Drive sets the push into the Shape (soft sine / tube / soft clip / diode / fold), Tone tilts the spectrum before the shaper, Feedback how much output returns, Color the feedback resonance frequency, and Mix the dry/wet. (Single-shaper core; the full device's serial/parallel/multiband/mid-side routings need a rack.)

ParamRangeDefaultUnit
Drive0 – 10.4—
ShapeSoft Sine · Tube · Soft Clip · Diode · Fold—
Tone-1 – 10—
Feedback0 – 0.980.3—
Color60 – 8000600Hz
Mix0 – 11—

# DrumBuss 1 input

Drum-bus processor (Ableton Drum Buss-style): a one-stop chain for drum groups - Transient sharpens or softens the attack, Drive adds tube grit, Crunch a harder harmonic edge, and Boom adds a tuned resonant low-end thump at BoomFreq. Mix blends it back. Glues and beefs up a drum bus in one block.

ParamRangeDefaultUnit
Drive0 – 10.3—
Crunch0 – 10.2—
Transient-1 – 10.2—
Boom0 – 10.3—
BoomFreq40 – 20080Hz
Mix0 – 11—

# Drive 1 input

Waveshaping overdrive with three curves (Type: tanh soft-clip, sine fold, or hard clip) driven by up to 48 dB of gain plus a Bias offset for even-harmonic asymmetry. A post Tone low-pass tames fizz, Mix blends dry/wet, and Output trims the final level. Spans subtle warmth to aggressive distortion depending on Drive and curve.

ParamRangeDefaultUnit
Drive0 – 4812dB
Output-24 – 6-6dB
Bias-1 – 10—
Tone200 – 1800018000Hz
Mix0 – 11—
Type0 – 20—

# Wavefolder 1 input

West-coast wavefolder that multiplies the signal by Fold and reflects it through triangle folding boundaries, adding bright harmonics that bloom as level rises. Bias shifts the fold symmetry for asymmetric timbres, Mix blends dry/wet and Output trims gain. Unlike clipping, folding keeps energy moving, so the tone stays lively even at extreme settings.

ParamRangeDefaultUnit
Fold1 – 122—
Bias-1 – 10—
Mix0 – 11—
Output-24 – 60dB

# Bitcrush 1 input

Digital degradation: Bits quantizes the amplitude to 2^Bits levels (quantization noise) while Downsample holds each sample for N frames (sample-rate reduction and aliasing). Mix blends against the dry signal. Low Bits gives gritty lo-fi crunch; high Downsample adds metallic aliasing for retro and 8-bit textures.

ParamRangeDefaultUnit
Bits1 – 168—
Downsample1 – 644x
Mix0 – 11—

# StochasticResonance 1 input

Stochastic resonance: the counter-intuitive effect where adding NOISE to a weak, sub-threshold signal HELPS it through a nonlinearity instead of burying it. The signal drives a bistable double-well system (x' = Barrier*x - x^3 + Drive*in + noise) that hops between its two states; a tuned amount of noise makes those hops follow the weak input, recovering and amplifying detail a gate or expander would simply cut. Too little noise and nothing crosses, too much and it is random - the sweet spot in between is the resonance, so SWEEP Noise to find it. A gritty, alive texture/recovery tool with no equivalent in the catalog. Drive scales the input into the wells, Noise the assist level, Barrier the well depth/threshold, Mix the blend.

ParamRangeDefaultUnit
Drive0 – 41—
Noise0 – 10.5—
Barrier0.3 – 21—
Mix0 – 11—

# FeedbackShaper 1 input

Self-modulating waveshaper: the block's OWN previous output is fed back into the shaping curve - y = tanh(Drive*in + Feedback*y_prev) - so the distortion bends itself every sample. From warm saturation up into chaotic screaming as Feedback rises; a living, unstable fuzz no static waveshaper can make. Drive sets gain, Feedback the self-modulation, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 506—
Feedback0 – 0.950.3—
Mix0 – 11—

# AsymWrap 1 input

Asymmetric wrap/fold: positive swings WRAP around a ceiling (sawtooth wraparound -> a brash, octave-rich buzz) while negative swings soft-clip with tanh. The deliberate lopsidedness throws strong even harmonics and a glitchy upper octave that symmetric folders never produce. Drive pushes it, Ceiling sets the positive wrap point, Mix blends.

ParamRangeDefaultUnit
Drive1 – 204—
Ceiling0.2 – 21—
Mix0 – 11—

# HysteresisQuant 1 input

Hysteresis quantizer: a stepped quantizer with a DEADBAND - it holds its current step and only jumps to a new one once the input moves past the deadband, so dithery, wandering signals stop chattering between adjacent steps. Glitch-free stair-stepping with a sticky, lagged digital character. Steps sets the resolution, Deadband the stickiness, Mix the blend.

ParamRangeDefaultUnit
Steps2 – 4812—
Deadband0 – 10.4—
Mix0 – 11—

# EnvCrush 1 input

Envelope-driven bit-crusher: the bit depth tracks the input LEVEL, so loud passages stay clean and quiet passages dissolve into gritty quantization - the opposite of how digital normally behaves, like a dying battery or a sample-player running out of headroom on the tails. Floor/Ceil set the bit-depth range, Sens how fast the level pulls it, Mix the blend.

ParamRangeDefaultUnit
Floor1 – 83—
Ceil4 – 1612—
Sens0.2 – 82—
Mix0 – 11—

# GravityQuant 1 input

Magnetic quantizer: instead of hard-snapping to a grid, the output is PULLED toward the nearest grid level by a continuous spring (Strength). At low Strength it just nudges the signal toward the steps for a subtle pitch/level magnetism; at full Strength it becomes a hard quantizer. The in-between gives a soft, gravitational stair-step. Levels sets the grid, Strength the pull.

ParamRangeDefaultUnit
Levels2 – 4812—
Strength0 – 10.5—

# FloatCrush 1 input

Floating-point crusher: quantizes the MANTISSA at the signal's own exponent, so the quantization step scales WITH the level (like low-bit floating-point audio) - the noise floor rides up and down with the signal instead of sitting at a fixed level as in a normal (linear) bit-crusher. A subtler, more 'alive' digital grit. Mantissa sets the kept bits, Mix the blend.

ParamRangeDefaultUnit
Mantissa1 – 124—
Mix0 – 11—

# ShotNoise 1 input

Shot noise: adds grit whose loudness follows the PHYSICAL shot-noise law - its amplitude scales with the square root of the instantaneous signal level (sqrt(|x|)), the way photon/electron shot noise grows with current. So the noise tracks the signal's contour instead of sitting flat: a self-masking, signal-dependent fizz that disappears in the gaps. Amount sets the noise gain, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.3—
Mix0 – 11—

# SagClip 1 input

Sag clipper: the clipping ceiling DROPS as the running level rises, modelling a power supply that sags under load - so sustained loud passages compress and clip harder while transients punch through before the rail collapses. A living, dynamic distortion that breathes, unlike a fixed clipper. Drive pushes it, Sag how far the rail collapses, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 304—
Sag0 – 10.5—
Mix0 – 11—

# PhaseBurn 1 input

Phase burn: a first-order all-pass whose coefficient is driven by the SIGNAL ITSELF (a shaped, level-dependent phase shift), so the waveform's phase smears and self-warps more as it gets louder - a frequency-dependent, dynamic phase distortion that adds a hollow, vowel-like movement and grit on transients without changing the amplitude curve. Drive scales the modulation, Amount the burn depth, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 204—
Amount0 – 10.5—
Mix0 – 11—

# ChaosFold 1 input

Chaotic wavefolder: the fold density is steered every sample by a logistic chaos map running in its turbulent regime, so the harmonics shimmer and scramble unpredictably - a folder that never repeats, between a controllable warble (low Chaos) and a fully scrambled metallic roar (high Chaos). Drive sets the input gain, Chaos the strangeness of the modulation, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 123—
Chaos0 – 10.5—
Mix0 – 11—

# TransientExciter 1 input

Transient exciter: harmonics are added ONLY during attacks - a fast/slow envelope split detects each onset and injects bright odd harmonics that fade as the note settles, so picks, hits and consonants get crisp bite while sustains stay clean. The opposite of smearing. Amount sets the bite, Sharp the harmonic edge, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Sharp0 – 10.5—
Mix0 – 11—

# Sizzle 1 input

Sizzle: an HF exciter that generates fizzy new top end from the signal's OWN high frequencies (it shapes the highpassed content, so it only sizzles where there is already brightness, never on bass). Adds air, presence and a metallic crackle. Drive sets the harmonic heat, Amount the added sizzle, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 308—
Amount0 – 10.4—
Mix0 – 11—

# GrowlBox 1 input

Growl box: at random zero crossings the polarity of an added sub-octave FLIPS, so the period randomly doubles and the tone breaks into a gnarly, sputtering sub-harmonic growl/multiphonic - the controlled chaos of a fuzz on the edge of tracking. Amount sets the sub level, Chaos how often it flips (smooth octave-down at 0, chaotic growl high), Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Chaos0 – 10.4—
Mix0 – 11—

# BitStick 1 input

Stuck-bit glitch: instead of quantizing every sample, the output randomly STICKS at its previous quantized value and only refreshes with probability (1 - Stick) - like a failing converter with stuck pixels, freezing little plateaus of the waveform into a jittery, broken digital texture. Steps sets the resolution, Stick the freeze probability, Mix the blend.

ParamRangeDefaultUnit
Steps2 – 6416—
Stick0 – 0.990.5—
Mix0 – 11—

# Munge 1 input

Munge: a digital mangler that flips between a small bank of per-sample operations (clean, invert, full-wave rectify, sine fold) on a random clock, so the waveform is mauled into a glitchy, ever-shifting destruction. No two passes mangle the same way. Rate sets how fast the operation switches, Amount the wet level, Mix the blend.

ParamRangeDefaultUnit
Rate1 – 40040Hz
Amount0 – 11—
Mix0 – 11—

# Snarl 1 input

Snarl: a high-resonance band-pass parked in the low-mids feeds a saturator, so the signal grows a vicious vocal-formant growl - a snarling, throaty bite midway between a wah stuck in place and a fuzz. Freq sets where it snarls, Drive the aggression, Mix the blend.

ParamRangeDefaultUnit
Freq150 – 2000600Hz
Drive1 – 123—
Mix0 – 11—

# Corrode 1 input

Corrode: a bit-depth that DROPS the longer the signal is sustained loud, so a held note progressively decays into a coarse, quantized, corroded version of itself, then recovers resolution in the gaps. Rate sets how fast it corrodes, Mix the blend.

ParamRangeDefaultUnit
Rate0 – 10.5—
Mix0 – 11—

# Pulverize 1 input

Pulverize: the signal is run through a stack of sine wavefolders in series, each one pulverizing the last, so a clean tone is ground into a dense, buzzing cloud of high harmonics. The more stages, the finer the powder. Drive sets the input level, Stages the grind depth, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 82—
Stages1 – 53—
Mix0 – 11—

# Magnetize 1 input

Magnetize: a saturator with magnetic HYSTERESIS - the transfer curve lags differently on the rising and falling edges, tracing a loop like tape magnetization, which adds warmth, a soft memory smear and even-order colour the way a real magnetic medium does. Drive sets the level into the loop, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 163—
Mix0 – 11—

# Polarize 1 input

Polarize: the asymmetry of a soft clipper is slowly swept by an LFO, so the bias drifts and the generated even harmonics wax and wane over time - the tone breathing between symmetric (odd-only) and lopsided (even-rich) saturation. Rate sets the sweep, Depth the bias swing, Mix the blend.

ParamRangeDefaultUnit
Rate0.05 – 40.4Hz
Depth0 – 10.6—
Mix0 – 11—

# ZenerClamp 1 input

Zener clamp: a voltage-reference clamp that limits asymmetrically - a soft forward knee one way, a harder reverse-breakdown wall the other - so the waveform is squashed lopsidedly the way a Zener-diode protection circuit clips, adding strong even harmonics. Forward sets the soft side, Reverse the breakdown wall, Mix the blend.

ParamRangeDefaultUnit
Forward0.2 – 10.7—
Reverse0.1 – 10.4—
Mix0 – 11—

# DomainFlip 1 input

Domain flip: a hysteretic staircase quantizer modelling magnetic domains that only flip once the input pushes far enough past the current level - so the output sticks on a step then jumps, tracing the jagged Barkhausen staircase rather than the smooth signal. Step sets the flip threshold, Mix the blend.

ParamRangeDefaultUnit
Step0.02 – 0.40.12—
Mix0 – 11—

# DeltaSigma 1 input

Delta-sigma crush: re-quantizes the audio to a single bit with first-order noise shaping (an error-feedback modulator), turning the signal into a dense +/-1 pulse-density stream like a 1-bit DSD converter - harsh, grainy, with the quantization noise pushed up high. Then a low-pass recovers a gritty version. Tone sets the recovery filter, Mix the blend.

ParamRangeDefaultUnit
Tone1000 – 160008000Hz
Mix0 – 11—

# SlopeOverload 1 input

Slope overload: a slew-rate-limited follower that can only change so fast, so when the input moves quicker than the limit it lags behind and overshoots - the slope-overload and granular-noise distortion of a delta / CVSD modulator. Slow signals stay clean, fast ones tear. Slew sets the rate limit, Mix the blend.

ParamRangeDefaultUnit
Slew0.001 – 0.20.03—
Mix0 – 11—

# SlewChew 1 input

Slew chew: a slew limiter with DIFFERENT rise and fall rate caps, so the waveform is chewed asymmetrically - sharp on one edge, rounded on the other - bending the shape and pumping in even harmonics, the lopsided cousin of a symmetric slew. Rise sets the up-rate, Fall the down-rate, Mix the blend.

ParamRangeDefaultUnit
Rise0.005 – 0.30.08—
Fall0.005 – 0.30.03—
Mix0 – 11—

# GridConduction 1 input

Grid conduction: when the drive swings positive past the bias the tube's grid starts drawing current and clamps that half hard, while the negative half stays soft - the asymmetric blocking distortion of an overdriven valve grid that gives tube amps their compressed, sagging bite. Drive sets the push, Bias where conduction starts, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 164—
Bias0 – 0.80.4—
Mix0 – 11—

# BiasStarve 1 input

Bias starve: a starved-plate, dying-battery fuzz - low supply voltage chokes the gain, so notes splat, sputter, gate and sag with a sick, broken-up 'velcro' decay that collapses as it starves. Starve sets how low the supply runs, Drive the gain into it, Mix the blend.

ParamRangeDefaultUnit
Starve0 – 10.6—
Drive1 – 206—
Mix0 – 11—

# SampleRot 1 input

Sample rot: the effective sample rate decays the longer a note sustains - the decimation deepens over a held tone so it grows progressively more aliased and gritty, then refreshes in the gaps. A time-axis companion to bit-rot, on the rate axis instead of the depth axis. Rate sets the rot speed, Mix the blend.

ParamRangeDefaultUnit
Rate0 – 10.5—
Mix0 – 11—

# CapLeak 1 input

Capacitor leak: a slow DC bias leaks in proportional to the recent signal and bleeds away in silence, drifting the operating point so the clipping turns lopsided and wanders - the bias-creep of a leaky coupling capacitor that never quite settles. Amount sets the leak, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# LPCWhiten 1 input

Linear-prediction whitener: a one-tap adaptive predictor (NLMS) continuously guesses the next sample from the last one and outputs only the prediction ERROR, so the predictable, resonant part is subtracted away and what's left is the flat, whitened, edgy residual - instant presence and de-resonance. Amount sets how much residual replaces the signal, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.6—
Mix0 – 11—

# TriState 1 input

Tri-state quantizer: collapses the signal to just three levels - full positive, full negative, or zero inside a central dead band - so it squares up like an infinite clipper but with a silent gap around zero, giving a gated, telegraph-like buzz. Dead sets the size of the zero zone, Mix the blend.

ParamRangeDefaultUnit
Dead0.01 – 0.50.1—
Mix0 – 11—

# GeoFold 1 input

Geometric folder: a wavefolder whose fold spacing is logarithmic rather than linear, so the harmonics it adds are spread geometrically (octave-like) instead of evenly - a brighter, bell-ier, more musical fold than the usual triangle/sine wrap. Drive sets how deep it folds, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 163—
Mix0 – 11—

# SpectralClip 1 input

Band clipper: splits the signal into low and high bands and clips ONLY the highs, leaving the lows clean - so you get crunchy, distorted top end riding over an undistorted, solid bottom, the inverse of the usual full-range fuzz that turns bass to mush. Drive sets the high-band clip, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 306—
Mix0 – 11—

# BitRotate 1 input

Bit rotate: quantizes to a byte then circularly ROTATES the bits, so the most-significant (loudest) bits wrap down into the least-significant places - a violent, non-monotonic remapping that turns smooth ramps into buzzing digital staircases. Distinct from bit-crushing: no information is dropped, it's scrambled. Bits sets the rotation amount, Mix the blend.

ParamRangeDefaultUnit
Bits1 – 73—
Mix0 – 11—

# XorFold 1 input

XOR fold: bit-wise exclusive-ORs the current sample against a delayed copy of itself, a digital comb that carves jagged, metallic, glitch-ridden notches no analog filter can make - the harmonics interfere at the BIT level rather than the amplitude level. Time sets the delay, Mix the blend.

ParamRangeDefaultUnit
Time0.1 – 405ms
Mix0 – 11—

# SlewStep 1 input

Slew step: quantizes to a coarse staircase but then GLIDES toward each new step at a limited rate instead of jumping, so you get the lo-fi stepping of a bit-crusher with smooth ramps between treads - a soft, gooey digital quantization rather than a hard one. Steps sets the resolution, Slew the glide rate, Mix the blend.

ParamRangeDefaultUnit
Steps2 – 6412—
Slew0.002 – 0.30.05—
Mix0 – 11—

# BitParity 1 input

Parity fuzz: quantizes the sample and inverts its polarity whenever the parity (XOR of all its bits) is odd - so the waveform is flipped on a fine, signal-dependent bit pattern, generating a dense, dirty, ring-mod-like fuzz that tracks the amplitude in a chaotic, digital way. Bits sets the resolution, Mix the blend.

ParamRangeDefaultUnit
Bits1 – 84—
Mix0 – 11—

# ChaosClip 1 input

Chaos clipper: a hard clipper whose ceiling is jittered every sample by a logistic chaos map, so the clip level dances unpredictably between tight and loose - the distortion shimmers and crackles with a living, never-repeating edge instead of a static wall. Drive sets the push, Chaos the ceiling jitter, Mix the blend.

ParamRangeDefaultUnit
Drive1 – 163—
Chaos0 – 10.5—
Mix0 – 11—

# PowerShape 1 input

Power-law shaper: raises the signal to a variable exponent (preserving sign), so below 1 it expands quiet detail and rounds the peaks while above 1 it contracts, hollowing the body and sharpening the spikes - a continuous control over the whole transfer curve's shape from soft-and-fat to hard-and-thin. Exp sets the exponent, Mix the blend.

ParamRangeDefaultUnit
Exp0.3 – 31—
Mix0 – 11—

# Waveshaper 1 input

Memoryless waveshaper with four transfer curves (Shape: tanh, atan, cubic soft-clip, sine fold) driven by Drive and blended via Mix. Each curve adds a different harmonic signature, from smooth saturation (tanh/atan) to a foldback character (sine). Lighter-weight than Drive when you just want one fixed shaping curve.

ParamRangeDefaultUnit
Drive1 – 202—
Shape0 – 30—
Mix0 – 11—

# Exciter 1 input

Harmonic exciter: splits off the band above Freq, generates new upper harmonics from it with a tanh Drive, and blends them back via Amount for added air and presence. Subtle settings add sheen and intelligibility without raising broadband level. Most effective on dull vocals, drums and full mixes.

ParamRangeDefaultUnit
Freq500 – 120003000Hz
Drive1 – 204—
Amount0 – 10.4—

# Lofi 1 input

Lo-fi degrader: sample-rate reduction (holds each sample for Rate frames) plus a Tone low-pass and added tape Hiss, blended via Mix. Unlike Bitcrush it quantizes in time rather than bit-depth, layering filtering and noise for a warmer vintage-sampler grime. Push Rate for aliasing; lower Tone and raise Hiss for cassette/SP-style character.

ParamRangeDefaultUnit
Rate1 – 648x
Tone500 – 120004000Hz
Hiss0 – 10.05—
Mix0 – 11—

# Tube 1 input

Tube-style saturation: an asymmetric transfer curve (offset by Bias) adds the even and odd harmonics of a valve stage, tamed by a Tone low-pass and blended via Mix. Warmer and rounder than the harder Drive/Waveshaper - subtle settings thicken and glue, higher Drive gives singing tube grit. See the TubePre and VariMu analog models for circuit-specific versions.

ParamRangeDefaultUnit
Drive0 – 3612dB
Bias0 – 10.3—
Tone500 – 160008000Hz
Mix0 – 11—

# Clip 1 input

Clipper that morphs from soft (tanh) to hard clipping at the Threshold via Hardness, with Output trim and dry/wet Mix. Soft adds rounded saturation harmonics; hard adds bright odd harmonics and caps peaks dead. Use as a tone shaper or a transparent peak ceiling ahead of a limiter.

ParamRangeDefaultUnit
Threshold-24 – 0-6dB
Hardness0 – 10.5—
Output-12 – 120dB
Mix0 – 11—

# Shaper 1 input

SynthMaster-style 12-mode waveshaper: Shape selects soft/hard clip, tube, diode, sine and triangle fold, full/half rectify, sine, crush, sync-wrap and Chebyshev modes, each driven by Drive with Bias for symmetry. Mix and Output blend and trim. Modulate Shape to morph between distortion characters - a one-stop tone-shaping distortion.

ParamRangeDefaultUnit
Drive0 – 3612dB
Shape0 – 110—
Bias-1 – 10—
Mix0 – 11—
Output-24 – 60dB

# Rectify 1 input

Rectifier waveshaper: full-wave (Mode 0) folds the negative half upward to add strong octave-up and even harmonics, while half-wave (Mode 1) keeps only the positive half. Mix blends with the dry signal. The classic octave-fuzz colour - aggressive alone, useful in small amounts for harmonic lift.

ParamRangeDefaultUnit
Mode0 – 10—
Mix0 – 11—

# Fuzz 1 input

High-gain fuzz: heavy drive soft-saturates then hard-clips into a square wave for a thick, sustaining buzz, with a Tone low-pass to tame the fizz and Level to set output. Mix blends dry/wet. Aggressive and compressed - see the BigMuff and FuzzFace analog models for circuit-specific fuzz voicings.

ParamRangeDefaultUnit
Drive0 – 4824dB
Tone0 – 10.5—
Level-24 – 6-8dB
Mix0 – 11—

# OctaveFuzz 1 input

Octave fuzz: blends a fuzz-distorted signal with a DC-corrected full-wave-rectified upper octave, the classic Hendrix/Octavia scream. Drive sets gain, Octave the upper-octave blend and Mix dry/wet. Tracks best on clean single notes near the 12th fret; chords intermodulate, by design.

ParamRangeDefaultUnit
Drive0 – 4824dB
Octave0 – 10.6—
Mix0 – 11—

# Chebyshev 1 input

Chebyshev-polynomial shaper that synthesizes a single chosen Harmonic (2nd-8th) from the input via the T_n recurrence, blended by Amount and Mix. Unlike broadband clipping it adds one targeted overtone - the 2nd for octave thickness, higher orders for metallic ring. Pairs well with a clean sine input for precise harmonic generation.

ParamRangeDefaultUnit
Harmonic2 – 82—
Amount0 – 10.5—
Mix0 – 11—

# SubEnhance 1 input

Sub-bass enhancer: a flip-flop toggled per rising zero crossing generates a half-frequency square tracked by the input envelope and low-passed, added under the dry signal at Sub. Reinforces weak low end on kicks, bass and 808s. Monophonic by nature - best on clean low-register sources.

ParamRangeDefaultUnit
Sub0 – 10.5—
Mix0 – 11—

# TapeSat 1 input

Tape-style saturation: a soft tanh stage with a touch of linear blend emulates magnetic-tape compression, with Warmth rolling off the highs for a rounder tone and Mix blending dry/wet. Gentle glue and harmonic thickening rather than overt distortion. See the Studer and Ampex analog models for machine-specific tape.

ParamRangeDefaultUnit
Drive0 – 3612dB
Warmth0 – 10.4—
Mix0 – 11—

# XformerSat 1 input

Transformer saturation: asymmetric soft-clipping knees (different for positive and negative swings) add even-harmonic colour, plus a low-passed component for iron-core low-end thickening. Subtle weight and warmth on bass, drums and the mix bus. See the NevePre analog model for a transformer-preamp variant.

ParamRangeDefaultUnit
Drive0 – 3612dB
Mix0 – 11—

# DynSat 1 input

Dynamic saturation: the drive amount tracks the input envelope, so louder passages distort more and quiet ones stay clean (Sens sets how strongly). Adds harmonics on transients and peaks without muddying sustained low-level material. Good for program-dependent grit on drums and bus.

ParamRangeDefaultUnit
Drive0 – 366dB
Sens0 – 10.5—
Mix0 – 11—

# Erosion 1 input

Noise-modulation distortion: sprays band-limited noise (Freq sets its colour) onto the signal by multiplying it with the input, eroding the tone into gritty granular texture. Amount sets intensity and Mix dry/wet. From subtle dirt to harsh destruction - a creative degrade rather than a clean overdrive.

ParamRangeDefaultUnit
Amount0 – 10.4—
Freq0 – 10.5—
Mix0 – 11—

# Character 1 input

Character drive with five voicings (Mode): Push (soft clip), Heat (S-clip), Soar (sine fold), Howl (triangle fold) and Shred (wrap fold), each driven by Drive and blended via Mix. One module spanning warm saturation to wild folding distortion. Modulate Mode or Drive for evolving textures.

ParamRangeDefaultUnit
Drive0 – 3612dB
Mode0 – 40—
Mix0 – 11—

# Vinyl 1 input

Vinyl character that reads the signal through a slowly modulated delay for wow pitch-drift, injects random impulses for surface crackle, and pushes the result through a tanh saturator for groove distortion. Wow scales the pitch-drift depth, Crackle sets how often surface pops appear, Drive sets the saturation amount, and Mix sets dry/wet. Use it to age a clean source with turntable wobble, dust noise and warm grit.

ParamRangeDefaultUnit
Crackle0 – 10.4—
Wow0 – 10.3—
Drive0 – 10.3—
Mix0 – 11—

# AmpSim 1 input

Guitar amp model chaining an asymmetric tanh preamp, a tone-tilt filter and a speaker-cabinet low-pass with output compensation. Drive sets preamp gain (0-48 dB) into the asymmetric clipper, Tone tilts between darker and brighter response, and Cab sets the cabinet cutoff (brighter at higher values). Mix blends the modeled tone against the dry; ranges from edge-of-breakup grit to saturated lead tones.

ParamRangeDefaultUnit
Drive0 – 4818dB
Tone0 – 10.5—
Cab0 – 10.7—
Mix0 – 11—

# Bitwise 1 input

Bitwise mangler / databender (a first as a synth block): converts each sample to a 16-bit integer and applies a raw bit operation - XOR, AND, OR or bit-rotate - against Mask, then back to audio. Where Bitcrush only quantises the amplitude, this rips into the actual bit pattern: flipping a high bit folds the waveform, toggling low bits adds fizzing digital grit. Op picks the operation, Mask the bits to act on, Mix the blend. Pure circuit-bent digital destruction with no analogue equivalent.

ParamRangeDefaultUnit
OpXOR · AND · OR · Rotate—
Mask0 – 655350—
Mix0 – 11—

# SlewClip 1 input

Slew-rate distortion (a first as a synth block): limits how fast the output can move between samples, so when Drive pushes the input past that maximum slope the block cannot keep up - fast transients are sheared into ramps and the waveform is dragged toward a buzzing triangle. Where a clipper flattens the peaks, SlewClip mangles the slopes: a harsh, gritty, distinctly digital lo-fi grind that also drops level as it limits. Rate sets the maximum step per sample, Drive the input gain, Mix the blend.

ParamRangeDefaultUnit
Rate0.002 – 10.05—
Drive1 – 162—
Mix0 – 11—

# Schmitt 1 input

Schmitt-trigger fuzz (a first as a synth block): a comparator with memory - the output snaps fully high once the driven input rises past +Hyst and stays high until it falls past -Hyst, squaring the signal into a hard two-level wave that resists chattering near zero. The hysteresis band makes it 'stick', cleaning the buzz of a raw square-up while adding a gated, brutal edge. Drive sets the gain into the trigger, Hyst the dead-band width, Level the output, Mix the blend. A hysteretic square fuzz no clipper or fold reproduces.

ParamRangeDefaultUnit
Drive1 – 324—
Hyst0 – 0.50.05—
Level0 – 10.7—
Mix0 – 11—

# MultiDist 1 input

Three-band distortion: one-pole filters at 300 Hz and 3 kHz split the input into low, mid and high bands, each saturated through its own tanh stage before being summed. Low, Mid and High set the drive into each band's saturator and Mix blends the result against dry. Per-band drive lets you grind the highs without muddying the lows, or add weight to bass alone.

ParamRangeDefaultUnit
Low0 – 10.3—
Mid0 – 10.3—
High0 – 10.3—
Mix0 – 11—

# CabSim 1 input

Generic speaker-cabinet voicing: a 90 Hz high-pass trims sub rumble, a high-frequency rolloff tames fizz, and a peak around 1.5 kHz adds cabinet body, all blended by Mix. Body sets how much of the resonant midrange peak is added and Bright raises the rolloff corner for a more open top end. A lightweight tone-shaping voicing for amp signals, not an impulse-response capture of a real cabinet.

ParamRangeDefaultUnit
Body0 – 10.5—
Bright0 – 10.5—
Mix0 – 11—

# BEOD 1 input

Friedman BE-OD-style high-gain overdrive: a hot op-amp gain stage into a tight asymmetric silicon diode clipper, voiced like the BE-100 amp's lead channel - saturated, focused, amp-in-a-box drive.

ParamRangeDefaultUnit
Drive0 – 10.5—
Tone0 – 10.5—
Level-24 – 6-6dB
Mix0 – 11—

# Tumnus 1 input

Wampler Tumnus-style transparent boost/overdrive (Klon-lineage): a clean op-amp boost summed with a mild germanium-diode clip stage for a touch of grit while keeping the dry signal intact - the famous transparent mid-push.

ParamRangeDefaultUnit
Drive0 – 10.5—
Tone0 – 10.5—
Level-24 – 6-6dB
Mix0 – 11—

# MorningGlory 1 input

JHS Morning Glory-style transparent overdrive: a low-gain symmetric LED-clipper drive that stays open, dynamic and amp-like, cleaning up with the guitar volume - a pedalboard always-on.

ParamRangeDefaultUnit
Drive0 – 10.5—
Tone0 – 10.5—
Level-24 – 6-6dB
Mix0 – 11—

# TurboRAT 1 input

ProCo Turbo RAT-style distortion: a high-gain op-amp stage into hard LED clipping for a sharper, louder, more aggressive RAT with a fierce midrange bite.

ParamRangeDefaultUnit
Drive0 – 10.5—
Tone0 – 10.5—
Level-24 – 6-6dB
Mix0 – 11—

# SovtekMuff 1 input

Sovtek (Green Russian) Big Muff-style fuzz: cascaded transistor gain into two symmetric silicon-diode clipping stages for the thick, smooth, mid-scooped wall of sustain - darker and bassier than the US Muff.

ParamRangeDefaultUnit
Drive0 – 10.5—
Tone0 – 10.5—
Level-24 – 6-6dB
Mix0 – 11—

# Riot 1 input

Suhr Riot-style distortion: a high-gain asymmetric-clipper drive that nails a tight, saturated, amp-like high-gain rhythm and lead - JCM800-into-a-box aggression with a smooth top.

ParamRangeDefaultUnit
Drive0 – 10.5—
Tone0 – 10.5—
Level-24 – 6-6dB
Mix0 – 11—

# Diode 1 input

Asymmetric diode clipper that drives the input into an exponential soft-knee saturation, shaping the positive and negative halves differently. Drive sets the input gain in dB into the nonlinearity, while Bias increases the curvature of the negative half for stronger asymmetry and added even harmonics. Mix blends the clipped signal against the dry input for germanium/silicon-style warmth and grit.

ParamRangeDefaultUnit
Drive0 – 3612dB
Bias0 – 10.3—
Mix0 – 11—

# VHS 1 input

Cassette/VHS tape emulation: the input runs through a short modulated delay whose time wobbles via an internal 0.7 Hz LFO, then a one-pole low-pass rolls off highs and random pseudo-noise hiss is summed in. Wow sets the LFO delay-modulation depth (pitch wobble), Hiss scales the added noise level, and Dropout raises the probability of brief signal dropouts driven by a per-sample random envelope. Mix blends the degraded signal against the dry input for subtle aging or full lo-fi destruction.

ParamRangeDefaultUnit
Wow0 – 10.4—
Hiss0 – 10.3—
Dropout0 – 10.2—
Mix0 – 11—

# Subharmonic 1 input

Subharmonic generator: zero-crossing detection on the input drives a divide-by-four flip-flop, multiplying the input's rectified amplitude to synthesize a tone two octaves below, then smooths it with a one-pole low-pass. Sub sets the level of the generated sub, Tone opens the low-pass cutoff (darker to brighter sub), and Mix sums the sub onto the dry signal. Adds weight and low-end body to bass, kicks and leads.

ParamRangeDefaultUnit
Sub0 – 10.6—
Tone0 – 10.5—
Mix0 – 11—

# Rumble 1 input

Techno rumble bass: the input on in0 (a kick) drives an envelope follower that swells two slightly detuned sub-sines running underneath it, so a low rolling sub locks to the kick pattern and the slow Release lets the rumble roll on between hits - the Drumcode-style rumble built by sub-under-kick rather than a reverb send. Tune sets the sub pitch, Detune beats the two oscillators against each other for movement, Release sets how long the rumble tail rolls, Drive saturates it for weight, and Mix blends the rumble under the dry input.

ParamRangeDefaultUnit
Tune25 – 12045Hz
Detune0 – 10.3—
Release0.05 – 20.6s
Drive0 – 10.4—
Mix0 – 10.6—

Amp

33 modules

# Tweed 1 input

Fender Tweed 5E3-style amp: two asymmetric triode stages into a physical B+ reservoir sag (droops and blooms under pick attack) and an output-transformer stage - warm, loose, early breakup.

ParamRangeDefaultUnit
Gain1 – 204—
Tone0 – 10.5—
Sag0 – 10.6—
Level0 – 10.5—

# Blackface 1 input

Fender Blackface-style amp: a triode stage, scooped-mid clean headroom (~500 Hz notch), a stiff (low-sag) power section and an output-transformer stage with a bright, glassy top.

ParamRangeDefaultUnit
Gain1 – 122—
Treble0 – 10.6—
Bass0 – 10.5—
Bright0 – 10.3—
Level0 – 10.6—

# Recto 1 input

Mesa Rectifier-style high-gain amp: three cascaded asymmetric triode stages with tight inter-stage high-passing, a deep mid scoop, selectable reservoir sag and an output-transformer stage.

ParamRangeDefaultUnit
Gain1 – 4015—
Scoop0 – 10.6—
Presence0 – 10.5—
Sag0 – 10.3—
Master0 – 10.5—

# Ampeg 1 input

Ampeg SVT-style bass amp: two triode stages, thick low-mid focus, power-supply sag and an output-transformer stage with a dark cab - built for bass.

ParamRangeDefaultUnit
Gain1 – 203—
Bass0 – 10.6—
Mid0 – 10.5—
Master0 – 10.6—

# Friedman 1 input

Friedman BE-100-style amp: hot-rodded Marshall - two cascaded triode stages, tight low end, singing mids, reservoir sag and an output-transformer stage.

ParamRangeDefaultUnit
Gain1 – 4012—
Mid0 – 10.6—
Presence0 – 10.5—
Master0 – 10.5—

# Soldano 1 input

Soldano SLO-100-style amp: three cascaded triode stages for a smooth, saturated lead with singing sustain, reservoir sag and an output-transformer stage.

ParamRangeDefaultUnit
Gain1 – 4015—
Tone0 – 10.5—
Presence0 – 10.5—
Master0 – 10.5—

# Diezel 1 input

Diezel VH4-style amp: three cascaded triode stages, ultra-tight aggressive high-gain with a scooped low end, reservoir sag and an output-transformer stage.

ParamRangeDefaultUnit
Gain1 – 4018—
Scoop0 – 10.6—
Presence0 – 10.5—
Master0 – 10.5—

# ENGL 1 input

ENGL-style amp: three cascaded triode stages, tight scooped modern-metal high-gain, reservoir sag and an output-transformer stage with a dark cab.

ParamRangeDefaultUnit
Gain1 – 4016—
Scoop0 – 10.7—
Presence0 – 10.5—
Master0 – 10.5—

# Supro 1 input

Supro 1624T-style octal amp: 6973 power tubes on a tube-rectifier supply with no negative feedback, so loud transients sag the rails - the amp ducks then blooms, breaking up asymmetrically and early. Sag sets how hard the supply droops.

ParamRangeDefaultUnit
Drive1 – 306—
Sag0 – 10.5—
Tone1500 – 90004000Hz
Level0 – 10.5—

# Bassman 1 input

Fender 5F6-A tweed Bassman / JTM45-lineage tube amp: two cascaded 12AX7 gain stages modeled with the Koren triode plate-current equation (real self-bias, grid-conduction asymmetry - not a tanh) into a Fender-style tone stack (wide ~650 Hz mid), then a class-AB EL34 push-pull power stage whose plate currents subtract through the output transformer (even harmonics cancel, odd-harmonic clip + supply sag emerge from the physics), 4x oversampled.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Plexi 1 input

Marshall Plexi 1959 Super Lead-style amp: two cascaded Koren 12AX7 stages into a scooped Marshall tone stack (~500 Hz mid) and a class-AB EL34 push-pull power stage - the bright, crunchy British roar, with real push-pull even-harmonic cancellation and supply sag. Same physics engine as the Bassman, Marshall voicing.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# JCM800 1 input

Marshall JCM800 2203-style high-gain amp: three cascaded Koren 12AX7 stages (the extra gain stage = hot-rodded crunch) into a scooped Marshall tone stack and a class-AB EL34 push-pull power stage. The 80s rock/metal standard - tight, aggressive, harmonically rich.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# AC30 1 input

Vox AC30 Top Boost-style amp: two cascaded Koren 12AX7 stages into a chimey top-boost tone stack (flat ~800 Hz mid, bright treble) and a class-A EL84 push-pull power stage that compresses and sags early - the jangly British chime. EL84 (lower max current) + class-A bias distinguish it from the EL34 Marshalls.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# JTM45 1 input

Marshall JTM45-style amp: the original Marshall, two cascaded Koren 12AX7 stages into a Marshall tone stack and a class-AB KT66 push-pull power stage (more headroom and a rounder break-up than the later EL34 Plexi). Bluesy British crunch with bloom.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Twin 1 input

Fender Twin Reverb-style amp: two Koren 12AX7 stages into a deeply scooped blackface tone stack and a big class-AB 6L6 push-pull power stage with huge clean headroom - the loud, sparkling, scooped American clean. Breaks up only when pushed hard.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# DeluxeRev 1 input

Fender Deluxe Reverb-style amp: two Koren 12AX7 stages into a blackface tone stack and a class-AB 6V6 push-pull power stage - the warm, touch-sensitive American combo that breaks into a sweet, compressed overdrive when cranked. Lower headroom than the Twin.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Vibrolux 1 input

Fender Vibrolux Reverb-style amp: two Koren 12AX7 stages into a blackface tone stack and a class-AB 6L6 push-pull power stage voiced bright and chimey - a smaller, livelier blackface clean that sings with pick dynamics.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Matchless 1 input

Matchless DC30-style boutique amp: two Koren 12AX7 stages into a chimey top-boost-style tone stack and a class-A EL84 push-pull power stage - the AC30 chime with tighter low end and a more focused, hi-fi breakup. Boutique British class-A.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Bogner 1 input

Bogner Ecstasy-style amp: three cascaded Koren 12AX7 stages into a tight, focused tone stack and a class-AB EL34 push-pull power stage - smooth, singing, high-gain modern British-voiced lead with a refined, liquid sustain.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Jubilee 1 input

Marshall Silver Jubilee 2555-style amp: three cascaded Koren 12AX7 stages into a scooped Marshall tone stack and a class-AB EL34 push-pull power stage - a hot-rodded JCM800 with a tighter, more compressed high-gain crunch. The 80s/90s rock-lead Marshall.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# EVH5150 1 input

EVH 5150III-style amp: three cascaded Koren 12AX7 stages into a scooped, aggressive tone stack and a class-AB EL34 push-pull power stage driven hard - the tight, saturated, percussive modern metal/shred standard with massive gain and a fast attack.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# MarkV 1 input

Mesa/Boogie Mark V-style amp: three cascaded Koren 12AX7 stages into a deeply scooped Mesa tone stack and a class-AB power stage - the smooth, compressed, mid-scooped American high-gain lead (the 'Santana/Metallica' voice) with singing sustain.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Rectoverb 1 input

Mesa/Boogie Rectoverb-style amp: three cascaded Koren 12AX7 stages into a loose, scooped Recto-voiced tone stack and a class-AB EL34 push-pull power stage - thick, saturated, sagging modern high-gain with a huge low end. The nu-metal/modern-rock rhythm crush.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Princeton 1 input

Fender Princeton Reverb-style amp: two Koren 12AX7 stages into a blackface tone stack and a small class-AB 6V6 push-pull power stage - the low-power (~12 W) blackface combo that breaks into a sweet, touch-sensitive overdrive earlier than the Deluxe, the studio recording favourite. Lower power-tube headroom = earlier sag and bloom.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Bandmaster 1 input

Fender Bandmaster-style amp: two Koren 12AX7 stages into a deeply scooped blackface tone stack and a class-AB 6L6 push-pull power stage - a piano-clean ~40 W blackface head with big headroom and a glassy, scooped top, breaking up only when pushed hard.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Showman 1 input

Fender Dual Showman-style amp: two Koren 12AX7 stages into a scooped blackface tone stack and a big, stiff class-AB 6L6 push-pull power stage - the loudest, cleanest blackface (~85 W), enormous headroom and a tight, sparkling, scooped clean that barely breaks up. Stiffer power supply (less sag) than the Twin.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# SuperReverb 1 input

Fender Super Reverb-style amp: two Koren 12AX7 stages into a blackface tone stack and a class-AB 6L6 push-pull power stage voiced bright and chimey through its 4x10 cab - a livelier, more touch-responsive blackface clean than the Twin, singing with pick dynamics and breaking up sweetly when cranked.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Bluesbreaker 1 input

Marshall 1962 Bluesbreaker-style amp: two Koren 12AX7 stages into a Marshall tone stack and a class-AB KT66 push-pull power stage - the JTM45-lineage combo behind the classic British blues-rock 'Beano' tone, with a warm, bloomy, KT66 break-up and more low-end body than the later EL34 Plexi.

ParamRangeDefaultUnit
Gain0 – 10.5—
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.6—
Master0 – 10.6—
Level-24 – 6-6dB

# Brit412 1 input

Marshall 1960A-style 4x12 with Celestion Greenback voicing: a tight low-cut, a roll-off around 4.5 kHz and a forward upper-mid presence - the definitive British rock guitar cabinet.

ParamRangeDefaultUnit
Tone0 – 10.5—
Body0 – 10.5—
Level-12 – 60dB

# Recto412 1 input

Mesa/Boogie Rectifier-style 4x12 (V30 loaded): a big low end, a slightly later treble roll-off and an aggressive 3-4 kHz bite - the modern high-gain metal cab.

ParamRangeDefaultUnit
Tone0 – 10.5—
Body0 – 10.5—
Level-12 – 60dB

# Blue212 1 input

Vox AC30-style 2x12 with Celestion Blue alnico voicing: an open low end, an extended top and a sweet chimey presence - the jangly British combo cab.

ParamRangeDefaultUnit
Tone0 – 10.5—
Body0 – 10.5—
Level-12 – 60dB

# Orange412 1 input

Orange-style 4x12: a thick, dark, low-mid-forward voicing with an earlier treble roll-off - the heavy, woody stoner/doom cabinet.

ParamRangeDefaultUnit
Tone0 – 10.5—
Body0 – 10.5—
Level-12 – 60dB

# Bass410 1 input

Ampeg-style 4x10 bass cabinet: a deep extended low end, a gentle low-mid bump and an early treble roll-off for a round, punchy bass tone.

ParamRangeDefaultUnit
Tone0 – 10.5—
Body0 – 10.5—
Level-12 – 60dB

Modulation

461 modules

# SwitcherLFO 0 inputs

Massive X morphing LFO: runs one phase at Rate through a bank of 8 bipolar shapes (sine, triangle, saw up/down, square, narrow pulse, s-curve, double sine), crossfading between adjacent shapes and mapping the result to a 0 to 1 output. Rate sets the cycle speed, Shape selects and morphs continuously across the bank, and Phase offsets the read position. Sweeping Shape gives a continuous waveform-morph modulator rather than a fixed LFO shape.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Shape0 – 10—
Phase0 – 10—

# DAHDSR 1 input

Six-stage modulation envelope driven by the gate at in0: on gate-on it runs Delay, Attack, Hold, Decay then holds at Sustain, and on gate-off it enters Release, outputting a 0 to 1 level. Delay/Attack/Hold/Decay/Release are times in seconds and Sustain is the held level. The extra Delay and Hold stages over a plain ADSR let it shape slow swells or gated bursts as a modulation source.

ParamRangeDefaultUnit
Delay0 – 40s
Attack0 – 50.01s
Hold0 – 40s
Decay0 – 50.2s
Sustain0 – 10.7—
Release0 – 50.3s

# Glide 2 inputs

Portamento: one-pole smooths the pitch/control signal at in0 toward each new value over Time, gated by in1. Time sets the glide duration in seconds (zero snaps instantly), and Mode chooses Always (glide on every note change) or Legato (snap on an isolated note, glide only between overlapping notes). Drop it between a note source and an oscillator for per-layer portamento.

ParamRangeDefaultUnit
Time0 – 20.1s
Mode0 – 10—

# PathLFO 0 inputs

Drawable XY-path LFO: a Rate-driven phase traverses the loop of 2D waypoints set in node config and reads back one coordinate as a bipolar -1 to 1 output, scaled by Level. Rate sets the traversal speed, Axis chooses whether the X or Y coordinate drives the output, and Level scales the result. Pair two nodes set to X and Y on the same drawn path to modulate two targets in a coordinated 2D motion.

ParamRangeDefaultUnit
Rate0.01 – 501Hz
Axis0 – 10—
Level0 – 11—

# MSEG 1 input

Multi-segment envelope generator: a gate edge resets a phase that ramps from 0 to 1 over Rate seconds, and the output linearly interpolates between user-defined 'time,level' breakpoints parsed from the node config. Rate sets the total run time of the shape, Loop makes the phase wrap and repeat instead of holding the last level, Level scales the final output, and Sync (1/1..1/16T) locks the cycle length to host tempo instead of the free Rate seconds. Breakpoints come from a 't,l;t,l;...' config string (defaulting to a fast attack and gentle decay when fewer than two are given), giving a flexible Serum/Vital-style modulation source for arbitrary multi-stage curves.

ParamRangeDefaultUnit
Rate0.05 – 81s
Loop0 – 10—
Level0 – 11—
Sync0 – 80—

# Performer 1 input

Performer (Massive X-style step modulator): a tempo-synced step sequencer that runs a drawn pattern of up to 64 step levels (up to ~8 bars) locked to the host tempo. Draw the pattern in the step-bar editor; Sync sets the per-step note division (1/1..1/16T), Glide slews between steps (hard steps to a smooth contour), Level scales the output, and a gate on in0 restarts the pattern from step 1. Patch its output into cutoff, pitch, level or any mod input for long, evolving rhythmic movement that locks to the transport.

ParamRangeDefaultUnit
Sync1 – 84—
Glide0 – 10—
Level0 – 11—

# Barberpole 1 input

Infinite (barberpole) phaser: two 4-stage allpass banks a half-cycle apart, each amplitude-windowed so one fades in as the other wraps, giving an endless rising or falling sweep. Rate sets the sweep speed (Hz), Depth scales the allpass coefficient swing, Dir flips between rising and falling, and Mix blends wet against dry. A Shepard-tone style effect that seems to climb or descend forever.

ParamRangeDefaultUnit
Rate0.02 – 40.3Hz
Depth0 – 10.7—
Dir0 – 10—
Mix0 – 10.5—

# PeakPhaser 1 input

A 6-stage allpass phaser whose sweep is driven by a peak envelope follower on the input, so transients trigger the filter motion instead of an LFO. Soften sets the envelope release time, Feedback sets the allpass regeneration (up to 0.9), Amount scales how far each peak sweeps the phaser, and Mix blends wet against dry. Part of the Traktor Pulse family, it pumps the phaser in time with the signal's own dynamics.

ParamRangeDefaultUnit
Soften0 – 10.5—
Feedback0 – 0.90.5—
Amount0 – 10.7—
Mix0 – 10.5—

# TriceraChorus 1 input

Tri-voice chorus with a micro-detune swirl: three LFO-modulated delay taps at spread phases plus a slow pitch-detuned voice for a rich animated widening.

ParamRangeDefaultUnit
Rate0.05 – 60.5Hz
Depth0 – 10.6—
Detune0 – 10.3—
Mix0 – 10.5—

# DimensionD 1 input

Roland Dimension D-style BBD chorus: two anti-phase bucket-brigade lines (compander + clock-tracked reconstruction filter) for a wide, 'motionless' thickening with no audible wobble.

ParamRangeDefaultUnit
Mode1 · 2 · 3 · 4—
Mix0 – 10.5—

# CE1 1 input

Boss CE-1-style BBD chorus/vibrato: a triangle-LFO chorus or a wet-only vibrato through a companded bucket-brigade line, with preamp coloration.

ParamRangeDefaultUnit
ModeChorus · Vibrato—
Rate0.1 – 81Hz
Depth0 – 10.5—
Mix0 – 10.5—

# Solina 1 input

Solina/string-machine-style ensemble: three BBD taps on 120-degree-phased dual LFOs (slow + fast) through one companded bucket-brigade line for a lush, moving multi-voice swirl.

ParamRangeDefaultUnit
Slow0.1 – 20.6Hz
Fast1 – 126Hz
Depth0 – 10.6—
Mix0 – 10.5—

# ElectricMistress 1 input

EHX Electric Mistress-style flanger: a swept companded bucket-brigade line forms moving comb notches; Filter Matrix freezes the sweep for a fixed metallic tone.

ParamRangeDefaultUnit
Rate0.05 – 80.4Hz
Range0 – 10.5—
Color0 – 10.4—
MatrixSweep · Freeze—

# TriStereo 1 input

Dytronics Tri-Stereo Chorus-style ensemble: three bucket-brigade voices (compander + clock-tracked reconstruction) at staggered rates for a lush, wide three-dimensional chorus.

ParamRangeDefaultUnit
Rate0.1 – 30.5Hz
Depth0 – 10.6—
Mix0 – 10.5—

# MXRFlanger 1 input

MXR Flanger-style BBD flanger: a companded bucket-brigade line swept for a deep, metallic comb with line-level regeneration for jet-plane sweeps.

ParamRangeDefaultUnit
Rate0.05 – 60.3Hz
Depth0 – 10.7—
Regen0 – 0.90.4—
Mix0 – 10.5—

# Phase90 1 input

MXR Phase 90-style 4-stage phaser: four JFET all-pass stages (bias-dependent frequency shift + transfer-curve saturation) give two evenly-tracking notches; Script (clean) or Block (resonant feedback).

ParamRangeDefaultUnit
Rate0.05 – 50.5Hz
BlockScript · Block—
Mix0 – 10.5—

# Phase100 1 input

MXR Phase 100-style 6-stage phaser: six JFET all-pass stages give three evenly-tracking notches - deeper and more resonant than the 4-stage Phase 90 - with a 4-position Intensity that adds feedback resonance for the thick, swirling, peakier sweep. Rate sets the LFO speed, Intensity the notch depth/feedback, Mix the blend.

ParamRangeDefaultUnit
Rate0.05 – 50.5Hz
Intensity0 – 10.5—
Mix0 – 10.5—

# SmallStone 1 input

EHX Small Stone-style 4-stage OTA phaser: nonlinear OTA all-pass stages; the Color switch adds feedback, drives the OTAs harder and widens the notch sweep for a more vocal, resonant swirl.

ParamRangeDefaultUnit
Rate0.05 – 50.4Hz
ColorOff · On—
Mix0 – 10.5—

# UniVibe 1 input

Uni-Vibe-style 4-stage phaser: staggered all-pass frequencies driven by an asymmetric lamp-filament LFO through a power-law photocell I-V curve, with nonlinear stages - the watery, throbbing swirl. Chorus or Vibrato.

ParamRangeDefaultUnit
Rate0.05 – 82Hz
Depth0 – 10.7—
ModeChorus · Vibrato—
Mix0 – 10.5—

# OptoTrem 1 input

Fender optical tremolo: a lamp drives a photocell whose asymmetric lag (cools slower than it warms) and sublinear I-V curve round the throb; Shape sets the cell response speed (smooth to choppy).

ParamRangeDefaultUnit
Rate0.5 – 125Hz
Depth0 – 10.6—
Shape0 – 10.7—

# BiasTrem 1 input

Tube bias tremolo: the LFO shifts the tube grid bias (operating point), so the throb modulates both amplitude and 2nd-harmonic content - a richer, harmonically-moving wobble than plain amplitude tremolo.

ParamRangeDefaultUnit
Rate0.5 – 104Hz
Depth0 – 10.5—
Bias0 – 10.3—

# FuncGen 0 inputs

H3000-style function generator: a modulation source with 19 selectable waveshapes plus random sample-and-hold, smooth random and noise (no audio input).

ParamRangeDefaultUnit
Rate0.01 – 301Hz
ShapeSine · Triangle · Saw Up · Saw Down · Square · Pulse · Sine2 · Rectified · Half Sine · Exp Up · Exp Down · Log · Trapezoid · Staircase · Random S&H · Smooth Rand · Noise · Ramp Hold · Chaos—
Depth0 – 11—
Phase0 – 10—
Width0.05 – 0.950.5—
Bias-1 – 10—

# BiPhase 1 input

Mu-Tron Bi-Phase dual phaser: TWO complete 6-stage OTA phasers with independent LFO rates (RateA / RateB), whose two moving notch combs beat against each other for a swirling, three-dimensional sweep no single-sweep phaser (Phase 90, Small Stone) can reach. Depth sets the sweep width, Feedback the resonant emphasis of the notches, Mix the wet blend. Six 1st-order all-pass stages per side.

ParamRangeDefaultUnit
RateA0.02 – 80.3Hz
RateB0.02 – 80.5Hz
Depth0 – 10.7—
Feedback0 – 0.90.3—
Mix0 – 10.5—

# BodeRing 1 input

Bode / Moog 6401-style ring modulator: the input multiplied by an internal tunable sine carrier through a diode-ring nonlinearity, giving the metallic sum-and-difference sidebands of the classic sci-fi/bell sound. Freq tunes the carrier, Drive sets the diode-bridge bite, Mix blends modulated against dry.

ParamRangeDefaultUnit
Freq1 – 4000220Hz
Drive0 – 10.3—
Mix0 – 11—

# PhaseDiffuse 1 input

Phase diffuser: a cascade of first-order all-pass stages whose coefficient drifts under a slow LFO smears phase (decorrelation / shimmer) without any delay line - flat magnitude, moving phase.

ParamRangeDefaultUnit
Amount0 – 10.5—
Rate0.01 – 50.2Hz
Stages1 – 64—

# RingSelf 1 input

Self ring modulator: multiplies the signal by a short-delayed copy of itself, producing metallic, pitch-tracking sidebands without an external carrier; delay sets the inharmonic flavour.

ParamRangeDefaultUnit
Delay0.1 – 203ms
Amount0 – 10.7—
Level0 – 10.8—

# SlewNoise 0 inputs

Slew-limited random LFO: picks a new random target at a set rate and glides toward it with a slew time, producing smooth, organic, non-repeating modulation (a continuous cousin of sample-and-hold).

ParamRangeDefaultUnit
Rate0.1 – 404Hz
Slew1 – 50050ms
Level0 – 10.8—

# PhaseGate 1 input

Phase-windowed rhythmic gate: an internal LFO opens the gate only during the first Width fraction of each cycle, with a smoothed edge - a tempo-set chopper / trance-gate without a sequencer.

ParamRangeDefaultUnit
Rate0.1 – 204Hz
Width0 – 10.5—
Smooth1 – 505ms

# TapeWow 1 input

Tape wow / flutter: a slow LFO sweeps a fractional delay so pitch wobbles like a slipping tape transport - the analog instability a clean digital path lacks.

ParamRangeDefaultUnit
Depth0 – 10.4—
Rate0.1 – 81.2Hz
Mix0 – 11—

# EnvTrace 1 input

Blendable envelope follower CV: morph between a peak and an RMS detector with one knob and scale the output - a clean control source for driving mods, distinct from the audio-path dynamics blocks.

ParamRangeDefaultUnit
Time1 – 50050ms
Mode0 – 10—
Sens0 – 41—

# CombFlange 1 input

Feedback flanger: a slow LFO sweeps a short delay line with regeneration, producing the swooshing swept-comb resonance of a classic flanger.

ParamRangeDefaultUnit
Rate0.05 – 50.3Hz
Depth0 – 10.6—
Feedback0 – 0.90.5—
Mix0 – 10.5—

# NoiseBreath 1 input

Breath/texture layer: low-passed deterministic noise scaled by the input envelope adds air, breath or grit that swells with the signal - the 'noise component' of a sound, dynamics-keyed.

ParamRangeDefaultUnit
Color50 – 80002000Hz
Amount0 – 10.5—
Track0 – 10.7—

# ChordRing 1 input

Chord ring modulator: rings the input against three internal carriers tuned to a triad ratio at once, scattering harmonically-related sidebands instead of the single clangorous tone of a one-carrier ring mod.

ParamRangeDefaultUnit
Root20 – 2000200Hz
Spread1 – 21.5—
Mix0 – 10.5—

# GateShape 1 input

Shaped rhythmic gate: an internal rate chops the signal, with one knob morphing the gate envelope from hard square (trance gate) to triangle (tremolo) - rhythmic amplitude shaping without a sequencer.

ParamRangeDefaultUnit
Rate0.1 – 164Hz
Shape0 – 10.5—
Depth0 – 11—

# RingFollow 1 input

Pitch-tracking ring modulator: the carrier frequency follows a ratio of the input's own pitch (from its zero crossings), so the ring-mod sidebands stay harmonically related and in tune instead of clashing.

ParamRangeDefaultUnit
Ratio0.5 – 82—
Mix0 – 10.5—

# DCWander 1 input

Slow DC wander: a gliding random offset drifts the signal's baseline like a thermally-unstable analog circuit, adding subtle low-frequency movement and bias for an alive, imperfect feel.

ParamRangeDefaultUnit
Rate0.01 – 20.2Hz
Depth0 – 10.3—

# ChorusEns 1 input

Ensemble chorus: three independently LFO-modulated delay taps detune and spread the signal into a lush, string-machine-style ensemble - richer than a single-voice chorus.

ParamRangeDefaultUnit
Rate0.1 – 30.5Hz
Depth0 – 10.5—
Mix0 – 10.5—

# GateRandom 1 input

Random rhythmic gate: at each step of an internal clock the gate opens or stays shut by a set probability, chopping the signal into an ever-changing stutter pattern (deterministic RNG).

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Prob0 – 10.5—
Smooth1 – 505ms

# BrownDrift 1 input

Brownian drift: a random walk accumulates small steps and reflects off the rails, producing smooth, momentum-carrying wander (1/f-ish) rather than the memoryless jumps of sample-and-hold random.

ParamRangeDefaultUnit
Step0 – 10.3—
Rate0.1 – 408Hz
Level0 – 10.8—

# PitchVibrato 1 input

Sine vibrato: a clean sinusoidal LFO sweeps a fractional delay for smooth, periodic pitch modulation (the controlled, musical counterpart to the random wow/drift blocks).

ParamRangeDefaultUnit
Rate0.1 – 125Hz
Depth0 – 10.3—
Mix0 – 11—

# RotorDoppler 1 input

Rotary speaker: one LFO drives both a Doppler pitch sweep (modulated delay) and the amplitude tremolo of a spinning horn at once, the intertwined motion a plain chorus or tremolo can't reproduce.

ParamRangeDefaultUnit
Rate0.5 – 85Hz
Depth0 – 10.5—
Mix0 – 10.6—

# TremHarmonic 1 input

Harmonic tremolo: the signal is split into low and high bands whose amplitudes are modulated in anti-phase by one LFO, producing the swirling, phase-shifting throb of a brownface amp tremolo rather than flat volume wobble.

ParamRangeDefaultUnit
Rate0.1 – 125Hz
Depth0 – 10.7—
Split200 – 3000800Hz

# GateClock 0 inputs

Clock gate generator: emits a steady rhythmic gate (rate + duty cycle) as a control source for triggering envelopes, plucks or sample-holds - a self-contained tempo pulse, needs no input.

ParamRangeDefaultUnit
Rate0.1 – 164Hz
Duty0.05 – 0.950.5—
Level0 – 11—

# Phaser4 1 input

Four-stage phaser: a cascade of four LFO-swept all-pass stages with feedback creates moving notches across the spectrum - the classic sweeping phaser whoosh, a true all-pass (not a flange delay).

ParamRangeDefaultUnit
Rate0.05 – 40.4Hz
Depth0 – 10.7—
Feedback0 – 0.70.3—
Mix0 – 10.5—

# CellAuto 1 input

Cellular-automaton sequencer: evolves a 32-cell elementary CA (any Wolfram rule, e.g. 30) one generation per clock step and outputs the centre cell - emergent, rule-driven gate/CV patterns from a one-line universe.

ParamRangeDefaultUnit
Rate0.5 – 508Hz
Rule0 – 25530—
Level0 – 11—

# GaloisSeq 1 input

Galois LFSR sequencer: a maximal-length linear-feedback shift register clocks out a long, deterministic pseudo-random bit sequence as a gate - the structured randomness behind Turing-machine-style sequencers.

ParamRangeDefaultUnit
Rate0.5 – 508Hz
Level0 – 11—

# RingFB 1 input

Feedback ring modulator: the carrier sine is phase-modulated by the previous output, so the sidebands recursively breed more sidebands - a self-feeding, FM-flavoured ring mod that grows denser with feedback.

ParamRangeDefaultUnit
Freq20 – 2000200Hz
Feedback0 – 0.90.3—
Mix0 – 10.6—

# CombSelf 1 input

Self-modulating comb: the comb's delay length is bent in real time by its own output, a feedback loop that breeds chaotic, screaming, never-quite-repeating resonances - a comb that modulates itself.

ParamRangeDefaultUnit
Freq40 – 2000200Hz
ModDepth0 – 10.5—
Feedback0 – 0.850.4—
Mix0 – 10.5—

# BounceBall 1 input

Bouncing-ball envelope: simulates a ball dropped under gravity that loses energy each bounce, so the control output bounces ever faster and lower then resets - an accelerating rhythmic ramp no LFO shape gives.

ParamRangeDefaultUnit
Gravity0.1 – 41—
Bounce0.3 – 0.950.7—
Level0 – 11—

# FibSeq 1 input

Fibonacci sequencer: clocks out a modular Fibonacci recurrence (next = (a+b) mod M), a deterministic sequence that visits its values in a fixed but non-obvious order - structured melodic/CV patterns from number theory.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Mod3 – 168—
Level0 – 11—

# VocoderBank 2 inputs

Channel vocoder: a modulator (e.g. voice) is split into four bands whose envelopes gate the matching bands of a carrier, stamping the modulator's moving spectrum onto the carrier - the classic robot-voice/talking-synth effect.

ParamRangeDefaultUnit
Bright0 – 10.5—
Mix0 – 11—
Level0 – 11—

# EuclidRhythm 0 inputs

Euclidean rhythm: spreads a number of pulses as evenly as possible across a number of steps (the Bjorklund algorithm that underlies most world-music rhythms) and clocks it out as a gate - generative grooves from two numbers.

ParamRangeDefaultUnit
Pulses1 – 164—
Steps2 – 168—
Rate0.5 – 164Hz

# ShiftMelody 1 input

Shift-register melody: a looping bit register clocks out a stepped CV; a probability knob occasionally flips the recirculating bit, morphing a locked loop into a slowly-mutating one - the Turing-machine sequencer in a block.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Mutate0 – 10.1—
Level0 – 11—

# FuncMaths 1 input

Function generator: a continuously-cycling rise/fall ramp with adjustable up and down times and a curve control (log to exp), a Maths-style slope source for modulation and looping envelopes.

ParamRangeDefaultUnit
Rise1 – 2000100ms
Fall1 – 2000100ms
Curve0 – 10.5—
Level0 – 11—

# BurstGen 1 input

Burst / ratchet generator: each gate fires a finite count of evenly-spaced trigger pulses, turning one hit into a programmable roll or ratchet - drum fills and stutters from a single trigger.

ParamRangeDefaultUnit
Count1 – 164—
Rate1 – 5016Hz
Level0 – 11—

# TrigDelay 1 input

Trigger delay: outputs the gate plus a time-shifted copy of itself, so one hit becomes a flam (two close hits) or a rhythmic echo of triggers - timing displacement for drums and envelopes.

ParamRangeDefaultUnit
Delay1 – 50050ms
Mix0 – 11—

# SlewSeq 1 input

Slewed step sequencer: a fixed-length loop of deterministic pseudo-random step values glided together by a slew limiter, a repeating melodic/CV contour that you can smooth from stepped to legato.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Length2 – 168—
Slew1 – 20020ms

# BodeShift 1 input

Frequency shifter: builds an approximate quadrature (90-degree) pair from the input and heterodynes it with a complex oscillator, shifting every partial by a fixed number of Hz - inharmonic, metallic, NOT pitch shifting (a Bode-style shifter).

ParamRangeDefaultUnit
Shift-500 – 500100Hz
Mix0 – 11—

# ClockMultiply 1 input

Clock multiplier: measures the period between incoming clock pulses and emits a chosen number of evenly-spaced sub-pulses inside each one, generating faster synced clocks (1/8 from 1/4 notes, etc.) from a single trigger stream.

ParamRangeDefaultUnit
Mult1 – 82—
Level0 – 11—

# KuramotoPair 1 input

Kuramoto coupled oscillators: two phase oscillators at slightly different rates pull on each other; below a coupling threshold they beat, above it they lock - the canonical model of spontaneous synchronization, as an evolving two-tone source.

ParamRangeDefaultUnit
Freq20 – 1000110Hz
Detune0 – 0.10.02—
Coupling0 – 41—
Level0 – 10.5—

# DiodeRing 2 inputs

Diode ring modulator: passes the product of two inputs through the exponential curve of a four-diode bridge, so the sidebands carry the gritty asymmetry and crossover kink of a real ring-mod transformer - not a clean multiply.

ParamRangeDefaultUnit
Drive0.5 – 41.5—
Mix0 – 11—

# SteppedLFO 1 input

Stepped LFO: a ramp quantized to a chosen number of discrete levels, producing a rising (or shaped) staircase control voltage for arpeggiated, sequenced-feeling modulation rather than a smooth sweep.

ParamRangeDefaultUnit
Rate0.05 – 201Hz
Steps2 – 168—
Level0 – 11—

# MarkovGate 1 input

Markov sequencer: a small state machine that on each clock step either holds or jumps to a new state by a transition probability, emitting each state as a CV level - structured-random sequences that have memory, unlike pure random.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Stay0 – 10.5—
States2 – 84—

# ProbSkip 1 input

Probability gate: each incoming trigger is passed through with a set probability and dropped otherwise, thinning a steady clock into a sparser, ever-varying rhythm (deterministic RNG).

ParamRangeDefaultUnit
Prob0 – 10.5—
Level0 – 11—

# EnvPluck 1 input

Transient-triggered envelope: detects attacks in the input and fires a short attack/decay envelope on each one, turning any rhythmic audio into a clean pluck/percussive CV without an external trigger.

ParamRangeDefaultUnit
Sens0 – 10.5—
Attack1 – 1005ms
Decay5 – 1000150ms

# OnsetGate 1 input

Onset detector: compares a fast and a slow envelope and outputs a short gate whenever the fast one surges past the slow one (an energy-flux onset), turning audio attacks into clean triggers for envelopes or drums.

ParamRangeDefaultUnit
Sens0 – 10.5—
Width1 – 10010ms

# PhotoVibe 1 input

Photocell vibe: four all-pass stages at staggered offsets are swept by an asymmetric (fast-rise, slow-fall, photocell-shaped) LFO, recreating the warbling, throbbing modulation of a Uni-Vibe rather than a symmetric phaser.

ParamRangeDefaultUnit
Rate0.1 – 84Hz
Depth0 – 10.7—
Mix0 – 10.5—

# LSystemSeq 1 input

L-system sequencer: expands a fractal rewriting grammar (the algae rule A->AB, B->A) into a self-similar symbol string and clocks it out as a stepped CV, generating structured, recursive, never-trivially-periodic melodic patterns.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# ArpSeq 2 inputs

Arpeggiator: samples a base pitch CV, then on each clock pulse steps an output CV through a fixed chord shape (root, third, fifth, octave) above it, turning one held note into a running arpeggio.

ParamRangeDefaultUnit
ChordMaj · Min · Oct—
Range1 – 11—
Level0 – 11—

# BarberFlange 1 input

Barber-pole flanger: two delay taps sweep in the same direction and crossfade as each resets, so the comb notches appear to glide endlessly upward (or downward) without ever wrapping - the auditory barber-pole illusion as a flanger.

ParamRangeDefaultUnit
Rate0.05 – 40.3Hz
Depth0 – 10.7—
Mix0 – 10.5—

# ThruZeroFlange 1 input

Through-zero flanger: a wet delay is modulated against a fixed dry delay so their difference passes through (and beyond) zero, producing the deep tape-flange null sweep and the brief reversal that only true through-zero flanging gives.

ParamRangeDefaultUnit
Rate0.05 – 40.4Hz
Depth0 – 10.7—
Mix0 – 10.5—

# DetuneDouble 1 input

Detune doubler: blends in a single copy whose pitch is shifted by a few cents via a slowly-swept delay, fattening a sound into a tight unison double (artificial double-tracking) without the wide motion of a chorus.

ParamRangeDefaultUnit
Detune0 – 10.4—
Mix0 – 10.5—

# ThueMorseSeq 1 input

Thue-Morse sequence: each step's value is the parity of the number of 1-bits in the step index, the famously cube-free, self-similar, aperiodic binary sequence - a non-repeating yet highly-structured gate/CV pattern.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# RudinShapiroSeq 1 input

Rudin-Shapiro sequence: +/-1 set by the parity of '11' bit-pairs in the index, the automatic sequence famous for its nearly-flat (white-like) Fourier spectrum despite being fully deterministic - a structured yet broadband stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# SternBrocotSeq 1 input

Stern diatomic sequence: the 'fusc' function that builds the Stern-Brocot tree of all rationals (a(2n)=a(n), a(2n+1)=a(n)+a(n+1)), giving a fractal sawtooth-of-sawtooths whose every value is a rational's numerator - structured self-similar CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# PaperFold 1 input

Paperfolding sequence: the turn directions you get by repeatedly folding a strip of paper in half (which trace the dragon curve), a 2-automatic sequence whose value comes from the bit just above the lowest set bit of the index - a self-similar fold pattern.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# GoldenSeq 1 input

Golden-ratio sequence: an additive recurrence that adds the golden ratio's fractional part each step and wraps, producing the maximally-equidistributed low-discrepancy sequence - quasi-random values that fill the range more evenly than noise.

ParamRangeDefaultUnit
Rate0.5 – 508Hz
Level0 – 11—

# VanDerCorputSeq 1 input

Van der Corput sequence: each step's value is the index's binary digits mirrored after the point (the base-2 radical inverse), which fills the unit interval by repeated bisection - the 1-D foundation of quasi-Monte-Carlo low-discrepancy sampling.

ParamRangeDefaultUnit
Rate0.5 – 508Hz
Level0 – 11—

# WeylSeq 1 input

Weyl sequence: adds a chosen irrational increment each step and wraps; by Weyl's equidistribution theorem the values fill the range uniformly without ever repeating - a tunable quasi-periodic CV whose step size sets how it scans the range.

ParamRangeDefaultUnit
Step0.1 – 0.90.414—
Rate0.5 – 508Hz
Level0 – 11—

# HaltonSeq 1 input

Halton sequence: the base-3 radical inverse (the van-der-Corput construction in base 3), filling the interval by repeated trisection; paired with base-2 it forms the 2-D Halton points used to scatter quasi-random samples evenly.

ParamRangeDefaultUnit
Rate0.5 – 508Hz
Level0 – 11—

# KolakoskiSeq 1 input

Kolakoski sequence: the unique 1,2 sequence that is its own run-length encoding (its run lengths spell out the sequence itself), a self-referential aperiodic pattern; precomputed once and clocked out as a hypnotically self-similar stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# BaumSweetSeq 1 input

Baum-Sweet sequence: a 2-automatic binary sequence where term n is 1 only if the binary of n contains no block of consecutive zeros of odd length - a deterministic, self-similar gate pattern from automata theory.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# FibWordSeq 1 input

Fibonacci word: the fixed point of the golden substitution 0->01, 1->0, a Sturmian sequence whose 0s and 1s fall at golden-ratio spacing - the most-ordered aperiodic binary pattern, clocked out as a gate.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# PeriodDoublingSeq 1 input

Period-doubling sequence: the fixed point of 0->01, 1->00, the symbolic itinerary of the logistic map's period-doubling cascade at the Feigenbaum point - a self-similar binary pattern that mirrors the route to chaos.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# MephistoSeq 1 input

Mephisto Waltz sequence: the fixed point of 0->001, 1->110, a self-similar ternary-grouped binary pattern with a swung, waltzing rhythmic feel when clocked out as a gate.

ParamRangeDefaultUnit
Rate0.5 – 166Hz
Level0 – 11—

# ChampernowneSeq 1 input

Champernowne digits: the digits of 0.123456789101112... (formed by concatenating the integers), a normal number whose digit stream is deterministic yet statistically uniform - an endlessly-climbing-then-resetting decimal-digit CV.

ParamRangeDefaultUnit
Rate0.5 – 308Hz
Level0 – 11—

# PrimeGapSeq 1 input

Prime gaps: the distances between successive prime numbers (2,1,2,4,2,4,2,4,6,...), an irregular yet not-quite-random integer sequence; clocked out, it makes a jagged melodic/CV pattern that drifts upward as primes thin out.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# DivisorCountSeq 1 input

Divisor count: the number-of-divisors function d(n) (1 for primes, large for highly-composite numbers), a multiplicatively-structured integer sequence; as a CV it spikes on composite-rich steps and dips on primes.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# TotientSeq 1 input

Euler totient: phi(n), the count of integers up to n coprime to it, an arithmetic function full of multiplicative structure; normalized by n it hovers and dips in a fractal-looking pattern, here a stepped control source.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# MoebiusSeq 1 input

Moebius function: mu(n) is +1, -1 or 0 depending on the prime factorization of n (0 if a square divides it), the sign sequence at the heart of analytic number theory - a sparse three-level CV that flickers between +1, -1 and rest.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# RecamanSeq 1 input

Recaman's sequence: start at 0 and at step n jump back by n if that lands on a new non-negative value, else jump forward by n; the result darts unpredictably over the number line (a famous OEIS visualization) - a wide-ranging stepped melody.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# LookAndSay 1 input

Look-and-say: each term describes the previous one aloud (1 -> '11' -> '21' -> '1211' -> ...), the self-describing sequence whose length grows by Conway's constant; its digit stream (only 1s, 2s and 3s) makes a chattering stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 166Hz
Level0 – 11—

# DigitSumSeq 1 input

Digit-sum sequence: the sum of the base-B digits of the step index, a self-similar arithmetic sequence (sawtooth-of-sawtooths in any base) whose averaged growth is logarithmic - a tunable-base stepped control pattern.

ParamRangeDefaultUnit
Base2 – 1010—
Rate0.5 – 164Hz
Level0 – 11—

# HofstadterQSeq 1 input

Hofstadter Q sequence: the meta-recurrence Q(n)=Q(n-Q(n-1))+Q(n-Q(n-2)) where the sequence indexes into itself, producing erratic, chaotic-looking yet deterministic growth (from Godel, Escher, Bach) - a self-referential stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 165Hz
Level0 – 11—

# RulerSeq 1 input

Ruler sequence: the exponent of the highest power of 2 dividing the step index (the tick heights on an imperial ruler: 0,1,0,2,0,1,0,3,...), a self-similar pattern that doubles its tallest mark at every power of two.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# GrayCodeSeq 1 input

Gray-code sequence: the reflected binary code (each successive integer differs from the last by exactly one bit), read out as a low-bit gate; its single-bit-change property gives a smoothly-rotating, glitch-minimal pattern.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Bit0 – 40—
Level0 – 11—

# PascalMod 1 input

Pascal mod 2: scans Pascal's triangle modulo 2 (binomial parity, which draws the Sierpinski triangle); by Kummer's theorem the bit is 1 only where the row and column indices share no carry - a self-similar triangular gate pattern.

ParamRangeDefaultUnit
Rate0.5 – 308Hz
Width4 – 3216—
Level0 – 11—

# CatalanModSeq 1 input

Catalan mod sequence: the Catalan numbers (1,1,2,5,14,42,...) reduced modulo a small base, a combinatorial sequence counting balanced-bracket and tree structures; the modular fold makes a quirky repeating melodic pattern.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# PartitionSeq 1 input

Partition sequence: p(n), the number of ways to write n as a sum of positive integers (1,1,2,3,5,7,11,15,...), reduced modulo a base; this deeply-studied sequence (Ramanujan congruences) makes an irregular repeating CV pattern.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# BeattySeq 1 input

Beatty sequence: the gaps in floor(n*phi) alternate between 1 and 2 in the golden-ratio (Fibonacci-word) pattern, partitioning the integers into the complementary Beatty pair - a Sturmian, maximally-even rhythmic gate.

ParamRangeDefaultUnit
Ratio1.2 – 2.51.618—
Rate0.5 – 164Hz
Level0 – 11—

# WythoffSeq 1 input

Wythoff sequence: floor(n*phi), the lower Wythoff sequence whose pairs with floor(n*phi^2) are the losing positions of Wythoff's nim game; its values climb in a golden, self-similar staircase, here a stepped control source.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# DeBruijnSeq 1 input

De Bruijn sequence: a cyclic binary string in which every possible k-bit pattern appears exactly once (generated here by the prime-necklace/Lyndon-word concatenation), the maximally-compressed traversal of all sub-patterns - a dense structured gate.

ParamRangeDefaultUnit
Order2 – 54—
Rate0.5 – 308Hz
Level0 – 11—

# HilbertScan 1 input

Hilbert curve scan: walks the Hilbert space-filling curve and reads out one coordinate, so a 1-D index sweeps a 2-D square while keeping nearby steps spatially close - a locality-preserving, self-similar stepped control source.

ParamRangeDefaultUnit
Order2 – 64—
Rate0.5 – 308Hz
Level0 – 11—

# QuasiCrystal1D 1 input

1-D quasicrystal: the cut-and-project construction that tiles the line with two lengths in a golden, non-repeating order (the 1-D Penrose / Fibonacci quasicrystal), giving aperiodic-yet-ordered points - a Sturmian gate with quasicrystalline structure.

ParamRangeDefaultUnit
Slope0.3 – 0.80.618—
Rate0.5 – 164Hz
Level0 – 11—

# StanleySeq 1 input

Stanley sequence: the greedy set containing no three-term arithmetic progression (0,1,3,4,9,10,12,13,...), which turns out to be exactly the integers whose base-3 representation uses only 0s and 1s - a Cantor-set-flavoured stepped pattern.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# GolombSeq 1 input

Golomb sequence: the unique non-decreasing sequence where term n states how many times n appears (1,2,2,3,3,4,4,4,...), a self-describing sequence that grows like n^(phi) - a gently-climbing staircase with repeated plateaus.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# PrimeIndicator 1 input

Prime gate: outputs high only when the step index is a prime number, so the gate fires on 2,3,5,7,11,... - an irregular, thinning-with-time rhythmic pattern straight from the primes.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# SquareFreeSeq 1 input

Squarefree gate: high when the step index has no repeated prime factor (1,2,3,5,6,7,10,...), the indicator of the squarefree numbers (density 6/pi^2) - a sieve-flavoured aperiodic gate.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# PadovanSeq 1 input

Padovan sequence: P(n)=P(n-2)+P(n-3) (the recurrence whose growth ratio is the plastic number), the 'Fibonacci with a gap' that underlies Padovan spirals; reduced modulo a base it makes a slow, gently-rolling melodic pattern.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# PerrinSeq 1 input

Perrin sequence: 3,0,2,3,2,5,5,7,... satisfying P(n)=P(n-2)+P(n-3) with its own seeds (famous because n divides P(n) almost exactly when n is prime - the Perrin pseudoprime test); modded, a quirky climbing pattern.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# TribonacciSeq 1 input

Tribonacci sequence: T(n)=T(n-1)+T(n-2)+T(n-3), the three-term generalization of Fibonacci whose growth ratio is the tribonacci constant; reduced modulo a base it gives a faster-climbing, busier melodic pattern than Fibonacci.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# PellSeq 1 input

Pell sequence: P(n)=2P(n-1)+P(n-2) (0,1,2,5,12,29,...), whose ratios converge to the silver ratio and whose terms give the best rational approximations to sqrt(2); modded, a brisk climbing melodic pattern.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# JacobsthalSeq 1 input

Jacobsthal sequence: J(n)=J(n-1)+2J(n-2) (0,1,1,3,5,11,21,43,...), the Fibonacci-like sequence whose ratio tends to 2 and which counts tilings and binary strings without adjacent 1s; modded, a doubling-ish stepped pattern.

ParamRangeDefaultUnit
Mod3 – 127—
Rate0.5 – 164Hz
Level0 – 11—

# UlamSeq 1 input

Ulam sequence: 1,2,3,4,6,8,11,13,... where each new term is the smallest integer that is the sum of two distinct earlier terms in exactly one way; mysteriously near-periodic in its density, it makes an intriguing climbing stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# KaprekarMap 1 input

Kaprekar routine: take a 4-digit number, subtract its ascending from its descending digit arrangement, and repeat; almost every start converges in at most 7 steps to the fixed point 6174 (Kaprekar's constant), then reseeds - a digit-process attractor.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# HappySeq 1 input

Happy numbers: repeatedly replace a number by the sum of the squares of its digits; 'happy' starts reach 1, the rest fall into the cycle 4,16,37,58,89,145,42,20,4... - this traces that digit-square trajectory, reseeding at each resolution.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# PeanoScan 1 input

Peano curve scan: walks Peano's original base-3 space-filling curve and reads out one coordinate; like the Hilbert scan it keeps consecutive indices spatially adjacent, but its ternary boustrophedon structure gives a different self-similar sweep.

ParamRangeDefaultUnit
Order1 – 43—
Rate0.5 – 308Hz
Level0 – 11—

# MortonScan 1 input

Morton Z-order scan: de-interleaves the bits of the step index into one coordinate, walking the Z-shaped space-filling curve; unlike Hilbert it has occasional long jumps at quadrant boundaries, giving a self-similar sweep with sudden leaps.

ParamRangeDefaultUnit
Order2 – 85—
Rate0.5 – 308Hz
Level0 – 11—

# FareySeq 1 input

Farey sequence: all reduced fractions in [0,1] with denominator up to a chosen order, listed in increasing size (0/1, 1/n, ..., 1/2, ..., 1/1); the gaps between successive Farey fractions make a symmetric, self-similar stepped CV.

ParamRangeDefaultUnit
Order3 – 106—
Rate0.5 – 308Hz
Level0 – 11—

# TribonacciWordSeq 1 input

Tribonacci word: the fixed point of the substitution a->ab, b->ac, c->a, a three-letter aperiodic sequence whose letter frequencies follow the tribonacci constant (the 3-symbol analogue of the Fibonacci word) - a structured three-level CV.

ParamRangeDefaultUnit
Rate0.5 – 165Hz
Level0 – 11—

# SierpinskiArrowhead 1 input

Sierpinski arrowhead: the turn sequence of the space-filling curve that traces out the Sierpinski triangle, a self-similar left/right turn pattern (derived from the ruler-like 2-adic structure of the index) - a fractal gate rhythm.

ParamRangeDefaultUnit
Rate0.5 – 166Hz
Level0 – 11—

# AbundanceSeq 1 input

Abundance sequence: compares the sum of a number's divisors to twice the number, outputting deficient (-), perfect (0) or abundant (+); perfect numbers (6,28,496,...) hit exactly zero, a rare event in an otherwise mostly-negative stream.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# LychrelMap 1 input

Reverse-and-add: take a number, add it to its digit-reversal, and repeat; most numbers quickly reach a palindrome, but suspected Lychrel numbers (like 196) seem never to - this traces that growing iteration, reseeding when a palindrome is hit.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# HofstadterFGMG 1 input

Hofstadter Female-Male sequences: two intertwined recurrences (F(n)=n-M(F(n-1)), M(n)=n-F(M(n-1))) that each call the other (from Godel, Escher, Bach); their interleaved growth makes a gently-jittering self-referential stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 165Hz
Level0 – 11—

# DigitalRoot 1 input

Digital root: repeatedly sum the decimal digits of the step index until one digit remains (equivalently 1 + (n-1) mod 9), producing a perfectly periodic 1..9 staircase - a nine-step modular ramp from elementary number theory.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# CollatzStopping 1 input

Collatz stopping time: how many 3n+1/halve steps it takes for the step index to reach 1, a famously erratic integer (27 takes 111 steps) - clocked out, it makes a wildly-jumping stepped pattern from the unsolved Collatz conjecture.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# PrimeCountSeq 1 input

Prime-counting function: pi(n), the running count of primes up to the step index, a staircase that climbs by one at each prime and flattens between them; its slope (the prime density) thins logarithmically per the prime number theorem.

ParamRangeDefaultUnit
Rate0.5 – 166Hz
Level0 – 11—

# MertensSeq 1 input

Mertens function: the running sum of the Moebius function, a slow random-walk-like staircase whose growth rate is tied to the Riemann hypothesis (the disproved Mertens conjecture said it stays within +/-sqrt(n)) - a meandering number-theoretic CV.

ParamRangeDefaultUnit
Rate0.5 – 166Hz
Level0 – 11—

# LiouvilleSeq 1 input

Liouville function: lambda(n) is +1 or -1 by the parity of the total number of prime factors of n (with multiplicity); its sign sequence and partial sums are central to analytic number theory - a deterministic, nearly-balanced +/-1 stream.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# MangoldtSeq 1 input

Von Mangoldt function: Lambda(n) equals log(p) when n is a power of a single prime p and zero otherwise, the weighting that makes the prime-counting explicit formula work; it fires log-scaled spikes only on prime powers - a sparse arithmetic CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# DigitProductSeq 1 input

Digit product: multiplies together the base-B digits of the step index (which collapses to zero whenever any digit is zero), giving a spiky pattern that drops to silence on every index containing a zero digit - a base-tunable arithmetic CV.

ParamRangeDefaultUnit
Base2 – 1010—
Rate0.5 – 164Hz
Level0 – 11—

# PersistenceSeq 1 input

Multiplicative persistence: how many times you must replace a number by the product of its digits before reaching a single digit (e.g. 277777788888899 takes 11, the known record); this counts that depth for each index - a sparse spiky CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# NivenSeq 1 input

Niven (Harshad) gate: high when the step index is divisible by the sum of its own digits (1,2,...,10,12,18,20,...), a pattern that is common among small numbers but thins out - an arithmetic rhythmic gate.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# SelfNumberSeq 1 input

Self-number gate: high when the step index is a self (Colombian) number - one that cannot be written as some smaller number plus that number's digit sum (1,3,5,7,9,20,31,...) - a sparse, self-referential arithmetic gate.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# GilbreathSeq 1 input

Gilbreath sequence: repeatedly take absolute differences of consecutive primes and stack the rows; the leading entry of every row is conjectured to always be 1 (Gilbreath's conjecture). This reads out one diagonal of that triangle as a sparse pattern.

ParamRangeDefaultUnit
Rate0.5 – 165Hz
Level0 – 11—

# ThueMorseTernary 1 input

Ternary Thue-Morse: the sum of the base-3 digits of the index taken mod 3, a three-symbol automatic sequence generalizing the binary Thue-Morse, giving a self-similar three-level stepped CV that avoids short repetitions.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# WeylTwoTone 1 input

Two-tone Weyl: two additive-irrational (Weyl) sequences at incommensurate increments summed and wrapped, filling the range with a quasi-periodic, never-exactly-repeating two-frequency beat - an equidistributed dual-rate control source.

ParamRangeDefaultUnit
Step10.05 – 0.90.382—
Step20.05 – 0.90.618—
Rate0.5 – 508Hz
Level0 – 11—

# PrimeMod6 1 input

Primes mod 6: every prime past 3 is congruent to 1 or 5 (i.e. +/-1) modulo 6; this clocks out that residue of successive primes, a near-balanced two-level stream whose subtle biases (Chebyshev's prime-race) are a topic of active research.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# RudinShapiroWalk 1 input

Rudin-Shapiro walk: the running partial sum of the +/-1 Rudin-Shapiro sequence, a deterministic walk that - unlike a random walk - stays provably within order-sqrt(n) of zero (the source of the Rudin-Shapiro polynomials' flat sup-norm) - a tightly-bounded meandering CV.

ParamRangeDefaultUnit
Rate0.5 – 166Hz
Level0 – 11—

# PrimeOmegaSeq 1 input

Big-omega Omega(n): counts the prime factors of the step index with multiplicity (so 12 = 2*2*3 gives 3), the additive function at the heart of the Erdos-Kac theorem; clocked out it makes a low, jittery integer staircase.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# DistinctPrimesSeq 1 input

Little-omega omega(n): counts the distinct prime factors of the step index (so 12 = 2^2*3 gives 2), ignoring multiplicity; it grows like log-log n on average and makes a sparse, slowly-rising stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# RadicalSeq 1 input

Radical rad(n): the product of the distinct prime factors of the step index (the squarefree kernel, central to the abc conjecture); equal to n for squarefree numbers and much smaller for prime-power-rich ones - a log-scaled arithmetic CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# LegendreSymbol 1 input

Legendre symbol: outputs +1 if the step index is a quadratic residue modulo the chosen odd prime, -1 if a non-residue, 0 if divisible; this +/-1 pattern (a multiplicative character) underlies quadratic reciprocity and is conjectured pseudo-random.

ParamRangeDefaultUnit
Prime3 – 21131—
Rate0.5 – 164Hz
Level0 – 11—

# JacobiSymbol 1 input

Jacobi symbol: the Legendre symbol generalized to any odd modulus via reciprocity, giving a +/-1 (or 0) sequence computed by the fast reciprocity flip-and-reduce algorithm - a number-theoretic character pattern over composite moduli.

ParamRangeDefaultUnit
Modulus3 – 25545—
Rate0.5 – 164Hz
Level0 – 11—

# KroneckerSeq 1 input

Kronecker symbol: the Jacobi symbol extended to even and negative arguments via the special rule for 2, completing the quadratic character to a fully-multiplicative function on all integers - a +/-1/0 sequence with a distinct even-index structure.

ParamRangeDefaultUnit
Modulus3 – 25560—
Rate0.5 – 164Hz
Level0 – 11—

# LucasSeq 1 input

Lucas numbers: the Fibonacci companion 2,1,3,4,7,11,18,... with L(n)=L(n-1)+L(n-2), stepped live and reduced modulo a base you set - the recurrence is iterated each clock so the modulus knob is fully live, giving a tunable climbing pattern.

ParamRangeDefaultUnit
Mod3 – 169—
Rate0.5 – 164Hz
Level0 – 11—

# PisanoSeq 1 input

Pisano sequence: the Fibonacci numbers reduced modulo M, which are periodic with the Pisano period pi(M); stepped live, changing the modulus knob switches you between different cyclic patterns of varying length - a tunable periodic CV.

ParamRangeDefaultUnit
Mod2 – 168—
Rate0.5 – 164Hz
Level0 – 11—

# JacobsthalLucasSeq 1 input

Jacobsthal-Lucas numbers: the companion to the Jacobsthal sequence, 2,1,5,7,17,31,65,... with JL(n)=JL(n-1)+2JL(n-2), stepped live and reduced modulo a base - a doubling-flavoured tunable pattern with a fully-live modulus knob.

ParamRangeDefaultUnit
Mod3 – 169—
Rate0.5 – 164Hz
Level0 – 11—

# SmoothNumberSeq 1 input

Smooth-number gate: high when the step index's largest prime factor does not exceed the bound B (a B-smooth number), the property that makes integers easy to factor and underlies sieve algorithms; raising B opens the gate on more indices.

ParamRangeDefaultUnit
Bound2 – 507—
Rate0.5 – 164Hz
Level0 – 11—

# LargestPrimeFactor 1 input

Largest prime factor: P(n), the biggest prime dividing the step index (the Stormer / smoothness measure), which equals n on primes and drops sharply on smooth numbers - a spiky log-scaled arithmetic CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# SumOfSquaresSeq 1 input

Sum-of-two-squares count: r2(n), how many ways the step index is a sum of two (signed, ordered) squares, governed by its primes congruent to 1 vs 3 mod 4 (Gauss circle problem); a sparse pattern that is zero for many indices.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# CollatzMaxSeq 1 input

Collatz peak: the highest value the 3n+1 trajectory reaches before falling to 1 (27 climbs all the way to 9232), a wildly-varying integer that dwarfs the starting number; log-scaled it makes a jagged, occasionally-spiking stepped CV.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# CollatzParityWord 1 input

Collatz parity word: as the 3n+1 trajectory of the step index unfolds it emits a bit at each step (0 if even, 1 if odd), the 'parity vector' that uniquely encodes the starting number - a deterministic bit-stream from the Collatz dynamics.

ParamRangeDefaultUnit
Rate1 – 5012Hz
Level0 – 11—

# AliquotSeq 1 input

Aliquot sequence: repeatedly replace a number by the sum of its proper divisors; it may hit a prime then 1, settle on a perfect number, or enter an amicable/sociable cycle (the open Catalan-Dickson question) - a number-theoretic trajectory, reseeded on collapse.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# UnitaryDivisorSeq 1 input

Unitary divisor sum: sigma*(n) adds only the divisors d of the step index that are coprime to n/d (the unitary divisors), the product of (p^a + 1) over prime powers; a multiplicative function distinct from the ordinary divisor sum.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# SumOfDivisorsSeq 1 input

Divisor sum sigma(n): the total of all divisors of the step index (1+2+3+6=12 for n=6), the multiplicative function whose comparison to 2n defines perfect/abundant numbers; log-scaled it makes a lumpy arithmetic CV that peaks on highly-composite indices.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Level0 – 11—

# RissetRhythm 1 input

Risset rhythm: several click layers at octave-related tempos crossfade so that as fast layers fade in and slow ones fade out the pulse seems to accelerate (or decelerate) forever - the rhythmic analogue of the Shepard tone, as a gate/CV.

ParamRangeDefaultUnit
Speed-1 – 10.3—
BaseTempo0.5 – 41.5Hz
Level0 – 11—

# PoissonPulse 1 input

Poisson pulses: random clicks whose gaps follow an exponential distribution (a Poisson point process at a set mean rate), the model of radioactive decay and shot noise - memoryless random impulses with no underlying periodicity.

ParamRangeDefaultUnit
Rate1 – 20020Hz
Level0 – 10.7—

# RandomTelegraph 1 input

Random telegraph signal: a two-level (+/-1) signal that flips state at random with a fixed per-sample probability (a symmetric two-state Markov chain), the dichotomous noise behind 1/f flicker and burst noise in electronics - a stochastic square wave.

ParamRangeDefaultUnit
SwitchRate0.5 – 10010Hz
Level0 – 10.7—

# GeometricNoise 1 input

Geometric noise: the discrete count of failures before the first success in repeated coin flips (the discrete memoryless distribution), quantized into integer levels; lower success probability stretches the tail toward larger counts - a stepped discrete source.

ParamRangeDefaultUnit
Prob0.1 – 0.90.4—
Rate1 – 20020Hz
Level0 – 10.6—

# HawkesProcess 1 input

Hawkes process: a self-exciting point process where each event temporarily raises the intensity of further events, so impulses arrive in bursts and aftershock clusters (used for earthquakes, trades, neural spikes) - a clustering, contagious click train.

ParamRangeDefaultUnit
Baseline0.5 – 103Hz
Excite0 – 10.5—
Decay1 – 308—
Level0 – 10.7—

# MarkovMelody 1 input

Markov chain melody: walks an eight-state chain where the next state is chosen by a near-neighbour transition rule (mostly small moves, occasional leaps), producing stepped pitch sequences that feel coherent yet never quite repeat - a stochastic melody generator.

ParamRangeDefaultUnit
Wander0 – 10.4—
Rate0.5 – 164Hz
Level0 – 11—

# BenfordSeq 1 input

Benford's law: draws leading digits with the logarithmic frequencies P(d)=log10(1+1/d) that real-world data (street addresses, stock prices) obey, by taking the first digit of 10^u; digit 1 appears ~30% of the time, 9 under 5% - a skewed digit CV.

ParamRangeDefaultUnit
Rate1 – 10012Hz
Level0 – 11—

# MoranProcess 1 input

Moran process: in a fixed population of N, each step one individual reproduces and one dies, so an allele's count does a random walk until it fixes at 0 or N (genetic drift to extinction or takeover); it then reseeds - a drift-to-absorption CV.

ParamRangeDefaultUnit
Pop8 – 6424—
Rate1 – 50080Hz
Level0 – 10.6—

# WrightFisher 1 input

Wright-Fisher model: each generation the whole population is resampled, so the next allele count is binomial in the current frequency, driving faster drift to fixation than the Moran process; it reseeds on fixation - a jumpier generational drift CV.

ParamRangeDefaultUnit
Pop8 – 4820—
Rate0.5 – 305Hz
Level0 – 10.6—

# GamblersRuinWalk 1 input

Gambler's ruin: a +/-1 random walk (optionally biased) between two absorbing barriers of 0 and the stake; it wanders until it hits a wall - bust or broke-the-bank - then resets to the middle, giving runs of varying length to absorption.

ParamRangeDefaultUnit
Bias0.3 – 0.70.5—
Stake8 – 6424—
Rate1 – 50080Hz
Level0 – 10.6—

# SkellamNoise 1 input

Skellam noise: the signed difference of two independent Poisson counts, the integer distribution of net change when arrivals and departures both happen randomly (goal differences, net votes) - a discrete, signed, mean-zero stepped source.

ParamRangeDefaultUnit
Mean1 – 124—
Rate1 – 10012Hz
Level0 – 10.6—

# NegBinomialNoise 1 input

Negative-binomial noise: the count of failures before r successes in repeated trials, a discrete distribution that is more overdispersed (clumpier) than Poisson - the model of contagious or clustered counts, here a stepped integer source.

ParamRangeDefaultUnit
Successes1 – 83—
Prob0.2 – 0.80.5—
Rate1 – 10012Hz
Level0 – 10.6—

# BernoulliNoise 1 input

Bernoulli noise: a biased coin flipped at the clock rate, outputting +1 with probability p and -1 otherwise, the simplest possible random source and the building block of every binomial process - a probability-tunable random gate.

ParamRangeDefaultUnit
Prob0 – 10.5—
Rate1 – 20016Hz
Level0 – 10.8—

# DirichletPick 1 input

Dirichlet pick: draws a random probability vector over several levels from a symmetric Dirichlet distribution (normalized gamma samples) then selects a level by it; low concentration makes one level dominate, high concentration spreads the choice - a structured random quantizer.

ParamRangeDefaultUnit
Levels3 – 126—
Concentration0.2 – 41—
Rate1 – 10010Hz
Level0 – 10.7—

# TuringMachineSeq 1 input

Turing-machine sequencer: a 16-bit loop is rotated each step and the recirculating bit is flipped with an adjustable probability - at zero the loop locks into a repeating melody, at one-half it is fully random, and in between it slowly mutates; a window of bits forms the CV.

ParamRangeDefaultUnit
Length2 – 168—
Mutate0 – 10.1—
Rate0.5 – 206Hz
Level0 – 11—

# DynamicAllpass 1 input

Level-dependent allpass: a first-order allpass whose phase-rotation coefficient is pushed by the input envelope, so the phase smear (and the phasey notches when mixed dry) breathes with how hard you play.

ParamRangeDefaultUnit
Coef-0.9 – 0.90.5—
EnvMod-1 – 10.5—
Mix0 – 11—

# AsymTremolo 1 input

Asymmetric tremolo: the amplitude LFO is a skewable ramp - fast-up/slow-down or the reverse - so the volume pumps lopsidedly instead of the usual symmetric sine, giving a rhythmic, sawtooth-like swell.

ParamRangeDefaultUnit
Rate0.1 – 204Hz
Skew0.05 – 0.950.2—
Depth0 – 10.7—

# RingChorus 1 input

Ring-modulated chorus: a modulated short delay (the chorus voice) is multiplied by a low carrier before it is mixed back in, so the doubled voice takes on a clangorous inharmonic ring on top of the usual chorus widening.

ParamRangeDefaultUnit
Rate0.05 – 60.8Hz
Depth0 – 10.5—
Carrier20 – 40080Hz

# EnvRingMod 1 input

Envelope-tracking ring mod: the sine carrier's frequency rises with the input's loudness, so quiet passages ring low and inharmonic while loud hits shoot the sidebands up the spectrum - a dynamics-driven clangour no static ring mod produces.

ParamRangeDefaultUnit
Base20 – 2000200Hz
EnvMod0 – 10.7—
Mix0 – 11—

# DiodeRectChorus 1 input

Rectified chorus: the modulated delay voice is passed through an asymmetric diode rectifier (the negative half attenuated) before mixing, adding even-harmonic grit and an octave-up shimmer to the usual chorus widening - a dirtier, more vocal double.

ParamRangeDefaultUnit
Rate0.05 – 60.7Hz
Depth0 – 10.5—
Asym0 – 10.5—

# EnvPhaser 1 input

Auto-phaser: a four-stage allpass chain whose coefficient (notch frequency) is pushed up by the input's loudness instead of an LFO, so the phaser sweeps open on every transient and falls back as the note decays - a touch-sensitive sweep that follows your playing.

ParamRangeDefaultUnit
Coef0 – 0.90.3—
EnvMod0 – 10.6—
Feedback0 – 0.90.4—
Mix0 – 10.5—

# EnvFlanger 1 input

Auto-flanger: the swept comb delay (0.5-10 ms) is driven by the input envelope rather than an LFO, so the jet-like flange whoosh opens with dynamics - quiet passages sit short and bright, loud hits sweep the comb wide. Feedback sharpens the resonant peaks.

ParamRangeDefaultUnit
EnvMod0 – 10.7—
Feedback0 – 0.950.5—
Mix0 – 10.5—

# PhaserFold 1 input

Folding phaser: a six-stage allpass chain whose feedback is wavefolded before it re-enters, so the phaser's resonant peaks generate fold harmonics that swirl with the notches - a screaming, harmonically-alive phaser unlike any clean one.

ParamRangeDefaultUnit
Coef0 – 0.950.6—
Feedback0 – 0.90.5—
Fold1 – 31.5—
Mix0 – 10.5—

# FoldTremolo 1 input

Timbral tremolo: an LFO pumps the drive into a wavefolder rather than the volume, so the brightness/harmonic density pulses in rhythm while the level stays steady - a spectral throb distinct from amplitude tremolo.

ParamRangeDefaultUnit
Rate0.1 – 124Hz
Depth0 – 10.6—
Level0 – 10.6—

# VibratoFold 1 input

Folded vibrato: the signal is pitch-modulated by a short swept delay (vibrato) and then wavefolded, so the fold harmonics shift in pitch with the vibrato sweep - a warbling, animated brightness on top of the pitch waver.

ParamRangeDefaultUnit
Rate0.5 – 105Hz
Depth0 – 10.6—
Fold1 – 31.5—
Mix0 – 10.7—

# CrushChorus 1 input

Lo-fi chorus: the modulated chorus voice is bit-crushed before mixing, so the doubled layer is grainy and degraded against the clean original - a digital, vintage-sampler shimmer distinct from a clean analog chorus.

ParamRangeDefaultUnit
Rate0.05 – 60.8Hz
Depth0 – 10.5—
Bits2 – 126—

# RectTremolo 1 input

Rectified tremolo: the amplitude is modulated by |sin| rather than a sine, so the volume drops to sharp V-shaped dips twice per LFO cycle (double-time) with a rounded top - a more rhythmic, percussive throb than a smooth sine tremolo.

ParamRangeDefaultUnit
Rate0.1 – 155Hz
Depth0 – 10.6—
Level0 – 11—

# PhaseScramble 1 input

Phase scrambler: six allpass sections with incommensurate, slowly LFO-modulated coefficients rotate phase without touching magnitude, smearing and de-correlating transients into a soft wash - a moving phase-only diffuser for thickening or blurring a source.

ParamRangeDefaultUnit
Rate0.05 – 50.5Hz
Depth0 – 10.5—
Mix0 – 11—

# SaturateChorus 1 input

Saturated chorus: the input is tanh-saturated first, then doubled by a modulated short delay, so the chorus voice carries the same harmonic grit as the dry - a thicker, dirtier widening than a clean chorus, the order (drive-then-chorus) giving consistent colour across both layers.

ParamRangeDefaultUnit
Drive1 – 103—
Rate0.05 – 60.8Hz
Depth0 – 10.5—

# TeagerEnergy 1 input

Teager-Kaiser energy operator: computes psi(x)=x[n-1]^2 - x[n-2]*x[n], which tracks the instantaneous energy of an oscillation (proportional to amplitude^2 times frequency^2) using only three samples - it spikes on transients and follows combined amplitude/frequency modulation far faster than an RMS detector. Gain scales the output. Adds 1 sample latency.

ParamRangeDefaultUnit
Gain0.5 – 408—
Level0 – 11—

# KurtosisDetector 1 input

Kurtosis detector: computes the 4th standardized moment of a 7-sample window minus 3 (excess kurtosis), which is near zero for noise, negative for a steady sine, and spikes positive on impulsive clicks and transients - a control signal that measures how 'peaky' the local waveform distribution is. A statistical transient/impulsiveness sensor, not an envelope follower.

ParamRangeDefaultUnit
Gain0.01 – 20.2—
Level0 – 11—

# SkewnessDetector 1 input

Skewness detector: computes the 3rd standardized moment of a 7-sample window, which is zero for a symmetric waveform and swings positive or negative when the local shape leans one way - so it tracks waveform asymmetry and even-harmonic / DC-offset character. A different statistical feature from kurtosis: lopsidedness rather than peakedness. Useful as a modulation source.

ParamRangeDefaultUnit
Gain0.1 – 41—
Level0 – 11—

# HjorthMobility 1 input

Hjorth mobility: sqrt(var(dx)/var(x)) over an 8-sample window - the ratio of the signal's slope variance to its amplitude variance, which is a time-domain estimate of mean frequency (brightness). It rises for fast, bright material and falls for slow, dull material, all without an FFT. A spectral-brightness control signal from EEG analysis.

ParamRangeDefaultUnit
Gain0.1 – 20.5—
Level0 – 11—

# PetrosianFD 1 input

Petrosian fractal dimension: estimates how 'crinkled' the waveform is from the number of direction changes in its slope across a 16-sample window, via log(n)/(log(n)+log(n/(n+0.4*Nd))). Near 1 for smooth tones, higher for noisy or busy signals - a cheap roughness/complexity control derived from sign changes alone. Output is scaled excess over the smooth baseline.

ParamRangeDefaultUnit
Gain0.5 – 208—
Level0 – 11—

# PermutationEntropy 1 input

Permutation entropy: classifies every consecutive triple in a 16-sample window into one of the 6 possible orderings, then takes the normalized Shannon entropy of that histogram - 0 when the waveform is perfectly ordered (a clean ramp or tone), 1 when the ordering is random (noise). An ordinal-pattern complexity measure that ignores amplitude entirely. Output in 0..1.

ParamRangeDefaultUnit
Gain0.1 – 21—
Level0 – 11—

# KatzFD 1 input

Katz fractal dimension: measures waveform crinkliness as log(n)/(log(n)+log(d/L)) over a 16-sample window, where L is the total Euclidean path length along the curve and d is the farthest reach from the first point - 1 for a straight line, rising as the path folds back on itself. Unlike Petrosian's sign-change form, Katz uses real path geometry, so it responds to amplitude excursions too.

ParamRangeDefaultUnit
Gain0.5 – 208—
Level0 – 11—

# SampleEntropy 1 input

Sample entropy: counts how many length-2 sub-sequences in a 16-sample window stay within Tolerance of each other and how many of those still match when extended to length 3, returning -log(A/B) - low for regular, repeating signals and high for irregular, unpredictable ones. A self-match-free predictability measure (more robust than approximate entropy). Tolerance sets the matching radius.

ParamRangeDefaultUnit
Tolerance0.02 – 0.50.1—
Gain0.1 – 10.3—
Level0 – 11—

# EsaFrequency 1 input

Energy-separation frequency: uses the Teager operator on both the signal and its difference to solve for the instantaneous normalized frequency, arccos(1 - psi(dx)/(2*psi(x))) - an FFT-free pitch tracker that follows fast frequency modulation sample by sample. Outputs the normalized frequency (0..1 over 0..Nyquist) and is distinct from Teager energy, which measures amplitude.

ParamRangeDefaultUnit
Gain0.5 – 21—
Level0 – 11—

# IqrSpread 1 input

Interquartile-range detector: sorts a 7-sample window and outputs the gap between its upper and lower quartiles - a robust measure of local signal spread that ignores the single most extreme sample on each side, so it tracks sustained activity/roughness without being thrown off by isolated clicks. A click-immune alternative to variance as a modulation source.

ParamRangeDefaultUnit
Gain0.5 – 82—
Level0 – 11—

# HigherOrderCrossings 1 input

Higher-order crossings: counts zero-crossings not of the signal itself but of its Order-1 th finite difference over a 16-sample window - Order 1 is the ordinary zero-crossing rate, higher Orders emphasize progressively higher frequencies, so the output is a tunable spectral-tilt sensor (Kedem's HOC). A frequency-content control distinct from a plain zero-crossing counter.

ParamRangeDefaultUnit
Order1 – 42—
Gain0.5 – 21—
Level0 – 11—

# TripleCorrelation 1 input

Triple correlation: a leaky average of the triple product x[n]*x[n-1]*x[n-2], the third-order autocorrelation at lags 1 and 2 - unlike variance (lag-zero, 2nd order) or skewness it captures lagged, time-asymmetric structure and quadratic phase coupling, staying near zero for symmetric/Gaussian signals and growing for waveforms with consistent directional shape. A higher-order-statistics modulation source.

ParamRangeDefaultUnit
Gain1 – 205—
Level0 – 11—

# OneEuroSmooth 1 input

One-euro filter: an adaptive low-pass whose cutoff rises with the input's rate of change, so a slow or still signal is smoothed hard (killing jitter) while a fast move passes with little lag - the Casiez 1-euro algorithm prized for de-noising control signals without the sluggishness of a fixed smoother. MinCut is the at-rest cutoff, Beta how aggressively speed opens it up.

ParamRangeDefaultUnit
MinCut0.1 – 201Hz
Beta0 – 20.3—
Level0 – 21—

# AlphaBetaTrack 1 input

Alpha-beta tracker: the radar constant-velocity estimator applied to a control signal - it predicts the next value from an internal velocity, then corrects position by Alpha and velocity by Beta of the residual. Because it carries momentum it follows ramps and sweeps with far less lag than an exponential smoother of equal noise rejection, settling without the overshoot of a resonant filter - a predictive smoother distinct from the median/trimmed-mean family.

ParamRangeDefaultUnit
Alpha0.001 – 10.1—
Beta0 – 0.50.05—
Level0 – 21—

# Random 0 inputs

Self-contained random modulation source: latches a new random value at Rate (internal sample-and-hold of a noise source) with Smooth slewing between steps - from hard random steps to smooth wandering drift. Depth scales the swing and Bias offsets the centre. Needs no input; patch its output into any mod input for evolving, never-repeating movement.

ParamRangeDefaultUnit
Rate0.01 – 502Hz
Smooth0 – 10—
Depth0 – 11—
Bias-1 – 10—

# MIDI CC 0 inputs

MIDI continuous-controller mod source: outputs the live value (0..1) of MIDI CC number CC, so any hardware knob, fader, expression or breath controller becomes a modulation source - patch its output into any parameter's mod input. Smooth slews fast controller jumps, Depth scales the range and Bias offsets the centre. Common numbers: 1 mod wheel, 2 breath, 7 volume, 11 expression, 64 sustain, 74 brightness.

ParamRangeDefaultUnit
CC0 – 1271#
Smooth0 – 10—
Depth0 – 11—
Bias-1 – 10—

# Walk 1 input

Random walk (drunk): on each rising edge of the in0 clock the output takes a random step of up to +/- Step, bounded to 0..1 - a wandering melodic/modulation CV that meanders rather than jumping, the classic 'drunk' generator. Hold the clock high-rate for a smooth wander, slow for stepped motion.

ParamRangeDefaultUnit
Step0 – 0.50.15—

# ChuaOsc 0 inputs

Chua's-circuit chaos oscillator: a self-running analog-chaos modulation source - a strange attractor that wanders unpredictably yet stays bounded, never repeating. Rate sets the speed of evolution, Shape the attractor regime. A textured, organic chaos for evolving modulation. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 406Hz
Shape0 – 10.5—

# LogisticMap 0 inputs

Logistic-map chaos: the classic population-dynamics iterator x = R*x*(1-x), stepped at Rate. As R climbs past ~3.57 the output period-doubles into full chaos, then snaps back to order in the periodic windows - a stepped, glitchy random source you can tune from steady to wild. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 20020Hz
R2.8 – 43.8—

# SmoothRandom 0 inputs

Smooth random modulation: latches a new random target at Rate and continuously glides toward it, for organic wandering motion with no steps. Depth scales the swing. The smooth cousin of a sample-and-hold random - free-running, needs no clock.

ParamRangeDefaultUnit
Rate0.05 – 302Hz
Depth0 – 11—

# SteppedRandom 1 input

Stepped random (sample & hold): on each rising edge of the in0 clock it latches a new random voltage and holds it until the next clock - the hard-stepped random for melodic and rhythmic modulation. Range scales the swing.

ParamRangeDefaultUnit
Range0 – 11—

# MultiLFO 1 input

Multi-phase LFO: blends two sine waves a settable Phase apart into a single richer, evolving modulation shape - cross between a complex LFO and a quadrature pair. Rate sets the speed, Phase the offset (90 deg = quadrature), Depth the blend of the second phase. A trigger into in0 resets the phase; unpatched = free-run.

ParamRangeDefaultUnit
Rate0.01 – 301Hz
Phase0 – 10.25—
Depth0 – 10.5—

# Rungler 0 inputs

Rungler (Rob Hordijk): a shift register clocked at Rate is fed a pseudo-random bit and its low bits are read out as a stepped, looping-but-evolving voltage staircase - the gurgling, semi-random heart of the Benjolin. Length sets the loop length / repeat character. Needs no input.

ParamRangeDefaultUnit
Rate0.5 – 20030Hz
Length2 – 88—

# StandardMap 0 inputs

Chirikov standard-map chaos: iterates the area-preserving kicked-rotor map (p += K*sin(theta); theta += p) at Rate. At low K the output is smooth and quasi-periodic; past K~1 it breaks into hard chaos - a tunable bridge from orderly to wild stepped modulation. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 20020Hz
K0 – 31—

# PhaseLFO 1 input

Phase-offset LFO: a free-running sine LFO with an adjustable phase shift, resettable to zero on a rising edge of in0 - patch one clock into several PhaseLFOs at different Phase settings for quadrature or poly-rhythmic modulation from a single source. Rate sets the speed, Phase the offset (0..1 of a cycle), Depth the output level.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Phase0 – 10—
Depth0 – 11—

# DrunkLFO 1 input

Drunk-walk modulation: a random source that takes small random steps up or down at a set rate, wandering smoothly within +/-1 and reflecting off the rails - a bounded random walk (the drunk walk) for organic, slowly-drifting modulation, unlike sample-and-hold's independent jumps. Step sets the stride size, Rate the step interval, Depth the output level. A trigger into in0 restarts the walk at centre; unpatched = free-run.

ParamRangeDefaultUnit
Step0.01 – 0.50.15—
Rate0.1 – 304Hz
Depth0 – 11—

# SkewLFO 1 input

Variable-skew LFO: a triangle whose rising/falling balance is continuously adjustable, morphing from a ramp-down through a symmetric triangle to a ramp-up - one knob covers saw, triangle and reverse-saw modulation shapes. Rate sets the speed, Skew the rise/fall ratio, Depth the output level. A trigger into in0 resets the phase; unpatched = free-run.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Skew0.02 – 0.980.5—
Depth0 – 11—

# PerlinLFO 1 input

Perlin-noise LFO: a smoothly-interpolated coherent-noise modulation source - organic, wandering movement with no audible steps, smoother than sample-and-hold and less regular than an LFO. Rate sets the speed, Smooth the curve, Depth the output. A trigger into in0 resets the phase; unpatched = free-run.

ParamRangeDefaultUnit
Rate0.05 – 201Hz
Smooth0 – 10.7—
Depth0 – 11—

# ThruZero 1 input

Through-zero flanger: two delay taps sweep symmetrically about a short centre delay - one lengthening while the other shortens - so as the LFO crosses zero the taps pass through each other, producing the deep notch that sweeps all the way down to DC and momentarily cancels, the unmistakable tape-flanger 'through-zero' sound a normal flanger (with its fixed minimum delay) can't make. Rate sets the sweep speed, Depth the excursion, Feedback the resonance, and Mix the wet blend.

ParamRangeDefaultUnit
Rate0.01 – 80.3Hz
Depth0 – 53ms
Feedback0 – 0.950.3—
Mix0 – 10.5—

# LFO 1 input

Low-frequency control generator with sine, triangle, saw and pulse shapes (Shape), free-running at Rate. Depth scales the swing, Bias offsets the centre, Phase shifts the start point, and Width sets the pulse duty cycle. Patch its output into any parameter's mod input for vibrato, tremolo, filter sweeps and rhythmic movement. A trigger into in0 resets the phase (retrigger); leave it unpatched to free-run.

ParamRangeDefaultUnit
Rate0.01 – 1001Hz
Shape0 – 30—
Depth0 – 11—
Phase0 – 10—
Bias-1 – 10—
Width0.05 – 0.950.5—

# RingMod 2 inputs

Ring and amplitude modulator that multiplies the input by a carrier on in 2 (plus Bias). Mode morphs from true ring modulation (bipolar carrier, inharmonic metallic sum/difference tones) to amplitude modulation (unipolar, keeps the original plus sidebands), and Amount sets dry/wet. An audio-rate carrier yields clangorous bell tones; a low-rate carrier becomes tremolo.

ParamRangeDefaultUnit
Amount0 – 11—
Mode0 – 10—
Bias-1 – 10—

# PhaseMod 2 inputs

FM / phase-modulation processor: phase-modulates the in0 carrier with the in1 modulator (stack any number of sources into either input) to make classic FM sidebands - the modular way to FM oscillators together without per-oscillator routing. Patch one oscillator into in0 and another into in1 for two-operator FM; stack more cables on in1 to FM with several sources at once. Index sets the modulation depth, Feedback routes the output back into the modulator for harmonic edge toward noise, and Mix blends against the dry carrier. Distinct from the self-contained FM oscillator: this FMs whatever audio you feed it.

ParamRangeDefaultUnit
Index0 – 10.3—
Feedback0 – 0.950—
Mix0 – 11—

# Clock 0 inputs

Tempo-synced clock generator: emits a gate-pulse train locked to the host tempo (or a free Hz Rate). Sync picks the note division (0=free Hz, 1=1/1 .. 8=1/16T), Rate is the free-running frequency when Sync is 0, and Width sets the pulse length as a fraction of the step. Patch its output into envelopes, sample-and-holds, ClockDiv or any gate input to drive rhythmic movement from the host transport.

ParamRangeDefaultUnit
Rate0.1 – 402Hz
Width0.05 – 0.950.5—
Sync0 – 83—

# Euclid 0 inputs

Euclidean rhythm generator: distributes Pulses hits as evenly as possible across Steps positions (the algorithm behind countless drum patterns) and clocks them at the tempo-synced step Rate. Steps is the pattern length, Pulses the number of hits, Rotate shifts the pattern start, Rate the per-step note division (1=1/1 .. 8=1/16T), and Width the gate length. Outputs a gate on each active step - feed a drum/pluck envelope for generative rhythm that locks to the host.

ParamRangeDefaultUnit
Steps1 – 3216—
Pulses0 – 324—
Rotate0 – 310—
Rate1 – 85—
Width0.05 – 0.950.5—

# Ratchet 1 input

Ratchet / retrigger: while the in0 gate is high, replaces the held gate with a fast burst of Count sub-gates at the tempo-synced Rate - the classic 'stutter/roll' on a step. Count sets how many retriggers fire per gate, Rate the sub-division (1=1/1 .. 8=1/16T), and Width each sub-gate's length. Patch a clock or sequencer gate into in0 and the ratcheted gate out into an envelope for rolls and rhythmic fills.

ParamRangeDefaultUnit
Count1 – 82—
Rate1 – 86—
Width0.05 – 0.950.5—

# Turing 1 input

Turing-machine sequencer (looping shift register): on each rising edge of the in0 clock it shifts an internal register of step values and feeds the end back to the front - but with probability set by Lock it injects a fresh random value instead, so Lock fully up gives a locked repeating loop, fully down a new random sequence each pass, and in between a slowly mutating pattern. Length sets the loop length (2-16 steps), Lock the lock/mutation amount, Range the CV span, and Quantize snaps each step to a chromatic grid. The classic generative Eurorack CV source - patch its output into an oscillator pitch or any mod input.

ParamRangeDefaultUnit
Length2 – 168—
Lock0 – 10.5—
Range0 – 11—
Quantize0 – 10—

# Grids 0 inputs

Topographic drum trigger generator (Mutable Instruments Grids): walks a 32-step groove map and fires a gate when the selected Voice's pattern density at the current step beats the Density threshold, so turning Density up adds hits and down thins them out. Map morphs the rhythm between two feels, Chaos sprays in random hits/drops, and Voice picks Kick, Snare or Hat (run three Grids off the same patch for a full kit). Self-clocks at Rate. Distinct from Euclid's evenly-spread Euclidean rhythms - these are curated grooves.

ParamRangeDefaultUnit
Rate0.1 – 1008Hz
Map0 – 10.5—
Density0 – 10.5—
Chaos0 – 10—
VoiceKick · Snare · Hat—

# Marbles 0 inputs

Random voltage source with a loop lock (Mutable Instruments Marbles): on each internal Rate step it generates a new random value around Bias with a width set by Spread, but Deja Vu blends in replay of a stored loop - 1 = a locked, repeating random melody of Length steps, 0 = fresh randomness every step. A stepped CV source between pure chance and a fixed sequence; quantize the output for pitch. Distinct from Random (no loop memory) and Turing (binary shift register, not continuous CV).

ParamRangeDefaultUnit
Rate0.1 – 1006Hz
Bias0 – 10.5—
Spread0 – 10.5—
DejaVu0 – 10.5—
Length1 – 168—

# Wogglebug 0 inputs

Source of uncertainty (Make Noise Wogglebug / Buchla 266): an irregular internal clock latches a new random value each tick; Smooth blends from hard stepped voltages toward a smoothly wandering output, and Woggle rings each step with a decaying sinusoid for the burbling Buchla character. A self-running random modulation source - no input needed. Distinct from Random (steady clock, no woggle) and Chaos/LorenzLFO (deterministic attractors).

ParamRangeDefaultUnit
Rate0.05 – 604Hz
Smooth0 – 10.4—
Woggle0 – 10.3—

# Maths 1 input

Function generator (Make Noise Maths / Buchla 281 / Serge DUSG): a rise/fall slope with shapeable curves. Rise and Fall set the up/down times; Curve bends them from logarithmic through linear to exponential. Mode: Cycle self-runs as a variable-shape LFO; Trig fires a one-shot AD envelope on a gate at in0; Gate rises while in0 is held and falls when released (AR). The CV building block behind envelopes, slope LFOs and generative Krell patches. Patch a Clock/Euclid into in0 to trigger it.

ParamRangeDefaultUnit
Rise0.001 – 50.05s
Fall0.001 – 100.4s
Curve0 – 10.5—
ModeCycle · Trig · Gate—

# Tides 0 inputs

Tidal modulator (Mutable Instruments Tides): a slope source whose shape morphs continuously. Rate sets the speed (LFO into audio range); Slope skews the ramp from a fast-rise/slow-fall sawtooth through a symmetric triangle to slow-rise/fast-fall; Smooth rounds the contour from a sharp triangle toward a smooth sine swell. Use it as an evolving LFO, an envelope, or a raw oscillator. Distinct from the stepped MSEG and the fixed LFO shapes.

ParamRangeDefaultUnit
Rate0.01 – 40001Hz
Slope0 – 10.5—
Smooth0 – 10.5—

# QuadLFO 1 input

Quadrature LFO (Doepfer A-143-9): one rate, four phase-locked outputs 90 degrees apart. Each instance reads the shared transport clock, so several QuadLFOs at the same Rate stay phase-coherent and Phase (0/90/180/270) picks which quadrature tap this one outputs - patch four for circular/3D panning, stereo movement or evolving cross-modulation. Shape selects sine, triangle, saw or square. Distinct from the free-running LFO (no fixed phase relationship between instances). A trigger into in0 resets the phase (trigger several together to re-lock them); unpatched = free-run.

ParamRangeDefaultUnit
Rate0.01 – 401Hz
Phase0 · 90 · 180 · 270—
ShapeSine · Tri · Saw · Square—

# PLL 1 input

Phase-locked loop (Doepfer A-196): an internal square-wave VCO chases the frequency of the in0 input through an XOR phase comparator and a loop filter, locking onto it (or a multiple) - the lock is never perfect, so it warbles, glitches and screams in the classic PLL way. Base sets the VCO centre, Lock the loop tightness (low = sloppy, unstable, vocal; high = quick, tight tracking), and Range how far it can pull (octaves). Feed it audio or a clock for frequency multiplication, robot voices and chaotic tracking tones.

ParamRangeDefaultUnit
Base20 – 4000220Hz
Lock0 – 10.4—
Range1 – 53oct

# Bloom 0 inputs

Fractal sequencer (Qu-Bit Bloom): grows a melody from a short Trunk seed sequence by recursively grafting variations onto it. Length sets the trunk length; Branch adds fractal sub-sequences derived from the trunk (0 = play the plain trunk, up = ever more elaborate variations); Path chooses which route through the recursive tree is traversed; Scale sets the output range. Self-clocks at Rate. A generative stepped-CV source - quantize for pitch. Distinct from Turing (shift register) and StepSeq (fixed).

ParamRangeDefaultUnit
Rate0.1 – 1008Hz
Length2 – 168—
Branch0 – 10.3—
Path0 – 10—
Scale0 – 11—

# Frames 4 inputs

Keyframe morphing mixer (Mutable Instruments Frames): blends its four inputs (A-D) by sweeping one Frame knob through a chain of keyframes, crossfading from A toward D as Frame moves 0 to 1 - the modular take on animation keyframing. Frame sets the position and Anim, when above zero, animates it automatically at that rate (an evolving 4-source morph). Patch four oscillators or modulators in for smooth timbral or CV morphs. Distinct from the static Mixer and the XY-plane Vector.

ParamRangeDefaultUnit
Frame0 – 10—
Anim0 – 100Hz

# Stages 1 input

Segment generator (Mutable Instruments Stages): builds a function from a chain of Segs segments, each ramping to a new level over Time. Shape morphs every segment from a hard step, through a linear ramp, to a smooth S-curve; Loop makes the chain cycle as an evolving LFO, or one-shot it from a gate at in0 as a complex envelope. The flexible CV building block between an envelope, an LFO and a slow sequencer. Distinct from the breakpoint MSEG.

ParamRangeDefaultUnit
Rate0.05 – 602Hz
Segs2 – 84—
Shape0 – 10.5—
LoopOneShot · Loop—

# JustFriends 0 inputs

Manifold function generator (Mannequins Just Friends): one shape, six harmonically-related copies summed into a rich evolving wave. Time sets the base rate (slow LFO up to audio pitch); Intone spreads the six harmonics from a tight integer series toward stretched, detuned ratios; Curve bends every slope from a linear ramp toward a smooth sine; Level trims output. A function generator and harmonic oscillator in one - drones, organ-ish tones and undulating modulation. Distinct from the partial-summing Additive (pure sines, spectral tilt).

ParamRangeDefaultUnit
Time0.05 – 20004Hz
Intone0 – 10—
Curve0 – 10.5—
Level0 – 10.7—

# SampleHold 1 input

Clocked sample-and-hold that latches the input value at Rate and holds it until the next tick, producing stepped random or quantized control. Glide slews between steps for a smoother, portamento-like contour. Feed it noise for classic random sample-and-hold modulation, or an audio source to quantize it in time.

ParamRangeDefaultUnit
Rate0.1 – 2008Hz
Glide0 – 10—

# Slew 1 input

Slew-rate limiter that caps how fast the signal can rise and fall, with independent Rise and Fall rates. Use it as portamento/glide on pitch CV, a smoother on stepped modulation, or a lag to de-zipper control changes. Asymmetric Rise/Fall gives simple envelope-like attack and decay shaping.

ParamRangeDefaultUnit
Rise0 – 10.5—
Fall0 – 10.5—

# Chaos 0 inputs

Chaos modulator driven by the logistic map (x = r*x*(1-x)): at each Rate tick it iterates the map, and Chaos raises r from the periodic into the chaotic regime for unpredictable-but-deterministic motion. Smooth slews between values for a flowing control source rather than hard steps. Use it for evolving, never-quite-repeating modulation.

ParamRangeDefaultUnit
Rate0.1 – 50020Hz
Chaos0 – 10.8—
Smooth0 – 10.5—

# Phaser 1 input

All-pass cascade phaser: an LFO sweeps 2-8 all-pass stages (Stages) to move a series of notches through the spectrum, with Feedback sharpening their resonance. Depth sets the sweep range and Mix the dry/wet blend. More stages add more notches for a deeper, more vocal swirl.

ParamRangeDefaultUnit
Rate0.05 – 80.4Hz
Depth0 – 10.7—
Feedback0 – 0.90.3—
Stages2 – 84—
Mix0 – 10.5—

# BiasPump 1 input

Bias pumping: a level-dependent tremolo modelling the way a leaking bias/supply makes an amp 'breathe' - the amplitude wobble gets DEEPER as the signal gets louder, so quiet parts are steady and loud parts pump and throb. Distinct from a plain tremolo whose depth is fixed. Rate sets the pump speed, Depth the worst-case pumping, Mix the blend.

ParamRangeDefaultUnit
Rate0.1 – 124Hz
Depth0 – 10.5—
Mix0 – 11—

# Gargle 1 input

Gargle modulator: chops the amplitude on and off at an audio-rate random clock, the classic 'gargle' robot-voice ring/AM chop - between a coarse buzzy ring-modulation and a sputtering bitlike chatter depending on Rate. Rate sets the chop clock, Mix the blend.

ParamRangeDefaultUnit
Rate20 – 4000400Hz
Mix0 – 11—

# Wobbulate 1 input

Wobbulator: a resonant band sweeps wildly across the spectrum driven by a sine LFO blended with a smoothed random walk, so the colour lurches and wobbles unpredictably between hollow vowels and shrill peaks - the lab-bench wobbulator turned into an effect. Rate sets the wobble speed, Depth the sweep range, Mix the blend.

ParamRangeDefaultUnit
Rate0.1 – 122Hz
Depth0 – 10.6—
Mix0 – 11—

# Dopplerize 1 input

Doppler: a delay line whose length is swept by a velocity LFO, so the pitch bends up as the virtual source rushes toward you and down as it recedes - the siren-passing-by warp. A continuous, physical pitch-vibrato quite unlike a static chorus. Rate sets the pass-by speed, Depth the pitch swing, Mix the blend.

ParamRangeDefaultUnit
Rate0.05 – 81Hz
Depth0 – 10.5—
Mix0 – 10.6—

# RatchetGate 1 input

Ratchet gate: each bar the gate retriggers at a clock that ACCELERATES through the bar - even subdivisions at the start rushing into a fast machine-gun stutter by the end, then resetting. The drum-fill ratchet as a rhythmic gate. Rate sets the bar speed, Accel how hard it speeds up, Mix the blend.

ParamRangeDefaultUnit
Rate0.2 – 41Hz
Accel0 – 0.60.2—
Mix0 – 11—

# ProbGate 1 input

Probability gate: on every step it flips a weighted coin and either passes the audio or mutes it for that step, so a steady part is randomly thinned into an ever-changing rhythm. Bernoulli muting, musical-rate, not the audio-rate chop of a ring chopper. Prob sets the pass likelihood, Rate the step clock, Mix the blend.

ParamRangeDefaultUnit
Prob0 – 10.6—
Rate1 – 328Hz
Mix0 – 11—

# DriftDetune 1 input

Analog drift: a single delayed copy whose pitch wanders on a smoothed random walk - the slow, lazy detuning of a warm analog oscillator that never quite stays in tune. Thickens and animates without the regular swirl of a chorus. Drift sets the wander speed, Depth the detune amount, Mix the blend.

ParamRangeDefaultUnit
Drift0 – 10.5—
Depth0 – 10.4—
Mix0 – 10.5—

# RingDip 1 input

Ducking ring-mod: the ring modulation depth is keyed INVERSELY to level, so quiet passages turn clangorous and metallic while loud hits ring through nearly clean - the robot tone emerges only in the gaps. Freq sets the carrier, Depth the maximum metallic-ness, Mix the blend.

ParamRangeDefaultUnit
Freq20 – 2000200Hz
Depth0 – 10.7—
Mix0 – 11—

# Gallop 1 input

Gallop: an amplitude pattern that plucks the signal in a galloping long-short-short triplet figure (hits at the downbeat and the back two thirds), turning a pad or a drone into a rhythmic canter. Rate sets the gallop tempo, Mix the blend.

ParamRangeDefaultUnit
Rate0.3 – 61.5Hz
Mix0 – 11—

# Breathe 1 input

Breathe: a slow asymmetric volume swell - a quick inhale rise and a longer exhale fall - that makes the signal seem to breathe in and out. Gentler and more lifelike than a sine tremolo because the shape itself is lung-like. Rate sets the breaths, Depth how deep the breath, Mix the blend.

ParamRangeDefaultUnit
Rate0.05 – 20.3Hz
Depth0 – 10.7—
Mix0 – 11—

# Undulate 1 input

Undulate: amplitude and timbre roll together on one slow LFO - as the volume swells the tone opens and brightens, as it dips the tone closes and darkens - so the sound undulates like a wave rather than just pulsing. Rate sets the swell speed, Depth the range, Mix the blend.

ParamRangeDefaultUnit
Rate0.05 – 40.5Hz
Depth0 – 10.6—
Mix0 – 11—

# Fracture 1 input

Fracture: an onset splits the signal into two delayed copies whose detune WIDENS over time, so the sound starts unified then cracks open and drifts apart into a widening rift. Spread sets how fast and far it fractures, Mix the blend.

ParamRangeDefaultUnit
Spread0 – 10.5—
Mix0 – 10.6—

# Melt 1 input

Melt: while a note is sustained the pitch slowly sags downward as a growing delay stretches it, so a held tone seems to melt and drip toward the floor, snapping back when you release. A continuous downward droop, not a triggered fall. Rate sets the melt speed, Mix the blend.

ParamRangeDefaultUnit
Rate0 – 10.5—
Mix0 – 10.6—

# Tremble 1 input

Tremble: a nervous, fluttering tremolo - the amplitude jitters on a fast smoothed-random envelope rather than a steady LFO, so the sound shivers and trembles unevenly, like a held note played by a shaking hand. Rate sets the flutter speed, Depth the shake, Mix the blend.

ParamRangeDefaultUnit
Rate2 – 3010Hz
Depth0 – 10.6—
Mix0 – 11—

# PitchStair 1 input

Pitch staircase: a delay line whose length jumps in discrete steps after each onset, so a held note climbs or sits on a STEPPED pitch ladder rather than a smooth glide - a quantized, robotic pitch staircase. Step sets the size of each tread, Rate how often it steps, Mix the blend.

ParamRangeDefaultUnit
Step0 – 10.5—
Rate1 – 206Hz
Mix0 – 10.6—

# SlideUp 1 input

Slide up: each onset starts the pitch below target and slides up into place as a shrinking delay closes the gap - the scoop-up / fall-up portamento into every note. Time sets how long the slide takes, Depth how far below it starts, Mix the blend.

ParamRangeDefaultUnit
Time0.02 – 0.50.12s
Depth0 – 10.6—
Mix0 – 10.6—

# PhaseRotate 1 input

Phase rotator: a cascade of all-pass stages spins the broadband phase of the signal without touching its magnitude spectrum, so asymmetric waveforms (voice, brass) get their positive/negative peaks evened out - a free headroom/symmetry trick that sounds identical alone but changes how it clips and sums. Amount sets the rotation, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# AutoRing 1 input

Self ring-mod: the signal is ring-modulated by a DELAYED copy of ITSELF rather than an external oscillator, so the carrier is always related to the source - producing inharmonic, evolving metallic sidebands that move with the material instead of a fixed clang. Time sets the delay (and so the carrier pitch), Depth the ring amount, Mix the blend.

ParamRangeDefaultUnit
Time0.1 – 304ms
Depth0 – 10.6—
Mix0 – 11—

# Tremolo 0 inputs

Amplitude tremolo: an LFO at Rate modulates the signal level by Depth, switchable between a smooth sine and a choppy square (Shape). Classic for rhythmic volume pulsing, surf-guitar wobble and rotary-style throb. At full Depth with the square shape it becomes a hard on/off gate.

ParamRangeDefaultUnit
Rate0.05 – 205Hz
Depth0 – 10.5—
Shape0 – 10—

# Dropout 1 input

Random rhythmic muting: a clock at Rate decides per cycle whether to drop the signal to silence (Amount sets the drop probability), smoothed by Smooth to avoid clicks. Emulates a bad cable, dying battery or stuttery transmission. Subtle for movement, extreme for glitch and IDM textures.

ParamRangeDefaultUnit
Rate0.1 – 304Hz
Amount0 – 10.3—
Smooth0 – 10.5—

# TranceGate 1 input

Rhythmic hard gate: an LFO at Rate chops the signal on and off with a Duty cycle, smoothed by Smooth and scaled by Depth. Modulate Rate to lock it to tempo for the classic trance/EDM stutter. See StepSeq for arbitrary per-step patterns rather than a fixed duty.

ParamRangeDefaultUnit
Rate0.1 – 308Hz
Duty0.05 – 0.950.5—
Smooth0 – 10.2—
Depth0 – 11—

# Vector 4 inputs

Bilinear XY vector mixer: blends four inputs across an X/Y plane (in 1/in 2 the top corners, in 3/in 4 the bottom), with X and Y setting the morph position. Classic vector synthesis (Prophet VS / Wavestation) - feed it four oscillators or sources and automate X/Y to morph between them.

ParamRangeDefaultUnit
X0 – 10.5—
Y0 – 10.5—

# Scan 4 inputs

Scanning four-source mixer: a read position sweeps across in 1..in 4 and crossfades between adjacent sources, wrapping 4 back to 1 for a continuous loop. Pos sets the position by hand; Rate above zero auto-scans the position and loops it; Smooth rounds the crossfade from linear to an S-curve. Feed it four oscillators or signals and scan or automate to morph between them - the sequential companion to the bilinear Vector mixer.

ParamRangeDefaultUnit
Pos0 – 10—
Rate0 – 300Hz
Smooth0 – 11—

# StepSeq 0 inputs

Step sequencer modulation source: cycles through up to 6 step levels (S1-S6) at Rate steps per second, outputting the held value of the current step. Use it as a rhythmic mod source for cutoff, pitch or level, or to chop gain into patterns. Modulate Rate to lock to tempo; see TranceGate for a simple on/off duty gate.

ParamRangeDefaultUnit
Rate0.1 – 304Hz
Steps1 – 64—
S10 – 11—
S20 – 10.5—
S30 – 10.75—
S40 – 10.25—
S50 – 10.6—
S60 – 10.4—

# Stepper 0 inputs

Tempo-synced step-sequencer modulator: steps through S1..S5 levels locked to the host tempo, with Glide smoothing the jumps from hard sample-and-hold steps to a slewed contour. Sync sets the per-step note division (1/1..1/16T), Steps how many levels are used, and Glide the slew time. Per-voice (each instance runs independently); patch it into cutoff, pitch or level for rhythmic, tempo-locked movement. Distinct from StepSeq, which free-runs in Hz with no glide or sync.

ParamRangeDefaultUnit
Sync1 – 84—
Steps1 – 54—
Glide0 – 10—
S10 – 11—
S20 – 10.4—
S30 – 10.7—
S40 – 10.2—
S50 – 10.55—

# KeyTrack 1 input

Keyboard-tracking mod source: turns the note pitch into a centered, scalable modulation - the classic filter keytrack. Patch the Note source into in0; the output is (note - Center) x Amount around the midpoint, so notes above Center push the modulation up and notes below push it down (Amount 1 = full 1:1 tracking across the keyboard, 0.5 = half, negative inverts). Patch the output into a filter cutoff (or any param) so the timbre follows the keyboard. Center sets the pivot note (0-127), Amount the bipolar tracking depth. Unlike the raw Note source this is centered and scalable, so the modulation is zero at the pivot.

ParamRangeDefaultUnit
Center0 – 12760—
Amount-2 – 21—

# Drift 0 inputs

Slow smoothed random-walk modulator centred on 0.5, emulating vintage analog drift. Rate sets how often it picks a new target and Depth the deviation. Patch a little into pitch, cutoff or level to take the static, too-perfect edge off a patch.

ParamRangeDefaultUnit
Rate0.05 – 50.5Hz
Depth0 – 10.5—

# Allpass 1 input

All-pass diffuser: a cascade of 1-8 first-order all-pass sections (Stages) that rotate phase while leaving magnitude flat, set by Coef. A building block for reverb diffusion, phasers and stereo de-correlation rather than an audible filter on its own. More stages and higher Coef smear transients harder.

ParamRangeDefaultUnit
Coef-0.95 – 0.950.7—
Stages1 – 84—
Mix0 – 11—

# LorenzLFO 1 input

Lorenz strange-attractor chaos modulator (Serum-style): integrates the Lorenz system and outputs one Axis (X/Y/Z), normalized and scaled by Depth. Produces smooth, organic, never-repeating motion - more flowing than stepped random. Great for evolving cutoff, pitch or pan drift. A trigger into in0 resets the attractor; unpatched = free-run.

ParamRangeDefaultUnit
Rate0.01 – 502Hz
Axis0 – 20—
Depth0 – 11—

# Combinate 2 inputs

Combines two modulation or audio inputs (Pigments-style): Mode selects sum, ring (multiply), max, min, difference or sign-XOR, scaled by Mix. A math/logic node for the mod matrix - build complex modulators from simpler ones, or use it as a flexible ring/AM stage. Complements the Expr script node for inline math.

ParamRangeDefaultUnit
Mode0 – 50—
Mix0 – 11—

# TZFlanger 1 input

Through-zero flanger that reads two short delay taps swept in opposite directions by a cosine LFO, so the offsets cross and produce a deep tape-style null. Rate sets the LFO speed, Depth scales the sweep range, Feedback (up to 0.95) regenerates one tap for sharper resonance, and Mix sets dry/wet. The counter-swept design gives the dramatic zero-crossing whoosh that fixed flangers cannot reach.

ParamRangeDefaultUnit
Rate0.01 – 80.3Hz
Depth0 – 10.6—
Feedback0 – 0.950.4—
Mix0 – 10.5—

# Vibe 1 input

Photocell-style vibe that runs the signal through four staggered first-order all-pass stages whose coefficients are swept by a cosine LFO, each stage offset slightly to mimic mismatched optical cells. Rate sets the swirl speed, Depth scales how far the all-pass coefficients move, and Mix blends the phase-shifted output against the dry signal. The uneven staging gives the watery, throbbing swirl associated with classic vibe pedals.

ParamRangeDefaultUnit
Rate0.05 – 81Hz
Depth0 – 10.7—
Mix0 – 10.5—

# HarmTremolo 1 input

Harmonic tremolo that splits the signal into low and high bands with a one-pole low-pass and amplitude-modulates them in opposition with a sine LFO, so as the lows swell the highs dip and back again. Rate sets the LFO speed, Depth sets the modulation intensity, Freq places the band split, and Mix sets dry/wet. The opposing band motion gives a richer, more vocal sweep than amplitude tremolo.

ParamRangeDefaultUnit
Rate0.1 – 124Hz
Depth0 – 10.6—
Freq200 – 3000800Hz
Mix0 – 11—

# WowFlutter 1 input

Tape pitch instability emulated by a short delay line (centred near 5 ms) whose read time is modulated by two sine LFOs, a slow ~0.6 Hz wow and a fast ~7 Hz flutter, producing continuous pitch drift. Wow scales the slow drift depth and Flutter scales the fast wobble, while Mix blends the warped signal against the dry input. Use low amounts for subtle tape warmth and higher settings for seasick, detuned movement.

ParamRangeDefaultUnit
Wow0 – 10.4—
Flutter0 – 10.3—
Mix0 – 11—

# Swarm 0 inputs

Flocking modulation source (a first as a synth block): a swarm of six agents drift under boids rules - steering toward the flock centre (Cohesion), away from crowding neighbours (Separation), toward the average heading, plus a little wander - and the output is the swarm's collective centre as a slowly evolving, organic CV. Rate sets the motion speed. Unlike an LFO (a fixed shape) or the memoryless random of Marbles/Wogglebug, the swarm self-organises: it flocks, splits and regroups, moving smoothly but never repeating. Needs no input.

ParamRangeDefaultUnit
Rate0 – 10.4—
Cohesion0 – 10.5—
Separation0 – 10.5—

# DoublePendulum 0 inputs

Double-pendulum chaos source (a first as a synth block): integrates the real equations of motion of two jointed pendulums - the textbook deterministic-chaos system - and outputs the lower bob's swing as a smooth, never-repeating CV. Tiny differences in motion explode into wholly different trajectories, so it wanders organically forever without an LFO's repetition or a noise source's harshness. Rate sets the simulation speed; the output stays bounded in +/-1 however wildly the arms tumble. A different, smoother chaos than the logistic Chaos or Lorenz blocks.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Chua 0 inputs

Chua's-circuit chaos source (a first as a synth block): integrates the dimensionless Chua equations - the simplest electronic circuit that is provably chaotic, a real analog oscillator built from an op-amp, two capacitors, an inductor and the piecewise-linear 'Chua diode'. The trajectory winds around two attracting loops and flips unpredictably between them (the famous double-scroll), giving a smooth bipolar CV that meanders forever without repeating. Rate sets the integration speed. A circuit-born chaos, smoother than a map and distinct from the mechanical DoublePendulum or the Lorenz LFO.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Duffing 0 inputs

Driven-Duffing chaos source (a first as a synth block): integrates the forced double-well Duffing oscillator x'' + d*x' - x + x^3 = Drive*cos(w t) - a mass in a twin-valley potential shaken by a periodic drive. At chaotic settings it jumps erratically between the two wells, never locking to the drive's period, yielding a smooth bipolar CV with a rhythmic pulse running under the chaos. Rate sets the speed, Drive the forcing amplitude (raise it to push from periodic motion into chaos). A forced-oscillator chaos distinct from the autonomous Chua or DoublePendulum.

ParamRangeDefaultUnit
Rate0.05 – 41—
Drive0 – 0.60.37—

# Standard 0 inputs

Chirikov standard-map source (a first as a synth block): the kicked-rotor map p <- p + K*sin(theta), theta <- theta + p on a torus - the textbook model of Hamiltonian chaos and the onset of turbulence. Below the critical kick the motion is smooth and quasi-periodic; above it (raise K) the phase space dissolves into a chaotic sea. It free-runs at Rate, stepping the map and outputting sin(theta) as a bipolar CV - regular and rolling at low K, wildly scattered at high K. A momentum-kicked chaos distinct from the dissipative attractors.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
K0.5 – 62—

# Gingerbread 0 inputs

Gingerbreadman-map source (a first as a synth block): iterates the piecewise-linear chaotic map x <- 1 - y + |x|, y <- x - an area-preserving map whose orbits fill a strange six-sided 'gingerbread man' region of interleaved chaotic seas and stable islands. It free-runs at Rate, stepping the map and emitting x as a bipolar stepped CV that hops around the figure forever without repeating. Built from only an absolute value and a subtraction, it is a different, more angular chaos than the trig-based attractors.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Clifford 0 inputs

Clifford-attractor source (a first as a synth block): iterates the strange-attractor map x <- sin(A*y) + cos(A*x), y <- sin(1.6*x) + 0.7*cos(1.6*y), whose orbit is forever drawn toward a delicate folded-ribbon fractal. It free-runs at Rate, stepping the map and outputting x as a smooth bipolar CV that traces the attractor's swirls. A sets the warp of the figure - small changes redraw the whole attractor - giving a rich family of organic, never-repeating motions distinct from the scrolls of Chua or the kicks of the standard map.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
A-2 – -0.5-1.4—

# CircleMap 0 inputs

Sine-circle-map source (a first as a synth block): iterates theta <- theta + Omega - (K/2pi) sin(2pi theta) on a circle - the model of an oscillator being kicked once per turn, and the textbook route to MODE-LOCKING. For bands of settings (the Arnold tongues) it locks onto a rational rhythm and repeats exactly; between them it runs quasi-periodically or, at high K, chaotically - so sweeping Omega walks a devil's-staircase of locked and unlocked ratios. It free-runs at Rate, outputting the angle as a 0..1 CV. K sets the kick strength, Omega the bare turn rate. A locking oscillator distinct from the dissipative attractors.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
K0 – 64—
Omega0 – 10.33—

# GaussMap 0 inputs

Gauss-map (mouse-map) source (a first as a synth block): iterates x <- exp(-Alpha x^2) + Beta, a bell-shaped map named for the Gaussian in it. Sweeping Beta marches it through a remarkable cascade - fixed points, period-doubling, and period-ADDING windows where the cycle length grows by one - drawing the 'mouse' shape in its bifurcation diagram. It free-runs at Rate, stepping the map and outputting x as a bipolar CV that ranges from steady to multi-step periodic to chaotic as Alpha and Beta move. A bell-curve map distinct from the parabolic logistic and tent maps.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Alpha4 – 86.2—
Beta-0.7 – 0.3-0.5—

# Cusp 0 inputs

Cusp-map source (a first as a synth block): iterates x <- 1 - 2*sqrt(|x|), a map with a sharp cusp at the origin instead of a smooth parabola. The square-root gives it an infinitely steep peak, so it stretches and folds the line more violently near zero than the polynomial maps, producing fully-developed chaos with a characteristic spiky density. It free-runs at Rate, stepping the map and outputting x as a bipolar CV that hops sharply across [-1, 1]. A non-smooth chaos distinct from the parabolic logistic and the piecewise tent.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# SineMap 0 inputs

Sine-map source (a first as a synth block): iterates x <- R*sin(pi*x), the trigonometric twin of the logistic map - a single smooth hump that, as R approaches 1, period-doubles its way into chaos by the very same Feigenbaum route, which is why it is a favourite engine for chaotic encryption. It free-runs at Rate, stepping the map and outputting x as a 0..1 CV. R sets the position on the road to chaos: low and it settles, near 1 and it never repeats. A sinusoidal unimodal map distinct from the polynomial logistic. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
R0.7 – 10.99—

# Cubic 0 inputs

Cubic-map source (a first as a synth block): iterates x <- A*x - x^3, an ODD-symmetric map (it treats positive and negative x as mirror images) unlike the lopsided logistic. That symmetry gives it a distinctive bifurcation diagram with two mirrored chaotic bands that can suddenly merge, and orbits that swing through both signs. It free-runs at Rate, stepping the map and outputting x as a bipolar CV. A sets the gain on the road to chaos. A symmetric cubic chaos distinct from the asymmetric quadratic maps. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
A2 – 32.59—

# DeJong 0 inputs

De-Jong attractor source (a first as a synth block): iterates Peter de Jong's map x <- sin(A*y) - cos(B*x), y <- sin(C*x) - cos(D*y), whose orbit weaves into a dense web of looping filaments - one of the most varied strange-attractor families, redrawing completely with the smallest change of constants. It free-runs at Rate, stepping the map and outputting x as a smooth bipolar CV that wanders the web. A warps the figure. A four-sine attractor distinct from the two-sine Clifford. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
A1 – 1.81.4—

# Tinkerbell 0 inputs

Tinkerbell-map source (a first as a synth block): iterates x <- x^2 - y^2 + A*x + B*y, y <- 2*x*y + C*x + D*y - a quadratic map of the plane whose orbit traces a comma-shaped fractal said to resemble Tinkerbell's flight path. Its mix of squaring and cross-coupling folds the trajectory into a tight curl with delicate internal banding. It free-runs at Rate, stepping the map and outputting x as a bipolar CV. A quadratic-plane attractor distinct from the trig-based De Jong and Clifford. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# GumowskiMira 0 inputs

Gumowski-Mira attractor source (a first as a synth block): iterates a map built around the recursive nonlinearity f(x) = A*x + 2(1-A)x^2/(1+x^2), devised at CERN to model the chaotic drift of particles in an accelerator beam. It is famous for the astonishing variety of shapes it draws - rings, swirls, lattices and creatures - from tiny parameter changes. It free-runs at Rate, stepping the map and outputting x as a bipolar CV. A particle-physics attractor distinct from the trigonometric and quadratic maps. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Lozi 0 inputs

Lozi-map source (a first as a synth block): iterates x <- 1 - A*|x| + y, y <- B*x - the piecewise-linear cousin of the Henon map, with an absolute value where Henon has a square. That sharp corner gives it a strange attractor made of straight-line segments rather than smooth curves, and one of the few chaotic maps proven rigorously to be chaotic. It free-runs at Rate, stepping the map and outputting x as a bipolar CV. A sets the fold sharpness. An angular, provably-chaotic attractor distinct from the smooth Henon. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
A1.4 – 1.81.7—

# Svensson 0 inputs

Svensson attractor source (a first as a synth block): iterates Johnny Svensson's map x <- D*sin(A*x) - sin(B*y), y <- C*cos(A*x) + cos(B*y), a sine-and-cosine attractor that draws tight rosette and starburst figures with sharp radial symmetry. The mix of large and small coefficients pulls the orbit into spiked petals quite unlike the woven webs of De Jong. It free-runs at Rate, stepping the map and outputting x as a bipolar CV. A radial-symmetry attractor distinct from the other trigonometric maps. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Thomas 0 inputs

Thomas cyclically-symmetric attractor (a first as a synth block): integrates x' = sin(y) - b*x and its two cyclic rotations - a flow built entirely from sines, completely symmetric under swapping x->y->z. As the damping b is lowered the trajectory unwinds from a simple loop into a labyrinthine chaotic walk that drifts through space like a particle in a turbulent crystal lattice. It free-runs at Rate, outputting x as a smooth, gently-wandering bipolar CV. A trig-flow chaos distinct from the polynomial Lorenz or Chua systems.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Halvorsen 0 inputs

Halvorsen attractor (a first as a synth block): integrates the cyclically-symmetric system x' = -a*x - 4y - 4z - y^2 (and its x->y->z rotations), whose quadratic cross-terms wind the trajectory into a tight three-armed spiral knot. It free-runs at Rate, outputting x as a smooth bipolar CV that loops and lurches around the attractor's arms. A denser, more wound-up chaos than the open Lorenz butterfly, distinct from the trig-based Thomas. Internally 3 small Euler sub-steps keep the stiff dynamics stable.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Aizawa 0 inputs

Aizawa attractor (a first as a synth block): integrates a six-parameter forced system whose trajectory wraps around a sphere while a hole opens through its top axis, producing a shape unlike any other strange attractor - a knotted ball with a drilled core. It free-runs at Rate, outputting x as a smooth bipolar CV that orbits the sphere and dips through the hole, giving rich circular motion with sudden axial excursions. A visually and sonically distinct chaos from the butterfly and spiral attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Qi 0 inputs

Qi-Chen four-wing attractor (a first as a synth block): integrates x' = a*(y - x) + y*z, y' = c*x - y - x*z, z' = x*y - b*z, a system famous for growing FOUR wings instead of the usual two, the trajectory hopping chaotically between all four lobes. The extra quadratic cross-terms give it very wide, energetic swings. It free-runs at Rate, outputting x as a smooth bipolar CV with large excursions. A four-wing chaos distinct from the two-wing Lorenz and Chen attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# ChenLee 0 inputs

Chen-Lee attractor (a first as a synth block): integrates x' = a*x - y*z, y' = b*y + x*z, z' = c*z + x*y/3, a model of a rigid body rotating under feedback torque, derived from Euler's equations for a gyroscope. Its trajectory traces a pair of stacked, twisted rings (a double-scroll that loops rather than wings), wandering chaotically between them. It free-runs at Rate, outputting x as a smooth bipolar CV with wide swings. A rotational-dynamics chaos distinct from the Lorenz and Rossler families.

ParamRangeDefaultUnit
Rate0.05 – 41—

# ShimizuMorioka 0 inputs

Shimizu-Morioka attractor (a first as a synth block): integrates x' = y, y' = x - a*y - x*z, z' = -b*z + x^2, a simplified model of the Lorenz system near the onset of chaos. It shows a symmetric butterfly that is born through a sequence of bifurcations as the parameters change, a clean laboratory for studying how order gives way to chaos. It free-runs at Rate, outputting x as a smooth bipolar CV that flips between the two wings. A reduced-Lorenz chaos distinct from the full Lorenz attractor.

ParamRangeDefaultUnit
Rate0.05 – 41—

# WangSun 0 inputs

Wang-Sun attractor (a first as a synth block): integrates a four-term quadratic system x' = a*x + c*y*z, y' = b*x + d*y - x*z, z' = e*z + f*x*y with an unusual mix of small and large coefficients, one of the gallery of distinct chaotic flows catalogued in the search for new attractor shapes. Its orbit folds into a lopsided, asymmetric scroll. It free-runs at Rate, outputting x as a smooth bipolar CV. A custom-coefficient chaos distinct from the named classical attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Rucklidge 0 inputs

Rucklidge attractor (a first as a synth block): integrates x' = -k*x + a*y - y*z, y' = x, z' = -z + y^2, a model of convection in a fluid layer subject to a magnetic field (double-diffusive convection). It produces a symmetric two-lobed attractor as the rolls of fluid reverse chaotically. It free-runs at Rate, outputting x as a smooth bipolar CV with broad excursions. A convective-magnetic chaos distinct from the rigid-body and reduced-Lorenz flows.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Yu 0 inputs

Yu-Wang attractor (a first as a synth block): integrates x' = a(y - x), y' = b*x - c*x*z, z' = exp(x*y) - d*z - unusual for its EXPONENTIAL term, which makes the z dynamics snap rather than curve. The orbit forms a tight two-scroll butterfly with sharp, fast reinjections. It free-runs at Rate, outputting x as a smooth bipolar CV. An exponential-nonlinearity chaos distinct from the purely polynomial attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# ThreeScroll 0 inputs

Three-scroll attractor (a first as a synth block): integrates the Pan-Xu-Zhou system x' = a(y - x) + d*x*z, y' = c*y - x*z, z' = b*z + x*y - e*x*x, a unified chaotic flow whose trajectory weaves through THREE separate scroll centres instead of the usual two, hopping between all three lobes. It free-runs at Rate, outputting x as a smooth bipolar CV with wide swings. A three-lobe chaos distinct from the two-wing Lorenz and four-wing Qi attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Lorenz84 0 inputs

Lorenz-84 attractor (a first as a synth block): integrates Edward Lorenz's low-order model of the GLOBAL ATMOSPHERIC circulation, x' = -y^2 - z^2 - a*x + a*F, y' = x*y - b*x*z - y + G, z' = b*x*y + x*z - z, where x is the strength of the westerly wind current and y, z are a travelling weather wave. It chaotically switches between calm and stormy regimes, a toy climate that never repeats. It free-runs at Rate, outputting x as a smooth bipolar CV. A climate-model chaos distinct from the original Lorenz convection attractor.

ParamRangeDefaultUnit
Rate0.05 – 41—

# MooreSpiegel 0 inputs

Moore-Spiegel oscillator (a first as a synth block): integrates the jerk system x' = y, y' = z, z' = -z - (T - R + R*x*x)*y - T*x, devised to model the aperiodic flickering of a parcel of gas in a star's atmosphere (thermo-mechanical oscillations under radiation). The cubic stiffness term makes it burst between small and large oscillations chaotically. It free-runs at Rate, outputting x as a smooth bipolar CV. An astrophysical jerk-chaos distinct from the rotational and convective attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Dequan 0 inputs

Dequan-Li attractor (a first as a synth block): integrates a five-term unified chaotic system x' = a(y - x) + d*x*z, y' = k*x + f*y - x*z, z' = c*z + x*y - e*x*x with large coefficients that drive very energetic, wide-ranging orbits forming a dense double scroll. It free-runs at Rate, outputting x as a smooth bipolar CV with broad excursions. A high-energy unified chaos distinct from the gentler classical attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottJ 0 inputs

Sprott-J attractor (a first as a synth block): integrates x' = 2z, y' = -2y + z, z' = -x + y + y^2 - one of the 19 algebraically SIMPLEST chaotic flows that Julien Sprott found by computer search, each with the bare minimum of terms needed for chaos. Case J folds a single quadratic term into an otherwise linear system. It free-runs at Rate, outputting x as a smooth bipolar CV. A minimal-quadratic chaos distinct from the elaborate named attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottK 0 inputs

Sprott-K attractor (a first as a synth block): integrates x' = x*y - z, y' = x - y, z' = x + 0.3*z - another of Sprott's minimal chaotic systems, this one driven by the single product term x*y. Despite having only one nonlinearity it produces a fully chaotic orbit. It free-runs at Rate, outputting x as a smooth bipolar CV. A single-product chaos distinct from the other minimal Sprott cases.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottN 0 inputs

Sprott-N attractor (a first as a synth block): integrates x' = -2y, y' = x + z^2, z' = 1 + y - 2z - a minimal chaotic flow whose only nonlinearity is the squared z term. It traces a folded sheet that the orbit wanders chaotically. It free-runs at Rate, outputting x as a smooth bipolar CV. A squared-term minimal chaos distinct from the product-driven Sprott cases.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottR 0 inputs

Sprott-R attractor (a first as a synth block): integrates x' = 0.9 - y, y' = 0.4 + z, z' = x*y - z - a minimal chaotic system with constant forcing terms and a single product nonlinearity. The constants push the orbit steadily while the x*y coupling folds it into chaos. It free-runs at Rate, outputting x as a smooth bipolar CV. A forced minimal chaos distinct from the unforced Sprott cases.

ParamRangeDefaultUnit
Rate0.05 – 41—

# FinanceChaos 0 inputs

Financial-chaos attractor (a first as a synth block): integrates a model of a chaotic macroeconomy x' = z + (y - a)x, y' = 1 - b*y - x^2, z' = -x - c*z, where x is the interest rate, y the investment demand and z the price index. It shows how a deterministic economy with no outside shocks can still wander unpredictably between booms and busts. It free-runs at Rate, outputting x as a smooth bipolar CV. An econophysics chaos distinct from the mechanical and climate attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# NoseHoover 0 inputs

Nose-Hoover oscillator (a first as a synth block): integrates the thermostatted system x' = y, y' = -x + y*z, z' = a - y^2 - the equations a physicist uses to hold a simulated molecule at constant temperature, which famously refuse to settle and instead wander chaotically. Unlike the dissipative attractors it is volume-CONSERVING, so the trajectory never collapses onto a thin sheet but fills a fat tube of phase space, giving a fuller, more even chaotic motion. It free-runs at Rate, outputting x as a smooth bipolar CV. A conservative chaos distinct from the dissipative attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Rikitake 0 inputs

Rikitake-dynamo attractor (a first as a synth block): integrates the two-disc Rikitake dynamo x' = -mu*x + z*y, y' = -mu*y + (z - a)*x, z' = 1 - x*y - a model of the Earth's geomagnetic field built from two coupled current discs. Its chaos is the textbook explanation for why the planet's magnetic poles REVERSE at irregular intervals: the trajectory orbits one polarity for a while then flips to the other, unpredictably. It free-runs at Rate, outputting x as a smooth bipolar CV with long stretches in one sign broken by sudden reversals - a switching chaos distinct from the steadily-wandering attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Chen 0 inputs

Chen attractor (a first as a synth block): integrates Chen's system x' = a(y-x), y' = (c-a)x - xz + cy, z' = xy - bz - a close relative of the Lorenz butterfly discovered by feedback control, but with a more tightly wound double scroll whose two lobes are pulled closer and spun faster. It free-runs at Rate, outputting x as a smooth bipolar CV that loops within one lobe then flips chaotically to the other. A wound-up cousin of Lorenz distinct from the Rossler and Thomas flows.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Lu 0 inputs

Lu (Lu-Chen) attractor (a first as a synth block): integrates x' = a(y-x), y' = -xz + cy, z' = xy - bz - the system that forms the missing BRIDGE between the Lorenz and Chen attractors, morphing continuously from one to the other as its parameter changes. Its double scroll sits between the two, with its own balance of slow orbiting and sudden lobe-switching. It free-runs at Rate, outputting x as a smooth bipolar CV. A transitional double-scroll chaos distinct from both Lorenz and Chen.

ParamRangeDefaultUnit
Rate0.05 – 41—

# BurkeShaw 0 inputs

Burke-Shaw attractor (a first as a synth block): integrates x' = -s(x+y), y' = -y - s*x*z, z' = s*x*y + V - a tightly-coiled variant of the Lorenz system that winds into a dense, near-toroidal spiral rather than two separate wings, spinning rapidly around a doughnut of trajectories. It free-runs at Rate, outputting x as a smooth, fast-cycling bipolar CV with a strong underlying rotation. A coiled, rotation-dominated chaos distinct from the wing-flipping Lorenz and Chen.

ParamRangeDefaultUnit
Rate0.05 – 41—

# NewtonLeipnik 0 inputs

Newton-Leipnik attractor (a first as a synth block): integrates a rigid-body rotation system (from the Euler equations of a tumbling object with feedback) that has the rare property of TWO coexisting strange attractors - depending on where it starts, the trajectory settles onto one of two different chaotic shapes. It free-runs at Rate, outputting x as a smooth bipolar CV that winds through a delicate folded-ribbon attractor. A two-attractor chaos distinct from the single-attractor Lorenz family.

ParamRangeDefaultUnit
Rate0.05 – 41—

# FourWing 0 inputs

Four-wing attractor (a first as a synth block): integrates x' = a*x + y*z, y' = b*x + c*y - x*z, z' = -z - x*y, a system whose trajectory visits FOUR separate wings instead of the usual two, wandering chaotically between all four quadrants in a butterfly with double the lobes. It free-runs at Rate, outputting x as a smooth bipolar CV that jumps unpredictably between the four wings. A four-lobed chaos distinct from the two-winged Lorenz, Chen and Lu attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottB 0 inputs

Sprott-B attractor (a first as a synth block): integrates x' = y*z, y' = x - y, z' = 1 - x*y, one of the algebraically SIMPLEST possible chaotic systems - J.C. Sprott found, by computer search, the minimal sets of terms that still produce chaos, and this is among them. Despite having only five terms it folds a genuine strange attractor. It free-runs at Rate, outputting x as a smooth bipolar CV. A minimal-form chaos distinct from the larger Lorenz and Chen systems. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottC 0 inputs

Sprott-C attractor (a first as a synth block): integrates x' = y*z, y' = x - y, z' = 1 - x^2, a sibling of the Sprott-B system with the cross-term x*y swapped for the square x^2 - another of Sprott's minimal five-term chaotic flows. The small change reshapes the attractor into its own distinct double-lobed fold. It free-runs at Rate, outputting x as a smooth bipolar CV. A minimal quadratic chaos distinct from Sprott-B and the classical attractors. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottE 0 inputs

Sprott-E attractor (a first as a synth block): integrates x' = y*z, y' = x^2 - y, z' = 1 - 4x, another of Sprott's algebraically-minimal chaotic systems, with a square nonlinearity in the y equation and a linear ramp in z. Its orbit winds through a compact, tightly-folded strange attractor. It free-runs at Rate, outputting x as a smooth bipolar CV. A minimal-form chaos distinct from the Sprott-B and Sprott-C variants. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# SprottG 0 inputs

Sprott-G attractor (a first as a synth block): integrates x' = 0.4x + z, y' = xz - y, z' = -x + y, a minimal chaotic flow with a small linear self-feedback that lets it spiral outward before the nonlinear term folds it back. Its attractor is a delicate scrolled spiral. It free-runs at Rate, outputting x as a smooth bipolar CV that winds and folds. A spiral minimal chaos distinct from the other Sprott systems. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Bouali 0 inputs

Bouali attractor (a first as a synth block): integrates a three-variable system devised to model fluctuating economic and predator-prey-like quantities - x' = x(4 - y) + 0.3z, y' = -y(1 - x^2), z' = -x(1.5 - 0.05z) - 0.05z - whose trajectory winds onto a broad, layered, sheet-like strange attractor. It free-runs at Rate, outputting x as a smooth bipolar CV with a strong slow sway under faster folds. A sheet-like chaos distinct from the scroll attractors. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Hopalong 0 inputs

Hopalong-map source (a first as a synth block): iterates Barry Martin's 'hopalong' map x <- y - sign(x)*sqrt(|x|), y <- A - x, which hurls the orbit back and forth across the origin, the point hopping along an intricate web of nested arcs and swirls. The square-root fold keeps it from running away while letting it explore a wide, lacy attractor. It free-runs at Rate, stepping the map and outputting x as a bipolar CV that leaps across the figure. An orbital, root-folded chaos distinct from the trigonometric and polynomial maps.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Bedhead 0 inputs

Bedhead-map source (a first as a synth block): iterates the trigonometric map x <- sin(x*y/b)*y + cos(a*x - y), y <- x + sin(y)/b, one of the 'bedhead' attractors whose orbit tangles into a soft, hair-like snarl of overlapping loops. The product term x*y inside the sine couples the two coordinates nonlinearly, giving a dense, organic, woven motion. It free-runs at Rate, outputting x as a bipolar CV. A coupled-trig chaos distinct from the additive De Jong and Clifford maps.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# FractalDream 0 inputs

Fractal-dream-map source (a first as a synth block): iterates Clifford Pickover's 'fractal dream' map x <- sin(B*y) + C*sin(B*x), y <- sin(A*x) + D*sin(A*y), a four-term sine system whose orbit settles into soft, dreamlike clouds of nested filaments. It free-runs at Rate, stepping the map and outputting x as a smooth bipolar CV that drifts through the dream. A four-sine attractor distinct from the De Jong and Svensson maps. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Martin 0 inputs

Martin-map source (a first as a synth block): iterates the sine variant of Barry Martin's map x <- y - sin(x), y <- A - x, whose orbit hops across a broad, wavy lattice of interleaved bands rather than a compact attractor. The single sine fold gives a wide, drifting, quasi-tiled motion that roams far before folding back. It free-runs at Rate, outputting x as a bipolar CV. A wide-ranging, lattice-like chaos distinct from the compact Hopalong and the trig attractors.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Pickover 0 inputs

Pickover attractor source (a first as a synth block): iterates Clifford Pickover's 3-D map x <- sin(a*y) - z*cos(b*x), y <- z*sin(c*x) - cos(d*y), z <- sin(x), whose orbit is drawn into a delicate, three-dimensional thread-like sculpture of looping filaments. The z-coupling pulls the motion out of the plane, giving a richer wander than the 2-D maps. It free-runs at Rate, outputting x as a smooth bipolar CV. A 3-D threaded attractor distinct from the planar De Jong, Clifford and Svensson maps.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Julia 0 inputs

Julia-set source (a first as a synth block): iterates the complex map z <- z*z + c, the equation behind the Julia fractals - a point in the complex plane is squared and shifted again and again. For points inside the set it wanders forever in an intricate bounded orbit; when one escapes to infinity the source reseeds near the centre and sets off again, so the output is a restless, fractal-flavoured CV. CReal and CImag pick which Julia set (its shape and dynamics) to explore. It free-runs at Rate, outputting the real part. A complex-dynamics source unlike any real-valued chaos.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
CReal-1 – 0.5-0.8—
CImag-1 – 10.156—

# BurningShip 0 inputs

Burning-Ship source (a first as a synth block): iterates z <- (|Re z| + i|Im z|)^2 + c, the Burning Ship fractal's map, where taking the ABSOLUTE VALUE of each part before squaring breaks the usual symmetry and produces the jagged, flame-and-mast shape it is named for. The folding makes its bounded orbits sharper and more angular than a Julia set; escapes reseed near the centre. CReal and CImag pick the region. It free-runs at Rate, outputting the real part. An absolute-value complex map distinct from the Julia and Tricorn sources.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
CReal-2 – 0-1.8—
CImag-1 – 1-0.08—

# Tricorn 0 inputs

Tricorn (Mandelbar) source (a first as a synth block): iterates z <- conj(z)^2 + c, the same squaring as a Julia set but on the CONJUGATE of z (flipping the sign of its imaginary part each step). That conjugation gives the fractal a three-cornered symmetry and makes its boundary fractal in a different way, so the bounded orbits twist with a distinctive three-fold pull; escapes reseed near the centre. CReal and CImag pick the region. It free-runs at Rate, outputting the real part. A conjugate complex map distinct from the Julia and Burning Ship sources.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
CReal-1 – 0.5-0.5—
CImag-1 – 10.5—

# Phoenix 0 inputs

Phoenix-set source (a first as a synth block): iterates z <- z*z + c + p*z_prev, a complex map with MEMORY - the next value depends not only on the current z but on the PREVIOUS one too, the extra feedback that grows the curling, bird-like Phoenix fractal. That one-step memory makes its bounded orbits curl and spiral more than a plain Julia set; escapes reseed near the centre. It free-runs at Rate, outputting the real part. A memory-fed complex map distinct from the memoryless Julia, Tricorn and Burning Ship.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
CReal0 – 10.567—
P-1 – 0-0.5—

# Newton 0 inputs

Newton-fractal source (a first as a synth block): runs Newton's root-finding method on the equation z^3 = 1 in the complex plane - z <- z - (z^3 - 1)/(3 z^2) - which always homes in on one of the three cube roots of unity, but WHICH one depends with fractal sensitivity on where it starts. The source iterates until it locks onto a root, then reseeds from a fresh random point, so the output jumps between the three roots' values with a swirling transient before each lock. It free-runs at Rate, outputting the real part. A root-finding chaos distinct from the squaring fractals.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Firefly 0 inputs

Firefly-synchronisation source (a first as a synth block): models a swarm of twelve fireflies, each charging toward its flash; when one fires it nudges all the others a little closer to firing too. Through this pulse coupling they spontaneously fall into rhythm - the real mechanism behind fields of fireflies flashing in unison. The output is the swarm's phase COHERENCE (0 = scattered, 1 = all flashing together), which rises as they sync and breaks up again, breathing in and out. Couple sets how strongly each flash pulls the others. A self-organising sync source distinct from the chaos oscillators. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Couple0 – 0.40.2—

# Vicsek 0 inputs

Vicsek-flocking source (a first as a synth block): models twelve self-propelled particles on a ring, each steering its heading toward the AVERAGE direction of its neighbours plus a dash of random Noise - the minimal model of how birds flock, fish school and bacteria swarm. At low noise they all line up and move as one (high order); raise the noise past a critical point and the flock shatters into disorder. The output is the order parameter (how aligned the flock is), which hovers and flickers near the flocking transition. A collective-motion source distinct from the single-body chaos. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Noise0 – 1.50.3—

# Deffuant 0 inputs

Deffuant opinion-dynamics source (a first as a synth block): models twelve people each holding an opinion between 0 and 1; at each step two meet at random and, only if their views are already within Tolerance of each other, they compromise and move closer - if they are too far apart they simply ignore one another. This 'bounded confidence' makes the crowd settle into one consensus (narrow Tolerance gives several rival camps), occasionally shaken up when someone changes their mind. The output is the SPREAD of opinion (wide = divided, near zero = agreed), drifting as clusters form and dissolve. A social-dynamics source distinct from the physical models. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Tolerance0.05 – 0.50.3—

# Galam 0 inputs

Galam majority-rule source (a first as a synth block): models twelve people on a ring each holding a yes/no opinion; at each step a small group is picked and EVERYONE in it adopts the local MAJORITY view - the mechanism Galam used to model how rumours, fashions and political opinions sweep through a crowd toward unanimity. A trickle of independent mind-changing keeps it from freezing forever. The output is the fraction holding 'yes', which lurches toward total consensus (all-yes or all-no) and then gets knocked back. A majority-driven opinion source distinct from the pairwise Deffuant model. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Flip0 – 0.050.01—

# Schelling 0 inputs

Schelling-segregation source (a first as a synth block): models twelve agents of two kinds on a ring; an agent is content only if enough of its neighbours are of its OWN kind, and a discontented one swaps places with a random other - Schelling's Nobel-winning demonstration that even a mild preference for similar neighbours drives a population into sharply segregated blocks. A little random relocation keeps it stirring. The output is the segregation index (how clumped the two kinds are), climbing as the blocks form. A self-sorting source distinct from the opinion models. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Stir0 – 0.050.01—

# SIR 0 inputs

SIR epidemic source (a first as a synth block): integrates the textbook Susceptible-Infected-Recovered model - the equations Kermack and McKendrick wrote in 1927 that underlie every epidemic forecast. A pathogen burns through the susceptible population in a wave that peaks and fades as the recovered build up herd immunity; births slowly refill the susceptible pool and a seasonal swing in contagion keeps the waves coming. The output is the infected fraction, a rising-and-falling epidemic curve. R0 sets the basic reproduction number (how contagious), Season the seasonal swing. A disease-dynamics source distinct from the chemical and predator-prey oscillators. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 41—
R01.5 – 84—
Season0 – 0.40.15—

# SIRS 0 inputs

SIRS epidemic source (a first as a synth block): the Susceptible-Infected-Recovered-Susceptible model, where immunity WANES - the recovered slowly become susceptible again and can be reinfected, so instead of a single epidemic the disease settles into recurring waves, the dynamics behind seasonal flu and the common cold. The output is the infected fraction, oscillating endlessly as immunity builds and fades. R0 sets the contagiousness, Season the seasonal forcing. A waning-immunity epidemic distinct from the one-shot SIR. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 41—
R01.5 – 84—
Season0 – 0.40.15—

# SIS 0 inputs

SIS epidemic source (a first as a synth block): the Susceptible-Infected-Susceptible model, where there is NO immunity at all - the infected recover straight back to susceptible and can immediately catch it again, the model for diseases like the common cold or many bacterial infections that confer no lasting protection. Above its threshold the disease never dies out but stays endemic at a high steady level, breathing up and down with the seasons. The output is the infected fraction, hovering high. R0 sets the contagiousness, Season the swing. A no-immunity epidemic distinct from the SIR and SIRS. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 41—
R01.5 – 84—
Season0 – 0.40.15—

# SEIR 0 inputs

SEIR epidemic source (a first as a synth block): the Susceptible-Exposed-Infected-Recovered model, which adds a LATENT period - the newly-infected are Exposed but not yet contagious for a while before they become Infectious, the more realistic model used for measles and COVID. That incubation delay slows and stretches the epidemic wave and makes its peaks lag behind the cause. The output is the infected fraction, a delayed rising-and-falling curve. R0 sets the contagiousness, Season the seasonal swing. A latent-period epidemic distinct from the instantaneous SIR. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 41—
R01.5 – 84—
Season0 – 0.40.15—

# SEIRS 0 inputs

SEIRS epidemic source (a first as a synth block): the full Susceptible-Exposed-Infected-Recovered-Susceptible cycle, combining BOTH a latent incubation period AND waning immunity - the most complete of the classic compartment models, used for endemic seasonal diseases. The exposed delay and the loss of immunity together produce rich, sustained, sometimes multi-year oscillation cycles in the infection level. The output is the infected fraction, oscillating with a layered rhythm. R0 sets the contagiousness, Season the seasonal forcing. The full-cycle epidemic distinct from the simpler SIR, SIRS and SEIR. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 41—
R01.5 – 84—
Season0 – 0.40.15—

# ElFarol 0 inputs

El-Farol-bar source (a first as a synth block): models Brian Arthur's famous bar problem - twelve regulars each decide whether to go out, wanting to go only if the bar will NOT be too crowded. Since everyone is second-guessing everyone else, no fixed rule works, yet through trial-and-error adjustment the crowd self-organises so attendance hovers right around Capacity, never settling. The output is the attendance, fluctuating around the comfort threshold - the founding model of bounded-rationality economics and inductive reasoning. A self-defeating-prediction source distinct from the consensus-seeking opinion models. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Capacity0.3 – 0.70.6—

# Cobweb 0 inputs

Cobweb-market source (a first as a synth block): models the boom-bust price cycle of a market where producers decide TODAY'S supply based on YESTERDAY'S price - the cobweb theorem behind hog and crop cycles. High prices trigger overproduction, which crashes prices, which triggers underproduction, and so on. With a realistic exponential (Ricker) supply response the price never settles: it oscillates and, when producers over-react (high R), tips into genuine chaos. The output is the price. R sets how strongly supply reacts. A lagged-market chaos distinct from the smooth predator-prey and the logistic map. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
R2 – 3.83—

# Bass 0 inputs

Bass-diffusion source (a first as a synth block): the marketing model of how a new product spreads - a few INNOVATORS adopt on their own, then a wave of IMITATORS follows as they see others using it, giving the classic S-shaped adoption curve. Here the market saturates and resets, so the output is a repeating slow swell from zero to full adoption: a smooth, asymmetric ramp that starts slow, accelerates through the tipping point, then levels off. Innovate sets the spontaneous-adoption rate, Imitate the word-of-mouth strength. A technology-adoption curve distinct from the oscillating dynamical sources. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 504Hz
Innovate0.005 – 0.10.03—
Imitate0.1 – 0.60.4—

# Goodwin 0 inputs

Goodwin growth-cycle source (a first as a synth block): Richard Goodwin's model of the capitalist business cycle, which borrows the predator-prey equations from ecology - here EMPLOYMENT plays the prey and the WORKERS' WAGE SHARE the predator. High employment lets workers win higher wages, which squeezes profits and investment, which raises unemployment, which weakens wages, which restores profits, and round it goes. The output is the employment rate, cycling endlessly like a boom-and-bust. A class-struggle oscillation, integrated symplectically so the cycle never winds down, distinct from the biological predator-prey. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Kirman 0 inputs

Kirman-herding source (a first as a synth block): Alan Kirman's 'ants' model of why crowds and markets swing between extremes - twelve agents each hold one of two views, and at each step one agent either switches by IMITATING a random other (herding) or changes its mind spontaneously. With strong herding the population does not settle in the middle but lurches as a herd, swinging to nearly all-one-way, lingering, then stampeding to the other - the bimodal switching behind fads, bank runs and market bubbles. The output is the fraction holding one view. Herd sets the imitation strength. A herding-instability source distinct from the consensus-seeking opinion models. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 5012Hz
Herd0 – 10.4—
Spontaneous0 – 0.10.01—

# Excitable 0 inputs

Excitable-medium source (a first as a synth block): a ring of sixteen FitzHugh-Nagumo cells coupled by diffusion, the model of an excitable tissue like heart muscle or a nerve sheet. A pulse, once lit, travels around the ring re-igniting each cell as it passes - a self-sustaining wave of excitation, the same mechanism behind a heartbeat and the spiral waves of a fibrillating heart. The output is one cell's voltage, spiking each time the wave sweeps by. Drive sets the excitability. A travelling-wave source distinct from the single-cell oscillators. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—
Drive0 – 10.5—

# KuramotoRing 0 inputs

Kuramoto-ring source (a first as a synth block): sixteen phase oscillators arranged in a circle, each pulled toward the phase of its two NEIGHBOURS only (not the whole crowd as in the classic Kuramoto model). Local coupling lets waves of synchrony travel around the ring - bands of in-step oscillators sweeping past out-of-step ones, the metachronal waves seen in beating cilia and centipede legs. The output is one oscillator's value, beating as the synchrony waves roll by. Couple sets the pull toward neighbours. A spatially-coupled sync source distinct from the all-to-all chaos. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 82—
Couple0 – 20.5—

# CoupledPendula 0 inputs

Coupled-pendulum-chain source (a first as a synth block): a ring of sixteen pendulums, each linked by a spring to its neighbours - the classic lecture-hall wave machine. Give one a push and the swing travels along the chain as a wave, reflecting and interfering with itself (this is the sine-Gordon system, famous for its solitons). With almost no friction the energy sloshes around the ring forever. The output is one pendulum's swing, rising and falling as the waves pass through it. A mechanical wave source distinct from the electronic and chemical oscillators. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—
Coupling0 – 1.50.5—

# LambdaOmega 0 inputs

Lambda-omega medium source (a first as a synth block): a ring of sixteen cells each running a little rotational oscillator (the lambda-omega reaction-diffusion system, the normal form for any chemical or biological medium near the onset of oscillation), coupled by diffusion. The cells phase-lock into travelling and spiral waves - the spinning patterns of the Belousov-Zhabotinsky reaction and slime-mould aggregation. The output is one cell's concentration, oscillating as the spiral arms sweep past. A pattern-forming oscillatory medium distinct from the excitable Excitable and the single-cell oscillators. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—
Diffuse0 – 10.4—

# Toda 0 inputs

Toda-lattice source (a first as a synth block): a ring of sixteen masses joined by springs whose force grows EXPONENTIALLY with compression - the Toda lattice, one of the rare nonlinear systems that is exactly solvable and supports SOLITONS, lumps of energy that travel through the chain and pass through each other unchanged. Kick it and solitons circulate the ring forever, colliding and re-emerging. The output is one mass's momentum, kicking each time a soliton passes through. An integrable-soliton source distinct from the chaotic lattices. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Henon 2 inputs

Henon-map chaos sequencer (a first as a synth block): iterates the classic 2-D strange-attractor map x' = 1 - A*x^2 + y, y' = B*x on every rising edge of the in0 clock, outputting x as a stepped CV that hops chaotically across the attractor. At the textbook A=1.4, B=0.3 it traces the famous folded Henon curve - deterministic yet never repeating, a sharper, more angular chaos than the smooth DoublePendulum or the logistic Chaos. A rising edge on in1 reseeds to the origin.

ParamRangeDefaultUnit
A1 – 1.41.4—
B0 – 0.30.3—

# Telegraph 0 inputs

Random-telegraph-signal source (a first as a synth block): the dichotomous noise of physics - a two-level signal that flips between 0 and 1 at random (memoryless) moments, the model for a trapped electron blinking or a bistable circuit jittering. Rate sets the mean number of flips per second; because the wait between flips is exponentially distributed the result is a random square wave with no fixed period, holding each level for an unpredictable time. A genuine stochastic gate, distinct from the random-but-clocked Sample-and-Hold sources. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 504Hz

# Poisson 0 inputs

Poisson-process trigger (a first as a synth block): fires a one-sample impulse at random, memoryless moments at an average Rate of events per second - the canonical model for radioactive decay clicks, photon arrivals or raindrops. The gaps between triggers follow an exponential distribution, so the pulses are genuinely random in time yet hold a steady long-run density. Patch it to gate or trigger anything that wants un-quantised, never-repeating randomness. Distinct from a regular Clock and from the Bernoulli gate (which only thins an existing clock). Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 1008Hz

# Hawkes 0 inputs

Self-exciting (Hawkes) trigger (a first as a synth block): a point process where every event briefly RAISES the chance of another - so triggers arrive in bursts and clusters rather than evenly, the model for earthquake aftershocks, neuron avalanches and viral cascades. Rate sets the background event rate, Excite how strongly each firing kicks the intensity up, and Decay how fast that excitement fades. With low Excite it behaves like a plain Poisson source; raise it and the output clumps into flurries of activity separated by lulls. The branching is kept sub-critical so it can never run away. Needs no input.

ParamRangeDefaultUnit
Rate0.5 – 306Hz
Excite0 – 4020—
Decay5 – 50021ms

# Renewal 0 inputs

Regularised (Erlang renewal) trigger (a first as a synth block): a point process that is MORE evenly spaced than random - it fires only every Regularity-th pulse of a faster internal Poisson source, so the wait between outputs is an Erlang sum of exponentials. Rate sets the output event rate. At Regularity 1 it is plain Poisson (fully random); raise it and the triggers tighten toward a steady metronome while keeping a little jitter - the sub-Poisson, anti-clustering opposite of Hawkes. The natural model for a neuron's refractory firing or a heartbeat's near-regular rhythm. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 1008Hz
Regularity1 – 84—

# Ornstein 0 inputs

Ornstein-Uhlenbeck source (a first as a synth block): the mean-reverting random process - Brownian motion on a spring, which wanders randomly but is always pulled back toward its centre, so it drifts and meanders without ever running off the way a free random walk does. It is the standard model for a noisy voltage settling, a particle in a fluid, or an interest rate. Pull sets how strongly it springs back to centre (higher = tighter, faster wobble) and Depth the noise amount. A smooth, naturally-bounded random CV distinct from the target-hopping Drift and the free Levy flight. Needs no input.

ParamRangeDefaultUnit
Pull0 – 0.020.002—
Depth0 – 0.10.02—

# VanDerPol 0 inputs

Van-der-Pol relaxation oscillator (a first as a synth block): integrates x'' - Mu(1 - x^2)x' + x = 0, the classic self-sustaining oscillator from early radio valves and the heartbeat. Unlike a sine it has nonlinear damping that pumps energy in when the swing is small and bleeds it off when large, so it settles into a fixed-amplitude limit cycle. At low Mu it is nearly sinusoidal; raise Mu and it snaps into a sharp relaxation wave - slow charge, sudden flip - the sawtooth-like pulse of a blinking neon or a firing neuron. Rate sets the speed. A self-stabilising oscillator distinct from the chaotic attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—
Mu0.5 – 52—

# FitzHughNagumo 0 inputs

FitzHugh-Nagumo neuron (a first as a synth block): integrates the two-variable simplification of the Hodgkin-Huxley nerve-impulse equations, v' = v - v^3/3 - w + Drive, w' = 0.08(v + 0.7 - 0.8w). It is the textbook EXCITABLE system: a fast voltage v that fires and a slow recovery w that resets it. With enough Drive it spikes over and over - a sharp upstroke, a refractory dip, a slow recharge - the canonical shape of a firing neuron. Rate sets the speed, Drive the injected current (turn it up to cross from silent into repetitive spiking). A spiking oscillator distinct from the smooth chaos sources.

ParamRangeDefaultUnit
Rate0.05 – 41—
Drive0 – 10.5—

# HindmarshRose 0 inputs

Hindmarsh-Rose bursting neuron (a first as a synth block): integrates a three-variable neuron model with a slow adaptation current that makes it BURST - it fires a rapid cluster of spikes, then falls quiet while the slow variable recovers, then bursts again, often chaotically so no two bursts match. This spike-then-rest-then-spike rhythm is exactly how many real neurons fire. The output is the membrane voltage: fast spiking riding on a slow up-and-down envelope. Rate sets the speed. A bursting chaos distinct from the steady spiking of FitzHugh-Nagumo and the smooth attractors.

ParamRangeDefaultUnit
Rate0.05 – 41—

# WilsonCowan 0 inputs

Wilson-Cowan neural-mass oscillator (a first as a synth block): models a whole population of brain cells, not one neuron - a pool of excitatory cells E that drives itself and an inhibitory pool I that reins it back, each passed through a sigmoid firing curve. The push-pull between excitation and delayed inhibition makes the population activity oscillate, the mechanism behind brain rhythms like the alpha and gamma waves on an EEG. The output is the excitatory activity, a smooth 0..1 rhythmic swell. Rate sets the speed and Drive the background input. A network-level oscillation distinct from the single-cell neuron models.

ParamRangeDefaultUnit
Rate0.05 – 41—
Drive0 – 1.50.5—

# Rulkov 0 inputs

Rulkov-map neuron (a first as a synth block): a two-variable MAP (not a differential equation) that reproduces neuron spiking and bursting with just x' = Alpha/(1 + x^2) + y and a slow y - prized because it captures the rich firing of a real cell at a fraction of the cost. A fast x that spikes sits on a slow y that drifts it in and out of bursting, so raising Alpha moves it from silence through tonic spikes into chaotic bursts. It free-runs at Rate, stepping the map and outputting x as a bipolar CV. A discrete-map neuron distinct from the integrated Hindmarsh-Rose and FitzHugh-Nagumo models.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Alpha4 – 4.64.3—

# LotkaVolterra 0 inputs

Lotka-Volterra predator-prey oscillator (a first as a synth block): the founding equations of mathematical ecology - prey x breed freely but are eaten by predators y, whose numbers in turn rise and fall on the food supply. The two populations chase each other in a perpetual cycle: prey boom, predators follow and crash them, then starve and let the prey boom again. Rate sets the speed and Growth the prey's breeding rate. The output is the prey population as a smooth 0..1 swell, integrated symplectically so the cycle never winds down. An ecological oscillation distinct from the neuron and chaos sources.

ParamRangeDefaultUnit
Rate0.05 – 41—
Growth0.5 – 21.1—

# Brusselator 0 inputs

Brusselator chemical oscillator (a first as a synth block): the textbook model of an autocatalytic chemical clock, where a reactant feeds a loop that periodically builds up and consumes an intermediate, so the concentration pulses up and down on its own - the kind of self-organising rhythm seen in real oscillating reactions. Above the critical feed it locks into a stable limit cycle. Rate sets the speed and B the feed parameter (raise it past 2 to start the oscillation). The output is the concentration x. A chemistry-born oscillation distinct from the biological and chaotic sources.

ParamRangeDefaultUnit
Rate0.05 – 41—
B2 – 43—

# Selkov 0 inputs

Sel'kov glycolytic oscillator (a first as a synth block): the model of glycolysis - the pathway cells use to burn sugar - which does not proceed steadily but PULSES, the concentration of an intermediate rising and falling in a self-sustained rhythm (the glycolytic oscillations seen in yeast extract). Rate sets the speed and Feed the substrate supply. The output is the oscillating concentration. A metabolic oscillation distinct from the Brusselator chemistry and the neuron models.

ParamRangeDefaultUnit
Rate0.05 – 41—
Feed0.4 – 0.80.6—

# Repressilator 0 inputs

Repressilator gene oscillator (a first as a synth block): the first synthetic gene circuit built to oscillate - three genes wired in a ring where each represses the next (A silences B, B silences C, C silences A), so no state is stable and the three protein levels cycle round in turn, a genetic clock engineered into living bacteria. Rate sets the speed and Strength the repression (raise it to deepen the swing). The output is the first protein's level. A synthetic-biology oscillation distinct from the metabolic and neural models.

ParamRangeDefaultUnit
Rate0.05 – 41—
Strength4 – 1610—

# Lengyel 0 inputs

Lengyel-Epstein chemical oscillator (a first as a synth block): the model of the CIMA reaction (chlorine-dioxide / iodine / malonic-acid), the experiment that first produced stationary Turing patterns in a real chemical and which, well stirred, oscillates in time instead. Two coupled concentrations chase each other into a stable limit cycle. Rate sets the speed and Feed the reactant supply. The output is the activator concentration. A pattern-forming chemistry distinct from the Brusselator and the biological oscillators.

ParamRangeDefaultUnit
Rate0.05 – 41—
Feed8 – 1410—

# Perlin 0 inputs

Perlin-noise source (a first as a synth block): smooth coherent gradient noise - the organic, flowing randomness used to generate natural terrain, clouds and fire in computer graphics. Unlike white noise or a sample-and-hold (which jump instantly), Perlin noise glides: nearby moments are always close in value, so the output meanders gently and naturally with no abrupt steps, set by a quintic-smoothed lattice of random gradients. Rate sets how fast it drifts through the noise field. The natural-movement modulator, distinct from the white/pink NoiseLFO and the stepped Random.

ParamRangeDefaultUnit
Rate0.05 – 201Hz

# fBm 0 inputs

Fractal-Brownian-motion source (a first as a synth block): stacks several octaves of Perlin noise - each one twice as fast and half as loud as the last - into the rich, self-similar randomness of natural terrain, coastlines and mountain skylines. The low octaves give the slow overall drift while the high ones add fine detail, so the motion is organic at every timescale at once. Rate sets the base speed and Octaves how many layers (more = finer, rougher detail). A multi-scale coherent-noise modulator distinct from the single-octave Perlin. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 201Hz
Octaves1 – 64—

# Ridged 0 inputs

Ridged-multifractal source (a first as a synth block): a fractal noise that takes each octave's absolute value and inverts it (1 - |noise|), so the smooth valleys of fBm become sharp upward RIDGES - the technique that carves mountain crests, canyon walls and lightning veins in procedural terrain. The output rides high and crinkles into sudden creases instead of rolling smoothly. Rate sets the base speed and Octaves the detail. A ridged, peaky coherent-noise modulator distinct from the rounded fBm and Billow. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 201Hz
Octaves1 – 64—

# Billow 0 inputs

Billow-noise source (a first as a synth block): a fractal noise that takes the absolute value of each octave (2|noise| - 1), turning the gentle zero-crossings of fBm into rounded, puffy lobes - the look of cumulus clouds, rolling smoke and bubbling foam in procedural textures. The output swells up in soft billows with creased troughs where it folds back on itself, the rounded opposite of the sharp Ridged. Rate sets the base speed and Octaves the detail. A billowy coherent-noise modulator distinct from fBm and Ridged. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 201Hz
Octaves1 – 64—

# Worley 0 inputs

Worley (cellular) noise source (a first as a synth block): scatters random feature points along the timeline and outputs the distance from the moving read-head to the NEAREST one - the cellular/Voronoi noise behind stone, scales, cracked mud and water-caustic textures. The value falls to zero each time the read-head passes a feature point and swells up in the gaps between them, giving a bumpy, organic ramp-and-dip motion quite unlike the smooth hills of Perlin. Rate sets how fast it travels between cells. A cellular coherent-noise modulator distinct from the gradient-noise family. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 201Hz

# Ehrenfest 0 inputs

Ehrenfest-urn source (a first as a synth block): the textbook model of diffusion and the arrow of time - Balls are split between two boxes and at each step ONE random ball is moved to the other box. Whichever box has more balls is more likely to lose one, so the split is gently pulled back toward 50/50 and then jiggles around it forever. The output is the fraction in one box: a mean-reverting random wander that, unlike a free random walk, never strays far - a statistical-mechanics restoring force rather than the spring of Ornstein-Uhlenbeck. Rate sets the step speed. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Balls8 – 12832—

# PolyaUrn 0 inputs

Polya-urn source (a first as a synth block): the canonical 'rich get richer' process - an urn holds red and black balls; draw one at random, then put it back ALONG WITH another of the same colour, so every draw makes that colour likelier still. The proportion drifts and then locks onto a random value that is different every run (the path-dependent limit). Here the urn is periodically emptied and reseeded, so the output settles to one plateau, holds, then jumps and settles on a fresh one - a self-reinforcing sample-and-hold quite unlike uniform randomness. Rate sets the draw speed. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz

# Moran 0 inputs

Moran-process source (a first as a synth block): the model of random genetic drift in a fixed population - Balls individuals are each one of two types; at every step one is chosen to reproduce and one (at random) dies, so the share of each type wanders purely by chance. A trickle of Mutation flips the occasional offspring, which keeps the share from ever getting permanently stuck at all-one-type. The output is that share: an unbiased random walk on a population, the discrete cousin of neutral evolution. Rate sets the generation speed. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Balls8 – 12832—
Mutation0 – 0.20.05—

# GamblersRuin 0 inputs

Gambler's-ruin source (a first as a synth block): a fortune that takes a coin-flip step up or down each turn between two walls - bankruptcy at the bottom, the jackpot at the top. The path is a pure random walk, but the moment it touches either wall the game restarts from the middle, so the output is a stream of random excursions: long meandering climbs and slides that always end in a sudden reset to centre. Rate sets the bet speed and Wall the playing-field size (wider walls = longer, rarer excursions). An absorbing-barrier walk distinct from the mean-reverting urns. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Wall8 – 12832—

# BirthDeath 0 inputs

Birth-death (queue) source (a first as a synth block): a population (or a queue of waiting jobs) where new arrivals appear at a steady Birth rate while each member already present has a Death chance of leaving, so the more there are the faster they go - a self-limiting balance that settles around Birth/Death. The output is the population, an ASYMMETRIC mean-reverting wander: it drifts up on a run of arrivals then thins out faster the higher it climbs, the Poisson-occupancy shape of a busy queue. Distinct from the symmetric Ehrenfest diffusion. Rate sets the event speed. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Birth1 – 104—
Death0.1 – 20.5—

# Rose 0 inputs

Rose-curve (rhodonea) LFO (a first as a synth block): traces the petal curve r = cos(Petals * angle) and outputs its horizontal sweep, a smooth modulation whose single cycle folds into a rosette of Petals lobes. The result is a repeating shape far richer than a sine - a flower of evenly-spaced swells and dips - whose symmetry is set directly by the petal count. Rate sets the speed. A geometric multi-lobe LFO distinct from the sine, ramp and random sources.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Petals2 – 125—

# Spirograph 0 inputs

Spirograph (hypotrochoid) LFO (a first as a synth block): traces the looping curve a small circle draws as it rolls inside a larger one - the toy-spirograph pattern - and outputs its sweep, the sum of two circular motions whose speeds are set by Ratio. The result is an epicyclic LFO with a fast inner wobble riding on a slow outer swing, Depth balancing the two. A geometric two-rate modulation distinct from a plain sine or a synced pair. Rate sets the speed.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Ratio2 – 93—
Depth0 – 10.6—

# Epicycloid 0 inputs

Epicycloid LFO (a first as a synth block): traces the curve a point on a small circle draws as it rolls around the OUTSIDE of a larger one - the path of a planet in a geocentric sky - and outputs its sweep. With Cusps points it forms a star-like loop of sharp, evenly-spaced cusps, so the LFO sweeps smoothly then snaps at each cusp, a spiky repeating contour. Rate sets the speed. A rolling-circle modulation distinct from the inner-rolling Spirograph.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Cusps2 – 104—

# Harmonograph 0 inputs

Harmonograph LFO (a first as a synth block): models the Victorian drawing machine where two pendulums swinging at slightly-detuned frequencies trace a slowly-evolving figure. It sums two sinusoids at the FreqA and FreqB harmonics with a tiny detuning, so the shape drifts and precesses cycle after cycle, never quite repeating - an organic, breathing modulation rather than a fixed loop. Rate sets the base speed, FreqA and FreqB the two pendulum rates. A quasi-periodic curve distinct from the exactly-repeating Rose and Spirograph.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
FreqA1 – 62—
FreqB1 – 63—

# Lissajous 0 inputs

Lissajous LFO (a first as a synth block): multiplies two sinusoids whose frequencies are in the ratio RatioX:RatioY - the pair that, plotted against each other, trace the classic Lissajous figures on an oscilloscope. The product is a complex, symmetric modulation that beats and nulls as the two rates cross, its character set entirely by the integer ratio. Simple ratios give clean repeating shapes, larger ones dense interference. Rate sets the speed. A two-tone interference LFO distinct from the rolling-circle curves.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
RatioX1 – 83—
RatioY1 – 82—

# Cardioid 0 inputs

Cardioid LFO (a first as a synth block): traces the heart-shaped curve r = 1 - cos(angle) and outputs its horizontal sweep, a strongly ASYMMETRIC modulation - a slow, lingering dwell near one extreme and a quick sweep through the other, the single-cusped 'heart' contour. Its lopsided shape makes it good for envelope-like swells that rise gently and fall fast (or vice versa). Rate sets the speed. A heart-curve LFO distinct from the symmetric sine and the multi-lobe Rose.

ParamRangeDefaultUnit
Rate0.01 – 201Hz

# Lemniscate 0 inputs

Lemniscate LFO (a first as a synth block): traces the figure-eight curve of Bernoulli (r-squared = cos(2*angle)) and outputs its sweep, which produces TWO smooth pulses per cycle separated by flat dead zones where the curve pinches to nothing at the crossing point. The result is a paired-pulse modulation - two lobes of motion, then rest, then two more - quite unlike a single sine swing. Rate sets the speed. A figure-eight LFO distinct from the single-loop curves.

ParamRangeDefaultUnit
Rate0.01 – 201Hz

# Astroid 0 inputs

Astroid LFO (a first as a synth block): traces the four-cusped star curve x = cos-cubed(angle) and outputs it directly - a cosine with FLATTENED peaks and steepened zero-crossings, so it lingers at the extremes and snaps quickly through the middle, the inverse of a sine's rounded shape. A gentle, plateau-topped modulation good for slow holds with fast transitions. Rate sets the speed. A cubed-cosine star curve distinct from the sine and triangle shapes.

ParamRangeDefaultUnit
Rate0.01 – 201Hz

# Deltoid 0 inputs

Deltoid LFO (a first as a synth block): traces the three-cusped hypocycloid (a circle rolling inside one three times its size), outputting (2*cos(angle) + cos(2*angle)) / 3 - a smooth modulation with a strong main swell and a smaller secondary bump, the triangular cousin of the astroid. Its three-fold asymmetry gives a lopsided, gently galloping motion. Rate sets the speed. A three-cusp curve distinct from the four-cusp astroid and the rolling-circle epicycloid.

ParamRangeDefaultUnit
Rate0.01 – 201Hz

# Superformula 0 inputs

Superformula LFO (a first as a synth block): Johan Gielis's single equation that draws a vast family of natural shapes - circles, polygons, stars, flowers, leaves - from just two knobs, by setting the radius from |cos(Sym*t/4)| and |sin(Sym*t/4)| raised to a power. Symmetry sets how many lobes (the polygon/star order) and Shape how sharp or rounded they are, so sweeping them MORPHS the LFO contour continuously from a smooth blob to a spiky star. The most shape-versatile single LFO, distinct from every fixed-curve source. Rate sets the speed.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Symmetry2 – 126—
Shape0.3 – 31—

# Rossler 0 inputs

Rossler-attractor chaos source (a first as a synth block): integrates the three Rossler equations dx=-y-z, dy=x+a*y, dz=b+z*(x-c) - a smooth deterministic-chaos system that traces a spiralling band with an occasional fold. The output is x as a slowly wandering CV: gentler and more periodic-looking than Lorenz, with long quasi-cycles broken by sudden excursions. Rate sets the integration speed. A continuous chaos with a different character from the angular Henon or the tumbling DoublePendulum; needs no input.

ParamRangeDefaultUnit
Rate0.05 – 41—

# Kuramoto 0 inputs

Kuramoto synchronisation source (a first as a synth block): eight phase oscillators, each at its own natural frequency, are nudged toward each other by Coupling - the model of how fireflies, neurons and metronomes spontaneously fall into step. The output is their combined mean field: with low Coupling the eight detuned waves smear into a restless wobble, and as Coupling rises they lock into one coherent oscillation that swells in amplitude. Rate sets the centre frequency and Spread the detuning. A self-organising motion no LFO or noise source produces. Needs no input.

ParamRangeDefaultUnit
Rate0.05 – 81Hz
Spread0 – 10.3—
Coupling0 – 41—

# Orbit 0 inputs

Kepler-orbit LFO (a first as a synth block): a body sweeps an elliptical orbit under gravity, so unlike a sine it lingers slowly at the far point (aphelion) then whips quickly through the near point (perihelion) - the asymmetric speed of a real planet, set by Eccentricity. It solves Kepler's equation each sample for the eccentric anomaly and outputs its cosine. At zero eccentricity it is a pure cosine; cranked up it becomes a lopsided swing that hangs and then lunges. Rate sets the orbital period. A gravitationally-shaped modulation curve, needs no input.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
Eccentricity0 – 0.90.5—

# Ising 0 inputs

Ising-model magnetisation source (a first as a synth block): a 4x4 lattice of up/down spins evolves by the Metropolis rule - a spin flips if it lowers the energy, or randomly with a chance set by Temperature - the textbook model of a magnet. The output is the net magnetisation: cold, the spins align into one domain and it drifts toward +/-1; hot, they tumble and it jitters around zero; near the critical temperature it swings in large, slow, self-similar fluctuations. A statistical-physics modulation source. Needs no input.

ParamRangeDefaultUnit
Temperature0.1 – 52.27—

# ForestFire 0 inputs

Forest-fire CA (a first as a synth block): a 4x4 grid of cells that are empty, growing a tree, or burning. Each sample a tree sprouts on an empty cell with chance Growth, a stray tree catches fire by Lightning, and fire spreads to neighbouring trees then burns out - the Drossel-Schwabl model of self-organised criticality. The output is the burning density: quiet while the forest regrows, then sudden sweeping fire-fronts, with the avalanche statistics of real wildfires. A different criticality than the Sandpile. Needs no input.

ParamRangeDefaultUnit
Growth0 – 0.050.01—
Lightning0 – 0.010.001—

# Levy 0 inputs

Levy-flight modulation source (a first as a synth block): a random walk whose step sizes are drawn from a heavy-tailed (Cauchy) distribution, so it mostly creeps in tiny steps but every so often makes a sudden enormous leap across the range - the foraging pattern of albatrosses and the maths of anomalous diffusion. Step sets the typical jump scale and Rate how often it moves; the walk reflects off +/-1 to stay in range. Where a smoothed-noise LFO wanders gently, Levy lurks then pounces - clustered stillness punctuated by leaps. Needs no input.

ParamRangeDefaultUnit
Step0.001 – 0.20.02—
Rate0 – 10.5—

# NBody 0 inputs

Gravitational N-body source (a first as a synth block): three point masses pull on one another by Newton's inverse-square law inside a box with reflecting walls, tracing the famously unsolvable three-body motion - bodies swing past, sling-shot and tumble in an endless gravitational dance. Gravity sets the attraction strength and Rate the simulation speed; the output follows the first body's horizontal position. A softened-gravity, wall-bounded chaos with its own swooping character, distinct from the pendulum or the strange-attractor maps. Needs no input.

ParamRangeDefaultUnit
Gravity0.05 – 20.5—
Rate0.05 – 41—

# Voter 0 inputs

Voter-model consensus source (a first as a synth block): a 4x4 grid of cells each holding one of two opinions; each step a random cell simply copies a random neighbour, the simplest model of imitation, gossip and herd behaviour. Domains coarsen and fight along their borders until - on a finite grid - one opinion wins and the whole field falls into consensus, at which point it freezes. The output is the net opinion, a CV that wanders then locks. Unlike the Ising model there is no temperature, only blind copying. Needs no input.

ParamRangeDefaultUnit
Rate1 – 84—

# RandomWalk 0 inputs

Random-walk source (a first as a synth block): the classic drunkard's walk - each step nudges the value by a random amount, so it wanders with no memory of where it has been, the very model of Brownian diffusion. It free-runs at Rate; reflecting walls at the rails keep it bouncing inside the range forever. Step sets how far each move can carry it. A memoryless diffusion distinct from the mean-pulled Ornstein-Uhlenbeck and the heavy-tailed Levy flight. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 508Hz
Step0 – 10.1—

# OrnsteinUhlenbeck 0 inputs

Ornstein-Uhlenbeck source (a first as a synth block): a random walk on an elastic leash - noise kicks it around but a restoring pull always drags it back toward the centre, the textbook mean-reverting process used to model everything from particle velocities to interest rates. The result is smooth, organic, band-limited drift (Brownian motion's well-behaved cousin) with no sharp jumps. Revert sets the strength of the pull, Sigma the noise. A mean-reverting drift distinct from the free random walk. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 20030Hz
Revert0 – 10.05—
Sigma0 – 10.12—

# LevyFlight 0 inputs

Levy-flight source (a first as a synth block): a random walk whose step sizes are drawn from a heavy-tailed Cauchy distribution, so most moves are tiny but every so often it takes a wild, far-reaching leap - the search pattern of foraging animals and the signature of anomalous, super-diffusive transport. The value mostly hovers, then teleports across the range and resumes. Jump scales the leaps; the rails wrap so a big jump reappears on the far side. A heavy-tailed flight distinct from the Gaussian random walk. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 506Hz
Jump0 – 0.20.02—

# TelegraphProcess 0 inputs

Random-telegraph source (a first as a synth block): a two-state signal that sits at one rail and then randomly flips to the other, the dichotomous noise that models a flickering switch, burst noise in electronics, and ion channels snapping open and shut. The hold times are exponentially distributed, so it is a stepped square wave with utterly unpredictable timing. Switch sets the flip probability per step (the average rate of jumps). A two-level jump process distinct from the continuous random walks. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 20040Hz
Switch0 – 10.05—

# BrownianBridge 0 inputs

Brownian-bridge source (a first as a synth block): a random walk that is tied down at both ends - it wanders freely in the middle but is mathematically guaranteed to arrive back at zero exactly at the end of each cycle, then starts a fresh bridge. This is the conditioned Brownian motion used to interpolate between fixed points and to model paths with a known destination. Length sets the cycle in steps. A pinned, self-resetting drift distinct from the open random walk. Needs no input.

ParamRangeDefaultUnit
Rate0.1 – 20040Hz
Length4 – 25664—

# CML 0 inputs

Coupled-map-lattice source (a first as a synth block): eight logistic maps sit in a ring, each iterating its own chaos while a Coupling term shares a fraction of each cell with its neighbours. The competition between local chaos and diffusive smoothing produces spatiotemporal chaos - travelling fronts, frozen-random patches and turbulent bursts that no single attractor shows. The output is the lattice average, a richly textured wandering CV. R sets each map's chaos and Coupling the diffusion. A whole field of coupled chaos rather than one oscillator. Needs no input.

ParamRangeDefaultUnit
R3.6 – 43.9—
Coupling0 – 0.50.1—

# Dimension 1 input

Dimension-D-style BBD chorus: a slow ~0.5 Hz LFO modulates a short delay around 8 ms, with the right channel running anti-phase, and the wet copy is blended with the dry at a fixed ratio. Depth scales how far the delay time is swept. Out picks L or R for the per-channel modulation phase, giving the lush stereo movement of the classic unit rather than a deep vibrato.

ParamRangeDefaultUnit
Depth0 – 10.5—
Out0 – 10—

# Gater 1 input

Step-sequenced tremolo gate that reads a per-step on/off pattern from a 16-bit mask, advancing through the steps on a sample-clock phase for tempo coherence. Rate sets the cycle frequency, Pattern is the bitmask of active steps, Steps sets how many steps are used, and Smooth softens the transitions between open and closed. Mix sets how deeply the gate cuts the signal, from subtle pulsing to full rhythmic chopping.

ParamRangeDefaultUnit
Rate0.25 – 82Hz
Pattern0 – 6553543690—
Steps1 – 168—
Smooth0 – 10.3—
Mix0 – 11—

# Undulator 1 input

Modulated short delay combined with an envelope swell and a tremolo running at twice the LFO rate for H3000-style undulation. Rate sets the LFO speed, Depth sets how far the delay time is swept for pitch-wobble and chorus, and Swell controls the tremolo depth driven from a slow input follower. Mix blends the moving, detuned voice against the dry signal for shimmering, breathing modulation.

ParamRangeDefaultUnit
Rate0.05 – 50.5Hz
Depth0 – 10.5—
Swell0 – 10.5—
Mix0 – 10.5—

# SideLFO 1 input

Sidechain-curve mod source: outputs the classic pump/duck envelope as a control signal (no audio through-path) so one ducking shape drives many destinations - patch it into a Mixer level, a reverb/delay send or a filter cutoff to sidechain them all to the same beat without a key signal. Rate sets the duck cycle in Hz (modulate or tempo-sync it to the kick), Depth how far the curve dips, Curve shapes the recovery ramp from snappy to gradual, and Bias offsets the output centre. Shares the Pump curve, exposed as CV instead of an inline gain. A trigger into in0 resets the duck cycle (sync it to the kick); unpatched = free-run.

ParamRangeDefaultUnit
Rate0.1 – 82Hz
Depth0 – 10.8—
Curve0.2 – 41.5—
Bias0 – 10—

# Generative 1 input

Probabilistic melodic random walk synced to a rate.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Range1 – 123st
Low0 – 12748—
High0 – 12772—
Probability0 – 10.7—

# MidiLFO 1 input

Low-frequency modulation source (sine/tri/saw/square) on the scalar control output.

ParamRangeDefaultUnit
Rate0.01 – 201Hz
ShapeSine · Triangle · Saw · Square—
Depth0 – 11—

# MidiEnv 1 input

ADSR envelope triggered by the note gate, on the scalar control output.

ParamRangeDefaultUnit
Attack1 – 50005ms
Decay1 – 5000200ms
Sustain0 – 10.7—
Release1 – 5000300ms

# MidiRandom 1 input

Generates random notes within a pitch range at a synced rate.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Low Note0 – 12748—
High Note0 – 12772—
Gate0 – 20.5—
Velocity1 – 127100—

# MidiSampleHold 1 input

Samples and holds the incoming control value on each note.

# MidiSlew 1 input

Smooths (glides) the control value over a set time.

ParamRangeDefaultUnit
Time0 – 2000100ms

# RandOctave 1 input

Randomly shifts notes by up to +/- Range octaves with a chance.

ParamRangeDefaultUnit
Range1 – 31—
Chance0 – 11—

# CCLFO 1 input

Continuous CC LFO generator (sine/triangle/saw/square) emitted on a chosen CC at a free Rate - automates a synth parameter over MIDI, where MidiLFO drives only the internal mod-matrix scalar.

ParamRangeDefaultUnit
CC0 – 1271—
Rate0.01 – 201Hz
ShapeSine · Triangle · Saw · Square—
Depth0 – 11—

# CCSeq 1 input

Tempo-synced step CC sequencer: one CC value per synced step cycling an 8-step shape (overridable via the node's config list) - a modulation sequencer in the CC domain, where StepSeqMidi sequences notes.

ParamRangeDefaultUnit
CC0 – 1271—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—

# VelToCC 1 input

Turns each note's velocity into a CC value emitted just before the note, so a synth's filter or level opens with how hard you played - dynamics routed to expression, where Note2CC sends pitch.

ParamRangeDefaultUnit
CC0 – 12711—

# CCGlide 1 input

Portamento for a CC: smooths the watched CC toward each newly received value over Time, emitting interpolated CC each block - de-zippers a stepped controller, where MidiSlew only glides the internal scalar.

ParamRangeDefaultUnit
CC0 – 1271—
Time1 – 2000120ms

# PressSwell 1 input

Generates a channel-pressure (aftertouch) swell that rises to Max over Rise while any note is held, snapping back to zero on release - an automatic crescendo for pads and strings, where ATProc only transforms incoming aftertouch.

ParamRangeDefaultUnit
Rise1 – 5000800ms
Max0 – 11—

# PitchDrift 1 input

Nudges each note's pitch by a small random detune up to +/-Cents (per-note, polyphonic) - the gentle oscillator instability of analog gear, applied to pitch where Humanize only scatters timing and velocity.

ParamRangeDefaultUnit
Cents0 – 508c

# MicrotuneSpread 1 input

Microtune spread: gives every note a small random pitch detune up to +/-Cents via its microtuning offset, loosening rigid tuning into a chorused, slightly-out ensemble shimmer.

ParamRangeDefaultUnit
Cents0 – 5010c

# QuarterToneShift 1 input

Quarter-tone shift: detunes every note by up to a quarter-tone via its microtuning offset, sliding the whole performance off the 12-tone grid into 24-tone territory without changing the note numbers.

ParamRangeDefaultUnit
Amount-1 – 10.5—

# VelToDetune 1 input

Velocity-to-detune: maps how hard each note is played to a microtuning detune, so dynamics bend pitch slightly sharp or flat - the pitch-pulls-with-force behaviour of acoustic instruments and analog drift.

ParamRangeDefaultUnit
Cents-50 – 5015c

# GamelanDetune 1 input

Gamelan detune: tunes alternate keys slightly apart so paired notes shimmer with the slow acoustic beating of a gamelan's deliberately-mistuned instrument pairs (ombak) - an ensemble-wide chorused waver.

ParamRangeDefaultUnit
Cents0 – 5015c

# GoldenAngleDetune 1 input

Golden-angle detune: scatters each successive note's microtuning by the golden angle, the maximally-even irrational spacing, so repeated notes never land on the same detune - an organic, never-repeating pitch shimmer.

ParamRangeDefaultUnit
Cents0 – 5012c

# StretchTuning 1 input

Stretch tuning: applies a Railsback-style octave stretch, tuning notes progressively sharp as they rise and flat as they fall, the psychoacoustic tuning real pianos use so octaves sound in tune to the ear.

ParamRangeDefaultUnit
Cents-30 – 308c

# NEdoRetune 1 input

N-EDO retune: detunes every note from 12-tone equal temperament to the nearest step of an N-equal-divisions-of-the-octave scale, opening up 19, 24, 31 or any microtonal grid without changing the played note numbers.

ParamRangeDefaultUnit
Divisions5 – 5319—

# HarmonicSeriesSnap 1 input

Harmonic-series snap: detunes each note to the nearest member of the natural harmonic series above a root, replacing tempered intervals with the pure, beatless ratios of just intonation as a brass or didgeridoo would sound them.

ParamRangeDefaultUnit
Root0 – 6024—

# WerckmeisterTune 1 input

Werckmeister tune: retunes to Werckmeister III, the famous 1691 well-temperament whose unequal fifths give each key its own colour (the 'well-tempered' tuning of Bach's era) - subtle, key-dependent detuning from equal temperament.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# PythagoreanTune 1 input

Pythagorean tune: retunes to 3-limit Pythagorean intonation built from a spiral of pure fifths, giving brilliant, wide major thirds and the bright, slightly-sharp leading tones of medieval and string-ensemble tuning.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# BohlenPierceTune 1 input

Bohlen-Pierce tune: retunes the keyboard to the Bohlen-Pierce scale, which divides not the octave but the 3:1 'tritave' into 13 equal steps, giving an alien but surprisingly consonant tuning built on odd-harmonic ratios.

ParamRangeDefaultUnit
Root0 – 12760—

# CarlosAlphaTune 1 input

Carlos Alpha tune: retunes to Wendy Carlos's Alpha scale of 78-cent equal steps, a non-octave temperament engineered to nail pure major thirds and fifths at the cost of ever repeating at the octave - a shimmering, otherworldly intonation.

ParamRangeDefaultUnit
Root0 – 12760—

# RandomCC 1 input

Random CC: fires a random value on a chosen controller number with every note-on, an instant source of evolving per-note modulation (filter, pan, anything) that never repeats; Amount sets the spread around center.

ParamRangeDefaultUnit
CC0 – 1271—
Amount0 – 10.5—

# PitchBendLFO 1 input

Pitch-bend LFO: emits a free-running pitch-bend sine that wobbles the tuning continuously whether or not notes are playing - a global vibrato/auto-bend source independent of any single note; Rate and Depth shape the sweep.

ParamRangeDefaultUnit
Rate0.05 – 124Hz
Depth0 – 10.2—

# NoteToPressure 1 input

Note-to-pressure: emits a channel-aftertouch value scaled from each note's velocity, so how hard you strike also drives any pressure-mapped destination (vibrato, filter, swell) - turning a non-aftertouch keyboard into an expressive one.

ParamRangeDefaultUnit
Amount0 – 10.7—

# SlendroTune 1 input

Slendro tune: retunes the keyboard to a Javanese gamelan slendro scale - five near-equal steps spanning the octave - giving the floating, anchorless quality of Indonesian slendro tuning, snapped from the nearest played note.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# PelogTune 1 input

Pelog tune: retunes to a Javanese pelog scale - seven unequal steps with characteristic narrow and wide intervals - the more tense, expressive counterpart to slendro in gamelan music.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# MaqamRastTune 1 input

Maqam Rast tune: retunes to the Arabic maqam Rast, whose neutral third and sixth sit a quarter-tone below the Western major, giving the characteristic in-between intervals of Middle-Eastern melody.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# HirajoshiTune 1 input

Hirajoshi tune: retunes to the Japanese hirajoshi pentatonic, the dark, koto-flavoured five-note scale of traditional Japanese music, snapped from the played notes.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# RagaBhairavTune 1 input

Raga Bhairav tune: retunes to the just-intonation shrutis of the North-Indian morning raga Bhairav (with its flat second and flat sixth), bringing the pure, beatless intervals of Indian classical tuning.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# TurkishMakamTune 1 input

Turkish makam tune: retunes to a Turkish makam built on Holdrian (53-comma) steps, whose microtonal neutral seconds and sevenths give the characteristic intervals of Ottoman classical melody.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# JustMinorTune 1 input

Just-minor tune: retunes to a 5-limit just-intonation natural minor (pure 6/5 third and 3/2 fifth), giving beatless minor chords impossible in equal temperament.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# SeptimalTune 1 input

Septimal tune: retunes to a 7-limit just scale including the harmonic seventh (7/4), the deep, locked-in dominant-seventh sound prized in barbershop and blues harmony.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# YoungTune 1 input

Young tune: retunes to Thomas Young's 1799 well-temperament, where each key has its own subtly different colour - near-pure common keys, spicier remote ones - the way Classical-era keyboards actually sounded.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# BluesInflect 1 input

Blues inflect: bends the third, fifth and seventh of a major key downward toward the blue notes (the cracks between the piano keys that a blues singer or guitarist bends into), adding microtonal blues feel without changing the notes played.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Amount0 – 10.6—

# HarmonicSeriesTune 1 input

Harmonic-series tune: retunes every note to the nearest member of the natural overtone series of a root (the just-intonation pitches a vibrating string actually produces), so chords lock into pure, beatless ratios that no equal scale can reach.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
RootOct0 – 83—

# SubharmonicTune 1 input

Subharmonic tune: retunes every note to the nearest member of the undertone (subharmonic) series descending from a top pitch, the mirror image of the overtone series that gives eerie, hollow, just-intoned minor sonorities.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
TopOct1 – 96—

# ThaiTune 1 input

Thai tune: retunes to the Thai 7-tone equal temperament (seven equal steps to the octave), the tuning of the Thai ranat and pi phat ensemble that sits between the Western diatonic pitches.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# ByzantineTune 1 input

Byzantine tune: retunes to a Byzantine chant scale, whose soft-chromatic genus uses neutral intervals absent from Western tuning, the sound of Eastern Orthodox liturgical melody.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# PersianTune 1 input

Persian tune: retunes to a Persian dastgah scale with its characteristic koron (quarter-flat) degrees, the microtonal intervals of classical Persian music played on the tar and santur.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# MeantoneTune 1 input

Meantone tune: retunes to quarter-comma meantone, the Renaissance/Baroque temperament with pure (beatless) major thirds bought at the price of a howling 'wolf' fifth, the sound of early-music keyboards.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# CarlosBetaTune 1 input

Carlos Beta tune: retunes to Wendy Carlos's Beta scale, built from a ~63.8-cent step that deliberately does not repeat at the octave, giving the uncanny non-octave harmony of her Beauty in the Beast.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# CarlosGammaTune 1 input

Carlos Gamma tune: retunes to Wendy Carlos's Gamma scale, an ultra-fine ~35.1-cent micro-step tuning that renders both perfect fifths and major thirds nearly pure, the smoothest of her invented scales.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# PartchTune 1 input

Partch tune: retunes to an 11-limit just-intonation subset in the spirit of Harry Partch's 43-tone tonality, the ratio-based microtonality of his hand-built instruments.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# QuarterToneTune 1 input

Quarter-tone tune: retunes to 24-tone equal temperament, snapping every note to the nearest 50-cent quarter-tone, the standard grid of Arabic maqam notation and much 20th-century microtonal music.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# PitchScoop 1 input

Pitch scoop: emits a pitch-bend that starts bent below each new note and swoops up to true pitch over the scoop time, the expressive slide-into-note of a fretless or vocal attack.

ParamRangeDefaultUnit
Depth0 – 10.4—
Time0.02 – 10.12—

# ExpressionSwell 1 input

Expression swell: emits a CC11 expression value that ramps up from zero after each note-on over the swell time, an automatic volume fade-in / crescendo per note for strings and pads.

ParamRangeDefaultUnit
Time0.02 – 40.5—

# HighNoteCC 1 input

High-note CC: emits a controller that tracks the pitch of the highest held note, so the top voice of your playing steers a synth parameter (filter, level, ...).

ParamRangeDefaultUnit
CC0 – 1271—

# LowNoteCC 1 input

Low-note CC: emits a controller that tracks the pitch of the lowest held note, so the bass voice of your playing steers a synth parameter.

ParamRangeDefaultUnit
CC0 – 1271—

# AvgPitchCC 1 input

Average-pitch CC: emits a controller that follows the mean pitch of all held notes (the chord's centroid), a smooth register-position modulation source.

ParamRangeDefaultUnit
CC0 – 1271—

# PolyCountCC 1 input

Poly-count CC: emits a controller that reflects how many notes are held (chord density), reaching full value at Max voices - play thicker chords to open a parameter.

ParamRangeDefaultUnit
CC0 – 1271—
Max1 – 166—

# ChordSpanCC 1 input

Chord-span CC: emits a controller that reflects the interval span (highest minus lowest) of the held notes, full at Range semitones - wide voicings push it up.

ParamRangeDefaultUnit
CC0 – 1271—
Range1 – 6024—

# IntervalCC 1 input

Interval CC: emits a controller on each note-on from how far it leaps from the previous note, so stepwise lines read low and big jumps read high, full at Range semitones.

ParamRangeDefaultUnit
CC0 – 1271—
Range1 – 4812—

# PitchClassCC 1 input

Pitch-class CC: emits a controller on each note-on from the note's pitch class (its position 0-11 within the octave, octave-independent), a harmonic-colour modulation source.

ParamRangeDefaultUnit
CC0 – 1271—

# NoteOnTrigCC 1 input

Note-on trigger CC: fires a CC pulse that jumps to full on every note-on and decays away, a built-in trigger envelope you can route to a synth parameter; Decay sets the fall time.

ParamRangeDefaultUnit
CC0 – 1271—
Decay0.5 – 10.99—

# BendFromVelocity 1 input

Bend from velocity: emits a pitch-bend on each note-on scaled by how hard you played, so harder hits bend up further (an expressive velocity-to-pitch gesture); Depth sets the range.

ParamRangeDefaultUnit
Depth0 – 10.5—

# SwellPressure 1 input

Swell pressure: emits a channel-pressure that rises the longer notes are held and falls once they release, an automatic aftertouch swell for sustained pads; Rate sets the speed.

ParamRangeDefaultUnit
Rate0.05 – 201—

Delay

59 modules

# FreqEcho 1 input

Frequency-shifted echo: a delay line whose feedback is single-sideband frequency-shifted via a polyphase Hilbert pair, so every repeat slides up or down in Hz rather than in pitch. Time sets the delay (1 to 1000 ms), Shift sets the linear frequency offset (-500 to +500 Hz), Feedback (0 to 0.95) sets repeat count, and Mix blends dry/wet. Because the shift is inharmonic, the tail detunes and smears with each pass for metallic, ever-evolving echoes.

ParamRangeDefaultUnit
Time1 – 1000250ms
Shift-500 – 50080Hz
Feedback0 – 0.950.6—
Mix0 – 10.4—

# Multitap 1 input

Multi-tap delay: the input is written into a circular buffer and read back at several time-spaced taps that are summed, averaged, and fed back into the buffer. Time sets the base delay in ms, Taps chooses 1 to 6 read points, Feedback recirculates the averaged taps for repeats, Spread pulls the taps toward the longer end for uneven echo timing, and Mix crossfades dry input against the wet sum. Low Spread gives evenly stacked echoes while high Spread spaces them out, and higher Feedback builds longer rhythmic delay trails.

ParamRangeDefaultUnit
Time1 – 1000250ms
Taps1 – 63—
Feedback0 – 0.90.4—
Spread0 – 10.5—
Mix0 – 10.4—

# Bouncer 2 inputs

A feedback delay whose delay time continually shrinks, so the echoes speed up toward a stutter like a bouncing ball; a gate on in1 re-arms the delay back to its start time. Time sets the initial delay (20..600 ms), Accel sets how fast the time shrinks, Feedback sets the echo regeneration (up to 0.95), and Mix blends wet against dry. Higher Accel collapses the repeats into a rapid buzz, while a gate retrigger resets the bounce.

ParamRangeDefaultUnit
Time20 – 600250ms
Accel0 – 10.5—
Feedback0 – 0.950.7—
Mix0 – 10.5—

# Beatmasher 2 inputs

Beat-repeat: while the gate on in1 is held it records a slice of audio on the first pass then loops that captured slice; releasing the gate passes the dry signal through. Length sets the size of the captured/looped slice (20..1000 ms) and Mix blends the looped slice against the dry input. Hold the gate to freeze and stutter a fragment, release to drop back to live audio.

ParamRangeDefaultUnit
Length20 – 1000250ms
Mix0 – 11—

# BeatSlicer 2 inputs

Captures a buffer while the gate on in1 is held, divides it into 8 slices, and replays them in one of several reorder patterns; releasing the gate passes dry audio through. Length sets the buffer/loop size (100..2000 ms), Pattern selects the slice reordering (0..4, e.g. straight, swapped pairs, doubled, reversed, interleaved), and Mix blends the sliced output against dry. Hold the gate to scramble a phrase into a rhythmic rearrangement.

ParamRangeDefaultUnit
Length100 – 2000500ms
Pattern0 – 41—
Mix0 – 11—

# SliceShuffler 1 input

Continuous buffer-shuffler (Max-for-Live Buffer-Shuffler style): records the incoming audio one bar at a time and, while recording the next bar, plays the last bar back as Steps slices re-ordered by a Seed-driven permutation, with a fraction of slices (Reverse) played backwards and a 16-step on/off Gate mask muting chosen slots. Length sets the bar in milliseconds, Steps the slice count (4/8/16), Seed the rearrangement (every value a different reproducible shuffle), and Mix blends against dry. Unlike BeatSlicer's five fixed patterns this is a fully addressable per-slice remap that runs without a trigger.

ParamRangeDefaultUnit
Length50 – 2000500ms
Steps4 · 8 · 16—
Seed0 – 2550—
Reverse0 – 10—
Gate0 – 6553565535—
Mix0 – 11—

# ReverseGrain 2 inputs

Captures a buffer while the gate on in1 is held, then plays it backward at a pitch-shifted read rate for a reversed, stuttered texture; releasing the gate passes dry audio through. Length sets the captured grain size (50..1500 ms), Pitch transposes the reverse playback rate (+/-12 semitones), and Mix blends the reversed grain against dry. Hold the gate to suck a phrase into a backward swell.

ParamRangeDefaultUnit
Length50 – 1500400ms
Pitch-12 – 120st
Mix0 – 11—

# PeakFlanger 1 input

A comb flanger whose delay time is swept by a peak envelope follower on the input, so transients drive the flange motion (delay ranges ~0.5..9.5 ms). Soften sets the envelope release time, Feedback sets the comb regeneration (+/-0.95, negative inverts the comb), Amount scales how far each peak sweeps the delay, and Mix blends wet against dry. The Traktor Flanger Pulse character: the jet sweep follows the music's own dynamics rather than a fixed LFO.

ParamRangeDefaultUnit
Soften0 – 10.5—
Feedback-0.95 – 0.950.5—
Amount0 – 10.7—
Mix0 – 10.5—

# SpaceEcho 1 input

Roland Space Echo-style tape delay: wow+flutter-modulated tape transport with magnetic hysteresis (asymmetric saturation + remanence) and tone-shaped head gap loss in the feedback repeats.

ParamRangeDefaultUnit
Time50 – 700300ms
Feedback0 – 0.950.4—
Wow0 – 10.2—
Tone1000 – 120005000Hz
Mix0 – 10.4—

# Echorec 1 input

Binson Echorec-style magnetic drum delay: several fixed playback heads give rhythmic multi-tap echoes with rotating-drum wobble and magnetic hysteresis in the feedback.

ParamRangeDefaultUnit
Time40 – 350150ms
Heads1 · 1-2 · 1-2-3 · All—
Feedback0 – 0.90.4—
Mix0 – 10.4—

# MemoryMan 1 input

EHX Memory Man-style analog BBD delay: a companded bucket-brigade line whose clock-tracked reconstruction filter darkens each repeat with delay length, gently chorused, with line-level regeneration.

ParamRangeDefaultUnit
Time30 – 550250ms
Feedback0 – 0.90.35—
Chorus0 – 10.3—
Mix0 – 10.4—

# SDD3000 1 input

Korg SDD-3000-style delay: a characterful input preamp into a modeled converter (ADC anti-alias + 13-bit quantization) - clean and bright with subtle digital grain.

ParamRangeDefaultUnit
Time20 – 900350ms
Feedback0 – 0.90.35—
Tone2000 – 160009000Hz
Mix0 – 10.4—

# TimeCube 1 input

Cooper Time Cube-style delay: a short, dark acoustic-tube delay (sound piped through a garden hose between transducers) for tight doubling and slapback. Time sets the short delay, Feedback the repeats and Mix the blend. Naturally band-limited and woody - characterful on vocals and snare, not a clean digital echo.

ParamRangeDefaultUnit
Time5 – 8030ms
Feedback0 – 0.60.2—
Mix0 – 10.4—

# Echoplex 1 input

Maestro Echoplex EP-34-style tape echo: warm, wow+flutter-modulated repeats with magnetic hysteresis (asymmetric saturation + remanence) and head gap-loss HF roll-off.

ParamRangeDefaultUnit
Time80 – 650300ms
Feedback0 – 0.90.4—
Wow0 – 10.3—
Mix0 – 10.4—

# PitchEcho 1 input

Pitch-locked echo: the delay time is set to a whole number of the input's detected pitch periods, so the repeats land exactly in phase and reinforce the tone instead of smearing it.

ParamRangeDefaultUnit
Periods1 – 164—
Feedback0 – 0.850.4—
Mix0 – 10.4—

# SlapDelay 1 input

Slapback echo: a single short delayed repeat (with optional feedback for a few taps) - the rockabilly/vocal slap that fattens a sound without turning into a wash.

ParamRangeDefaultUnit
Time20 – 250120ms
Feedback0 – 0.70.3—
Mix0 – 10.4—

# BBDelay 1 input

Bucket-brigade delay: emulates an analog BBD chip with input companding, a darkening low-pass on each repeat and gentle saturation, for the warm, lo-fi, increasingly-murky echoes of a vintage analog delay.

ParamRangeDefaultUnit
Time20 – 600250ms
Feedback0 – 0.850.4—
Tone800 – 60002500Hz
Mix0 – 10.4—

# MultiTapDelay 1 input

Multi-tap delay: reads four taps at 1/4, 1/2, 3/4 and 1x of the base time off a single delay line with decreasing levels, building a rhythmic pattern of echoes from one knob.

ParamRangeDefaultUnit
Time50 – 800300ms
Feedback0 – 0.80.3—
Mix0 – 10.4—

# DubEcho 1 input

Dub echo: each repeat passes through a low-pass and soft saturation in the feedback loop, so echoes get progressively darker and warmer as they decay - the classic dub/reggae spring-into-the-mix delay.

ParamRangeDefaultUnit
Time50 – 800350ms
Feedback0 – 0.90.5—
Tone400 – 60002000Hz
Mix0 – 10.4—

# FractalEcho 1 input

Fractal echo: five taps spaced at successive golden-ratio fractions of the base time, each quieter than the last, so one hit scatters into a self-similar cluster of echoes that bunch up as they fade - a fractal stutter, not an even repeat.

ParamRangeDefaultUnit
Time20 – 1000300ms
Decay0 – 0.90.6—
Mix0 – 10.4—

# TapeFlutter 1 input

Tape flutter: a short fractional delay whose read head wobbles under three stacked LFOs - slow wow, mid flutter and fast scrape - reproducing the drifting pitch waver of worn tape; no echo, just the wobble.

ParamRangeDefaultUnit
Base1 – 308ms
Depth0 – 41.5—
Mix0 – 11—

# NoiseModDelay 1 input

Random-warble delay: the delay time wanders on a smoothed random-step modulator that picks a new target at the set rate, giving an unpredictable detuned warble between a chorus and a broken-tape pitch drift.

ParamRangeDefaultUnit
Base2 – 4012ms
Depth0 – 84—
Mix0 – 10.5—
Rate0.1 – 102Hz

# CrossFeedbackDelay 1 input

Cross-coupled delay: two delay lines at incommensurate times each feed the OTHER line's input through a damping filter, so echoes bounce between the two streams and interleave into a denser, evolving pattern than a single tap can make.

ParamRangeDefaultUnit
Feedback0 – 0.90.6—
Damp0 – 0.950.3—
Mix0 – 10.4—

# SpectralTiltDelay 1 input

Spectral-tilt delay: each pass through the feedback loop tilts the spectrum around a pivot, so successive echoes get progressively darker (or brighter) - tape-like high-end decay or a reverse 'opening up' tail, set by one bipolar Tilt knob.

ParamRangeDefaultUnit
Time20 – 1000300ms
Feedback0 – 0.90.6—
Tilt-1 – 1-0.3—
Mix0 – 10.4—

# GrainReverse 1 input

Reverse-grain smear: continuously records the input and reads each short grain backwards through a Hann window, so the sound is chopped into little reversed snippets - a stuttering, sucking, backwards texture from a live signal, no buffer-capture needed.

ParamRangeDefaultUnit
Size10 – 20080ms
Mix0 – 10.7—

# FoldDelay 1 input

Folding echo: a long delay whose feedback path is wavefolded each pass, so every repeat grows brighter and more harmonically dense instead of darker - an inverted, ever-spikier echo tail that a damped delay never produces.

ParamRangeDefaultUnit
Time20 – 1000300ms
Feedback0 – 0.90.6—
Fold1 – 31.3—
Mix0 – 10.4—

# RectDelay 1 input

Octave-rising echo: the feedback is full-wave rectified (DC-removed) each pass, so every repeat jumps an octave and the tail climbs into a shimmering high cloud - a pitched, ascending echo unlike any flat-pitch delay.

ParamRangeDefaultUnit
Time20 – 1000250ms
Feedback0 – 0.850.55—
Mix0 – 10.4—

# WowDelay 1 input

Wow echo: the delay time drifts under a slow sub-1 Hz wow LFO, so the repeats sag and rise in pitch like a worn tape echo - the warbling, detuning character of an old Echoplex, distinct from the fast flutter of TapeFlutter.

ParamRangeDefaultUnit
Time50 – 800300ms
WowDepth0 – 206ms
Feedback0 – 0.850.5—
Mix0 – 10.4—

# LagrangeDelay 1 input

Lagrange fractional delay: reads the delay line at a sub-sample position using 4-point (cubic) Lagrange interpolation rather than the usual linear interpolation, so sub-sample delays keep their high-frequency content instead of being dulled - the interpolation used in high-quality tuning, chorus and physical-modeling delay lines. Delay in ms, wet/dry Mix.

ParamRangeDefaultUnit
Delay0.1 – 305ms
Mix0 – 10.5—

# DuckingDelay 1 input

Ducking delay: a feedback echo whose wet output is pulled down by an envelope of the dry input, so the repeats stay out of the way while you play and swell up in the gaps - the classic technique for delays that add space without cluttering the mix. Time sets the delay, Feedback the repeats, Depth how hard the dry ducks the wet.

ParamRangeDefaultUnit
Time10 – 500250ms
Feedback0 – 0.90.4—
Depth0 – 10.7—
Mix0 – 10.5—

# ThiranAllpass 1 input

Thiran fractional delay: an integer delay line followed by a first-order Thiran all-pass that adds the sub-sample remainder with a maximally-flat group delay, resolving the delay to a fraction of a sample without the high-frequency loss of linear interpolation. A recursive all-pass method distinct from the FIR Lagrange delay - flat magnitude at the cost of frequency-dependent group delay. Feedback recirculates, Mix blends.

ParamRangeDefaultUnit
Delay0.5 – 505ms
Feedback0 – 0.90.3—
Mix0 – 10.5—

# Slapback 1 input

Slapback echo: a single short delayed repeat (typically 60-150 ms) layered under the dry signal - the snappy rockabilly/vocal doubling slap, no feedback wash. Time sets the delay, Mix the level of the repeat.

ParamRangeDefaultUnit
Time20 – 400110ms
Mix0 – 10.5—

# Freeze 2 inputs

Audio freeze / looper: while in1 is high it captures the recent input and loops a window of it indefinitely (an instant sustain/pad-freeze); while in1 is low it passes the dry signal and keeps recording. Size sets the loop window length, Mix the wet level.

ParamRangeDefaultUnit
Size20 – 1000250ms
Mix0 – 11—

# TapeStop 2 inputs

Tape-stop effect: while in1 is held the playback slows from full speed to a halt over Time, dropping the pitch and smearing into silence - the classic turntable/tape brake. Releasing in1 returns to normal speed. Mix blends against the dry. A performance effect, not a fixed pitch shift.

ParamRangeDefaultUnit
Time0.05 – 40.6s
Mix0 – 11—

# Delay 3 inputs

Feedback delay line (1-8000 ms) with a damping low-pass in the feedback path that progressively darkens each repeat. Time is modulated by in 3 (scaled by Mod) for chorus and flange-style movement, Feedback sets regeneration up to 0.99, and Mix sets dry/wet. Damp at 0 gives bright digital echoes; higher values emulate tape/BBD high-frequency loss.

ParamRangeDefaultUnit
Time1 – 8000250ms
Feedback0 – 0.990.35—
Mod0 – 5000ms
Damp0 – 10—
Mix0 – 11—

# AlignDelay 1 input

Alignment delay (Ableton Align Delay-style): a clean dry delay used to time-align tracks or push a signal later by a precise amount - no feedback, no filtering, no colour. Time sets the delay in milliseconds; leave Mix fully wet for pure alignment, or blend for a simple slap double.

ParamRangeDefaultUnit
Time0 – 1000ms
Mix0 – 11—

# FilterDelay 1 input

Filtered multi-tap delay (Ableton Filter Delay-style): three delay taps at spreading times, each band-passed at Color before feedback, so the echoes are tuned and coloured rather than full-range. Time sets the first tap, Spread the spacing of the other two, Color the band-pass centre, Feedback the regeneration, and Mix the wet blend. (Mono sum of the three taps; the device's L/C/R panning needs a stereo rack.)

ParamRangeDefaultUnit
Time1 – 8000250ms
Spread0 – 10.5—
Color100 – 60001200Hz
Feedback0 – 0.90.4—
Mix0 – 10.5—

# Rainmaker 1 input

Rhythmic tapped delay (Intellijel / Cylonix Rainmaker): spreads up to Taps echoes across the delay Time in a decaying rhythm, then runs the result through a tuned Comb resonator for ringing, pitched repeats - rhythmic delays, resonant reverbs and string-like tones in one. Time sets the span, Taps the number of echoes, Feedback the regeneration, Comb the resonator pitch/amount, and Mix the wet blend. A 16-tap rhythm engine, distinct from the fixed-tap Multitap.

ParamRangeDefaultUnit
Time20 – 8000400ms
Taps1 – 168—
Feedback0 – 0.90.3—
Comb0 – 10.3—
Mix0 – 10.5—

# Morphagene 1 input

Tape-splice granular (Make Noise / Soundhack Morphagene): continuously records the in0 input onto a virtual tape, then plays back a Gene (grain) from it. Slide scans the playback position along the reel, Vari sets the varispeed (pitch + direction, reverse below centre), Gene the grain length, Morph the grain overlap/smear, and Mix the blend. Scrub, stretch, reverse and granulate live audio - distinct from the fixed-loop Looper and the cloud-style granular blocks.

ParamRangeDefaultUnit
Gene0.02 – 0.50.15s
Vari-1 – 11—
Slide0 – 10—
Morph0 – 10.5—
Mix0 – 10.5—

# Comb 1 input

Tuned comb resonator: a short feedback delay set by Freq (20-2000 Hz) with a damping low-pass, which doubles as a Karplus-Strong plucked string when excited by a transient. Feedback sets resonance and sustain while Damp darkens the decay. High feedback rings at the tuned pitch; pair it with noise or an impulse for string and membrane tones.

ParamRangeDefaultUnit
Freq20 – 2000220Hz
Feedback0 – 0.990.9—
Damp0 – 10.3—
Mix0 – 11—

# Chorus 1 input

Single-voice chorus: an LFO (Rate, Depth) modulates a short base Delay (1-30 ms) and the detuned copy is blended back via Mix to thicken and widen the source. Short delays with light depth give subtle doubling; longer and deeper settings approach vibrato and flange. See Ensemble for a three-voice string-machine variant.

ParamRangeDefaultUnit
Rate0.05 – 80.8Hz
Depth0 – 10.5—
Delay1 – 3012ms
Mix0 – 10.5—

# Flanger 1 input

Swept-comb flanger: an LFO sweeps a very short delay (0.5-10 ms) mixed with the dry signal to create moving comb notches, with bipolar Feedback resonating the peaks (negative values invert for a hollow tone). Depth sets the sweep width and Mix the blend. Short delays with high feedback give the classic metallic jet-whoosh.

ParamRangeDefaultUnit
Rate0.05 – 80.3Hz
Depth0 – 10.7—
Feedback-0.95 – 0.950.3—
Delay0.5 – 102ms
Mix0 – 10.5—

# Vibrato 1 input

Pitch vibrato: an LFO modulates a short delay's read position to bend pitch, output fully wet (no dry blend) for true vibrato rather than chorus. Rate sets the wobble speed and Depth its pitch range. Gentle settings add expression; deep settings give a seasick warble.

ParamRangeDefaultUnit
Rate0.1 – 125Hz
Depth0 – 10.3—
Delay1 – 205ms

# Stutter 1 input

Auto-rhythmic buffer repeat: at each Rate cycle it snapshots a Grab-length window and loops it for the cycle, creating stutters and beat-repeat artefacts, with Mix blending against the live signal. Short grabs at high rates give granular buzz; longer grabs repeat recognizable slices. See Beatmasher and BeatSlicer for tempo-locked glitching.

ParamRangeDefaultUnit
Rate0.5 – 164Hz
Grab10 – 25060ms
Mix0 – 11—

# TapeDelay 1 input

Vintage tape echo: a ~1.5 Hz wow modulates the delay time while a Tone low-pass and tanh tape Saturation in the feedback path darken and thicken each repeat. Feedback sets regeneration and Mix the blend. Unlike the clean Delay, repeats degrade and warble musically - raise Wow and Sat for worn-tape character.

ParamRangeDefaultUnit
Time1 – 8000300ms
Feedback0 – 0.990.45—
Wow0 – 10.2—
Tone500 – 160005000Hz
Sat0 – 10.3—
Mix0 – 10.4—

# Ensemble 1 input

Three-voice string-machine chorus: one LFO modulates three delay taps at evenly spread phases, summing into a lush, wide thickening richer than the single-voice Chorus. Rate and Depth set the swirl and Mix the blend. Classic for pads, strings and synth-brass.

ParamRangeDefaultUnit
Rate0.05 – 40.6Hz
Depth0 – 10.6—
Mix0 – 10.5—

# Rotary 1 input

Leslie rotary speaker: combines a doppler pitch wobble (modulated short delay) with a phase-offset amplitude tremolo so the tone swirls as the virtual horn spins. Speed sets the rotation rate and Depth its intensity. Iconic on organ, electric piano and guitar - automate Speed for the slow-to-fast chorale ramp.

ParamRangeDefaultUnit
Speed0.5 – 86Hz
Depth0 – 10.5—
Mix0 – 10.5—

# Reverse 1 input

Reverse delay: snapshots a Window-length slice of input and plays it backward on a loop, a glitchy pre-echo/reverse texture, blended via Mix. Short windows give fluttering grains; longer windows reverse recognizable phrases. See ReverseGrain and ReverseVerb for related effects.

ParamRangeDefaultUnit
Window20 – 500120ms
Mix0 – 11—

# BBDDelay 1 input

Bucket-brigade style echo whose delayed tap is passed through a one-pole low-pass and a tanh saturation in the feedback path, so each repeat grows darker and grittier. Time sets the delay length (1-8000 ms), Feedback sets regeneration up to 0.9, Tone sets the high-frequency rolloff of the repeats, and Mix blends the filtered echo with the dry signal. Lower Tone yields the murky, decaying character of analog BBD delays.

ParamRangeDefaultUnit
Time1 – 8000250ms
Feedback0 – 0.90.4—
Tone0 – 10.5—
Mix0 – 10.5—

# ReverseDelay 1 input

Captures the input into a delay buffer and reads it back newest-to-oldest within a repeating window, so each chunk plays in reverse. Time sets the window length (50-8000 ms) that defines how much audio is flipped per cycle, and Mix blends the reversed playback against the dry signal. Useful for backward-tape swells and disorienting rhythmic stutters.

ParamRangeDefaultUnit
Time50 – 8000400ms
Mix0 – 10.5—

# DuckDelay 1 input

Feedback delay line whose wet output is attenuated by an envelope follower tracking the dry signal, so repeats drop out while you play and swell up in the gaps. Time sets the delay length (1-8000 ms), Feedback sets regeneration up to 0.9, Duck sets how hard the dry level suppresses the echoes, and Mix blends wet and dry. Keeps echoes from cluttering busy passages while letting them bloom in the silences.

ParamRangeDefaultUnit
Time1 – 8000300ms
Feedback0 – 0.90.4—
Duck0 – 10.7—
Mix0 – 10.5—

# GrainDelay 1 input

Granular feedback delay that reads overlapping windowed grains from the delay line, pitch-shifting them and scattering their read positions. Time sets the base tap (10-8000 ms), Pitch transposes the grains +/-12 semitones, and Scatter randomizes each grain's offset for a smeared, diffuse cloud. Mix sets dry/wet; the shifted grains are fed back at reduced gain, so repeats drift in pitch and position.

ParamRangeDefaultUnit
Time10 – 8000300ms
Pitch-12 – 120st
Scatter0 – 10.4—
Mix0 – 10.5—

# DiffuseDelay 1 input

Feedback delay whose tap is smeared through a 4-stage all-pass diffusion chain, pushing echoes toward reverb. Time sets the delay (1-1000 ms), Feedback sets regeneration up to 0.9, and Diffuse sets the all-pass coefficient that controls how much each repeat is blurred. Mix sets dry/wet; low Diffuse gives clean echoes, high Diffuse dissolves them into a diffuse wash.

ParamRangeDefaultUnit
Time1 – 1000300ms
Feedback0 – 0.90.4—
Diffuse0 – 0.90.6—
Mix0 – 10.5—

# Looper 1 input

Circulating-buffer looper that re-reads a fixed-length loop and either overdubs new input onto it or recirculates it unchanged. Length sets the loop time (100-2000 ms) and Record switches between overdub (input mixed with the looped buffer at half gain) and pure recirculation when off. Mix sets dry/wet; leave Record on to layer takes, turn it off to freeze and play back the captured loop.

ParamRangeDefaultUnit
Length100 – 20001000ms
Record0 – 11—
Mix0 – 10.5—

# Shuffler 1 input

Beat-shuffler that records the input and, at each segment boundary, may jump its playback to one of a few earlier segment offsets. Segment sets the slice length (50-500 ms) and Chance sets the probability that a new boundary triggers a jump to a randomly chosen prior offset. Mix sets dry/wet; low Chance plays mostly straight, high Chance stutters and rearranges the beat.

ParamRangeDefaultUnit
Segment50 – 500200ms
Chance0 – 10.5—
Mix0 – 10.5—

# Scratch 1 input

Turntable-scratch effect where a raised-cosine LFO sweeps the delay read head back and forth through recent input. Rate sets the sweep speed (0.1-8 Hz) and Depth sets how far back the head travels (1-200 ms). Mix sets dry/wet; faster Rate and deeper Depth give more pronounced vinyl-scratch wobble.

ParamRangeDefaultUnit
Rate0.1 – 82Hz
Depth1 – 20080ms
Mix0 – 10.5—

# PingPong 1 input

Ping-pong delay for a mono source: a single line is read at time T or 2T so the two outputs hear staggered taps that appear to bounce between speakers, with regeneration fed back through the longer tap. Time sets the base delay, Feedback the number of repeats up to 0.9, and Mix dry/wet. Out picks L or R, where R hears T and L hears 2T to create the alternating bounce.

ParamRangeDefaultUnit
Time1 – 1000300ms
Feedback0 – 0.90.45—
Out0 – 10—
Mix0 – 10.5—

# Glitch 1 input

Probabilistic buffer glitcher that records the input and, at each slice boundary, randomly jumps to a captured slice and may play it forward or reversed. Slice sets the segment length in milliseconds and Chance sets the probability that a given slice is repeated or reversed rather than passed through cleanly. Mix blends the glitched playback against the dry signal for stutter, repeat and reverse artifacts.

ParamRangeDefaultUnit
Slice50 – 500150ms
Chance0 – 10.4—
Mix0 – 11—

# DubDelay 1 input

Dub-techno echo: a feedback delay whose repeats are progressively band-limited and tape-saturated inside the loop, so each echo gets darker, warmer and more degraded - the endless, dubby Basic-Channel chord-stab echo of dub techno and dub house. Time sets the delay, Feedback how many repeats (high = near-infinite), Tone darkens each repeat (low-pass in the loop), Drive the in-loop tape saturation, and Mix the wet/dry blend. Long Time + high Feedback + low Tone gives the classic sinking dub tail. Distinct from the clean Delay and the wow/flutter TapeDelay - the feedback path is filtered and saturated.

ParamRangeDefaultUnit
Time50 – 1000375ms
Feedback0 – 0.950.6—
Tone0 – 10.4—
Drive0 – 10.3—
Mix0 – 10.4—

Reverb

50 modules

# Convolution 1 input

Convolution reverb: input is buffered into blocks and convolved with an impulse response via partitioned FFT, then streamed back with block latency. The IR comes from the node config (an audio file path loads that real IR, otherwise a decay time in seconds generates a decaying-noise tail); PreDelay offsets the wet by 0 to 200 ms, Tone is a one-pole low-pass on the wet, and Mix blends dry/wet. Use it to place sounds in real spaces or to apply any captured IR.

ParamRangeDefaultUnit
Mix0 – 10.3—
PreDelay0 – 2000ms
Tone0 – 11—

# Plate 1 input

Plate reverb: the input runs through four series allpass diffusers and then into four parallel damped feedback combs that are summed for the wet tail. Decay sets the comb feedback (0 to 0.95), Damp is a one-pole low-pass inside the feedback that darkens later reflections, Size scales the delay-line lengths, and Mix blends dry/wet. Dense, smooth metallic decay suited to plates and tight ambiences.

ParamRangeDefaultUnit
Size0 – 10.6—
Decay0 – 0.950.7—
Damp0 – 10.4—
Mix0 – 10.3—

# Shimmer 1 input

Shimmer reverb: a delay line whose feedback path is pitch-shifted by a two-window granular shifter so repeats climb in pitch each pass. Shift sets the transposition in semitones (-12 to +24), Feedback (0 to 0.95) controls how long the tail sustains, Size sets the delay time in ms, Damp low-passes the feedback, and Mix blends dry/wet. With Shift at +12 it builds the classic ethereal rising-octave wash.

ParamRangeDefaultUnit
Size50 – 800300ms
Shift-12 – 2412st
Feedback0 – 0.950.7—
Damp0 – 10.4—
Mix0 – 10.4—

# Iceverb 1 input

Four lowpass-damped comb filters form the reverb body, then a self-oscillating resonant state-variable filter is applied to the tail for a cold, ringing sheen. Size sets the comb feedback/decay (up to 0.95), Color sets the resonant filter frequency (~100 Hz..14 kHz), Icing sets its resonance toward self-oscillation, and Mix blends wet against dry. High Icing makes the tail sing into a metallic, icy ring.

ParamRangeDefaultUnit
Size0 – 0.950.7—
Color0 – 10.5—
Icing0.5 – 148—
Mix0 – 10.35—

# ModEchoVerb 1 input

Fused reverb and modulated delay: the input feeds a wow-modulated feedback delay and a short comb reverb tank at once, blending echo and space in one block.

ParamRangeDefaultUnit
Size0 – 0.950.6—
Time20 – 1000300ms
Feedback0 – 0.90.4—
ModRate0.05 – 50.4Hz
Mix0 – 10.4—

# EMT140 1 input

EMT 140-style plate reverb: a dispersive modulated all-pass tank (the plate shimmer where HF and LF propagate at different speeds), instant dense diffusion, bright sheen, HF decaying faster than the low tail.

ParamRangeDefaultUnit
Decay0 – 10.6—
Tone0 – 10.4—
PreDelay0 – 2000ms
Mix0 – 10.3—

# Chamber 1 input

Chamber reverb: higher modal density than a plate with a diffuse onset and warm, non-metallic tail - between a plate and a room.

ParamRangeDefaultUnit
Decay0 – 10.6—
Tone0 – 10.6—
PreDelay0 – 20010ms
Mix0 – 10.3—

# BX20 1 input

AKG BX-20-style torsional-spring reverb: a dispersive modulated all-pass tank models the spring chirp smeared smooth - long, dark, no boing.

ParamRangeDefaultUnit
Decay0 – 10.7—
Tone0 – 10.7—
Mix0 – 10.3—

# Lex224 1 input

Lexicon 224-style digital hall: a long, lush, slowly-modulated reverb tail (chorusing avoids metallic ringing) with bright, dense diffusion.

ParamRangeDefaultUnit
Decay0 – 10.7—
Tone0 – 10.5—
PreDelay0 – 20020ms
Mix0 – 10.3—

# Lex480 1 input

Lexicon 480L-style digital reverb: a brighter, denser random-hall/plate with a modulated tail and fast build-up.

ParamRangeDefaultUnit
Decay0 – 10.65—
Tone0 – 10.6—
PreDelay0 – 20010ms
Mix0 – 10.3—

# EMT250 1 input

EMT 250-style early digital reverb: a dense tank with first-generation converter quantization grain - bright and unmistakably early-digital.

ParamRangeDefaultUnit
Decay0 – 10.55—
Tone0 – 10.55—
PreDelay0 – 1508ms
Mix0 – 10.3—

# RMX16 1 input

AMS RMX16-style digital reverb (Nonlin program): a dense, gated tail that holds then cuts off instead of decaying naturally - the classic 80s gated sound.

ParamRangeDefaultUnit
Density0 – 10.6—
Hold20 – 400150ms
Tone0 – 10.5—
Mix0 – 10.3—

# SchroederAP 1 input

Schroeder all-pass diffuser: the classic flat-magnitude, phase-smearing all-pass that thickens transients into a diffuse tail - one reverb-grade diffusion stage you can chain or use alone.

ParamRangeDefaultUnit
Time5 – 8030ms
Gain0 – 0.80.6—
Mix0 – 10.5—

# CombReverb 1 input

Two-comb reverb: a pair of damped feedback combs at incommensurate delays sum into a short, coloured reverb tail - the core of a Schroeder reverb in one block.

ParamRangeDefaultUnit
Decay0 – 0.950.7—
Damp0 – 10.3—
Mix0 – 10.4—

# SpringVerb 1 input

Spring reverb: an all-pass-dispersed feedback delay recreates the chirpy, boingy, frequency-smeared bounce of a reverb spring tank, the surf-guitar/amp reverb sound rather than a smooth hall.

ParamRangeDefaultUnit
Decay0 – 0.90.6—
Disperse0 – 0.90.7—
Mix0 – 10.4—

# FDNReverb 1 input

Feedback-delay-network reverb: four delay lines recirculate through a lossless Hadamard mixing matrix, the modern algorithmic-reverb core that builds a dense, smooth, hall-like tail from just four taps.

ParamRangeDefaultUnit
Decay0 – 0.950.8—
Damp0 – 10.3—
Mix0 – 10.4—

# AllpassChain 1 input

All-pass diffusion chain: four first-order all-pass stages in series smear phase without touching magnitude, thickening and diffusing transients - a building block for reverb pre-diffusion or a standalone phasey wash.

ParamRangeDefaultUnit
Coeff0 – 0.90.6—
Mix0 – 10.5—

# GatedReverb 1 input

Gated reverb: a dense reverb whose tail is cut off abruptly by a gate that closes when the dry input falls quiet, the explosive, truncated drum-reverb sound of 1980s records.

ParamRangeDefaultUnit
Decay0 – 0.950.85—
Hold10 – 500120ms
Mix0 – 10.5—

# ShimmerVerb 1 input

Shimmer reverb: the reverb's feedback path is granular-pitch-shifted up an octave each pass, so the tail blooms into an ethereal, ever-rising angelic wash - the signature ambient/post-rock reverb.

ParamRangeDefaultUnit
Decay0 – 0.90.7—
Shimmer0 – 10.5—
Mix0 – 10.4—

# CombAllpassDiffuse 1 input

Comb-into-allpass diffuser: a tuned feedback comb followed by an all-pass smears its periodic echoes into a denser, less-metallic tail - the comb-plus-allpass building block of Schroeder/Moorer reverbs in one cell.

ParamRangeDefaultUnit
Time10 – 12050ms
Decay0 – 0.90.7—
Diffuse0 – 0.80.5—
Mix0 – 10.4—

# PlateReverb 1 input

Plate reverb: a pair of all-pass input diffusers feed a damped recirculating delay tank (the Dattorro topology), producing the dense, bright, metallic-smooth decay of a studio plate rather than a room.

ParamRangeDefaultUnit
Decay0 – 0.920.7—
Damp0 – 10.4—
Mix0 – 10.35—

# SlewVerb 1 input

Slew-limiter wash: six slew-rate limiters in series, fed back on the last stage, smear every edge into a soft triangular blur that pools into a short ambient tail - a reverb-like space built entirely from slew limiting, no delay lines.

ParamRangeDefaultUnit
Rate0.001 – 0.50.05—
Feedback0 – 0.90.5—
Mix0 – 10.4—

# CombHaze 1 input

Comb haze: four short feedback comb taps at incommensurate delays share one buffer and sum into a dense, metallic, slightly detuned resonance with a damping low-pass on the tail - a small bright box between a resonator and a reverb.

ParamRangeDefaultUnit
Feedback0 – 0.90.6—
Damp0 – 0.950.4—
Mix0 – 10.4—

# CombSwarm 1 input

Comb swarm: four damped feedback combs at closely-detuned incommensurate delays beat against each other into a shimmering, chorused metallic resonance - denser and more animated than a single comb, between a resonator and a small bright reverb.

ParamRangeDefaultUnit
Decay0 – 0.950.8—
Damp0 – 0.950.4—
Mix0 – 10.4—

# CrushVerb 1 input

Lo-fi crush reverb: a pair of damped feedback combs whose recirculating signal is bit-crushed each pass, so the tail degrades into a grainy, quantized, ever-coarser decay - a digital ruin between a reverb and a sample-rate reducer.

ParamRangeDefaultUnit
Decay0 – 0.920.7—
Bits3 – 126—
Mix0 – 10.4—

# DiffusorComb 1 input

Diffused comb: a pair of allpass diffusers smear the input before it enters a tuned damped comb, so the comb's metallic resonance is softened into a smooth, dense, plate-like ring rather than a sharp peak - between a resonator and a small reverb.

ParamRangeDefaultUnit
Decay0 – 0.950.8—
Damp0 – 0.950.4—
Mix0 – 10.4—

# CombAllpass 1 input

Schroeder allpass: a tuned delay-line allpass (feed-forward and feedback comb combined) that passes all frequencies flat but smears phase into a short coloured tail - the building block of classic reverb diffusion, here exposed standalone and tuned in Hz. Distinct from the first-order AllpassChain.

ParamRangeDefaultUnit
Tune50 – 1000200Hz
G0 – 0.90.6—
Mix0 – 11—

# EarlyReflections 1 input

Early reflections: sums eight delayed taps at prime-spaced room-like times with decaying gains - the discrete first echoes a room produces before the diffuse tail, with no feedback. Adds spatial depth and 'air' without the wash of a full reverb. Size scales the room dimensions (tap times); Mix blends against the dry signal.

ParamRangeDefaultUnit
Size0.3 – 21—
Mix0 – 10.4—
Level0 – 11—

# FreezeReverb 1 input

Freeze reverb: a damped comb-feedback reverberator whose Freeze control pushes the feedback toward unity while muting the input, capturing the current sound and sustaining it forever as a smooth pad - the 'infinite reverb / hold' effect. At Freeze 0 it is an ordinary decaying reverb (set by Feedback); turn it up to lock the tail. Damping rolls off the highs in the loop.

ParamRangeDefaultUnit
Time20 – 12080ms
Feedback0 – 0.950.7—
Freeze0 – 10—
Mix0 – 10.5—

# SpringReverb 1 input

Spring-tank reverb: a feedback delay whose loop runs through a chain of first-order all-pass sections, giving the frequency-dependent (dispersive) delay that produces a real spring's characteristic 'boing' and metallic chirp - distinct from the dense diffusion of plate or hall reverbs. Time sets the tank length, Decay the tail, Dispersion the all-pass chirp amount, Damp the high-frequency loss, and Mix the wet/dry blend.

ParamRangeDefaultUnit
Time10 – 20060ms
Decay0 – 0.950.7—
Dispersion0 – 0.90.6—
Damp0 – 10.4—
Mix0 – 10.4—

# Plonk 1 input

Modal resonator (Rings/Plonk-style): excites a bank of five tuned band-pass resonators with the input, imposing the ringing modes of a struck object - bar, plate, bell, drumhead - onto any signal. Tune sets the fundamental, Structure morphs the partials from a harmonic stack toward inharmonic metallic ratios, Decay sets the ring time (resonator Q), and Mix the wet blend. Feed it drums, noise or a synth for plucked, struck and resonated tones. Distinct from the single-mode Resonator and the self-struck Modal oscillator.

ParamRangeDefaultUnit
Tune40 – 2000220Hz
Structure0 – 10.5—
Decay1 – 4012—
Mix0 – 10.5—

# Diffuser 1 input

Allpass diffuser: a cascade of four Schroeder all-pass sections with prime-spaced delays smears transients into a short, dense burst without adding a reverb tail or colouring the magnitude spectrum - the diffusion stage that lives inside reverbs, exposed on its own to thicken percussion, blur clicks, or pre-soften a signal before further processing. Amount sets the all-pass coefficient (smear density), Size scales the delay times, and Mix blends against the dry signal.

ParamRangeDefaultUnit
Amount0 – 0.850.6—
Size0.2 – 21—
Mix0 – 10.5—

# Aetherizer 1 input

Grain cloud (Absynth Aetherizer-style): continuously records the input and sprays a swarm of overlapping Hann-windowed grains read back from random recent positions, each at a randomized pitch, so a held sound dissolves into an evolving shimmering cloud. Size sets grain length, Density the grains per second, Pitch the centre transpose, Spread the random pitch scatter, Scatter how far back grains are picked, and Mix the wet amount. A texture/sound-design effect distinct from the granular delay and granular reverb.

ParamRangeDefaultUnit
Size20 – 20080ms
Density5 – 12040Hz
Pitch-12 – 120st
Spread0 – 123st
Scatter20 – 1000300ms
Mix0 – 10.5—

# Sympathetic 1 input

Sympathetic-string resonator bank: four high-Q tuned resonators (like the drone strings of a sitar or the undamped strings of a piano) ring in sympathy with the input, voiced as a chord above the Tune root. Tune sets the root pitch, Decay how long the strings ring (resonator Q), Spread the chord voicing, and Mix the resonated blend. Feed it a plucked or percussive source for shimmering resonant tails - distinct from reverb and from a single modal resonator.

ParamRangeDefaultUnit
Tune40 – 1000220Hz
Decay0 – 10.7—
Spread0 – 10.5—
Mix0 – 10.5—

# ErbeVerb 1 input

Modeless morphing reverb (Make Noise / Soundhack Erbe-Verb): a continuously-variable feedback-delay-network reverb with no presets - dial Size and Decay anywhere from a tight room through a cavernous hall, and Tilt from dark to bright. Mod animates the delay network for chorused, evolving and unreal spaces, and Mix blends wet against dry. One reverb that morphs smoothly across the whole space rather than switching between fixed types.

ParamRangeDefaultUnit
Size0 – 10.5—
Decay0 – 10.6—
Tilt0 – 10.5—
Mod0 – 10.2—
Mix0 – 10.4—

# Reverb 1 input

Algorithmic room reverb (Freeverb-style comb/all-pass network) with Size scaling the decay time and Damp rolling off the highs in the tail. Width sets the stereo spread and Mix the dry/wet blend. Large Size with low Damp gives long bright halls; high Damp yields short dark rooms - see Massive, Plate, Spring and Shimmer for character-specific spaces.

ParamRangeDefaultUnit
Size0 – 10.5—
Damp0 – 10.5—
Width0 – 11—
Mix0 – 10.3—

# Massive 1 input

Feedback-delay-network reverb (Valhalla Supermassive style): four modulated delay lines mixed through a unitary Hadamard matrix give huge, smooth, near-infinite tails. Size scales delay length up to multi-second, Decay sets feedback, Damp absorbs highs in the loop, and Mod choruses the lines for shimmer. Mode picks Lush / Huge / Cosmos voicings, from tight to cathedral to cosmic.

ParamRangeDefaultUnit
Size0 – 10.6—
Decay0 – 10.85—
Damp0 – 10.4—
Mod0 – 10.3—
Mode0 – 21—
Mix0 – 10.4—

# Spring 1 input

Spring-reverb approximation: a short (~30 ms) delay loop diffused through an all-pass cascade for the characteristic dispersive boing, with a Tone low-pass in the feedback. Decay sets the tail length and Mix the blend. The classic guitar-amp and dub reverb - splashy on transients, drippy at high Decay.

ParamRangeDefaultUnit
Decay0 – 0.950.6—
Tone500 – 80003000Hz
Mix0 – 10.3—

# Ascend 1 input

Pitch-rising shimmer reverb: a long delay whose feedback is pitch-shifted up an octave (granular two-tap) and damped, so the tail ascends and blooms into ethereal pads. Size sets the delay length, Shimmer the octave-up feedback amount and Damp the tail brightness. Lush on pads, vocals and ambient guitar - see Crystals for reverse+pitch and Gravity for huge inverted tails.

ParamRangeDefaultUnit
Size0 – 10.6—
Shimmer0 – 0.950.5—
Damp0 – 10.4—
Mix0 – 10.3—

# GatedVerb 1 input

Reverb whose wet tail is muted by a fast envelope-driven gate, so the reverb only passes while the dry input stays above a threshold. Size sets the room length and Damp the high-frequency decay, Threshold sets the level below which the tail is cut, and Mix blends the gated reverb against the dry signal. Reproduces the abrupt, chopped-off reverb of 80s drum production.

ParamRangeDefaultUnit
Size0 – 10.6—
Damp0 – 10.4—
Threshold-60 – 0-30dB
Mix0 – 10.3—

# FreezeVerb 1 input

Reverb that can latch into an infinite-hold freeze mode, sustaining the current tail indefinitely instead of decaying. Size sets the room length and Damp the high-frequency decay, Freeze above its midpoint engages the infinite hold, and Mix blends the reverb against the dry signal. Use the freeze to build sustained drones and pads from a single moment of input.

ParamRangeDefaultUnit
Size0 – 10.7—
Damp0 – 10.3—
Freeze0 – 10—
Mix0 – 10.4—

# DuckVerb 1 input

Reverb whose wet signal is attenuated by an envelope follower tracking the dry input, so the tail dips while you play and swells back in the gaps. Size sets the room length and Damp the high-frequency decay, Duck sets how strongly the dry level suppresses the wet, and Mix blends the ducked reverb against the dry signal. Keeps the reverb from washing out a busy performance while preserving the tail between phrases.

ParamRangeDefaultUnit
Size0 – 10.6—
Damp0 – 10.4—
Duck0 – 10.7—
Mix0 – 10.3—

# ModVerb 1 input

Reverb whose room size is continuously modulated by a sine LFO, detuning the tail for a chorused, shimmering character. Size sets the base room length and Damp the high-frequency decay, Rate sets the LFO speed (0.05-5 Hz) and Depth how far it sweeps the size, and Mix blends the moving reverb against the dry signal. Adds motion and width to otherwise static reverb tails.

ParamRangeDefaultUnit
Size0 – 10.6—
Damp0 – 10.4—
Rate0.05 – 50.5Hz
Depth0 – 10.3—
Mix0 – 10.3—

# ReverseVerb 1 input

Reverb whose wet level swells up from silence after each detected onset, fading the tail in rather than out for a backward, blooming effect. Size sets the room length and Damp the high-frequency decay, Swell sets the fade-in time (1-500 ms) restarted on every new transient, and Mix blends the swelling reverb against the dry signal. Produces the rising, sucked-in quality of reversed reverb.

ParamRangeDefaultUnit
Size0 – 10.6—
Damp0 – 10.4—
Swell1 – 500150ms
Mix0 – 10.4—

# Gravity 1 input

Oversized 4-line feedback delay network (FDN) reverb, each line damped by a low-pass and length-modulated by a shared LFO. Size stretches the base delay times up to 9x, Gravity raises feedback toward unity for near-infinite tails, Mod sets the LFO modulation depth, and Freeze pins feedback to 1.0 while muting new input. Mix blends the Hadamard-mixed wet sum against the dry; pushed hard it yields huge, slowly-evolving, freezable spaces.

ParamRangeDefaultUnit
Size0 – 10.8—
Gravity0 – 10.9—
Mod0 – 10.4—
Freeze0 – 10—
Mix0 – 10.4—

# NonlinVerb 1 input

Nonlinear 4-line FDN reverb whose wet tail is gated by an envelope follower: a transient above the running level retriggers a hold, then the gain holds flat before cutting off. Size scales the short base delay times up to 5x, while Hold sets how long (10-500 ms) the tail sustains at full level before it decays away. Mix sets dry/wet; the held-then-cut behaviour gives gated, non-natural reverb bursts rather than a smooth decay.

ParamRangeDefaultUnit
Size0 – 10.5—
Hold10 – 500150ms
Mix0 – 10.4—

# Crystals 1 input

Shimmer reverb: a 4-line FDN whose output is pitch-shifted an octave up and re-injected into the network, building rising crystalline overtones. Size scales the base delay times up to 6x, Shimmer sets how much octave-up signal feeds back in, and Damp sets the per-line low-pass that darkens repeats. Mix blends the wet sum against the dry; higher Shimmer ascends further, higher Damp tames the brightness.

ParamRangeDefaultUnit
Size0 – 10.6—
Shimmer0 – 10.5—
Damp0 – 10.4—
Mix0 – 10.4—

# GrainVerb 1 input

Granular reverb that windows the input with a moving Hann grain and injects it into a 4-line feedback delay network for diffusion. Size scales the four delay lengths up to 6x for longer tails, Grain sets the grain rate in milliseconds, and Damp applies a low-pass in each feedback line to darken successive reflections. Mix blends the diffused tail against the dry input for a smeared, granular ambience.

ParamRangeDefaultUnit
Size0 – 10.6—
Grain5 – 10030ms
Damp0 – 10.4—
Mix0 – 10.3—

# Freezer 1 input

Audio freezer that continuously buffers the input and, when Freeze is engaged, loops the most recently captured window indefinitely. Size sets the length of the looped window in milliseconds, trading a short stuttering grain against a longer evolving pad, and Mix blends the frozen loop against the dry signal. With Freeze off it passes the input through while keeping the buffer primed for an instant capture.

ParamRangeDefaultUnit
Freeze0 – 10—
Size20 – 500200ms
Mix0 – 11—

# MangledVerb 1 input

Reverb whose fully wet output is fed through a tanh saturation stage for gritty, broken ambience. Size sets the room size and tail length, Damp rolls off high frequencies in the decay, and Drive pushes the reverb output harder into the nonlinearity for increasing crush. Mix blends the distorted tail against the dry signal, ranging from a lightly dirtied space to a heavily mangled wash.

ParamRangeDefaultUnit
Size0 – 10.6—
Damp0 – 10.4—
Drive0 – 10.5—
Mix0 – 10.3—

Dynamics

249 modules

# Omnipressor 1 input

Extreme dynamics on one knob: Function sweeps from gating expansion through limiting compression to full dynamic reversal, where loud passages turn quiet and quiet turns loud.

ParamRangeDefaultUnit
Function-1 – 31—
Threshold-48 – 0-18dB
Attack0.1 – 1003ms
Release5 – 800120ms
Gain-12 – 240dB

# VariMu 1 input

Fairchild/Manley-style tube vari-mu compressor: program-dependent ratio rises with level, and a remote-cutoff tube transfer whose genuine 2nd-harmonic warmth grows as gain reduction biases the tube toward cutoff.

ParamRangeDefaultUnit
Threshold-48 – 0-18dB
Ratio1.5 – 83—
Attack1 – 10020ms
Release50 – 2000400ms
Makeup-6 – 240dB

# Opto 1 input

LA-2A-style optical compressor: a T4 photocell whose photoresistor gain law gives a soft knee and a ratio that rises with level, plus program-dependent release (recovers slower after sustained compression).

ParamRangeDefaultUnit
Threshold-48 – 0-20dB
Ratio2 – 63—
Attack1 – 5010ms
Release50 – 3000600ms
Makeup-6 – 240dB

# FET 1 input

1176-style FET compressor: ultra-fast attack, fixed high ratios, and an asymmetric FET gain cell whose harmonic bite grows with gain reduction (max ratio = all-buttons slam).

ParamRangeDefaultUnit
Threshold-48 – 0-16dB
Ratio4 – 208—
Attack0.02 – 50.5ms
Release20 – 1200200ms
Makeup-6 – 240dB

# SSLBus 1 input

SSL bus-style VCA glue compressor: a dual-time-constant program-dependent auto-release for pumping-free glue, through a dB-linear VCA cell with control-port slew and gain-cell THD that grows with gain reduction.

ParamRangeDefaultUnit
Threshold-40 – 0-14dB
Ratio2 – 104—
Attack0.1 – 3010ms
Release0.1 – 1.20.3s
Makeup-6 – 240dB

# Dbx160 1 input

dbx 160-style VCA compressor: true-RMS detection and an 'over-easy' soft knee through a dB-linear VCA cell with control-port slew and gain-cell THD; punchy and musical.

ParamRangeDefaultUnit
Threshold-40 – 0-18dB
Ratio1 – 204—
Knee0 – 2012dB
Makeup-6 – 240dB

# Distressor 1 input

Distressor-style aggressive compressor: a FET gain cell whose bite grows with gain reduction, switchable harmonic distortion (Dist2 = genuine 2nd, Dist3 = 3rd) and a British-mode all-buttons slam.

ParamRangeDefaultUnit
Threshold-40 – 0-16dB
Ratio1 – 206—
Attack0.05 – 50.5ms
Release20 – 1200150ms
DistClean · Dist2 · Dist3—
BritishOff · On—

# LA3A 1 input

Teletronix LA-3A-style optical compressor: the LA-2A photocell gain law but a fast-attack, brighter solid-state amp - punchier optical leveling with program-dependent release.

ParamRangeDefaultUnit
Threshold-40 – 0-18dB
Ratio2 – 84—
Makeup-6 – 240dB
Mix0 – 11—

# API2500 1 input

API 2500-style VCA bus compressor: a Thrust sidechain tilt with Old (feedback) or New (feedforward) detection, through a dB-linear VCA cell with control-port slew and gain-cell THD.

ParamRangeDefaultUnit
Threshold-40 – 0-14dB
Ratio1.5 – 104—
Attack0.1 – 3010ms
Release50 – 2000300ms
ThrustOff · Med · Loud—
ModeOld · New—

# StaLevel 1 input

Gates Sta-Level-style tube vari-mu limiter: a very slow program-dependent auto-release and gentle ~3:1 leveling through a remote-cutoff tube cell whose 2nd-harmonic warmth (Warmth) grows with gain reduction.

ParamRangeDefaultUnit
Threshold-40 – 0-16dB
Release0 – 10.5—
Makeup-6 – 240dB
Warmth0 – 10.3—

# Neve33609 1 input

Neve 33609-style diode-bridge bus compressor: smooth glue through a diode-bridge gain cell with control-port slew, a dual-time-constant release and transformer saturation.

ParamRangeDefaultUnit
Threshold-40 – 0-16dB
Ratio1.5 – 63—
Attack0.1 – 308ms
Release50 – 2000400ms
Makeup-6 – 240dB

# TubeTech 1 input

Tube-Tech CL 1B-style opto compressor: a photocell gain law (soft knee, rising ratio) with program-dependent release and tube makeup warmth.

ParamRangeDefaultUnit
Threshold-40 – 0-18dB
Ratio1.5 – 104—
Attack5 – 30050ms
Release100 – 50001000ms
Makeup-6 – 240dB

# ShadowHills 1 input

Shadow Hills Mastering-style compressor: a photocell opto stage (soft-knee, rising-ratio law, program-dependent release) into a discrete fixed-ratio VCA stage, with a transformer-flavour select (nickel/iron/steel).

ParamRangeDefaultUnit
Threshold-40 – 0-16dB
Opto Ratio1.5 – 42—
VCA Ratio2 – 83—
Release100 – 2000500ms
XfmrNickel · Iron · Steel—
Makeup-6 – 240dB

# Summit 1 input

Summit TLA-100-style tube/opto leveler: photocell gain law (soft knee, rising ratio) with program-dependent release, transformer warmth and tube makeup.

ParamRangeDefaultUnit
Threshold-40 – 0-18dB
Ratio2 – 104—
Attack1 – 10020ms
Release100 – 3000600ms
Makeup-6 – 240dB

# SCComp 2 inputs

Sidechain compressor: compresses the signal (in 0) by the level of a key input (in 1) through a dB-linear VCA cell with control-port slew and gain-cell THD - cable the host sidechain (SC L/R) to the key for ducking/pumping.

ParamRangeDefaultUnit
Threshold-48 – 0-18dB
Ratio1 – 204—
Attack0.1 – 1005ms
Release1 – 500100ms
Makeup-6 – 240dB

# DynaComp 1 input

MXR Dyna Comp-style OTA pedal compressor (CA3080): a full-wave-rectified envelope drives a high-ratio OTA gain cell for the squishy, sustaining 'country squeeze' - fast clamp, slow bloom, and the signature high-end softening. Sensitivity sets how hard it squeezes, Attack the detector speed, Output the makeup.

ParamRangeDefaultUnit
Sensitivity0 – 10.6—
Attack1 – 506ms
Output-6 – 248dB

# LA2A 1 input

Teletronix LA-2A-style opto leveling amplifier: a T4 electro-optical cell compresses slowly and smoothly with the cell's two-stage, program-dependent release - fast for the first part of recovery, then a long gentle tail - so it sits musically without surgical control. Peak Reduction sets how hard it leans, Gain the makeup, Emphasis tilts the detector toward highs (de-essing).

ParamRangeDefaultUnit
Peak Reduction0 – 10.5—
Gain-6 – 308dB
Emphasis0 – 10.3—

# FATSO 1 input

Empirical Labs FATSO-style warmth/comp: a soft-knee compressor into a tape-style saturation stage (a tilting HF soft-clip) that rounds transients and adds harmonic 'warmth', the way the hardware glues and thickens a mix. Comp sets the squeeze, Warmth the saturation drive, Output the makeup.

ParamRangeDefaultUnit
Comp0 – 10.4—
Warmth0 – 10.3—
Output-6 – 184dB

# Drawmer 1 input

Drawmer DS201-style noise gate: opens fast above Threshold and closes after Release, with hysteresis so it doesn't chatter on the edge. Range sets how far it ducks when closed (hard gate vs gentle expander), Attack the open speed - the studio-standard gate for tightening drums and killing hum between phrases.

ParamRangeDefaultUnit
Threshold-60 – 0-30dB
Range-80 – 0-60dB
Attack0.1 – 501ms
Release5 – 1000120ms

# Audimax 1 input

CBS Audimax-style broadcast AGC: a slow, bidirectional gain-riding automatic level control that holds a target output loudness - boosting quiet material UP and pulling loud material DOWN over seconds, unlike a compressor (downward-only, fast). Its 'platform' gate FREEZES the gain when the program falls silent so it never rides room noise up in the pauses. Target sets the held level, Speed the gain-ride time, Range the maximum boost, Gate the platform threshold.

ParamRangeDefaultUnit
Target0.1 – 0.70.3—
Speed100 – 3000800ms
Range6 – 3018dB
Gate0 – 0.10.01—

# Urei1176 1 input

UREI 1176LN-style FET peak limiter: a field-effect transistor as the variable-gain cell gives the near-instant attack (20 us-800 us) no opto or vari-mu matches, with fixed program ratios and the all-buttons-in mode that slams every ratio at once for the aggressive, distorted British crush. Input drives it into reduction, Attack/Release are the (reversed on the real unit) time constants, Ratio selects 4/8/12/20:1 or All, Output is makeup.

ParamRangeDefaultUnit
Input0 – 4016dB
Attack0.02 – 0.80.1ms
Release50 – 1100250ms
Ratio4:1 · 8:1 · 12:1 · 20:1 · All—
Output-12 – 240dB

# Fairchild670 1 input

Fairchild 670-style vari-mu tube limiter: a remote-cutoff 6386 twin-triode is the gain cell, its mu falling as control bias rises so the ratio is soft and program-dependent, and the 6-position time-constant switch sets attack/release from snappy to molasses. Threshold leans it in, TimeConst picks the program-dependent ballistics, the vari-mu adds gentle glue and tube harmonics, Output is makeup.

ParamRangeDefaultUnit
Threshold-30 – 6-8dB
TimeConst1 · 2 · 3 · 4 · 5 · 6—
Output-6 – 244dB

# Dbx165 1 input

dbx 165-style VCA compressor: true-RMS detection into a dB-linear VCA with the over-easy soft knee, faster and more aggressive than the 160, plus the PeakStop clamp - a click-free output brickwall that stops transients dead. Threshold/Ratio/Knee shape the compression, Makeup the makeup gain.

ParamRangeDefaultUnit
Threshold-40 – 0-16dB
Ratio1 – 308—
Knee0 – 208dB
Makeup-6 – 240dB

# RossComp 1 input

Ross Compressor-style OTA pedal (CA3080): the smoother, longer-sustaining cousin of the Dyna Comp - a softer knee and slower release give singing sustain with less squash and a more open top end. Sustain sets how hard it squeezes, Attack the detector speed, Level the makeup.

ParamRangeDefaultUnit
Sustain0 – 10.6—
Attack2 – 6012ms
Level-6 – 248dB

# dbxNR 1 input

dbx Type II-style companding noise reduction: a 2:1 RMS-compress encode and complementary 1:2 expand decode with HF pre-emphasis - run as one box the two halves track at slightly different speeds, so steady tone passes clean but transients pump and HF content (cymbals) modulates the floor: the signature dbx 'breathing'. Amount sets the companding depth, Emphasis the HF-triggered breathing, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Emphasis0 – 10.5—
Mix0 – 11—

# ContrastEnv 1 input

Amplitude contrast: a power curve applied to the signal's envelope around a reference level pushes loud parts louder and quiet parts quieter (positive) or evens them out (negative), preserving waveform shape.

ParamRangeDefaultUnit
Amount-1 – 10.5—
Ref0.01 – 10.3—
Time1 – 20020ms

# TransientSplit 1 input

Transient designer: a fast minus slow envelope isolates attack vs sustain energy, scaled independently so you can sharpen or soften hits and swell or dampen tails without a threshold.

ParamRangeDefaultUnit
Attack-1 – 10.5—
Sustain-1 – 10—
Time1 – 505ms

# HystGate 1 input

Hysteresis gate: separate open and (lower) close thresholds give Schmitt-trigger immunity to chatter near the threshold, with a smoothed gain ramp so the gate fades rather than clicks.

ParamRangeDefaultUnit
Open0 – 10.1—
Close0 – 10.05—
Smooth1 – 20010ms

# EnvClip 1 input

Adaptive clipper: the soft-clip ceiling follows the signal envelope, so the amount of clipping stays proportional as levels change - consistent grit from quiet to loud passages instead of a fixed wall.

ParamRangeDefaultUnit
Threshold0.02 – 10.5—
Track0 – 10.5—
Time1 – 10020ms
Level0 – 11—

# AmpHold 1 input

Peak-hold envelope: captures the loudest recent peak and holds it, then decays slowly - a control-rate 'freeze the loudness' source for driving other parameters, distinct from a plain release-only follower.

ParamRangeDefaultUnit
Decay1 – 4000300ms
Sens0 – 41—

# TransientGate 1 input

Transient-only gate: passes the signal while the fast envelope outruns the slow one (the attack) and mutes the sustain - isolates clicks / picks / hits, the inverse of a sustain ducker.

ParamRangeDefaultUnit
Sens0 – 10.5—
Time1 – 505ms
Level0 – 11—

# SoftKnee 1 input

Soft-knee compressor: a smooth knee region around the threshold eases gain reduction from 1:1 into the set ratio, so compression blends in gradually instead of switching hard at the threshold.

ParamRangeDefaultUnit
Thresh0.02 – 10.5—
Ratio1 – 204—
Knee0.02 – 10.3—
Time1 – 10010ms

# EnvSwell 1 input

Auto volume swell: a slow-attack envelope suppresses each note's initial transient and fades the body in (the violin bow-swell / no-pick effect), with no pedal or LFO.

ParamRangeDefaultUnit
Time10 – 1000200ms
Depth0 – 11—
Level0 – 11—

# SlewGate 1 input

Self-adjusting gate: the threshold slews toward a slow running average of the level, so the gate auto-tracks a drifting noise floor and opens only on signal that rises above its own recent average.

ParamRangeDefaultUnit
Sens0 – 10.5—
Time1 – 20020ms
Smooth1 – 10010ms

# NoiseGateHF 1 input

High-frequency-keyed gate: triggered by high-band energy (a one-pole high-pass detector), it clamps hiss and cymbal bleed without choking sustained low-frequency tone.

ParamRangeDefaultUnit
Cutoff500 – 80003000Hz
Thresh0 – 0.50.05—
Time1 – 20020ms

# EntropyGate 1 input

Entropy gate: measures zero-crossing density (how noisy vs tonal the signal is) and gates on it, so you can pass tone and mute hiss/noise, or the reverse - a timbre-keyed gate, not a level gate.

ParamRangeDefaultUnit
Thresh0 – 10.4—
Mode0 – 10—
Smooth1 – 10010ms

# SoftExpand 1 input

Soft downward expander: below the threshold the gain falls off by the set ratio (smoothly, not a hard gate), widening dynamic range and pushing low-level noise/bleed down without chopping.

ParamRangeDefaultUnit
Thresh0.01 – 10.3—
Ratio1 – 82—
Time1 – 20020ms

# SubBoost 1 input

Sub-bass synthesizer: isolates the low band and drives it through a soft nonlinearity to regenerate and reinforce the fundamental, adding felt low end on small speakers without just boosting EQ.

ParamRangeDefaultUnit
Freq40 – 16080Hz
Amount0 – 10.6—
Level0 – 10.9—

# EnvGateAR 2 inputs

Gated AR envelope VCA: a second-input gate opens an attack/release envelope that shapes the audio input's level - a self-contained note-on amplitude envelope without a full synth voice.

ParamRangeDefaultUnit
Attack1 – 50010ms
Release1 – 2000200ms
Level0 – 11—

# Sidechain 2 inputs

Sidechain ducker: the audio level is pulled down in proportion to a second input's envelope, the pumping kick-ducks-bass / broadcast voiceover effect, driven by an external key.

ParamRangeDefaultUnit
Amount0 – 10.7—
Time1 – 30050ms

# TransientDesign 1 input

Transient designer: a fast and a slow envelope track the signal; their difference isolates the attack while the slow part is the sustain, so you can punch up or soften each independently - add snap or glue without a threshold.

ParamRangeDefaultUnit
Attack-1 – 10.5—
Sustain-1 – 10—
Level0 – 11—

# DeSibilance 1 input

De-esser: detects energy in a high band (the 's' and 't' sounds) and ducks only that band when it exceeds a threshold, taming harsh sibilance on vocals without dulling the whole signal.

ParamRangeDefaultUnit
Freq2000 – 100006000Hz
Thresh0.01 – 0.50.1—
Amount0 – 10.7—

# CompProg 1 input

Program-dependent compressor: blends a fast and a slow release envelope so brief peaks recover quickly while sustained loud passages release slowly, the auto-release behaviour of classic bus compressors - transparent glue.

ParamRangeDefaultUnit
Thresh0.02 – 10.4—
Ratio1 – 204—
MakeUp1 – 41.4—

# CompUpward 1 input

Upward compressor: instead of pulling loud parts down, it pushes signal below the threshold up, raising low-level detail and ambience - density and presence without limiting the peaks.

ParamRangeDefaultUnit
Thresh0.02 – 10.3—
Amount0 – 10.5—
Time1 – 30030ms

# PeakLimiter 1 input

Peak limiter: gain drops instantly whenever the signal would exceed the ceiling and recovers gradually, holding output below a hard threshold without the slow ratio behaviour of a compressor - transparent loudness control.

ParamRangeDefaultUnit
Ceiling0.1 – 10.8—
Release5 – 50080ms
Gain1 – 81.5—

# AutoGain 1 input

Automatic gain control: tracks the signal's average level and slowly scales it toward a target, evening out long-term loudness swings (quiet passages come up, loud ones come down) the way a broadcast leveler does.

ParamRangeDefaultUnit
Target0.05 – 0.70.3—
Speed50 – 2000400ms
MaxGain1 – 166—

# MultiCompress 1 input

Two-band compressor: splits the signal at a crossover and compresses the low and high bands independently before recombining, so a loud low end stops pumping the highs (and vice versa) - the core of multiband dynamics.

ParamRangeDefaultUnit
Crossover100 – 2000400Hz
Thresh0.02 – 10.4—
Ratio1 – 123—
Time1 – 20030ms

# RmsComp 1 input

RMS compressor: detects level with a root-mean-square window instead of peaks, so gain reduction follows perceived loudness smoothly and ignores brief spikes - the gentle, musical compression of classic RMS-detector units.

ParamRangeDefaultUnit
Thresh0.02 – 10.3—
Ratio1 – 123—
Window5 – 20040ms
MakeUp1 – 41.4—

# TransientSculpt 1 input

Transient designer: a fast and a slow envelope follower track the signal; their difference is the attack and the slow one is the body, letting you boost or cut the punch and the sustain of a sound independently.

ParamRangeDefaultUnit
Attack-1 – 10.5—
Sustain-1 – 10—
Level0 – 21—

# AsymComp 1 input

Asymmetric compressor: independent envelope followers level the positive and negative half-waves with separate ratios, so unequal polarity gains introduce even harmonics and a tube-like asymmetry on top of the leveling - part compressor, part saturator.

ParamRangeDefaultUnit
RatioPos0 – 83—
RatioNeg0 – 81—
Makeup0.5 – 41.5—

# NoiseGateChop 1 input

Chopping gate: while the input sits above threshold it passes clean, but as it falls below the gate chops it with a fast square on/off instead of fading - so decaying tails break into a rhythmic glitchy stutter rather than smoothly muting. Rate sets the chop speed.

ParamRangeDefaultUnit
Thresh0 – 0.50.1—
Rate2 – 5012Hz

# SoftThreshold 1 input

Soft thresholding: the wavelet-denoising shrinkage operator sign(x)*max(|x|-T,0), which subtracts the threshold from the magnitude rather than hard-gating - so signal below T is removed and signal above is passed but pulled down by T, a continuous deadband distinct from a hard noise gate.

ParamRangeDefaultUnit
Thresh0 – 0.50.1—
Makeup0.5 – 41.5—

# LookaheadLimit 1 input

Lookahead limiter: the signal is delayed through a short buffer while the gain is computed from the (still-undelayed) incoming peak, so the gain reduction is already in place when the peak reaches the output - catching transients a feed-forward limiter would overshoot. Release sets the recovery, Thresh the ceiling.

ParamRangeDefaultUnit
Thresh0.1 – 10.7—
Release5 – 20050ms
Makeup0.5 – 41—

# CrestFactor 1 input

Crest-factor follower: tracks the running peak-to-RMS ratio of the input (about 1.4 for a steady sine, ~1 for a square, high for spiky/transient or sparse material) - a control signal measuring how 'peaky' the dynamics are, for transient-aware modulation or auto-dynamics. Time sets the averaging window.

ParamRangeDefaultUnit
Time5 – 500100ms
Scale0 – 20.5—

# EnvSlope 1 input

Envelope slope: outputs the per-sample rate of change of the amplitude envelope - strongly positive on attacks, negative on decays, near zero on steady sustain - a bipolar onset/transient detector and dynamics-derived modulation source. Gain scales the (small) derivative to a usable range.

ParamRangeDefaultUnit
Time1 – 10010ms
Gain1 – 500100—

# FeedbackCompressor 1 input

Feedback-topology compressor: the level detector watches the already-compressed output instead of the input (the classic 1176/opto behavior), so the gain reduction is self-referential - this softens the knee, makes the effective ratio program-dependent, and gives the smoother, 'rounder' character feedback designs are prized for. Threshold, Ratio, Attack/Release in ms, Makeup.

ParamRangeDefaultUnit
Threshold0.02 – 10.3—
Ratio1 – 204—
Attack0.1 – 505ms
Release5 – 500100ms
Makeup0 – 41—

# TruePeakLimit 1 input

True-peak limiter: estimates the inter-sample peak with a 4-point band-limited reconstruction of the midpoint between samples and limits against that, catching the over-0 dBFS overshoots a sample-peak limiter misses and that clip a downstream converter (the ITU-R BS.1770 true-peak concern). Output is one sample delayed so the gain aligns with the reconstructed peak - an inter-sample-aware ceiling, distinct from a plain lookahead limiter. Ceiling sets the ISP ceiling, Release the recovery.

ParamRangeDefaultUnit
Ceiling0.1 – 10.89—
Release5 – 20050ms
Makeup0.5 – 41—

# EnvFollow 1 input

Envelope follower: tracks the rectified amplitude of the input with separate Attack and Release times, outputting a smooth control signal that rises quickly on transients and falls slowly back - the standard way to turn audio into a modulation source. Patch its output into any parameter's mod input so a filter, VCA or effect responds to playing dynamics; Gain scales the result. Unlike the duckers (which bury the follower inside one effect) this exposes the envelope itself.

ParamRangeDefaultUnit
Attack0.1 – 2005ms
Release1 – 1000100ms
Gain0 – 81—

# NoiseGate 1 input

Noise gate: passes the in0 audio only while its level is above Threshold, otherwise silences it - cleans up hiss, bleed and tails between notes. A peak follower with a Release time smoothly opens and closes the gate so it doesn't chatter.

ParamRangeDefaultUnit
Threshold0 – 10.1—
Release1 – 2000150ms

# Envelope 1 input

Envelope follower that rectifies the input and smooths it with independent Attack and Release times into a control signal. Gain scales the output for driving a filter cutoff, VCA or any mod input (auto-wah, ducking, dynamics). Fast attack tracks transients; a longer release gives a smoother contour.

ParamRangeDefaultUnit
Attack0.1 – 2005ms
Release1 – 100080ms
Gain0 – 81—

# Compressor 1 input

Peak-following compressor: tracks the input envelope with Attack/Release ballistics and, above Threshold, reduces gain by the set Ratio, with Makeup to restore level. Fast attack tames transients while slow release glues sustained material. A clean general-purpose dynamics stage - see the analog pack (FET, Opto, VariMu) for coloured compression.

ParamRangeDefaultUnit
Threshold-60 – 0-18dB
Ratio1 – 204—
Attack0.1 – 1005ms
Release1 – 50080ms
Makeup-12 – 240dB

# ParallelComp 1 input

Parallel (New York) compression: a heavily-compressed copy is blended back UNDER the dry signal, so the transients and peaks stay intact while the body and low-level detail are lifted - punch and density without squashing the dynamics (the drum-bus / mix-bus trick). Distinct from a normal compressor, which replaces the signal: here the crush sits in parallel. Threshold/Ratio set the parallel crush, Attack/Release its ballistics, Makeup the parallel gain, Blend how much of the compressed copy is mixed under the dry.

ParamRangeDefaultUnit
Threshold-60 – 0-32dB
Ratio1 – 2010—
Attack0.1 – 1003ms
Release1 – 500120ms
Makeup-12 – 246dB
Blend0 – 10.5—

# ZeroCrossGate 1 input

Zero-cross gate: a noise gate that only ever opens or closes AT a zero crossing of the signal, so it never produces the click a normal gate makes when it slams shut mid-waveform. The gate decision is latched at each crossing from the envelope vs Threshold. Click-free gating for harsh, percussive, or already-distorted material. Threshold sets the open level, Mix the blend.

ParamRangeDefaultUnit
Threshold-60 – 0-30dB
Mix0 – 11—

# MaskGate 1 input

Temporal masking gate: a loud event briefly DEAFENS the block to what follows, modelling forward auditory masking - quiet detail in the wake of a transient is pushed down (the ear can't hear it anyway), tightening busy material and emphasising the hits. Distinct from a normal gate: the threshold is set by the recent loudest peak, not a fixed level. Amount sets the masking depth, Hold the masking time, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.6—
Hold5 – 20060ms
Mix0 – 11—

# RateGate 1 input

Slew gate: opens on MOTION, not loudness - it passes signal only while its rate of change (slew) is high, so fast transients and bright content get through while slow, steady tones are gated out. A movement-sensitive gate that does the opposite of a sustain pedal: keeps the attacks, drops the drones. Threshold sets the motion needed, Mix the blend.

ParamRangeDefaultUnit
Threshold0.001 – 0.20.02—
Mix0 – 11—

# Splat 1 input

Splat: a transient that crosses the threshold briefly blows the gain into hard saturation, then recovers - so big hits 'splat' with a momentary overdriven smear before settling clean, the overshoot artifact of a slamming converter or a maxed preamp. Thresh sets the trigger, Amount the splat heat, Mix the blend.

ParamRangeDefaultUnit
Thresh0 – 0.50.15—
Amount0 – 10.6—
Mix0 – 11—

# Choke 1 input

Choke gate: every new onset slams the gain shut for a brief window, killing whatever tail was still ringing - the hi-hat choke, applied to anything. Successive hits clamp each other off into a tight, staccato, gasping rhythm. Time sets the choke window, Mix the blend.

ParamRangeDefaultUnit
Time2 – 8020ms
Mix0 – 11—

# Inflate 1 input

Inflate: a psychoacoustic loudness exciter - a gentle cubic curve that lifts the body and harmonics of the signal so it sounds bigger and louder without raising the peak level. The 'inflator' move for making a mix feel fuller. Amount sets the inflation, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.6—
Mix0 – 11—

# Deflate 1 input

Deflate: the opposite of an inflator - a cubic curve that sucks the body out of low-level signal so quiet detail shrinks back and the sound feels smaller, thinner and pulled-in. Use it to deflate an over-full source or for a claustrophobic effect. Amount sets the deflation, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.6—
Mix0 – 11—

# ThyratronZap 1 input

Thyratron latch: a gas-tube trigger that FIRES when the input crosses a strike level and stays latched on - passing full signal - until the level falls below a lower hold point, then snaps off. A latching, hysteretic on/off zap that holds a note open after a hit. Strike sets the fire level, Hold the drop-out level, Mix the blend.

ParamRangeDefaultUnit
Strike0.05 – 0.80.3—
Hold0.01 – 0.50.08—
Mix0 – 11—

# GateBounce 1 input

Contact bounce: when the gate opens it chatters - a few fast random on/off bounces before it settles, the way a mechanical relay or switch contact bounces on closing. Adds a glitchy, machine-gun stutter to every note onset. Bounce sets how much it chatters, Mix the blend.

ParamRangeDefaultUnit
Bounce0 – 10.5—
Mix0 – 11—

# VarianceGate 1 input

Variance gate: opens not on loudness but on COMPLEXITY - it tracks the short-term variance (the energy of the fluctuation around the local mean) and passes only when the signal is busy/noisy, muting steady tones and DC-like calm. A texture-sensitive gate. Threshold sets the activity needed, Mix the blend.

ParamRangeDefaultUnit
Threshold0.001 – 0.10.01—
Mix0 – 11—

# PercentileGate 1 input

Percentile gate: the threshold is not fixed - it slowly tracks the signal's own loud peaks, so the gate passes only the top fraction of dynamics and adapts as the material gets louder or softer over time. Self-calibrating, unlike a fixed-dB gate. Open sets how much of the top passes, Mix the blend.

ParamRangeDefaultUnit
Open0 – 0.90.4—
Mix0 – 11—

# Gate 1 input

Noise gate: when the detected level falls below Threshold it attenuates the signal toward Range (the floor), opening and closing with Attack/Release ballistics. Range at -80 dB fully mutes between events; smaller values leave a residual for gentler ducking. Use it to silence hiss and bleed between phrases or for rhythmic gating.

ParamRangeDefaultUnit
Threshold-80 – 0-40dB
Attack0.1 – 501ms
Release1 – 500100ms
Range-80 – 0-80dB

# Limiter 1 input

Brick-wall peak limiter: instantly clamps gain so peaks never exceed Threshold, then releases smoothly back to unity over Release, with Output trimming the post-limit level. Set Threshold as the ceiling and drive the input for transparent loudness. See Maximizer for loudness-optimized limiting.

ParamRangeDefaultUnit
Threshold-24 – 00dB
Release1 – 50050ms
Output-12 – 120dB

# Transient 1 input

Transient shaper: a fast vs slow envelope follower separates the attack (fast > slow) from the sustain (fast < slow), letting Attack and Sustain each be boosted or cut independently, with Output trimming the result. Add punch to drums, or tighten/lengthen sustain - all independent of input level, unlike a compressor.

ParamRangeDefaultUnit
Attack-1 – 10.3—
Sustain-1 – 10—
Output-12 – 120dB

# Expander 1 input

Downward expander: attenuates signal that falls below Threshold by the set Ratio (the inverse of a compressor), tightening quiet passages and reducing bleed and hiss between notes. Attack/Release set the ballistics. Gentler than a gate - it fades low-level material rather than hard-muting it.

ParamRangeDefaultUnit
Threshold-60 – 0-40dB
Ratio1 – 102—
Attack0.1 – 1005ms
Release1 – 500100ms

# MultiComp 1 input

Three-band compressor: crossovers split the signal into low, mid and high bands (Low/Mid and Mid/High), each compressed independently against a shared Threshold and Ratio with fast-attack/slow-release ballistics, then summed with Makeup. Tame a busy mix's bands separately - control boomy lows without dulling the highs. See the SSL/dbx analog models for coloured bus compression.

ParamRangeDefaultUnit
Low/Mid100 – 1000300Hz
Mid/High1000 – 120003000Hz
Threshold-48 – 0-18dB
Ratio1 – 204—
Makeup-12 – 240dB

# DeEsser 1 input

Tames sibilance by splitting off a high band with a one-pole low-pass, tracking its level with a fast-attack envelope, and applying gain reduction to that band only when it crosses the threshold before recombining it with the lows. Freq sets the sibilance band, Threshold sets where reduction begins, Amount scales how hard the high band is pulled down, and Mix sets dry/wet. Because only the highs are compressed, it removes harsh esses without dulling the rest of the signal.

ParamRangeDefaultUnit
Freq2000 – 120006000Hz
Threshold-60 – 0-24dB
Amount0 – 10.7—
Mix0 – 11—

# Ducker 2 inputs

Sidechain ducker that follows the level of the key input (in 2) with a release-smoothed envelope and pulls down the main signal whenever that key exceeds the threshold. Threshold sets the key level that triggers ducking, Amount sets how far the main signal drops, and Release sets how quickly it recovers once the key falls back. Use it for music-under-voice ducking or rhythmic pumping driven by a separate trigger.

ParamRangeDefaultUnit
Threshold-60 – 0-30dB
Amount0 – 10.8—
Release10 – 1000200ms

# Maximizer 1 input

Loudness maximizer that applies a gain boost, tracks the peak envelope, and divides back any sample exceeding the ceiling before hard-clamping to it, acting as a brick-wall limiter. Boost sets how hard the input is driven up and Ceiling sets the absolute output peak in dB. Push Boost while keeping Ceiling near 0 dB to raise apparent loudness without overshooting the output.

ParamRangeDefaultUnit
Boost0 – 246dB
Ceiling-12 – 0-0.3dB

# UpComp 1 input

Upward compressor that tracks the input envelope and, when it sits below the threshold, applies makeup gain proportional to how far below it is and to the ratio, lifting quiet passages toward the threshold. Threshold sets the level below which boosting begins, Ratio sets how aggressively the deficit is filled, Makeup adds a fixed output gain, and Mix sets dry/wet. Use it to raise low-level detail and tighten dynamic range from the bottom up rather than taming peaks.

ParamRangeDefaultUnit
Threshold-60 – 0-30dB
Ratio1 – 82—
Makeup0 – 240dB
Mix0 – 11—

# DynEQ 1 input

Dynamic EQ band: an SVF band-pass at Freq/Q tracks an envelope follower, and when that band's energy crosses Threshold the band is subtracted from the signal in proportion to Amount. Freq and Q place and narrow the band, Threshold sets where reduction begins, and Mix blends the result against dry. It only acts when the band gets loud, so it tames resonances and harshness without static EQ cuts.

ParamRangeDefaultUnit
Freq100 – 120002000Hz
Q0.5 – 82—
Threshold-60 – 0-24dB
Amount0 – 10.7—
Mix0 – 11—

# MBDynamics 1 input

Multiband dynamics processor that splits the input into low, mid and high bands (crossovers near 250 Hz and 2.5 kHz) and applies independent compression and gating to each. Threshold sets the level above which a band is compressed at Ratio, while Gate sets the level below which a band is attenuated downward. Mix blends the processed sum against the dry signal, useful for tightening or de-noising specific frequency regions at once.

ParamRangeDefaultUnit
Threshold-60 – 0-24dB
Ratio1 – 203—
Gate-80 – -20-60dB
Mix0 – 11—

# Pump 1 input

Tempo-synced sidechain-style volume pump that ducks the input each cycle and recovers using a sample-clock phase for coherent timing. Rate sets the duck frequency in Hz, Depth sets how far the level drops, and Curve shapes the recovery ramp from snappy to gradual. Mix blends the pumped signal against the dry input for the classic EDM ducking effect without an external sidechain.

ParamRangeDefaultUnit
Rate0.1 – 82Hz
Depth0 – 10.8—
Curve0.2 – 41.5—
Mix0 – 11—

# Squash 1 input

Aggressive parallel smash: a fast peak-following envelope drives heavy gain reduction above a fixed threshold, and the gain-reduced signal is pushed through a tanh saturator for crushed, distorted dynamics. Amount steepens the gain-reduction curve (harder squash), Tone scales the saturated output level, and Mix blends the smashed signal in parallel with the dry input. Useful for adding punch and grit to drums and bus material.

ParamRangeDefaultUnit
Amount0 – 10.7—
Tone0 – 10.5—
Mix0 – 10.5—

# OTT 1 input

Over-the-top multiband compressor (Xfer OTT-style): splits the signal into low / mid / high bands and applies BOTH downward and upward compression to each at once - loud parts are pulled down and quiet detail is pushed up - for the dense, controlled, minimal-dynamic-range sound on modern EDM / dubstep / future-bass synths and drums. Depth sets how hard the up + down compression bites (the OTT % knob), Time the attack/release across all bands (fast = tight, slow = more transient), Low / Mid / High trim each band's output in dB, and Mix blends against dry. Unlike MultiComp / MBDynamics this also compresses upward (raises the quiet parts), which is what gives OTT its signature.

ParamRangeDefaultUnit
Depth0 – 10.6—
Time0 – 10.5—
Low-12 – 120dB
Mid-12 – 120dB
High-12 – 120dB
Mix0 – 11—

# Velocity 1 input

Scales and offsets note velocity, with a modulation amount.

ParamRangeDefaultUnit
Scale0 – 21—
Offset-64 – 640—
Mod Amt-64 – 640—

# VelCurve 1 input

Reshapes velocity through a power curve.

ParamRangeDefaultUnit
Curve0.2 – 51—

# Humanize 1 input

Adds random timing and velocity jitter for a human feel.

ParamRangeDefaultUnit
Timing0 – 508ms
Velocity0 – 10.3—

# Accent 1 input

Boosts velocity on every Nth note.

ParamRangeDefaultUnit
Every1 – 164—
Amount0 – 10.5—

# VelClip 1 input

Clamps velocity between Min and Max.

ParamRangeDefaultUnit
Min1 – 1271—
Max1 – 127127—

# Ramp 1 input

Velocity ramp over a run of notes, ascending or descending.

ParamRangeDefaultUnit
Length2 – 168—
Depth0 – 10.6—
DirectionUp · Down—

# VelCompress 1 input

Velocity compressor: velocities above Threshold are pulled toward it by Ratio (1 = off, 8 = hard), narrowing the dynamic range smoothly instead of hard-clamping like VelClip.

ParamRangeDefaultUnit
Threshold1 – 12764—
Ratio1 – 82—

# VelInvert 1 input

Flips the velocity scale around its midpoint (soft <-> loud) by Amount, so your accents become ghost notes and the ghosts become accents - a velocity mirror, blendable to taste.

ParamRangeDefaultUnit
Amount0 – 11—

# VelKey 1 input

Keyboard velocity tracking: scales each note's velocity by how far its pitch sits from a Center note, Tilt setting how strongly and which way - higher notes louder (or softer), the dynamic key-tracking of real instruments.

ParamRangeDefaultUnit
Center0 – 12760—
Tilt-1 – 10.5—

# VelLength 1 input

Note duration scales with velocity: hard notes ring for Max ms, soft notes for Min (set Max < Min to make accents staccato) - the played articulation where dynamics shape note length.

ParamRangeDefaultUnit
Min1 – 200060ms
Max1 – 2000500ms

# GoldenVel 1 input

Golden velocity: replaces each note's velocity with a value from the golden-ratio low-discrepancy sequence, which fills the dynamic range far more evenly than random, so accents never clump; Depth blends it against the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# RudinShapiroAccent 1 input

Rudin-Shapiro accent: pushes each note's velocity up or down by the +/-1 Rudin-Shapiro sequence of its count, an aperiodic accent pattern with a famously flat (white-like) spectrum - structured stress that never repeats predictably.

ParamRangeDefaultUnit
Amount0 – 6324—

# FibVelocity 1 input

Fibonacci velocity: drives note velocity from the Fibonacci sequence taken modulo 128, climbing then wrapping in the golden cadence; Depth blends the pattern against the incoming velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelDrift 1 input

Velocity drift: each note's velocity takes one step of a bounded random walk, so dynamics wander smoothly and correlatedly over time instead of jumping independently like Humanize - the slow swell and ebb of a tiring player.

ParamRangeDefaultUnit
Step0 – 10.3—

# VelGate 1 input

Velocity gate: drops any note whose velocity falls outside the Min..Max window, so only soft (or only hard) hits pass - a dynamics-dependent filter for splitting ghosted from accented playing.

ParamRangeDefaultUnit
Min1 – 1271—
Max1 – 127127—

# CrescendoLoop 1 input

Crescendo loop: velocity climbs from Min to Max across Length notes then snaps back and repeats, an automatic sawtooth dynamic swell driven by the note count rather than the clock.

ParamRangeDefaultUnit
Length2 – 328—
Min1 – 12730—
Max1 – 127120—

# VelByPitch 1 input

Velocity by pitch: sets each note's velocity from its keyboard position (a Slope per semitone around middle C plus a Base), so high notes can ring louder or softer - keyboard-position dynamics.

ParamRangeDefaultUnit
Slope-3 – 31—
Base1 – 12780—

# ZipfVelocity 1 input

Zipf velocity: draws each note's velocity from a Zipf (1/rank) distribution, so a few dynamic levels dominate and loud accents are rare - the power-law dynamics of natural performance; Depth blends it against the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PrimeVelocity 1 input

Prime velocity: drives velocity from the gaps between successive prime numbers, an irregular yet deterministic accent sequence that never settles into an obvious loop; Depth blends it with the incoming velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelStep 1 input

Velocity step: quantizes velocity to a small number of levels (a dynamics bit-crush), flattening expressive playing into stepped terraces from gentle 8-level to brutal 2-level.

ParamRangeDefaultUnit
Levels2 – 164—

# AccentPattern 1 input

Accent pattern: boosts velocity on the on-steps of a 16-step accent bitmask and trims it elsewhere, stamping a repeating dynamic groove onto an even stream of notes.

ParamRangeDefaultUnit
Pattern0 – 6553534953—
Amount0 – 6324—

# ThueMorseVelocity 1 input

Thue-Morse velocity: alternates two velocity levels by the cube-free Thue-Morse parity of the note count, accenting in a self-similar, never-quite-repeating pattern instead of a simple every-other.

ParamRangeDefaultUnit
Low1 – 12750—
High1 – 127110—

# CollatzVelocity 1 input

Collatz velocity: maps each note's velocity to the number of 3n+1 steps its count takes to reach 1, an erratic deterministic accent sequence from the unsolved conjecture; Depth blends against the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DigitSumVelocity 1 input

Digit-sum velocity: derives velocity from the decimal digit-sum of the note count, a self-similar sawtooth-of-sawtooths accent that resets every power of ten; Depth blends it with the incoming velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# HarmonicVelocity 1 input

Harmonic velocity: shapes velocity along a 1/(k+1) harmonic-decay curve over a repeating Length-note cycle, so each phrase opens strong and tapers - an automatic accent-and-decay groove.

ParamRangeDefaultUnit
Length2 – 164—
Base1 – 127110—

# DivisorCountVelocity 1 input

Divisor-count velocity: makes notes louder on counts with many divisors, so highly-composite ordinals (12, 24, 36...) land as accents and primes stay quiet; Depth blends against the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# TotientVelocity 1 input

Totient velocity: drives velocity from Euler's totient ratio phi(n)/n of the count, dipping on numbers rich in small prime factors and peaking on primes - a number-theoretic accent contour; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# OmegaVelocity 1 input

Omega velocity: sets velocity from the number of prime factors (with multiplicity) of the count, so smooth primes play soft and factor-heavy numbers play hard; Depth blends it with the incoming velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PitchClassVelocity 1 input

Pitch-class velocity: accents every note of a chosen pitch class and softens the rest, so a tonic or any scale degree rings out across the whole keyboard - a harmonic spotlight on one note name.

ParamRangeDefaultUnit
ClassC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Amount0 – 6324—

# IntervalVelocity 1 input

Interval velocity: sets each note's velocity from the size of its leap from the previous note, so wide jumps hit hard and stepwise motion stays gentle - dynamics that follow the melodic contour; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# RepeatDecay 1 input

Repeat decay: each immediate repetition of the same note plays quieter by a decay factor, taming machine-gun retriggers into a natural fade and resetting the moment the pitch changes.

ParamRangeDefaultUnit
Decay0.3 – 0.990.8—

# BinaryWeightVelocity 1 input

Binary-weight velocity: drives velocity from the number of 1-bits (Hamming weight) in the note count, a self-similar accent pattern that pulses with the binary structure of the ordinal; Depth blends it with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# RulerVelocity 1 input

Ruler velocity: accents notes by the ruler sequence (the power of two dividing the count: 0,1,0,2,0,1,0,3,...), so every other note is a light tick and the downbeats of each binary level land harder - a self-similar metric accent.

ParamRangeDefaultUnit
Depth0 – 11—

# SternBrocotVelocity 1 input

Stern-Brocot velocity: shapes velocity from Stern's diatomic (fusc) sequence, the fractal numerators of the Stern-Brocot tree of rationals, giving a self-similar sawtooth-of-sawtooths accent; Depth blends with the incoming velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelocityLFO 1 input

Velocity LFO: sweeps velocity up and down with a slow sine over a set number of notes, an automatic dynamic swell-and-fade that breathes life into a flat sequence; Depth sets how deep the swell.

ParamRangeDefaultUnit
Period2 – 6416—
Depth0 – 6330—

# SwingVelocity 1 input

Swing velocity: accents on-beat notes and softens off-beat ones, applying the dynamic side of a swing/shuffle feel (the loud-soft alternation) independent of timing - instant groove from even input.

ParamRangeDefaultUnit
Amount0 – 6320—

# GoldenSectionAccent 1 input

Golden-section accent: places a strong accent at the start and at the golden-ratio point (~0.618) of a repeating cycle, an aesthetically-balanced asymmetric stress pattern instead of an even backbeat.

ParamRangeDefaultUnit
Length3 – 328—
Amount0 – 6328—

# ZeckendorfVelocity 1 input

Zeckendorf velocity: accents each note by how many Fibonacci numbers it takes to sum to the note count (its Zeckendorf representation length), a number-theoretic accent that grows in golden steps; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelocitySmooth 1 input

Velocity smooth: glides each note's velocity toward a running average of the recent ones, ironing out wild dynamic jumps into an even, controlled performance; Amount sets how strongly it pulls toward the average.

ParamRangeDefaultUnit
Amount0 – 10.6—

# MarkovVelocity 1 input

Markov velocity: walks the velocity through a near-neighbour Markov chain of levels, so dynamics drift coherently (mostly small changes, occasional leaps) rather than jumping randomly - a stochastic but musical accent contour.

ParamRangeDefaultUnit
Levels3 – 126—
Wander0 – 10.4—

# EuclideanVelocity 1 input

Euclidean velocity: accents the notes that fall on the onsets of a Euclidean rhythm of Pulses-in-Steps and softens the rest, stamping a maximally-even world-rhythm groove onto the dynamics.

ParamRangeDefaultUnit
Pulses1 – 165—
Steps1 – 168—
Amount0 – 6328—

# VelGateHysteresis 1 input

Velocity Schmitt gate: opens once a note exceeds the High velocity and stays open until one drops below Low, so soft passages between accents either all pass or all mute - hysteretic dynamic gating that avoids chattering at the threshold.

ParamRangeDefaultUnit
High1 – 12790—
Low1 – 12750—

# KolakoskiVelocity 1 input

Kolakoski velocity: alternates two velocity levels following the self-describing Kolakoski sequence (whose run-lengths are the sequence itself), giving a hypnotically self-similar yet non-repeating accent pattern.

ParamRangeDefaultUnit
Low1 – 12750—
High1 – 127110—

# MoebiusVelocity 1 input

Moebius velocity: accents notes by the Moebius function of the count - loud on squarefree numbers with an even number of prime factors, soft on odd, and mid-level on square-divisible ones; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PadovanVelocity 1 input

Padovan velocity: steps velocity through the Padovan sequence (P(n)=P(n-2)+P(n-3), the plastic-number recurrence) taken modulo a range, a slow, gently-rolling accent contour; Depth blends with the incoming velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# LucasVelocity 1 input

Lucas velocity: steps velocity through the Lucas numbers (the Fibonacci companion 2,1,3,4,7,11,...) taken modulo a range, a golden-cadence accent contour; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# GcdVelocity 1 input

GCD velocity: sets velocity from the greatest common divisor of the note count and a modulus, so counts sharing big factors with the modulus hit harder - a quietly-periodic, factor-driven accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Modulus2 – 2412—
Depth0 – 11—

# PrimeCountVelocity 1 input

Prime-count velocity: drives velocity from the prime-counting function pi(count) - how many primes are at or below the note count - taken modulo a span, a slowly-climbing-then-wrapping accent rooted in the distribution of primes.

ParamRangeDefaultUnit
Depth0 – 11—

# MelodicAccent 1 input

Melodic accent: accents notes that step up from the previous one and softens those that step down, so the dynamics follow the rise and fall of the melodic contour - phrasing that breathes with the line.

ParamRangeDefaultUnit
Amount0 – 6320—

# VelocityFloor 1 input

Velocity floor: lifts any note played softer than the floor up to it, guaranteeing every note speaks at a minimum level - a reverse noise gate for taming ghost notes and uneven controllers.

ParamRangeDefaultUnit
Floor1 – 12740—

# VelocityExpand 1 input

Velocity expand: pushes velocities away from the mid-level (the opposite of compression), so soft notes get softer and loud notes louder - widening the dynamic range of a flatly-played or over-quantized part.

ParamRangeDefaultUnit
Ratio1 – 31.5—

# AccentEveryN 1 input

Accent every N: boosts the velocity of every Nth note and slightly ducks the rest, stamping a steady metric downbeat onto an even stream - the simplest way to imply a time signature in the dynamics.

ParamRangeDefaultUnit
N2 – 164—
Amount0 – 6328—

# GhostNoteInject 1 input

Ghost-note inject: randomly demotes a fraction of notes to a soft 'ghost' level, scattering the quiet in-between hits that give drum and bass parts their human, shuffling feel.

ParamRangeDefaultUnit
Probability0 – 10.3—
GhostVel1 – 8030—

# DigitalRootVelocity 1 input

Digital-root velocity: accents each note by the digital root (the repeated digit-sum, 1..9) of its count, a perfectly periodic nine-step accent staircase from elementary number theory; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# AbundancyVelocity 1 input

Abundancy velocity: drives velocity from the abundancy index sigma(n)/n of the count - near 1 for primes, climbing past 2 for perfect and abundant numbers - so divisor-rich counts hit hardest; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PrimeFactorVelocity 1 input

Prime-factor velocity: sets velocity from the largest prime factor of the count (log-scaled), so prime counts ring loud and smooth, small-factored counts stay soft; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# SquareDistanceVelocity 1 input

Square-distance velocity: accents notes by how close the count sits to a perfect square - loud right on the squares, fading in the gaps - a pulsing accent that widens as the squares spread apart; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelocityRandomScale 1 input

Velocity random scale: multiplies each note's velocity by an independent random gain, scattering the dynamics for a more human, less machine-perfect feel (timing untouched, unlike Humanize); Amount sets the scatter width.

ParamRangeDefaultUnit
Amount0 – 10.3—

# HappyVelocity 1 input

Happy velocity: accents each note by how its count behaves under the happy-number process (sum of squared digits) - loud and bright if it reaches 1, darker if it falls into the sad cycle; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# KaprekarVelocity 1 input

Kaprekar velocity: drives velocity from how many digit-sort-and-subtract steps the count takes to reach Kaprekar's constant 6174, an erratic 0-7 accent from a famous digit routine; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# CatalanVelocity 1 input

Catalan velocity: steps velocity through the Catalan numbers (1,1,2,5,14,42,...) taken modulo a range, the combinatorial sequence counting balanced brackets and binary trees; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DigitReverseVelocity 1 input

Digit-reverse velocity: drives velocity from the count read backwards (123 becomes 321), an erratic accent that scrambles the steady climb of the counter into a jumpy pattern; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PersistenceVelocity 1 input

Persistence velocity: accents each note by the multiplicative-persistence depth of its count (how many digit-product steps reach a single digit), a sparse, spiky accent rooted in a famous open digit problem; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# GrayCodeVelocity 1 input

Gray-code velocity: drives velocity from the reflected-binary Gray code of the note count (successive values differ by one bit), giving a smoothly-rotating, single-step-change accent pattern; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# FactorialBaseVelocity 1 input

Factorial-base velocity: accents each note by the digit-sum of its count written in the factorial number system (where place values are 1!,2!,3!,...), an exotic mixed-radix accent contour; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# ScaleHighlight 1 input

Scale highlight: accents notes that belong to the chosen Root/Scale and softens the chromatic outsiders, spotlighting the key without removing any notes - a scale-aware dynamic emphasis.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Amount0 – 6324—

# ThueMorseTernaryVel 1 input

Ternary Thue-Morse velocity: picks one of three velocity levels from the base-3 Thue-Morse sequence (digit-sum mod 3) of the count, a self-similar three-level accent that avoids short repeats; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# BernoulliSignVelocity 1 input

Bernoulli-sign velocity: alternates two velocity levels by the sign of the Bernoulli numbers (the alternating-sign even-index sequence from number theory and calculus), with a neutral level on the zero-valued odd indices.

ParamRangeDefaultUnit
Low1 – 12750—
High1 – 127110—

# LookSayVelocity 1 input

Look-and-say velocity: drives velocity from the growing length of the look-and-say sequence (1, 11, 21, 1211, ...) at the note count, a self-describing sequence that lengthens by Conway's constant; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# SigmaVelocity 1 input

Sigma velocity: drives velocity from sigma(count), the sum of all divisors of the note count, so highly-divisible counts hit harder - an accent contour straight out of number theory; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# RadicalVelocity 1 input

Radical velocity: accents each note by the radical of its count (the product of its distinct prime factors), so squarefree counts read high and prime-power counts read low; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# HammingDistanceVelocity 1 input

Hamming-distance velocity: drives velocity from how many bits flip between successive note counts (the Hamming distance of consecutive integers), a small spiky accent that jumps at binary carries; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# UnitaryDivisorVelocity 1 input

Unitary-divisor velocity: accents each note by the sum of its count's unitary divisors (divisors that share no factor with their cofactor), a coprime-divisor variant of the sigma accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# EuclideanAccentVelocity 1 input

Euclidean accent: boosts the velocity of notes landing on a Euclidean (Bjorklund) rhythm and softens the rest, stamping an evenly-distributed accent groove onto a steady stream of notes without dropping any.

ParamRangeDefaultUnit
Pulses1 – 325—
Steps1 – 328—
Amount0 – 6328—

# AliquotVelocity 1 input

Aliquot velocity: drives velocity from the aliquot sum (the sum of a number's proper divisors) of the note count, the quantity behind perfect, abundant and deficient numbers; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# MobiusVelocity 1 input

Moebius velocity: picks one of three velocity levels from the Moebius function mu of the count - high for squarefree-even-factor counts, low for squarefree-odd, neutral for counts with a squared factor - a number-theoretic three-state accent.

ParamRangeDefaultUnit
Low1 – 12745—
High1 – 127110—

# PrimeGapVelocity 1 input

Prime-gap velocity: drives velocity from the size of the prime gap bracketing the note count (the distance between the primes just below and just above it), so notes near large prime deserts hit harder; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# CototientVelocity 1 input

Cototient velocity: accents each note by the cototient n minus Euler's totient (the count of integers up to n that share a factor with it), a divisor-flavoured accent complementary to the totient; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PellVelocity 1 input

Pell velocity: drives velocity from the Pell numbers (P(n)=2P(n-1)+P(n-2): 1,2,5,12,29,70,...), the silver-ratio cousin of Fibonacci; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# WythoffVelocity 1 input

Wythoff velocity: drives velocity from the lower Wythoff sequence floor(n*phi) (the golden Beatty sequence, the winning positions of Wythoff's game: 1,3,4,6,8,9,11,...); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# SternDiatomicVelocity 1 input

Stern-diatomic velocity: accents each note by Stern's diatomic (fusc) sequence 1,1,2,1,3,2,3,1,4,... whose consecutive ratios enumerate every rational once (the Stern-Brocot tree); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# BeattyVelocity 1 input

Beatty velocity: drives velocity from the Beatty sequence floor(n*sqrt2) (an irrational-rotation staircase that, with its complement, partitions the integers); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# BackbeatAccent 1 input

Backbeat accent: boosts the velocity of notes on beats 2 and 4 (the backbeat) and slightly softens the others, stamping the rock/pop snare-accent feel onto a flat stream without dropping notes.

ParamRangeDefaultUnit
Amount0 – 6328—

# ScaleDegreeAccent 1 input

Scale-degree accent: accents notes by their function in the key - tonic loudest, then fifth and third, with weak and chromatic degrees softened - carving a dynamic shape that follows the harmony.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Amount0 – 6324—

# RegisterAccent 1 input

Register accent: boosts the velocity of notes inside a Low..High pitch window and softens those outside, spotlighting one register's dynamics without dropping any notes.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—
Amount0 – 6324—

# TurnaroundAccent 1 input

Turnaround accent: boosts the velocity of notes that are local melodic turning points - the peaks and valleys where the line changes direction - emphasising the contour's corners.

ParamRangeDefaultUnit
Amount0 – 6328—

# PrimeIndexAccent 1 input

Prime-index accent: accents the prime-numbered notes in the stream (the 2nd, 3rd, 5th, 7th, 11th, ... to pass) and softens the rest, an irregular number-theoretic accent pattern.

ParamRangeDefaultUnit
Amount0 – 6324—

# PopcountVelocity 1 input

Popcount velocity: drives velocity from the number of 1-bits in the note count (its binary Hamming weight), a jagged bit-pattern accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# TrailingOnesVelocity 1 input

Trailing-ones velocity: accents each note by how many 1-bits trail at the bottom of its binary count (0,1,0,2,0,1,0,3,...), a carry-driven spiky pattern; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# ReverseBitsVelocity 1 input

Bit-reverse velocity: drives velocity from the 8-bit bit-reversal of the note count, scrambling the steady counter into the scattered order used by FFT bit-reversal; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DigitProductVelocity 1 input

Digit-product velocity: accents each note by the product of its count's decimal digits, so counts with big digits hit hard and those with small digits stay soft; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# AlternatingSumVelocity 1 input

Alternating-sum velocity: drives velocity from the alternating digit sum of the count (the signed digit total behind the divisible-by-11 test), an oscillating accent contour; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DistinctPrimeVelocity 1 input

Distinct-prime velocity: accents each note by little-omega, the number of distinct prime factors of its count (primes softest, highly-composite counts loudest); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# JacobiVelocity 1 input

Jacobi-symbol velocity: picks one of three velocity levels from the Jacobi symbol of the count over an odd Modulus (+1, -1 or 0), a quadratic-residue signature from number theory; the modulus sets the pattern's period.

ParamRangeDefaultUnit
Modulus3 – 9915—
Low1 – 12745—
High1 – 127110—

# SmoothnessVelocity 1 input

Smoothness velocity: drives velocity from the largest prime factor of the note count, so smooth (small-factor) counts read soft and prime counts read loud; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# RoughnessVelocity 1 input

Roughness velocity: drives velocity from the smallest prime factor of the note count, the complement of smoothness, so even counts read low and prime-like counts read high; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelocityGammaCurve 1 input

Velocity gamma curve: reshapes velocity through a gamma transfer curve - values below 1 lift soft notes and compress dynamics, above 1 push them down and expand - a smooth nonlinear dynamics bend.

ParamRangeDefaultUnit
Gamma0.2 – 51—

# VelocityRandomWalk 1 input

Velocity random walk: nudges velocity by a smoothed, bounded random walk so the dynamics drift and breathe over time rather than jumping independently each note, a gradual humanizing of touch.

ParamRangeDefaultUnit
Step0 – 10.3—

# TotientStepsVelocity 1 input

Totient-depth velocity: accents each note by how many times Euler's totient must be applied to its count to reach 1 (the iterated-totient depth, roughly log-scaled); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PrimePiVelocity 1 input

Prime-pi velocity: drives velocity from the prime-counting function pi(count) - how many primes are at or below the count - a slowly-climbing staircase accent from analytic number theory; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelocityGate 1 input

Velocity gate: passes only notes whose velocity falls inside a Low..High window, masking soft or loud notes (a dynamics filter / range splitter); Invert mutes the window instead of keeping it.

ParamRangeDefaultUnit
Low1 – 1271—
High1 – 127127—
Invert0 – 10—

# DigitMaxVelocity 1 input

Digit-max velocity: drives velocity from the largest decimal digit of the note count, a coarse stepping accent that climbs and resets with the leading digits; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# BinaryRunVelocity 1 input

Binary-run velocity: accents each note by the longest run of identical bits in its binary count, spiking on counts like 7, 15, 31 and 56; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# GoldenAngleVelocity 1 input

Golden-angle velocity: rotates each note count by the 137.5-degree golden angle (the phyllotaxis spiral that arranges sunflower seeds) and reads velocity from the resulting angle, an evenly-scattering accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# ModRangeVelocity 1 input

Mod-range velocity: ramps velocity in a repeating sawtooth across a chosen period of notes, a steady rising-then-resetting accent staircase; Depth blends with the played velocity.

ParamRangeDefaultUnit
Period2 – 328—
Depth0 – 11—

# DigitSpreadVelocity 1 input

Digit-spread velocity: drives velocity from the spread between the largest and smallest decimal digit of the note count, so repdigit counts read soft and mixed-digit counts read loud; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# NibbleSwapVelocity 1 input

Nibble-swap velocity: scrambles velocity by swapping the high and low 4-bit nibbles of the note count, a byte-twiddling accent that jumps in a fixed but jagged pattern; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# CompositeRunVelocity 1 input

Composite-run velocity: accents each note by how many composite counts have passed since the last prime, ramping up through prime gaps and snapping back to zero on each prime; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# TriangularModVelocity 1 input

Triangular-mod velocity: shapes velocity as a triangle wave rising and falling across a chosen period of notes, a smooth swell-and-fade accent contour; Depth blends with the played velocity.

ParamRangeDefaultUnit
Period2 – 328—
Depth0 – 11—

# SquareWaveVelocity 1 input

Square-wave velocity: alternates every note between two fixed velocity levels, a hard 2-step on/off accent that drives a mechanical pumping groove.

ParamRangeDefaultUnit
Low1 – 12750—
High1 – 127110—

# RandomHoldVelocity 1 input

Random-hold velocity: picks a random velocity and holds it for Hold notes before re-rolling, a sample-and-hold dynamic that gives blocky terraced changes rather than per-note jumps; Depth blends with the played velocity.

ParamRangeDefaultUnit
Hold1 – 164—
Depth0 – 11—

# DivisorProductVelocity 1 input

Divisor-product velocity: drives velocity from the product of the note count's divisors (taken modulo a range), a number-theoretic accent that swings high for highly-composite counts; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# SineWaveVelocity 1 input

Sine-wave velocity: shapes velocity as a smooth sine across a chosen period of notes, a gentle rise-and-fall dynamic swell repeating every Period notes; Depth blends with the played velocity.

ParamRangeDefaultUnit
Period2 – 328—
Depth0 – 11—

# ExpDecayVelocity 1 input

Exp-decay velocity: velocity starts loud and decays exponentially across a phrase of N notes then resets, an automatic decrescendo per phrase; Depth blends with the played velocity.

ParamRangeDefaultUnit
Period2 – 328—
Depth0 – 11—

# StaircaseVelocity 1 input

Staircase velocity: velocity climbs in quantized steps up a staircase across a chosen number of steps then drops back, a terraced crescendo accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Steps2 – 124—
Depth0 – 11—

# CollatzPeakVelocity 1 input

Collatz-peak velocity: accents each note by the log-height of the highest value its count reaches in the Collatz (3n+1) hailstone trajectory, so counts that soar before falling hit hardest; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# TotientRatioVelocity 1 input

Totient-ratio velocity: drives velocity from Euler's totient ratio phi(n)/n, so primes read near-full and highly-composite counts read soft, an arithmetic density accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# AbundanceVelocity 1 input

Abundance velocity: accents each note by the signed abundance sigma(n)-2n, so deficient counts read soft, perfect counts sit at centre and abundant counts read loud; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# JacobsthalVelocity 1 input

Jacobsthal velocity: drives velocity from the Jacobsthal numbers (J(n)=J(n-1)+2J(n-2): 1,1,3,5,11,21,...), a Fibonacci cousin tied to powers of two; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PerrinVelocity 1 input

Perrin velocity: drives velocity from the Perrin sequence (P(n)=P(n-2)+P(n-3): 3,2,3,2,5,5,7,10,...), famous for its primality-test conjecture; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# NarayanaVelocity 1 input

Narayana velocity: drives velocity from Narayana's-cows sequence (a(n)=a(n-1)+a(n-3): 1,2,3,4,6,9,13,19,...), whose ratio tends to the supergolden ratio; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# CalkinWilfVelocity 1 input

Calkin-Wilf velocity: drives velocity from the Calkin-Wilf rational at the count (fusc(n)/fusc(n+1)), the breadth-first enumeration that lists every positive fraction exactly once; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# HarmonicNumberVelocity 1 input

Harmonic-number velocity: drives velocity from the harmonic number H(n)=1+1/2+...+1/n, a smooth slowly-saturating logarithmic climb across the note count; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# LogVelocity 1 input

Log velocity: drives velocity from the base-2 logarithm of the note count, a gentle ever-slowing ramp that doubles its reach each octave of counts; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# SquareRootVelocity 1 input

Square-root velocity: drives velocity from the integer square root of the note count, a staircase whose steps grow ever wider; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DigitRotateVelocity 1 input

Digit-rotate velocity: rotates the count's decimal digits one place (the last digit jumps to the front) and reads velocity from the result, scrambling the steady counter into a jumpy pattern; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PrimeIndexVelocity 1 input

Prime-index velocity: drives velocity from the n-th prime number (the prime sitting at the running count's index), an irregularly-climbing accent straight from the prime sequence; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PartitionVelocity 1 input

Partition velocity: drives velocity from p(n), the number of ways to write the count as a sum of positive integers, a fast-growing combinatorial accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# TernaryDigitVelocity 1 input

Ternary-digit velocity: drives velocity from the base-3 digit sum of the note count, a self-similar accent that climbs and resets on ternary carries; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# FactorialModVelocity 1 input

Factorial-mod velocity: drives velocity from the count's factorial taken modulo 127, which collapses to zero past a small index (Wilson's theorem territory), giving a sharp early flurry then silence-velocity; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# ReverseSubtractVelocity 1 input

Reverse-subtract velocity: drives velocity from the absolute difference between the count and its digit-reversal (the 196-algorithm / Kaprekar step), zero on palindromes and large on lopsided counts; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# CollatzOddStepsVelocity 1 input

Collatz-odd-steps velocity: accents each note by how many odd (3n+1) rises its count takes on the way down the Collatz trajectory, an erratic hailstone-flavoured accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# ModInverseVelocity 1 input

Mod-inverse velocity: drives velocity from the modular inverse of the note count under a chosen modulus (zero when the count shares a factor with the modulus), a number-theoretic scramble; Depth blends with the played velocity.

ParamRangeDefaultUnit
Modulus3 – 12717—
Depth0 – 11—

# DigitEntropyVelocity 1 input

Digit-entropy velocity: drives velocity from how many distinct decimal digits the count uses, so repdigits read soft and varied counts read loud; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# RunningSumVelocity 1 input

Running-sum velocity: accumulates a small per-note increment into a velocity that drifts upward and wraps, a slowly-cycling ramp untied to pitch; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# AliquotStepsVelocity 1 input

Aliquot-steps velocity: accents each note by how many steps the count's aliquot sequence (repeatedly summing proper divisors) takes before terminating or settling, an unpredictable number-theory accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DigitMinVelocity 1 input

Digit-min velocity: drives velocity from the smallest decimal digit of the note count, the mirror of digit-max; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PowerOfTwoFactorVelocity 1 input

Power-of-two-factor velocity: drives velocity from the largest power of two that divides the count, so odd counts read soft and highly-even counts read loud (a binary-divisibility accent); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# GoldbachCountVelocity 1 input

Goldbach-count velocity: accents each even count by the number of distinct ways it splits into a sum of two primes (its Goldbach partitions), a rising and jagged accent; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# DivisorSumVelocity 1 input

Divisor-sum velocity: drives velocity from sigma(n), the sum of all divisors of the note count, so primes read low and highly-composite counts read loud; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# PrimorialModVelocity 1 input

Primorial-mod velocity: drives velocity from the primorial (product of the first k primes) taken modulo 127, a fast-scrambling accent that jumps as each new prime multiplies in; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# LeonardoVelocity 1 input

Leonardo velocity: drives velocity from the Leonardo numbers (L(n)=L(n-1)+L(n-2)+1: 1,1,3,5,9,15,25,...), the smoothsort sequence kin to Fibonacci; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# TribonacciVelocity 1 input

Tribonacci velocity: drives velocity from the Tribonacci numbers where each term sums the previous three (0,1,1,2,4,7,13,24,44,...); Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# HumanizeVelocity 1 input

Humanize velocity: adds a small random variation to each note-on velocity so repeated hits no longer read as identical, a subtle natural-feel dither.

ParamRangeDefaultUnit
Amount0 – 6412—

# VelocityCompress 1 input

Velocity compress: pulls every note-on velocity toward the centre by the set ratio, narrowing the dynamic range so soft and loud notes sit closer together.

ParamRangeDefaultUnit
Ratio0 – 10.5—

# VelocityDrift 1 input

Velocity drift: applies a slow bounded random walk to note-on velocities so the dynamics wander gently up and down over time rather than jumping; Step sets the walk speed.

ParamRangeDefaultUnit
Step0 – 308—

# VelocityClip 1 input

Velocity clip: hard-limits note-on velocities to a floor and ceiling, clamping anything outside the window to the edges (a dynamic gate/limiter).

ParamRangeDefaultUnit
Floor1 – 12720—
Ceil1 – 127110—

# VelocityCurve 1 input

Velocity curve: reshapes note-on velocity through a gamma curve - values above 1 soften the response (more playing in the quiet range), below 1 harden it.

ParamRangeDefaultUnit
Gamma0.2 – 51—

# VelocityQuantize 1 input

Velocity quantize: snaps note-on velocities to a small number of evenly-spaced levels, a terraced/stepped dynamic reminiscent of early samplers and harpsichords.

ParamRangeDefaultUnit
Steps2 – 164—

# GhostNoteEveryN 1 input

Ghost-note every N: softens every Nth note-on down to a quiet ghost-note level, dropping a recurring accent into the background for a syncopated groove.

ParamRangeDefaultUnit
Every2 – 164—
Ghost1 – 10025—

# CrescendoRamp 1 input

Crescendo ramp: ramps note-on velocity up linearly across a phrase of N notes then resets, an automatic swell from soft to loud; Depth blends with the played velocity.

ParamRangeDefaultUnit
Period2 – 328—
Depth0 – 11—

# DiminuendoRamp 1 input

Diminuendo ramp: ramps note-on velocity down linearly across a phrase of N notes then resets, an automatic fade from loud to soft; Depth blends with the played velocity.

ParamRangeDefaultUnit
Period2 – 328—
Depth0 – 11—

# VelocitySwap 1 input

Velocity swap: inverts each note-on velocity (128 minus the value) so the softest hits become the loudest and vice versa; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# VelocityMultiply 1 input

Velocity multiply: scales every note-on velocity by a fixed gain factor, a simple dynamics trim that boosts or attenuates the whole part.

ParamRangeDefaultUnit
Gain0.1 – 31—

# VelocityFromPitch 1 input

Velocity from pitch: derives velocity from the note's pitch so higher notes play louder (or, inverted, lower notes louder), a keyboard-tilt dynamic; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—
Invert0 – 10—

# VelocityFromInterval 1 input

Velocity from interval: accents each note by how far it leaps from the previous note, so large melodic jumps hit harder than stepwise motion; Depth blends with the played velocity.

ParamRangeDefaultUnit
Depth0 – 11—

# AccentOnHigh 1 input

Accent on high: boosts the velocity of note-ons at or above a pitch threshold, brightening the top of the keyboard.

ParamRangeDefaultUnit
Threshold0 – 12772—
Boost0 – 6420—

# AccentOnLow 1 input

Accent on low: boosts the velocity of note-ons at or below a pitch threshold, reinforcing the bass register.

ParamRangeDefaultUnit
Threshold0 – 12748—
Boost0 – 6420—

# VelocityFold 1 input

Velocity fold: folds note-on velocities that exceed a ceiling back downward (a wavefolder for dynamics), so very hard hits read softer in a non-monotonic way.

ParamRangeDefaultUnit
Ceiling8 – 127100—

# VelocityBoost 1 input

Velocity boost: adds a fixed amount (positive or negative) to every note-on velocity, clamped to the legal range, a quick dynamics offset.

ParamRangeDefaultUnit
Amount-64 – 6416—

# VelocityAlternate 1 input

Velocity alternate: alternates note-on velocities between two fixed levels (loud, soft, loud, soft), an automatic backbeat-style dynamic groove.

ParamRangeDefaultUnit
Loud1 – 127110—
Soft1 – 12760—

# ZoneVelocityScale 1 input

Zone velocity scale: scales the velocity of notes inside [Low,High] by Gain, a per-zone dynamics trim that lets a split layer sit louder or softer than the rest.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—
Gain0 – 31—

Pitch

29 modules

# FreqShift 1 input

Bode-style single-sideband frequency shifter: splits the input at in0 into in-phase and 90-degree branches via a polyphase IIR Hilbert allpass pair, then heterodynes against an internal carrier to shift every partial by a fixed Hz amount. Shift sets the offset (-1000 to +1000 Hz) and Mix blends the shifted signal against the dry input. Because the shift is in Hz rather than ratio, harmonic relationships break, giving inharmonic, metallic, clangorous tones.

ParamRangeDefaultUnit
Shift-1000 – 1000100Hz
Mix0 – 11—

# Shifter 1 input

Pitch / frequency / ring shifter in one (Ableton Shifter-style). Mode switches between granular Pitch shift (transpose by Coarse semitones + Fine cents, length preserved), Bode Frequency shift (Coarse/Fine reinterpreted as Hz via a polyphase-IIR Hilbert SSB shifter, breaking harmonics into inharmonic/metallic tones), and Ring modulation (multiply by an internal sine carrier at the Coarse/Fine frequency). Window sets the pitch-mode grain size; Mix blends dry/wet.

ParamRangeDefaultUnit
ModePitch · Frequency · Ring—
Coarse-48 – 487st
Fine-100 – 1000ct
Window20 – 12060ms
Mix0 – 11—

# Spinback 2 inputs

Turntable brake: a gate on in1 starts reading the captured buffer at steadily falling speed, so playback drops in pitch and slows to a dead stop like braking a record. Time sets how long the brake takes to reach a halt (50..3000 ms) and Mix blends the braked signal against the dry input. Releasing the gate stops braking and returns to live audio.

ParamRangeDefaultUnit
Time50 – 3000600ms
Mix0 – 11—

# H910 1 input

Harmonizer: a pitch shifter feeding a feedback delay, so each repeat is pitched again into a rising or falling cascade (the classic H910 fused pitch+delay).

ParamRangeDefaultUnit
Pitch-12 – 127st
Delay1 – 1000200ms
Feedback0 – 0.90.4—
Mix0 – 10.5—

# Octavox 1 input

A cloud of four pitch-shifted voices at diatonic intervals, each on its own delay tap, summed into a shimmering harmonized pitch-delay (Octavox/Quadravox class).

ParamRangeDefaultUnit
Spread10 – 400120ms
Key0 – 20—
Feedback0 – 0.850.3—
Level0 – 10.6—
Mix0 – 10.5—

# H3000 1 input

Eventide H3000-style micro-pitch doubler: two slightly detuned, short-delayed voices thicken the signal into a wide, lush double-track.

ParamRangeDefaultUnit
Detune0 – 3012ct
Delay1 – 5018ms
Width0 – 10.7—
Mix0 – 10.5—

# ZeroLockRamp 1 input

Zero-cross-locked ramp: measures the input period from its rising zero crossings and emits a clean phase ramp (saw) at a multiple of that pitch - a band-limited 'reconstruct the oscillator' from any monophonic source.

ParamRangeDefaultUnit
Mult0.25 – 41—
Level0 – 10.8—

# SubOctave 1 input

Sub-octave generator: a flip-flop toggled on each rising zero crossing produces a square one octave below the input pitch (analog octave-divider style), smoothed and mixed with the dry signal.

ParamRangeDefaultUnit
Sub0 – 10.7—
Mix0 – 10.5—
Level0 – 10.8—

# DriftPitch 1 input

Analog pitch drift: a quasi-random slow modulator (two incommensurate LFOs) sweeps a fractional delay so pitch wanders like a detuning analog oscillator - organic, never-repeating instability.

ParamRangeDefaultUnit
Depth0 – 10.5—
Rate0.05 – 20.3Hz
Mix0 – 11—

# SubHarm 1 input

Sub-harmonic sine synthesizer: tracks the input period from zero crossings and synthesizes a clean sine one octave below it - a smooth tonal sub, distinct from the square-wave flip-flop SubOctave.

ParamRangeDefaultUnit
Sub0 – 10.7—
Mix0 – 10.5—
Level0 – 10.8—

# PitchQuant 1 input

Pitch quantizer: tracks the input pitch from zero crossings, snaps it to the nearest equal-tempered semitone, and emits a clean saw at the quantized pitch - a monophonic auto-tune-to-grid oscillator.

ParamRangeDefaultUnit
Level0 – 10.8—

# OctUp 1 input

Octave-up doubler: full-wave rectification (which doubles the fundamental) followed by a DC blocker yields an octave-up tone tracking the input, blended back with the dry signal.

ParamRangeDefaultUnit
Oct0 – 10.7—
Mix0 – 10.5—
Level0 – 10.8—

# FreqDouble 1 input

Frequency doubler: squaring the signal generates a component at twice the frequency; a DC blocker removes the rectification offset, leaving an octave-up tone that tracks the input.

ParamRangeDefaultUnit
Amount0 – 10.7—
Mix0 – 10.5—
Level0 – 10.7—

# PhaseMult 1 input

Harmonic phase multiplier: tracks the input period and emits a clean saw at an exact integer multiple of its pitch, generating a precise upper harmonic locked to the source (octaves, fifths-as-3x, etc.).

ParamRangeDefaultUnit
Mult1 – 82—
Level0 – 10.8—

# PitchCV 1 input

Pitch-to-CV converter: tracks the input's fundamental from its zero crossings and outputs the frequency as a 0..1 control signal between two limits - a monophonic pitch follower for driving filters or other oscillators.

ParamRangeDefaultUnit
Min20 – 40050Hz
Max200 – 40001000Hz

# ScaleSnap 1 input

Scale quantizer: snaps a 0..1 control input to the nearest note of a chromatic, major or minor scale across a chosen octave span - the pitch-quantizer that turns a smooth or random CV into in-key steps.

ParamRangeDefaultUnit
ScaleChromatic · Major · Minor—
Octaves1 – 42—

# GranPitch 1 input

Granular pitch shifter: two delay read-heads sweep at the pitch-shift ratio and crossfade with overlapping windows, transposing the input up or down in real time without changing its length - classic time-domain pitch shifting.

ParamRangeDefaultUnit
Pitch0.5 – 21—
Grain20 – 12060ms
Mix0 – 11—

# HarmonizerFixed 1 input

Diatonic harmonizer: granular-pitch-shifts the input by a fixed musical interval (third, fourth, fifth, octave) and mixes it under the dry signal, adding a parallel harmony voice without a separate sequencer.

ParamRangeDefaultUnit
Interval3rd · 4th · 5th · Octave—
Grain20 – 12060ms
Mix0 – 10.5—

# InstFreq 1 input

Instantaneous frequency: differentiates the unwrapped phase of the analytic signal (input plus its quadrature) to estimate the signal's frequency continuously - a fast pitch/movement CV that responds within a cycle.

ParamRangeDefaultUnit
Scale0.001 – 0.050.01—
Smooth1 – 508ms

# PitchShiftFB 1 input

Feedback pitch shifter: the granular-shifted output is fed back into the buffer, so each pass is transposed again, stacking an ever-climbing (or descending) cascade of shifted copies - the harmonic-staircase / barber-pole pitch effect.

ParamRangeDefaultUnit
Pitch0.5 – 21.5—
Feedback0 – 0.850.5—
Grain30 – 12070ms
Mix0 – 10.5—

# PitchShift 1 input

Granular pitch shifter using two overlapping, cross-faded grains (Window 20-120 ms) to transpose +/-24 semitones without changing length. Feedback re-injects the shifted output for cascading and shimmer effects, and Mix sets dry/wet. Shorter windows tighten transients but add warble; longer windows smooth the tone at the cost of latency.

ParamRangeDefaultUnit
Pitch-24 – 247st
Mix0 – 10.5—
Feedback0 – 0.90—
Window20 – 12060ms

# Octaver 1 input

Sub-octave generator: a flip-flop toggled at each rising zero crossing produces a half-rate square tracked by the input envelope, low-passed by Tone for warmth and mixed under the Dry signal at Sub. Monophonic, analog-pedal style - best on clean single notes and bass. It glitches on chords, as expected of the technique.

ParamRangeDefaultUnit
Sub0 – 10.7—
Dry0 – 11—
Tone200 – 80002000Hz

# Unison 1 input

Unison thickener: turns a mono input into up to 16 pitch-detuned voices (the supersaw sound) using overlapping ramped-delay pitch shifters at symmetric cent offsets, so the centre stays at pitch and the outer voices spread apart. Detune sets the spread, Blend the outer-voice level and Mix dry/wet. Wide and lush on synths, pads and backing vocals.

ParamRangeDefaultUnit
Voices1 – 164—
Detune0 – 5018ct
Blend0 – 10.7—
Mix0 – 11—

# MicroShift 1 input

Micro-pitch doubler that generates two delay-line voices detuned slightly up and slightly down, then sums them with the dry signal to widen the source. Detune sets the symmetric pitch offset (0-50 cents) and Delay sets the base tap time (0-40 ms) before the shifted voices. Mix sets dry/wet; small Detune thickens, larger Detune broadens into a chorus-like spread.

ParamRangeDefaultUnit
Detune0 – 5012cents
Delay0 – 4012ms
Mix0 – 10.5—

# Harmonizer 1 input

Single-voice harmonizer that pitch-shifts the input by a chosen musical interval using overlapping windowed delay-line reads, then adds it back to the dry signal. Interval sets the transposition (+/-24 semitones), Detune adds up to 30 cents of offset for a less rigid blend, and Level sets the harmony voice gain. Mix scales the added voice into the output; useful for parallel harmonies and octave doubling.

ParamRangeDefaultUnit
Interval-24 – 247st
Detune0 – 300cents
Level0 – 10.7—
Mix0 – 11—

# Pitch2Midi 1 input

Monophonic pitch tracker that measures the period between rising zero-crossings, converts it to a MIDI note number, and emits it as a control value. Glide smooths the tracked pitch over time for portamento, while Out switches the output between the normalized pitch CV and a simple gate that goes high whenever the input is active. Intended to drive other modules from a played signal rather than to process audio.

ParamRangeDefaultUnit
Glide0 – 0.990.3—
Out0 – 10—

# PitchCorrect 1 input

Rough auto-tune that detects the input period via zero-crossings, finds the nearest semitone, and applies a crossfaded two-tap windowed pitch shift to pull the note onto pitch. Amount scales how far the signal is moved toward the target semitone, from no correction to full snapping, and Mix blends the corrected voice against the dry input. Best on clean monophonic sources; artifacts increase with stronger correction.

ParamRangeDefaultUnit
Amount0 – 10.8—
Mix0 – 11—

# TimeStretch 1 input

Granular time-smear that writes the input into a delay line and reads it back with two overlapping Hann-windowed grains advancing slower than real time. Stretch sets how slowly the read position moves (lower values smear the sound out further) and Grain sets the grain length in milliseconds, trading smoothness against fluttering artifacts. Mix blends the stretched texture against the dry signal for frozen, drifting timbres.

ParamRangeDefaultUnit
Stretch0.25 – 10.5—
Grain20 – 20080ms
Mix0 – 11—

# Doppler 2 inputs

Doppler pass-by: makes the input sound like a source moving past the listener - on a trigger the pitch bends up as it approaches then down as it recedes (a varispeed delay line), the level swells to a peak at the closest point, and a low-pass opens at the pass then closes with distance. The car / jet / projectile fly-by of film sound design. Speed sets the pass duration, Amount the pitch-bend depth (how fast the source moves), Distance the closest approach (level and tone contrast), and Mix blends against dry. in0 = Audio, in1 = Trigger.

ParamRangeDefaultUnit
Speed0.3 – 82s
Amount0 – 10.5—
Distance0 – 10.5—
Mix0 – 11—

Utility

147 modules

# Expr 3 inputs

User-written per-sample expression compiled by an RT-safe VM (P0..P5 params plus two signal inputs) - does what the fixed blocks can't.

ParamRangeDefaultUnit
P00 – 10.5—
P10 – 10.5—
P20 – 10.5—
P30 – 10.5—
P40 – 10.5—
P50 – 10.5—

# Gain 1 input

Gain trim (dB) plus a DC bias offset.

ParamRangeDefaultUnit
Gain-60 – 240—
Bias-1 – 10—

# Mixer 3 inputs

Sums three scaled inputs plus a DC offset.

ParamRangeDefaultUnit
In 1-1.5 – 1.51—
In 2-1.5 – 1.51—
Mod Amt-1.5 – 1.50—
Offset-1 – 10—

# Subtract 3 inputs

Difference node: in0 minus in1 minus in2, plus a DC Offset. Feed two signals to get their difference (error/side-chain CV, mid-from-sum, delta detectors) or leave in2 unpatched for a simple two-input subtract. Unconnected inputs contribute 0.

ParamRangeDefaultUnit
Offset-2 – 20—

# Multiply 2 inputs

Two-quadrant multiplier / VCA: in0 times in1 times Scale. With an audio-rate in1 it is ring modulation; with a control-rate in1 it is a clean amplitude VCA. Both inputs must be patched - an unconnected input is 0, which mutes the output (the multiplicative identity is not assumed).

ParamRangeDefaultUnit
Scale-4 – 41—

# Divide 2 inputs

Safe divider: in0 divided by (in1 + Denom), with the result limited to +/-Limit so a near-zero denominator can never blow up. Denom both seeds the divisor when in1 is unpatched and biases it when it is, and the magnitude of the divisor is floored at a tiny epsilon. Useful for normalising, ratio CV, and reciprocal-style shaping.

ParamRangeDefaultUnit
Denom-4 – 41—
Limit1 – 6416—

# Negate 1 input

Sign inverter: outputs -in0 scaled by Scale (default 1) plus an Offset. Flip the phase of an audio signal, invert a control voltage, or build a difference by summing a Negate against another source. Scale at -1 passes the signal through unchanged.

ParamRangeDefaultUnit
Scale-2 – 21—
Offset-1 – 10—

# Reciprocal 1 input

One-over-x: 1 / (in0 + Bias), limited to +/-Limit and floored away from zero so it stays finite. Turns a rising CV into a falling one, converts frequency to period (and back), and builds hyperbolic shapes. Bias keeps the denominator off zero when in0 passes through the origin.

ParamRangeDefaultUnit
Bias-2 – 20—
Limit1 – 6416—

# Min 2 inputs

Outputs the smaller of in0 and in1 (after adding the In B offset to in1). Pairs with Max to build hard clippers, envelope floors, and CV limiters. An unconnected in1 reads 0, so In B sets the constant floor in that case.

ParamRangeDefaultUnit
In B-2 – 20—

# Max 2 inputs

Outputs the larger of in0 and in1 (after adding the In B offset to in1). Max against 0 is a half-wave rectifier / positive-only clamp; against a constant it is an envelope ceiling. An unconnected in1 reads 0, so In B sets the constant ceiling in that case.

ParamRangeDefaultUnit
In B-2 – 20—

# Clamp 1 input

Hard range limiter: constrains in0 to the [Lo, Hi] window with no saturation curve (unlike Clip, which rounds the knee). Use it to bound CV, keep a feedback signal in range, or window a modulator. If Lo > Hi the bounds swap so the window is always valid.

ParamRangeDefaultUnit
Lo-2 – 2-1—
Hi-2 – 21—

# Constant 0 inputs

DC source: emits a fixed Value every sample with no input. Patch it into a maths block as a constant operand, into a parameter mod input as a manual offset, or sum it onto a signal as bias. The simplest way to add a tunable number to the graph.

ParamRangeDefaultUnit
Value-1 – 11—

# Crossfade 3 inputs

Blends from in0 to in1 by a fade position of Mix plus the in2 CV (clamped 0..1). Mode 0 is a linear (constant-sum) fade; Mode 1 is an equal-power (constant-energy) fade for click-free audio crossfades. Patch in2 to automate the morph; leave it unpatched to set the blend by hand with Mix.

ParamRangeDefaultUnit
Mix0 – 10.5—
ModeLinear · Equal Power—

# Select 3 inputs

Two-way signal switch: routes in0 when the in2 selector (plus the Threshold) is below 0.5 and in1 when it is at or above, so a gate or LFO can hard-flip between two sources. Unlike Crossfade there is no blend - it is a clean A/B route for muxing oscillators or CV paths.

ParamRangeDefaultUnit
Threshold-1 – 10—

# Power 1 input

Sign-preserving exponent: outputs sign(in0) * |in0|^Exp, so it reshapes a normalised signal's curve without changing its polarity or its 0 and +/-1 endpoints. Exp > 1 bends a CV toward the extremes (snappier envelopes), Exp < 1 expands the middle (gentler control feel).

ParamRangeDefaultUnit
Exp0.1 – 82—

# Sign 1 input

Sign extractor with a dead zone: outputs -1, 0, or +1 depending on whether in0 sits below, inside, or above a +/-Dead band around zero. Turns any signal into a bipolar gate, derives direction from a slope, or squares an oscillator into a pulse. Dead at 0 gives a pure two-state comparator.

ParamRangeDefaultUnit
Dead0 – 10—

# Quantize 1 input

Rounds in0 to the nearest of Steps evenly-spaced levels across the [-1, 1] range, turning a smooth signal into a stepped one. Drop the resolution of a sweep into discrete plateaus, build sample-rate-style bit-crush on CV, or snap a glide into a staircase. Steps at 2 gives a bipolar square; higher Steps gives finer stairs.

ParamRangeDefaultUnit
Steps2 – 648—

# Fold 1 input

Triangle wavefolder: when |in0 * Drive| exceeds Threshold the excess is reflected back inward, repeatedly, so a loud signal folds onto itself and sprouts bright upper harmonics (Serge / Buchla west-coast timbre). Unlike a clipper it keeps adding partials with more Drive instead of flattening into a square.

ParamRangeDefaultUnit
Drive1 – 161—
Threshold0.1 – 11—

# Wrap 1 input

Phase-style wrap: folds in0 back into the [-Range, Range] window by wrapping (modulo) rather than clamping, so a value leaving one edge re-enters from the opposite edge. Ideal for keeping a phasor or free-running ramp bounded, or for hard sync-style discontinuities.

ParamRangeDefaultUnit
Range0.1 – 21—

# Modulo 1 input

Euclidean remainder: outputs in0 wrapped into [0, Mod), the non-negative remainder of in0 / Mod. Generate ramps from a rising counter, build polyrhythmic resets, or derive a phasor from accumulated CV. Differs from Wrap, which keeps a bipolar +/-Range window centred on zero.

ParamRangeDefaultUnit
Mod0.01 – 21—

# Compare 1 input

Schmitt comparator: outputs +1 (high) when in0 rises above Threshold + Hyst and -1 (low) when it falls below Threshold - Hyst, holding its state in between so noise near the edge cannot chatter. Turns an audio or control signal into a clean bipolar gate; Hyst at 0 is an instantaneous comparator.

ParamRangeDefaultUnit
Threshold-1 – 10—
Hyst0 – 0.50.02—

# Logic 2 inputs

Boolean gate combiner: treats in0 and in1 as logic highs when they exceed 0.5 and applies AND, OR, XOR, NAND, NOR, or XNOR (Op), emitting +1 for true and -1 for false. Build trigger conditioners, gate masks, and rhythmic combinations from clocks, gates, and square LFOs.

ParamRangeDefaultUnit
OpAND · OR · XOR · NAND · NOR · XNOR—

# Map 1 input

Affine range mapper: rescales in0 from its [In Lo, In Hi] range onto a [Out Lo, Out Hi] range, then optionally clamps to the output bounds. The general-purpose glue for matching signal ranges - convert a 0..1 envelope to a +/-1 CV, narrow an LFO's swing, or invert a range by setting Out Lo > Out Hi.

ParamRangeDefaultUnit
In Lo-2 – 2-1—
In Hi-2 – 21—
Out Lo-2 – 20—
Out Hi-2 – 21—
ClampOff · On—

# Mux 4 inputs

Four-way input selector: routes one of in0..in3 to the output based on the Sel index (plus the in-built Sel knob), so a stepped CV or sequencer can hard-switch between four sources. Where Select chooses between two inputs, Mux scales to four - a clean N-way router with no crossfade. The selector is floored to an integer and wrapped, so an out-of-range index stays valid.

ParamRangeDefaultUnit
SelIn 0 · In 1 · In 2 · In 3—

# Average 4 inputs

Mean of the four signal inputs, weighted only by how many are non-zero so an unpatched input does not drag the result toward zero. Use it to find the centre of several CVs, average detuned oscillators, or build a simple low-pass on a set of parallel signals. With one input patched it passes that signal through unchanged.

# Window 1 input

Window comparator: outputs High when in0 sits inside the [Lo, Hi] band and Low when it is outside, the two-sided counterpart to Compare's single threshold. Detect when a CV enters a range, build a band-gate, or fire a trigger only while a modulator is within bounds. If Lo > Hi the bounds swap so the window is always valid.

ParamRangeDefaultUnit
Lo-1 – 1-0.5—
Hi-1 – 10.5—
High-1 – 11—
Low-1 – 1-1—

# Round 1 input

Integer rounding with a selectable Mode (nearest, floor, ceil, truncate) applied at a chosen Step size, so a smooth signal snaps to a grid of that spacing. Unlike Quantize (which maps onto a fixed number of levels across [-1,1]), Round works at an absolute step and direction - quantise a control voltage to semitone-sized steps, or floor a phasor to whole cycles.

ParamRangeDefaultUnit
Step0.01 – 10.1—
ModeNearest · Floor · Ceil · Trunc—

# Smoothstep 1 input

Hermite smoothstep ramp: maps in0 across the [Edge0, Edge1] range through the classic 3t^2 - 2t^3 S-curve (zero slope at both ends), clamped outside the edges. Where Power bends a curve around zero, Smoothstep eases between two thresholds - de-zipper a control, soften a gate into a fade, or shape a crossfade position so it accelerates and decelerates smoothly.

ParamRangeDefaultUnit
Edge0-1 – 10—
Edge1-1 – 11—

# Hypot 2 inputs

Vector magnitude: outputs sqrt(in0^2 + in1^2) scaled by Gain - the Euclidean length of the two inputs treated as X and Y. Combine two quadrature signals into one amplitude, derive an envelope from a stereo pair, or build a distance/radius control from two CVs. Always non-negative regardless of input sign.

ParamRangeDefaultUnit
Gain0 – 41—

# Frac 1 input

Fractional part: outputs in0 minus its floor, the [0, 1) remainder after the whole number is removed. A rising ramp becomes a repeating 0..1 sawtooth, so it is the quickest way to turn an accumulator or phasor into a wrapped phase - feed it a slow rising CV to generate a tempo ramp, or take the Frac of a scaled signal to build stepped repeats. Negative inputs still map to [0, 1).

ParamRangeDefaultUnit
Scale0 – 161—

# Atan2 2 inputs

Two-argument arctangent: outputs the angle of the (in0, in1) vector mapped to [-1, 1] (= atan2(in1, in0) / pi). The phase counterpart to Hypot's magnitude - together they convert a quadrature (X/Y) pair to polar form. Derive a rotation angle from two CVs, recover phase from a sine/cosine pair, or build a circular panner control. Output is bipolar and wraps at the +/-1 edges.

# Exp 1 input

Linear-to-exponential converter: outputs 2^(in0 * Range), turning a linear control voltage into the exponential frequency or time multiplier that pitch and filter cutoffs expect. in0 of 1 at Range 1 gives x2 (one octave up); 0 gives x1. The companion to Log - feed a linear envelope or LFO here so it tracks musical per-octave intervals instead of a flat sweep.

ParamRangeDefaultUnit
Range-8 – 81—

# Log 1 input

Exponential-to-linear converter: outputs log2(in0) / Range, the inverse of Exp - recover a linear control voltage from a frequency or time multiplier. in0 of 2 at Range 1 gives 1 (one octave). The input is floored at a tiny positive value so a zero or negative multiplier stays finite rather than diverging.

ParamRangeDefaultUnit
Range-8 – 81—

# Threshold 1 input

Unipolar threshold gate: outputs High when in0 is at or above Threshold and Low otherwise - a hard one-sided switch. Where Compare returns a bipolar +/-1 with hysteresis and Window tests a two-sided band, Threshold is the plain 'is it past this level' detector: turn an envelope or LFO into a clean 0/1 gate, or trigger an event when a signal crosses a level.

ParamRangeDefaultUnit
Threshold-1 – 10—
High-1 – 11—
Low-1 – 10—

# Skew 1 input

Asymmetric curve bender: warps in0 across the [0,1] range so its midpoint slides toward 0 or 1 by Skew, bending a linear ramp into an ease-in or ease-out while leaving the 0 and 1 endpoints fixed. Where Power is symmetric around zero, Skew pivots one-sided over the unit range - shape an envelope segment, bias an LFO ramp, or curve a crossfade. Skew at 0 passes the value through unchanged.

ParamRangeDefaultUnit
Skew-1 – 10—

# ScaleQuant 1 input

Musical scale / pitch quantizer: snaps in0 - read as a pitch in semitones (the synth's Note source, a sequencer, or any CV scaled so 1.0 = one semitone) - to the nearest note of the selected Scale rooted on Root. Where Quantize maps onto N evenly-spaced levels across [-1,1], ScaleQuant snaps to a musical key, so a random or smoothly-drifting CV driving an oscillator's pitch always lands in tune. Output is the quantised semitone value - patch it into an oscillator's pitch / Note input.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Min Penta · Maj Penta · Blues · Whole Tone—

# ChordQuant 1 input

Chord quantizer: snaps in0 - a pitch in semitones (the Note source, a sequencer, or any CV scaled 1.0 = one semitone) - to the nearest tone of the chord set by Root + Chord. Where ScaleQuant snaps to a 5-7 note key, ChordQuant snaps to just the 2-5 tones of a chord, so a drifting or random CV driving an oscillator's pitch arpeggiates strictly inside the harmony. Output is the quantised semitone - patch into an oscillator's pitch / Note input.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Chord5th · Maj · Min · Dim · Aug · Sus2 · Sus4 · Maj6 · Min6 · Maj7 · Min7 · Dom7 · Maj9 · Min9—

# Abs 1 input

Absolute value / full-wave rectifier: outputs |in0| * Gain plus Offset, so every sample is folded to the positive side. Where Sign keeps only the polarity and Negate flips it, Abs discards it - turn a bipolar LFO or audio signal into a unipolar envelope, derive a level from a waveform, or build a full-wave rectifier (Max against 0 is only half-wave).

ParamRangeDefaultUnit
Gain0 – 41—
Offset-2 – 20—

# AbsDiff 2 inputs

Unsigned difference: outputs |in0 - in1| * Scale, the distance between the two inputs on the number line regardless of which is larger. Where Subtract keeps the sign and Hypot is the 2-D vector length, AbsDiff is the 1-D magnitude of an error - a rectified side-chain, a change detector, or a symmetric closeness measure for two CVs. Both inputs must be patched.

ParamRangeDefaultUnit
Scale0 – 41—

# Equal 2 inputs

Tolerance comparator: outputs High when in0 sits within +/-Tol of (in1 plus Offset) and Low otherwise. Where Compare tests a rising/falling threshold crossing and Window tests a fixed band on one signal, Equal asks whether two moving signals currently match - detect a sequencer landing on a value, gate when two CVs coincide, or build a quantizer-hit indicator. With in1 unpatched it tests in0 against the constant Offset.

ParamRangeDefaultUnit
Offset-2 – 20—
Tol0 – 20.01—
High-1 – 11—
Low-1 – 10—

# Complement 1 input

Unit-range inverter: outputs Center - in0 * Scale, defaulting to 1 - in0 so a normalised 0..1 control is flipped end-for-end. Where Negate mirrors a bipolar signal about zero, Complement mirrors a unipolar one about its Center - derive a dry amount from a wet 0..1 knob, invert an envelope's shape, or turn a rising 0..1 ramp into a falling one. Set Center to 2 with Scale 1 to reflect about 1.

ParamRangeDefaultUnit
Center-2 – 21—
Scale-2 – 21—

# Decibels 1 input

Decibel <-> linear-gain converter. In dB->Gain mode it outputs 10^(in0 / 20), turning a decibel value at in0 into the linear amplitude multiplier a VCA wants; in Gain->dB mode it outputs 20*log10(|in0|), recovering the dB level of a linear gain (floored so a zero input stays finite). The result is limited to +/-Limit. Where Exp/Log work in per-octave powers of two, Decibels is the audio-level (20*log10) law.

ParamRangeDefaultUnit
ModedB->Gain · Gain->dB—
Limit1 – 25664—

# Semitones 1 input

Semitone-to-ratio pitch converter: outputs 2^((in0 * Range) / 12), turning a semitone interval at in0 into the frequency multiplier that retunes an oscillator, FM ratio, delay time, or sample playback rate. in0 of 12 at Range 1 gives x2 (one octave); 7 gives a perfect fifth (~1.498). Range scales the incoming interval. The 12-tone-equal-temperament counterpart to Exp's per-octave power.

ParamRangeDefaultUnit
Range-24 – 241—

# AbsMax 2 inputs

Largest magnitude: outputs the greater of |in0| and |in1| times Gain - the loudest of the two inputs regardless of sign (the L-infinity norm). Where Max compares signed values, Hypot is the L2 vector length and AbsDiff is the gap between them, AbsMax is the peak of the pair - combine two level followers into a single peak meter, or take the worse-case of two error signals. Always non-negative.

ParamRangeDefaultUnit
Gain0 – 41—

# GeoMean 2 inputs

Geometric mean of two inputs: outputs sign(in0*in1) * sqrt(|in0 * in1|) * Scale. Where Average is the arithmetic mean (sum/2), the geometric mean is the multiplicative centre - it pulls toward the smaller magnitude and collapses to zero if either input is zero, which makes it a soft AND for two level/CV signals. The sign follows the product, so two negatives give a positive root.

ParamRangeDefaultUnit
Scale0 – 41—

# Deadband 1 input

Centre dead-zone: passes in0 straight through once it moves more than Width from zero, and outputs 0 inside the +/-Width band. With Subtract on, the surviving signal is shifted back so it leaves the band continuously (no step) instead of jumping by Width. Unlike Sign's dead-zone (which emits +/-1) this keeps the signal itself - a noise gate for CV, a joystick centre detent, or a way to ignore small wobble on a control.

ParamRangeDefaultUnit
Width0 – 10.1—
SubtractOff · On—

# Gaussian 1 input

Bell-curve shaper: outputs exp(-((in0 - Centre)^2) / (2 * Width^2)), a smooth hump that peaks at 1 when in0 = Centre and falls off symmetrically on both sides, never quite reaching 0. Width sets how broad the bell is. A ready-made windowing/proximity response - turn distance-from-a-target into a fade, build a resonant-looking CV peak, or weight a value by how close it sits to Centre. Unlike Smoothstep's one-sided ramp this is a two-sided peak.

ParamRangeDefaultUnit
Centre-2 – 20—
Width0.01 – 20.4—

# Quadratic 1 input

Second-order polynomial shaper: outputs A*in0^2 + B*in0 + C, a full parabola with adjustable curvature (A), slope (B) and offset (C). Where Power gives a single sign-preserving exponent, Quadratic mixes a squared term with a linear one for asymmetric curves, gentle pedal/expo CV responses, or a parabolic envelope segment. A=0 leaves a plain affine B*in0 + C; B=0 is a pure square bowl.

ParamRangeDefaultUnit
A-4 – 41—
B-4 – 40—
C-2 – 20—

# Logistic 1 input

Logistic sigmoid: outputs 1 / (1 + exp(-Gain * (in0 - Centre))), the classic S-curve that eases from 0 up to 1 with its steepest slope at Centre and Gain setting the sharpness. Unlike Smoothstep (a clamped Hermite that hits exactly 0 and 1 over a finite window) the logistic asymptotes and never fully reaches the rails, so it is the natural soft gate, compander curve, or probability mapping for an unbounded input. High Gain approaches a hard 0/1 switch.

ParamRangeDefaultUnit
Gain0.1 – 326—
Centre-2 – 20—

# Median3 3 inputs

Median of three inputs: outputs the middle value of in0, in1, in2, discarding the highest and lowest. Where Average is pulled by an outlier and Min/Max take the extreme, the median rejects a single spike entirely - de-glitch a noisy CV, pick the consensus of three sensors or LFOs, or smooth a control without the lag of a filter. Unconnected inputs read 0, so feed all three.

# Spread 3 inputs

Dispersion of three inputs: outputs (max - min) of in0, in1, in2 times Gain - how far apart the most extreme pair sits. Where AbsDiff is the gap between two signals, Spread is the full range across three, a one-number measure of how much a set of CVs disagree: drive a 'tightness' control, detect when voices diverge, or derive a width amount. Always non-negative; unconnected inputs read 0.

ParamRangeDefaultUnit
Gain0 – 41—

# Manhattan 2 inputs

Taxicab (L1) magnitude: outputs (|in0| + |in1|) * Gain, the sum of the two inputs' magnitudes. The third member of the norm family beside Hypot (the L2 straight-line length) and AbsMax (the L-infinity peak) - L1 grows fastest and is cheap, useful as a combined level/activity measure of two signals or an energy estimate. Always non-negative regardless of input sign.

ParamRangeDefaultUnit
Gain0 – 41—

# Sinh 1 input

Hyperbolic-sine shaper: warps in0 through a normalised sinh(in0 * Drive) / sinh(Drive), an odd (sign-preserving) exponential curve that passes 0 and reaches +/-1 at +/-1 while bowing the middle. Low Drive is nearly linear; high Drive is steeply exponential near the rails. The symmetric, both-sides counterpart to Exp's one-sided per-octave curve - an expo response for bipolar CV or a soft expander curve.

ParamRangeDefaultUnit
Drive0.01 – 62—

# Cosh 1 input

Hyperbolic-cosine bowl: warps in0 through a normalised (cosh(in0 * Drive) - 1) / (cosh(Drive) - 1), an even (symmetric) U-shaped curve that is 0 at the centre and rises to 1 at +/-1 - the catenary/parabola-like counterpart to the odd Sinh. Turn a bipolar CV into a centre-dipped magnitude, build a smile/frown response, or weight by distance from zero with a steeper-than-square edge as Drive rises.

ParamRangeDefaultUnit
Drive0.01 – 62—

# Sinc 1 input

Normalised sinc: outputs sin(pi * in0 * Scale) / (pi * in0 * Scale), the cardinal sine that is 1 at the origin and rings out in decaying side-lobes on either side, crossing zero at every integer of in0 * Scale. The impulse response behind ideal interpolation and brick-wall filtering - use it as a ripply symmetric window, a decaying-oscillation CV shape, or a damped bipolar response around a centre.

ParamRangeDefaultUnit
Scale0 – 161—

# Atan 1 input

Arctangent shaper: outputs (2/pi) * atan(Drive * in0), a smooth odd S-curve that asymptotes toward +/-1 without ever clipping, with Drive setting how hard it leans on the signal. The single-argument companion to Atan2 (which takes an X/Y pair) and a gentler always-on alternative to the threshold-based Clip - soft-saturate a CV, tame a hot modulator, or compress an audio signal with a rounded knee that never reaches the rail.

ParamRangeDefaultUnit
Drive0.1 – 324—

# Asinh 1 input

Inverse-hyperbolic-sine compander: outputs asinh(Drive * in0) / asinh(Drive), a normalised odd curve that is near-linear for small inputs and rolls into a logarithmic slope for large ones, reaching +/-1 at +/-1. The bipolar, through-zero counterpart to Log (which is positive-only and diverges at 0) and the inverse of Sinh - a soft dynamics compander for CV or audio that keeps small detail while taming peaks, with no discontinuity at the origin.

ParamRangeDefaultUnit
Drive0.01 – 163—

# Atanh 1 input

Inverse-hyperbolic-tangent expander: clamps in0 to +/-Edge then outputs atanh(in0) / atanh(Edge), an odd curve that is gentle near zero and steepens sharply toward the rails - the inverse of a tanh saturator, so it undoes soft clipping and exaggerates dynamics instead of taming them. Edge sets how close to 1 the input may get before the slope runs away (the clamp keeps it finite). Use it to add bite, expand a squashed envelope, or pre-distort before a saturator.

ParamRangeDefaultUnit
Edge0.5 – 0.9990.95—

# ArgMax 4 inputs

Winner-take-all index: outputs which of in0..in3 is currently the largest, as the integer 0, 1, 2 or 3. Where Mux routes a chosen input by a selector, ArgMax generates that selector - patch its output into a Mux Sel to follow the loudest source, or use it to detect which of several envelopes/LFOs is on top. Ties resolve to the lowest index; unconnected inputs read 0.

# RMS3 3 inputs

Root-mean-square of three inputs: outputs sqrt((in0^2 + in1^2 + in2^2) / 3) * Gain, the power-average level of the trio. Where Average is the arithmetic mean (which cancels when signals are out of phase) and Hypot is the unnormalised two-input vector length, RMS3 is the normalised energy of three signals - a combined loudness/activity estimate that ignores sign and does not null out. Always non-negative; unconnected inputs read 0.

ParamRangeDefaultUnit
Gain0 – 41—

# PhaseDiff 2 inputs

Wrapped phase distance: treats in0 and in1 as phases on a [-1, 1] cycle and outputs their shortest signed difference, folded back into [-1, 1] so a value near the +1/-1 seam still reads as a small gap instead of a near-2 jump. Where Subtract gives the raw (unwrapped) difference and AbsDiff its unsigned size, PhaseDiff respects the circular wrap - compare two LFO/oscillator phases, measure how far a phasor has drifted, or build a phase-lock error signal.

# Asin 1 input

Arcsine shaper: clamps in0 to [-1, 1] then outputs asin(in0) * 2/pi, an odd curve that is gentle through the centre and steepens sharply as it nears the rails - the circular cousin of Atanh (which steepens harder) and the inverse of a sine-shaped saturator. Use it to expand the mid-range of a normalised CV, add edge near the extremes, or pre-warp a value before a sine lookup. Input outside +/-1 is clamped.

# Acos 1 input

Arccosine shaper: clamps in0 to [-1, 1] then outputs acos(in0) / pi, a smooth monotone curve that falls from 1 (at in0 = -1) to 0 (at in0 = +1), passing 0.5 at the centre. Where Complement inverts a unit range linearly, Acos inverts it along a cosine arc - eased at both ends and steepest in the middle. A drop-in curved 'one minus' for a normalised control, or the falling partner to Asin's rising shape.

# Erf 1 input

Error-function sigmoid: outputs erf(Drive * in0), the Gaussian-integral S-curve that eases through zero and saturates smoothly toward +/-1 as the input grows. Drive sets the steepness. It sits between Atan (a gentle, slowly-saturating knee) and a hard tanh clip - a distinct, statistically-flavoured soft saturator whose shoulder rolls off faster than the logistic. Soft-limit a CV or warm an audio signal with a rounded, never-clipping ceiling.

ParamRangeDefaultUnit
Drive0.1 – 82—

# Logit 1 input

Logit (inverse-logistic) expander: clamps in0 to [1-Edge, Edge] then outputs log(p / (1 - p)) normalised so the Edge maps to +/-1. The exact inverse of Logistic - it takes a squashed 0..1 probability-like signal and stretches it back out, gentle near the 0.5 centre and steepening toward the 0/1 ends. Edge sets how close to 0/1 the input may get before the slope runs away (the clamp keeps it finite). Expand a compressed envelope or undo a logistic soft-knee.

ParamRangeDefaultUnit
Edge0.5 – 0.9990.99—

# TriShape 1 input

Phasor-to-triangle shaper: treats in0 as a phase and outputs a triangle that rises 0 -> 1 over the first half of each cycle and falls 1 -> 0 over the second, repeating every 1/Freq of input. Where Frac turns a rising ramp into a sawtooth, TriShape turns it into a symmetric triangle - reshape a phasor or accumulator into a triangle LFO, or fold a linear sweep into an up-down contour without an oscillator. Freq multiplies the cycle count.

ParamRangeDefaultUnit
Freq0 – 161—

# SignGate 2 inputs

Polarity transplant: outputs the magnitude of input A carrying the sign of input B - a one-bit ring modulator that imposes B's zero-crossing structure on A's amplitude.

ParamRangeDefaultUnit
Level0 – 21—

# GlitchHold 1 input

Sample-level glitch hold: with a set probability it freezes the current sample for a random run length, producing buffer-underrun-style digital stutter and aliasing artifacts (RT-safe deterministic RNG).

ParamRangeDefaultUnit
Prob0 – 10.2—
MaxLen1 – 2000200smp
Level0 – 11—

# BitRepeat 1 input

Fixed-rate sample-hold decimator: re-samples the input at a chosen rate and holds between samples (the deterministic, non-random cousin of a glitch hold) - classic downsampling aliasing and lo-fi character.

ParamRangeDefaultUnit
Rate100 – 240004000Hz
Mix0 – 11—

# RevGrain 1 input

Reverse-grain looper: continuously plays the most recent window of input backwards on a loop, layering a reversed echo of what just happened - granular reverse texture with no transport.

ParamRangeDefaultUnit
Length10 – 20080ms
Mix0 – 10.5—

# SampleSkip 1 input

Random sample dropout: with a set probability each sample is discarded and the previous one held, simulating a glitching digital link - bit-rot crackle and stutter, deterministic (RT-safe) RNG.

ParamRangeDefaultUnit
Prob0 – 10.2—
Level0 – 11—

# SlewExp 1 input

Exponential slew limiter: limits how fast the output can follow, but with an exponential (RC-style) approach whose speed grows with the distance to the target - smooth glide / portamento with a natural curve, separate rise and fall.

ParamRangeDefaultUnit
Rise1 – 100030ms
Fall1 – 100030ms

# DitherCrush 1 input

Dithered bit reducer: requantizes to a chosen bit depth after adding triangular (TPDF) dither, so the bit-crush decorrelates into a smooth noise floor instead of correlated distortion - lo-fi done the right way.

ParamRangeDefaultUnit
Bits2 – 168—
Dither0 – 11—
Level0 – 10.9—

# CrossfadeLoop 1 input

Crossfade looper: two overlapping read-heads replay the most recent window forward on a loop with triangular crossfades, so the captured texture repeats seamlessly with no click at the loop point - an instant stutter/loop layer.

ParamRangeDefaultUnit
Length50 – 1000400ms
Mix0 – 10.6—

# MinMaxGate 2 inputs

Two-input logic combiner: outputs the minimum, maximum or absolute difference of two signals - the analog-logic building block for combining CVs, rectifying differences or wave-multiplexing two sources.

ParamRangeDefaultUnit
ModeMin · Max · AbsDiff—
Level0 – 11—

# LogicGate 2 inputs

Gate logic: treats two inputs as boolean gates and outputs their AND, OR, XOR or NAND - the combinational-logic building block for deriving new triggers and rhythms from two existing gate streams.

ParamRangeDefaultUnit
OpAND · OR · XOR · NAND—

# Comparator 2 inputs

Comparator: outputs a gate that goes high when input A rises above input B and low when it falls below by a hysteresis margin - turns any signal into a clean trigger with no chatter near the threshold.

ParamRangeDefaultUnit
Hysteresis0 – 0.50.05—
Level0 – 11—

# Attenuvert 1 input

Attenuverter + offset: scales the input by a bipolar gain (can invert) and adds a DC offset - the fundamental CV-shaping utility for inverting, attenuating and biasing control or audio signals.

ParamRangeDefaultUnit
Gain-2 – 21—
Offset-1 – 10—

# SampHold 2 inputs

Sample and hold: captures the value of the signal input at the instant the trigger input rises and holds it until the next trigger - the classic stepped/random voltage source when fed noise and a clock.

ParamRangeDefaultUnit
Level0 – 11—

# TrackAndHold 2 inputs

Track and hold: follows the signal input while the gate is open and freezes the last value when the gate closes - a glitch-free way to freeze a moving signal or build sample-and-hold with a variable aperture.

ParamRangeDefaultUnit
Level0 – 11—

# PeakFollow 1 input

Peak follower: tracks the instantaneous peak of the signal and decays back down at a set rate, a fast-attack/slow-release detector that produces a clean envelope CV for triggering or amplitude-following.

ParamRangeDefaultUnit
Decay1 – 2000200ms
Sens0 – 41—

# SlopeDetect 1 input

Slope detector: outputs a smoothed derivative of the input, positive while it rises and negative while it falls - a movement/transient CV for triggering on direction changes or driving slew-dependent effects.

ParamRangeDefaultUnit
Gain1 – 20040—
Smooth1 – 505ms

# GrainCloud 1 input

Granular cloud: continuously sprays short windowed grains plucked from random positions in the recent input buffer, smearing the source into an evolving textural cloud - the core of granular texture synthesis.

ParamRangeDefaultUnit
Density5 – 20060Hz
Spread10 – 500200ms
Mix0 – 10.7—

# TapeBrake 2 inputs

Tape stop: when the gate goes high the playback speed of a short buffer ramps down to a standstill (pitch and tempo falling together), then spins back up when released - the DJ/turntable brake effect.

ParamRangeDefaultUnit
Time50 – 2000600ms
Mix0 – 11—

# BeatRepeat 2 inputs

Beat repeat: on each trigger it grabs the most recent slice and loops it for the slice length, freezing the groove into a glitchy stutter until the next trigger - the classic beat-repeat/roll effect.

ParamRangeDefaultUnit
Slice20 – 500125ms
Mix0 – 11—

# XFade 2 inputs

Equal-power crossfade: blends two inputs with a constant-power (sine/cosine) law so the perceived loudness stays even across the whole sweep - the correct way to morph or A/B between two signals.

ParamRangeDefaultUnit
Fade0 – 10.5—
Level0 – 11—

# RectifyCV 1 input

Rectifier: passes only the positive half, only the negative half, or the absolute value of the signal, then offsets it - the analog full/half-wave rectifier for deriving envelopes and folding control voltages.

ParamRangeDefaultUnit
ModeHalf+ · Half- · Full—
Offset-1 – 10—

# GranScrub 2 inputs

Granular scrubber: a position CV moves a windowed grain freely through the recent input buffer, so you can freeze, slow-scrub or jump around the recent audio in real time - tape-scrub/timestretch by hand.

ParamRangeDefaultUnit
Grain20 – 20080ms
Mix0 – 11—

# HilbertEnv 1 input

Instantaneous amplitude: forms an approximate quadrature (90-degree) partner of the signal via an all-pass and takes the magnitude of the analytic signal, tracking the true envelope even within a single cycle - smoother than a rectified follower.

ParamRangeDefaultUnit
Smooth0.1 – 202ms
Sens0 – 41—

# SlewLimAsym 1 input

Asymmetric slew limiter: caps how fast the output may rise and fall independently with a hard (linear, constant-slope) limit, for lag/portamento or attack-vs-release shaping with a straight-line edge rather than an exponential curve.

ParamRangeDefaultUnit
Rise1 – 200050ms
Fall1 – 200050ms

# WaveSetRepeat 1 input

Waveset repeat: detects each cycle between rising zero crossings (a 'waveset') and replays it a number of times before moving on, the Trevor-Wishart waveset-distortion technique that drops pitch and adds buzzy sub-harmonics.

ParamRangeDefaultUnit
Repeat1 – 82—
Mix0 – 11—

# RmsFollow 1 input

RMS follower: tracks the running root-mean-square of the signal rather than its peak, giving a smooth loudness-correlated envelope (the detector loudness meters and RMS compressors use) - steadier than a rectified peak follower.

ParamRangeDefaultUnit
Window1 – 50050ms
Sens0 – 41—

# BrightCV 1 input

Brightness follower: compares the energy above a split frequency to the total energy and outputs the ratio, a cheap spectral-centroid-style 'how bright is it right now' control voltage for driving timbre-reactive patches.

ParamRangeDefaultUnit
Split500 – 60002000Hz
Smooth1 – 20030ms

# NoiseRate 1 input

Noisiness follower: measures the zero-crossing rate of the signal (low for tones, high for noise) and outputs it as a control voltage, a tone-vs-noise discriminator for driving gates, filters or morphs.

ParamRangeDefaultUnit
Smooth1 – 20030ms
Gain0.2 – 41—

# CrestCV 1 input

Crest-factor follower: outputs the ratio of peak level to RMS level, which is high for spiky percussive material and low for sustained tones - a 'how punchy is it' control voltage for transient-aware patching.

ParamRangeDefaultUnit
Window5 – 30050ms
Gain0.2 – 20.7—

# GranTimeStretch 1 input

Granular time stretch: overlapping grains advance their read position slower (or faster) than real time, stretching or compressing the recent audio's duration while leaving its pitch unchanged - time-domain timestretching.

ParamRangeDefaultUnit
Stretch0.25 – 42—
Grain30 – 15080ms
Mix0 – 11—

# WindowGate 1 input

Window comparator: outputs a high gate only while the input sits between a lower and upper bound, the analog window-detector used to fire triggers when a control voltage passes through a specific range.

ParamRangeDefaultUnit
Low-1 – 1-0.2—
High-1 – 10.2—
Level0 – 11—

# LogSumExp 2 inputs

Smooth maximum: log(e^(k*a)+e^(k*b))/k, a differentiable soft-max of two signals that rounds the corner where a plain max would kink. Sharp sets how tightly it hugs the true maximum (high) versus averaging the two inputs (low) - a smooth selector/combiner.

ParamRangeDefaultUnit
Sharp0.5 – 102—

# SmoothMin 2 inputs

Polynomial smooth minimum: blends toward min(a,b) but rounds the crossover with a quadratic over a window K (the computer-graphics smin) - a compact-support soft-min distinct from the exponential log-sum-exp, for gentle kink-free combining or ducking of two signals.

ParamRangeDefaultUnit
K0.01 – 10.3—

# PowerMean 2 inputs

Power mean: the generalized Holder mean of the two input magnitudes ((|a|^p+|b|^p)/2)^(1/p), where Power sweeps continuously through harmonic (-1), geometric (0), arithmetic (1) and RMS (2) means - one knob spanning every classical average for combining envelopes or control signals.

ParamRangeDefaultUnit
Power-2 – 21—

# CopySign 2 inputs

Copy-sign: outputs the magnitude of A carrying the sign (polarity) of B - so B's zero-crossings/phase drive A's, useful for re-polarizing a signal, building ring-mod-like polarity gating, or forcing one source to follow another's sign pattern.

ParamRangeDefaultUnit
Gain0 – 21—

# AbsDiffSq 2 inputs

Squared difference: (a-b)^2 scaled, which is zero when the two inputs match and grows quadratically as they diverge - a sharp similarity/error detector for sidechaining, gating on signal mismatch, or driving modulation from how far apart two sources are.

ParamRangeDefaultUnit
Scale0 – 41—

# AbsSum 2 inputs

Sum of magnitudes: |a|+|b| scaled, the combined rectified level of two sources - a quick total-energy/activity signal for driving envelopes, gates or meters from a pair of inputs, distinct from a signed mix or a max-of-magnitudes.

ParamRangeDefaultUnit
Gain0 – 21—

# ContraharmonicMean 2 inputs

Contraharmonic mean: outputs (|a|^2+|b|^2)/(|a|+|b|) of the two inputs, a mean that always lies above the arithmetic mean and is pulled toward whichever input is larger - useful for level-combining that favours the louder source. Gain scales the result.

ParamRangeDefaultUnit
Gain0 – 21—

# LehmerMean 2 inputs

Lehmer mean: outputs (|a|^p+|b|^p)/(|a|^(p-1)+|b|^(p-1)), a one-parameter family that gives the harmonic mean at Power=0, the arithmetic at 1 and the contraharmonic at 2 - so Power continuously biases the combination from the smaller toward the larger input.

ParamRangeDefaultUnit
Power0 – 31.5—

# HeronianMean 2 inputs

Heronian mean: outputs (|a| + sqrt(|a||b|) + |b|)/3, the mean used for the volume of a frustum - it sits between the geometric and arithmetic means, a gentle blend of two sources that leans slightly toward their average. Gain scales the result.

ParamRangeDefaultUnit
Gain0 – 21—

# LogMean 2 inputs

Logarithmic mean: outputs (|a|-|b|)/(ln|a|-ln|b|) (and |a| when they are equal), the mean from heat-transfer analysis that lies strictly between the geometric and arithmetic means - a smooth combiner biased toward the smaller value. Gain scales the result.

ParamRangeDefaultUnit
Gain0 – 21—

# CentroidalMean 2 inputs

Centroidal mean: outputs (2/3)(|a|^2+|a||b|+|b|^2)/(|a|+|b|), the x-coordinate of the centroid of the region under a line between the two values - another above-arithmetic mean with its own bias toward the larger input, distinct from the contraharmonic. Gain scales the result.

ParamRangeDefaultUnit
Gain0 – 21—

# StolarskyMean 2 inputs

Stolarsky mean: outputs ((a^p-b^p)/(p(a-b)))^(1/(p-1)) of the two input magnitudes, a difference-based family that interpolates the logarithmic, geometric, identric and power means as Power varies - a richly-tunable two-source combiner. Bounded.

ParamRangeDefaultUnit
Power-2 – 32—

# GiniMean 2 inputs

Gini mean: outputs ((a^R+b^R)/(a^S+b^S))^(1/(R-S)) of the two input magnitudes, a two-exponent generalization of the power means - R and S together place the result anywhere from harmonic-like to contraharmonic-like, the most flexible of the two-source mean combiners. Bounded.

ParamRangeDefaultUnit
R0 – 32—
S0 – 31—

# HypotDiff 2 inputs

Hypotenuse difference: outputs sqrt(max(0, a^2 - b^2)), the remaining leg of a right triangle given the hypotenuse A and one side B (and zero when B exceeds A) - a complement to the usual hypot, useful for de-correlation, sideband math or gating when one signal overtakes another. Gain scales the result.

ParamRangeDefaultUnit
Gain0 – 21—

# MinkowskiMix 2 inputs

Minkowski (p-norm) mixer: combines two inputs by their L-p norm (|a|^Norm+|b|^Norm)^(1/Norm), carrying the sign of their sum - at Norm=1 it sums magnitudes, at Norm=2 it is the Euclidean/RMS blend, and as Norm grows it approaches a max() of the two. A tunable interpolation between additive and maximum mixing. Bounded.

ParamRangeDefaultUnit
Norm0.5 – 82—
Level0 – 10.6—

# LmsCanceller 2 inputs

LMS adaptive canceller: an 8-tap adaptive FIR (least-mean-squares) that filters the reference input (in 2) to best match the correlated component of the primary input (in 1), then subtracts it - the classic adaptive setup for stripping hum, a tone, or any reference-correlated noise out of a signal. StepSize sets adaptation speed vs stability; the output is the residual error.

ParamRangeDefaultUnit
StepSize0 – 0.050.005—
Level0 – 11—

# NlmsCanceller 2 inputs

Normalized-LMS canceller: an 8-tap adaptive FIR like the plain LMS canceller, but the step is divided by the reference signal's instantaneous power - so convergence speed no longer depends on input level and it adapts faster and more stably across quiet and loud passages. Filters reference (in 2) to cancel its correlated part from primary (in 1); outputs the residual.

ParamRangeDefaultUnit
StepSize0.01 – 1.50.5—
Level0 – 11—

# MinMaxMorph 2 inputs

Order-statistic morph: blends the sample-by-sample minimum and maximum of two inputs by Morph - at 0 it outputs min(a,b) (an AM-like duck to the quieter signal), at 1 it outputs max(a,b) (an OR-style combine to the louder), and at 0.5 their average. A continuous slider across the order statistics of two signals, distinct from additive or ring mixing.

ParamRangeDefaultUnit
Morph0 – 10.5—
Level0 – 11—

# Sum 4 inputs

Summing node: adds inputs in 1..4 into a single output with no per-input gain - the quick way to merge oscillators, parallel chains or control signals without wiring up a full Mixer.

# Analyzer 2 inputs

Signal analyzer: passes in 1 straight through (out = in 1, transparent in the chain) while its detail panel shows a live 3D FFT waterfall + oscilloscope of in 1, and a Lissajous (X-Y) phase scope of in 1 against in 2. A measurement tool, not an effect - drop it inline to see the spectrum feeding a filter, the harmonics a distortion adds, what an envelope follower tracks, or the stereo/phase relationship of two signals.

# ClockDiv 1 input

Clock divider: passes only every Div-th rising edge of the in0 trigger, turning a fast gate or clock into a slower one for polyrhythms and rhythmic gating. The output mirrors the input pulse on the pulses it lets through and is silent otherwise, and the count stays phase-locked to the input.

ParamRangeDefaultUnit
Div2 – 162—

# Counter 2 inputs

Pulse counter / staircase: each rising edge of the in0 trigger advances an internal count, and the output is that count scaled to 0..1 over Steps before wrapping to zero - a stepped CV ramp for sequences and rhythmic builds. A rising edge on in1 resets the count so it can be re-synced to a bar.

ParamRangeDefaultUnit
Steps2 – 328—

# TrigToGate 1 input

Trigger-to-gate: each rising edge of the in0 trigger opens a gate that stays high for a fixed Length, then closes - turning a momentary pulse (a clock tick, a Compare edge) into a sustained gate of predictable duration. Retriggering restarts the timer, so a stream of pulses keeps the gate open. Drive envelopes, VCAs or effects from short triggers.

ParamRangeDefaultUnit
Length1 – 100050ms

# ClockMult 1 input

Clock multiplier: measures the period of the in0 clock and emits Mult evenly-spaced pulses per input beat - the complement to ClockDiv, for faster subdivisions and ratchets. Locks to the input tempo on every edge so it tracks tempo changes.

ParamRangeDefaultUnit
Mult2 – 82—

# GateDelay 1 input

Trigger delay: a rising edge on in0 is held for Time, then re-emitted as a short pulse - shift a trigger later in time to stagger hits, build echoes of a clock or offset a sequence. Each input edge arms an independent delay.

ParamRangeDefaultUnit
Time1 – 2000100ms

# FlipFlop 2 inputs

T (toggle) flip-flop: each rising edge of the in0 trigger flips the output between 0 and 1, halving the clock and turning a stream of triggers into a square gate. A rising edge on in1 resets it to 0. The bistable building block for clock division and on/off latching.

# ShiftReg 2 inputs

Analog shift register: each rising edge of the in0 clock shifts the in1 voltage one stage down a chain, and the output is the value Stages steps ago - a tapped delay for CV that turns a melody or random source into canonic, echoing pitch patterns. The classic Buchla/Triadex-style sequencing trick.

ParamRangeDefaultUnit
Stages1 – 84—

# WindowComp 1 input

Window comparator: outputs a high gate whenever the in0 voltage sits inside the Low..High window, and low when it strays outside - a band detector for triggering events when a CV enters a range, or for extracting a slice of a modulation curve.

ParamRangeDefaultUnit
Low-1 – 1-0.3—
High-1 – 10.3—

# MinMax 2 inputs

Minimum / maximum selector: outputs either the smaller or the larger of the two input voltages each sample - an analog comparator-style utility for combining envelopes, CVs or gates (max = OR-like, min = AND-like). Mode picks min or max. in0, in1 = inputs.

ParamRangeDefaultUnit
Mode0 – 11—

# Hysteresis 1 input

Schmitt trigger with memory: the output latches High once in0 rises above the upper threshold (Center + Width) and stays High until in0 falls below the lower threshold (Center - Width), then latches Low. Because it remembers its last state, a noisy or slowly-drifting signal around one level produces a clean debounced gate instead of chattering - unlike the stateless Compare, which has no memory.

ParamRangeDefaultUnit
Center-1 – 10—
Width0 – 10.1—
High-1 – 11—
Low-1 – 1-1—

# PeakHold 2 inputs

Peak / hold detector: latches the extreme value in0 reaches and holds it, optionally bleeding back toward zero at Decay (Decay 0 = hold forever). Mode picks the maximum (Peak), the minimum (Trough), or the largest magnitude (Abs Peak). A rising edge on the in1 reset clears the held value to the current input. Where EnvFollow smooths the amplitude with attack/release, PeakHold captures the strict extreme - peak-metering CV, grabbing the loudest transient, or a max-tracking sample-and-hold.

ParamRangeDefaultUnit
Decay0 – 10—
ModePeak · Trough · Abs Peak—

# Latch 2 inputs

Bistable latch / flip-flop: remembers a High/Low state across time. In Toggle mode each rising edge on in0 flips the state (a clock divide-by-two, or tap-to-toggle). In Set/Reset mode a rising edge on in0 sets the output High and a rising edge on in1 sets it Low (a one-bit memory cell driven by two triggers). Outputs High when set and Low when clear - the missing fundamental logic block alongside Compare, Logic and Hysteresis.

ParamRangeDefaultUnit
ModeToggle · Set/Reset—
High-1 – 11—
Low-1 – 10—

# CrossTrig 1 input

Crossing detector: emits a one-sample High pulse each time in0 crosses the Level (zero by default), on the Rising, Falling or Both edge as selected. Turns an oscillator or LFO into a clock (a zero-crossing tick), derives a trigger from a gate's edge, or fires an event when a signal passes a threshold. Pairs with TrigToGate to stretch the pulse into a sustained gate.

ParamRangeDefaultUnit
Level-1 – 10—
EdgeRising · Falling · Both—

# Switch 4 inputs

Clocked sequential switch: routes one of the signal inputs in0..in2 to the output and advances to the next on every rising edge of the in3 clock - an addressed router (Doepfer A-151 style) that steps through your sources in time. Steps sets how many inputs are in the rotation (2 or 3). Where Mux selects an input by a manual index and Select chooses between two by level, Switch cycles automatically on a clock.

ParamRangeDefaultUnit
Steps2 – 33—

# Bernoulli 1 input

Bernoulli gate (coin-flip router): on each rising edge of the in0 trigger it flips a weighted coin and either passes that gate through or blocks it, with Probability setting the odds. A stream of clocks becomes a randomly thinned-out pattern - the building block for generative rhythms and stochastic sequencing. Unlike the deterministic ClockDiv, every pulse is an independent chance event; the decision latches until the next trigger.

ParamRangeDefaultUnit
Probability0 – 10.5—

# Burst 1 input

Burst generator: a rising edge on in0 fires a burst of Count evenly-spaced trigger pulses at Rate, then falls silent until the next input edge - turn one hit into a ratchet, a drum-roll trigger or a stutter clock. Count sets how many pulses and Rate their spacing; re-triggering mid-burst restarts the count. Patch its output into envelopes, sample-and-holds or sequencer clocks.

ParamRangeDefaultUnit
Count1 – 164—
Rate1 – 10020Hz

# Integrator 2 inputs

Leaky integrator / accumulator (CV): sums in0 over time so a constant input ramps and a periodic input is smoothed and phase-shifted a quarter cycle. Rate scales the input before accumulation, Leak bleeds the accumulator toward zero (0 = a near-perfect integrator that holds, higher = a shorter-memory smoother), and a rising edge on in1 resets the sum to zero. The running output is safety-limited. Distinct from Slew (which rate-limits a signal) and Counter (which counts edges).

ParamRangeDefaultUnit
Rate-8 – 81—
Leak0 – 10.3—

# Slope 1 input

Differentiator / rate-of-change detector (CV): outputs how fast in0 is moving - positive while it rises, negative while it falls, zero when steady - so it reads the slope of an envelope, LFO or any control signal. Scale sets the sensitivity and Smooth low-passes the result to tame noise on fast signals. Pair it with Compare to fire a trigger on a rising or falling edge. The inverse complement of the Integrator.

ParamRangeDefaultUnit
Scale0 – 10.05—
Smooth0 – 10.2—

# TrackHold 2 inputs

Track-and-hold (Doepfer A-148): while the gate at in1 is high the output follows the in0 signal; when the gate goes low it freezes and holds the last value until the gate returns. Unlike Sample-and-hold (which grabs one instant on a trigger), it tracks continuously through the whole gate - use it to freeze a slow LFO or envelope, glide-and-hold pitch, or window a control signal. A core CV utility.

# PhaseInvert 1 input

Flips the polarity of the signal, negating every sample when engaged and passing it untouched otherwise. Invert toggles the inversion on or off. Use it to correct out-of-phase tracks or to null one source against another.

ParamRangeDefaultUnit
Invert0 – 11—

# DCBlock 1 input

Removes DC offset and sub-sonic bias with a one-pole high-pass that subtracts the previous input and feeds back a 0.9995 coefficient, passing audio while draining any constant component. It takes no parameters and always runs at the same fixed corner. Place it after asymmetric distortion or rectification stages to keep the signal centred.

# Entropy 1 input

Information-theoretic modulation source (a first as a synth block): outputs a running Shannon-entropy estimate of the input - near 0 for silence or a steady tone, rising toward 1 for noisy, unpredictable signals. It folds recent samples into a decaying 16-bin amplitude histogram and reports the normalised entropy of that distribution, answering 'how disordered is this signal right now?' as a control voltage. Window sets the memory (higher = slower, smoother). Patch it so an effect opens up only when the input turns chaotic.

ParamRangeDefaultUnit
Window0.001 – 10.05—

# Stochastic 1 input

Stochastic-resonance detector (a first as a synth block): the real phenomenon where adding the RIGHT amount of noise lets a weak, sub-threshold signal cross a detector it otherwise never could - too little and the signal stays buried, too much and it drowns. Noise sets the injected level, Threshold the detector, Smooth the output ballistic, and the output is the recovered crossing envelope. Sweep Noise to find the resonance sweet spot where a rhythm hidden below the threshold suddenly emerges.

ParamRangeDefaultUnit
Threshold0 – 10.5—
Noise0 – 10.3—
Smooth0.001 – 10.05—

# Surprise 1 input

Adaptive novelty detector (a first as a synth block): keeps a self-tuning one-tap linear predictor of the input and outputs the magnitude of its prediction error - a spike whenever the signal does something the recent past did not predict, near silence while it stays predictable. Unlike Slope (the raw derivative, which stays high through any steady ramp) Surprise LEARNS the trend and fires only on genuine novelty: a new note, a sudden jump, a broken pattern. Rate sets how fast it adapts, Smooth the output ballistic.

ParamRangeDefaultUnit
Rate0 – 10.3—
Smooth0.001 – 10.05—

# Correlate 2 inputs

Two-signal relatedness meter (a first as a synth block): outputs a running normalised cross-correlation of in0 against in1 - how strongly the two signals move together - as a control voltage. About +1 when they rise and fall in lock-step, 0 when independent, -1 when they mirror each other. Window sets the averaging time. Detect when two modulators line up, gate an effect on the agreement of two sources, or measure stereo/phase coherence. Both inputs must vary (a constant has no correlation).

ParamRangeDefaultUnit
Window0 – 10.02—

# Periodicity 1 input

Self-similarity detector (a first as a synth block): writes the input to a delay line and outputs the running normalised correlation between the signal now and the signal one Period ago - how strongly it repeats itself at that lag. About 1 for a steady tone or loop whose cycle matches Period, near 0 for noise or a one-shot, so it reports the STRENGTH of repetition rather than the pitch (set Period to the cycle you are listening for). Window sets the averaging time. Drive an effect by how locked-in a groove is.

ParamRangeDefaultUnit
Period0.1 – 10010ms
Window0 – 10.02—

# Dither 1 input

Bit-depth reducer with triangular (TPDF) dither: builds a quantization step from Bits, adds triangular noise from two xorshift draws scaled by Amount, then rounds to the step. Bits sets the target word length from 8 to 24 and Amount scales the dither level. The dither decorrelates quantization error so low-level detail survives reduction instead of distorting.

ParamRangeDefaultUnit
Bits8 – 2416—
Amount0 – 11—

# CVBridge 1 input

Control-voltage utility that conditions a single input value in one of three Mode settings: attenuvert (scale by Scale plus Offset), note-to-1V/oct pitch conversion, or bipolar-to-unipolar remap. Scale provides positive or negative gain including inversion, and Offset shifts the result up or down. Useful for routing and rescaling modulation or pitch control between modules.

ParamRangeDefaultUnit
Mode0 – 20—
Scale-2 – 21—
Offset-1 – 10—

# Meter 1 input

Analysis meter that tracks the running mean-square of the input and outputs its RMS level as a scalar control value. Smooth sets the one-pole averaging coefficient, with higher values giving slower, steadier readings and lower values reacting faster to transients. Used to derive a level signal for metering or to drive other modules from program loudness.

ParamRangeDefaultUnit
Smooth0 – 0.9990.99—

# NullTest 2 inputs

Null tester that subtracts the second input from the first and outputs the residual difference, scaled by Gain. When two signals are identical the output is silence, and any audible residual reveals the difference between them. Gain amplifies that residual so small mismatches become easy to hear, making this a tool for verifying bit-for-bit equivalence between processing chains.

ParamRangeDefaultUnit
Gain0 – 41—

Control

5 modules

# CCMap 1 input

Remaps a CC number and scales/offsets its value.

ParamRangeDefaultUnit
From-1 – 1271—
To0 – 12711—
Scale0 – 21—
Offset-1 – 10—

# Note2CC 1 input

Emits a CC from each note (pitch or velocity).

ParamRangeDefaultUnit
CC0 – 1271—
SourcePitch · Velocity—

# CC2Note 1 input

A watched CC crossing a threshold triggers a note.

ParamRangeDefaultUnit
Watch0 – 1271—
Note0 – 12760—
Threshold0 – 10.5—

# BendProc 1 input

Scales and/or inverts incoming pitch-bend.

ParamRangeDefaultUnit
Scale0 – 21—
Invert0 – 10—

# ATProc 1 input

Scales aftertouch, optionally converting it to a CC.

ParamRangeDefaultUnit
Scale0 – 21—
To CC-1 – 127-1—

EQ

4 modules

# Baxandall 1 input

Baxandall negative-feedback tone network: the classic hi-fi Bass/Treble - a gentle low shelf (~100 Hz) and high shelf (~10 kHz) that boost or cut smoothly and symmetrically, with none of the midrange scoop of a passive stack. Bass and Treble in dB.

ParamRangeDefaultUnit
Bass-15 – 150dB
Treble-15 – 150dB

# MassivePassive 1 input

Manley Massive Passive-style EQ: broad, gentle passive-network shelf and bell curves with wide, interactive Q - boosts feel airy and musical rather than surgical, the reason it's a mastering staple. Low shelf, a wide high bell at HiFreq, and an Air shelf on top, each in dB.

ParamRangeDefaultUnit
Low-11 – 110dB
High-11 – 110dB
HiFreq2000 – 160008000Hz
Air0 – 80dB

# Sontec 1 input

Sontec MEP-250-style mastering parametric EQ: clean Class-A bell bands with a musical, selectable Q - precise without sounding clinical, the mastering standard. Two parametric bells (Lo/Hi freq + gain) sharing the Q control.

ParamRangeDefaultUnit
LoFreq40 – 1200200Hz
LoGain-10 – 100dB
HiFreq1500 – 180006000Hz
HiGain-10 – 100dB
Q0.4 – 31—

# Neve1081 1 input

Neve 1081-style 4-band EQ: the 1073's bigger brother with a fixed HF and LF shelf PLUS two independently sweepable mid bells (the 1073 has only one), into an iron-core transformer whose LF flux saturates first for genuine low-end warmth. High/Low set the shelves, LoMid/HiMid the two bell gains, LoMidFreq/HiMidFreq their centres.

ParamRangeDefaultUnit
Low-16 – 160dB
LoMid-18 – 180dB
LoMidFreq200 – 1500500Hz
HiMid-18 – 180dB
HiMidFreq1500 – 90003500Hz
High-16 – 160dB

Effect

52 modules

# Lockhart 1 input

Lockhart-style transistor wavefolder (west-coast): the signal reflects off the rails through several folding stages, multiplying harmonics as Fold rises - the Buchla/Serge timbre. 4x-oversampled.

ParamRangeDefaultUnit
Fold1 – 163—
Symmetry-1 – 10—
Mix0 – 11—

# FreqShifter 1 input

Frequency shifter: builds an approximate quadrature (Hilbert) pair of the input through two allpass paths and ring-modulates them with a complex exponential, shifting every partial by a fixed Hz amount (not a pitch ratio) - the inharmonic, Bode-style shifter.

ParamRangeDefaultUnit
Shift-500 – 500100Hz
Mix0 – 11—

# Warps 2 inputs

Cross-modulator (meta): blends two inputs through one of four cross-modulation algorithms - crossfade, amplitude mod, ring mod, or sine wavefold of in0 by in1 - with Amount morphing from the clean carrier into the modulated signal. One knob from subtle movement to clangorous metallic timbres.

ParamRangeDefaultUnit
Algorithm0 – 32—
Amount0 – 10.5—

# SubBass 1 input

Sub-octave generator: tracks the in0 signal and synthesises a clean sine/square one octave below, fattening basslines and kicks with weight a normal octaver can't. Tone shapes the sub from pure sine to growl, Mix blends it under the dry signal.

ParamRangeDefaultUnit
Tone0 – 10.3—
Mix0 – 10.6—

# VinylSim 1 input

Vinyl record emulation: passes in0 through a wow/flutter pitch wobble (a slowly-modulated delay), a band-limiting filter and added surface crackle - the warm, worn character of a played record. Wow sets the pitch wobble, Crackle the surface noise, Mix the blend.

ParamRangeDefaultUnit
Wow0 – 10.4—
Crackle0 – 10.3—
Tone0 – 10.5—
Mix0 – 11—

# ToneStack 1 input

Passive guitar-amp tone stack: the interacting Bass / Mid / Treble shelving network of a Fender/Marshall preamp, with the characteristic mid scoop when the controls interact. Bass boosts the lows, Treble the highs, Mid cuts or boosts the middle. in0 = Audio.

ParamRangeDefaultUnit
Bass0 – 10.5—
Mid0 – 10.5—
Treble0 – 10.5—

# Overdrive 1 input

Tube-style overdrive: a smooth tanh soft-clip with a midrange-focused drive, warming and compressing the signal the way a pushed valve preamp does - the Tube Screamer voicing. Drive sets the gain into the clip, Tone the post brightness, Level the output. in0 = Audio.

ParamRangeDefaultUnit
Drive1 – 406dB
Tone0 – 10.5—
Level0 – 10.7—

# DiodeClipper 1 input

Diode clipper: a symmetric pair of clipping diodes giving a soft-knee crunch that rounds into hard saturation as it's pushed - the core of countless distortion pedals. Drive sets the gain, Bias skews the symmetry toward even harmonics, Level the output. in0 = Audio.

ParamRangeDefaultUnit
Drive1 – 6010dB
Bias-0.5 – 0.50—
Level0 – 10.6—

# RatDist 1 input

RAT-style distortion: a hard op-amp clip into a sweepable lowpass 'filter' control, giving the aggressive, fuzzy-yet-focused ProCo RAT grind. Drive sets the gain into the clip, Filter rolls off the top (counter-clockwise = darker), Level the output. in0 = Audio.

ParamRangeDefaultUnit
Drive1 – 6018dB
Filter0 – 10.6—
Level0 – 10.5—

# Foldback 1 input

Foldback distortion: instead of clipping, any signal past the threshold is reflected back on itself, generating bright, ring-mod-like upper harmonics that grow chaotically with drive - harsher and more digital than soft clipping. Drive sets the level into the fold, Thresh the fold point, Level the output. in0 = Audio.

ParamRangeDefaultUnit
Drive1 – 304dB
Thresh0.1 – 10.6—
Level0 – 10.5—

# AMRadio 1 input

AM-radio lo-fi: band-limits in0 to a tinny midrange, adds a faint carrier hum and a wash of static, the sound of a distant transistor radio. Band sets the midrange tightness, Static the noise level, Mix the blend. in0 = Audio.

ParamRangeDefaultUnit
Band0 – 10.5—
Static0 – 10.3—
Mix0 – 11—

# Megaphone 1 input

Megaphone / bullhorn: forces in0 through a harsh, peaky midrange band and clips it, the distorted, honking voice-of-authority sound. Honk sets the resonant peak, Drive the clipping, Mix the blend. in0 = Audio.

ParamRangeDefaultUnit
Honk0 – 10.6—
Drive1 – 308dB
Mix0 – 11—

# PhaserStages 1 input

Multi-stage phaser: a cascade of all-pass sections swept by a built-in LFO, with feedback for deeper notches - from a subtle shimmer to a vocal, resonant sweep. Rate sets the LFO, Stages the notch count, Feedback the resonance, Mix the depth. in0 = Audio.

ParamRangeDefaultUnit
Rate0.05 – 80.5Hz
Stages2 – 84—
Feedback0 – 0.90.5—
Mix0 – 10.6—

# RotarySpeaker 1 input

Rotary speaker (Leslie): a spinning-horn cabinet that adds pitch-doppler vibrato and amplitude tremolo, sweeping between slow (chorale) and fast (tremolo) - the swirling organ and guitar cabinet. Speed morphs slow to fast, Depth the swirl, Mix the wet. in0 = Audio.

ParamRangeDefaultUnit
Speed0 – 10.6—
Depth0 – 10.5—
Mix0 – 11—

# Robotize 1 input

Robot voice: ring-modulates the input against a fixed carrier and imposes a vowel formant, turning speech or any signal into the classic talking-robot timbre. Pitch sets the carrier, Vowel the formant, Mix the wet. in0 = Audio.

ParamRangeDefaultUnit
Pitch50 – 800200Hz
Vowel0 – 10.5—
Mix0 – 11—

# PrintThrough 1 input

Tape print-through: on a wound reel the magnetic field of a loud passage slowly imprints a faint GHOST of itself onto the tape layers pressed against it - so on playback a dull copy appears both one layer BEFORE the sound (the eerie pre-echo that creeps in just ahead of a loud transient on old tapes) and one layer AFTER it (the post-echo). A plain delay cannot make a pre-echo; this does, at the cost of one print-spacing of latency. Spacing sets the reel-layer time between the ghosts and the original, Amount the print strength, Tone how dull the ghosts are, Mix the print intensity. A vintage-tape character and a uniquely 'impossible' pre-echo effect.

ParamRangeDefaultUnit
Spacing10 – 12045ms
Amount0 – 10.4—
Tone500 – 60002500Hz
Mix0 – 11—

# IntegrateDump 1 input

Integrate-and-dump: the input is accumulated into a bucket and, the moment the bucket overflows past Threshold, it DUMPS its whole contents as one spike and resets to zero. Loud or sustained input fills it fast (rapid spikes), quiet input fills it slowly (sparse spikes) - a charge-pump rhythm generator whose pulse rate tracks the signal energy. Rate sets the fill speed, Threshold the dump level, Mix the blend.

ParamRangeDefaultUnit
Rate0.1 – 102—
Threshold0.05 – 30.5—
Mix0 – 10.6—

# RectifierHum 1 input

Power-supply hum injector: adds mains-frequency hum (and its octave, the way a full-wave rectifier ripples at 2x mains) whose level GROWS with the signal - modelling a sagging power supply that hums harder when the amp is pushed. Distinct from a static hum: it ducks away in silence and blooms on transients. Freq sets the mains frequency, Amount the worst-case hum, Mix the blend.

ParamRangeDefaultUnit
Freq40 – 12060Hz
Amount0 – 0.50.1—
Mix0 – 11—

# GeigerNoise 1 input

Geiger counter: emits sharp random CLICKS whose density tracks the input level - loud input is a frantic crackle of clicks, quiet input an occasional tick, like a Geiger counter responding to radiation. Each click is a fast-decaying impulse fired by a Poisson process whose rate is driven by |signal|. A novel level-to-texture sonifier. Sensitivity sets the click rate, Decay the click length, Mix the blend.

ParamRangeDefaultUnit
Sensitivity0 – 10.4—
Decay0.9 – 0.9990.99—
Mix0 – 10.7—

# WaterDrop 1 input

Water drop: each transient in the input strikes a resonator whose pitch RISES as it rings out - the unmistakable 'bloop' of a drip into water (the cavity shrinks as the bubble collapses, so the frequency sweeps UP). A percussion-to-droplet converter. Tune sets the base pitch, Rise how far the pitch sweeps up, Decay the ring, Mix the blend.

ParamRangeDefaultUnit
Tune200 – 2000700Hz
Rise0 – 10.6—
Decay0.99 – 0.9990.997—
Mix0 – 10.7—

# Sproing 1 input

Sproing: each transient launches a cartoon spring 'boing' - a sine whose pitch DROPS rapidly after the hit (the opposite of WaterDrop) with a dispersive, comedic wobble. Turns drum hits and clicks into bouncy spring-toy sounds. Tune sets the start pitch, Drop how far it falls, Decay the bounce length, Mix the blend.

ParamRangeDefaultUnit
Tune200 – 2000900Hz
Drop0 – 10.7—
Decay0.99 – 0.9990.996—
Mix0 – 10.7—

# MetalStress 1 input

Metal fatigue: the input's energy accumulates as 'stress' in a metal part; when the stress crosses a building threshold the metal CRACKS - a bright inharmonic ping - and partially relieves, so sustained loud input produces irregular, escalating metallic snaps and creaks, like a stressed sheet or cooling engine. Buildup sets how fast stress accrues, Threshold the crack point, Mix the blend.

ParamRangeDefaultUnit
Buildup0.1 – 102—
Threshold0.2 – 51.5—
Mix0 – 10.7—

# Dropout2 1 input

Tape dropout: random brief mutes, as if the oxide flaked off the tape - the signal cuts out for a few milliseconds at random, with a quick fade so it ticks rather than clicks. Sparse and subtle for vintage wear, dense for a glitchy, failing-media stutter. Rate sets how often dropouts happen, Length their duration, Mix the blend.

ParamRangeDefaultUnit
Rate0 – 10.2—
Length1 – 8015ms
Mix0 – 11—

# TapeHiss 1 input

Tape noise floor: adds a band-limited hiss that behaves like real tape - it is loudest in the SILENCES and ducks down under the signal (self-masking), instead of the constant flat hiss of just summing in noise. Tone shapes the hiss colour, Amount the floor level, Mix the blend. Pairs with the tape/print-through blocks for an authentic worn-tape bed.

ParamRangeDefaultUnit
Amount0 – 0.30.06—
Tone1000 – 120005000Hz
Mix0 – 11—

# WaxCylinder 1 input

Wax cylinder: the 1900s phonograph sound - a steep midrange band (everything below ~250 Hz and above ~3 kHz gone), heavy slow wow from the hand-cranked mandrel, constant surface crackle, and soft horn-driven saturation. The most extreme lo-fi in the box, older than tape. Age scales the bandlimiting + saturation, Wow the pitch drift, Surface the crackle, Mix the blend.

ParamRangeDefaultUnit
Age0 – 10.6—
Wow0 – 10.4—
Surface0 – 10.4—
Mix0 – 11—

# ScrapeFlutter 1 input

Scrape flutter: the fast, nervous high-frequency wobble of tape scraping past a fixed guide or head - a rapid (tens of Hz) random micro-pitch and amplitude jitter plus a faint signal-gated scrape hiss, the gritty motion noise distinct from the slow musical wow. Rate sets the flutter speed, Depth the jitter intensity, Mix the blend.

ParamRangeDefaultUnit
Rate10 – 20060Hz
Depth0 – 10.4—
Mix0 – 11—

# SteamHiss 1 input

Steam hiss: a high, airy band of noise that swells and breathes like escaping steam or a hi-hat wash, with the input level pushing the pressure up. Tone sets how bright/sharp the jet is, Amount the pressure, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.4—
Tone2000 – 140007000Hz
Mix0 – 11—

# Sparkle 1 input

Sparkle: every transient triggers a brief random high bell 'ting', so hits and picks throw off glittering, fairy-dust overtones at random pitches above the note - an onset-driven shimmer quite unlike a reverb or a fixed octaver. Amount sets the sparkle level, Decay the ting length, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.4—
Decay0.99 – 0.9990.997—
Mix0 – 10.8—

# Creak 1 input

Creak: a stress-driven stick-slip squeak - the input level winds up tension that periodically slips, sweeping a thin resonant tone upward in little jerks, like a creaking door, rope or floorboard. The louder you push, the faster and higher it creaks. Tune sets the squeak pitch, Mix the blend.

ParamRangeDefaultUnit
Tune150 – 3000600Hz
Mix0 – 10.7—

# Groan 1 input

Groan: the input level wakes a deep, slowly wavering sub-tone that moans underneath the signal - a wobbling low resonance whose pitch drifts on a slow random LFO, adding a creaking, living, beast-like undertone to drones and pads. Tune sets the groan pitch, Mix the blend.

ParamRangeDefaultUnit
Tune30 – 20070Hz
Mix0 – 10.6—

# Tinnitus 1 input

Tinnitus: a thin high sine that you only hear in the GAPS - it ducks away while the signal plays and rings out in the silences, building up after loud passages and slowly fading, exactly like the ear-ringing after a loud show. An eerie, fatiguing ambience or a sound-design unease tool. Freq sets the ring pitch, Amount the loudest ring, Mix the blend.

ParamRangeDefaultUnit
Freq2000 – 120006000Hz
Amount0 – 0.50.15—
Mix0 – 11—

# Shatter 1 input

Shatter: the signal is smashed into tiny grains that play back from random points in a short buffer at random gains (some silent), so the sound fractures into a jagged spray of shards - a stochastic granular shatter, not a tidy looped stutter. Size sets the shard length, Chaos how often and how violently it re-shards, Mix the blend.

ParamRangeDefaultUnit
Size5 – 12040ms
Chaos0 – 10.6—
Mix0 – 11—

# Stammer 1 input

Stammer: an onset captures a tiny grain and replays it a handful of times with falling level before the sound continues - a quick involuntary repeat that trips over itself, the verbal stammer made audible. Rate sets the repeat speed, Decay how fast the stammer dies, Mix the blend.

ParamRangeDefaultUnit
Rate8 – 8030Hz
Decay0.5 – 0.950.8—
Mix0 – 11—

# Sigh 1 input

Sigh: when a note releases (the level falls away) it triggers a downward filter sweep, so phrase endings trail off into a soft darkening sigh. A release-keyed motion you can't get from a static EQ. Fall sets how long the sigh takes, Mix the blend.

ParamRangeDefaultUnit
Fall0.99 – 0.9990.998—
Mix0 – 11—

# Sputter 1 input

Sputter: the signal cuts in and out at irregular intervals with little bursts of crackle at each break - a failing cable, a dying tube, a loose connection. The randomness of the timing is the point: it never settles into a rhythm. Rate sets the average break rate, Mix the blend.

ParamRangeDefaultUnit
Rate1 – 408Hz
Mix0 – 11—

# Twang 1 input

Twang: each transient excites a tuned resonator whose pitch droops as it decays, so picks and hits bloom into a springy, boinging twang - the wobble-board / saw-blade / loose-spring voice. Tune sets the resonant pitch, Decay the twang length, Mix the blend.

ParamRangeDefaultUnit
Tune60 – 800200Hz
Decay0.99 – 0.9990.997—
Mix0 – 10.7—

# Rattle 1 input

Rattle: while the signal is loud enough a loose part buzzes against it - fast random noise bursts gated by the input envelope, like a snare wire, a blown speaker or a rattling panel that only sounds when driven hard. Goes quiet the instant the signal drops. Thresh sets the drive needed, Amount the rattle level, Mix the blend.

ParamRangeDefaultUnit
Thresh0 – 0.50.15—
Amount0 – 10.5—
Mix0 – 11—

# Boomerang 1 input

Boomerang: a reverse delay that catches the signal and throws it back REVERSED through a sliding window, with feedback so each throw comes back again - swelling, backwards-shimmer echoes that arc out and return. Time sets the window length, Feedback how many returns, Mix the blend.

ParamRangeDefaultUnit
Time0.05 – 10.3s
Feedback0 – 0.70.4—
Mix0 – 10.5—

# Tumble 1 input

Tumble: a feedback echo whose delay time slowly GROWS after each onset, so the repeats droop downward in pitch and spread apart - the sound of something tumbling away down a flight of stairs. Time sets the starting gap, Feedback the tumble length, Mix the blend.

ParamRangeDefaultUnit
Time0.01 – 0.20.04s
Feedback0 – 0.80.55—
Mix0 – 10.5—

# Avalanche 1 input

Avalanche: a feedback line whose gain briefly exceeds unity after a loud trigger, so the sound builds on itself into a swelling roar before a tanh ceiling and a decay tame it back down - a self-amplifying cascade that snowballs and settles. Trigger sets the trip level, Decay the avalanche length, Mix the blend.

ParamRangeDefaultUnit
Trigger0 – 0.50.2—
Decay0.99 – 10.999—
Mix0 – 10.5—

# Rust 1 input

Rust: a corrosion that ACCUMULATES the longer the signal is present - a crackle/grit bed that grows as the contact oxidizes, then slowly cleans up in silence. Unlike a static crackle, it gets worse over a held passage. Speed sets the rusting rate, Mix the blend.

ParamRangeDefaultUnit
Speed0 – 10.5—
Mix0 – 11—

# Crumble 1 input

Crumble: the longer a note sustains the more of its samples drop out and hold, so a held tone progressively crumbles into a stuttering, gap-riddled fragment - then knits back together in the silences. Rate sets the crumble onset, Mix the blend.

ParamRangeDefaultUnit
Rate0 – 10.5—
Mix0 – 11—

# Crystallize 1 input

Crystallize: each transient seeds a high shimmering partial locked to a tuned pitch grid (so the sparkle is always musical, never random), ringing out and accreting into a crystalline upper layer. Tune sets the grid root, Amount the shimmer level, Mix the blend.

ParamRangeDefaultUnit
Tune200 – 1000440Hz
Amount0 – 10.4—
Mix0 – 10.8—

# Ionize 1 input

Ionize: transients ignite bursts of high, crackling electric sparks - bandpassed noise gated into random arcs, like a plasma discharge or a Tesla coil snapping. Distinct from a tonal sparkle: this is pure electric noise. Amount sets the arc level, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# Vaporize 1 input

Vaporize: the attack passes clean but the sustain dissolves into a cloud of filtered noise driven by the signal's own envelope, so notes evaporate from solid tone into airy vapor as they hold. Amount sets how much vaporizes, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.6—
Mix0 – 11—

# BarkhausenBuzz 1 input

Barkhausen buzz: magnetic-domain jumps emit a crackle whose intensity tracks the RATE of magnetization change (dB/dt) - so fast-moving signal hisses and buzzes with domain noise while steady levels stay quiet. The audible signature of a magnetizing core. Amount sets the buzz level, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# PlosivePop 1 input

Plosive pop: each transient triggers a short low-frequency thump under the signal - the 'p'/'b' plosive blast or a mic-pop, a dull pressure pulse that fattens hits with sub-bass weight. Tune sets the pop pitch, Amount the thump level, Mix the blend.

ParamRangeDefaultUnit
Tune40 – 20090Hz
Amount0 – 10.5—
Mix0 – 11—

# MagnetostrictRing 1 input

Magnetostrictive ring: a magnetic core changes shape with the SQUARE of the drive (magnetostriction), exciting a high metallic resonance an octave up - so the signal grows a singing, ferromagnetic ring that tracks its envelope, the hum you hear from transformers and tape heads. Freq sets the ring pitch, Amount the ring level, Mix the blend.

ParamRangeDefaultUnit
Freq400 – 40001200Hz
Amount0 – 10.4—
Mix0 – 11—

# JitterClock 1 input

Clock jitter: the sampling instant is dithered by a tiny random delay each sample, so the signal acquires the smeared, noisy edge of a jittery sample clock - subtle phase-noise grime that frosts transients and high frequencies. Amount sets the jitter, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# GravelCrunch 1 input

Gravel crunch: dense bursts of low-passed noise grains gated by the signal level, like boots grinding on gravel - the more signal, the more it crunches underneath. A grounded, gritty texture rather than a hiss. Density sets the crunch amount, Mix the blend.

ParamRangeDefaultUnit
Density0 – 10.5—
Mix0 – 11—

# ClothRustle 1 input

Cloth rustle: soft high-frequency noise bursts triggered by how fast the signal MOVES, like fabric brushing past a microphone - it whispers and rustles on motion and falls silent when the signal holds still. Amount sets the rustle level, Mix the blend.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# SignFlip 1 input

Sign flip: at a steady clock it randomly inverts the polarity of the whole signal for that window, scrambling the phase into a harsh, fizzing, broken texture - a pure waveform-polarity destroyer with no level change, just sign chaos. Rate sets the flip clock, Mix the blend.

ParamRangeDefaultUnit
Rate1 – 40060Hz
Mix0 – 11—

Envelope

6 modules

# HoldDecay 1 input

Peak-hold envelope with linear decay: latches the loudest recent peak, holds it for a set time, then ramps down at a constant slope (not exponentially) - a control source with a straight-line fall a plain release follower cannot make.

ParamRangeDefaultUnit
Hold0 – 200050ms
Decay1 – 4000500ms
Sens0 – 41—

# EnvADSR 2 inputs

ADSR envelope: a gate drives the classic attack/decay/sustain/release contour, applied as a VCA to the audio input - the fundamental synth envelope as a self-contained block.

ParamRangeDefaultUnit
Attack1 – 100010ms
Decay1 – 1000100ms
Sustain0 – 10.7—
Release1 – 2000200ms

# AD 1 input

Attack-Decay envelope: a rising edge on the in0 gate fires a one-shot ramp up over Attack then back down over Decay, ignoring how long the gate is held - the classic percussive/pluck envelope. Patch its CV output into a VCA, filter cutoff or any param.

ParamRangeDefaultUnit
Attack1 – 50005ms
Decay1 – 5000200ms

# AR 1 input

Attack-Release (ASR) envelope: while the in0 gate is high the output ramps up to full over Attack and holds; when the gate falls it ramps back to zero over Release - a smooth sustaining envelope for pads and swells.

ParamRangeDefaultUnit
Attack1 – 500050ms
Release1 – 5000300ms

# ADSR 1 input

Full ADSR envelope: a held in0 gate ramps up over Attack, falls to the Sustain level over Decay and holds there; releasing the gate fades to zero over Release - the standard four-stage envelope for any voice or modulation.

ParamRangeDefaultUnit
Attack1 – 50005ms
Decay1 – 5000150ms
Sustain0 – 10.7—
Release1 – 5000300ms

# DADSR 1 input

Delayed ADSR: like ADSR but with a Delay stage before the attack - the gate opens, nothing happens for Delay, then the four-stage envelope runs. Useful for staggered swells and per-voice timing offsets.

ParamRangeDefaultUnit
Delay0 – 40000ms
Attack1 – 50005ms
Decay1 – 5000150ms
Sustain0 – 10.7—
Release1 – 5000300ms

Expression

3 modules

# Scoop 1 input

Bends up into each struck note from Depth below, resolving to pitch over Time - the vocal/brass scoop, a pitch-bend ramp that ends at centre so no bend is left hanging.

ParamRangeDefaultUnit
Depth0 – 10.3—
Time1 – 100080ms

# Fall 1 input

Jazz fall-off: on release the pitch sweeps down by Depth over Time while the note rings, then the note releases and the bend snaps back to centre. The note-off is delayed to the end of the fall.

ParamRangeDefaultUnit
Depth0 – 10.5—
Time10 – 2000300ms

# MidiVibrato 1 input

A pitch-bend LFO that fades in after an Onset delay while any note is held - the delayed, played-in vibrato of a string or voice rather than an instant wobble. Rate in Hz, Depth as bend amount.

ParamRangeDefaultUnit
Rate0.1 – 125Hz
Depth0 – 10.15—
Onset0 – 2000300ms

Harmony

51 modules

# Chord 1 input

Turns each incoming note into a chord (165 types) with inversion, spread, octave doubling and strum.

ParamRangeDefaultUnit
TypeUnison · Octave · 5th (Power) · 5th + Oct · Tritone · Major · Minor · Diminished · Augmented · Major (1st inv) · Major (2nd inv) · Minor (1st inv) · Minor (2nd inv) · Sus2 · Sus4 · Sus2 Sus4 · 7 Sus4 · 9 Sus4 · Major 6 · Minor 6 · 6/9 · Minor 6/9 · Major 7 · Dominant 7 · Minor 7 · Minor Maj7 · Half Dim 7 · Diminished 7 · Augmented 7 · Aug Maj7 · 7 Flat5 · Maj7 Flat5 · Maj7 Sharp5 · Major 9 · Dominant 9 · Minor 9 · Minor Maj9 · 6/9 add11 · 7 Flat9 · 7 Sharp9 · 9 Flat5 · 9 Sharp5 · Maj7 Sharp9 · Major 11 · Dominant 11 · Minor 11 · Minor Maj11 · 7 Sharp11 · Maj7 Sharp11 · 9 Sharp11 · Major 13 · Dominant 13 · Minor 13 · 13 Flat9 · 13 Sharp11 · 13 Sus4 · Add9 · Minor Add9 · Add11 · Minor Add11 · Add13 · Add9 Add11 · 2 · 7 Alt · 7 Flat9 Sharp11 · 7 Flat9 Flat13 · 7 Sharp9 Sharp11 · 13 Sharp9 · Lydian · Phrygian · Mystic · Petrushka · Hendrix · So What · Quartal 3 · Quartal 4 · Quartal 5 · Quintal 3 · Cluster 3 · Cluster 4 · Whole Tone · Major (open) · Minor (open) · Maj7 (open) · Min7 (open) · Major (drop2) · Maj7 (drop2) · Min7 (drop2) · Dom7 (drop2) · Maj7 (drop3) · Major x2 Oct · Minor x2 Oct · 5th Stack · Big Major · Big Minor · Maj over 5 · Min over b7 · Maj over 2 · Poly Maj/Maj · Poly Min/Maj · Dom7 (1st inv) · Dom7 (2nd inv) · Dom7 (3rd inv) · Maj7 (1st inv) · Maj7 (2nd inv) · Min7 (1st inv) · Min7 (2nd inv) · Dim (1st inv) · Aug (1st inv) · Dom7 (no 3) · Maj7 (no 5) · Min7 (no 5) · Maj9 (no 5) · Min9 (no 5) · Dom9 (no 5) · Dom13 (no 5,9) · Min11 (no 5) · 6 Sus2 · 6 Sus4 · Sus4 Add9 · Sus2 Add11 · Maj7 Sus2 · Min7 Add11 · 7 Flat13 · 7 Sharp5 Sharp9 · 7 Flat5 Flat9 · Maj13 Sharp11 · Dim Maj7 · Aug Add9 · Italian 6th · Elektra · Viennese · Neapolitan · Magic Hexad · Quartal 6 · Cluster 5 · Pentatonic Stack · Min Pent Stack · Major +8va · Major -8va · Minor +8va · Minor -8va · Dominant 7 +8va · Dominant 7 -8va · Major 7 +8va · Major 7 -8va · Minor 7 +8va · Minor 7 -8va · Sus4 +8va · Sus4 -8va · Add9 +8va · Add9 -8va · Major 6 +8va · Major 6 -8va · Minor 9 +8va · Minor 9 -8va · Major 9 +8va · Major 9 -8va · 6/9 +8va · 6/9 -8va · Diminished 7 +8va · Diminished 7 -8va · Augmented +8va · Augmented -8va · Half Dim 7 +8va · Half Dim 7 -8va—
Inversion0 – 40—
Spread0 – 20—
Octave x20 – 20—
Transpose-24 – 240st
Strum0 – 2000ms

# Scale 1 input

Quantizes incoming notes to the nearest degree of the chosen root and scale.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—

# Transpose 1 input

Shifts every note by a fixed semitone amount plus a modulatable offset.

ParamRangeDefaultUnit
Semitones-24 – 240st
Mod Amt-24 – 240st

# Harmonize 1 input

Adds up to three fixed-interval harmony voices to each note.

ParamRangeDefaultUnit
Interval 1-24 – 247st
Interval 2-24 – 240st
Interval 3-24 – 240st

# Drone 1 input

Doubles every note with a fixed pedal root.

ParamRangeDefaultUnit
Root0 – 12736—

# MidiCluster 1 input

Adds symmetric tone-cluster voices above and below each note.

ParamRangeDefaultUnit
Width0 – 41—
Spread1 – 41st

# Glissando 1 input

Fills a stepwise run between consecutive notes.

ParamRangeDefaultUnit
Rate5 – 20040ms

# ChordMem 1 input

Each key plays a stored chord shape (semitone intervals from node config).

# ChordProg 1 input

Each note triggers the next chord in a stored root progression (node config).

# ChordVoicing 1 input

Re-voices each note into a jazz shape (open / shell / quartal / spread).

ParamRangeDefaultUnit
VoicingOpen · Shell · Quartal · Spread—

# Octave 1 input

Doubles each note up and/or down by whole octaves.

ParamRangeDefaultUnit
Up0 – 31—
Down0 – 30—

# MidiFold 1 input

Folds out-of-range notes back inside a Low..High window.

ParamRangeDefaultUnit
Low Note0 – 12748—
High Note0 – 12772—

# Invert 1 input

Mirrors pitch around a pivot note.

ParamRangeDefaultUnit
Pivot0 – 12760—

# Diatonic 1 input

Transposes by scale DEGREES within Root/Scale (a third, a fifth...) instead of by raw semitones like Transpose - the shift always lands back in key. Mod Amt adds a modulatable degree offset.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Degrees-7 – 72—
Mod Amt-7 – 70—

# DiatonicChord 1 input

Auto-harmoniser: builds the in-key chord on every note by stacking diatonic thirds (triad, 7th...) along Root/Scale, so single-finger melodies become correct chords in the key.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Notes2 – 43—

# NeoRiemann 1 input

Neo-Riemannian triad transforms: builds a major/minor triad on each note and applies P (parallel), L (leading-tone) or R (relative) - the maximally-smooth chord moves of late-Romantic and film harmony, each sharing two common tones with the input.

ParamRangeDefaultUnit
QualityMajor · Minor—
TransformNone · P · L · R—

# Counterpoint 1 input

Adds a second voice in contrary motion - when the melody rises the counter voice falls and vice-versa - quantised to Root/Scale. Interval sets the starting separation.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Interval1 – 247st

# Bassline 1 input

Follows the chord with a mono bass voice: the lowest held note dropped Octaves down, retriggered whenever the lowest note changes. Passes the original notes through and adds the bass beneath them.

ParamRangeDefaultUnit
Octaves1 – 31—
Velocity1 – 127100—

# VoiceLead 1 input

Smooth voice leading: places each note's pitch class in the octave nearest the previous output, so a line or chord progression moves by the smallest interval. Range caps the leap; past it the original octave is kept.

ParamRangeDefaultUnit
Range1 – 127st

# AutoInvert 1 input

Cycles the inversion of each struck chord: every trigger rotates which of the lowest notes jump an octave (by Rotate), so a repeated chord keeps climbing through its inversions - movement ChordVoicing's static shapes don't give.

ParamRangeDefaultUnit
Rotate1 – 41—

# ChordLock 1 input

Quantizes every note to the nearest tone of a fixed chord (Root + Type), tighter than Scale's scale-quantize - locks an improvisation to a chord's notes.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
TypeUnison · Octave · 5th (Power) · 5th + Oct · Tritone · Major · Minor · Diminished · Augmented · Major (1st inv) · Major (2nd inv) · Minor (1st inv) · Minor (2nd inv) · Sus2 · Sus4 · Sus2 Sus4 · 7 Sus4 · 9 Sus4 · Major 6 · Minor 6 · 6/9 · Minor 6/9 · Major 7 · Dominant 7 · Minor 7 · Minor Maj7 · Half Dim 7 · Diminished 7 · Augmented 7 · Aug Maj7 · 7 Flat5 · Maj7 Flat5 · Maj7 Sharp5 · Major 9 · Dominant 9 · Minor 9 · Minor Maj9 · 6/9 add11 · 7 Flat9 · 7 Sharp9 · 9 Flat5 · 9 Sharp5 · Maj7 Sharp9 · Major 11 · Dominant 11 · Minor 11 · Minor Maj11 · 7 Sharp11 · Maj7 Sharp11 · 9 Sharp11 · Major 13 · Dominant 13 · Minor 13 · 13 Flat9 · 13 Sharp11 · 13 Sus4 · Add9 · Minor Add9 · Add11 · Minor Add11 · Add13 · Add9 Add11 · 2 · 7 Alt · 7 Flat9 Sharp11 · 7 Flat9 Flat13 · 7 Sharp9 Sharp11 · 13 Sharp9 · Lydian · Phrygian · Mystic · Petrushka · Hendrix · So What · Quartal 3 · Quartal 4 · Quartal 5 · Quintal 3 · Cluster 3 · Cluster 4 · Whole Tone · Major (open) · Minor (open) · Maj7 (open) · Min7 (open) · Major (drop2) · Maj7 (drop2) · Min7 (drop2) · Dom7 (drop2) · Maj7 (drop3) · Major x2 Oct · Minor x2 Oct · 5th Stack · Big Major · Big Minor · Maj over 5 · Min over b7 · Maj over 2 · Poly Maj/Maj · Poly Min/Maj · Dom7 (1st inv) · Dom7 (2nd inv) · Dom7 (3rd inv) · Maj7 (1st inv) · Maj7 (2nd inv) · Min7 (1st inv) · Min7 (2nd inv) · Dim (1st inv) · Aug (1st inv) · Dom7 (no 3) · Maj7 (no 5) · Min7 (no 5) · Maj9 (no 5) · Min9 (no 5) · Dom9 (no 5) · Dom13 (no 5,9) · Min11 (no 5) · 6 Sus2 · 6 Sus4 · Sus4 Add9 · Sus2 Add11 · Maj7 Sus2 · Min7 Add11 · 7 Flat13 · 7 Sharp5 Sharp9 · 7 Flat5 Flat9 · Maj13 Sharp11 · Dim Maj7 · Aug Add9 · Italian 6th · Elektra · Viennese · Neapolitan · Magic Hexad · Quartal 6 · Cluster 5 · Pentatonic Stack · Min Pent Stack · Major +8va · Major -8va · Minor +8va · Minor -8va · Dominant 7 +8va · Dominant 7 -8va · Major 7 +8va · Major 7 -8va · Minor 7 +8va · Minor 7 -8va · Sus4 +8va · Sus4 -8va · Add9 +8va · Add9 -8va · Major 6 +8va · Major 6 -8va · Minor 9 +8va · Minor 9 -8va · Major 9 +8va · Major 9 -8va · 6/9 +8va · 6/9 -8va · Diminished 7 +8va · Diminished 7 -8va · Augmented +8va · Augmented -8va · Half Dim 7 +8va · Half Dim 7 -8va—

# GhostNote 1 input

Ghost note: doubles every note with a quiet copy a set interval below (default an octave), at a fraction of the original velocity - the subliminal low reinforcement drummers and bassists use to thicken a line.

ParamRangeDefaultUnit
Interval1 – 2412st
GhostLevel0.05 – 10.4—

# MirrorPivot 1 input

Mirror pivot: reflects every note about a fixed pivot pitch (out = 2*Pivot - note), turning rising lines into falling ones and inverting every interval around the chosen axis - melodic inversion with a movable mirror.

ParamRangeDefaultUnit
Pivot0 – 12760—

# OctaveClamp 1 input

Octave clamp: folds every incoming note into the single octave starting at Center by collapsing its pitch class, flattening wide-ranging input into one register - a pitch-class monitor or tight-range re-voicer.

ParamRangeDefaultUnit
Center0 – 11648—

# SubHarmonicAdd 1 input

Sub-harmonic add: reinforces every note with undertone voices an octave (Sub1) and an octave-plus-fifth (Sub2) below at adjustable levels - the subharmonic weight of a Trautonium or organ bourdon.

ParamRangeDefaultUnit
Sub10 – 10.5—
Sub20 – 10.25—

# OvertoneStack 1 input

Overtone stack: layers quieter harmonic-series voices (octave, octave+fifth, two octaves) above each note with a geometric Rolloff, thickening a single note toward an organ-like harmonic chord.

ParamRangeDefaultUnit
Rolloff0.1 – 10.5—

# PitchClassGate 1 input

Pitch-class gate: passes only notes whose pitch class belongs to the chosen Root and Mode set (chromatic, major, minor, pentatonic or whole-tone), filtering a stream down to a key without transposing anything.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ModeChromatic · Major · Minor · Pentatonic · WholeTone—

# WholeToneSnap 1 input

Whole-tone snap: quantizes every note to the nearest degree of the six-note whole-tone scale from Root, dissolving tonality into the dreamy, rootless ambiguity that scale is famous for.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# ReflectOctave 1 input

Reflect octave: mirrors each note's pitch class about a pivot while keeping it in its own octave, inverting the melodic contour within every register at once - octave-preserving interval inversion.

ParamRangeDefaultUnit
PivotC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# NegativeHarmony 1 input

Negative harmony: reflects every note about the axis halfway between the tonic and dominant (Ernst Levy's mirror), swapping major for minor and turning a progression into its tonal shadow while keeping the same harmonic function.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—

# TwelveToneRow 1 input

Twelve-tone row: enforces Schoenberg's serial rule - no pitch class may sound again until all twelve have been played - dropping early repeats so the stream is forced into complete chromatic rows.

ParamRangeDefaultUnit
On0 – 11—

# ConsonanceGate 1 input

Consonance gate: passes a note only when its interval from the previous one is consonant (unison, third, fourth, fifth, sixth or octave), filtering a chromatic line down to smooth, dissonance-free melodic motion.

ParamRangeDefaultUnit
On0 – 11—

# GravityQuantize 1 input

Gravity quantize: pulls every note toward a center pitch by an adjustable strength, as if the keyboard had a gravitational well - gentle settings nudge stray notes inward, strong settings collapse a whole part toward one tone.

ParamRangeDefaultUnit
Center0 – 12760—
Strength0 – 10.3—

# HarmonicQuantize 1 input

Harmonic quantize: re-pitches each note to the nearest member of the natural harmonic series above a root, snapping a chromatic part onto the pure, stretched-then-compressed intervals of the overtone series.

ParamRangeDefaultUnit
Root0 – 6024—

# SubharmonicShift 1 input

Subharmonic shift: drops each note to the nearest undertone (subharmonic) of a ceiling pitch, the mirror of the harmonic series, building dark, minor-tilted lines beneath an upper anchor note.

ParamRangeDefaultUnit
Ceiling60 – 12096—

# RangeCompress 1 input

Range compress: linearly squeezes the played pitch range toward a center note, narrowing a wide-ranging part into a tighter register (or, near ratio 1, leaving it alone) - a melodic-ambitus compressor.

ParamRangeDefaultUnit
Center0 – 12760—
Ratio0.1 – 10.6—

# RangeExpand 1 input

Range expand: stretches the played pitch range away from a center note (the inverse of range-compress), exaggerating a cramped melody into a wider, more dramatic ambitus; near ratio 1 it leaves the part alone.

ParamRangeDefaultUnit
Center0 – 12760—
Ratio1 – 31.5—

# DiatonicTranspose 1 input

Diatonic transpose: shifts every note by a number of whole scale degrees within a major key, so the melody moves up or down the staff while always landing on in-key notes - true in-key transposition, unlike the chromatic kind.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Steps-14 – 142—

# ModalShift 1 input

Modal shift: brightens or darkens the key by raising the fourth toward Lydian or lowering the third, sixth and seventh toward natural minor, recolouring a part's mode without retransposing it.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Brightness-1 – 10—

# IntervalClassGate 1 input

Interval-class gate: passes a note only when its leap from the previous kept note belongs to a chosen interval class (0 unison/octave .. 6 tritone), filtering a line down to one harmonic colour of motion; Invert keeps the rest.

ParamRangeDefaultUnit
Class0 – 65—
Invert0 – 10—

# ContourGate 1 input

Contour gate: passes only the rising moves (or only the falling moves) of a melody relative to the previous kept note, isolating the ascending or descending gestures of a line.

ParamRangeDefaultUnit
Ascending0 – 11—

# RangeGate 1 input

Range gate: passes only notes whose pitch lies inside a Low..High window, masking a register in or out of the part; Invert mutes the window instead of keeping it.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—
Invert0 – 10—

# LeapGate 1 input

Leap gate: passes only stepwise motion (intervals below the threshold) or only leaps (intervals at or above it) relative to the previous kept note, splitting a melody into its smooth and its jagged motion.

ParamRangeDefaultUnit
Threshold1 – 245—
WantLeap0 – 10—

# OctaveFoldGate 1 input

Octave fold: collapses every note into a single octave above a base note (keeping only its pitch class), squashing a wide-ranging part into one register - useful for bass-monitoring or extreme register clamping.

ParamRangeDefaultUnit
Base0 – 11548—

# PitchMirror 1 input

Pitch mirror: reflects every note around a fixed axis pitch, so ascending lines become descending and the melody is turned upside-down about a chosen centre (a literal pitch inversion, key-independent).

ParamRangeDefaultUnit
Axis0 – 12760—
On0 – 11—

# RepeatedNoteGate 1 input

Repeated-note gate: drops a note-on when it repeats the previous kept pitch, passing only when the melody actually changes note - a de-stutter that removes hammered repeats; Invert keeps only the repeats.

ParamRangeDefaultUnit
Invert0 – 10—

# ContourReverseGate 1 input

Contour-reverse gate: passes a note only when the melody changes direction (a peak or valley), keeping just the turning points of a line and dropping the runs between them; Invert keeps the runs.

ParamRangeDefaultUnit
Invert0 – 10—

# DiatonicHarmonize 1 input

Diatonic harmonize: adds a second voice a chosen number of scale steps above each note within a major key, so the harmony note always stays in key (true diatonic thirds/sixths, unlike a fixed chromatic interval).

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Steps1 – 72—

# PowerChordAdd 1 input

Power chord: doubles every note with a perfect fifth above (and optionally the octave on top), instantly turning a single line into the root-fifth power chords of rock guitar.

ParamRangeDefaultUnit
AddOctave0 – 11—

# OctaveStackAdd 1 input

Octave stack: layers each note with a copy an octave above and/or below, fattening a thin line into a multi-octave stack (organ-style); choose which octaves to add.

ParamRangeDefaultUnit
Up0 – 11—
Down0 – 11—

# UnisonDetuneAdd 1 input

Unison detune: layers a second copy of each note slightly detuned (via per-note microtuning), thickening a mono line into a wide chorused unison without a separate effect.

ParamRangeDefaultUnit
Cents-50 – 5012ct

Physical

20 modules

# Banjo 1 input

Banjo (physical model): five digital-waveguide steel strings (Extended Karplus-Strong - tuned delay + Thiran fractional-delay allpass + one-pole loss filter + light dispersion for steel stiffness) tuned to open G, strummed at Rate, whose bridge drives a tensioned circular-membrane HEAD modelled as a 9-mode resonator bank at the Bessel-zero frequency ratios of a real drum head. The head reaction couples back into every string, so the bright percussive plunk, the broadband attack and the sympathetic ring all emerge from the string<->membrane coupling - not a canned sample. Root sets the pitch, Head the membrane tuning/brightness, Sustain the string decay.

ParamRangeDefaultUnit
Root80 – 400147Hz
Rate0.2 – 81.5Hz
Head0 – 10.5—
Sustain0 – 10.4—
Level0 – 10.5—

# AcousticGuitar 1 input

Acoustic guitar (physical model): six digital-waveguide strings (Extended Karplus-Strong - tuned delay + Thiran fractional-delay allpass + loss filter + light dispersion) in standard EADGBE tuning, strummed at Rate, coupled through the bridge to a FIXED guitar-body modal bank - the Helmholtz air resonance (~100 Hz) plus top/back plate signature modes that colour every note the same way (the body is a formant, it does not track the note). The body reaction rings the strings, so sympathetic resonance and the woody body voice emerge from the coupling. Root sets the pitch, Tone the string brightness, Body the resonance depth, Sustain the string decay.

ParamRangeDefaultUnit
Root60 – 33082Hz
Rate0.2 – 81Hz
Tone0 – 10.5—
Body0 – 10.5—
Sustain0 – 10.6—
Level0 – 10.5—

# Harp 1 input

Harp (physical model): seven diatonic digital-waveguide strings (Extended Karplus-Strong - tuned delay + Thiran fractional-delay allpass + loss filter) arpeggiated one at a time at Rate, coupled through the bridge to a fixed wooden-soundboard modal bank. The long string sustain and heavy body->string coupling make the open strings bloom in sympathy - the shimmering wash of a harp gliss. Root sets the pitch, Rate the arpeggio speed, Sustain the string ring, Body the soundboard depth, Level the output.

ParamRangeDefaultUnit
Root50 – 400110Hz
Rate1 – 248Hz
Sustain0 – 10.7—
Body0 – 10.5—
Level0 – 10.5—

# TubularBells 1 input

Tubular bells / orchestral chimes (physical model): a struck metal tube whose prominent partials are tuned to 2:3:4 above the perceived strike pitch - the ear fuses them into a virtual pitch one octave below the 4th partial (the missing fundamental) - with higher inharmonic tube partials for the metallic clang and a long metal ring. Struck at Rate; Root is the perceived strike pitch, Mallet the strike hardness, Decay the ring length, Level out.

ParamRangeDefaultUnit
Root80 – 1000261Hz
Rate0.2 – 61Hz
Mallet0 – 10.5—
Decay0.3 – 21x
Level0 – 10.45—

# Dulcimer 1 input

Appalachian dulcimer (physical model): a strummed melody string over two open drone strings (root + fifth) - the constant drone under the melody is its signature - plucked digital-waveguide strings (Extended Karplus-Strong) through a small wooden box. Root sets the pitch, Rate the strum, Melody the melody-string interval above the drone, Bright the tone, Level out.

ParamRangeDefaultUnit
Root100 – 500196Hz
Rate0.3 – 82Hz
Melody0 – 74st
Bright0 – 10.5—
Level0 – 10.5—

# Kantele 1 input

Kantele (physical model): the Finnish box zither - open metal strings over a shallow wooden box plucked one at a time, a very bright, clean, bell-like tone with little body colour (drier and brighter than a harp), tuned pentatonic and arpeggiated. Root sets the pitch, Rate the arpeggio, Bright the metallic shimmer, Level the output.

ParamRangeDefaultUnit
Root120 – 800330Hz
Rate1 – 207Hz
Bright0 – 10.6—
Level0 – 10.5—

# Clavichord 1 input

Clavichord (physical model): a brass tangent strikes the string and stays in contact, so key pressure bends the pitch - the Bebung vibrato is its signature. Thin, low-stiffness strings give a quiet, bright, near-harmonic, fast-decaying metallic tone (Extended Karplus-Strong) through a small soundboard. Root sets the pitch, Rate the re-strike, Bright the tangent attack, Bebung the pitch-vibrato depth, Level the output.

ParamRangeDefaultUnit
Root80 – 1200262Hz
Rate0.3 – 102Hz
Bright0 – 10.5—
Bebung0 – 10.3—
Level0 – 10.5—

# Violin 1 input

Violin (physical model): a self-oscillating bowed string - an STK two-delay waveguide (separate neck and bridge delays, -1 nut + bridge reflections through a body lowpass) driven by a McIntyre-Woodhouse falling friction curve at the bow point, so the traveling Helmholtz corner sustains the classic sawtooth - coupled to a FIXED violin-body modal bank at the measured signature-mode frequencies (A0 air ~280 Hz, CBR ~400, B1-/A1/B1+ ~460/480/540) plus the ~2.3 kHz bridge hill, with three sympathetic open strings (D/A/E) ringing under the note. Root sets the pitch, BowSpeed/BowForce the articulation, Bright the tone, Level the output.

ParamRangeDefaultUnit
Root180 – 1400440Hz
BowSpeed0 – 10.5—
BowForce0 – 10.5—
Bright0 – 10.5—
Level0 – 10.4—

# Cello 1 input

Cello (physical model): a self-oscillating bowed string (STK two-delay waveguide - neck + bridge delays, -1 nut + bridge reflections through a body lowpass, McIntyre-Woodhouse falling friction at the bow) in the cello's range, coupled to a FIXED cello-body modal bank (A0 air ~100 Hz, T1 ~140, C3 ~180, main wood ~210/300, higher ~600) with three sympathetic open strings (G/D/A). Root sets the pitch, BowSpeed/BowForce the articulation, Bright the tone, Level the output.

ParamRangeDefaultUnit
Root65 – 520131Hz
BowSpeed0 – 10.5—
BowForce0 – 10.5—
Bright0 – 10.5—
Level0 – 10.4—

# DoubleBass 1 input

Double bass (physical model): the bowed STK two-delay waveguide in the double bass's deep range, coupled to a FIXED big-body modal bank scaled into the bass register (air ~60 Hz + low wood modes ~90/120/160/250/400) with three sympathetic open strings (A/D/G). The lowest, darkest of the bowed family. Root sets the pitch, BowSpeed/BowForce the articulation, Bright the tone, Level the output.

ParamRangeDefaultUnit
Root41 – 22055Hz
BowSpeed0 – 10.5—
BowForce0 – 10.5—
Bright0 – 10.5—
Level0 – 10.4—

# Viola 1 input

Viola (physical model): the bowed STK two-delay waveguide in the viola's alto range, coupled to a FIXED viola-body modal bank at its measured signature frequencies (A0 air ~230 Hz, second air ~330, main wood ~350/440, higher ~600) - lower and darker than the violin, brighter than the cello - with three sympathetic open strings (G/D/A). Root sets the pitch, BowSpeed/BowForce the articulation, Bright the tone, Level the output.

ParamRangeDefaultUnit
Root130 – 700220Hz
BowSpeed0 – 10.5—
BowForce0 – 10.5—
Bright0 – 10.5—
Level0 – 10.4—

# ViolaDaGamba 1 input

Viola da gamba (physical model): the bowed STK two-delay waveguide voiced as a bass viol - softer, reedier and flatter-bridged than the cello, in a comparable range - coupled to a FIXED viol-body modal bank (~90/130/175/220/300/550 Hz) with three sympathetic open strings (G/D/A). Root sets the pitch, BowSpeed/BowForce the articulation, Bright the tone, Level the output.

ParamRangeDefaultUnit
Root65 – 350147Hz
BowSpeed0 – 10.5—
BowForce0 – 10.5—
Bright0 – 10.45—
Level0 – 10.4—

# Nyckelharpa 1 input

Nyckelharpa (physical model): the Swedish keyed fiddle - a self-oscillating bowed string (STK two-delay waveguide, McIntyre-Woodhouse friction) over a bank of TWELVE chromatic sympathetic resonance strings that ring with every note, giving the silvery, reverberant halo that is its signature (far more sympathetic strings than the violin), through a wooden body. Root sets the pitch, BowSpeed/BowForce the articulation, Sympathetic the resonance-halo amount, Level the output.

ParamRangeDefaultUnit
Root150 – 900294Hz
BowSpeed0 – 10.5—
BowForce0 – 10.5—
Sympathetic0 – 10.6—
Level0 – 10.4—

# GrandPiano 1 input

Grand piano (physical model, modal synthesis): the 16 string partials are placed DIRECTLY at the stiff-string law f_n = n*f0*sqrt(1+B*n^2), so the inharmonicity is exact (the warmth/stretch of a real piano) - not a waveguide dispersion approximation. The hammer strikes at ~1/8 of the string, so its comb nulls the 8th partial (amp ~ |sin(n*pi/8)|); a second slightly-detuned unison set beats against the first for the two-stage decay and singing aftersound; a soundboard modal bank radiates. Root sets the pitch, Stiffness the inharmonicity B, Mallet the hammer brightness, Decay the ring, Detune the unison beat, Level the output.

ParamRangeDefaultUnit
Root30 – 1000220Hz
Stiffness0 – 0.0040.001—
Mallet0 – 10.5—
Decay0 – 10.6—
Detune0 – 10.4—
Level0 – 10.5—

# HurdyGurdy 1 input

Hurdy-gurdy (physical model): a rosined wheel, turned by the crank, continuously bows ALL the strings at once - a keyed melody string plus two constant drone strings (bourdon + a fifth) - through three self-oscillating STK BowedStrings, with a buzzing bridge ('the dog' / trompette) that rattles on each rhythmic crank coup. Root sets the melody pitch, Wheel the crank speed, Drone the drone level, Buzz the trompette rattle, Level the output.

ParamRangeDefaultUnit
Root100 – 800294Hz
Wheel0 – 10.5—
Drone0 – 10.6—
Buzz0 – 10.3—
Level0 – 10.4—

# Celesta 1 input

Celesta (physical model): steel bars struck by FELT hammers (soft, so few high partials) over wooden box resonators that boost and sustain the fundamental - the free-free bar modes (1 : 2.76 : 5.4) are present but the fundamental dominates, giving the soft, pure, ethereal bell-like celesta tone (warmer than a bare-bar glockenspiel, metal not wood like a marimba). Modal synthesis. Root sets the pitch, Rate the re-strike, Mallet the hammer hardness, Decay the ring, Level the output.

ParamRangeDefaultUnit
Root200 – 2000523Hz
Rate0.3 – 82Hz
Mallet0 – 10.4—
Decay0.3 – 31.2x
Level0 – 10.5—

# TuningFork 1 input

Tuning fork (physical model): a struck fork rings in the modes of a clamped-free bar (ratios 1 : 6.267 : 17.45) - the bright 'clang' overtone at 6.27x is prominent at the strike but dies away fast, leaving the pure, long-ringing fundamental sine that is the fork's signature. Modal synthesis. Root sets the pitch, Decay the (long) fundamental ring, Clang the overtone strength, Level the output.

ParamRangeDefaultUnit
Root120 – 2000440Hz
Rate0.2 – 60.8Hz
Decay1 – 168s
Clang0 – 10.6—
Level0 – 10.5—

# ChurchBell 1 input

Church bell (physical model): a cast bronze bell tuned to the true-harmonic partials - hum (0.5), prime (1.0, the perceived strike note), TIERCE (1.2, a minor third above the prime - the somber 'bell' colour no chime or bowl has), quint (1.5), nominal (2.0) and higher - struck by the clapper with a very long bronze ring (the hum rings longest). Modal synthesis. Root sets the strike pitch (prime), Mallet the clapper hardness, Decay the (long) ring, Level the output.

ParamRangeDefaultUnit
Root60 – 800196Hz
Rate0.1 – 40.6Hz
Mallet0 – 10.5—
Decay1 – 147s
Level0 – 10.45—

# SingingBowl 1 input

Tibetan singing bowl (physical model): a struck standing bell - four inharmonic shell modes (~1 : 2.7 : 5.2 : 8.3) with a very long decay, EACH a degenerate pair split by a few Hz (no bowl is perfectly round), so the two halves of every mode beat against each other - the slow amplitude 'wah' is its signature. Root sets the pitch, Split the beat rate (Hz between the paired modes), Decay the (long) ring, Mallet the strike hardness, Level the output.

ParamRangeDefaultUnit
Root100 – 800220Hz
Split0 – 62.5Hz
Decay1 – 126s
Mallet0 – 10.5—
Level0 – 10.45—

# SteelTongue 1 input

Steel tongue drum (physical model): cut steel tongues of a tank/Hapi drum, each TUNED so its overtones sit near-harmonic (octave-tuned, ~1:2:3) for a mellow, pure, bell-like pitched tone with a medium ring - warmer and rounder than a glockenspiel or chime. Struck-modal. Root sets the pitch, Rate the re-strike, Mallet the hardness, Decay the ring, Level the output.

ParamRangeDefaultUnit
Root100 – 1000261Hz
Rate0.3 – 81.5Hz
Mallet0 – 10.5—
Decay0.3 – 31.2x
Level0 – 10.5—

Probability

180 modules

# Chance 1 input

Probabilistic gate: lets each note through with the set probability.

ParamRangeDefaultUnit
Probability0 – 10.8—
Mod Amt-1 – 10—

# PrimeGate 1 input

Number-theory gate: counts incoming notes and lets one through only when its ordinal is a prime number (2,3,5,7,11,...), so the texture thins out unpredictably as primes spread; Invert keeps the composites instead.

ParamRangeDefaultUnit
Invert0 – 10—

# ThueMorseGate 1 input

Thue-Morse gate: passes notes where the cube-free Thue-Morse sequence (the bit-parity of the note count) is 0, an aperiodic-yet-structured pattern that never settles into a short loop; Invert flips which half plays.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitGate 1 input

Digit-sum gate: passes a note unless the decimal digit-sum of its count is divisible by Modulo, carving a self-similar arithmetic rhythm out of a steady stream; Invert keeps only the divisible ones.

ParamRangeDefaultUnit
Modulo2 – 93—
Invert0 – 10—

# CollatzGate 1 input

Collatz gate: runs the 3n+1 process on each note's count and passes it when the number of steps to reach 1 is even - an erratic but deterministic gate straight from the unsolved Collatz conjecture; Invert takes the odd-length ones.

ParamRangeDefaultUnit
Invert0 – 10—

# GoldenGate 1 input

Golden gate: passes notes by a golden-ratio low-discrepancy sequence against Density, so the kept notes spread far more evenly through time than random chance ever would - a deterministic, clump-free thinning.

ParamRangeDefaultUnit
Density0 – 10.5—

# FibGate 1 input

Fibonacci gate: passes a note unless the Fibonacci number of its ordinal is divisible by Modulo, carving a golden, self-similar rhythm out of a steady stream; Invert keeps the divisible ones.

ParamRangeDefaultUnit
Modulo2 – 125—
Invert0 – 10—

# RandomGateWalk 1 input

Random-gate walk: the pass probability itself drifts on a bounded random walk, so the music breathes between dense and sparse passages instead of thinning uniformly like a fixed-chance gate.

ParamRangeDefaultUnit
Step0 – 10.3—

# IntervalGate 1 input

Interval gate: passes a note only if its leap from the previous kept note lies between Min and Max semitones, filtering a line down to small steps or to wide jumps - a melodic-contour sieve.

ParamRangeDefaultUnit
Min0 – 240st
Max0 – 247st

# VelRandomGate 1 input

Velocity-random gate: passes each note with a probability that rises with its velocity, so accented hits survive while ghost notes thin out - dynamics-weighted probabilistic gating.

ParamRangeDefaultUnit
Bias0 – 10.7—

# MoebiusGate 1 input

Moebius gate: passes a note only when its count is squarefree (the Moebius function is non-zero), dropping any note whose ordinal is divisible by a perfect square - a sieve-flavoured aperiodic gate; Invert keeps the square-divisible ones.

ParamRangeDefaultUnit
Invert0 – 10—

# SquareGate 1 input

Square gate: passes note-ons only on perfect-square counts (1,4,9,16,25,...), so notes get steadily sparser as the gaps between squares widen; Invert plays everything except the squares.

ParamRangeDefaultUnit
Invert0 – 10—

# TriangularGate 1 input

Triangular gate: passes note-ons on triangular-number counts (1,3,6,10,15,...), thinning the stream on the handshake-number sequence; Invert keeps the non-triangular notes.

ParamRangeDefaultUnit
Invert0 – 10—

# AbundantGate 1 input

Abundant gate: passes note-ons only on abundant counts - numbers whose proper divisors sum to more than themselves (12, 18, 20, 24...) - thinning the stream onto the divisor-rich integers; Invert keeps the deficient ones.

ParamRangeDefaultUnit
Invert0 – 10—

# HappyGate 1 input

Happy gate: passes notes on happy-number counts - those whose repeated sum-of-squared-digits reaches 1 - and drops the sad ones that fall into the 4-16-37 cycle; Invert flips which set plays.

ParamRangeDefaultUnit
Invert0 – 10—

# PrimePowerGate 1 input

Prime-power gate: passes note-ons only when the count is a power of a single prime (2,3,4,5,7,8,9,...), a sparse self-similar pattern from analytic number theory; Invert keeps everything else.

ParamRangeDefaultUnit
Invert0 – 10—

# LucasGate 1 input

Lucas gate: passes note-ons only on Lucas-number counts (2,1,3,4,7,11,18,...), the Fibonacci companion sequence, thinning the stream onto golden-ratio-spaced ordinals; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CatalanGate 1 input

Catalan gate: passes note-ons only on Catalan-number counts (1,2,5,14,42,...), the combinatorial sequence counting trees and bracketings, which thins out fast as the values explode; Invert keeps the others.

ParamRangeDefaultUnit
Invert0 – 10—

# PalindromeGate 1 input

Palindrome gate: passes note-ons only on counts that read the same forwards and backwards (1,2,...,9,11,22,...,101,...), an irregular, self-mirroring thinning; Invert keeps the non-palindromes.

ParamRangeDefaultUnit
Invert0 – 10—

# HighlyCompositeGate 1 input

Highly-composite gate: passes note-ons only on counts that set a new record for number of divisors (1,2,4,6,12,24,36,48,60,...), the maximally-factorable integers; a rare, widening-gap accent pulse. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# ProbabilityRamp 1 input

Probability ramp: the pass chance sweeps from Start to End across a repeating cycle of notes, so phrases can fade in (sparse to dense) or thin out (dense to sparse) on a loop - an evolving probabilistic gate.

ParamRangeDefaultUnit
Length2 – 328—
Start0 – 10.2—
End0 – 11—

# AntiRepeatGate 1 input

Anti-repeat gate: drops a note when it repeats the immediately-previous pitch, forcing the line to keep moving instead of hammering one note - an automatic de-stutter for melodic variety.

ParamRangeDefaultUnit
On0 – 11—

# ProbabilityByPitch 1 input

Probability by pitch: the chance a note passes rises or falls with its keyboard position, so you can thin out the bass while keeping the top (or the reverse) - register-weighted probabilistic gating.

ParamRangeDefaultUnit
Base0 – 10.7—
Slope-1 – 10.3—

# PrimeIntervalGate 1 input

Prime-interval gate: passes a note only when its leap from the previous one spans a prime number of semitones (2,3,5,7,11,...), favouring the seconds, thirds, fourths and fifths while blocking octaves and tritones - a number-theoretic melodic filter.

ParamRangeDefaultUnit
On0 – 11—

# PerrinGate 1 input

Perrin gate: passes note-ons on Perrin-sequence counts (3,2,5,5,7,10,12,...; P(n)=P(n-2)+P(n-3)), famous because n almost always divides P(n) exactly when n is prime; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PartitionGate 1 input

Partition gate: passes note-ons on integer-partition counts p(k) (1,2,3,5,7,11,15,22,30,...), the number of ways to write k as a sum, which thins out as it climbs; Invert keeps the others.

ParamRangeDefaultUnit
Invert0 – 10—

# TribonacciGate 1 input

Tribonacci gate: passes note-ons on Tribonacci-sequence counts (1,2,4,7,13,24,44,...; each the sum of the previous three), spreading wider than Fibonacci; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# JacobsthalGate 1 input

Jacobsthal gate: passes note-ons on Jacobsthal-number counts (1,3,5,11,21,43,...; J(n)=J(n-1)+2J(n-2)), a Fibonacci-like sequence whose ratio tends to 2; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PellGate 1 input

Pell gate: passes note-ons on Pell-number counts (1,2,5,12,29,70,...; P(n)=2P(n-1)+P(n-2)), the silver-ratio sequence behind the best rational approximations to root-2; Invert keeps the others.

ParamRangeDefaultUnit
Invert0 – 10—

# CoprimeGate 1 input

Coprime gate: passes a note only when its count shares no common factor with the modulus (gcd = 1), thinning the stream onto the totatives of the modulus - a number-theoretic sieve; Invert keeps the non-coprime counts.

ParamRangeDefaultUnit
Modulus2 – 166—
Invert0 – 10—

# ContraryGate 1 input

Contrary gate: passes a note only if it moves in the opposite direction to the previous melodic step, forcing the line into constant zig-zag contrary motion and filtering out runs that keep climbing or falling.

ParamRangeDefaultUnit
On0 – 11—

# WythoffGate 1 input

Wythoff gate: passes note-ons on the lower-Wythoff counts floor(n*phi) (1,3,4,6,8,9,11,...), the golden-ratio Beatty sequence that, with its complement, partitions the integers; Invert keeps the upper-Wythoff notes.

ParamRangeDefaultUnit
Invert0 – 10—

# SemiprimeGate 1 input

Semiprime gate: passes note-ons on semiprime counts - numbers that are the product of exactly two primes (4,6,9,10,14,15,21,...) - a moderately-sparse, multiplicatively-defined pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PentagonalGate 1 input

Pentagonal gate: passes note-ons on pentagonal-number counts (1,5,12,22,35,...; k(3k-1)/2), the figurate numbers from Euler's pentagonal-number theorem; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PronicGate 1 input

Pronic gate: passes note-ons on pronic (oblong) counts n(n+1): 2,6,12,20,30,..., the products of consecutive integers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# MersenneGate 1 input

Mersenne gate: passes note-ons on Mersenne-number counts (one less than a power of two: 1,3,7,15,31,63,127), the all-ones binary numbers; their exponential spacing thins the stream fast. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# TwinPrimeGate 1 input

Twin-prime gate: passes note-ons on counts belonging to a twin-prime pair (a prime with another prime two away: 3,5,7,11,13,17,19,...), thinning onto the famously-clustered twin primes; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SophieGermainGate 1 input

Sophie-Germain gate: passes note-ons on Sophie-Germain-prime counts - primes p where 2p+1 is also prime (2,3,5,11,23,...), the primes behind safe-prime cryptography; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# RecamanGate 1 input

Recaman gate: passes note-ons on counts that appear in Recaman's sequence (jump back by n if new and positive, else forward), the famously erratic jumping sequence; its darting coverage thins the stream unpredictably. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# UlamGate 1 input

Ulam gate: passes note-ons on Ulam-number counts (each the smallest integer that is a sum of two earlier terms in exactly one way: 1,2,3,4,6,8,11,...), a mysteriously near-periodic set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# TetrahedralGate 1 input

Tetrahedral gate: passes note-ons on tetrahedral-number counts n(n+1)(n+2)/6 (1,4,10,20,35,56,...), the 3-D figurate numbers counting stacked spheres; their cubic spacing thins fast. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# NarcissisticGate 1 input

Narcissistic gate: passes note-ons on Armstrong (narcissistic) counts that equal the sum of their own digits each raised to the number-of-digits power (1,153,370,371,407,...), a rare self-referential set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PolygonalGate 1 input

Polygonal gate: passes note-ons on s-gonal figurate-number counts for any chosen number of Sides - triangular at 3, square at 4, pentagonal at 5, and so on - one knob covering the whole figurate family; Invert keeps the rest.

ParamRangeDefaultUnit
Sides3 – 125—
Invert0 – 10—

# SmoothNumberGate 1 input

Smooth-number gate: passes note-ons whose count's largest prime factor stays at or below Bound (a B-smooth number, the easy-to-factor integers behind sieve algorithms); raising Bound opens the gate on more counts. Invert keeps the rest.

ParamRangeDefaultUnit
Bound2 – 507—
Invert0 – 10—

# RoughNumberGate 1 input

Rough-number gate: passes note-ons whose count's smallest prime factor is at least Bound (a B-rough number with no small factors), the complement of smoothness; raising Bound makes the gate fire only on prime-like counts. Invert keeps the rest.

ParamRangeDefaultUnit
Bound2 – 305—
Invert0 – 10—

# KeithNumberGate 1 input

Keith-number gate: passes note-ons on Keith (repfigit) counts - numbers that reappear in the Fibonacci-like sequence seeded by their own digits (14,19,28,47,...) - an extremely rare self-referential set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PracticalNumberGate 1 input

Practical-number gate: passes note-ons on practical counts, where every smaller integer is a sum of distinct divisors of the count (1,2,4,6,8,12,...; all powers of two and more), a divisor-rich set close to the abundant numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# UndulatingGate 1 input

Undulating gate: passes note-ons on undulating counts whose digits zig-zag high-low-high (121,132,231,1212,...), a wave-like digit pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# RepunitGate 1 input

Repunit gate: passes note-ons on repunit counts whose decimal digits are all ones (1,11,111,1111,...), an extremely sparse, widely-spaced pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# AutomorphicGate 1 input

Automorphic gate: passes note-ons on automorphic counts whose square ends in the number itself (5,6,25,76,376,625,...), a curious self-reproducing-under-squaring set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# BinaryPalindromeGate 1 input

Binary-palindrome gate: passes note-ons whose count reads the same in binary forwards and backwards (1,3,5,7,9,15,17,21,...), a self-mirroring bit pattern distinct from decimal palindromes; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PalindromicPrimeGate 1 input

Palindromic-prime gate: passes note-ons on counts that are both prime and a decimal palindrome (2,3,5,7,11,101,131,151,...), the intersection of two famous sparse sets; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# MotzkinGate 1 input

Motzkin gate: passes note-ons on Motzkin-number counts (1,2,4,9,21,51,127,...), the combinatorial sequence counting non-crossing chords and lattice paths; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# BellNumberGate 1 input

Bell-number gate: passes note-ons on Bell-number counts (1,2,5,15,52,203,877,...), which count the ways to partition a set into groups; their fast growth thins the stream quickly. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PadovanGate 1 input

Padovan gate: passes note-ons on Padovan-number counts (1,2,3,4,5,7,9,12,16,...; P(n)=P(n-2)+P(n-3)), the plastic-number sequence; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PartitionParityGate 1 input

Partition-parity gate: passes note-ons when the integer-partition number p(count) is odd, a famously-irregular parity pattern (the subject of Ramanujan's congruences); Invert keeps the even-p counts.

ParamRangeDefaultUnit
Invert0 – 10—

# CatalanParityGate 1 input

Catalan-parity gate: passes note-ons when the Catalan number C(count) is odd - which happens only when the count-plus-one is a power of two - giving a sparse, exponentially-spaced pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitProductGate 1 input

Digit-product gate: passes a note only when the product of its count's decimal digits exceeds a threshold, so counts containing a zero or small digits drop out - a digit-driven thinning with a tunable density. Invert keeps the rest.

ParamRangeDefaultUnit
Threshold0 – 2009—
Invert0 – 10—

# SylvesterGate 1 input

Sylvester gate: passes note-ons on Sylvester's-sequence counts (2,3,7,43,1807,...; each one more than the product of all previous), a doubly-exponential set so sparse it fires only a handful of times; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# GolombGate 1 input

Golomb gate: passes note-ons on Golomb-sequence counts (1,2,3,4,5,...; the non-decreasing self-describing sequence where term n says how often n appears), a gently-climbing staircase set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HofstadterQGate 1 input

Hofstadter-Q gate: passes note-ons on values that occur in the chaotic Hofstadter Q meta-sequence (Q(n)=Q(n-Q(n-1))+Q(n-Q(n-2))), an erratic self-referential set from Godel, Escher, Bach; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SelfNumberGate 1 input

Self-number gate: passes note-ons on self (Colombian) counts that cannot be written as some smaller number plus that number's digit-sum (1,3,5,7,9,20,31,...), a self-referential sieve; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SphenicGate 1 input

Sphenic gate: passes note-ons on sphenic counts - squarefree products of exactly three distinct primes (30,42,66,70,78,...) - a multiplicatively-defined, moderately-sparse set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PowerfulNumberGate 1 input

Powerful-number gate: passes note-ons on powerful counts where every prime factor occurs at least squared (1,4,8,9,16,25,27,32,36,...), the dense-factor opposite of squarefree; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# EvenDigitGate 1 input

Even-digit gate: passes note-ons whose count is written with only even decimal digits (2,4,6,8,20,22,24,...), a simple digit-pattern thinning; Invert passes counts containing an odd digit.

ParamRangeDefaultUnit
Invert0 – 10—

# OddDigitGate 1 input

Odd-digit gate: passes note-ons whose count is written with only odd decimal digits (1,3,5,7,9,11,13,15,...), the digit-pattern complement of the even-digit gate; Invert passes counts containing an even digit.

ParamRangeDefaultUnit
Invert0 – 10—

# MertensGate 1 input

Mertens gate: passes note-ons while the Mertens function (the running sum of the Moebius function up to the count) is positive, a slow random-walk-like sign whose growth is tied to the Riemann hypothesis; Invert keeps the negative stretches.

ParamRangeDefaultUnit
Invert0 – 10—

# LiouvilleGate 1 input

Liouville gate: passes note-ons when the Liouville function is +1 (the count has an even number of prime factors with multiplicity), an almost-balanced parity stream from analytic number theory; Invert keeps the odd-factor counts.

ParamRangeDefaultUnit
Invert0 – 10—

# PrimeDigitGate 1 input

Prime-digit gate: passes note-ons whose count is written with only the prime digits 2, 3, 5 and 7 (2,3,5,7,22,23,25,...), a digit-pattern sieve; Invert passes counts containing a non-prime digit.

ParamRangeDefaultUnit
Invert0 – 10—

# SmithNumberGate 1 input

Smith-number gate: passes note-ons on Smith counts whose digit sum equals the digit sum of their prime factorization (4,22,27,58,85,...), a quirky composite set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DivisorParityGate 1 input

Divisor-parity gate: passes note-ons on counts with an odd number of divisors, which are exactly the perfect squares (1,4,9,16,25,...) - a gate that fires on an ever-widening square spacing; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitalRootGate 1 input

Digital-root gate: passes note-ons whose count has a chosen digital root (the single digit reached by repeatedly summing digits), giving a clean period-9 repeating pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Root1 – 99—
Invert0 – 10—

# BinaryWeightGate 1 input

Binary-weight gate: passes note-ons whose count has exactly the chosen number of 1-bits in binary (its Hamming weight), a bit-pattern sieve that thins to sparser, more clustered hits as the weight rises; Invert keeps the rest.

ParamRangeDefaultUnit
Bits1 – 82—
Invert0 – 10—

# PentanacciGate 1 input

Pentanacci gate: passes note-ons on pentanacci counts where each term is the sum of the previous five (1,2,4,8,16,31,61,120,...), a fast-growing Fibonacci generalization; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# TetranacciGate 1 input

Tetranacci gate: passes note-ons on tetranacci counts where each term is the sum of the previous four (1,2,4,8,15,29,56,108,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# NarayanaGate 1 input

Narayana gate: passes note-ons on Narayana's-cows counts (a(n)=a(n-1)+a(n-3): 1,2,3,4,6,9,13,19,28,...), a slow recurrence whose ratio tends to the supergolden ratio; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CollatzPeakGate 1 input

Collatz-peak gate: passes note-ons whose count sends its Collatz (3n+1) trajectory soaring above Mult times the starting value, spotlighting the counts that take the wildest hailstone excursions; Invert keeps the rest.

ParamRangeDefaultUnit
Mult1 – 508—
Invert0 – 10—

# PellLucasGate 1 input

Pell-Lucas gate: passes note-ons on companion-Pell counts (Q(n)=2Q(n-1)+Q(n-2): 2,6,14,34,82,198,...), the Lucas-style partner of the Pell numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# UntouchableGate 1 input

Untouchable gate: passes note-ons on untouchable counts that can never be the sum of the proper divisors of any number (2,5,52,88,96,...), an unreachable set in the aliquot map; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# RefactorableGate 1 input

Refactorable gate: passes note-ons on refactorable (tau) counts whose own number of divisors divides the number (1,2,8,9,12,18,24,36,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PowerOfTwoGate 1 input

Power-of-two gate: passes note-ons only on counts that are exact powers of two (1,2,4,8,16,32,...), an octave-spaced exponentially-thinning pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# AlmostPrimeGate 1 input

Almost-prime gate: passes note-ons on k-almost-prime counts having exactly K prime factors counted with multiplicity (K=1 primes, K=2 semiprimes, K=3 ...), one knob spanning the whole almost-prime family; Invert keeps the rest.

ParamRangeDefaultUnit
K1 – 62—
Invert0 – 10—

# SquarefreeGate 1 input

Squarefree gate: passes note-ons on squarefree counts with no repeated prime factor (1,2,3,5,6,7,10,11,13,...), about 61 percent of integers; Invert keeps the square-divisible counts.

ParamRangeDefaultUnit
Invert0 – 10—

# CubeGate 1 input

Cube gate: passes note-ons on perfect-cube counts (1,8,27,64,125,...), an exponentially-widening figurate spacing; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# FibonacciGate 1 input

Fibonacci gate: passes note-ons on Fibonacci-number counts (1,2,3,5,8,13,21,34,...), the golden-ratio recurrence whose gaps grow geometrically; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredHexGate 1 input

Centered-hexagonal gate: passes note-ons on centered-hexagonal counts (1,7,19,37,61,...), the numbers of dots in a growing hexagonal grid (and the rows of Pascal-triangle hex packing); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# LazyCatererGate 1 input

Lazy-caterer gate: passes note-ons on central-polygonal (lazy-caterer) counts (1,2,4,7,11,16,22,...), the maximum pieces a pancake splits into with n straight cuts; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# StarNumberGate 1 input

Star-number gate: passes note-ons on centered star (hexagram) counts (1,13,37,73,121,...), the dots in a growing six-pointed star; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# VelocityProbGate 1 input

Velocity-probability gate: passes each note with a probability that rises with its velocity, so soft notes thin out and accents survive - a dynamics-driven random thinning; Bias lifts the baseline pass chance.

ParamRangeDefaultUnit
Bias0 – 10.2—

# OreNumberGate 1 input

Ore-number gate: passes note-ons on Ore (harmonic-divisor) counts whose divisors have an integer harmonic mean (1,6,28,140,496,...), a divisor-rich set overlapping the perfect numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# EmirpGate 1 input

Emirp gate: passes note-ons on emirp counts - primes that turn into a different prime when their digits are reversed (13,17,31,37,71,73,79,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredSquareGate 1 input

Centered-square gate: passes note-ons on centered-square counts (1,5,13,25,41,...), the dots in a square diamond grown ring by ring; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SquarePyramidalGate 1 input

Square-pyramidal gate: passes note-ons on square-pyramidal counts (1,5,14,30,55,...), the number of cannonballs in a square-based pyramid; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredTriangularGate 1 input

Centered-triangular gate: passes note-ons on centered-triangular counts (1,4,10,19,31,...), a triangular grid grown outward from a central dot; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitCountGate 1 input

Digit-count gate: passes note-ons whose running count has exactly the chosen number of decimal digits, opening for a block of counts then closing - a coarse decimal-magnitude window; Invert keeps the rest.

ParamRangeDefaultUnit
Digits1 – 62—
Invert0 – 10—

# GapGate 1 input

Gap gate: passes a note only after at least Gap notes have gone by since the last one it let through, a refractory thinner that guarantees a minimum spacing between surviving notes regardless of input density.

ParamRangeDefaultUnit
Gap1 – 324—

# CoprimeStepGate 1 input

Coprime-step gate: passes a note only when its running count shares no common factor with the previous kept count (their gcd is 1), a number-theoretic thinning that favours relatively-prime spacings; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# AchillesGate 1 input

Achilles gate: passes note-ons on Achilles counts - powerful numbers (every prime factor squared) that are not themselves a perfect power (72,108,200,288,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# FrugalGate 1 input

Frugal gate: passes note-ons on frugal counts that take fewer digits to write than their prime factorization does (125=5^3, 128=2^7, ...), an economical-number sieve; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SemiperfectGate 1 input

Semiperfect gate: passes note-ons on semiperfect (pseudoperfect) counts where some subset of the proper divisors sums to the number (6,12,18,20,24,28,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# ZumkellerGate 1 input

Zumkeller gate: passes note-ons on Zumkeller counts whose divisors can be split into two sets of equal sum (6,12,20,24,28,30,...), a balanced-divisor set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PoliteGate 1 input

Polite gate: passes note-ons on polite counts that can be written as a sum of two or more consecutive integers (everything except the powers of two); Invert keeps just the powers of two.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitalRootPrimeGate 1 input

Digital-root-prime gate: passes note-ons whose digital root is a prime digit (2, 3, 5 or 7), a clean period-9 repeating pattern; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# RepdigitGate 1 input

Repdigit gate: passes note-ons on repdigit counts whose decimal digits are all identical (1..9,11,22,...,99,111,...), a sparse uniform-digit pattern distinct from the all-ones repunits; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# StrobogrammaticGate 1 input

Strobogrammatic gate: passes note-ons on counts that read the same when rotated 180 degrees (0,1,8,11,69,88,96,...), a visual digit-symmetry set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# TruncatablePrimeGate 1 input

Right-truncatable-prime gate: passes note-ons on primes that stay prime as each trailing digit is chopped off (2,3,5,7,23,29,31,37,53,...), a famously finite set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# NivenGate 1 input

Niven (Harshad) gate: passes note-ons on counts divisible by the sum of their own digits (1..10,12,18,20,21,24,...), a moderately-dense digit-driven set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PerfectPowerGate 1 input

Perfect-power gate: passes note-ons on counts that are an exact power a^b with b>=2 (1,4,8,9,16,25,27,32,...), merging the squares, cubes and higher powers into one set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CakeNumberGate 1 input

Cake-number gate: passes note-ons on cake counts (the most pieces a cake splits into with k planar cuts: 1,2,4,8,15,26,42,...), the 3-D analogue of the lazy-caterer numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HighlyAbundantGate 1 input

Highly-abundant gate: passes note-ons on highly-abundant counts whose divisor sum beats that of every smaller number (1,2,3,4,6,8,10,12,16,18,20,24,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# MersennePrimeGate 1 input

Mersenne-prime gate: passes note-ons on Mersenne-prime counts (2^p-1 that are prime: 3,7,31,127,...), an extremely sparse, exponentially-spaced set tied to the perfect numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# FermatPrimeGate 1 input

Fermat-prime gate: passes note-ons on the five known Fermat primes (2^(2^k)+1: 3,5,17,257,65537), the primes behind constructible polygons; an exceedingly rare set. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SuperabundantGate 1 input

Superabundant gate: passes note-ons on superabundant counts whose ratio sigma(n)/n beats every smaller number (1,2,4,6,12,24,36,48,60,120,...), the densest-divisor records; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DeficientGate 1 input

Deficient gate: passes note-ons on deficient counts whose proper divisors sum to less than the number (1,2,3,4,5,7,8,9,10,11,...; the majority of integers); Invert keeps the abundant/perfect ones.

ParamRangeDefaultUnit
Invert0 – 10—

# PerfectNumberGate 1 input

Perfect-number gate: passes note-ons on perfect counts equal to the sum of their proper divisors (6,28,496,8128), an exceedingly rare and ancient set; mostly silent, firing only on those landmarks. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HammingNumberGate 1 input

Hamming-number gate: passes note-ons on regular (5-smooth) counts whose only prime factors are 2, 3 and 5 (1,2,3,4,5,6,8,9,10,12,15,16,...), the Hamming/Humble numbers of computing lore; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# ThabitGate 1 input

Thabit gate: passes note-ons on Thabit (321-) number counts (3*2^n-1: 2,5,11,23,47,95,191,...), the medieval numbers behind amicable-pair constructions; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# ProthGate 1 input

Proth gate: passes note-ons on Proth-number counts (k*2^n+1 with k odd and k below 2^n: 3,5,9,13,17,25,...), the numbers with a fast dedicated primality test; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# LeylandGate 1 input

Leyland gate: passes note-ons on Leyland-number counts (x^y+y^x for x,y>=2: 8,17,32,54,57,100,145,...), a sparse two-exponent set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# WoodallGate 1 input

Woodall gate: passes note-ons on Woodall-number counts (n*2^n-1: 1,7,23,63,159,383,...), an exponentially-sparse set partnered with the Cullen numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CullenGate 1 input

Cullen gate: passes note-ons on Cullen-number counts (n*2^n+1: 3,9,25,65,161,385,...), the +1 companions of the Woodall numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitSumGate 1 input

Digit-sum gate: passes note-ons whose decimal digit sum equals the chosen target, a repeating digit-driven pattern whose density you set with the target; Invert keeps the rest.

ParamRangeDefaultUnit
Target1 – 409—
Invert0 – 10—

# DivisorCountGate 1 input

Divisor-count gate: passes note-ons whose count has exactly the chosen number of divisors (tau=2 selects primes, tau=3 prime squares, and so on), a divisor-structure sieve; Invert keeps the rest.

ParamRangeDefaultUnit
Tau1 – 242—
Invert0 – 10—

# OctahedralGate 1 input

Octahedral gate: passes note-ons on octahedral counts (k(2k^2+1)/3: 1,6,19,44,85,...), the 3-D figurate numbers counting points in an octahedron; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# StellaOctangulaGate 1 input

Stella-octangula gate: passes note-ons on stella-octangula counts (k(2k^2-1): 1,14,51,124,245,...), the points of a growing star-tetrahedron; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# KaprekarGate 1 input

Kaprekar gate: passes note-ons on Kaprekar counts whose square can be split into two parts that add back to the number (1,9,45,55,99,297,703,999,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CarmichaelGate 1 input

Carmichael gate: passes note-ons on Carmichael counts - squarefree composites that fool the Fermat primality test (561,1105,1729,...) - via Korselt's criterion; an extremely sparse set. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PolydivisibleGate 1 input

Polydivisible gate: passes note-ons on polydivisible counts where the first k digits form a number divisible by k for every prefix (12,15,24,...,120,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitFactorialGate 1 input

Factorion gate: passes note-ons on the rare factorion counts equal to the sum of the factorials of their digits (1,2,145,40585); mostly silent, firing only on those four. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# EvenDigitSumGate 1 input

Even-digit-sum gate: passes note-ons whose decimal digit sum is even, a near-even-split digit pattern; Invert keeps the odd-digit-sum counts.

ParamRangeDefaultUnit
Invert0 – 10—

# WeirdNumberGate 1 input

Weird-number gate: passes note-ons on weird counts that are abundant yet have no subset of proper divisors summing to the number (70,836,4030,...), a rare paradoxical set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PrimorialGate 1 input

Primorial gate: passes note-ons on primorial counts - products of the first k primes (2,6,30,210,2310,...) - an extremely sparse, fast-growing set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# AntiprimeGate 1 input

Antiprime gate: passes note-ons on highly-composite (antiprime) counts that have more divisors than every smaller number (1,2,4,6,12,24,36,48,60,...), the most-divisible records; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# TrimorphicGate 1 input

Trimorphic gate: passes note-ons on trimorphic counts whose cube ends in the number itself (1,4,5,6,9,24,25,49,...), the cube-analogue of automorphic numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# EquidigitalGate 1 input

Equidigital gate: passes note-ons on equidigital counts that take the same number of digits to write as their prime factorization does (1,2,3,5,7,10,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# ExtravagantGate 1 input

Extravagant gate: passes note-ons on extravagant counts whose prime factorization takes MORE digits to write than the number itself (4,6,8,9,12,18,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HoaxNumberGate 1 input

Hoax-number gate: passes note-ons on hoax counts whose digit sum equals the summed digit sums of their DISTINCT prime factors (22,58,84,...), the squarefree-distinct cousin of Smith numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DudeneyGate 1 input

Dudeney gate: passes note-ons on Dudeney counts that are perfect cubes whose digit sum equals the cube root (1,512,4913,5832,17576,19683); an extremely rare set. Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SunnyNumberGate 1 input

Sunny-number gate: passes note-ons on sunny counts where the number plus one is a perfect square (3,8,15,24,35,48,...), one less than each square; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# OdiousGate 1 input

Odious gate: passes note-ons on odious counts with an odd number of 1-bits in binary (1,2,4,7,8,11,13,14,...), the Thue-Morse complement of the evil numbers; Invert keeps the evil counts.

ParamRangeDefaultUnit
Invert0 – 10—

# SchroederGate 1 input

Schroeder gate: passes note-ons on large-Schroeder counts (1,2,6,22,90,394,1806,...), the lattice-path numbers counting subdivisions and super-Catalan structures; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DelannoyGate 1 input

Delannoy gate: passes note-ons on central-Delannoy counts (1,3,13,63,321,1683,...), the king-move lattice paths from corner to corner of a grid; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# WedderburnEthringtonGate 1 input

Wedderburn-Etherington gate: passes note-ons on the counts of unordered binary trees (1,2,3,6,11,23,46,98,...), a combinatorial sequence from chemistry and phylogenetics; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PalindromicSquareGate 1 input

Palindromic-square gate: passes note-ons whose square reads the same forwards and backwards (1,2,3,11,22,26,101,111,...), the roots of palindromic squares; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# NontotientGate 1 input

Nontotient gate: passes note-ons on nontotient counts that are never the output of Euler's totient for any number (14,26,34,38,50,...; all even), an unreachable set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# LuckyNumberGate 1 input

Lucky-number gate: passes note-ons on Ulam's lucky counts, the survivors of a Josephus-style sieve (1,3,7,9,13,15,21,25,...) that share many properties with the primes; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# MagicConstantGate 1 input

Magic-constant gate: passes note-ons on magic-square constant counts n(n^2+1)/2 - the common row/column/diagonal sum of an n x n magic square (1,5,15,34,65,111,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# LeonardoGate 1 input

Leonardo gate: passes note-ons on Leonardo-number counts (L(n)=L(n-1)+L(n-2)+1: 1,3,5,9,15,25,41,...), the sizes behind Dijkstra's smoothsort heaps; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HeptanacciGate 1 input

Heptanacci gate: passes note-ons on heptanacci counts where each term is the sum of the previous seven (1,2,4,8,16,32,64,127,...), approaching a doubling sequence; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HexanacciGate 1 input

Hexanacci gate: passes note-ons on hexanacci counts where each term is the sum of the previous six (1,2,4,8,16,32,63,125,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredPentagonalGate 1 input

Centered-pentagonal gate: passes note-ons on centered-pentagonal counts (1,6,16,31,51,76,...), a pentagon grown ring by ring around a center dot; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredCubeGate 1 input

Centered-cube gate: passes note-ons on centered-cube counts (1,9,35,91,189,...), the dots in a cube grown shell by shell around a center; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# RhombicDodecahedralGate 1 input

Rhombic-dodecahedral gate: passes note-ons on rhombic-dodecahedral counts (1,15,65,175,369,...), the 3-D figurate numbers of that crystal shape; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# ZuckermanGate 1 input

Zuckerman gate: passes note-ons on Zuckerman counts divisible by the product of their own (nonzero) decimal digits (1..9,11,12,15,24,36,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# MoranGate 1 input

Moran gate: passes note-ons on Moran counts - Harshad numbers whose quotient (number over its digit sum) is prime (18,21,27,42,45,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# BlumIntegerGate 1 input

Blum-integer gate: passes note-ons on Blum counts that are the product of two distinct primes both congruent to 3 mod 4 (21,33,57,69,77,...), the moduli behind Blum-Blum-Shub cryptography; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# FibonacciPrimeGate 1 input

Fibonacci-prime gate: passes note-ons on Fibonacci counts that are also prime (2,3,5,13,89,233,1597,...), a doubly-special sparse set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# LucasPrimeGate 1 input

Lucas-prime gate: passes note-ons on Lucas counts that are also prime (2,3,7,11,29,47,199,521,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SafePrimeGate 1 input

Safe-prime gate: passes note-ons on safe-prime counts - primes p for which (p-1)/2 is also prime (5,7,11,23,47,59,...), the partners of the Sophie-Germain primes used in cryptography; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CousinPrimeGate 1 input

Cousin-prime gate: passes note-ons on counts in a cousin-prime pair (two primes four apart: 3,7,13,17,19,23,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SexyPrimeGate 1 input

Sexy-prime gate: passes note-ons on counts in a sexy-prime pair (two primes six apart: 5,7,11,13,17,23,...), so named from the Latin sex for six; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# HexagonalPyramidalGate 1 input

Hexagonal-pyramidal gate: passes note-ons on hexagonal-pyramidal counts (1,7,25,63,129,...), the cannonballs in a hexagon-based pyramid; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredDecagonalGate 1 input

Centered-decagonal gate: passes note-ons on centered-decagonal counts (1,11,31,61,101,...), a ten-sided figure grown ring by ring around a center; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# NudeNumberGate 1 input

Nude-number gate: passes note-ons on nude counts that are divisible by each of their own nonzero digits (1..9,11,12,15,22,24,...), a polydivisible-by-digit set; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitSumSquareGate 1 input

Digit-sum-square gate: passes note-ons whose decimal digit sum is a perfect square (1,4,9,16,...), so counts summing to 1, 4, 9 or 16 pass; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# TrailingZeroGate 1 input

Trailing-zero gate: passes note-ons whose count has exactly the chosen number of trailing binary zeros (its 2-adic valuation), selecting one rung of the ruler sequence - odd counts at 0, doubly-even at higher; Invert keeps the rest.

ParamRangeDefaultUnit
Zeros0 – 81—
Invert0 – 10—

# DoubleFactorialGate 1 input

Double-factorial gate: passes note-ons on double-factorial counts n!! - the product of integers of the same parity down to 1 (1,2,3,8,15,48,105,384,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CenteredNonagonalGate 1 input

Centered-nonagonal gate: passes note-ons on centered-nonagonal counts (1,10,28,55,91,...), a nine-sided figure grown ring by ring around a center, which are also every third triangular number; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# GeneralizedPentagonalGate 1 input

Generalized-pentagonal gate: passes note-ons on generalized-pentagonal counts (1,2,5,7,12,15,22,26,...), the exponents in Euler's pentagonal-number-theorem partition product; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# SquareTriangularGate 1 input

Square-triangular gate: passes note-ons on the rare counts that are simultaneously a perfect square and a triangular number (1,36,1225,41616,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CircularPrimeGate 1 input

Circular-prime gate: passes note-ons on circular-prime counts where every cyclic rotation of the decimal digits is itself prime (2,3,5,7,11,13,17,37,79,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# AdditivePrimeGate 1 input

Additive-prime gate: passes note-ons on additive-prime counts that are prime and whose digit sum is also prime (2,3,5,7,11,23,29,41,43,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# MultiplicativePersistenceGate 1 input

Multiplicative-persistence gate: passes note-ons whose multiplicative persistence - the number of times you replace the count by the product of its digits before hitting a single digit - equals the chosen target; Invert keeps the rest.

ParamRangeDefaultUnit
Steps0 – 62—
Invert0 – 10—

# UndulatingNumberGate 1 input

Undulating-number gate: passes note-ons on counts of 3+ digits that undulate in an alternating ababab pattern with two different digits (121,131,212,232,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DigitProductPrimeGate 1 input

Digit-product-prime gate: passes note-ons where the product of the nonzero decimal digits is prime - exactly one prime digit (2,3,5,7) among ones (2,3,5,7,12,13,15,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PrimeTripletGate 1 input

Prime-triplet gate: passes note-ons on counts belonging to a prime triplet - a prime with two more primes within a span of six (5,7,11,13,17,19,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# PandigitalGate 1 input

Pandigital gate: passes note-ons on 1-to-k pandigital counts whose digits are exactly a permutation of 1..(digit count), using each once with no zeros (1,12,21,123,132,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# AscendingDigitGate 1 input

Ascending-digit gate: passes note-ons whose decimal digits strictly increase from left to right (1..9,12,13,...,123,124,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# DescendingDigitGate 1 input

Descending-digit gate: passes note-ons of 2+ digits whose decimal digits strictly decrease from left to right (10,20,21,30,31,32,...); Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# VelocityFloorGate 1 input

Velocity floor gate: drops note-ons whose velocity falls below a floor, filtering out the quietest notes (off events for dropped notes are removed too to avoid stuck notes); Invert keeps only the quiet ones.

ParamRangeDefaultUnit
Floor1 – 12740—
Invert0 – 10—

Routing

30 modules

# SeqSwitch 5 inputs

Sequential switch: a clock on in0 steps the output through the In A..D signal inputs in turn, wrapping after Steps - route four sources into one in a repeating cycle, or scan CVs into a sequence. Like a rotary switch advanced by a clock instead of by hand.

ParamRangeDefaultUnit
Steps2 – 44—

# Split 1 input

Keyboard split: notes below the split point transpose by Low, the rest by High.

ParamRangeDefaultUnit
Split0 – 12760—
Low-24 – 240st
High-24 – 240st

# Transformer 1 input

Rule: notes within a range are transposed and velocity-scaled.

ParamRangeDefaultUnit
Low0 – 1270—
High0 – 127127—
Transpose-24 – 240st
VelScale0 – 21—

# Merge 2 inputs

Passes both note-stream inputs through, merged into one stream.

# NoteFilter 1 input

Passes only notes inside a key and velocity window.

ParamRangeDefaultUnit
Low Note0 – 1270—
High Note0 – 127127—
Low Vel1 – 1271—
High Vel1 – 127127—

# MidiLatch 1 input

Holds notes after release until the next note arrives.

# Channel 1 input

Reassigns notes to a fixed MIDI channel.

ParamRangeDefaultUnit
Channel1 – 161—

# FixedNote 1 input

Forces every note to a single fixed pitch (drum / trigger).

ParamRangeDefaultUnit
Note0 – 12736—

# KeySwitch 1 input

Splits the keyboard at a note; one zone passes, the other is filtered.

ParamRangeDefaultUnit
Split0 – 12760—
Low ZoneHigh passes · Low passes—

# NoteLimit 1 input

Polyphony cap: never lets more than Max notes sound at once, stealing the oldest (FIFO note-off) when a new note would exceed the limit - tames dense chords and runaway generators.

ParamRangeDefaultUnit
Max1 – 164—

# PolyChan 1 input

Round-robins each new note to the next of Voices MIDI channels from Base, spreading a polyphonic part across a multitimbral rig - one note per channel, the classic voice-allocation split (distinct from MPEConvert's per-note MPE channels).

ParamRangeDefaultUnit
Voices1 – 164—
Base1 – 161—

# Thin 1 input

Note-density limiter: drops any note-on arriving within MinGap ms of the last one passed, decluttering a busy stream or fast repeats - distinct from NoteLimit, which caps simultaneous polyphony. A dropped note's off is dropped too.

ParamRangeDefaultUnit
MinGap1 – 50030ms

# MaxPolyphony 1 input

Max polyphony: caps how many notes may sound at once, dropping any note-on past the limit until a voice frees up - a voice-stealing-free polyphony clamp for thinning dense chords.

ParamRangeDefaultUnit
Voices1 – 324—

# FoldToRange 1 input

Fold to range: shifts every note up or down by whole octaves until it sits inside the [Low,High] window, packing a wide-range part into a fixed register while preserving each note's pitch class.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—

# WrapAround 1 input

Wrap around: notes that rise above the High edge wrap back to the Low end of the range (and vice versa), a modular pitch fold that keeps a part inside a register while letting runs cycle around.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—

# NoteToPitchBend 1 input

Note-to-pitch-bend: emits a pitch-bend proportional to each note's distance from a center pitch, so notes far from the center are pre-bent - a way to map keyboard position onto continuous detune or to drive a synth's bend input from played pitch.

ParamRangeDefaultUnit
Center0 – 12760—
Amount0 – 10.5—

# RandomPanCC 1 input

Random-pan CC: fires a random pan (controller 10) value on every note-on, scattering successive notes across the stereo field for an automatic, ever-shifting spatial spread; Spread sets how wide the scatter.

ParamRangeDefaultUnit
Spread0 – 10.8—

# KeyboardSplit3 1 input

Three-zone split: divides the keyboard at two split points into low, mid and high zones, each transposed by its own amount - a quick way to layer a bassline, a pad and a lead from one part across three regions.

ParamRangeDefaultUnit
Split10 – 12748—
Split20 – 12772—
Low-24 – 24-12st
Mid-24 – 240st
High-24 – 2412st

# ChannelByPitch 1 input

Channel-by-pitch: routes notes to different MIDI channels by register, splitting the keyboard into Zones equal bands so a single part can drive several multitimbral instruments stacked across the range.

ParamRangeDefaultUnit
Zones2 – 164—

# PanByPitch 1 input

Pan by pitch: emits a pan CC (controller 10) that places low notes to the left and high notes to the right, an automatic keyboard-position stereo spread as a synth or sampler plays.

ParamRangeDefaultUnit
Amount0 – 10.7—

# NoteToGateCC 1 input

Note-to-gate CC: emits a chosen controller high while any note is on and low when it releases, turning note events into a gate/trigger control signal for envelopes, side-chains or external gear.

ParamRangeDefaultUnit
CC0 – 12764—

# KeyZoneGate 1 input

Key-zone gate: passes only notes whose pitch sits inside [Low,High] and drops the rest (their note-offs are removed too to avoid stuck notes); Invert keeps only the notes outside the zone.

ParamRangeDefaultUnit
Low0 – 12736—
High0 – 12772—
Invert0 – 10—

# MuteZone 1 input

Mute zone: drops every note whose pitch sits inside [Low,High] while letting the rest of the keyboard through, punching a silent notch into the range.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12760—

# VelocityZoneGate 1 input

Velocity-zone gate: passes only notes whose velocity falls inside [Min,Max] and drops the rest; Invert keeps only the notes outside the velocity window.

ParamRangeDefaultUnit
Min1 – 12740—
Max1 – 127110—
Invert0 – 10—

# NoteRangeTranspose 1 input

Note-range transpose: transposes by Semitones only the notes whose pitch sits inside [Low,High], leaving everything outside the zone at its original pitch.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—
Semitones-48 – 4812—

# SplitTranspose 1 input

Split transpose: a keyboard split where notes at or above the Split point are transposed by Semitones and notes below pass untouched, so two hands play in different registers.

ParamRangeDefaultUnit
Split0 – 12760—
Semitones-48 – 48-12—

# MirrorZone 1 input

Mirror zone: reflects the notes inside [Low,High] around the zone centre (a melodic inversion confined to one key zone), leaving notes outside the zone alone.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—

# ClampToRange 1 input

Clamp to range: pulls every out-of-range note onto the nearest boundary of [Low,High], folding a wide part flat against the edges of a fixed register.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—

# ChannelByZone 1 input

Channel by zone: routes notes below the Split point to channel ChanLo and notes at or above it to ChanHi, splitting one keyboard across two MIDI channels (multitimbral split).

ParamRangeDefaultUnit
Split0 – 12760—
ChanLo1 – 161—
ChanHi1 – 162—

# ZoneOctaveShift 1 input

Zone octave shift: shifts the notes inside [Low,High] by whole Octaves, leaving notes outside the zone where they are, a register jump confined to one key range.

ParamRangeDefaultUnit
Low0 – 12748—
High0 – 12772—
Octaves-4 – 41—

Sequencing

249 modules

# EuclidGate 1 input

Euclidean gate generator: distributes Pulses as evenly as possible across Steps and emits that rhythm, advancing one step on each rising edge of the in0 clock - the maximally-even Euclidean patterns (e.g. 3-in-8 = the tresillo) behind so much generative rhythm. Rotate shifts the pattern's starting point.

ParamRangeDefaultUnit
Pulses1 – 164—
Steps1 – 168—
Rotate0 – 150—

# TrigSeq 1 input

Trigger sequencer: steps through an on/off pattern on each rising edge of the in0 clock, emitting a trigger on the steps you switch on - a compact drum/gate sequencer. Steps sets the loop length, Pattern is the on/off bitmask (0-255 = 8 steps). in0 = Clock.

ParamRangeDefaultUnit
Steps1 – 88—
Pattern0 – 255170—

# Automaton 2 inputs

Elementary cellular-automaton sequencer (a first as a synth block): a 16-cell row of one-bit cells evolves one generation on every rising edge of the in0 clock, each cell's next state set by the 8-bit Rule applied to its left/centre/right neighbours (Wolfram's elementary CA, wrapped). Rule 90 paints a fractal Sierpinski pattern, 30 is chaotic, 110 is Turing-complete. The output is the live cell density (0..1 stepped CV) - a deterministic yet endlessly evolving pattern, unlike the random shift-register of Turing or Marbles. A rising edge on in1 reseeds a single centre cell.

ParamRangeDefaultUnit
Rule0 – 25590—

# Markov 2 inputs

Style-learning sequencer (a first as a synth block): quantises the input at in0 into 4 states and continuously learns the transition probabilities between them (a Markov chain; Memory sets how fast old transitions fade). On each rising edge of the in1 clock it samples the learned transitions from its current state to pick the next, improvising a NEW sequence in the style of what it heard - feed it a melody or CV and it riffs endless variations that obey the same move-to-move statistics. Output is the generated state as a 0..1 stepped CV.

ParamRangeDefaultUnit
Memory0.9 – 10.999—

# GameOfLife 2 inputs

Conway's Game of Life sequencer (a first as a synth block): a 32-cell torus grid (8 wide x 4 tall) evolves one Conway generation on every rising edge of the in0 clock - a live cell with 2 or 3 neighbours survives, a dead cell with exactly 3 is born (the classic B3/S23) - and the output is the live population density as a 0..1 stepped CV. Where the 1-D Automaton runs a row rule, this is full 2-D Life with its gliders, blinkers and still-lifes: the population breathes, oscillates or settles into stable colonies. A rising edge on in1 reseeds the grid; Seed sets the random fill. Genuinely alive modulation.

ParamRangeDefaultUnit
Seed0 – 10.35—

# BrianBrain 2 inputs

Brian's Brain cellular automaton (a first as a synth block): a 4x4 torus grid of three-state cells - ready, firing, dying - evolves on every rising edge of the in0 clock. A ready cell ignites only when exactly two neighbours are firing; a firing cell always passes to dying; a dying cell falls back to ready. Where Conway's Game of Life has two states, this refractory third state keeps structures restless - they almost never settle, throwing off gliders and sparks. Output is the firing-cell density as a 0..1 stepped CV. A rising edge on in1 reseeds; Seed sets the random fill.

ParamRangeDefaultUnit
Seed0 – 10.3—

# Langton 2 inputs

Langton's Ant turmite sequencer (a first as a synth block): a single 'ant' walks an 8x4 torus of cells - turning right on a white cell, left on a black one, flipping each cell it leaves, then stepping forward. From a blank grid it scribbles chaotically for a while, then abruptly locks into a periodic 'highway' - emergent order from one trivial rule. Each rising edge of the in0 clock advances the ant Steps cells; the output is the ant's column position as a 0..1 stepped CV. A rising edge on in1 resets the ant to the centre of a clear grid. Unlike the cellular automata this is a single moving agent, not a population.

ParamRangeDefaultUnit
Steps1 – 161—

# Collatz 2 inputs

Collatz-conjecture sequencer (a first as a synth block): walks the famous 3n+1 trajectory - on each rising edge of the in0 clock the number halves if even or becomes 3n+1 if odd, and the output is its altitude (log2 of the value, 0..1) so you hear the trajectory's jagged climbs and plunges. When it reaches 1 the tour restarts from Start. A rising edge on in1 also restarts. Different Start values give wildly different melodic contours from one deterministic rule.

ParamRangeDefaultUnit
Start1 – 200027—

# ThueMorse 2 inputs

Thue-Morse sequencer (a first as a synth block): outputs the Thue-Morse sequence - the parity of the number of 1-bits in a step counter - as a 0/1 gate that advances on every rising edge of the in0 clock (0,1,1,0,1,0,0,1...). It is the canonical fair-share, cube-free, self-similar binary sequence: never periodic yet never random, full of nested symmetry. Use it as an aperiodic rhythm, a generative on/off mask, or a melodic gate that feels structured but never repeats. A rising edge on in1 resets the counter.

# RudinShapiro 2 inputs

Rudin-Shapiro sequencer (a first as a synth block): outputs the Rudin-Shapiro sequence as a 0/1 gate - high when the number of overlapping '11' pairs in the step counter's binary is even (the +1 term), low when odd. Its defining property is remarkable: it is fully deterministic yet its power spectrum is FLAT, like white noise - the +/-1 sequence whose partial sums stay bounded by sqrt-of-n, the closest a structured pattern gets to acoustically random. A rhythm that sounds scattered and unpredictable but never actually repeats, distinct from the nested symmetry of Thue-Morse. A rising edge on in1 resets the counter.

# Cantor 2 inputs

Cantor-set rhythm gate (a first as a synth block): the step counter is read in base 3 and the output goes high only when NO ternary digit is 1 - exactly the membership rule of the Cantor middle-thirds set. The result is a self-similar fractal on/off pattern: dense clusters of hits separated by silences of every scale, the same gappy structure repeating inside itself at 1/3, 1/9, 1/27... A deeply uneven yet deterministic rhythm with built-in fractal phrasing, unlike the even fair-share of Thue-Morse. A rising edge on in1 resets the counter.

# FibWord 2 inputs

Fibonacci-word sequencer (a first as a synth block): the infinite Fibonacci word over {0,1} grown by the substitution 0 -> 0 1, 1 -> 0 (its own fixed point) - 0,1,0,0,1,0,1,0,0,1,0,0,1... - emitted as a 0/1 gate, one symbol per in0 clock. It is the canonical Sturmian sequence: the 1s fall at the golden-ratio spacing, the quasicrystal of one dimension, balanced so any two windows of equal length hold the same count of 1s to within one. A structured aperiodic gate built on phi, distinct from the self-describing Kolakoski. A rising edge on in1 resets; the first 256 symbols then loop.

# Champernowne 2 inputs

Champernowne-constant sequencer (a first as a synth block): walks the decimal digits of Champernowne's constant 0.123456789101112131415... - simply the counting numbers written out and concatenated - emitting one digit per in0 clock as a 0..1 stepped melody (digit / 9). Because the constant is provably NORMAL, the digit stream eventually contains every finite pattern, every motif, infinitely often: it climbs 1..9 then folds into the rolling two- and three-digit runs of 10,11,12..., a melody that is rigidly deterministic yet endlessly inventive. Distinct from the integer sequences - this plays the digits themselves. A rising edge on in1 resets.

# Pascal 2 inputs

Pascal's-triangle sequencer (a first as a synth block): reads Pascal's triangle row by row - 1; 1,1; 1,2,1; 1,3,3,1... - taking each binomial coefficient modulo Base and emitting it as a 0..1 stepped value, one per in0 clock. Modulo 2 the pattern IS the Sierpinski triangle (Lucas' theorem): a self-similar fractal of 1s and 0s; higher Base reveals the richer nested structure of binomials mod a number. A fractal melody/gate from the most elementary combinatorics, distinct from the cellular-automaton fractals. A rising edge on in1 resets to the top of the triangle.

ParamRangeDefaultUnit
Base2 – 82—

# Prime 2 inputs

Prime-step gate (a first as a synth block): a step counter advances on each rising edge of the in0 clock and the output goes high only when the count is a prime number (2,3,5,7,11,13...). Because primes thin out as they grow, the gate fires densely at first then ever more sparsely and irregularly - a deterministic yet non-repeating rhythm with no built-in period. Use it to trigger events, mask a sequence, or gate an effect on the primes. A rising edge on in1 resets the counter.

# Happy 2 inputs

Happy-number gate (a first as a synth block): a step counter advances on each in0 clock and the output goes high when the count is a happy number - one that reaches 1 when you repeatedly replace it by the sum of the squares of its digits (7 -> 49 -> 97 -> 130 -> 10 -> 1). The unhappy numbers instead fall forever into the cycle 4,16,37,58,89,145,42,20. The happy numbers are scattered with no pattern (1,7,10,13,19,23,28,31,32,44...), so the gate fires on a sparse, irregular, deterministic rhythm distinct from the primes. A rising edge on in1 resets.

# Harshad 2 inputs

Harshad-number gate (a first as a synth block): a step counter advances on each in0 clock and the output goes high when the count is a Harshad (Niven) number - one divisible by the sum of its own digits (18 is, since 1+8=9 divides 18; 19 is not). Harshad numbers are common among small values then thin out gradually, so the gate fires densely at first and slowly sparsens - a denser, more regular cousin of the prime gate, with little runs and gaps tied to the decimal digits. A rising edge on in1 resets.

# Abundant 2 inputs

Abundant-number gate (a first as a synth block): a step counter advances on each in0 clock and the output goes high when the count is an abundant number - one whose proper divisors sum to MORE than itself (12: 1+2+3+4+6 = 16 > 12). These are the 'over-rich' integers, the opposite of the deficient majority, with the perfect numbers sitting exactly on the boundary. Abundant numbers cluster around the highly-composite values, so the gate fires in factor-rich bursts - a number-theoretic rhythm tied to divisor structure, distinct from the digit-based Harshad. A rising edge on in1 resets.

# Lucky 2 inputs

Lucky-number gate (a first as a synth block): the output goes high when the step count is a 'lucky number' (1,3,7,9,13,15,21,25,31...) - survivors of a sieve like the prime sieve but which crosses out by POSITION instead of by value: keep every number, delete every 2nd, then from the survivors delete every 3rd, then every 7th, and so on. Astonishingly the luckies share many statistical traits with the primes (twin luckies, a similar density) despite being built from counting alone, not divisibility. A different deterministic sparse rhythm from the prime gate. A rising edge on in1 resets; the first 256-step phrase then loops.

# DigitSum 2 inputs

Digit-sum sequencer (a first as a synth block): each in0 clock advances the step n and outputs the sum of n's digits in base Base, folded into Steps as a 0..1 melody. As n counts up, the digit sum climbs steadily then drops sharply at every carry (9 -> 10, 99 -> 100), tracing a self-similar sawtooth whose teeth get longer in higher place values - the fingerprint of positional notation itself. Base reshapes the pattern (base 2 gives the popcount/binary-weight contour, base 10 the familiar decimal roll). A digit-structure melody distinct from the value-based recurrences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 1610—
Steps4 – 3212—

# DigitReverse 2 inputs

Digit-reversal sequencer (a first as a synth block): each in0 clock advances the step n and outputs n with its decimal digits written backwards (123 -> 321, 250 -> 52), folded into Steps. The reversal scrambles the steady count into a jagged, self-similar permutation - the ones digit becomes the loudest place, so the melody leaps by big jumps within each block of ten and resets at each new power of ten. A digit-permutation contour distinct from the digit-SUM and the value-based sequences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# DigitProduct 2 inputs

Digit-product sequencer (a first as a synth block): each in0 clock advances the step n and outputs the product of n's decimal digits (24 -> 2*4 = 8, 39 -> 27), folded into Steps. Unlike the steadily-climbing digit SUM, the product swings wildly and collapses to ZERO whenever any digit is 0 (every tenth number, all the hundreds...), punching rhythmic holes into the melody. A multiplicative digit contour with its own jagged, gap-ridden shape distinct from the digit sum and reversal. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# MultRoot 2 inputs

Multiplicative-digital-root sequencer (a first as a synth block): each in0 clock advances the step n and repeatedly replaces it by the product of its digits until a single digit is left - the multiplicative digital root (39 -> 27 -> 14 -> 4). The output is that final digit over 9. Because any number containing a 0 (or that ever reaches one) collapses to 0, the melody is dotted with zeros among the 1..9 values, a sparse fingerprint of the multiplicative structure of each integer. Distinct from the additive digital root, which simply cycles 1..9. A rising edge on in1 resets.

# Kaprekar 2 inputs

Kaprekar-routine sequencer (a first as a synth block): each in0 clock advances the step n and counts how many rounds of Kaprekar's routine its four-digit form takes to reach 6174 - the magic Kaprekar constant. One round sorts the digits up and down and subtracts the smaller from the larger (e.g. 3524 -> 5432 - 2345 = 3087 -> ... -> 6174); EVERY four-digit number with at least two different digits funnels to 6174 in at most seven rounds, while repeated-digit numbers fall to zero. The output is that round count over 7, a strange staircase rising and falling with no obvious pattern. A rising edge on in1 resets.

# Keith 2 inputs

Keith-number gate (a first as a synth block): the output goes high when the step n is a Keith number (14, 19, 28, 47, 61, 75, 197...). To test n, seed a Fibonacci-like sequence with its digits - then each new term is the sum of the previous (digit-count) terms; n is a Keith number if that sequence eventually lands exactly on n. They are far rarer than the primes (only a hundred or so below a trillion), so the gate fires on a very sparse, irregular pulse - a deep, hard-to-find numerical rhythm distinct from the prime, happy and lucky gates. A rising edge on in1 resets.

# Totient 2 inputs

Euler-totient sequencer (a first as a synth block): each rising edge of the in0 clock advances the step n and outputs phi(n)/n - the fraction of integers up to n that share no factor with it. The contour is jagged and number-aware: it sits high near primes (phi(p)/p = 1 - 1/p, almost 1) and plunges at the highly-composite, factor-rich numbers (6, 30, 210...), tracing the multiplicative texture of the integers as a melody. A deterministic line whose ups and downs encode coprimality itself, unlike the additive Stern or the word sequences. A rising edge on in1 resets.

# Mobius 2 inputs

Mobius-function source (a first as a synth block): each rising edge of the in0 clock advances the step n and outputs the Mobius function mu(n) as a three-level CV - high for a squarefree number with an even count of prime factors (+1), centre for a non-squarefree number (0, it has a repeated prime), low for squarefree with an odd count (-1). The squarefree/squareful flicker and the parity swings produce a jittery three-state pattern that encodes the prime-factor structure of each integer. A number-theoretic trit stream found nowhere else in modular gear. A rising edge on in1 resets.

# Liouville 2 inputs

Liouville-function gate (a first as a synth block): each rising edge of the in0 clock advances the step n and the output goes high when lambda(n) = +1, low when -1 - lambda being (-1) raised to the TOTAL number of prime factors of n counted with multiplicity. It is the multiplicative cousin of Thue-Morse (which counts bits, this counts prime factors): a deeply structured, conjecturally-balanced two-level pattern tied to the Riemann hypothesis through its running sum. An aperiodic gate built from the deepest texture of the primes. A rising edge on in1 resets.

# Divisors 2 inputs

Divisor-count sequencer (a first as a synth block): each rising edge of the in0 clock advances the step n and outputs d(n), the number of divisors of n, folded into Steps as a 0..1 melody. Primes drop to the floor (d = 2) while the highly-composite numbers (12, 24, 36, 48, 60...) leap up with many divisors, so the line is a spiky staircase that spotlights the most factor-rich integers - the arithmetic opposite of the Totient dip. A melody driven by raw divisibility, distinct from the additive and word sequences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3212—

# Zeckendorf 2 inputs

Zeckendorf-weight sequencer (a first as a synth block): every positive integer has a UNIQUE representation as a sum of non-consecutive Fibonacci numbers (Zeckendorf's theorem); each rising edge of the in0 clock advances the step n and outputs how many Fibonacci terms that representation needs, folded into Steps. The weight rises and falls as the greedy Fibonacci-base digits shuffle - the 'Fibonacci-base digit sum', a self-similar contour related to the golden ratio and the Fibonacci word. A melody from base-phi numeration, distinct from the decimal Champernowne. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3212—

# Partition 2 inputs

Partition-number sequencer (a first as a synth block): outputs p(n), the number of ways to write n as a sum of positive integers (4 = 4, 3+1, 2+2, 2+1+1, 1+1+1+1 so p(4)=5), taken modulo Base, one per in0 clock. The partition numbers - 1,1,2,3,5,7,11,15,22,30,42... - grow almost as fast as the primes thin out (Hardy-Ramanujan), and are built here by Euler's pentagonal-number recurrence (additions and subtractions only), so mod Base is exact. A melody from the deep additive combinatorics of the integers, distinct from the multiplicative divisor functions. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Sigma 2 inputs

Divisor-sum sequencer (a first as a synth block): each in0 clock advances the step n and outputs sigma(n), the sum of ALL of n's divisors (sigma(6) = 1+2+3+6 = 12), folded into Steps as a 0..1 melody. Where the Totient counts what is coprime to n and Divisors counts how many divisors it has, Sigma adds them all up - so it climbs highest at the abundant, factor-rich numbers and sits low (sigma(p) = p+1) at the primes. The perfect numbers are exactly where sigma(n) = 2n. A melody from the total weight of divisibility, distinct from the other arithmetic functions. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Mertens 2 inputs

Mertens-function source (a first as a synth block): each in0 clock advances the step n and outputs the running sum of the Mobius function, M(n) = mu(1) + mu(2) + ... + mu(n) - a famous slowly-staggering walk that creeps up and down by +/-1 and 0 as squarefree numbers of even and odd prime-count alternate. Whether it stays bounded by sqrt(n) (the disproved Mertens conjecture) is tied to the Riemann hypothesis. The output is centred on 0.5, drifting either side like a number-theoretic Brownian path that is in fact fully deterministic. Distinct from the per-step Mobius block. A rising edge on in1 resets.

# PrimePi 2 inputs

Prime-counting sequencer (a first as a synth block): each in0 clock advances the step n and outputs pi(n), the number of primes less than or equal to n, folded into Steps. Unlike the prime GATE (which only fires on the primes themselves) this plays the running TALLY - a monotone staircase that steps up by one at every prime and holds flat across the composite runs, the function at the heart of the Prime Number Theorem (pi(n) ~ n / ln n). The widening flat steps trace how the primes thin out. A counting melody distinct from the prime gate. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Triangular 2 inputs

Triangular-number gate (a first as a synth block): the output goes high when the step n is a triangular number - one that counts the dots in a filled triangle, 0,1,3,6,10,15,21,28,36,45... (n(n+1)/2). The test is the classic one: n is triangular exactly when 8n+1 is a perfect square. Because the gaps between successive triangular numbers grow by one each time, the gate fires on a steadily-rarefying rhythm - dense at first, then ever-longer silences - a smoothly-decelerating pulse distinct from the irregular prime and happy-number gates. A rising edge on in1 resets.

# Square 2 inputs

Perfect-square gate (a first as a synth block): the output goes high when the step n is a perfect square - 0, 1, 4, 9, 16, 25, 36... The gaps between squares grow by the odd numbers (1, 3, 5, 7...), so the gate fires on a smoothly and quadratically decelerating rhythm: a quick flurry at the start that stretches into ever-longer silences faster than the triangular gate. A perfect-square pulse distinct from the triangular and prime gates. A rising edge on in1 resets.

# Pentagonal 2 inputs

Pentagonal-number gate (a first as a synth block): the output goes high when the step n is a pentagonal number - 1, 5, 12, 22, 35, 51, 70... (k(3k-1)/2), the dots that tile a growing pentagon. These are the very numbers in Euler's pentagonal-number theorem that drive the partition function, and n is one exactly when 24n+1 is a perfect square whose root is one less than a multiple of 6. The gate fires on a decelerating but sparser rhythm than the squares or triangulars. A rising edge on in1 resets.

# Pronic 2 inputs

Pronic-number gate (a first as a synth block): the output goes high when the step n is a pronic (oblong) number - the product of two consecutive integers, 0, 2, 6, 12, 20, 30, 42... (k(k+1)), the count of dots in a rectangle one taller than it is wide, and exactly twice each triangular number. n is pronic when 4n+1 is a perfect square. The gate fires on a decelerating rhythm interleaved exactly halfway between the squares. A rising edge on in1 resets.

# Fibonacci 2 inputs

Fibonacci-number gate (a first as a synth block): the output goes high when the step n is itself a Fibonacci number - 0, 1, 2, 3, 5, 8, 13, 21, 34, 55... Because each Fibonacci number is roughly the golden ratio times the last, the gaps grow GEOMETRICALLY, so the gate fires fast and densely at first then thins out exponentially - a self-similar, golden-spaced rhythm quite unlike the polynomial slow-down of the square and triangular gates. The test is Gessel's: n is Fibonacci exactly when 5n^2+4 or 5n^2-4 is a perfect square. A rising edge on in1 resets.

# Power2 2 inputs

Power-of-two gate (a first as a synth block): the output goes high only when the step n is an exact power of two - 1, 2, 4, 8, 16, 32, 64... Each gap is double the last, so the gate fires on the sparsest possible self-similar rhythm: it hits, waits twice as long, hits, waits twice as long again, forever halving in density. The test is the classic bit trick (n AND n-1) == 0. The most extreme decelerando of the number gates, ideal for octave-spaced accents and bar-doubling structure. A rising edge on in1 resets.

# Beatty 2 inputs

Golden-ratio (Beatty) rhythm gate (a first as a synth block): fires high when the clock step lands on floor(n * Ratio) for n = 1, 2, 3... With Ratio at the golden mean (~1.618) the hits fall on 1, 3, 4, 6, 8, 9... - a quasi-periodic pattern that never settles into a loop, the irrational cousin of the Euclidean rhythm. By Beatty's theorem two such sequences with complementary ratios partition every beat exactly once. Use it for organic, non-repeating grooves. A rising edge on in1 resets.

ParamRangeDefaultUnit
Ratio1.05 – 41.618—

# GrayCode 2 inputs

Gray-code sequencer (a first as a synth block): advances a counter on each rising edge of the in0 clock and outputs its reflected binary Gray code (n XOR n>>1), folded into 16 steps - so successive values always differ by exactly one bit. The result is a stepped CV that walks 0, 1, 3, 2, 6, 7, 5, 4... visiting levels in an order where every move is a single minimal change, giving smooth one-step contours that still tour the whole range without repeating until the cycle completes. A rising edge on in1 resets.

# VanDerCorput 2 inputs

Van der Corput low-discrepancy sequencer (a first as a synth block): outputs the radical-inverse sequence - reverse the bits of the step counter and read them as a fraction - so each new value lands in the largest remaining gap (0.5, 0.25, 0.75, 0.125, 0.625...). The result spreads evenly across the range yet never repeats a spacing, the quasi-random-but-balanced pattern used in quasi-Monte-Carlo sampling. Advance on the in0 clock; a rising edge on in1 resets. A more even, less clumpy alternative to a random source.

# DeBruijn 2 inputs

De Bruijn sequence gate (a first as a synth block): plays a cyclic binary sequence in which every possible 5-bit pattern appears exactly once before the 32-step cycle repeats - the shortest sequence that tours all sub-patterns. Advancing on the in0 clock it fires a dense, structured, maximally-varied rhythm that never presents the same five-step window twice within a bar. Where Euclid spreads pulses evenly and ThueMorse is self-similar, the de Bruijn cycle is exhaustive. A rising edge on in1 resets to the start.

# Pisano 2 inputs

Fibonacci-modulo sequencer (a first as a synth block): runs the Fibonacci recurrence modulo M, so the output is (..0,1,1,2,3,5,8,13..) wrapped into M levels - a melodic loop whose length is the Pisano period of M (often surprisingly long and lopsided). Advance on the in0 clock; Modulus sets the wrap and therefore the loop length and contour. Deterministic and exactly repeating yet rarely an obvious cycle - the additive cousin of the multiplicative sequencers. A rising edge on in1 resets to 0,1.

ParamRangeDefaultUnit
Modulus2 – 328—

# Wireworld 2 inputs

Wireworld cellular automaton (a first as a synth block): a 4x4 grid of cells in four states - empty, electron head, electron tail, conductor - evolves on each rising edge of the in0 clock. A head becomes a tail, a tail becomes a conductor, and a conductor becomes a head only if exactly one or two neighbours are heads, so electrons stream along the conductor wires like current in a circuit. The output is the electron-head density as a stepped CV - sparks chasing each other around closed loops. Seed sets the initial spark density; a rising edge on in1 reseeds.

ParamRangeDefaultUnit
Seed0 – 10.2—

# TentMap 2 inputs

Tent-map chaos sequencer (a first as a synth block): iterates x' = R * min(x, 1-x), the simplest piecewise-linear chaotic map - a symmetric tent that stretches and folds the unit interval. At R near 2 it is fully chaotic, producing a stepped CV that never repeats yet stays evenly spread across the range (unlike the lopsided logistic Chaos). Each rising edge of the in0 clock takes one iteration; R below 2 tames it toward order. A rising edge on in1 reseeds. The angular, uniform cousin of the smooth attractors.

ParamRangeDefaultUnit
R1 – 21.99—

# Sandpile 2 inputs

Abelian sandpile (a first as a synth block): drops a grain on the centre of a 4x4 pile each clock; when any cell reaches four grains it topples, sending one to each neighbour and possibly starting a chain reaction off the open edges. The output is the avalanche size - how many topplings that grain triggered - which is silent most of the time then spikes, following the power-law statistics of self-organised criticality. Most hits do nothing; occasionally one grain unleashes a cascade. A model of avalanches, forest fires and earthquakes as a rhythmic CV. A rising edge on in1 clears the pile.

# Dragon 2 inputs

Dragon-curve (paperfolding) sequencer (a first as a synth block): outputs the regular paperfolding sequence - the fold directions of the famous dragon-curve fractal - as a 0/1 gate that advances on the in0 clock (1,1,0,1,1,0,0,1...). Strip the trailing zeros from the step counter and the next bit decides the turn, giving a sequence that is perfectly self-similar (it contains scaled copies of itself) yet never periodic. Between Euclid's even spread and ThueMorse's parity, the dragon fold is the fractal one. A rising edge on in1 resets.

# Ikeda 2 inputs

Ikeda-map chaos sequencer (a first as a synth block): iterates the Ikeda map - a model of light circulating in a nonlinear optical cavity - whose state rotates by an angle that itself depends on the state, folding the plane into an intricate strange attractor. On each rising edge of the in0 clock it advances one step and outputs the x coordinate as a stepped CV that hops chaotically around the attractor's hooked arms. U sets how deep into chaos it runs. A different flavour again from the angular Henon, smooth Rossler or tumbling pendulum. A rising edge on in1 reseeds.

ParamRangeDefaultUnit
U0.7 – 0.920.9—

# CyclicCA 2 inputs

Cyclic cellular automaton (a first as a synth block): every cell holds one of N colours arranged in a cycle, and a cell advances to the next colour if at least Threshold neighbours already wear it - rock beats scissors beats paper beats rock. From noise it self-organises into rotating spiral waves that endlessly consume one another. Each rising edge of the in0 clock steps one generation; the output is the grid's mean colour as a smoothly cycling CV. A demolition-derby of colours quite unlike the Game-of-Life family. A rising edge on in1 reseeds.

ParamRangeDefaultUnit
States3 – 64—
Threshold1 – 31—

# BakSneppen 2 inputs

Bak-Sneppen evolution source (a first as a synth block): sixteen species sit in a ring, each with a random fitness; every clock the least-fit species - and its two neighbours - are wiped out and replaced with new random fitnesses. Driving out the weakest drags the whole ecosystem upward in fits and starts: long calm stretches of slow improvement shattered by sudden cascades of extinction, the punctuated equilibrium of self-organised criticality. The output is the current minimum fitness, climbing toward a critical threshold then collapsing. A rising edge on in1 reseeds.

# Stern 2 inputs

Stern diatomic sequencer (a first as a synth block): outputs Stern's diatomic sequence (the fusc function) - 0,1,1,2,1,3,2,3,1,4,3,5... - in which consecutive pairs enumerate every positive rational number exactly once, the arithmetic behind the Stern-Brocot tree. Each rising edge of the in0 clock advances one term, folded into 16 steps; the contour rises and falls in a self-similar fractal staircase that never repeats. A deterministic, number-theoretic melody distinct from the Fibonacci-based Pisano. A rising edge on in1 resets.

# Tribonacci 2 inputs

Tribonacci-word sequencer (a first as a synth block): the three-symbol cousin of the Fibonacci word, grown by the substitution a -> a b, b -> a c, c -> a (its own fixed point) and emitted as a three-level CV (0, 0.5, 1), one symbol per in0 clock. Where the Fibonacci word is built on the golden ratio, this is built on the tribonacci constant ~1.839 - a balanced, aperiodic THREE-state pattern that never repeats and tiles the line like a 1-D quasicrystal. A richer alphabet than the binary words, distinct from the Fibonacci word and Kolakoski. A rising edge on in1 resets; the first 256 symbols then loop.

# Padovan 2 inputs

Padovan-sequence sequencer (a first as a synth block): the plastic-number analogue of Fibonacci - P(n) = P(n-2) + P(n-3), giving 1,1,1,2,2,3,4,5,7,9,12,16,21... - whose ratio of successive terms tends to the plastic number ~1.3247 instead of the golden ratio. Each rising edge of the in0 clock advances one term, taken modulo Steps so it stays in range. Its slower, gentler growth makes a melody that climbs more lazily than Fibonacci, distinct from the Pisano (Fibonacci mod m) and Perrin recurrences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Perrin 2 inputs

Perrin-sequence sequencer (a first as a synth block): the recurrence P(n) = P(n-2) + P(n-3) seeded 3,0,2 - giving 3,0,2,3,2,5,5,7,10,12,17,22,29... - famous for the Perrin pseudoprime test (n divides P(n) almost exactly when n is prime). Each rising edge of the in0 clock advances one term, taken modulo Steps. It shares Padovan's plastic-number growth but a different opening, so its melody starts on a falling figure (3,0,2) before climbing - a distinct number-theoretic line from Padovan or the Fibonacci-based Pisano. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Bell 2 inputs

Bell-number sequencer (a first as a synth block): outputs the Bell numbers - 1,1,2,5,15,52,203,877... - the count of ways to partition a set of n elements, taken modulo Base, one per in0 clock. They are built here by Aitken's array (pure additions, the analogue of Pascal's triangle for set partitions), so taking them mod Base is exact. The values explode combinatorially, so mod Base they scramble into a busy, evenly-spread pattern - a melody from the deep counting numbers of combinatorics, distinct from the additive recurrences. A rising edge on in1 resets to the top.

ParamRangeDefaultUnit
Base2 – 127—

# GoldenAngle 2 inputs

Golden-angle (phyllotaxis) sequencer (a first as a synth block): each in0 clock adds the golden ratio's fractional part (~0.618) to a running position wrapped into 0..1 - the additive recurrence that places sunflower seeds and pinecone scales at the 137.5-degree golden angle, the most irrational rotation there is. The result is a maximally even, low-discrepancy melody: successive notes land as far from all previous notes as possible, filling the range without ever repeating or clustering. The optimal spread, distinct from the bit-reversal Van der Corput. A rising edge on in1 resets to the start.

# Jacobsthal 2 inputs

Jacobsthal-sequence sequencer (a first as a synth block): the recurrence J(n) = J(n-1) + 2*J(n-2) - giving 0,1,1,3,5,11,21,43,85,171... - a Fibonacci cousin whose doubled second term makes successive ratios tend to 2 instead of the golden ratio. Each rising edge of the in0 clock advances one term, taken modulo Steps. Its faster, near-doubling growth gives a melody that leaps up the scale more aggressively than Fibonacci, a distinct integer-recurrence line from the Pisano, Padovan and Pell sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Pell 2 inputs

Pell-sequence sequencer (a first as a synth block): the recurrence P(n) = 2*P(n-1) + P(n-2) - giving 0,1,2,5,12,29,70,169,408... - whose ratios converge on the SILVER ratio (1 + sqrt2 ~ 2.414), the silver-mean analogue of Fibonacci's golden. The Pell numbers also give the best rational approximations to sqrt2 (the side-and-diagonal numbers). Each rising edge of the in0 clock advances one term, taken modulo Steps - a faster-climbing, silver-ratio melody distinct from the golden Fibonacci/Pisano and the plastic Padovan. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Narayana 2 inputs

Narayana's-cows sequencer (a first as a synth block): the 14th-century recurrence N(n) = N(n-1) + N(n-3) - giving 1,1,1,2,3,4,6,9,13,19,28... - from the Indian problem of how a herd grows if each cow bears a calf every year from its fourth year on. Its ratios converge on the SUPERGOLDEN ratio (~1.4656). Each rising edge of the in0 clock advances one term, taken modulo Steps. Its three-step memory gives a gentler, more loping climb than Fibonacci, distinct from the Padovan (N(n-2)+N(n-3)) it is often confused with. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Catalan 2 inputs

Catalan-number sequencer (a first as a synth block): outputs the Catalan numbers - 1,1,2,5,14,42,132,429,1430... - taken modulo Base, one per in0 clock. They count an astonishing range of things (the ways to balance n pairs of brackets, to triangulate a polygon, the paths that never cross the diagonal) and are built here by the convolution C(n) = sum C(i)C(n-1-i), so taking them mod Base is exact. They explode faster than 2^n, so mod Base they scramble into a busy pattern - a melody from the most ubiquitous numbers in combinatorics, distinct from the Bell and Motzkin counts. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Motzkin 2 inputs

Motzkin-number sequencer (a first as a synth block): outputs the Motzkin numbers - 1,1,2,4,9,21,51,127,323... - taken modulo Base, one per in0 clock. They count the ways to draw non-crossing chords between points on a circle (the chords-and-non-edges cousin of the bracket-counting Catalan), and are built here by the convolution M(n) = M(n-1) + sum M(i)M(n-2-i), so mod Base is exact. A combinatorial melody with its own growth rate (~3^n), distinct from the Catalan and Bell counts. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Ruler 2 inputs

Ruler-sequence sequencer (a first as a synth block): outputs the 2-adic valuation of the step n - the number of times 2 divides it, equivalently the count of trailing zeros in its binary - folded into Steps, one per in0 clock. The result is exactly the tick pattern on a ruler: 0,1,0,2,0,1,0,3,0,1,0,2... where every other mark is short, every fourth is taller, every eighth taller still, forever self-similar. A perfectly nested fractal staircase that drives rhythmic accents and melodic emphasis, distinct from the digit-sum and popcount contours. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Popcount 2 inputs

Popcount sequencer (a first as a synth block): outputs the Hamming weight of the step n - the number of 1-bits in its binary representation - folded into Steps, one per in0 clock. As n counts up the bit-count rises and falls in a self-similar fractal pattern (0,1,1,2,1,2,2,3...), climbing on dense numbers and dropping to 1 at every power of two. Where Thue-Morse keeps only the PARITY of this count, Popcount plays the full value - a binary-weight melody distinct from the digit-sum and ruler contours. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Gould 2 inputs

Gould-sequence sequencer (a first as a synth block): outputs Gould's sequence - 2 raised to the number of 1-bits of the step n - folded into Steps, one per in0 clock. By Kummer's theorem this is exactly the count of ODD entries in row n of Pascal's triangle, so plotting it draws the Sierpinski-triangle skyline: it leaps to a new power of two on the dense numbers and collapses to 1 at the powers of two. A doubling, self-similar contour distinct from the plain popcount it is built on. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# BaumSweet 2 inputs

Baum-Sweet gate (a first as a synth block): the output goes high when the step n is a Baum-Sweet number - one whose binary representation contains NO block of consecutive 0s of odd length (n = 0 counts as high by convention). It is one of the classic automatic sequences (computable by a tiny finite automaton reading n's bits) yet its pattern of 1s and 0s looks irregular and unpredictable - 1,1,0,1,1,0,0,1,0,1... A deterministic, self-similar gate built purely from the shape of the zero-runs in binary, distinct from the bit-COUNT sequences. A rising edge on in1 resets.

# Fibbinary 2 inputs

Fibbinary gate (a first as a synth block): the output goes high when the step n is a fibbinary number - one whose binary representation has NO two adjacent 1-bits (0,1,2,4,5,8,9,10,16...). These are exactly the numbers expressible as a sum of non-consecutive powers of two, the base-2 mirror of Zeckendorf's non-consecutive Fibonacci sums. The gate fires in a sparse, self-similar pattern whose density follows the golden ratio, distinct from the prime and happy-number gates. A rising edge on in1 resets.

# Recaman 2 inputs

Recaman's-sequence sequencer (a first as a synth block): walks the famous OEIS A005132 path a(n) = a(n-1) - n when that step lands on a positive integer not already visited, else a(n-1) + n - the jump-back-or-leap-forward self-avoiding walk that is renowned for sounding musical (the Numberphile melody). Each rising edge of the in0 clock advances one term, folded into Steps to keep it in range; the contour darts down and springs up with none of the symmetry of a periodic pattern. Distinct from the monotone hailstone of Collatz. A rising edge on in1 resets to the 256-term phrase start.

ParamRangeDefaultUnit
Steps4 – 3216—

# Kolakoski 2 inputs

Kolakoski self-describing sequencer (a first as a synth block): the unique sequence over {1,2} that is its OWN run-length encoding - 1,2,2,1,1,2,1,2,2,1,2,2... - so reading off the lengths of its own runs reproduces it exactly. Each rising edge of the in0 clock emits the next symbol as a two-level CV (1 low, 2 high): a quasi-periodic gate pattern that never settles into a loop and has no underlying period, aperiodic yet fully deterministic. A rhythmic counterpart to the number-theoretic pitch sequences. A rising edge on in1 resets; the first 256 symbols are generated, then the phrase repeats.

# Hofstadter 2 inputs

Hofstadter Q-sequence source (a first as a synth block): the chaotic meta-Fibonacci recurrence Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2)) with Q(1)=Q(2)=1 - but where Fibonacci looks a fixed distance back, this looks back by its OWN recent values, so it never settles and wanders erratically around n/2. Each rising edge of the in0 clock advances one term; the output is Q(n)/n, a turbulent drift hovering near 0.5 with unpredictable excursions - deterministic chaos from pure integer recursion, distinct from the smooth Fibonacci-period Pisano. A rising edge on in1 resets; the first 512 terms then loop.

# HofstadterG 2 inputs

Hofstadter G-sequence sequencer (a first as a synth block): the self-referential recurrence G(n) = n - G(G(n-1)) with G(0)=0, which folds the integers down by feeding the sequence's own output back into itself TWICE. Despite the tangled recursion it grows smoothly at the golden-ratio rate (G(n) is almost exactly floor(n/phi)), so it makes a gently-climbing staircase with an occasional flat step where the recursion catches up. Each in0 clock advances one term, folded into Steps. A self-referential melody distinct from the chaotic Q-sequence. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# HofstadterH 2 inputs

Hofstadter H-sequence sequencer (a first as a synth block): the recurrence H(n) = n - H(H(H(n-1))) with H(0)=0 - the same self-referential idea as the G-sequence but nesting the sequence inside itself THREE deep, so it grows at the 'plastic number' rate (~n times 0.6823) rather than the golden ratio. The result is a smoothly-climbing staircase that rises a touch slower than G, with its own pattern of flat treads. Each in0 clock advances one term, folded into Steps. A deeper self-recursion distinct from the G-sequence. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Conway 2 inputs

Conway-Hofstadter sequencer (a first as a synth block): the recurrence a(n) = a(a(n-1)) + a(n - a(n-1)) with a(1)=a(2)=1 - Conway's '$10000 sequence', so named for the prize he offered to anyone who could tame its wild early behaviour. The output is a(n)/n, which lurches chaotically near the start, swinging widely above and below 0.5, then (as Mallows proved) gradually settles toward exactly 0.5 - a turbulence that calms as it goes. Each in0 clock advances one term. A famous self-referential drift distinct from the Hofstadter Q-sequence. A rising edge on in1 resets; the first 512 terms then loop.

# Golomb 2 inputs

Golomb self-describing sequencer (a first as a synth block): outputs Golomb's sequence - 1,2,2,3,3,4,4,4,5,5,5... - the unique non-decreasing sequence that DESCRIBES ITSELF: the number n appears in it exactly a(n) times (1 appears once, 2 appears twice, 3 appears three times, and so on). It climbs in ever-longer plateaus whose lengths are given by the sequence's own earlier values. Each in0 clock advances one term, folded into Steps, giving a gently-rising staircase of stretching steps. A self-describing melody distinct from the self-referential Hofstadter recurrences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# FemaleMale 2 inputs

Hofstadter Female-Male sequencer (a first as a synth block): outputs the 'Female' half of Hofstadter's famous pair of INTERTWINED sequences, F(n) = n - M(F(n-1)) and M(n) = n - F(M(n-1)) - two sequences each defined in terms of the OTHER, an elegant mutual recursion. F grows smoothly (close to the golden-ratio staircase) while leaning on M at every step. Each in0 clock advances one term, folded into Steps. A mutually-recursive melody distinct from the single self-referential Hofstadter sequences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Tetranacci 2 inputs

Tetranacci sequencer (a first as a synth block): the four-step Fibonacci, T(n) = T(n-1) + T(n-2) + T(n-3) + T(n-4) - 0,0,0,1,1,2,4,8,15,29,56... - each term the sum of the FOUR before it instead of two, so its ratio of successive terms climbs toward ~1.9276 rather than the golden 1.618. Each in0 clock advances one term, taken modulo Steps. Its faster four-term growth gives a melody that accelerates up the scale more steeply than Fibonacci or Tribonacci. A higher-order recurrence distinct from the Pisano and Padovan sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Lucas 2 inputs

Lucas-number sequencer (a first as a synth block): the companion of the Fibonacci sequence - same add-the-last-two rule but seeded 2, 1 instead of 0, 1, giving 2,1,3,4,7,11,18,29,47,76... Its ratios converge on the very same golden ratio, so it shares Fibonacci's growth while landing on different values (the Lucas numbers turn up in primality testing and the closed form for Fibonacci itself). Each in0 clock advances one term, taken modulo Steps - a golden-growth melody with its own distinct contour. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Schroeder 2 inputs

Schroeder-number sequencer (a first as a synth block): outputs the large Schroeder numbers - 1,2,6,22,90,394,1806... - which count the lattice paths from one corner of a grid to the opposite one using east, north and diagonal steps that never cross the diagonal (and a dozen other things in combinatorics). They are built here by the convolution S(n) = S(n-1) + sum S(k)S(n-1-k), so taking them modulo Base is exact. Growing faster than 5^n, mod Base they scramble into a busy pattern. A lattice-path melody distinct from the Catalan and Motzkin counts. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Delannoy 2 inputs

Delannoy-number sequencer (a first as a synth block): outputs the central Delannoy numbers - 1,3,13,63,321,1683... - which count the paths a KING takes across a chessboard from one corner to the other, moving only right, up or diagonally. They are built here by the lattice recurrence D(i,j) = D(i-1,j) + D(i,j-1) + D(i-1,j-1) read down the diagonal, so taking them modulo Base is exact (pure additions). A king-path melody from two-dimensional lattice combinatorics, distinct from the one-dimensional recurrences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# CentralBinomial 2 inputs

Central-binomial sequencer (a first as a synth block): outputs the central binomial coefficients C(2n, n) - 1,2,6,20,70,252,924... - the biggest number in each EVEN row of Pascal's triangle (the count of equal-length up/down paths, the heart of the random walk). They are built here straight from Pascal's additive triangle, so modulo Base is exact, and they grow like 4^n so mod Base they scramble busily. The combinatorial spine of Pascal's triangle as a melody, distinct from the Catalan numbers that are derived from them. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Stirling2 2 inputs

Stirling-second-kind sequencer (a first as a synth block): reads Stirling's triangle of the SECOND kind row by row - S(n,k), the number of ways to split n objects into exactly k non-empty groups (1; 1,1; 1,3,1; 1,7,6,1...) - taken modulo Base. Built by the recurrence S(n,k) = S(n-1,k-1) + k*S(n-1,k), so mod Base is exact. Each row sums to a Bell number, so this is the partition-counting triangle behind the Bell sequence. A set-partition triangle melody distinct from the Pascal and Catalan triangles. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Stirling1 2 inputs

Stirling-first-kind sequencer (a first as a synth block): reads the UNSIGNED Stirling triangle of the FIRST kind row by row - the number of permutations of n items having exactly k disjoint cycles (1; 1,1; 2,3,1; 6,11,6,1...) - modulo Base. Built by S(n,k) = S(n-1,k-1) + (n-1)*S(n-1,k), so mod Base is exact. Where the second kind counts set partitions, the first kind counts permutation cycles, and each row sums to a factorial. A cycle-counting triangle melody distinct from the second-kind and Pascal triangles. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Eulerian 2 inputs

Eulerian-number sequencer (a first as a synth block): reads the triangle of Eulerian numbers row by row - A(n,k), the number of permutations of n items with exactly k ascents (1; 1,1; 1,4,1; 1,11,11,1; 1,26,66,26,1...) - modulo Base. Built by A(n,k) = (k+1)*A(n-1,k) + (n-k)*A(n-1,k-1), so mod Base is exact. The rows are symmetric and sum to a factorial, and they are the coefficients that connect powers to binomial sums. A permutation-ascent triangle melody distinct from the Stirling and Pascal triangles. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Lah 2 inputs

Lah-number sequencer (a first as a synth block): reads the triangle of unsigned Lah numbers row by row - L(n,k), the number of ways to partition n items into k non-empty ORDERED lists (1; 2,1; 6,6,1; 24,36,12,1...) - modulo Base. Built by L(n,k) = (n+k-1)*L(n-1,k) + L(n-1,k-1), so mod Base is exact. The Lah numbers are the 'Stirling numbers of the third kind' that convert rising factorials into falling ones. An ordered-partition triangle melody distinct from the two Stirling triangles. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# Ballot 2 inputs

Ballot-triangle sequencer (a first as a synth block): reads Catalan's ballot triangle row by row - the number of ways a count can stay ahead in an election where each entry is the sum of the one to its left and the one above (1; 1,1; 1,2,2; 1,3,5,5; 1,4,9,14,14...) - modulo Base. Built by C(n,k) = C(n,k-1) + C(n-1,k), so mod Base is exact, and its right edge IS the Catalan numbers. The combinatorics of never-falling-behind paths as a melody, distinct from the Pascal and Stirling triangles. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 127—

# PrimeOmega 2 inputs

Prime-factor-count sequencer (a first as a synth block): each in0 clock advances the step n and outputs big-Omega(n) - the number of prime factors of n counted WITH multiplicity (so 12 = 2*2*3 gives 3) - folded into Steps. It rises to a local peak at the powers and products of small primes and drops to 1 at every prime, climbing on average like log-log n. The total weight of a number's prime factorisation as a melody, distinct from the parity-only Liouville and the divisor-counting Divisors. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3212—

# SmallOmega 2 inputs

Distinct-prime-factor sequencer (a first as a synth block): each in0 clock advances the step n and outputs little-omega(n) - the number of DISTINCT prime factors of n (so 12 = 2*2*3 gives just 2, since only 2 and 3 are distinct) - folded into Steps. It stays at 1 across all the prime powers and rises only when a number draws in a NEW prime, so it climbs very slowly and spotlights the squarefree, many-prime numbers. The count of distinct primes as a melody, distinct from the with-multiplicity PrimeOmega. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3212—

# Radical 2 inputs

Radical sequencer (a first as a synth block): each in0 clock advances the step n and outputs the RADICAL of n - the product of its distinct prime factors, with all repeats stripped out (so 12 = 2*2*3 has radical 2*3 = 6, and 8 = 2*2*2 has radical just 2) - folded into Steps. The radical equals n itself for the squarefree numbers and drops far below it for the prime-power-heavy ones, so the melody dips sharply at every perfect power. The squarefree kernel of a number as a melody, central to the abc conjecture, distinct from the additive divisor functions. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Jordan 2 inputs

Jordan-totient sequencer (a first as a synth block): each in0 clock advances the step n and outputs J2(n)/n^2, where J2 is Jordan's totient - a generalisation of Euler's totient that counts pairs coprime to n rather than single numbers, given by n^2 times the product of (1 - 1/p^2) over the primes p dividing n. The output rides high (near 1) at the primes and dips at the factor-rich numbers, a SHARPER version of the totient curve because each prime cuts by 1/p^2. A second-order coprimality melody distinct from the ordinary Totient. A rising edge on in1 resets.

# Dedekind 2 inputs

Dedekind-psi sequencer (a first as a synth block): each in0 clock advances the step n and outputs psi(n)/n - 1, where psi is the Dedekind psi function, n times the product of (1 + 1/p) over the primes p dividing n (the count of points on a certain modular curve). It is the mirror image of the totient: where the totient REMOVES a fraction for each prime, psi ADDS one, so the output sits near zero at the primes and rises at the factor-rich numbers - the inverse contour of the Jordan and Totient curves. A multiplicative-growth melody distinct from the totient-family dips. A rising edge on in1 resets.

# CollatzSteps 2 inputs

Collatz-stopping-time sequencer (a first as a synth block): each in0 clock advances the step n and outputs how many steps n takes to reach 1 under the Collatz rule (halve it if even, triple-plus-one if odd) - the total stopping time, folded into Steps. Whether EVERY number reaches 1 is the famous unsolved Collatz conjecture; the step counts jump around wildly with no pattern (n=27 takes 111 steps). Where the Collatz block plays the trajectory itself, this plays its LENGTH - a chaotic-looking melody from an unproven theorem. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# CollatzPeak 2 inputs

Collatz-peak sequencer (a first as a synth block): each in0 clock advances the step n and outputs the HIGHEST value the Collatz trajectory of n ever climbs to before falling to 1, folded into Steps. Some starting numbers shoot up to enormous heights before collapsing (27 soars past 9000 on its way down), and the peak heights leap about unpredictably from one n to the next. Where CollatzSteps counts the journey's LENGTH, this measures its greatest ALTITUDE - a different chaotic contour from the same famous iteration. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# LookSay 2 inputs

Look-and-say sequencer (a first as a synth block): each in0 clock advances one term of Conway's look-and-say sequence - 1, 11, 21, 1211, 111221, 312211... - where each term is read aloud to make the next ('one 1' -> 11, 'two 1s' -> 21, 'one 2 one 1' -> 1211). The output is the LENGTH of each term, folded into Steps; those lengths grow by Conway's constant (~1.303685) each step, so the melody climbs in a fixed geometric ratio - an 'audioactive' sequence whose only digits are ever 1, 2 and 3. A self-describing melody distinct from the Kolakoski self-description. A rising edge on in1 resets; the first 16 terms then loop.

ParamRangeDefaultUnit
Steps4 – 3216—

# Persistence 2 inputs

Multiplicative-persistence sequencer (a first as a synth block): each in0 clock advances the step n and outputs its multiplicative persistence - how many times you must replace the number by the product of its digits before reaching a single digit (39 -> 27 -> 14 -> 4 takes three steps, so its persistence is 3). Astonishingly, no number below 10^233 is known to need more than 11 steps, an unexplained ceiling. Most numbers collapse in one or two steps, so the output is a low, spiky pattern that occasionally jumps. The DEPTH of digit-product collapse, distinct from the MultRoot block that plays its endpoint. A rising edge on in1 resets.

# Aliquot 2 inputs

Aliquot-sequence sequencer (a first as a synth block): each in0 clock advances the step n and outputs how many steps its aliquot sequence runs before it terminates - the sequence where each term is the sum of the PROPER divisors of the last (12 -> 16 -> 15 -> 9 -> 4 -> 3 -> 1). Most chains fall to 1, but the PERFECT numbers (6, 28...) are fixed points that never move, the AMICABLE pairs cycle forever, and some chains climb without any known end - one of number theory's great open questions. The output is the chain length (capped), spiking at the perfect and untouchable numbers. A divisor-iteration melody distinct from the single-step Sigma. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Palindrome 2 inputs

Palindrome gate (a first as a synth block): the output goes high when the step n reads the same backwards as forwards in decimal (1, 2, ..., 9, 11, 22, ..., 99, 101, 111, 121...). The palindromes thin out in a self-similar way - dense among the small numbers, then clustering near each new power of ten - so the gate fires in rhythmic bursts that stretch apart as the count climbs. A mirror-symmetry digit rhythm distinct from the divisibility and prime gates. A rising edge on in1 resets.

# Automorphic 2 inputs

Automorphic-number gate (a first as a synth block): the output goes high when the step n is automorphic - its SQUARE ends in n itself (5 squared is 25, 6 squared is 36, 25 squared is 625, 76 squared is 5776...). These 'curious' self-reproducing numbers are extraordinarily rare - only a handful below each power of ten - so the gate fires on a very sparse, irregular pulse. A self-squaring digit rhythm distinct from the figurate and prime gates. A rising edge on in1 resets.

# Smith 2 inputs

Smith-number gate (a first as a synth block): the output goes high when the step n is a Smith number - a composite whose digits sum to the SAME total as the digits of all its prime factors added up (4 = 2*2 has digit sum 4 and factor-digit sum 2+2 = 4; 22 = 2*11 gives 4 and 2+1+1 = 4). Named after a phone number that turned out to have this property, they are scattered irregularly among the integers, so the gate fires on a sparse, unpredictable rhythm tied to the deep link between a number's digits and its factorisation. A rising edge on in1 resets.

# Repdigit 2 inputs

Repdigit gate (a first as a synth block): the output goes high when every digit of the step n is the SAME (1, 2, ..., 9, 11, 22, ..., 99, 111, 222, ..., 1111...). These monodigit numbers (the repunits 1, 11, 111... among them) are extremely sparse - only nine in each block of digit-length - so the gate fires in tight little clusters of nine right after each power of ten, then falls silent for a long stretch. The most regular of the rare digit gates, distinct from the palindrome and prime gates. A rising edge on in1 resets.

# Undulating 2 inputs

Undulating-number gate (a first as a synth block): the output goes high when the step n has digits that strictly ALTERNATE between two different values in an a-b-a-b-a pattern (101, 121, 131..., 212, 232..., 12121...). These wavy numbers ripple back and forth between two digits, and they are sparse and clustered, so the gate fires in little flurries near each band of three-, then four-, then five-digit numbers. A zig-zag digit rhythm distinct from the palindrome and repdigit gates. A rising edge on in1 resets.

# Euler 2 inputs

Euler zigzag sequencer (a first as a synth block): steps through the up-down (alternating-permutation) numbers 1, 1, 1, 2, 5, 16, 61, 272, 1385... that count the ways to arrange 1..n so the values go up, down, up, down. Built from the boustrophedon triangle that snakes left-then-right across each row, it is the combinatorial heart shared by the tangent and secant functions. The term is folded modulo Base into a stepped pitch, giving a fast-accelerating melodic climb distinct from the factorial Pisano and Catalan sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Tangent 2 inputs

Tangent-number sequencer (a first as a synth block): steps through the odd-indexed zigzag numbers 1, 2, 16, 272, 7936, 353792... that appear as the coefficients in the Taylor series of tan(x). These are the alternating permutations of ODD length, and they explode far faster than the secant family, so the melody rockets upward in big leaps once folded modulo Base. A trigonometric-combinatorial climb distinct from the Euler and Catalan sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Secant 2 inputs

Secant-number sequencer (a first as a synth block): steps through the even-indexed zigzag numbers 1, 1, 5, 61, 1385, 50521... that appear as the coefficients in the Taylor series of sec(x) (the unsigned Euler numbers). These count the alternating permutations of EVEN length and grow a touch slower than the tangent family, so the melody climbs steeply but a step behind Tangent once folded modulo Base. A trigonometric-combinatorial line distinct from the Euler and Tangent sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Boustrophedon 2 inputs

Boustrophedon-triangle sequencer (a first as a synth block): reads out the Seidel-Entringer-Arnold triangle one cell at a time, row by row. The triangle is built ox-plough style - each row is filled by snaking left-to-right then right-to-left, accumulating the row above - and its diagonal is the Euler zigzag sequence. Walking the interior cells instead of just the diagonal gives a rippling, terraced contour folded modulo Base, distinct from the single-line Euler, Tangent and Secant sequencers that only sample its edges. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# DistinctParts 2 inputs

Distinct-partition sequencer (a first as a synth block): steps through the number of ways to write n as a sum of DISTINCT positive integers 1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15... (4 = 4 = 3+1, so two ways). Euler proved this equals the count of partitions into ODD parts, a famous identity. It grows smoothly and sub-exponentially, so folded modulo Base it gives a gentle, slowly-rising organic contour distinct from the explosive zigzag sequencers and the unrestricted-partition family. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# ReverseAdd 2 inputs

Reverse-and-add orbit sequencer (a first as a synth block): walks the famous 196-algorithm - take a number, add it to its own digit-reversal, repeat - which almost always tumbles into a palindrome but for a few stubborn seeds (196, 879...) may climb forever. Each clock takes one reverse-add step and emits the running value folded into a pitch; when it grows large it reseeds to the next small number, so you hear orbit after orbit of this digit-mixing climb. A self-referential digit dynamic distinct from the power-sum orbits. A rising edge on in1 resets.

# DigitFactorial 2 inputs

Digit-factorial orbit sequencer (a first as a synth block): iterates the factorion map - replace a number by the sum of the factorials of its digits - whose orbits famously fall into the fixed points 1, 2, 145, 40585 or the cycle 169 -> 363601 -> 1454 -> 169. Each clock advances one step and emits the value folded into a pitch, reseeding every so often to tour fresh orbits. A factorial-of-digits dynamic distinct from the reverse-add and cube orbits. A rising edge on in1 resets.

# DigitCube 2 inputs

Digit-cube orbit sequencer (a first as a synth block): iterates the map that replaces a number by the sum of the CUBES of its digits, whose orbits settle on the fixed points 1, 153, 370, 371, 407 (the three-digit narcissistic numbers) or short cycles such as 55 -> 250 -> 133 -> 55 and 136 -> 244 -> 136. Each clock advances one step and emits the value folded into a pitch, reseeding to tour fresh orbits. A cube-of-digits dynamic distinct from the factorial and reverse-add orbits. A rising edge on in1 resets.

# Farey 2 inputs

Farey-sequence sequencer (a first as a synth block): walks the Farey sequence of order N - every fraction in 0..1 whose denominator is at most N, listed in increasing size (for N=5: 0, 1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 1). It steps with the exact integer mediant recurrence, so each clock outputs the next fraction directly as a control voltage and loops back at 1. A rising, unevenly-spaced rational staircase whose gaps mirror the deep structure of the rationals, distinct from the digit-orbit sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Order2 – 328—

# ContinuedFraction 2 inputs

Continued-fraction sequencer (a first as a synth block): emits the partial quotients of the square root of N - the integers a0; a1, a2... in sqrt(N) = a0 + 1/(a1 + 1/(a2 + ...)). For any non-square N this expansion is eventually PERIODIC (sqrt(7) = 2; 1,1,1,4 repeating; sqrt(23) = 4; 1,3,1,8...), and the periodic block is palindromic, so the sequencer produces a clean repeating melodic loop whose shape is fixed by N. A number-theoretic period distinct from the digit-orbit and Farey sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
N2 – 997—

# EKG 2 inputs

EKG-sequence sequencer (a first as a synth block): walks the EKG (or electrocardiogram) sequence 1, 2, 4, 6, 3, 9, 12, 8, 10, 5, 15... where each term is the smallest number not yet used that shares a common factor with the previous one. Plotted, it traces a jagged heartbeat-like trace, and it is a proved permutation of the positive integers with a deep three-line structure. Each clock advances one term, folded modulo Base into a pitch. A gcd-chained permutation distinct from the digit and prime sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Hamming 2 inputs

Hamming-number sequencer (a first as a synth block): steps through the regular or 5-smooth numbers 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27... - the integers whose only prime factors are 2, 3 and 5. Famous from Dijkstra's programming exercise, they are exactly the just-intonation frequency ratios, so the sequence is a ladder of harmonically pure intervals. Each clock advances one term, folded modulo Base. A smooth-number ladder distinct from the prime and figurate sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# SelfNumber 2 inputs

Self-number sequencer (a first as a synth block): steps through the self (or Colombian) numbers 1, 3, 5, 7, 9, 20, 31, 42, 53, 64, 75, 86, 97, 108... - integers that CANNOT be written as some smaller number plus its own digit sum, so they have no 'generator' and stand alone. Discovered by the Indian mathematician Kaprekar, they thin out in a curious near-periodic pattern tied to base ten. Each clock advances one term, folded modulo Base. A digit-generator gap sequence distinct from the other digit sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Powerful 2 inputs

Powerful-number sequencer (a first as a synth block): steps through the powerful numbers 1, 4, 8, 9, 16, 25, 27, 32, 36, 49, 64, 72, 81, 100... - integers in which every prime factor appears at least squared (so each is a product of a perfect square and a perfect cube). They are sparse and clump near the squares and cubes, giving a sequence that climbs in widening, uneven leaps. Each clock advances one term, folded modulo Base. A factor-exponent class distinct from the squarefree and smooth sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Squarefree 2 inputs

Squarefree-number sequencer (a first as a synth block): steps through the squarefree numbers 1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15, 17, 19, 21, 22, 23... - integers divisible by no perfect square (no repeated prime factor). They have density 6/pi-squared, about 61 percent of all integers, so the sequence skips only the few that carry a squared factor (4, 8, 9, 12, 16...), giving a near-chromatic run with occasional gaps. Each clock advances one term, folded modulo Base. The exact complement of the powerful numbers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Leonardo 2 inputs

Leonardo-number sequencer (a first as a synth block): steps through the Leonardo numbers 1, 1, 3, 5, 9, 15, 25, 41, 67, 109... defined by L(n) = L(n-1) + L(n-2) + 1 - the Fibonacci rule with a plus-one twist. They are the sizes of the balanced binary trees used in Dijkstra's smoothsort, and each is one less than twice a Fibonacci number. A nearly-Fibonacci climb, slightly steeper, folded modulo Base. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# PellLucas 2 inputs

Pell-Lucas sequencer (a first as a synth block): steps through the companion Pell numbers 2, 2, 6, 14, 34, 82, 198, 478... defined by Q(n) = 2*Q(n-1) + Q(n-2) - the Pell recurrence (doubling the previous term) seeded to give the numerators of the rational approximations to the square root of 2. They grow by the silver ratio 1 + sqrt(2), a faster climb than the golden Fibonacci. Folded modulo Base. A silver-ratio companion sequence distinct from the Pell and Fibonacci sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# JacobsthalLucas 2 inputs

Jacobsthal-Lucas sequencer (a first as a synth block): steps through the Jacobsthal-Lucas numbers 2, 1, 5, 7, 17, 31, 65, 127, 257... defined by a(n) = a(n-1) + 2*a(n-2), the companion to the Jacobsthal sequence. Their values hug the powers of two (each is 2^n plus or minus one), so the sequence is a wobble around a clean octave doubling. Folded modulo Base. A near-power-of-two companion distinct from the Jacobsthal and Mersenne sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Pentanacci 2 inputs

Pentanacci sequencer (a first as a synth block): the five-step Fibonacci - each term is the sum of the previous FIVE: 0, 0, 0, 0, 1, 1, 2, 4, 8, 16, 31, 61, 120... For the first several terms it doubles exactly (powers of two) before the deeper memory pulls it just below, its growth ratio approaching 2 as the number of summed terms rises. A deep-memory recurrence distinct from the two-term Fibonacci and three-term Tribonacci. Folded modulo Base. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Wedderburn 2 inputs

Wedderburn-Etherington sequencer (a first as a synth block): steps through the Wedderburn-Etherington numbers 1, 1, 1, 2, 3, 6, 11, 23, 46, 98, 207, 451... which count the number of distinct ways to bracket a product of n identical items when the operation is commutative but NOT associative - equivalently the unordered binary trees with n leaves. They arise in counting hydrocarbon isomers and phylogenetic trees, and grow by a deep nonlinear self-convolution. Folded modulo Base. A combinatorial tree count distinct from the linear recurrences. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# CopelandErdos 2 inputs

Copeland-Erdos sequencer (a first as a synth block): reads out the digits of the Copeland-Erdos constant 0.235711131719232931... - formed by writing the prime numbers one after another. Copeland and Erdos proved this constant is normal in base ten (its digits are perfectly evenly distributed), so the melody is a statistically uniform digit stream that nonetheless encodes the primes in order. Each clock advances one decimal digit, output as a 0..1 pitch step. A prime-digit stream distinct from the Champernowne and prime-gap sequencers. A rising edge on in1 resets.

# FibonacciWord 2 inputs

Fibonacci-word sequencer (a first as a synth block): the infinite binary word grown by the substitution 0 -> 01, 1 -> 0, giving 0100101001001010010100100... - the most-ordered aperiodic sequence there is, the symbolic shadow of the golden ratio. The 1s land exactly where the golden-ratio Beatty sequence says, so it is a self-similar two-note rhythm that never repeats yet is utterly deterministic. Each clock advances one symbol, output as a 0 or 1 gate. A golden-ratio word distinct from the Thue-Morse and Rudin-Shapiro sequencers. A rising edge on in1 resets.

# TribonacciWord 2 inputs

Tribonacci-word sequencer (a first as a synth block): the infinite three-symbol word grown by the substitution 0 -> 01, 1 -> 02, 2 -> 0, giving 0102010010201010201... - the ternary cousin of the Fibonacci word, the symbolic shadow of the Tribonacci constant. Its three symbols appear in the Tribonacci proportions and tile the line self-similarly, a three-note aperiodic pattern. Each clock advances one symbol, output as 0, 0.5 or 1. A Tribonacci-ratio word distinct from the two-symbol Fibonacci word. A rising edge on in1 resets.

# MephistoWaltz 2 inputs

Mephisto-waltz sequencer (a first as a synth block): the binary word grown by the substitution 0 -> 001, 1 -> 110, giving 001001110001001110110... - named after Liszt's waltz for its restless triple-time feel. It is an automatic sequence with curious correlation properties, closely related to the ternary expansion of position. Each clock advances one symbol, output as a 0 or 1 gate, giving a lurching three-against-two rhythm. A triple-time word distinct from the Fibonacci and Thue-Morse sequencers. A rising edge on in1 resets.

# BitReversal 2 inputs

Bit-reversal sequencer (a first as a synth block): emits the bit-reversal permutation - count up 0, 1, 2, 3... but flip the binary digits end-for-end before reading the value (with 4 bits: 0, 8, 4, 12, 2, 10, 6, 14...). This is the scrambled order in which the fast Fourier transform visits its data, a perfect shuffle that maximally spreads consecutive indices apart. Bits sets the word length (and so the loop length, 2^Bits). A deterministic maximal-spread permutation distinct from the random and quasi-random sources. A rising edge on in1 resets.

ParamRangeDefaultUnit
Bits2 – 126—

# Tetrahedral 2 inputs

Tetrahedral-number sequencer (a first as a synth block): steps through the tetrahedral numbers 1, 4, 10, 20, 35, 56, 84, 120... = n(n+1)(n+2)/6 - the count of spheres stacked in a triangular pyramid (cannonball-pile shape), the running sums of the triangular numbers. They are the third diagonal of Pascal's triangle. Each clock advances one term, folded modulo Base. A 3-D figurate climb distinct from the flat polygonal and the 4-D pentatope sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Octahedral 2 inputs

Octahedral-number sequencer (a first as a synth block): steps through the octahedral numbers 1, 6, 19, 44, 85, 146... = n(2*n*n + 1)/3 - the count of spheres stacked into a regular octahedron (two square pyramids base to base). Each is the sum of two consecutive square-pyramidal numbers. Each clock advances one term, folded modulo Base. A different polyhedral packing distinct from the tetrahedral and pyramidal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# SquarePyramidal 2 inputs

Square-pyramidal-number sequencer (a first as a synth block): steps through the square-pyramidal numbers 1, 5, 14, 30, 55, 91... = n(n+1)(2n+1)/6 - the count of spheres stacked in a pyramid with a square base, the running sums of the perfect squares. They appear in the classic cannonball problem (only 4900 is both square and square-pyramidal). Each clock advances one term, folded modulo Base. A square-based packing distinct from the triangular tetrahedral sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Pentatope 2 inputs

Pentatope-number sequencer (a first as a synth block): steps through the pentatope (4-simplex) numbers 1, 5, 15, 35, 70, 126... = n(n+1)(n+2)(n+3)/24 - the four-dimensional analogue of the tetrahedral numbers, the running sums of the tetrahedral numbers and the fourth diagonal of Pascal's triangle (so every fifth binomial coefficient C(n,4)). Each clock advances one term, folded modulo Base. A 4-D figurate climb distinct from the 3-D tetrahedral sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# StarNumber 2 inputs

Star-number sequencer (a first as a synth block): steps through the star (or centred-hexagram) numbers 1, 13, 37, 73, 121, 181... = 6n(n-1) + 1 - dots arranged in a six-pointed Star of David, a centred hexagonal number with six triangular points added. They climb in even, widely-spaced jumps. Each clock advances one term, folded modulo Base. A centred star figurate distinct from the solid polyhedral sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# TwinPrime 2 inputs

Twin-prime sequencer (a first as a synth block): steps through the lesser members of the twin-prime pairs 3, 5, 11, 17, 29, 41, 59, 71, 101, 107... - primes p for which p+2 is ALSO prime (3 and 5, 11 and 13, 17 and 19). Whether there are infinitely many is one of the oldest open problems in mathematics. They thin out faster than the primes, giving a sparse, irregular climb. Each clock advances one term, folded modulo Base. A prime-pair subset distinct from the full prime sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# SophieGermain 2 inputs

Sophie-Germain-prime sequencer (a first as a synth block): steps through the primes p for which 2p+1 is ALSO prime - 2, 3, 5, 11, 23, 29, 41, 53, 83, 89... Named after the mathematician who used them to attack Fermat's Last Theorem, they are central to cryptography (the safe primes 2p+1 resist certain attacks). They form a sparse, irregular subset of the primes. Each clock advances one term, folded modulo Base. A cryptographic prime class distinct from the twin-prime and full prime sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# ChenPrime 2 inputs

Chen-prime sequencer (a first as a synth block): steps through the Chen primes - primes p for which p+2 is either prime OR a product of two primes (a semiprime): 2, 3, 5, 7, 11, 13, 17, 19, 23, 29... Chen Jingrun proved there are infinitely many, a celebrated partial result toward the twin-prime and Goldbach conjectures. They are denser than the twin primes but still a proper prime subset. Each clock advances one term, folded modulo Base. A near-twin prime class distinct from the strict twin-prime sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Primorial 2 inputs

Primorial sequencer (a first as a synth block): steps through the primorials 2, 6, 30, 210, 2310, 30030, 510510... - the running products of the prime numbers (2, then 2*3, then 2*3*5, and so on), the prime analogue of the factorial. They explode even faster than factorials and are central to proofs about prime gaps and to Euclid's proof that the primes never end. The exact product is folded modulo Base, giving a fast-cycling pattern as each new prime multiplies in. A prime-product climb distinct from the additive prime sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Mersenne 2 inputs

Mersenne-number sequencer (a first as a synth block): steps through the Mersenne numbers 2^n - 1 = 1, 3, 7, 15, 31, 63, 127, 255... - the numbers that are all-ones in binary. When the exponent is prime these are the candidates for Mersenne PRIMES, the form that has held the record for the largest known prime for decades, hunted by the GIMPS distributed search. The exact value 2^n - 1 is folded modulo Base, giving a doubling-then-wrapping staircase. A power-of-two-minus-one climb distinct from the additive sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Derangement 2 inputs

Derangement sequencer (a first as a synth block): steps through the subfactorials 1, 0, 1, 2, 9, 44, 265, 1854... - the number of ways to shuffle n items so that NONE ends up in its own place (the hat-check problem). They satisfy D(n) = (n-1)(D(n-1) + D(n-2)) and the ratio D(n)/n! homes in on 1/e, so almost exactly 37 percent of all shufflings are derangements. Folded modulo Base. A fixed-point-free permutation count distinct from the factorial and Bell sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Arrangement 2 inputs

Arrangement sequencer (a first as a synth block): steps through the total number of arrangements 1, 2, 5, 16, 65, 326, 1957... - the count of ALL ordered selections (of any length) from n items, equal to the sum of n!/k! over k. It obeys the tidy rule a(n) = n*a(n-1) + 1, and the values are the nearest integers to n!*e. Folded modulo Base. A partial-permutation total distinct from the full-factorial and derangement sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Fubini 2 inputs

Fubini-number sequencer (a first as a synth block): steps through the ordered Bell (Fubini) numbers 1, 1, 3, 13, 75, 541, 4683... - the number of ways to rank n items allowing ties (the outcomes of a race with photo finishes), equivalently the number of ordered set partitions. They grow faster than the plain Bell numbers because the blocks are ordered. The exact value is folded modulo Base. A weak-ordering count distinct from the unordered Bell sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Necklace 2 inputs

Necklace sequencer (a first as a synth block): steps through the number of distinct two-colour necklaces of n beads 1, 2, 3, 4, 6, 8, 14, 20, 36, 60... - binary strings of length n counted as the same when rotated into one another. Burnside's counting lemma gives the count as the average over rotations, mixing Euler's totient with powers of two. The exact value is folded modulo Base. A cyclic-symmetry count distinct from the linear word sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# LyndonWords 2 inputs

Lyndon-word sequencer (a first as a synth block): steps through the number of binary Lyndon words of length n 2, 1, 2, 3, 6, 9, 18, 30, 56, 99... - the aperiodic necklaces, strings that are strictly smallest among all their rotations. Every string factors uniquely into a descending sequence of Lyndon words (the Chen-Fox-Lyndon theorem), making them a basis for free Lie algebras. Counted by Moebius inversion of the powers of two, the exact value is folded modulo Base. A primitive-string count distinct from the full necklace sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Hipparchus 2 inputs

Hipparchus sequencer (a first as a synth block): steps through the little Schroeder (super-Catalan) numbers 1, 1, 3, 11, 45, 197, 903, 4279... which count the ways to insert non-crossing brackets into a row of n items, or to subdivide a polygon by non-crossing diagonals. Plutarch records that Hipparchus counted the tenth term (103049) two thousand years before they were rediscovered. The exact value is folded modulo Base. A bracketing count distinct from the Catalan and Motzkin sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# TernaryTree 2 inputs

Ternary-tree sequencer (a first as a synth block): steps through the Fuss-Catalan numbers 1, 1, 3, 12, 55, 273, 1428, 7752... = C(3n, n)/(2n+1) - the count of rooted trees in which every node has exactly zero or three children (the ternary analogue of the Catalan binary trees), and of the ways to triangulate a polygon with non-crossing diagonals into quadrilaterals. The exact value is folded modulo Base. A three-way branching count distinct from the binary Catalan sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Riordan 2 inputs

Riordan-number sequencer (a first as a synth block): steps through the Riordan numbers 1, 0, 1, 1, 3, 6, 15, 36, 91, 232... - the Motzkin paths with no flat steps at ground level, equivalently certain trees and the number of ways to colour cyclic arrangements. They obey (n+1)a(n) = (n-1)(2a(n-1) + 3a(n-2)) and are a close relative of the Motzkin and Catalan families. The exact value is folded modulo Base. A flat-step-free path count distinct from the Motzkin sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# PlanePartition 2 inputs

Plane-partition sequencer (a first as a synth block): steps through the number of plane partitions of n 1, 1, 3, 6, 13, 24, 48, 86, 160... - stacks of unit cubes pushed into a corner so the heights never increase going away from the walls, the three-dimensional generalisation of ordinary integer partitions. MacMahon's beautiful product formula counts them. The exact value is folded modulo Base. A 3-D partition count distinct from the flat partition and figurate sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Apery 2 inputs

Apery-number sequencer (a first as a synth block): steps through the Apery numbers 1, 5, 73, 1445, 33001, 819005... - the extraordinary integers Roger Apery used in 1979 to prove that zeta(3) is irrational, a result that had eluded everyone for centuries. They satisfy a deep three-term recurrence with cubic coefficients and are sums of products of squared binomial coefficients. The exact value is folded modulo Base, giving a fast, wide-leaping climb. A zeta-irrationality witness distinct from the polynomial figurate sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# MianChowla 2 inputs

Mian-Chowla sequencer (a first as a synth block): the greedy Sidon sequence 1, 2, 4, 8, 13, 21, 31, 45, 66, 81... - built by always taking the smallest next integer such that ALL the pairwise sums stay distinct (no two pairs add to the same value). Sidon sets like this are prized in signal design and radio astronomy for their flat autocorrelation. The terms spread apart ever wider as collisions become harder to avoid. Folded modulo Base. A distinct-sums greedy set distinct from the prime and figurate sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# HofstadterQ 2 inputs

Hofstadter Q-sequencer (a first as a synth block): the chaotic meta-Fibonacci sequence Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2)), seeded Q(1) = Q(2) = 1, giving 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6, 8... Unlike Fibonacci it looks BACK by amounts that the sequence itself decides, so it wobbles unpredictably and it is unknown whether it stays defined forever. A self-indexing, semi-chaotic climb folded modulo Base. A strange-loop recurrence distinct from the smooth linear sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Queens 2 inputs

N-queens sequencer (a first as a synth block): steps through the number of ways to place n non-attacking queens on an n-by-n chessboard 1, 1, 0, 0, 2, 10, 4, 40, 92, 352, 724... - one of the most famous combinatorial search problems. The count is zero for the impossible 2 and 3 boards, then climbs irregularly; the eight-queens puzzle has its celebrated 92 solutions. Each clock recomputes the count by backtracking and folds it modulo Base. A board-packing count distinct from every closed-form sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Stanley 2 inputs

Stanley sequencer (a first as a synth block): steps through the Stanley sequence 0, 1, 3, 4, 9, 10, 12, 13, 27, 28... - built greedily by always adding the smallest integer that creates NO three-term arithmetic progression with any two earlier terms. Remarkably the result is exactly the numbers whose base-three representation contains no digit 2, giving it a clean self-similar Cantor-like structure. Folded modulo Base. A progression-free greedy set distinct from the Sidon (Mian-Chowla) set. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# PartitionsIntoPrimes 2 inputs

Prime-partition sequencer (a first as a synth block): steps through the number of ways to write n as a sum of PRIME numbers 1, 0, 1, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7... (7 = 7 = 5+2 = 3+2+2, so three ways). It restricts the famous partition function to prime parts only, tying the additive world of partitions to the multiplicative primes. Computed by the exact prime-restricted partition recurrence, folded modulo Base. A prime-restricted partition count distinct from the full partition and distinct-parts sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Heptagonal 2 inputs

Heptagonal-number sequencer (a first as a synth block): steps through the seven-sided polygonal numbers 1, 7, 18, 34, 55, 81, 112, 148... = n(5n-3)/2 - dots arranged in nested heptagons. Like all polygonal numbers they are second differences constant (here the gaps grow by 5 each time). Each clock advances one term, folded modulo Base. A seven-gon figurate climb distinct from the triangular, square and pentagonal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Octagonal 2 inputs

Octagonal-number sequencer (a first as a synth block): steps through the eight-sided polygonal numbers 1, 8, 21, 40, 65, 96, 133, 176... = n(3n-2) - dots arranged in nested octagons, the gaps between terms growing by 6 each step. Each clock advances one term, folded modulo Base. An eight-gon figurate climb distinct from the lower polygonal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# CenteredSquare 2 inputs

Centered-square-number sequencer (a first as a synth block): steps through the centered square numbers 1, 5, 13, 25, 41, 61, 85, 113, 145... = 2n^2 + 2n + 1 - a central dot ringed by successive square frames (the pattern of a diamond growing outward). They are the sums of two consecutive squares, and the gaps between them run through the multiples of four. Each clock advances one term, folded modulo Base. A centered figurate distinct from the ordinary square sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# CenteredTriangular 2 inputs

Centered-triangular-number sequencer (a first as a synth block): steps through the centered triangular numbers 1, 4, 10, 19, 31, 46, 64, 85, 109... = (3n^2 + 3n + 2)/2 - a central dot surrounded by growing triangular rings. The gaps between terms run through the multiples of three. Each clock advances one term, folded modulo Base. A centered figurate distinct from the ordinary triangular sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# CenteredHexagonal 2 inputs

Centered-hexagonal-number sequencer (a first as a synth block): steps through the centered hexagonal numbers 1, 7, 19, 37, 61, 91, 127, 169, 217... = 3n(n+1) + 1 - a central dot ringed by hexagons (the hex or honeycomb numbers). Their partial sums are the perfect cubes, and the gaps between them are the multiples of six. Each clock advances one term, folded modulo Base. A honeycomb figurate distinct from the star and pyramidal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Hexagonal 2 inputs

Hexagonal-number sequencer (a first as a synth block): steps through the six-sided polygonal numbers 1, 6, 15, 28, 45, 66, 91, 120... = n(2n-1) - dots in nested hexagons. They are exactly the odd-indexed triangular numbers, and every perfect number is hexagonal. Each clock advances one term, folded modulo Base. A six-gon figurate climb distinct from the triangular and pentagonal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Nonagonal 2 inputs

Nonagonal-number sequencer (a first as a synth block): steps through the nine-sided polygonal numbers 1, 9, 24, 46, 75, 111, 154, 204... = n(7n-5)/2 - dots arranged in nested nine-gons, the gaps between terms growing by 7 each step. Each clock advances one term, folded modulo Base. A nine-gon figurate climb distinct from the lower polygonal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Decagonal 2 inputs

Decagonal-number sequencer (a first as a synth block): steps through the ten-sided polygonal numbers 1, 10, 27, 52, 85, 126, 175, 232... = n(4n-3) - dots arranged in nested ten-gons, the gaps between terms growing by 8 each step. Each clock advances one term, folded modulo Base. A ten-gon figurate climb distinct from the octagonal and nonagonal sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Practical 2 inputs

Practical-number sequencer (a first as a synth block): steps through the practical numbers 1, 2, 4, 6, 8, 12, 16, 18, 20, 24... - integers n such that EVERY smaller number can be written as a sum of distinct divisors of n. They behave like little change-making systems (12 is why a dozen is handy), and they are about as dense as the primes yet defined multiplicatively. Each clock advances one term, folded modulo Base. A subset-sum-complete class distinct from the prime and abundant sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# HighlyComposite 2 inputs

Highly-composite-number sequencer (a first as a synth block): steps through the highly composite numbers 1, 2, 4, 6, 12, 24, 36, 48, 60, 120... - each having MORE divisors than any smaller number, the record-breakers of factor-richness studied by Ramanujan. They are the anti-primes (12 and 60 and 360 are why clocks and circles are divided as they are). Each clock advances one record-setter, folded modulo Base. A divisor-maximising class distinct from the prime and figurate sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Refactorable 2 inputs

Refactorable-number sequencer (a first as a synth block): steps through the refactorable (or tau) numbers 1, 2, 8, 9, 12, 18, 24, 36, 40, 56... - integers that are divisible by their OWN number of divisors (12 has six divisors and 12/6 = 2). A self-referential factor property: the count of divisors itself divides the number. Each clock advances one term, folded modulo Base. A self-divisor class distinct from the perfect and abundant sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Achilles 2 inputs

Achilles-number sequencer (a first as a synth block): steps through the Achilles numbers 72, 108, 200, 288, 392, 432, 500, 648... - integers that are POWERFUL (every prime factor appears at least squared) yet are NOT themselves a perfect power. Like the hero, they are strong but imperfect - 72 = 2^3 * 3^2 cannot be written as a single base to a single exponent. Each clock advances one term, folded modulo Base. A strong-but-imperfect class distinct from the plain powerful sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Amicable 2 inputs

Amicable-number sequencer (a first as a synth block): steps through the members of amicable pairs 220, 284, 1184, 1210, 2620, 2924... - two numbers each equal to the sum of the OTHER'S proper divisors (the divisors of 220 sum to 284 and vice versa). Known to the Pythagoreans as a symbol of friendship, these pairs are rare and were hunted for centuries. Each clock advances one amicable number, folded modulo Base. A mutual-divisor-sum class distinct from the self-referential perfect numbers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# SelfConjugate 2 inputs

Self-conjugate-partition sequencer (a first as a synth block): steps through the number of self-conjugate partitions of n 1, 1, 0, 1, 1, 1, 1, 1, 2, 2... - the partitions whose Young diagram is symmetric across its main diagonal (unchanged when rows and columns are swapped). Euler showed these are exactly the partitions into DISTINCT ODD parts. Computed by the distinct-odd-parts recurrence, folded modulo Base. A symmetric-diagram count distinct from the full and distinct partition sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# RogersRamanujan1 2 inputs

Rogers-Ramanujan (first) sequencer (a first as a synth block): steps through the partitions of n into parts that leave remainder 1 or 4 when divided by 5: 1, 1, 1, 1, 2, 2, 3, 3, 4, 5... The celebrated first Rogers-Ramanujan identity proves this exactly equals the partitions whose parts differ by at least 2 - a deep and surprising equality between a congruence condition and a gap condition. Folded modulo Base. A gap-condition partition count distinct from the ordinary partition sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# RogersRamanujan2 2 inputs

Rogers-Ramanujan (second) sequencer (a first as a synth block): steps through the partitions of n into parts that leave remainder 2 or 3 when divided by 5: 1, 0, 1, 1, 1, 1, 2, 2, 3, 3... The second Rogers-Ramanujan identity proves this equals the partitions whose parts are at least 2 and differ by at least 2. The companion to the first identity, shifted by the smallest allowed part. Folded modulo Base. A shifted gap-condition count distinct from the first Rogers-Ramanujan sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# PartitionsIntoSquares 2 inputs

Square-partition sequencer (a first as a synth block): steps through the number of ways to write n as a sum of perfect squares 1, 1, 1, 1, 2, 2, 2, 2, 3, 4... (allowing repeats, order ignored: 4 = 4 = 1+1+1+1, so two ways). It connects the additive partition world to the squares, and is bounded above by the four-squares theorem that says four are always enough. Folded modulo Base. A square-part partition count distinct from the prime-part and ordinary partition sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# PartitionsIntoTriangular 2 inputs

Triangular-partition sequencer (a first as a synth block): steps through the number of ways to write n as a sum of triangular numbers 1, 1, 1, 2, 2, 2, 4, 4, 4, 6... (the parts drawn from 1, 3, 6, 10, 15...). Gauss proved every number is a sum of at most three triangular numbers (his EUREKA theorem), and this sequence counts all the ways. Folded modulo Base. A triangular-part partition count distinct from the square-part and prime-part sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Pernicious 2 inputs

Pernicious-number sequencer (a first as a synth block): steps through the pernicious numbers 3, 5, 6, 7, 9, 10, 11, 12, 13, 14... - integers whose binary representation contains a PRIME number of 1-bits (3 = 11 has two ones, 7 = 111 has three). A property living entirely in the binary digits, bridging primality and bit patterns. Each clock advances one term, folded modulo Base. A binary-popcount-prime class distinct from the decimal-digit sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# BinaryPalindrome 2 inputs

Binary-palindrome sequencer (a first as a synth block): steps through the numbers that read the same forwards and backwards in BINARY 0, 1, 3, 5, 7, 9, 15, 17, 21, 27... (5 = 101, 9 = 1001, 21 = 10101). Mirror symmetry in base two rather than base ten, so the pattern is quite different from the decimal palindromes. Each clock advances one term, folded modulo Base. A base-two mirror class distinct from the decimal Palindrome sequencer. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Zuckerman 2 inputs

Zuckerman-number sequencer (a first as a synth block): steps through the Zuckerman numbers 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15... - integers divisible by the PRODUCT of their own digits (12 has digit product 2 and 12/2 = 6; numbers containing a zero are excluded). A self-referential multiplicative digit property. Each clock advances one term, folded modulo Base. A digit-product-divisible class distinct from the digit-sum Harshad sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Polydivisible 2 inputs

Polydivisible-number sequencer (a first as a synth block): steps through the polydivisible numbers 1, 2, ..., 9, 10, 12, 14, 16, 18, 20... - numbers where the first digit is divisible by 1, the first two digits form a number divisible by 2, the first three by 3, and so on all the way down. A cascade of divisibility through the digits; there are only finitely many (the longest has 25 digits). Each clock advances one term, folded modulo Base. A prefix-divisibility class distinct from the whole-number divisibility sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# CircularPrime 2 inputs

Circular-prime sequencer (a first as a synth block): steps through the circular primes 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97, 113... - primes that stay prime under EVERY cyclic rotation of their digits (197 -> 971 -> 719 are all prime). A rare and elegant prime property combining primality with digit rotation. Each clock advances one term, folded modulo Base. A rotation-stable prime class distinct from the twin and Sophie-Germain sequencers. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 3212—

# Halton 2 inputs

Halton-sequence sequencer (a first as a synth block): a quasi-random low-discrepancy sequence built from the radical inverse - take the index, write it in base b, then flip the digits across the decimal point (1,2,3 in base 2 give .1, .01, .11 = 0.5, 0.25, 0.75). Unlike true randomness it fills the interval evenly, never clumping or leaving gaps, the workhorse of quasi-Monte-Carlo sampling. As a melody it sounds scattered yet always lands in the holes it left before. Base picks the digit base. A deterministic gap-filling scatter distinct from the pseudo-random generators. A rising edge on in1 resets.

ParamRangeDefaultUnit
Base2 – 123—

# Weyl 2 inputs

Weyl-sequence sequencer (a first as a synth block): the additive recurrence x <- frac(x + alpha) with an IRRATIONAL step, whose iterates are equidistributed by Weyl's theorem - they spread out perfectly evenly and never repeat. With the golden ratio as the step it becomes the optimal one-dimensional low-discrepancy sequence, each new note falling in the largest remaining gap. Ratio selects the irrational (golden, root 2, root 3, plastic), each giving a different even scatter. A number-theoretic equidistribution distinct from the chaotic and pseudo-random sources. A rising edge on in1 resets.

ParamRangeDefaultUnit
RatioGolden · Sqrt2 · Sqrt3 · Plastic—

# MiddleSquare 2 inputs

Middle-square-Weyl sequencer (a first as a synth block): a modern repair of von Neumann's 1949 middle-square method - square the number and keep the middle digits - which on its own quickly collapses to zero. Adding a Weyl sequence (a steadily advancing counter) each step cures the collapse, yielding a fast, high-quality pseudo-random stream that passes stringent statistical tests. It plays a deterministic but thoroughly scrambled melody. Bits sets the read-out pitch range. A squared-digit generator distinct from the shift-register and congruential ones. A rising edge on in1 resets.

ParamRangeDefaultUnit
Bits4 – 128—

# LaggedFibonacci 2 inputs

Lagged-Fibonacci sequencer (a first as a synth block): generalises the Fibonacci rule by adding two FAR-apart earlier terms - x(n) = x(n-7) + x(n-10) modulo a power of two - keeping a short ring of past values. This classic pseudo-random generator has an enormously long period and the additive, memory-of-the-past structure gives it a subtly different texture from the bit-twiddling generators. It plays a deterministic scrambled melody that drifts and never quite repeats. Bits sets the pitch range. An additive-recurrence noise distinct from the shift-register ones. A rising edge on in1 resets.

ParamRangeDefaultUnit
Bits4 – 128—

# PCG 2 inputs

Permuted-congruential sequencer (a first as a synth block): the modern PCG generator - a plain linear-congruential engine (the oldest pseudo-random method) whose weak low bits are fixed by an output permutation that xor-shifts and then bit-rotates the state. The result is small, fast and statistically excellent, far better than the bare congruential generator it is built on. It plays a deterministic, very thoroughly scrambled melody. Bits sets the pitch range. A permuted-LCG noise distinct from the shift-register and squared-digit generators. A rising edge on in1 resets.

ParamRangeDefaultUnit
Bits4 – 128—

# Wolfram 2 inputs

Elementary cellular-automaton sequencer (a first as a synth block): runs Stephen Wolfram's one-dimensional 2-state CA on a 31-cell ring - every cell updates from itself and its two neighbours by the 8-bit Rule code (Rule 30 is chaotic and was used as a random generator, Rule 90 draws the Sierpinski triangle, Rule 110 is Turing-complete, Rule 184 models traffic). Each clock advances one generation, reading a 12-cell window of the row out as a stepped CV. The whole zoo of CA behaviour - order, chaos and the complex edge between them - from one integer. A rising edge on in1 resets to a single live cell.

ParamRangeDefaultUnit
Rule0 – 25530—

# Totalistic 2 inputs

Totalistic cellular-automaton sequencer (a first as a synth block): runs a one-dimensional CA whose next cell depends only on the SUM of its three-cell neighbourhood (0 to 3), not the exact pattern - so the whole rule is a 4-bit Code. This is the symmetric, count-only cousin of the Wolfram CA, the same rule space Wolfram used to study totalistic complexity. Each clock advances one generation on a 31-cell ring, reading a 12-cell window out as a stepped CV. A sum-driven automaton distinct from the pattern-driven Wolfram and second-order CAs. A rising edge on in1 resets to a single live cell.

ParamRangeDefaultUnit
Code0 – 1510—

# SecondOrder 2 inputs

Second-order (reversible) cellular-automaton sequencer (a first as a synth block): runs an elementary CA with memory - the next row is the Rule applied to the current row XOR-ed with the PREVIOUS row. That backward coupling makes the automaton time-reversible (you can run it backwards to recover any past state), so it conserves information and never settles into a fixed pattern, churning endlessly. Each clock advances one generation on a 31-cell ring, reading a 12-cell window out as a stepped CV. A reversible CA distinct from the dissipative Wolfram and Totalistic ones. A rising edge on in1 resets.

ParamRangeDefaultUnit
Rule0 – 25590—

# LFSR 2 inputs

Linear-feedback shift-register sequencer (a first as a synth block): clocks a 16-bit Galois LFSR with maximal-length feedback taps, the classic hardware pseudo-random generator behind scramblers, CRCs and chip-tune noise. It marches through all 65535 non-zero states in a fixed, repeatable order before looping, so it sounds random yet plays the exact same long pattern every time - a deterministic random melody. Bits sets how many low bits are read out as the pitch CV. A shift-register noise distinct from the word-mixing Xorshift. A rising edge on in1 resets the register.

ParamRangeDefaultUnit
Bits4 – 128—

# Xorshift 2 inputs

Xorshift-PRNG sequencer (a first as a synth block): clocks George Marsaglia's xorshift generator - the running 32-bit word is repeatedly shifted and XOR-ed into itself (left 13, right 17, left 5) - one of the fastest pseudo-random generators known. It visits all 2^32 - 1 non-zero states before repeating, so like the LFSR it plays a deterministic but seemingly random melody, with a denser, more thoroughly scrambled feel from mixing the whole word at once. Bits sets the read-out pitch range. A word-mixing noise distinct from the bit-shifting LFSR. A rising edge on in1 resets the seed.

ParamRangeDefaultUnit
Bits4 – 128—

# Ulam 2 inputs

Ulam-sequence sequencer (a first as a synth block): the additive sequence 1, 2, 3, 4, 6, 8, 11, 13, 16, 18, 26, 28... where each new term is the smallest integer larger than the last that is the sum of two distinct earlier terms in EXACTLY one way. Despite that purely additive rule it develops a deep, still-unexplained near-periodicity (a hidden spacing near 21.6) that number theory cannot yet account for. Each rising edge of the in0 clock advances one term, folded into Steps; a quasi-periodic melody distinct from the Fibonacci-based Pisano and the rational-enumerating Stern. A rising edge on in1 resets.

ParamRangeDefaultUnit
Steps4 – 3216—

# Galton 2 inputs

Galton-board (bean machine) source (a first as a synth block): each rising edge of the in0 clock drops a bean through Rows rows of pins, bouncing left or right on a fair coin at every pin; the output is the bin it settles in, 0..1. Because that bin is the SUM of Rows coin flips it is binomially distributed - clustered around the centre and rare at the edges, the discrete bell curve - unlike the flat, uniform spread of the Random source. Rows sets the curve's sharpness (more rows = tighter central bias). A Gaussian-weighted random step for natural-feeling movement. A rising edge on in1 reseeds.

ParamRangeDefaultUnit
Rows1 – 2412—

# Arp 1 input

Arpeggiator: cycles held notes through a pattern at a synced rate with gate, octaves, swing and step count. Latch holds the chord so it keeps arpeggiating after the keys are released (the next key starts a new chord).

ParamRangeDefaultUnit
ModeUp · Down · Up/Down · Down/Up · Converge · Diverge · As Played · Random · Chord—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0 – 20.5—
Octaves1 – 41—
Swing0 – 0.750—
Steps1 – 1616—
Latch0 – 10—

# SeqEuclid 1 input

Euclidean rhythm gate: spreads Pulses evenly across Steps (rotatable) at a synced rate.

ParamRangeDefaultUnit
Pulses1 – 165—
Steps1 – 168—
Rotate0 – 150—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0 – 20.5—

# MidiGameOfLife 1 input

Conway's Game of Life MIDI sequencer: an 8x8 cell grid evolves under the B3/S23 rule; each clock step reads the next column and plays a note for every live cell (row maps to a scale degree from Root/Scale), and a full 8-step sweep advances one generation. Gliders, blinkers and still-lifes become ever-shifting melodic and harmonic patterns. Density sets the random fill when the grid (re)seeds. The MIDI-note counterpart to the GameOfLife CV block.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0 – 20.5—
Density0 – 10.35—

# MidiBrianBrain 1 input

Brian's Brain MIDI sequencer: an 8x8 three-state grid (ready / firing / dying) evolves under Brian's Brain rules - a ready cell ignites only with exactly two firing neighbours, firing cells pass to dying, dying cells reset. Each clock step plays a note for every firing cell in the next column (row maps to a scale degree from Root/Scale); a full 8-step sweep advances one generation. The refractory state keeps it restless and sparkly where Game of Life settles. Density sets the random fill. The MIDI-note counterpart to the BrianBrain CV block.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0 – 20.5—
Density0 – 10.3—

# MidiLangton 1 input

Langton's Ant MIDI melody: a single turmite walks an 8x8 grid - turning right on a white cell, left on a black one, flipping each cell as it leaves, then stepping forward. Each clock advances the ant Steps cells and plays one note for its current row (mapped to a scale degree from Root/Scale), so the melody scribbles chaotically then locks into the famous periodic 'highway'. Emergent order from one trivial rule - a single moving agent, not a population.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0 – 20.5—
Steps1 – 161—

# Swing 1 input

Pushes off-beat eighth-notes later for a swing/shuffle feel.

ParamRangeDefaultUnit
Amount0 – 0.750.3—

# PatternGate 1 input

Gates note-ons through a 16-step on/off pattern (bitmask).

ParamRangeDefaultUnit
Pattern0 – 6553521845—
Steps1 – 1616—

# NoteOffDelay 1 input

Extends each note's gate by delaying its note-off.

ParamRangeDefaultUnit
Delay0 – 2000200ms

# Ricochet 1 input

Accelerating bouncing retriggers with decaying velocity.

ParamRangeDefaultUnit
Bounces1 – 166—
Decay0.3 – 0.980.7—
Start10 – 500100ms

# StepSeqMidi 1 input

Melodic step sequencer - semitone offsets (node config) clock the held root.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Velocity1 – 127100—

# Echo 1 input

MIDI delay: repeats notes at a synced time with velocity feedback decay.

ParamRangeDefaultUnit
Time1 – 2000250ms
Feedback0 – 0.950.5—
Repeats1 – 83—

# Flam 1 input

Precedes every note with a quiet grace note, delaying the main hit so the grace leads it - the classic drum flam.

ParamRangeDefaultUnit
Time1 – 20030ms
Grace Vel0 – 10.5—

# Roll 1 input

Drum roll / buzz: retriggers every held note at Rate for as long as it is held, each hit gated to a fraction of the interval.

ParamRangeDefaultUnit
Rate1 – 5012Hz
Gate0.05 – 0.950.5—

# Trill 1 input

Keyboard trill: while a note is held, alternates rapidly between it and the note Interval semitones above, at Rate.

ParamRangeDefaultUnit
Rate1 – 5010Hz
Interval1 – 122st
Gate0.05 – 0.950.5—

# Mordent 1 input

One-shot ornament: each struck note plays principal -> auxiliary -> principal at the attack, then sustains, the single-flick counterpart to the continuous Trill.

ParamRangeDefaultUnit
Time5 – 15040ms
Interval1 – 122st
DirectionUpper · Lower—

# Turn 1 input

Gruppetto turn: a four-step ornament at the attack - upper auxiliary, principal, lower auxiliary, then the principal held. Time sets each step, Interval the neighbour distance.

ParamRangeDefaultUnit
Time5 – 15035ms
Interval1 – 122st

# Appoggiatura 1 input

Leaning grace note: each struck note first sounds a long auxiliary (Interval away) that takes Time from the principal, which then sustains - the expressive long grace, unlike the quick Flam or Mordent.

ParamRangeDefaultUnit
Time20 – 400120ms
Interval1 – 122st
DirectionUpper · Lower—

# Strum 1 input

Spreads a chord's notes over time, up or down, like a guitar strum.

ParamRangeDefaultUnit
Spread0 – 20020ms
DirectionUp · Down—

# MidiQuantize 1 input

Snaps note starts to a synced grid by a strength amount.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Strength0 – 11—

# SeqRatchet 1 input

Retriggers each note Count times within a synced step.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Count1 – 84—
Gate0.05 – 10.9—

# NoteLength 1 input

Forces a fixed note duration (gate length).

ParamRangeDefaultUnit
Length1 – 2000200ms

# Cascade 1 input

Each struck note fans out into a timed run of Steps notes climbing (or falling) the scale from it - an arpeggiated flourish fired per key, unlike Arp which cycles the whole held chord.

ParamRangeDefaultUnit
RootC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
ScaleChromatic · Major · Natural Minor · Harmonic Minor · Melodic Minor · Dorian · Phrygian · Lydian · Mixolydian · Locrian · Pentatonic Maj · Pentatonic Min · Blues · Whole Tone · Diminished · Augmented · Hungarian Min · Japanese · Egyptian · Spanish—
Steps2 – 84—
Time5 – 20050ms
DirectionUp · Down—

# MidiTuring 1 input

Turing-machine sequencer (Music Thing style): a circular shift register clocks once per step and the held notes fire when the read bit is 1. Change is the probability the recycled bit flips - 0 locks an evolving loop, 1 fully randomises, between = slowly mutating melodies.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Length2 – 168—
Change0 – 10.15—
Gate0.05 – 10.5—

# Polymeter 1 input

Two step lanes of different lengths (LenA, LenB) clock together over the held notes, phasing against each other so the combined pattern only repeats after lcm(LenA,LenB) steps - instant polymetric movement from one chord.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Len A1 – 163—
Len B1 – 164—
Gate0.05 – 10.5—

# MidiTranceGate 1 input

Chops the held notes with a 16-step on/off Pattern at a synced Rate: every 'on' step retriggers all held notes, gated to a fraction of the step. The rhythmic gate behind the trance sound - pattern-driven, where Roll is a fixed pulse.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Pattern0 – 6553521845—
Steps1 – 1616—
Gate0.05 – 10.5—

# StepArp 1 input

Cthulhu-style step arpeggiator: walks the held chord strictly upward across Octaves octaves at a synced Rate, accenting the first step of each cycle - the rolling, octave-jumping arp of Xfer Cthulhu's sequencer. Distinct from Arp's mode-cycling: this climbs the chord in order.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Octaves1 – 42—
Accent1 – 127110—

# ChordArp 1 input

Cthulhu-style chord arpeggiator: each key builds a full chord (Type) and the result is arpeggiated upward across Octaves at a synced Rate - one finger plays a moving arpeggio of the whole chord. Releasing the key stops its run.

ParamRangeDefaultUnit
TypeUnison · Octave · 5th (Power) · 5th + Oct · Tritone · Major · Minor · Diminished · Augmented · Major (1st inv) · Major (2nd inv) · Minor (1st inv) · Minor (2nd inv) · Sus2 · Sus4 · Sus2 Sus4 · 7 Sus4 · 9 Sus4 · Major 6 · Minor 6 · 6/9 · Minor 6/9 · Major 7 · Dominant 7 · Minor 7 · Minor Maj7 · Half Dim 7 · Diminished 7 · Augmented 7 · Aug Maj7 · 7 Flat5 · Maj7 Flat5 · Maj7 Sharp5 · Major 9 · Dominant 9 · Minor 9 · Minor Maj9 · 6/9 add11 · 7 Flat9 · 7 Sharp9 · 9 Flat5 · 9 Sharp5 · Maj7 Sharp9 · Major 11 · Dominant 11 · Minor 11 · Minor Maj11 · 7 Sharp11 · Maj7 Sharp11 · 9 Sharp11 · Major 13 · Dominant 13 · Minor 13 · 13 Flat9 · 13 Sharp11 · 13 Sus4 · Add9 · Minor Add9 · Add11 · Minor Add11 · Add13 · Add9 Add11 · 2 · 7 Alt · 7 Flat9 Sharp11 · 7 Flat9 Flat13 · 7 Sharp9 Sharp11 · 13 Sharp9 · Lydian · Phrygian · Mystic · Petrushka · Hendrix · So What · Quartal 3 · Quartal 4 · Quartal 5 · Quintal 3 · Cluster 3 · Cluster 4 · Whole Tone · Major (open) · Minor (open) · Maj7 (open) · Min7 (open) · Major (drop2) · Maj7 (drop2) · Min7 (drop2) · Dom7 (drop2) · Maj7 (drop3) · Major x2 Oct · Minor x2 Oct · 5th Stack · Big Major · Big Minor · Maj over 5 · Min over b7 · Maj over 2 · Poly Maj/Maj · Poly Min/Maj · Dom7 (1st inv) · Dom7 (2nd inv) · Dom7 (3rd inv) · Maj7 (1st inv) · Maj7 (2nd inv) · Min7 (1st inv) · Min7 (2nd inv) · Dim (1st inv) · Aug (1st inv) · Dom7 (no 3) · Maj7 (no 5) · Min7 (no 5) · Maj9 (no 5) · Min9 (no 5) · Dom9 (no 5) · Dom13 (no 5,9) · Min11 (no 5) · 6 Sus2 · 6 Sus4 · Sus4 Add9 · Sus2 Add11 · Maj7 Sus2 · Min7 Add11 · 7 Flat13 · 7 Sharp5 Sharp9 · 7 Flat5 Flat9 · Maj13 Sharp11 · Dim Maj7 · Aug Add9 · Italian 6th · Elektra · Viennese · Neapolitan · Magic Hexad · Quartal 6 · Cluster 5 · Pentatonic Stack · Min Pent Stack · Major +8va · Major -8va · Minor +8va · Minor -8va · Dominant 7 +8va · Dominant 7 -8va · Major 7 +8va · Major 7 -8va · Minor 7 +8va · Minor 7 -8va · Sus4 +8va · Sus4 -8va · Add9 +8va · Add9 -8va · Major 6 +8va · Major 6 -8va · Minor 9 +8va · Minor 9 -8va · Major 9 +8va · Major 9 -8va · 6/9 +8va · 6/9 -8va · Diminished 7 +8va · Diminished 7 -8va · Augmented +8va · Augmented -8va · Half Dim 7 +8va · Half Dim 7 -8va—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Octaves1 – 41—

# OctaveArp 1 input

Cthulhu's arp octave lane: arpeggiates the held chord while a per-step octave-offset Pattern leaps the line up and down by whole octaves (alternating, staircase, bounce...) instead of climbing monotonically like StepArp.

ParamRangeDefaultUnit
Pattern0 – 71—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—

# GateArp 1 input

Cthulhu's arp gate lane: walks the held chord upward across Octaves while the note length cycles a per-step staccato/legato pattern, so the rhythm breathes - short stabs then sustained notes. Gate scales the pattern (>1 overlaps into the next step).

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.25 – 21—
Octaves1 – 41—

# VelArp 1 input

Cthulhu's arp velocity lane as a ramp: arpeggiates the held chord while velocity sweeps from From to To across Steps then resets, so every pass swells or fades without a per-step editor.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
From1 – 12740—
To1 – 127120—
Steps1 – 328—

# TransArp 1 input

Cthulhu's arp transpose lane: arpeggiates the held chord upward across Octaves while a per-step semitone Pattern (fifth pedals, triad arps, scalar runs) is added on top, so the line outlines a melodic contour, not just the chord tones.

ParamRangeDefaultUnit
Pattern0 – 72—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Octaves1 – 41—

# RatchetArp 1 input

Cthulhu's arp repeat lane: walks the held chord upward across Octaves while a per-step pattern retriggers selected steps multiple times (capped by Max), packing rolls into the line. Unlike SeqRatchet's fixed count, the repeat count varies per step.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Octaves1 – 41—
Max1 – 84—

# SkipArp 1 input

Cthulhu's arp skip lane: arpeggiates the held chord upward across Octaves, but each step has a Skip probability of being dropped to a rest, thinning the pattern differently every cycle for generative movement.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Octaves1 – 41—
Skip0 – 0.950.3—

# Drunk 1 input

Random-walk melodic sequencer: each synced Rate step nudges the pitch by a random +/-Step semitones, bounded within +/-Range of the lowest held note - Brownian melody anchored to the chord, unlike MidiRandom's memoryless picks.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Step1 – 72st
Range1 – 2412st

# EuclidMel 1 input

Euclidean melody: spreads Pulses evenly across Steps (Bjorklund) and, on each hit, advances a cursor through the held chord - the rhythm is Euclidean and the pitch walks the chord, unlike SeqEuclid which stabs all held notes per pulse.

ParamRangeDefaultUnit
Pulses1 – 165—
Steps1 – 168—
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—

# Spiral 1 input

Transposing MIDI delay: each repeat is delayed by Time and shifted by Interval semitones with velocity decaying by Feedback, so one note spins off a climbing or falling staircase of echoes - unlike Echo, which repeats the same pitch.

ParamRangeDefaultUnit
Time1 – 1000120ms
Interval-12 – 124st
Feedback0 – 0.950.7—
Repeats1 – 125—

# Tuplet 1 input

Snaps note starts to a Tuplets-per-beat grid (3 = triplets, 5 = quintuplets) by Strength, for a triplet or odd-tuplet feel where MidiQuantize only snaps to the straight grid.

ParamRangeDefaultUnit
Tuplets2 – 93—
Strength0 – 11—

# Shift 1 input

Delays every note by Delay ms (groove nudge / lay-back), pushing note-ons and offs back by the same amount so durations are preserved - the per-track timing offset of a groove sequencer.

ParamRangeDefaultUnit
Delay0 – 20020ms

# MidiMarkov 1 input

Learns the note-to-note transition statistics of what you play (a 12x12 pitch-class chain) and, on each synced step, walks the chain to improvise a new line in the same style. Memory fades old transitions.

ParamRangeDefaultUnit
Rate1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T—
Gate0.05 – 10.5—
Memory0 – 10.2—

# PolyrhythmGate 1 input

Polyrhythm gate: passes notes that land on a multiple of either count A or count B, overlaying two pulse grids (e.g. 3 against 4) into an interlocking cross-rhythm of accents.

ParamRangeDefaultUnit
A1 – 163—
B1 – 164—

# ClockDivideGate 1 input

Clock divider: passes one note-on out of every Divide that arrive and drops the rest, a simple note-rate divider for thinning fast passages or extracting a downbeat pulse.

ParamRangeDefaultUnit
Divide1 – 162—

# EuclidComplementGate 1 input

Euclidean complement: passes notes that fall on the rests of a Euclidean rhythm of Pulses-in-Steps, the photo-negative of a Euclid sequencer - an instant interlocking counter-rhythm.

ParamRangeDefaultUnit
Pulses1 – 165—
Steps1 – 168—

# SkipNote 1 input

Skip note: drops every Nth note-on and lets the rest through, the inverse of a clock divider - a quick way to punch regular holes in a run of notes.

ParamRangeDefaultUnit
Every2 – 164—

# PaperfoldGate 1 input

Paperfold gate: gates notes by the regular paperfolding (dragon-curve) sequence of the count, a 2-automatic pattern that folds in on itself at every scale; Invert flips the kept and dropped halves.

ParamRangeDefaultUnit
Invert0 – 10—

# BurstGate 1 input

Burst gate: lets OnLen consecutive notes through, mutes the next OffLen, and repeats, chopping a steady run into rhythmic bursts and rests - a note-count gate for stutter and ratchet feels.

ParamRangeDefaultUnit
OnLen1 – 163—
OffLen1 – 161—

# BeattyGate 1 input

Beatty gate: passes note-ons on a Beatty sequence floor(n*Ratio) for any irrational ratio, a Sturmian, maximally-even thinning whose density is set by the ratio; Invert keeps the complement.

ParamRangeDefaultUnit
Ratio1.1 – 31.618—
Invert0 – 10—

# GoldenWordGate 1 input

Golden-word gate: gates notes by the infinite Fibonacci word (the Sturmian 0/1 sequence at golden-ratio spacing), the most-ordered aperiodic rhythm there is; Invert flips which letter plays.

ParamRangeDefaultUnit
Invert0 – 10—

# KolakoskiGate 1 input

Kolakoski gate: gates notes by the self-describing Kolakoski 1,2 sequence (whose run-lengths reproduce the sequence itself), a hypnotically self-similar aperiodic pattern; Invert flips which symbol plays.

ParamRangeDefaultUnit
Invert0 – 10—

# EuclideanGate 1 input

Euclidean gate: passes notes on the pulses of a Euclidean (Bjorklund) rhythm that spreads Pulses as evenly as possible over Steps - the algorithm that reproduces clave, tresillo and most world rhythms from two numbers; Rotation shifts the pattern. Invert keeps the rest.

ParamRangeDefaultUnit
Pulses1 – 325—
Steps1 – 328—
Rotation0 – 310—
Invert0 – 10—

# CrossPulseGate 1 input

Cross-pulse gate: lays two pulse grids of different periods over the note stream and passes notes where they coincide (AND) or where either fires (OR), generating polyrhythmic and cross-rhythmic gating from two simple counts.

ParamRangeDefaultUnit
PeriodA1 – 163—
PeriodB1 – 164—
BothOnly0 – 10—

# ClaveGate 1 input

Clave gate: passes notes on the pulses of the Afro-Cuban son clave, the five-stroke rhythmic key of salsa and Latin music, selectable as the 3-2 or 2-3 orientation; Invert keeps the off-clave notes.

ParamRangeDefaultUnit
ThreeTwo0 – 11—
Invert0 – 10—

# TresilloGate 1 input

Tresillo gate: passes notes on the tresillo 3-3-2 pattern, the eight-step rhythmic cell underlying reggaeton, habanera and countless Latin grooves; Invert keeps the rest.

ParamRangeDefaultUnit
Invert0 – 10—

# CongruentGate 1 input

Congruent gate: passes a note only when its running count is congruent to Remainder modulo Modulus, a fully-parameterized periodic gate that covers every-Nth-note and offbeat patterns from two numbers; Invert keeps the rest.

ParamRangeDefaultUnit
Modulus1 – 164—
Remainder0 – 150—
Invert0 – 10—

# StaccatoCut 1 input

Staccato cut: clips every note to a short fixed length for a crisp detached articulation, no matter how long the key was held.

ParamRangeDefaultUnit
Length5 – 40060ms

# TenutoHold 1 input

Tenuto hold: extends every note to a long fixed length so notes sustain and run into each other, a held legato-style gate.

ParamRangeDefaultUnit
Length100 – 4000800ms

# GateLengthRandom 1 input

Gate-length random: gives each note a random duration between Min and Max, humanising the gate so no two notes ring exactly the same length.

ParamRangeDefaultUnit
Min5 – 400060ms
Max5 – 4000400ms

# DurationFromPitch 1 input

Duration from pitch: maps each note's pitch to its length so high notes play short and low notes long (or, inverted, the reverse), a register-tilt articulation.

ParamRangeDefaultUnit
Min5 – 400060ms
Max5 – 4000600ms
Invert0 – 10—

# GateLengthLFO 1 input

Gate-length LFO: sweeps note duration between Min and Max with a sine that completes one cycle every Period notes, a breathing gate that swells and shrinks.

ParamRangeDefaultUnit
Min5 – 400060ms
Max5 – 4000500ms
Period1 – 328—

# GateLengthAlternate 1 input

Gate-length alternate: alternates note durations between two lengths (long, short, long, short), a bouncing gate groove.

ParamRangeDefaultUnit
Length A5 – 4000300ms
Length B5 – 400080ms

# GateLengthRamp 1 input

Gate-length ramp: ramps note duration linearly from Min to Max across Steps notes then resets, an automatic gate crescendo.

ParamRangeDefaultUnit
Min5 – 400060ms
Max5 – 4000500ms
Steps2 – 328—

# GateLengthAccent 1 input

Gate-length accent: holds every Nth note (the downbeat) for the Long duration and clips the rest to Short, a rhythmic gate accent.

ParamRangeDefaultUnit
Every1 – 164—
Long5 – 4000400ms
Short5 – 400080ms

# GateLengthFromInterval 1 input

Gate-length from interval: grows each note's duration with how far it leaps from the previous note, so big melodic jumps ring longer than stepwise motion.

ParamRangeDefaultUnit
Base5 – 400080ms
Scale0 – 4000600ms

# GateLengthInvVelocity 1 input

Gate-length inverse velocity: louder notes are clipped short and soft notes ring long (the inverse of VelLength), a punch-then-decay articulation.

ParamRangeDefaultUnit
Min5 – 400060ms
Max5 – 4000600ms

Spectral

12 modules

# SpecGate 1 input

Spectral gate: runs a streaming STFT and, per frame, zeroes any FFT bin whose magnitude falls below Threshold relative to the loudest bin. Threshold sets that cutoff fraction (0 passes everything, 1 keeps only the peak); Mix blends the gated spectrum against the dry input. Keeps only the strongest partials, thinning noise and weak harmonics into a sparser, cleaner tone.

ParamRangeDefaultUnit
Threshold0 – 10.2—
Mix0 – 11—

# SpecFreeze 1 input

Spectral freeze: while Freeze is off it tracks each FFT bin's magnitude per frame; when Freeze is on it holds those captured magnitudes (keeping the live phase) to sustain the last spectrum indefinitely. Freeze is the on/off latch and Mix blends the held spectrum against the dry input. Turns a transient moment into a steady drone or pad.

ParamRangeDefaultUnit
Freeze0 – 10—
Mix0 – 11—

# SpecFilter 1 input

Per-bin spectral filter: runs a streaming STFT and zeroes whole FFT bins on one side of a cutoff bin for a brick-wall response in the frequency domain. Cutoff is the bin index of the edge and Mode selects low-pass (zero bins above) or high-pass (zero bins below); Mix blends against the dry input. The hard bin cut gives a far steeper, ringing-free roll-off than an analog filter.

ParamRangeDefaultUnit
Cutoff1 – 512256bin
Mode0 – 10—
Mix0 – 11—

# SpecComp 1 input

Spectral compressor: per STFT frame it finds the loudest bin, then attenuates every bin above Threshold (relative to that peak) back toward the threshold. Threshold sets the relative knee and Amount scales how hard over-threshold bins are pulled down; Mix blends against the dry input. Evens out spectral dynamics, taming dominant partials for a flatter, denser spectrum.

ParamRangeDefaultUnit
Threshold0 – 10.3—
Amount0 – 10.6—
Mix0 – 11—

# SpecDelay 1 input

Spectral echo: per STFT frame each bin's magnitude is summed with its previous-frame value scaled by Feedback, and that running magnitude is fed back (live phase retained). Feedback (0..0.95) sets how much each bin's energy persists and decays across frames; Mix blends against the dry input. Produces a smeared, frequency-domain tail closer to a freeze/reverb than a discrete time echo.

ParamRangeDefaultUnit
Feedback0 – 0.950.5—
Mix0 – 11—

# SpecBlur 1 input

Spectral blur: per STFT frame each bin's magnitude is a Blur-weighted mix of its previous value and the current one, smearing magnitudes over time while keeping live phase. Blur (0..1) sets the smoothing amount -- higher values hold past energy longer; Mix blends against the dry input. Softens transients and stretches the sound into a sustained pad.

ParamRangeDefaultUnit
Blur0 – 10.5—
Mix0 – 11—

# SpecMorph 1 input

Spectral smoothing: per STFT frame it runs a one-pole average up the bins, replacing each magnitude with a Smooth-weighted blend of the running value and the current bin (live phase retained). Smooth (0..1) sets how strongly the envelope is smeared across frequency -- higher values flatten spectral detail; Mix blends against the dry input. Blurs sharp formants into a softer, more uniform tone.

ParamRangeDefaultUnit
Smooth0 – 10.5—
Mix0 – 11—

# SpectralReso 1 input

Spectral resonator: per STFT frame each bin is compared with its two neighbors; local peaks are boosted by up to 1 + Amount x 2 while non-peak bins are cut by up to Amount x 0.5. Amount (0..1) sets both the peak boost and the valley attenuation; Mix blends against the dry input. Sharpens the spectrum into a more resonant, harmonically pronounced, vowel-like tone.

ParamRangeDefaultUnit
Amount0 – 10.5—
Mix0 – 11—

# FormantShift 1 input

Formant shift: per STFT frame it captures the magnitude envelope, resamples it by a ratio of 2^(Shift/12), then re-weights each bin to impose the shifted envelope while leaving the underlying partials in place. Shift (+/-12 semitones) moves the formants up or down, so pitch stays fixed while timbre changes; Mix blends against the dry input. Produces vocal gender/size effects without affecting the played note.

ParamRangeDefaultUnit
Shift-12 – 120st
Mix0 – 11—

# Soothe 1 input

Dynamic resonance suppressor: per STFT frame it tracks a smoothed local average up the bins and pulls any bin above that average down toward it, scaled by Amount. Amount (0..1) sets how aggressively over-average peaks are tamed (0 leaves them, 1 flattens them to the average); Mix blends against the dry input. Reduces harsh resonant spikes for a smoother, more even spectrum.

ParamRangeDefaultUnit
Amount0 – 10.6—
Mix0 – 11—

# MatchEQ 1 input

Matching EQ: with Capture on it learns each bin's magnitude as a reference curve; with Capture off it scales every bin toward that stored reference per frame. Capture latches learn vs apply, Amount (0..1) blends between no change and a full match (bin gain clamped to 8x); Mix blends against the dry input. Reshapes the input's tonal balance to resemble a previously captured reference.

ParamRangeDefaultUnit
Capture0 – 10—
Amount0 – 10.7—
Mix0 – 11—

# LinearEQ 1 input

Linear-phase 3-band EQ: per STFT frame it applies a single magnitude gain to each FFT bin grouped into low (below half/8), mid, and high (from half/2) bands, so the output has zero phase shift. Low, Mid, and High set each band's gain in dB (converted via 10^(dB/20)); Mix blends against the dry input. The linear-phase response avoids the phase smearing of analog EQ, useful on transient or stereo material.

ParamRangeDefaultUnit
Low-18 – 180dB
Mid-18 – 180dB
High-18 – 180dB
Mix0 – 11—

Stereo

18 modules

# StereoWidth 2 inputs

Mid/side stereo widener: decomposes the L/R pair into mid (sum) and side (difference), scales the side by Width, then recombines. Width below 1 narrows toward mono and above 1 (up to 2) exaggerates the stereo spread. Out picks L or R, so one instance emits each recombined channel; useful for tightening or opening a stereo bus.

ParamRangeDefaultUnit
Width0 – 21—
Out0 – 10—

# MidSide 2 inputs

Mid/side processor with independent gain on each component: splits L/R into mid and side, applies MidGain and SideGain in dB, then recombines. Lowering MidGain or raising SideGain widens the image while the reverse focuses the centre. Out picks L or R for the recombined channel; handy for level-matching centre versus stereo content.

ParamRangeDefaultUnit
MidGain-24 – 120dB
SideGain-24 – 120dB
Out0 – 10—

# Rotate 2 inputs

Stereo field rotation: rotates the L/R signal vector by Angle, tilting the whole stereo image (a hard-left source swings toward centre and on toward the right) - a true rotation rather than a width change. Angle sets the rotation in degrees and Out picks L or R. Subtle angles re-balance a lopsided image; +/-90 swaps the channels.

ParamRangeDefaultUnit
Angle-180 – 1800deg
Out0 – 10—

# Shuffle 2 inputs

Blumlein shuffler (frequency-dependent stereo width): splits the side (L-R) signal at a crossover and applies Bass width below and Treble width above, so you can collapse the low end toward mono for a tight, phase-safe centre while widening the highs - the classic mastering width control. Freq sets the crossover, Bass/Treble the width on each side of it, and Out picks L or R.

ParamRangeDefaultUnit
Freq80 – 800250Hz
Bass0 – 20.4—
Treble0 – 21.4—
Out0 – 10—

# Binaural 2 inputs

Binaural 3D panner: positions the (summed) input at an Azimuth around the head using an interaural time delay, an interaural level difference and a head-shadow low-pass on the far ear - a simplified HRTF that places a sound left/right with real depth on headphones, beyond a flat constant-power pan. Azimuth sweeps -90..90 degrees, Distance dims and dulls far sources, and Out picks L or R.

ParamRangeDefaultUnit
Azimuth-90 – 900deg
Distance0 – 10.3—
Out0 – 10—

# MonoMaker 2 inputs

Bass mono-maker: a one-pole low-pass at Freq splits the spectrum so content below the crossover is summed to mono while the highs stay in their own channel. Freq sets the crossover from 20 to 500 Hz. Out picks L or R, supplying that channel's highs over the shared mono low end; tightens low-frequency phase for vinyl and club playback.

ParamRangeDefaultUnit
Freq20 – 500150Hz
Out0 – 10—

# Haas 1 input

Haas widener for a mono source: feeds the input into a delay line and outputs either the dry signal or a copy delayed by a few milliseconds. Delay sets the offset from 0 to 40 ms, exploiting the precedence effect to throw the image to one side. Out picks L (dry) or R (delayed) so the pair forms a wide stereo spread from one mono input.

ParamRangeDefaultUnit
Delay0 – 4015ms
Out0 – 10—

# Panner 1 input

Constant-power panner for a mono source: maps Pan (-1 to +1) onto a sine/cosine gain pair so total power stays even across the field. Pan at 0 centres the source; the +/-1 extremes hard-pan it. Out picks L or R, each instance applying the matching sine or cosine leg of the pan law.

ParamRangeDefaultUnit
Pan-1 – 10—
Out0 – 10—

# AutoPan 1 input

LFO auto-panner for a mono source: a sine LFO driven from the shared transport time sweeps a constant-power pan automatically. Rate sets the sweep speed from 0.05 to 10 Hz and Depth scales how far the source travels. Out picks L or R, and because the LFO is phase-coherent across instances the two outputs track in opposition for stable motion.

ParamRangeDefaultUnit
Rate0.05 – 101Hz
Depth0 – 11—
Out0 – 10—

# Stereoize 1 input

Mono-to-stereo decorrelator: runs the input through a four-stage all-pass chain to phase-shift it without changing tone, then blends that toward the dry signal by Amount. Amount controls how much decorrelated signal is mixed in. Out picks L (dry) or R (decorrelated) so the stereo pair widens a mono source while keeping a centred reference.

ParamRangeDefaultUnit
Amount0 – 10.7—
Out0 – 10—

# StereoImager 2 inputs

Frequency-dependent imager: splits the side signal at Freq with a one-pole low-pass and scales only the high side band by Width, leaving the low side untouched. Width sets the high-band spread and Freq sets the split point from 100 to 2000 Hz. Out picks L or R for the recombined channel; widens air and detail while keeping the low end mono-safe.

ParamRangeDefaultUnit
Width0 – 21.3—
Freq100 – 2000400Hz
Out0 – 10—

# FreqPanner 2 inputs

Frequency-split panner: sums the input to mono, low-passes it at Freq, and applies a constant-power pan to only the high band while the low band stays centred. Freq sets the split from 100 to 4000 Hz and Pan positions the highs from -1 to +1. Out picks L or R, applying the matching pan-law leg to the highs over the shared centred lows.

ParamRangeDefaultUnit
Freq100 – 4000800Hz
Pan-1 – 10.5—
Out0 – 10—

# Pan 1 input

Static constant-power panner for a mono source: places the input at a fixed position from -1 (hard left) to +1 (hard right) using an equal-power (sin/cos) law so perceived loudness stays constant across the sweep. The plain manual counterpart to the LFO-driven AutoPan and the frequency-split FreqPanner - set a source's place in the image once. Out picks L or R, supplying that channel's pan-law leg; centred (Pan 0) sends equal power to both.

ParamRangeDefaultUnit
Pan-1 – 10—
Out0 – 10—

# Balance 2 inputs

Stereo balance for an existing L/R pair: tilts the level between the two input channels without collapsing them to mono - Balance at -1 mutes the right and passes the left, +1 does the reverse, 0 leaves both untouched. Where Pan places a single mono source and StereoWidth changes the mid/side spread, Balance simply re-weights a stereo signal's sides (the classic balance knob). in0 is L, in1 is R; Out picks which channel this instance emits.

ParamRangeDefaultUnit
Balance-1 – 10—
Out0 – 10—

# AutoWidth 2 inputs

Auto-widening LFO: a sine LFO swings the mid/side width of the L/R pair so the stereo image rhythmically breathes between narrow and wide. Rate sets the sweep speed, Depth how far the width travels around a centred 1.0, and the LFO is driven from the shared transport time so it is phase-coherent across instances. Where AutoPan moves a mono source side to side and StereoWidth sets a fixed spread, AutoWidth animates the width of an existing stereo signal. in0 is L, in1 is R; Out picks the channel.

ParamRangeDefaultUnit
Rate0.05 – 100.5Hz
Depth0 – 10.7—
Out0 – 10—

# Crossfeed 2 inputs

Headphone crossfeed: low-passes the opposite channel and bleeds it into this one by Amount, emulating how each ear hears both speakers in a room. Amount sets the bleed level from 0 to 1. Out picks L or R, choosing which channel is the destination and which is the filtered source; eases the hard-panned separation that fatigues on headphones.

ParamRangeDefaultUnit
Amount0 – 10.3—
Out0 – 10—

# Doubler 1 input

Vocal doubler: writes the input to a delay line and reads back a single detuned, delayed copy whose time drifts via a slow c.time-phased LFO for a natural double-tracked feel. Detune scales the drift depth, Delay sets the base delay time, and Out shifts the copy slightly shorter or longer (0.9x or 1.1x of the base) to place it as the left or right voice. Layer two instances on opposite Out settings for a widened stereo double.

ParamRangeDefaultUnit
Detune0 – 3012cents
Delay10 – 5025ms
Out0 – 10—

# Imager 2 inputs

Multiband stereo imager (Ozone-Imager-style): mono the low end and widen the highs - low frequencies (below Freq) are summed to the centre so the bass stays tight and phase-coherent, while the side content above Freq is spread by Width for an airy top. Low directional bass widened only weakens and phase-cancels the low end, so this keeps the 'stereo rose' shape: narrow at the bottom, widest at the top. Freq sets the mono crossover (80-120 Hz typical), Width the high-band spread (1 = unchanged, >1 wider, 0 fully mono), and Out picks the channel. in0 = L, in1 = R; run two instances on opposite Out for the stereo pair.

ParamRangeDefaultUnit
Freq50 – 400120Hz
Width0 – 21.5—
Out0 – 10—

Tape

1 modules

# Cassette 1 input

Tascam Portastudio-style 4-track cassette: the lo-fi tape end - a slow narrow capstan gives heavy wow (slow pitch drift) plus flutter (fast wobble) through a modulated delay, a restricted bandwidth (HF gap loss + LF rolloff) and early-saturating tape hysteresis, the bedroom-demo cassette character versus the clean Ampex/Studer mastering decks. Wow sets the pitch instability, Sat the tape drive, Tone the HF rolloff, Mix the blend.

ParamRangeDefaultUnit
Wow0 – 10.4—
Sat1 – 62—
Tone4000 – 1500010000Hz
Mix0 – 11—

Timing

2 modules

# StrumChord 1 input

Strum chord: staggers the start of simultaneously-played notes by a small delay so a chord is strummed across the strings rather than struck as a block, with selectable up- or down-stroke direction; Spread sets the strum speed.

ParamRangeDefaultUnit
Spread1 – 4000600smp
Down0 – 10—

# HumanizeTiming 1 input

Humanize timing: nudges each event's timing by a small random amount (up to the set sample range) so a rigid sequenced part feels played by hand.

ParamRangeDefaultUnit
Amount0 – 2000300smp

Tuning

3 modules

# Microtuner 1 input

Stretched-octave microtuning via per-note pitch detune.

ParamRangeDefaultUnit
Stretch-50 – 500cents/oct

# JustTune 1 input

Adaptive just intonation: retunes each note toward its 5-limit JI ratio relative to Key via per-note detune (polyphonic), Amount blending from equal temperament to pure - the beatless thirds and fifths of real harmony.

ParamRangeDefaultUnit
KeyC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Amount0 – 11—

# TuneTable 1 input

Custom microtuning: detunes each note by a per-pitch-class cents offset from the node's 12-value config list (relative to Key) - meantone, Pythagorean, maqam or gamelan, any temperament. Amount scales the table.

ParamRangeDefaultUnit
KeyC · C# · D · D# · E · F · F# · G · G# · A · A# · B—
Amount0 – 11—

Voicing

5 modules

# MPEConvert 1 input

Assigns each note its own rotating channel for per-note MPE expression.

ParamRangeDefaultUnit
Voices2 – 1515—

# Sustain 1 input

Sustain-pedal simulation: while Hold is engaged, note-offs are captured so the notes keep sounding; when Hold drops, every held note releases at once. Hold is a parameter, so a CC, an LFO or automation can play the pedal.

ParamRangeDefaultUnit
HoldOff · On—

# Mono 1 input

Monophonic note priority (last / lowest / highest).

ParamRangeDefaultUnit
PriorityLast · Lowest · Highest—

# MidiUnison 1 input

Doubles each note into multiple voices, optionally spread across channels.

ParamRangeDefaultUnit
Voices1 – 42—
SpreadSame chan · Spread chans—

# Slide 1 input

Cthulhu's slide: mono legato glue. Picks one held note by Priority (last/low/high) and emits the new note-on before releasing the old one, so a portamento synth slurs between notes instead of retriggering.

ParamRangeDefaultUnit
PriorityLast · Low · High—