zpwr-midi-fx - Reference

>_MODULE REFERENCE

A patchable grid of MIDI note-stream modules: build arps, chords, sequencers and generators by wiring blocks together. 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 MIDI In 3 Random Mod Wheel Pitch Bend Aftertouch Velocity Expression Sustain MPE Bend MPE Pressure MPE Slide

Modulation

60 modules

# `Generative` 1 input

Probabilistic melodic random walk synced to a rate.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Range`	1 – 12	3	st
`Low`	0 – 127	48	—
`High`	0 – 127	72	—
`Probability`	0 – 1	0.7	—

# `MidiLFO` 1 input

Low-frequency modulation source (sine/tri/saw/square) on the scalar control output.

Param	Range	Default	Unit
`Rate`	0.01 – 20	1	Hz
`Shape`	Sine · Triangle · Saw · Square		—
`Depth`	0 – 1	1	—

# `MidiEnv` 1 input

ADSR envelope triggered by the note gate, on the scalar control output.

Param	Range	Default	Unit
`Attack`	1 – 5000	5	ms
`Decay`	1 – 5000	200	ms
`Sustain`	0 – 1	0.7	—
`Release`	1 – 5000	300	ms

# `MidiRandom` 1 input

Generates random notes within a pitch range at a synced rate.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Low Note`	0 – 127	48	—
`High Note`	0 – 127	72	—
`Gate`	0 – 2	0.5	—
`Velocity`	1 – 127	100	—

# `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.

Param	Range	Default	Unit
`Time`	0 – 2000	100	ms

# `RandOctave` 1 input

Randomly shifts notes by up to +/- Range octaves with a chance.

Param	Range	Default	Unit
`Range`	1 – 3	1	—
`Chance`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Rate`	0.01 – 20	1	Hz
`Shape`	Sine · Triangle · Saw · Square		—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Rate`	1/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.

Param	Range	Default	Unit
`CC`	0 – 127	11	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Time`	1 – 2000	120	ms

# `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.

Param	Range	Default	Unit
`Rise`	1 – 5000	800	ms
`Max`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Cents`	0 – 50	8	c

# `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.

Param	Range	Default	Unit
`Cents`	0 – 50	10	c

# `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.

Param	Range	Default	Unit
`Amount`	-1 – 1	0.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.

Param	Range	Default	Unit
`Cents`	-50 – 50	15	c

# `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.

Param	Range	Default	Unit
`Cents`	0 – 50	15	c

# `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.

Param	Range	Default	Unit
`Cents`	0 – 50	12	c

# `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.

Param	Range	Default	Unit
`Cents`	-30 – 30	8	c

# `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.

Param	Range	Default	Unit
`Divisions`	5 – 53	19	—

# `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.

Param	Range	Default	Unit
`Root`	0 – 60	24	—

# `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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	0 – 127	60	—

# `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.

Param	Range	Default	Unit
`Root`	0 – 127	60	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`Rate`	0.05 – 12	4	Hz
`Depth`	0 – 1	0.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.

Param	Range	Default	Unit
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`RootOct`	0 – 8	3	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`TopOct`	1 – 9	6	—

# `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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Depth`	0 – 1	0.4	—
`Time`	0.02 – 1	0.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.

Param	Range	Default	Unit
`Time`	0.02 – 4	0.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, ...).

Param	Range	Default	Unit
`CC`	0 – 127	1	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Max`	1 – 16	6	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Range`	1 – 60	24	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Range`	1 – 48	12	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—

# `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.

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Decay`	0.5 – 1	0.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.

Param	Range	Default	Unit
`Depth`	0 – 1	0.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.

Param	Range	Default	Unit
`Rate`	0.05 – 20	1	—

Dynamics

162 modules

# `Velocity` 1 input

Scales and offsets note velocity, with a modulation amount.

Param	Range	Default	Unit
`Scale`	0 – 2	1	—
`Offset`	-64 – 64	0	—
`Mod Amt`	-64 – 64	0	—

# `VelCurve` 1 input

Reshapes velocity through a power curve.

Param	Range	Default	Unit
`Curve`	0.2 – 5	1	—

# `Humanize` 1 input

Adds random timing and velocity jitter for a human feel.

Param	Range	Default	Unit
`Timing`	0 – 50	8	ms
`Velocity`	0 – 1	0.3	—

# `Accent` 1 input

Boosts velocity on every Nth note.

Param	Range	Default	Unit
`Every`	1 – 16	4	—
`Amount`	0 – 1	0.5	—

# `VelClip` 1 input

Clamps velocity between Min and Max.

Param	Range	Default	Unit
`Min`	1 – 127	1	—
`Max`	1 – 127	127	—

# `Ramp` 1 input

Velocity ramp over a run of notes, ascending or descending.

Param	Range	Default	Unit
`Length`	2 – 16	8	—
`Depth`	0 – 1	0.6	—
`Direction`	Up · 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.

Param	Range	Default	Unit
`Threshold`	1 – 127	64	—
`Ratio`	1 – 8	2	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Center`	0 – 127	60	—
`Tilt`	-1 – 1	0.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.

Param	Range	Default	Unit
`Min`	1 – 2000	60	ms
`Max`	1 – 2000	500	ms

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Step`	0 – 1	0.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.

Param	Range	Default	Unit
`Min`	1 – 127	1	—
`Max`	1 – 127	127	—

# `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.

Param	Range	Default	Unit
`Length`	2 – 32	8	—
`Min`	1 – 127	30	—
`Max`	1 – 127	120	—

# `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.

Param	Range	Default	Unit
`Slope`	-3 – 3	1	—
`Base`	1 – 127	80	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Levels`	2 – 16	4	—

# `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.

Param	Range	Default	Unit
`Pattern`	0 – 65535	34953	—
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Low`	1 – 127	50	—
`High`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Length`	2 – 16	4	—
`Base`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Class`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Decay`	0.3 – 0.99	0.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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 64	16	—
`Depth`	0 – 63	30	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 63	20	—

# `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.

Param	Range	Default	Unit
`Length`	3 – 32	8	—
`Amount`	0 – 63	28	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`Levels`	3 – 12	6	—
`Wander`	0 – 1	0.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.

Param	Range	Default	Unit
`Pulses`	1 – 16	5	—
`Steps`	1 – 16	8	—
`Amount`	0 – 63	28	—

# `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.

Param	Range	Default	Unit
`High`	1 – 127	90	—
`Low`	1 – 127	50	—

# `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.

Param	Range	Default	Unit
`Low`	1 – 127	50	—
`High`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Modulus`	2 – 24	12	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 63	20	—

# `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.

Param	Range	Default	Unit
`Floor`	1 – 127	40	—

# `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.

Param	Range	Default	Unit
`Ratio`	1 – 3	1.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.

Param	Range	Default	Unit
`N`	2 – 16	4	—
`Amount`	0 – 63	28	—

# `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.

Param	Range	Default	Unit
`Probability`	0 – 1	0.3	—
`GhostVel`	1 – 80	30	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Low`	1 – 127	50	—
`High`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Pulses`	1 – 32	5	—
`Steps`	1 – 32	8	—
`Amount`	0 – 63	28	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Low`	1 – 127	45	—
`High`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 63	28	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 63	28	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 63	24	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Modulus`	3 – 99	15	—
`Low`	1 – 127	45	—
`High`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Gamma`	0.2 – 5	1	—

# `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.

Param	Range	Default	Unit
`Step`	0 – 1	0.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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Low`	1 – 127	1	—
`High`	1 – 127	127	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 32	8	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 32	8	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Low`	1 – 127	50	—
`High`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Hold`	1 – 16	4	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 32	8	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 32	8	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Steps`	2 – 12	4	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Modulus`	3 – 127	17	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 64	12	—

# `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.

Param	Range	Default	Unit
`Ratio`	0 – 1	0.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.

Param	Range	Default	Unit
`Step`	0 – 30	8	—

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

Param	Range	Default	Unit
`Floor`	1 – 127	20	—
`Ceil`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Gamma`	0.2 – 5	1	—

# `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.

Param	Range	Default	Unit
`Steps`	2 – 16	4	—

# `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.

Param	Range	Default	Unit
`Every`	2 – 16	4	—
`Ghost`	1 – 100	25	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 32	8	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Period`	2 – 32	8	—
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Gain`	0.1 – 3	1	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	1	—

# `AccentOnHigh` 1 input

Accent on high: boosts the velocity of note-ons at or above a pitch threshold, brightening the top of the keyboard.

Param	Range	Default	Unit
`Threshold`	0 – 127	72	—
`Boost`	0 – 64	20	—

# `AccentOnLow` 1 input

Accent on low: boosts the velocity of note-ons at or below a pitch threshold, reinforcing the bass register.

Param	Range	Default	Unit
`Threshold`	0 – 127	48	—
`Boost`	0 – 64	20	—

# `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.

Param	Range	Default	Unit
`Ceiling`	8 – 127	100	—

# `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.

Param	Range	Default	Unit
`Amount`	-64 – 64	16	—

# `VelocityAlternate` 1 input

Velocity alternate: alternates note-on velocities between two fixed levels (loud, soft, loud, soft), an automatic backbeat-style dynamic groove.

Param	Range	Default	Unit
`Loud`	1 – 127	110	—
`Soft`	1 – 127	60	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—
`Gain`	0 – 3	1	—

Control

5 modules

# `CCMap` 1 input

Remaps a CC number and scales/offsets its value.

Param	Range	Default	Unit
`From`	-1 – 127	1	—
`To`	0 – 127	11	—
`Scale`	0 – 2	1	—
`Offset`	-1 – 1	0	—

# `Note2CC` 1 input

Emits a CC from each note (pitch or velocity).

Param	Range	Default	Unit
`CC`	0 – 127	1	—
`Source`	Pitch · Velocity		—

# `CC2Note` 1 input

A watched CC crossing a threshold triggers a note.

Param	Range	Default	Unit
`Watch`	0 – 127	1	—
`Note`	0 – 127	60	—
`Threshold`	0 – 1	0.5	—

# `BendProc` 1 input

Scales and/or inverts incoming pitch-bend.

Param	Range	Default	Unit
`Scale`	0 – 2	1	—
`Invert`	0 – 1	0	—

# `ATProc` 1 input

Scales aftertouch, optionally converting it to a CC.

Param	Range	Default	Unit
`Scale`	0 – 2	1	—
`To CC`	-1 – 127	-1	—

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.

Param	Range	Default	Unit
`Depth`	0 – 1	0.3	—
`Time`	1 – 1000	80	ms

# `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.

Param	Range	Default	Unit
`Depth`	0 – 1	0.5	—
`Time`	10 – 2000	300	ms

# `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.

Param	Range	Default	Unit
`Rate`	0.1 – 12	5	Hz
`Depth`	0 – 1	0.15	—
`Onset`	0 – 2000	300	ms

Harmony

51 modules

# `Chord` 1 input

Turns each incoming note into a chord (165 types) with inversion, spread, octave doubling and strum.

Param	Range	Default	Unit
`Type`	Unison · 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		—
`Inversion`	0 – 4	0	—
`Spread`	0 – 2	0	—
`Octave x2`	0 – 2	0	—
`Transpose`	-24 – 24	0	st
`Strum`	0 – 200	0	ms

# `Scale` 1 input

Quantizes incoming notes to the nearest degree of the chosen root and scale.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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.

Param	Range	Default	Unit
`Semitones`	-24 – 24	0	st
`Mod Amt`	-24 – 24	0	st

# `Harmonize` 1 input

Adds up to three fixed-interval harmony voices to each note.

Param	Range	Default	Unit
`Interval 1`	-24 – 24	7	st
`Interval 2`	-24 – 24	0	st
`Interval 3`	-24 – 24	0	st

# `Drone` 1 input

Doubles every note with a fixed pedal root.

Param	Range	Default	Unit
`Root`	0 – 127	36	—

# `MidiCluster` 1 input

Adds symmetric tone-cluster voices above and below each note.

Param	Range	Default	Unit
`Width`	0 – 4	1	—
`Spread`	1 – 4	1	st

# `Glissando` 1 input

Fills a stepwise run between consecutive notes.

Param	Range	Default	Unit
`Rate`	5 – 200	40	ms

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

Param	Range	Default	Unit
`Voicing`	Open · Shell · Quartal · Spread		—

# `Octave` 1 input

Doubles each note up and/or down by whole octaves.

Param	Range	Default	Unit
`Up`	0 – 3	1	—
`Down`	0 – 3	0	—

# `MidiFold` 1 input

Folds out-of-range notes back inside a Low..High window.

Param	Range	Default	Unit
`Low Note`	0 – 127	48	—
`High Note`	0 – 127	72	—

# `Invert` 1 input

Mirrors pitch around a pivot note.

Param	Range	Default	Unit
`Pivot`	0 – 127	60	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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 – 7	2	—
`Mod Amt`	-7 – 7	0	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Notes`	2 – 4	3	—

# `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.

Param	Range	Default	Unit
`Quality`	Major · Minor		—
`Transform`	None · 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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Interval`	1 – 24	7	st

# `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.

Param	Range	Default	Unit
`Octaves`	1 – 3	1	—
`Velocity`	1 – 127	100	—

# `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.

Param	Range	Default	Unit
`Range`	1 – 12	7	st

# `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.

Param	Range	Default	Unit
`Rotate`	1 – 4	1	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Type`	Unison · 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.

Param	Range	Default	Unit
`Interval`	1 – 24	12	st
`GhostLevel`	0.05 – 1	0.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.

Param	Range	Default	Unit
`Pivot`	0 – 127	60	—

# `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.

Param	Range	Default	Unit
`Center`	0 – 116	48	—

# `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.

Param	Range	Default	Unit
`Sub1`	0 – 1	0.5	—
`Sub2`	0 – 1	0.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.

Param	Range	Default	Unit
`Rolloff`	0.1 – 1	0.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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Mode`	Chromatic · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`Pivot`	C · 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.

Param	Range	Default	Unit
`Root`	C · 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.

Param	Range	Default	Unit
`On`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`On`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Center`	0 – 127	60	—
`Strength`	0 – 1	0.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.

Param	Range	Default	Unit
`Root`	0 – 60	24	—

# `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.

Param	Range	Default	Unit
`Ceiling`	60 – 120	96	—

# `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.

Param	Range	Default	Unit
`Center`	0 – 127	60	—
`Ratio`	0.1 – 1	0.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.

Param	Range	Default	Unit
`Center`	0 – 127	60	—
`Ratio`	1 – 3	1.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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Steps`	-14 – 14	2	—

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Brightness`	-1 – 1	0	—

# `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.

Param	Range	Default	Unit
`Class`	0 – 6	5	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Ascending`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Threshold`	1 – 24	5	—
`WantLeap`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Base`	0 – 115	48	—

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

Param	Range	Default	Unit
`Axis`	0 – 127	60	—
`On`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

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

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Steps`	1 – 7	2	—

# `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.

Param	Range	Default	Unit
`AddOctave`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Up`	0 – 1	1	—
`Down`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Cents`	-50 – 50	12	ct

Probability

180 modules

# `Chance` 1 input

Probabilistic gate: lets each note through with the set probability.

Param	Range	Default	Unit
`Probability`	0 – 1	0.8	—
`Mod Amt`	-1 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Modulo`	2 – 9	3	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Density`	0 – 1	0.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.

Param	Range	Default	Unit
`Modulo`	2 – 12	5	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Step`	0 – 1	0.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.

Param	Range	Default	Unit
`Min`	0 – 24	0	st
`Max`	0 – 24	7	st

# `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.

Param	Range	Default	Unit
`Bias`	0 – 1	0.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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Length`	2 – 32	8	—
`Start`	0 – 1	0.2	—
`End`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`On`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Base`	0 – 1	0.7	—
`Slope`	-1 – 1	0.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.

Param	Range	Default	Unit
`On`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Modulus`	2 – 16	6	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`On`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Sides`	3 – 12	5	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Bound`	2 – 50	7	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Bound`	2 – 30	5	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Threshold`	0 – 200	9	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Root`	1 – 9	9	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Bits`	1 – 8	2	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Mult`	1 – 50	8	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`K`	1 – 6	2	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Bias`	0 – 1	0.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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Digits`	1 – 6	2	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Gap`	1 – 32	4	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Target`	1 – 40	9	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Tau`	1 – 24	2	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Zeros`	0 – 8	1	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Steps`	0 – 6	2	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Floor`	1 – 127	40	—
`Invert`	0 – 1	0	—

Routing

29 modules

# `Split` 1 input

Keyboard split: notes below the split point transpose by Low, the rest by High.

Param	Range	Default	Unit
`Split`	0 – 127	60	—
`Low`	-24 – 24	0	st
`High`	-24 – 24	0	st

# `Transformer` 1 input

Rule: notes within a range are transposed and velocity-scaled.

Param	Range	Default	Unit
`Low`	0 – 127	0	—
`High`	0 – 127	127	—
`Transpose`	-24 – 24	0	st
`VelScale`	0 – 2	1	—

# `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.

Param	Range	Default	Unit
`Low Note`	0 – 127	0	—
`High Note`	0 – 127	127	—
`Low Vel`	1 – 127	1	—
`High Vel`	1 – 127	127	—

# `MidiLatch` 1 input

Holds notes after release until the next note arrives.

# `Channel` 1 input

Reassigns notes to a fixed MIDI channel.

Param	Range	Default	Unit
`Channel`	1 – 16	1	—

# `FixedNote` 1 input

Forces every note to a single fixed pitch (drum / trigger).

Param	Range	Default	Unit
`Note`	0 – 127	36	—

# `KeySwitch` 1 input

Splits the keyboard at a note; one zone passes, the other is filtered.

Param	Range	Default	Unit
`Split`	0 – 127	60	—
`Low Zone`	High 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.

Param	Range	Default	Unit
`Max`	1 – 16	4	—

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

Param	Range	Default	Unit
`Voices`	1 – 16	4	—
`Base`	1 – 16	1	—

# `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.

Param	Range	Default	Unit
`MinGap`	1 – 500	30	ms

# `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.

Param	Range	Default	Unit
`Voices`	1 – 32	4	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—

# `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.

Param	Range	Default	Unit
`Center`	0 – 127	60	—
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`Spread`	0 – 1	0.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.

Param	Range	Default	Unit
`Split1`	0 – 127	48	—
`Split2`	0 – 127	72	—
`Low`	-24 – 24	-12	st
`Mid`	-24 – 24	0	st
`High`	-24 – 24	12	st

# `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.

Param	Range	Default	Unit
`Zones`	2 – 16	4	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 1	0.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.

Param	Range	Default	Unit
`CC`	0 – 127	64	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	36	—
`High`	0 – 127	72	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	60	—

# `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.

Param	Range	Default	Unit
`Min`	1 – 127	40	—
`Max`	1 – 127	110	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—
`Semitones`	-48 – 48	12	—

# `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.

Param	Range	Default	Unit
`Split`	0 – 127	60	—
`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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—

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

Param	Range	Default	Unit
`Split`	0 – 127	60	—
`ChanLo`	1 – 16	1	—
`ChanHi`	1 – 16	2	—

# `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.

Param	Range	Default	Unit
`Low`	0 – 127	48	—
`High`	0 – 127	72	—
`Octaves`	-4 – 4	1	—

Sequencing

63 modules

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

Param	Range	Default	Unit
`Mode`	Up · Down · Up/Down · Down/Up · Converge · Diverge · As Played · Random · Chord		—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0 – 2	0.5	—
`Octaves`	1 – 4	1	—
`Swing`	0 – 0.75	0	—
`Steps`	1 – 16	16	—
`Latch`	0 – 1	0	—

# `SeqEuclid` 1 input

Euclidean rhythm gate: spreads Pulses evenly across Steps (rotatable) at a synced rate.

Param	Range	Default	Unit
`Pulses`	1 – 16	5	—
`Steps`	1 – 16	8	—
`Rotate`	0 – 15	0	—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0 – 2	0.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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0 – 2	0.5	—
`Density`	0 – 1	0.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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0 – 2	0.5	—
`Density`	0 – 1	0.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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0 – 2	0.5	—
`Steps`	1 – 16	1	—

# `Swing` 1 input

Pushes off-beat eighth-notes later for a swing/shuffle feel.

Param	Range	Default	Unit
`Amount`	0 – 0.75	0.3	—

# `PatternGate` 1 input

Gates note-ons through a 16-step on/off pattern (bitmask).

Param	Range	Default	Unit
`Pattern`	0 – 65535	21845	—
`Steps`	1 – 16	16	—

# `NoteOffDelay` 1 input

Extends each note's gate by delaying its note-off.

Param	Range	Default	Unit
`Delay`	0 – 2000	200	ms

# `Ricochet` 1 input

Accelerating bouncing retriggers with decaying velocity.

Param	Range	Default	Unit
`Bounces`	1 – 16	6	—
`Decay`	0.3 – 0.98	0.7	—
`Start`	10 – 500	100	ms

# `StepSeqMidi` 1 input

Melodic step sequencer - semitone offsets (node config) clock the held root.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Velocity`	1 – 127	100	—

# `Echo` 1 input

MIDI delay: repeats notes at a synced time with velocity feedback decay.

Param	Range	Default	Unit
`Time`	1 – 2000	250	ms
`Feedback`	0 – 0.95	0.5	—
`Repeats`	1 – 8	3	—

# `Flam` 1 input

Precedes every note with a quiet grace note, delaying the main hit so the grace leads it - the classic drum flam.

Param	Range	Default	Unit
`Time`	1 – 200	30	ms
`Grace Vel`	0 – 1	0.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.

Param	Range	Default	Unit
`Rate`	1 – 50	12	Hz
`Gate`	0.05 – 0.95	0.5	—

# `Trill` 1 input

Keyboard trill: while a note is held, alternates rapidly between it and the note Interval semitones above, at Rate.

Param	Range	Default	Unit
`Rate`	1 – 50	10	Hz
`Interval`	1 – 12	2	st
`Gate`	0.05 – 0.95	0.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.

Param	Range	Default	Unit
`Time`	5 – 150	40	ms
`Interval`	1 – 12	2	st
`Direction`	Upper · 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.

Param	Range	Default	Unit
`Time`	5 – 150	35	ms
`Interval`	1 – 12	2	st

# `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.

Param	Range	Default	Unit
`Time`	20 – 400	120	ms
`Interval`	1 – 12	2	st
`Direction`	Upper · Lower		—

# `Strum` 1 input

Spreads a chord's notes over time, up or down, like a guitar strum.

Param	Range	Default	Unit
`Spread`	0 – 200	20	ms
`Direction`	Up · Down		—

# `MidiQuantize` 1 input

Snaps note starts to a synced grid by a strength amount.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Strength`	0 – 1	1	—

# `SeqRatchet` 1 input

Retriggers each note Count times within a synced step.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Count`	1 – 8	4	—
`Gate`	0.05 – 1	0.9	—

# `NoteLength` 1 input

Forces a fixed note duration (gate length).

Param	Range	Default	Unit
`Length`	1 – 2000	200	ms

# `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.

Param	Range	Default	Unit
`Root`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Scale`	Chromatic · 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		—
`Steps`	2 – 8	4	—
`Time`	5 – 200	50	ms
`Direction`	Up · 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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Length`	2 – 16	8	—
`Change`	0 – 1	0.15	—
`Gate`	0.05 – 1	0.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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Len A`	1 – 16	3	—
`Len B`	1 – 16	4	—
`Gate`	0.05 – 1	0.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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Pattern`	0 – 65535	21845	—
`Steps`	1 – 16	16	—
`Gate`	0.05 – 1	0.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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Octaves`	1 – 4	2	—
`Accent`	1 – 127	110	—

# `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.

Param	Range	Default	Unit
`Type`	Unison · 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		—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Octaves`	1 – 4	1	—

# `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.

Param	Range	Default	Unit
`Pattern`	0 – 7	1	—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.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).

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.25 – 2	1	—
`Octaves`	1 – 4	1	—

# `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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`From`	1 – 127	40	—
`To`	1 – 127	120	—
`Steps`	1 – 32	8	—

# `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.

Param	Range	Default	Unit
`Pattern`	0 – 7	2	—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Octaves`	1 – 4	1	—

# `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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Octaves`	1 – 4	1	—
`Max`	1 – 8	4	—

# `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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Octaves`	1 – 4	1	—
`Skip`	0 – 0.95	0.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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Step`	1 – 7	2	st
`Range`	1 – 24	12	st

# `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.

Param	Range	Default	Unit
`Pulses`	1 – 16	5	—
`Steps`	1 – 16	8	—
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.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.

Param	Range	Default	Unit
`Time`	1 – 1000	120	ms
`Interval`	-12 – 12	4	st
`Feedback`	0 – 0.95	0.7	—
`Repeats`	1 – 12	5	—

# `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.

Param	Range	Default	Unit
`Tuplets`	2 – 9	3	—
`Strength`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Delay`	0 – 200	20	ms

# `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.

Param	Range	Default	Unit
`Rate`	1/1 · 1/2 · 1/4 · 1/8 · 1/16 · 1/32 · 1/4. · 1/8. · 1/16. · 1/4T · 1/8T · 1/16T		—
`Gate`	0.05 – 1	0.5	—
`Memory`	0 – 1	0.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.

Param	Range	Default	Unit
`A`	1 – 16	3	—
`B`	1 – 16	4	—

# `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.

Param	Range	Default	Unit
`Divide`	1 – 16	2	—

# `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.

Param	Range	Default	Unit
`Pulses`	1 – 16	5	—
`Steps`	1 – 16	8	—

# `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.

Param	Range	Default	Unit
`Every`	2 – 16	4	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`OnLen`	1 – 16	3	—
`OffLen`	1 – 16	1	—

# `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.

Param	Range	Default	Unit
`Ratio`	1.1 – 3	1.618	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Pulses`	1 – 32	5	—
`Steps`	1 – 32	8	—
`Rotation`	0 – 31	0	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`PeriodA`	1 – 16	3	—
`PeriodB`	1 – 16	4	—
`BothOnly`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`ThreeTwo`	0 – 1	1	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Modulus`	1 – 16	4	—
`Remainder`	0 – 15	0	—
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Length`	5 – 400	60	ms

# `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.

Param	Range	Default	Unit
`Length`	100 – 4000	800	ms

# `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.

Param	Range	Default	Unit
`Min`	5 – 4000	60	ms
`Max`	5 – 4000	400	ms

# `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.

Param	Range	Default	Unit
`Min`	5 – 4000	60	ms
`Max`	5 – 4000	600	ms
`Invert`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Min`	5 – 4000	60	ms
`Max`	5 – 4000	500	ms
`Period`	1 – 32	8	—

# `GateLengthAlternate` 1 input

Gate-length alternate: alternates note durations between two lengths (long, short, long, short), a bouncing gate groove.

Param	Range	Default	Unit
`Length A`	5 – 4000	300	ms
`Length B`	5 – 4000	80	ms

# `GateLengthRamp` 1 input

Gate-length ramp: ramps note duration linearly from Min to Max across Steps notes then resets, an automatic gate crescendo.

Param	Range	Default	Unit
`Min`	5 – 4000	60	ms
`Max`	5 – 4000	500	ms
`Steps`	2 – 32	8	—

# `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.

Param	Range	Default	Unit
`Every`	1 – 16	4	—
`Long`	5 – 4000	400	ms
`Short`	5 – 4000	80	ms

# `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.

Param	Range	Default	Unit
`Base`	5 – 4000	80	ms
`Scale`	0 – 4000	600	ms

# `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.

Param	Range	Default	Unit
`Min`	5 – 4000	60	ms
`Max`	5 – 4000	600	ms

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.

Param	Range	Default	Unit
`Spread`	1 – 4000	600	smp
`Down`	0 – 1	0	—

# `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.

Param	Range	Default	Unit
`Amount`	0 – 2000	300	smp

Tuning

3 modules

# `Microtuner` 1 input

Stretched-octave microtuning via per-note pitch detune.

Param	Range	Default	Unit
`Stretch`	-50 – 50	0	cents/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.

Param	Range	Default	Unit
`Key`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Amount`	0 – 1	1	—

# `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.

Param	Range	Default	Unit
`Key`	C · C# · D · D# · E · F · F# · G · G# · A · A# · B		—
`Amount`	0 – 1	1	—

Voicing

5 modules

# `MPEConvert` 1 input

Assigns each note its own rotating channel for per-note MPE expression.

Param	Range	Default	Unit
`Voices`	2 – 15	15	—

# `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.

Param	Range	Default	Unit
`Hold`	Off · On		—

# `Mono` 1 input

Monophonic note priority (last / lowest / highest).

Param	Range	Default	Unit
`Priority`	Last · Lowest · Highest		—

# `MidiUnison` 1 input

Doubles each note into multiple voices, optionally spread across channels.

Param	Range	Default	Unit
`Voices`	1 – 4	2	—
`Spread`	Same 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.

Param	Range	Default	Unit
`Priority`	Last · Low · High		—

>_MODULE REFERENCE

Signal Sources

Categories

Modulation

# Generative 1 input

# MidiLFO 1 input

# MidiEnv 1 input

# MidiRandom 1 input

# MidiSampleHold 1 input

# MidiSlew 1 input

# RandOctave 1 input

# CCLFO 1 input

# CCSeq 1 input

# VelToCC 1 input

# CCGlide 1 input

# PressSwell 1 input

# PitchDrift 1 input

# MicrotuneSpread 1 input

# QuarterToneShift 1 input

# VelToDetune 1 input

# GamelanDetune 1 input

# GoldenAngleDetune 1 input

# StretchTuning 1 input

# NEdoRetune 1 input

# HarmonicSeriesSnap 1 input

# WerckmeisterTune 1 input

# PythagoreanTune 1 input

# BohlenPierceTune 1 input

# CarlosAlphaTune 1 input

# RandomCC 1 input

# PitchBendLFO 1 input

# NoteToPressure 1 input

# SlendroTune 1 input

# PelogTune 1 input

# MaqamRastTune 1 input

# HirajoshiTune 1 input

# RagaBhairavTune 1 input

# TurkishMakamTune 1 input

# JustMinorTune 1 input

# SeptimalTune 1 input

# YoungTune 1 input

# BluesInflect 1 input

# HarmonicSeriesTune 1 input

# SubharmonicTune 1 input

# ThaiTune 1 input

# ByzantineTune 1 input

# PersianTune 1 input

# MeantoneTune 1 input

# CarlosBetaTune 1 input

# CarlosGammaTune 1 input

# PartchTune 1 input

# QuarterToneTune 1 input

# PitchScoop 1 input

# ExpressionSwell 1 input

# HighNoteCC 1 input

# LowNoteCC 1 input

# AvgPitchCC 1 input

# PolyCountCC 1 input

# ChordSpanCC 1 input

# IntervalCC 1 input

# PitchClassCC 1 input

# NoteOnTrigCC 1 input

# BendFromVelocity 1 input

# SwellPressure 1 input