LIVECODE

livecode · utilities · JS-runtime live-coding module

LIVECODE is a side-tool module that mutates the rack from JavaScript. Spawn modules, draw patch cables, set knob values, schedule callbacks on the master clock — all from a CodeMirror editor on a card. Designed for live coding, repeatable set-ups, and bulk module wiring without click-fatigue.

The card has no audio I/O. Drop it onto your canvas like any other module, type a script, hit Run, and the rack reshapes itself. Mutations are transactional: a parse or runtime error means the successfully-emitted mutations are still applied (so partial scripts still progress), and the error message points at the offending line.

The editor has port-aware autocomplete (typing patch('vco1.sine', ' suggests only ports that can take an audio signal) and red-underline diagnostics for patches that would fail at Run-time, so you can iterate without hitting Run repeatedly.

API reference

rack

Signature	Summary
`spawn(type, name?)`	Create a new module of the given type. Optional `name` sets the script-facing identifier (e.g. spawn('analogVco', 'lead')). Returns the new module's name.
`patch('moduleA.outPort', 'moduleB.inPort')`	Wire a cable. Order is forgiving — patch may be called source-first or destination-first; the runtime detects which is which from the module def and rejects type-incompatible pairs with a clear error.
`unpatch('moduleA.outPort', 'moduleB.inPort')`	Remove a cable between two ports. Order-insensitive, like patch().
`set('module', 'param', value)`	Write a numeric param value. Clamped server-side by the module def.
`setData('module', 'key', value)`	Write an arbitrary JSON value to node.data[key]. Use for sequencer step arrays, drum-machine patterns, and other non-numeric module state — numeric knobs use set() instead.

state

Signature	Summary
`read('module', 'key')`	Read a module's runtime state. Common keys: 'step' (sequencer playhead), 'isPlaying', 'snapshot' (scope/wavviz), 'outputPeak.<portId>' (engine analyser tap).
`listModules()`	Returns the names of every spawned module on the rack — useful for diagnostic logging.
`state.get('key')`	Read a stored value (undefined if never set).
`state.set('key', value)`	Write a value (any JSON-serializable type). Returns the written value.
`state.has('key')`	Returns true iff `key` has been set (distinguishes a stored `undefined` from never-set).
`state.keys()`	Returns an array of every key stored on this runner's state bag.
`state.clear()`	Wipe this runner's state bag.

transport

Signature	Summary
`clock.start()`	Unmute the master clock outputs (equivalent to clock.unmute()).
`clock.stop()`	Mute the master clock outputs. The internal clock keeps running so clocked() callbacks continue to fire.
`clock.mute()`	Alias of clock.stop().
`clock.unmute()`	Alias of clock.start().
`clock.bpm(value?)`	Get (no args) or set (one numeric arg) the master BPM. Clamped 10..300.

schedule

Signature	Summary
`clocked('division', () => { /* … */ })`	Schedule a callback to fire every clock division. Divisions: '1/512', '1/256', '1/128', '1/64', '1/32', '1/16', '1', '2x', '4x'. Calling clocked() spawns a CLOCKED RUNNER module on the canvas that owns the subscription — delete the runner to cancel; edit its body inline to change the callback.
`every('division', () => { /* … */ })`	Alias of clocked().

util

Signature	Summary
`log(...values)`	Push a line to the LIVECODE card's output panel. Replaces console.log inside the sandbox.

clocked() divisions

Valid first-arg values for clocked(division, fn): '1/512','1/256','1/128','1/64','1/32','1/16','1','2x','4x'. Divisions ≤ 1/64 derive from TIMELORDE's clock outputs; finer (1/128, 1/256, 1/512) divide further from the scheduler tick. Period is derived from TIMELORDE.bpm every tick so a clock.bpm(140) call takes effect on the next tick without needing to re-spawn the runner.

Examples

Simplest — spawn one module + change a param

// Simplest: spawn one VCO + Audio Out and route a steady tone.
spawn('analogVco', 'v');
spawn('audioOut',  'o');
patch('v.sine', 'o.L');
patch('v.sine', 'o.R');
set('v', 'tune', 0);

Master clock — start / stop / set BPM

// Master clock control. TIMELORDE is always running so clocked()
// callbacks keep firing; clock.mute() / clock.unmute() only gate
// the gate outputs.

clock.bpm(140);  // set BPM
clock.stop();    // mute clock outputs (callbacks keep firing)
clock.start();   // unmute

clocked() — fire a callback per division

Every clocked() call spawns a CLOCKED runner module on the canvas (auto-named, positioned next to the LIVECODE that spawned it). The runner owns the subscription; delete it to cancel. You can also edit the body inline on the runner card. Re-running the same LIVECODE script updates the existing runner instead of spawning duplicates.

// clocked() — fire a callback every clock division. The clocked()
// call spawns a CLOCKED runner module on the canvas; delete the
// runner to cancel; edit its body inline to change the logic.

clocked('1/16', () => {
  // boolean predicates work the same as any JS — combine reads from
  // multiple modules with && / || / ?:
  if (read('SEQUENCER1', 'stepIndex') === 0) {
    set('SAMSLOOP1', 'gate', 1);
  }
});

Full chain — sequencer + ADSR + VCA + VCO + DRUMMERGIRL + clocked sidechain

Real-world script: a melody sequencer drives a VCO through an ADSR + VCA, a DRUMMERGIRL kick fires on every TIMELORDE beat, the kick's 1x output drives a second ADSR whose env_inv output ducks a sidechain VCA — and a clocked() callback uses state.* to track a beat counter and breathes the ducking depth between 0.2 and 1.0 over an 8-beat cosine.

// ── 9 modules ───────────────────────────────────────────────────
spawn('sequencer',   'seq');
spawn('analogVco',   'vco');
spawn('adsr',        'env');     // pluck envelope for the melody
spawn('vca',         'amp');     // melody VCA (env-driven)
spawn('vca',         'duck');    // sidechain VCA — kick ducks this one
spawn('adsr',        'sideEnv'); // sidechain envelope (kick-triggered)
spawn('drummergirl', 'kick');
spawn('mixer',       'mix');
spawn('audioOut',    'out');

// ── Main melody chain ───────────────────────────────────────────
patch('seq.pitch', 'vco.pitch');
patch('seq.gate',  'env.gate');
patch('vco.sine',  'amp.audio');
patch('env.env',   'amp.cv');

// ── Sidechain chain ─────────────────────────────────────────────
patch('amp.audio',       'duck.audio');       // melody through sidechain VCA
patch('TIMELORDE1.1x',   'kick.gate');         // kick on every beat
patch('TIMELORDE1.1x',   'sideEnv.gate');      // same trigger envelopes the duck
patch('sideEnv.env_inv', 'duck.cv');           // inverted ADSR ⇒ duck shape

// ── Mix + out ───────────────────────────────────────────────────
patch('duck.audio', 'mix.in1');
patch('kick.audio', 'mix.in2');
patch('mix.audio',  'out.L');
patch('mix.audio',  'out.R');

// ── Knobs ───────────────────────────────────────────────────────
set('env', 'attack',  0.005);
set('env', 'decay',   0.12);
set('env', 'sustain', 0.4);
set('env', 'release', 0.18);

set('amp',  'base', 0);   set('amp',  'cvAmount', 1);  // melody VCA
set('duck', 'base', 0);   set('duck', 'cvAmount', 1);  // duck idles fully open

set('sideEnv', 'attack',  0.001);
set('sideEnv', 'decay',   0.22);
set('sideEnv', 'sustain', 0);
set('sideEnv', 'release', 0.05);

// DRUMMERGIRL dialed in as a kick.
set('kick', 'pitch',  -12);
set('kick', 'tone',   0.18);
set('kick', 'shape',  0.35);
set('kick', 'decay',  0.30);
set('kick', 'volume', 1.5);

set('mix', 'ch1', 0.85); set('mix', 'ch2', 0.95); set('mix', 'master', 0.8);
set('out', 'master', 0.5);

set('seq', 'bpm',       120);
set('seq', 'length',    16);
set('seq', 'isPlaying', 1);

// ── 8-note melody on the sequencer (rest in remaining 8 slots) ─
setData('seq', 'steps', [
  { on: true,  pitch: 60 }, // C4
  { on: false },
  { on: true,  pitch: 64 }, // E4
  { on: false },
  { on: true,  pitch: 67 }, // G4
  { on: false },
  { on: true,  pitch: 72 }, // C5
  { on: false },
  { on: true,  pitch: 67 }, // G4
  { on: false },
  { on: true,  pitch: 64 }, // E4
  { on: false },
  { on: true,  pitch: 60 }, // C4
  { on: false }, { on: false }, { on: false },
]);

// ── Modulate sidechain depth via clocked() + state ─────────────
// Every 1/16 beat: bump a beat counter, sweep depth 0.2..1.0
// over an 8-beat cosine. state.* persists across ticks so we
// don't reset the counter every fire.
clocked('1/16', () => {
  const tick = (state.get('tick') ?? 0) + 1;
  state.set('tick', tick);
  // 16 sixteenths per beat → 128 ticks per 8 beats
  const phase = (tick / 128) * 2 * Math.PI;
  const depth = 0.6 + 0.4 * Math.cos(phase);  // 0.2 .. 1.0
  set('duck', 'cvAmount', depth);
});

Minimal sidechain — VCO + VCA + ADSR.env_inv + DRUMSEQZ gate

The classic sidechain ducker, wired from a single script. The inverted ADSR envelope (env_inv, available on every ADSR) idles at 1.0 (VCA full-open) and DIPS to 0 when the kick fires, pumping the VCO's volume in time with the drums.

// Sidechain ducker — VCO plays through VCA; a drum-sequencer gate
// fires an ADSR whose INVERTED envelope (env_inv) modulates the
// VCA's cv, ducking the VCO in time with the beat.

spawn('analogVco', 'lead');
spawn('vca', 'duck');
spawn('adsr', 'ducker');
spawn('drumseqz', 'drums');
spawn('audioOut', 'mainout');

patch('lead.sine',       'duck.audio');
patch('ducker.env_inv',  'duck.cv');
patch('drums.gate1',     'ducker.gate');
patch('duck.audio',      'mainout.L');
patch('duck.audio',      'mainout.R');

// Snappy envelope so the dip is quick + the level returns fast.
set('ducker', 'attack',  0.005);
set('ducker', 'decay',   0.18);
set('ducker', 'sustain', 0);
set('ducker', 'release', 0.05);

// VCA: cv-driven, no DC offset (env_inv idles at 1 → VCA full open
// when no kick has fired yet).
set('duck', 'base',     0);
set('duck', 'cvAmount', 1);

// 120 BPM; toggle a hit on track 1 then run the sequencer so gate1
// fires on the beat.
set('drums', 'bpm',       120);
set('drums', 'isPlaying', 1);

Reference: per-module addressable surface

Every module's port + param ids, ready to drop into a script. Auto-generated from module-registry.ts at build time.

sources (59)modulation (27)filters (7)effects (28)utilities (30)output (11)utility (7)processors (3)filter (1)games (5)video-effects (2)hybrid (2)

sources

903a random signal generator moog903a

903A Random Signal Generator (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). Passive white + pink noise source with two independent audio taps (WHITE = flat spectrum; PINK = -3 dB/oct, Voss-McCartney), scaled by a single LEVEL knob. No inputs. Own-code (public-domain noise technique). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

white audio
pink audio

params

level 0..1

example js

spawn('moog903a', 'x');
set('x', 'level', 0.8);

921 vco moog921Vco

921 voltage-controlled oscillator (first module of the moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). Faithful to the original 921: ONE oscillator core presents FOUR simultaneous waveform jacks — sine, triangle, sawtooth, and rectangular with variable pulse width — all phase-coherent off the shared core. Pitch input is exponential 1V/oct (0V = C4); a dedicated LINEAR frequency-control input (lin_fm, scaled by the Lin FM depth) gives through-zero-style linear FM; a sync input drives the hard/soft/off SYNC switch (-1 soft / 0 off / +1 hard) for classic sync timbres. RANGE sets the coarse octave (+/-5 oct), FREQ the fine tune (+/-12 st), WIDTH the rectangular duty cycle (with audio-rate width_cv), LEVEL the output gain. DSP is own-code: a clean-room polyBLEP/polyBLAMP band-limited oscillator (not a port of any moogafakkin schematic or copyleft source - permissive only). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

sine audio
triangle audio
sawtooth audio
rectangular audio

inputs

pitch pitch
lin_fm audio
sync audio
width_cv cv
octave cv
tune cv
linFmAmount cv
level cv

params

octave -5..5oct
tune -12..12st
width 0.02..0.98
linFmAmount -1..1
sync -1..1
level 0..2

example js

spawn('moog921Vco', 'x');
set('x', 'octave', 0);
patch('x.sine', 'x.pitch');

921b osc moog921b

921B Oscillator (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). The slaved VCO driven by a 921A bus: it reads freq_bus (V/oct pitch) + width_bus (pulse width) CONTROL INPUTS from a 921A rather than carrying its own 1V/oct jack, and presents FOUR fixed-level simultaneous waveform outs off one common core — sine, triangle, saw, rectangular — across 1 Hz–40 kHz. The FREQUENCY pot is a 2-octave fine trim; the RANGE switch sets the octave footage; DC MODULATE is DC-coupled LINEAR FM (non-1V/oct, ±Hz); AC MODULATE is cap-coupled LINEAR FM (a DC-blocking high-pass runs first so a DC offset on the modulator doesn't bend the pitch); the SYNC input + 3-position SYNC switch (off / lo=soft / hi=hard) drive oscillator sync. With nothing patched the bus normals to C4 @ 50% duty so the 921B still sounds standalone, but it is designed to be driven by a 921A driver. DSP forks the shared own-code moogafakkin VCO core (clean-room polyBLEP/polyBLAMP band-limited oscillator + hard/soft sync, the same core the 921 VCO uses) - not a port of any moogafakkin schematic or copyleft source, permissive only. Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

sine audio
triangle audio
saw audio
rect audio

inputs

freq_bus cv
width_bus cv
dc_mod audio
ac_mod audio
sync audio

params

fine -12..12st
range -5..5oct
modAmount -1..1
syncMode -1..1
level 0..2

example js

spawn('moog921b', 'x');
set('x', 'fine', 0);
patch('x.sine', 'x.freq_bus');

acidwarp acidwarp

acidwarp is a pure-GPU plasma SOURCE — it has no video input, it synthesizes its picture from math. It is a faithful port of Noah Spurrier's 1992-93 ACIDWARP demo: a 320x240 (NTSC 4:3) buffer of 8-bit palette indices is generated once per scene by a per-pixel formula (distance + angle + scaled sin/cos modulators, plus a few XOR scenes and recursive "rain" noise scenes), then every frame a 256-entry color palette is rotated by one or more slots and sampled per pixel. The scrolling palette is what makes the pattern appear to flow and pulse, even though the underlying index field is static until the scene changes. There are 41 scenes (concentric rings, simple rays, peacock, five-arm star, interference fields, rain/noise, interlaced two-screen variants, etc.) and 8 palettes (RGBW rainbow, greyscale, half-grey, pastel — each with an optional sparkle/"lightning" variant that brightens every 4th slot). Use it as a generative video bed: patch OUT into a mixer/feedback/output card, ride SPEED for the cycling rate, and nudge SCENE by hand or with a clock into scene_cv for rhythmic pattern changes. Slot 0 is reserved black, so palette rotation cycles only the 255 non-black colors.

outputs

out video

inputs

speed_cv cv
scene_cv cv

params

speed 0..1
freeze 0..1
scene 0..?
paletteType 0..?
sceneTrig 0..1

example js

spawn('acidwarp', 'x');
set('x', 'speed', 0);
patch('x.out', 'x.speed_cv');

analog vco analogVco

Analog-style oscillator with saw / square / triangle / sine outputs and FM input.

outputs

saw audio
square audio
triangle audio
sine audio
morph audio
sync audio

inputs

pitch pitch
fm audio
pm audio
sync audio
tune cv
fine cv
fmAmount cv
pmAmount cv
shape cv

params

tune -36..36semi
fine -100..100cent
fmAmount -1..1
pmAmount -1..1
pw 0.05..0.95
shape 0..1

example js

spawn('analogVco', 'x');
set('x', 'tune', 0);
patch('x.saw', 'x.pitch');

archivist archivist

ARCHIVIST — universal Internet Archive (archive.org) media SOURCE. Pick a media type (IMAGE / AUDIO / VIDEO / ANY), type a search term + press Enter, and the card searches archive.org, picks a RANDOM matching item, and loads it; "↻ next" re-rolls another random match from the same results. Optional FROM/TO year-range narrows the search (e.g. 1970–1989). All searching + metadata happen client-side (the archive.org search + metadata APIs are CORS-open, so NO proxy is needed). PER-TYPE OUTPUTS (subject to archive.org CORS on the SERVED file — verified): IMAGE → the still image is uploaded as a CORS-clean WebGL texture on the `image` output (image upcasts to `video` for free, so it can drive video inputs). AUDIO → the clip plays + scrubs and its stereo audio routes out CORS-clean on `audio_l` / `audio_r` (analysable downstream, e.g. into SYNESTHESIA for beats). VIDEO → archive.org does NOT send CORS headers on served video files, so the clip is PLAY-ONLY: it plays + scrubs in the card preview, but the texture would be tainted, so the `video` output is NOT delivered for an archive video (the card shows a "play-only" warning). SCRUBBING for time-media (audio + video): a draggable timeline seeks the playhead, with ±10s skip, a "jump to random position" button (⤭), and an mm:ss readout — robust to archive.org's byte-range support (verified: audio + video serve HTTP 206 ranges). GATE/TRIGGER + CV OUTPUTS: `loaded` (trigger — a short pulse each time a new item finishes loading, any type), `ended` (trigger — pulses when a time-media item reaches its end), `playing` (gate — HIGH while a time-media item is playing), and `playhead` (CV — 0..1 normalized playhead position). The `play_trigger` gate INPUT toggles play/pause on a rising edge. PATCHING: all inputs + outputs live in the card's yellow drill-down PATCH PANEL (top-left / top-right affordances → INPUT / OUTPUT → grouped Gates / CV / Audio / Video rows) — there are no side jacks. PLAYABLE-FILE PICKING: for video the card prefers an HTML5-playable derivative (h.264 .mp4 → theora .ogv → .webm) chosen by the metadata format token, NOT just the file extension — so an un-decodable MPEG-4-Part-2 / HEVC .mp4 ORIGINAL or an old MPEG-2 / AVI / MOV is skipped; if the picked file still can't decode, the card surfaces a "couldn't play — skipping" status and AUTO-ADVANCES to the next random match (it never hangs on "Loading"). Only publicly-streamable items are loaded (the query excludes access-restricted / lending / DMCA items). Attribution: the card surfaces the item title + a link to its archive.org details page and labels the source as Internet Archive. A clean VIDEO texture output would require a same-origin streaming proxy (re-serving archive.org video with our own CORS + Range passthrough) — out of scope for v1; image + audio ship with real clean outputs, video ships play/scrub-only with the limitation documented.

outputs

image image
video video
audio_l audio
audio_r audio
loaded gate
ended gate
playing gate
playhead cv

inputs

play_trigger gate

params

gain 0..2
cv_play_trigger 0..1

example js

spawn('archivist', 'x');
set('x', 'gain', 0);
patch('x.image', 'x.play_trigger');

audio in audioIn

System audio input source. Stream from a user-selected mic/line-in/interface via getUserMedia; L+R outputs are fanned out from mono sources or split from stereo. Card owns the permission prompt + device dropdown + devicechange refresh.

outputs

audio_l_out audio
audio_r_out audio

params

gain 0..2gain

example js

spawn('audioIn', 'x');
set('x', 'gain', 1);

blood blood

Interactive BLOOD video source — the NBlood (Build-engine) port of Blood, compiled to WebAssembly and rendered as a video module. Owner-only and single-instance, like DOOM: the rack owner spawns it and plays; the video output is the Build software-rendered framebuffer, aspect-correct letterboxed into the canvas. CV-typed gate inputs (up/down/left/right, fire, altfire, use, jump, crouch, weapnext/weapprev, esc, enter) drive the marine from cables, and the focused card also captures the keyboard. Stereo audio_l/audio_r outputs are wired but silent in v1 (the PCM bridge is stubbed). The card boots OUT-OF-BOX: the 1997 Blood SHAREWARE data ("The Way of All Flesh", episode 1: maps E1M1-E1M8) is bundled under static/blood/ and LFS-tracked, so no picker is needed. The "Load full Blood data…" picker is an optional override — supply a copy of the full game you own (GOG/Steam One Unit Whole Blood or Fresh Supply) to play all episodes.

outputs

out video
audio_l audio
audio_r audio

params

audioGain 0..2
fillMode 0..1

example js

spawn('blood', 'x');
set('x', 'audioGain', 1);

bluebox bluebox

DTMF dialer with phreaker buttons. 12-key phone keypad — digits 0-9 emit the Bell-System dual-tone pair (row + col, e.g. "5" → 770 Hz + 1336 Hz); BLUEBOX emits a single 2600 Hz sine (the AT&T in-band supervisory tone that 1970s phreakers used to seize long-distance trunks); REDBOX emits 1700 + 2200 Hz summed (the US payphone coin-acceptance pair). Each key is push-to-talk — pointerdown on the card OR a gate cable into the matching gate_<name> input holds the key down. Multiple held keys sum, and shared frequencies (e.g. "1" and "4" both pull col=1209) collapse onto a single shared phase accumulator so simultaneous presses produce a louder tone, not a flam. No envelope or musical AD — bare on/off sines with a ~1 ms anti-click ramp at the boundary.

outputs

out audio

inputs

gate_1 gate
gate_2 gate
gate_3 gate
gate_4 gate
gate_5 gate
gate_6 gate
gate_7 gate
gate_8 gate
gate_9 gate
gate_0 gate
gate_bluebox gate
gate_redbox gate

params

btn_1 0..1
btn_2 0..1
btn_3 0..1
btn_4 0..1
btn_5 0..1
btn_6 0..1
btn_7 0..1
btn_8 0..1
btn_9 0..1
btn_0 0..1
btn_bluebox 0..1
btn_redbox 0..1

example js

spawn('bluebox', 'x');
set('x', 'btn_1', 0);
patch('x.out', 'x.gate_1');

camera cameraInput

Webcam input (LOCAL ONLY). Live <video> -> WebGL2 texture; gain / mirror / on params. The captured stream is local to your browser tab and is NOT sent to other rack-mates — collaborators see a presence badge ("user X has CAMERA active") via Y-awareness, not the video itself. Multiplayer streaming (WebRTC + SFU) is deferred to a future phase. Spec: .myrobots/plans/module-camera-input.md.

outputs

out video

inputs

gain cv
mirror gate

params

gain 0..2
enabled 0..1
mirror 0..1
fillMode 0..1

example js

spawn('cameraInput', 'x');
set('x', 'gain', 0);
patch('x.out', 'x.gain');

chowkick chowkick

Punchy synth-kick voice — hand-port of ChowKick by Jatin Chowdhury / chowdsp (github.com/Chowdhury-DSP/ChowKick, BSD-3-Clause). Gate-triggered single-voice kick: a tight pulse shaper (Width / Amp / Decay / Sustain) plus a gated transient-click noise burst (Amount / Decay / Cutoff + 4 noise types: Uniform / Gaussian / Pink / Velvet) PINGS a true 2-pole resonant BODY that rings a bipolar decaying sine at Freq (+ 1V/oct pitch CV). The body's pole RADIUS is set by Damping (the ring-time control: low = long boom, high = short thud), the pole ANGLE by Freq; Q sharpens the resonance; Tight adds symmetric tanh drive (fatter, odd harmonics) and Bounce an asymmetric skew (even harmonics). A per-trigger downward PITCH ENVELOPE (Pitch Amount / Pitch Decay — sweeps the body from ~3.5× Freq down to Freq on each gate) gives the kick its punch; a Drive stage adds weight + small-speaker translation; an internal 25 Hz DC blocker keeps the output bipolar. A first-order Tone LPF (50..2000 Hz) and dB Level (-60..0) form the output stage; Portamento (0..100 ms) smooths Freq under V/oct sweeps; LINK couples Q + Damping (midpoint blend) for a single "tightness" macro. Defaults ship punchy out of the box (short 0.5 ms pulse, ringing body @ damp 0.4, click @ N Amt 0.2, pitch sweep 0.6, drive 0.3, tone 2 kHz). All 20 knobs/toggles are CV-able with per-port cvScale hints (log/linear/discrete) per ADR-004. The card mirrors the source plugin's two-band UI (Pulse Shape + Resonant Filter, with a third PUNCH fader row) and live canvas previews of the envelope shape + body response. Mono audio_out. (NOTE: the earlier port shipped a coefficient bug — an inverted peaking-EQ that NOTCHED the body — so it emitted a pitchless unipolar DC blob; PR feat/chowkick-oomph replaced it with the ringing resonator + punch chain.)

outputs

audio_out audio

inputs

gate_in gate
pitch_cv cv
width_cv cv
amplitude_cv cv
decay_cv cv
sustain_cv cv
noise_amount_cv cv
noise_decay_cv cv
noise_cutoff_cv cv
freq_cv cv
q_cv cv
damping_cv cv
tight_cv cv
bounce_cv cv
tone_cv cv
portamento_cv cv
level_cv cv
pitch_amount_cv cv
pitch_decay_cv cv
drive_cv cv

params

width 0.1..50ms
amplitude 0..2
decay 0..1
sustain 0..1
noise_amount 0..1
noise_decay 0..1
noise_cutoff 20..8000Hz
noise_type 0..3
freq 20..500Hz
q 0.1..10
damping 0..1
tight 0..1
bounce 0..1
tone 50..4000Hz
portamento 0..100ms
level -60..0dB
link 0..1
pitch_amount 0..1
pitch_decay 0..1
drive 0..1

example js

spawn('chowkick', 'x');
set('x', 'width', 0.5);
patch('x.audio_out', 'x.gate_in');

cube cube

3D wavetable-navigator oscillator. Builds a 3D scalar field — "the cube," a space that is a mix of solid and filled — out of THREE e352 wavetables (FLOOR / WALL / CEILING, each independently chosen from WAVESCULPT's full preset set, defaults FLOOR=basic-shapes, WALL=harmonic-sweep, CEILING=basic-shapes), then flies an arbitrary planar SLICE through the field and reads it back as the played waveform via a SURFACE-HEIGHT SCAN: for each of 256 x-positions the sample = how far the solid extends along the slice (intersection depth), so the cube's shape literally becomes the wave. MORPH connects the wall to the floor (at min) or the ceiling (at max), weighted-averaged in between; CONNECT morphs the connecting curve from a circle arc to a sawtooth-V touching the floor, and CONNECT STRENGTH overshoots the connector's interior control point "out of the cube" for a dramatic swell of the solid base (0 = today's exact shape). The slice navigates with Y (up/down) + Rot X/Y/Z (Euler rotation on all 3 axes). MATERIAL switches SMOOTH (continuous density) ↔ HARD (binary solid in/out). CRUSH is a 3D bitcrush reducing spatial-grid + amplitude resolution (default 0 = transparent → blocky/steppy at max); SPACE CRUSH is an independent spatial voxelization of just the FIELD lookup coordinates (chunky voxels, 0 = transparent), and SPACE DIFFUSE applies a gravity that pulls the sampled cloud toward the cube's lowest-information (emptiest) wall — the target wall latches when the tables/morph change, not as the knob moves (0 = off). WRAP toggles whether a slice extending outside the cube is silent (default) or mirror-folds back to the opposite side. A V/oct pitched oscillator (pitch input + tune/fine) with stereo L/R SPREAD on SEPARATE L and R output ports (max ±18% of the cube depth between channels — the L slice is read below center, the R above, so the spread is clearly audible and survives patching into mono inputs). View-only Zoom + Rot X/Y/Z orbit the WebGL2 3D cube visualization (the scalar field rendered as a translucent voxel slice-stack with the live selection slice shown as a square plane cutting through it) without affecting the sound or the selected slice. CV inputs cover the expressive params (slice Y/rotation, morph, connect, connect strength, crush, space crush, space diffuse, fold, tune). A POLY input (polyPitchGate) accepts the 5-voice chord bus from MIDI LANE (mode=poly) or POLYSEQZ: when any lane is gated CUBE runs one phase accumulator per gated lane through the SAME posted slice waves at that lane's pitch and sums them — polyphonic, with the slice/field timbre shared across voices; with nothing patched to poly the mono `pitch` path runs unchanged. A per-voice amplitude ADSR (Attack / Decay / Sustain / Release) plus a BASE VOL knob shape each voice. GATING is decided by what is PATCHED: when the POLY bus OR the mono TRIGGER is connected, CUBE is a GATED voice — a lane/voice sounds only while it is gated-or-releasing, and a never-gated lane is SILENT (patching poly never auto-drones). When NEITHER is patched, CUBE is a continuous raw VCO. BASE VOL is a per-voice VCA FLOOR the envelope rides on top of: gain = base + (1-base)·env per ACTIVE voice — base=1 (default) means the env does nothing (full gain), base=0 is pure ADSR (silent between notes), 0.5 floors at 0.5 and rises to 1.0 at the env peak. For the raw-VCO case (nothing patched) the env is idle so the gain is exactly BASE VOL, so the default of 1 is the legacy continuous drone (byte-identical) and BASE VOL doubles as the raw-VCO level. In poly mode each lane's gate edge drives its own envelope (one per voice, soft/click-safe retrigger), and the mix is normalized over ACTIVE voices (1/sqrt(N)) so a sustain=0 held note doesn't pump and a releasing tail doesn't pop. The ADSR + BASE VOL params read live (continuous k-rate) across all stages. Edge detection is block-rate (retrigger granularity floor ≈ one audio block); connectedness (poly/trigger patched) is read from the live patch edges, not bus presence. Pure deterministic field/slice DSP in cube-dsp.ts is reused verbatim by node-ART AND by the card's 3D render, and the surface-height scan runs OFF the audio thread (computed on the main thread, posted to the worklet) so sweeping params never drops the audio out. v1 is audio-only; a cross-domain viz_out video raster is a planned follow-up.

outputs

L audio
R audio
sync audio
video_out mono-video

inputs

pitch cv
poly polyPitchGate
trigger gate
slice_y cv
slice_rx cv
slice_ry cv
slice_rz cv
morph_fc cv
connect cv
connect_strength cv
crush cv
space_crush cv
space_diffuse cv
fold_cv cv
tune cv

params

tune -36..36st
fine -100..100¢
morph_fc 0..1
connect 0..1
connect_strength 0..1
crush 0..1
space_crush 0..1
space_diffuse 0..1
fold 0..1
spread 0..1
slice_y 0..1
slice_rx -3.1416..3.1416
slice_ry -3.1416..3.1416
slice_rz -3.1416..3.1416
level 0..2
attack 0.001..5s
decay 0.001..5s
sustain 0..1
release 0.001..5s
base_vol 0..1
wrap 0..1
material 0..1
view_zoom 0.3..3
view_rot_x -3.1416..3.1416
view_rot_y -3.1416..3.1416
view_rot_z -3.1416..3.1416
screen_on 0..1

example js

spawn('cube', 'x');
set('x', 'tune', 0);
patch('x.L', 'x.pitch');

doom doom

DOOM runs the 1993 shareware game compiled to WebAssembly (doomgeneric) and renders each peer's OWN first-person view to the video 'out' jack, with the WASM SFX mixer bridged to stereo audio outputs. It is a host-only, single-node module (maxInstances 1, ownerOnly): the rack owner adds one DOOM card, clicks the surface to download/cache the ~4 MB shareware WAD and boot the WASM, then either plays solo or hosts a true-lockstep co-op netgame that up to 3 rack-mates one-click hot-join (4 marines total — the owner is player 1) — every peer runs its own runtime and the deterministic tic stream keeps all marines byte-identical. Play with the keyboard once the card is focused (arrows move/turn, Ctrl/F fire, Space uses doors), or drive it from CV: the per-slot gate inputs p1..p4 act as held keypresses (movement/fire/strafe/menu) so an LFO, sequencer, or GAMEPAD can play the marine — each peer applies only its own seated slot's group (own-slot rule), and in single-player only the p1 group is live. Two extra cheat gates inject IDDQD (god mode) and IDKFA (full arsenal) on a rising edge. Game events feed the audio domain as 10 ms gate pulses — per-player weapon fire, door opens, the any-monster kill plus per-monster-type kills, and per-player deaths — so DOOM's action can trigger synths, drums, or a SCOREBOARD. The card's load button, the Single Player / Host Multiplayer start choice, the guest Join button, the click-to-capture-keyboard hint, and the arbiter's New Game dialog (mode/skill/episode/map custom dropdowns + a Launch / Next Map button) are UI controls, not patchable params. There is no host framebuffer mirror — an unjoined spectator simply shows the dark attract screen until it JOINS.

outputs

out video
audio_l audio
audio_r audio
evt_kill gate
evt_door gate
evt_gun_p1 gate
evt_gun_p2 gate
evt_gun_p3 gate
evt_gun_p4 gate

inputs

iddqd_in cv
idkfa_in cv

params

audioGain 0..2
fillMode 0..1
cv_iddqd_in 0..1
cv_idkfa_in 0..1

example js

spawn('doom', 'x');
set('x', 'audioGain', 1);
patch('x.out', 'x.iddqd_in');

drummergirl drummergirl

Gate-triggered drum voice (kick / snare / hat morph).

outputs

audio audio

inputs

gate gate
pitch cv
tone cv
shape cv
volume cv
decay cv

params

pitch -36..36semi
tone 0..1
shape 0..1
volume 0..2
decay 0.001..0.5s

example js

spawn('drummergirl', 'x');
set('x', 'pitch', 0);
patch('x.audio', 'x.gate');

dx7 dx7

Pure-TypeScript 6-operator DX7-style FM synthesizer. 32 algorithms, 5-voice polyphony via the polyPitchGate cable, bundled bank of factory-inspired patches (E.PIANO 1, BASS 1, HARMONICA, STRINGS 1, MARIMBA, etc.), and a .syx file picker for loading custom 32-voice cartridge dumps (in-memory only). On top of the six per-operator DX7 envelope generators, a per-voice master OUTPUT-VCA ADSR (Attack / Decay / Sustain / Release) gives a player-dialable amplitude swell / long-release without editing the SYX: one envelope per voice multiplies the summed-carrier output, gated by the same note-on/note-off as the operator EGs (soft/click-safe retrigger). Defaults are ~pass-through (fast attack, full sustain, fast release) so loaded patches sound identical until you touch the master ADSR; a long master release now outlives operator-EG silence (a voice frees only once both the operator EGs and the master amp envelope have faded). NOT a Plaits-backed implementation — see .myrobots/plans/dx7-and-polyphony.md for the design rationale.

outputs

out audio

inputs

poly polyPitchGate
pitch_cv cv
gate gate

params

algorithm 1..32
voiceCount 1..5
level 0..2
transpose -24..24st
attack 0.001..5s
decay 0.001..5s
sustain 0..1
release 0.001..5s

example js

spawn('dx7', 'x');
set('x', 'algorithm', 5);
patch('x.out', 'x.poly');

elements elements

Modal / physical-modeling voice (Mutable Instruments Elements archetype, Émilie Gillet, 2014, MIT-licensed). Faithful TypeScript port of the eurorack/elements/ DSP. An EXCITER section feeds a modal RESONATOR: BOW (FLOW noise + bow-table friction band-waveguide), BLOW (filtered noise through a waveguide TUBE when pushed past unity) and STRIKE (mallet impulse / particle cloud / plectrum, meta-morphed by MALLET) each have level + timbre. The RESONATOR is a bank of up to 64 parallel state-variable bandpasses: GEOMETRY stretches the partials (harmonic→inharmonic/bell), DAMPING sets Q/decay, BRIGHTNESS biases high-mode energy, POSITION drives a cosine-oscillator pickup comb with a slow-LFO second tap for the stereo aux channel. SPACE blends raw exciter → dry → reverb and widens the stereo spread. PITCH is V/oct, NOTE a ±60-semitone offset, STRENGTH an accent. Outputs main / aux (stereo). FAITHFUL: exciters, modal resonator, tube, envelope, stereo mixdown + soft-limit. SIMPLIFIED: SPACE reverb tail is a compact FDN-lite (not MI reverb.h); sample-ROM exciters use synthetic equivalents; STRING resonator model deferred.

outputs

main audio
aux audio

inputs

in audio
strike_in audio
pitch pitch
gate gate
note_cv cv
env_cv cv
bowlvl_cv cv
bowtim_cv cv
blowlvl_cv cv
blowmeta_cv cv
blowtim_cv cv
strklvl_cv cv
strkmeta_cv cv
strktim_cv cv
geom_cv cv
bright_cv cv
damp_cv cv
pos_cv cv
space_cv cv
strength_cv cv

params

note -60..60st
envShape 0..1
bowLevel 0..1
bowTimbre 0..1
blowLevel 0..1
blowMeta 0..1
blowTimbre 0..1
strikeLevel 0..1
strikeMeta 0..1
strikeTimbre 0..1
geometry 0..1
brightness 0..1
damping 0..1
position 0..1
space 0..2
strength 0..1

example js

spawn('elements', 'x');
set('x', 'note', 0);
patch('x.main', 'x.in');

foxy foxy

Hybrid audio-visual module that hides a whole signal chain in one box: a miniature SWOLEVCO drives an internal RASTERIZE (audio painted as a drifting raster), which is downsampled to 256×256 and run through a simplified RUTTETRA "XYZ" forward-scatter scope; the XYZ height field is converted in realtime into an animated wavetable (64 frames × 256 samples, throttled to ~24 Hz) fed to an internal WAVECEL wavetable VCO. The on-card 3D wavetable display visibly animates as the field evolves. Exposes WAVECEL's full control + IO surface (tune/fine/morph/spread/fold; pitch/fm + morph_cv/spread_cv/fold_cv; out_l/out_r + scope_out + wave3d_out) plus the mini-SWOLEVCO source controls and the XYZ shape/displacement knobs. The video stages run CPU-side on the main thread (no GL inside the audio node); only the WAVECEL stage is a real worklet.

outputs

out_l audio
out_r audio
scope_out mono-video
wave3d_out video
combined_out video

inputs

pitch pitch
fm audio
morph_cv cv
spread_cv cv
fold_cv cv

params

tune -36..36st
fine -100..100¢
morph 0..1
spread 1..5
fold 0..1
src_tune -36..36st
src_fine -100..100¢
src_timbre 0..1
src_symmetry 0..1
src_fold 0..1
src2_tune -36..36st
src2_fine -100..100¢
src2_timbre 0..1
src2_symmetry 0..1
src2_fold 0..1
src3_tune -36..36st
src3_fine -100..100¢
src3_timbre 0..1
src3_symmetry 0..1
src3_fold 0..1
xyz_xshape 0..1
xyz_yshape 0..1
xyz_ydisp -1..1
xyz_warp 0..1
xyz_zheight 0..1
xyz_zoom 1..8
xyz_smooth 0..1
sync_mode 0..?
freezeRasterA 0..1
freezeRasterB 0..1
freezeRasterC 0..1
freezeTable 0..1
gen_mode 0..?

example js

spawn('foxy', 'x');
set('x', 'tune', 0);
patch('x.out_l', 'x.pitch');

gibribbon gibribbon

GIBRIBBON (video) — a Vib-Ribbon spiritual successor rendered with DOOM shareware-WAD sprites. A single white vector "ribbon"/ground line scrolls right→left on black (Vib-Ribbon's exact line-art grammar: the ground dips into a pit V for a LOOP, rises into a hump for a JUMP), while imp (TROO*) and zombie/former-human (POSS*) enemies — REAL sprites decoded from the same DOOM1.WAD the DOOM module uses — ride the ribbon in from the right. The player character is the green DOOM marine (PLAY*). An overhead ABXY prompt strip shows the button each upcoming event needs. FOUR events map to the four ABXY buttons: LOOP (A), JUMP (B), IMP SPAWN (X), ZOMBIE SPAWN (Y); a correct, in-window press clears the obstacle (marine loops/jumps) or fires-and-kills the enemy (it plays its DOOM death animation). Missing an event degrades the marine down a DOOM-flavoured health ladder (super → healthy → wounded → critical → GAME OVER); clean streaks recover rungs and reach a SUPER state. Inputs: cv1..cv4 (modsignal — drive event GENERATION from slow Synesthesia envelopes; each channel maps to one event kind), clock (the 1× scroll/tempo tick), gate (the beat — biases which CV channel spawns), x + y (joystick axes), and four ABXY button gates a / b / x_btn / y_btn (named to disambiguate from the x/y axes). Outputs: out (video), evt_hit / evt_miss / evt_fire / evt_kill / evt_gameover (10 ms gate pulses), and health_cv (marine vitality 0..1). Event generation is a PURE deterministic function of the inputs (gibribbon-events.ts) with all CV→event thresholds in a single tunable GIB_TUNING block; sprite extraction is a PURE WAD picture/PLAYPAL decoder (wad-sprites.ts) run at load time. DOOM1.WAD stays gitignored + fetched like the DOOM module; without it the game falls back to line-art placeholder figures so it still plays. DOOM shareware terms apply (same as the DOOM module).

outputs

out video
evt_hit gate
evt_miss gate
evt_fire gate
evt_kill gate
evt_gameover gate
health_cv cv

inputs

cv1 modsignal
cv2 modsignal
cv3 modsignal
cv4 modsignal
clock gate
gate gate
x modsignal
y modsignal
a gate
b gate
x_btn gate
y_btn gate

params

cv1 0..1
cv2 0..1
cv3 0..1
cv4 0..1
clock 0..1
gate 0..1
autoplay 0..1
axis_x -1..1
axis_y -1..1
btn_a 0..1
btn_b 0..1
btn_x 0..1
btn_y 0..1

example js

spawn('gibribbon', 'x');
set('x', 'cv1', 0);
patch('x.out', 'x.cv1');

hypercube hypercube

4D tesseract oscillator — a sibling of CUBE that extends the 3D wavetable-navigator field into a FOURTH dimension. On top of CUBE's FLOOR / WALL / CEILING wavetables it adds a fourth "HOLO" wavetable (default basic-shapes, the same as floor/ceiling, so a fresh HYPERCUBE is benign) and an ALPHA axis (0..1) — the slice's 4th-dimension (w) coordinate. The 2D slice is still ray-marched through a 3D field, but ALPHA selects WHICH 3D field by blending the field's occupancy toward the HOLO cell: f4 = (1-alpha)·f3 + alpha·dH, a genuine tesseract cross-section (NOT a 4D march — one extra occ() per step). ALPHA is a continuous, CV-able morph defaulting to 0, where HYPERCUBE collapses byte-for-byte to a plain 3-table CUBE render (off = identity). Everything else mirrors CUBE: MORPH connects the wall to floor/ceiling; CONNECT morphs the connecting curve circle↔V; the slice navigates with Y + Rot X/Y/Z; MATERIAL switches SMOOTH↔HARD; CRUSH is a 3D bitcrush; WRAP toggles silent-outside vs mirror-fold; FOLD is a West-coast wavefolder; a V/oct pitched oscillator (pitch + tune/fine) with stereo L/R SPREAD on SEPARATE L and R output ports; view-only Zoom + Rot X/Y/Z orbit the WebGL2 visualization. CV inputs cover slice Y/rotation, morph, connect, crush, fold, ALPHA, and tune. The pure deterministic field/slice DSP is shared with CUBE in cube-dsp.ts (the HOLO/ALPHA additions are no-ops when absent) and the surface-height scan runs OFF the audio thread so sweeping ALPHA never drops the audio out.

outputs

L audio
R audio
video_out mono-video

inputs

pitch cv
slice_y cv
slice_rx cv
slice_ry cv
slice_rz cv
morph_fc cv
connect cv
crush cv
fold_cv cv
alpha cv
tune cv

params

tune -36..36st
fine -100..100¢
morph_fc 0..1
connect 0..1
crush 0..1
fold 0..1
alpha 0..1
spread 0..1
slice_y 0..1
slice_rx -3.1416..3.1416
slice_ry -3.1416..3.1416
slice_rz -3.1416..3.1416
level 0..2
wrap 0..1
material 0..1
view_zoom 0.3..3
view_rot_x -3.1416..3.1416
view_rot_y -3.1416..3.1416
view_rot_z -3.1416..3.1416
screen_on 0..1

example js

spawn('hypercube', 'x');
set('x', 'tune', 0);
patch('x.L', 'x.pitch');

inwards inwards

A procedural source that synthesizes a field of concentric rings centered on the frame, with their phase scrolling inward over time so the bands appear to zoom toward the center (positive Speed) or outward (negative). The shader takes the radial distance from center, multiplies it by Density to set how many rings fit on screen, then subtracts time*Speed to animate the sweep; an abs(sin) wave is soft-banded by Thickness to render alternating bright and dark grayscale rings. There is no video input — it generates its image entirely from time and the three params, so it works without camera permissions. Use it as a hypnotic radial backdrop or a moving mask/wipe source: patch an LFO or envelope into Speed for pulsing zoom, or sweep Density for a tunnel-breathing effect.

outputs

out mono-video

inputs

speed cv
density cv
thickness cv

params

speed -2..2
density 1..50
thickness 0..1

example js

spawn('inwards', 'x');
set('x', 'speed', 0);
patch('x.out', 'x.speed');

kick drum kickdrum

Layered stereo kick VOICE — the "shake the house" deep-bass kick (own-code; build plan .myrobots/plans/kick-drum-voice-2026-07-01.md). Three DECOUPLED generator layers so depth and punch live on orthogonal knobs: a pure-sine SUB (Tune 20–120 Hz, gentle slow settle, long Sub Dec ≤ 800 ms — the air-moving pulse), a band-limited BODY one octave up (fast downward P Amt/P Time pitch sweep — the 909 "dooo" chest-thump — plus Shape sine→tri→rect morph and a Tension amplitude→pitch glide), and a filtered-noise CLICK transient (Click len / Clk Tone / Clk Lvl). The summed layers run a serial bus: DRIVE saturation with a single HARD character switch (clean-warm vs aggressive, owner-decided instead of a mode menu), an own-code 3-band kick EQ (Sub/Body/Atk EQ bells + a spectral Tilt), and the TRANSLATE harmonic exciter that synthesizes the sub's 2nd/3rd/4th harmonics so a 40–50 Hz fundamental still reads deep on laptop/phone speakers. DYNAMICS: a threshold-free transient shaper (Attack/Sustain), a GLUE compressor whose detector is sidechain-HPF'd ~100 Hz so the sub never pumps it, and a CEILING soft-clip that true-peak-bounds the voice so it can sit hot. Stereo stage: everything <120 Hz is strictly MONO (phase-safe, full excursion); Width spreads only the upper body/click band (M/S) — separate audio_l/audio_r outs with stereoPairs auto-pairing. Inputs: trigger_in (edge-trigger STRIKE — phases reset, envelopes fire), accent_in (per-hit 0..1 CV latched at the strike edge, scaling sweep depth + level), pitch_cv (1V/oct, transposes the whole voice), choke_in (level-sensitive gate — damps while high through a short ramp, releases on the falling edge). Level spans −24..+12 dB (the deliberate headroom fix vs chowkick's −60..0), guarded by the internal ceiling. Wide 3u banded card: SUB·BODY·CLICK / DRIVE·EQ·TRANSLATE / DYNAMICS·STEREO·OUT. Ships as a clean-deep club kick by default; later DSP phases land inside the worklet without changing this contract (Phase 1 renders SUB+BODY, L=R).

outputs

audio_l audio
audio_r audio

inputs

trigger_in gate
accent_in cv
pitch_cv cv
choke_in gate

params

tune 20..120Hz
pitch_amt 0..48st
pitch_time 5..120ms
tension 0..0.6
sub_decay 50..800ms
body_decay 20..400ms
click_len 2..60ms
sub_level 0..1
body_level 0..1
click_level 0..1
body_shape 0..1
click_tone 500..6000Hz
drive 0..1
hard 0..1
translate 0..1
sub_eq -12..12dB
body_eq -12..12dB
attack_eq -12..12dB
tilt -1..1
attack -1..1
sustain -1..1
glue 0..1
ceiling 0..1
width 0..1
level -24..12dB

example js

spawn('kickdrum', 'x');
set('x', 'tune', 50);
patch('x.audio_l', 'x.trigger_in');

lines lines

LINES is a procedural mono-video source that renders soft-edged parallel stripes whose orientation, count, thickness, and scroll you dial in. The shader rotates the UV space by Orient (0 = horizontal lines, 1 = vertical, anything between = diagonal), then computes wave = abs(sin(2pi * Amp * (position + Phase))) along that axis and lights up bright bands wherever the wave falls under the Thickness threshold, with a smoothstep soft edge straddling it. The result is a grayscale grating written equally to all three RGB channels (alpha 1). The pattern auto-scrolls on its own (Phase advances steadily over time, time * 0.15 wrapped to 0..1) so it is visibly alive without touching a knob; your Phase value adds on top of that drift. Patch the OUT into an OUTPUT screen, a video mixer, or a colorizer; use it as a structural test pattern or as a moving modulation texture for downstream video modules.

outputs

out mono-video

inputs

fm mono-video
orient cv
amp cv
thickness cv
phase cv

params

orient 0..1
amp 0.5..50lpx
thickness 0..1
phase 0..1
fmDepth 0..1

example js

spawn('lines', 'x');
set('x', 'orient', 0);
patch('x.out', 'x.fm');

loopback loopback

The BROWSER VIEWPORT as a video source (LOCAL ONLY). Zero inputs, one video OUT whose contents are what you currently SEE in this tab — the visible canvas pane — so you can feed LOOPBACK -> RECORDERBOX to record your viewport, or -> any effect for live self-referential feedback. Mechanism: the card captures the current tab via the Screen Capture API (getDisplayMedia({ video: { displaySurface: "browser" }, preferCurrentTab: true, selfBrowserSurface: "include" }) — the Start capture button is the required user gesture), runs it in a hidden <video>, and the engine samples each frame into a WebGL2 texture exactly like CAMERA; a crop step then windows the tab frame down to the app viewport element's on-screen rectangle (measured per frame, pushed to the engine as LOCAL per-viewer state — never synced) so OUT is just the active viewport, letterbox-fit into the engine frame (black bars, never cropping edges away). Because the preview shows the tab it is captured from, an on-card preview is intentionally recursive (a video-feedback tunnel). Params: gain (0..2 RGB multiplier), crop (viewport vs whole-tab, ON by default). Capture needs a gesture and can be stopped from the browser's share bar (the card returns to idle with a re-capture button); getDisplayMedia is feature-detected, degrading to a disabled unsupported state where the API is missing.

outputs

out video

params

gain 0..2
crop 0..1

example js

spawn('loopback', 'x');
set('x', 'gain', 0);

macrooscillator macrooscillator

Plaits-style macro oscillator (Mutable Instruments archetype). Clean-room pure-TypeScript implementation — not a port of Plaits' C++ source (see PR #27 for the closed emscripten attempt). First-slice scope ships two synthesis models behind the three canonical macros (HARMONICS / TIMBRE / MORPH): (0) virtual analog (VA) — morphing saw→square→triangle PolyBLEP wave + detuned partner (HARMONICS = detune amount) + wavefolder (TIMBRE = fold amount); (1) waveshape — sine through a morphable wavefolder/tanh-waveshaper (TIMBRE = drive, MORPH = wavefolder↔tanh, HARMONICS = sub-octave mix). PITCH input is V/oct; NOTE param is a ±60-semitone offset on top. TRIG resets phase on rising edge for percussive attack alignment. OUT is the level-scaled main output; AUX is a per-model raw tap (unfolded sub-octave triangle in VA, pre-distortion body in waveshape). More models (granular, FM, chord, speech, kick/snare/hat, modal, etc.) land in follow-up PRs.

outputs

out audio
aux audio

inputs

pitch pitch
trig gate
model_cv cv
note_cv cv
harm_cv cv
timb_cv cv
morph_cv cv
level_cv cv

params

model 0..?
note -60..60st
harmonics 0..1
timbre 0..1
morph 0..1
level 0..1

example js

spawn('macrooscillator', 'x');
set('x', 'model', 0);
patch('x.out', 'x.pitch');

mandelbulb mandelbulb

A WebGL2 ray-marched 3D Mandelbulb fractal source that doubles as an audio oscillator. A single full-screen-quad fragment shader marches the power-8 Mandelbulb distance estimate, shades the hit surface with finite-difference normals, diffuse + Phong specular and a soft shadow, tints it with the Hue palette, and emits the render on video_out (4:3, ray-marched internally at half engine resolution — 512x384 at the 1024x768 default — and LINEAR-upscaled). An orbit camera (Zoom dolly + Rot X pitch / Rot Y yaw) frames the bulb; Power morphs the fractal shape and Detail sets the iteration budget (higher = crisper, costlier). Turn SLICE on to bridge into audio: a fixed-size plane (camera-independent) is marched through the bulb's distance field to read its cross-section as a 256-sample wavetable, played as an oscillator on audio_out and shown as a second on-card readout with a draggable yellow select box. Usage: patch a slow LFO into rotate_y_cv (or just leave SPIN on) for a tumbling fractal, modulate power_cv for shape-morphing, and enable SLICE to play the bulb's geometry as an evolving waveform.

outputs

video_out mono-video
audio_out audio

inputs

zoom_cv cv
rotate_x_cv cv
rotate_y_cv cv
power_cv cv
detail_cv cv
hue_cv cv
slice_y_cv cv
slice_rx_cv cv
slice_ry_cv cv
slice_rz_cv cv

params

zoom 0.3..3
rotate_x ?..?
rotate_y ?..?
power 1..12
detail 4..30
hue 0..1
autospin 0..1
screen_on 0..1
slice 0..1
slice_y ?..?
slice_rx ?..?
slice_ry ?..?
slice_rz ?..?

example js

spawn('mandelbulb', 'x');
set('x', 'zoom', 0);
patch('x.video_out', 'x.zoom_cv');

marbles marbles

Random sampler / clock generator (Mutable Instruments Marbles archetype, Émilie Gillet, MIT-licensed). Clean-room TypeScript port of the eurorack/marbles/ DSP. The T-section (t1 / t2 gates) generates clocked random gates via one of six models — COIN (complementary Bernoulli), CLUSTERS, DRUMS (18 built-in 8-step patterns), INDEP (independent Bernoulli), 3-STATE, MARKOV — with a déjà-vu loop that locks the random stream into a repeating pattern (RATE / T BIAS / T JITTER / DÉJÀ VU / LENGTH). The X-section (x1 / x2 / x3 CV) draws random voltages shaped by SPREAD (variance), X BIAS (mean), and STEPS (quantization amount + STEPS-knob portamento), snapped through a weight-aware variable-resolution quantizer onto one of six scales (C major / C minor / Pentatonic / Pelog / Raag Bhairav / Raag Shri), with its own déjà-vu loop shared across the three X channels via pseudo-random hash shifts. clk is the master clock. CV outs are ±1 (= ±5V). Beta-distribution sampling is approximated analytically vs the firmware's precomputed table; the déjà-vu / Markov / quantizer / lag logic is ported line-for-line.

outputs

t1 gate
t2 gate
x1 cv
x2 cv
x3 cv
clk gate

inputs

rate_cv cv
tmodel_cv cv
tbias_cv cv
tjitter_cv cv
dejavu_cv cv
length_cv cv
spread_cv cv
xbias_cv cv
steps_cv cv
xdejavu_cv cv
scale_cv cv

params

rate -60..60st
t_model 0..?
t_bias 0..1
t_jitter 0..1
deja_vu 0..1
length 1..16
pw_mean 0..1
spread 0..1
x_bias 0..1
steps 0..1
x_deja_vu 0..1
x_length 1..16
scale 0..?

example js

spawn('marbles', 'x');
set('x', 'rate', 0);
patch('x.t1', 'x.rate_cv');

meowbox meowbox

Gate-triggered cat-vocal synth voice (formant bank + harmonic + noise excitation).

outputs

L audio
R audio

inputs

gate gate
pitch pitch
morph cv
decay cv
level cv

params

pitch -36..36semi
morph 0..1
decay 0.05..2s
level 0..2

example js

spawn('meowbox', 'x');
set('x', 'pitch', 0);
patch('x.L', 'x.gate');

midi lane midiLane

MIDI LANE — a per-channel "instrument bus" demux for a hardware MIDI sequencer (Reliq, Cre8audio Programm, Empress ZOIA, or any class-compliant USB-MIDI device). DAW-style workflow: assign each track of your sequencer to its own MIDI channel, then drop one MIDI LANE per instrument and point each at that track's channel — multi-timbral = several lanes, like several MIDI-CV-BUDDYs but channel-aware and richer. Each lane demuxes its channel into the CV/gate the rack speaks: pitch_cv (V/oct, 0V = C4 = MIDI 60, pitch-bend summed at ±2 st), gate (HIGH while any key on the lane is held; with RETRIG, dips one audio block on each new note-on so a downstream ADSR re-fires), velocity_cv (0..1), plus TWO learn-assignable CC taps (cc_a / cc_b → 0..1 CV — hit LEARN, wiggle a CC, done; these subsume the per-track CC-modulation lane and can drive audio params OR video params via the cross-domain bridge), plus ONE by-note-number drum gate (note_gate fires on a card-selected MIDI note, default GM kick = 36 — the Programm/Reliq ch10 drum-router pattern generalized via configuration, not 8 fixed ports). MONO mode is monophonic with three voice-priority modes (LAST / LOW / HIGH); POLY mode adds a 10-channel polyPitchGate output (poly) so a chord on the lane plays a polyphonic synth (cartesian / dx7). The SAME outputs drive VIDEO modules for free: a gate or cv handle cabled into ACIDWARP.scene_cv / DOOM.cv_pN fires visuals with no synth voice — the engine's cross-domain CV/gate→video bridge needs no special "video gate" port. Uses the browser's built-in Web MIDI API (no third-party library, no native bridge); click "Connect MIDI…" once per origin to grant access. Main-thread plumbing (ConstantSource-per-output, 2 ms scheduling lookahead) identical to MIDI-CV-BUDDY, whose note logic it reuses verbatim. v1 surfaces a single-channel-or-ALL selector on the card (the engine supports a multi-channel Set under the hood for a future multi-select). End-to-end Web MIDI latency is the honest ~5-10 ms main-thread path.

outputs

pitch_cv cv
gate gate
velocity_cv cv
cc_a cv
cc_b cv
note_gate gate
poly polyPitchGate

example js

spawn('midiLane', 'x');

midi-cv-buddy midiCvBuddy

Hardware MIDI controller → pitch + gate + velocity CV. Uses the browser's built-in Web MIDI API (no third-party library) and converts incoming note-on / note-off / pitch-bend messages into three ConstantSourceNode outputs: pitch_cv (V/oct, 0V = C4 = MIDI 60, with pitch-bend summed in at the MIDI-standard ±2 semitones), gate (0/1), and velocity_cv (0..1). Monophonic with three voice-priority modes (LAST = newest key wins, the conventional default; LOW = lowest key, classic mono-bass behavior; HIGH = highest), a RETRIG toggle that drops the gate to 0 for one audio block between successive note-ons (so a downstream ADSR re-fires) versus legato (gate stays high through key changes), an ALL/1..16 channel filter, and a device-picker dropdown that hot-plugs when controllers connect/disconnect. The user clicks "Connect MIDI…" once per origin to grant permission; subsequent reloads reuse the grant. End-to-end latency is honest about the Web MIDI main-thread path (~5-10 ms typical on Chrome/macOS); event.timeStamp is mapped to ctx.currentTime + a 2 ms lookahead so scheduling lands at the start of the next audio block rather than mid-block.

outputs

pitch_cv cv
gate gate
velocity_cv cv

example js

spawn('midiCvBuddy', 'x');

midiclock midiclock

Hardware MIDI transport bridge. Locks to a MIDI device and surfaces the System Real-Time stream as gate/CV: clock (gate) at a user-selectable subdivision — 24=quarter (default, patch directly into TIMELORDE.clock to slave it to the external transport), 12=eighth, 6=sixteenth, 3=32nd, 1=raw 24 PPQN; run (cv, 0/1) tracks transport state; midistart + midistop fire one-shot gates on MIDI Start (0xFA) and Stop (0xFC). Continue (0xFB) raises run without re-firing midistart, so downstream loops resume in place. Channel-voice messages are ignored — pair with MIDI-CV-BUDDY for note/velocity. Same Web MIDI / ConstantSource / 2 ms lookahead plumbing as MIDI-CV-BUDDY.

outputs

clock gate
run cv
midistart gate
midistop gate

example js

spawn('midiclock', 'x');

milkdrop milkdrop

MILKDROP — a Winamp/Milkdrop music visualizer (wrapping the open-source butterchurn WebGL2 engine + ~20 curated classic presets) as a fully CV-instrumented video SOURCE. Patch audio into AUDIO and the visuals react (the tap is inaudible). The novel part: butterchurn drives nearly all preset motion from three audio scalars — bass/mid/treb — and MILKDROP lets a cable REPLACE any of them. Patch CV into BASS/MID/TREB to drive that band from the cable instead of the live audio (an unpatched band still follows the audio); REACT scales all three. SPEED time-warps the engine clock (clamped at 0), PRESET selects the active preset (quantized knob/CV), MORPH sets the crossfade seconds, and a rising edge on NEXT advances presets hands-free. OUT is a normal downstream video texture (route into a mixer / keyer / OUTPUT). The card has a live preview + preset name/index readout + RCT/SPD/PST/MPH knobs, and hide-controls turns it into a resizable monitor. The butterchurn engine lives in node_modules (not vendored into the WebGL attest basis) and the preset pack loads behind a dynamic import() as a separate chunk. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks, #767).

outputs

out video

inputs

audio audio
bass cv
mid cv
treb cv
reactivity cv
speed cv
presetSelect cv
morph cv
next gate

params

bass 0..2
mid 0..2
treb 0..2
reactivity 0..2
speed 0..2
presetSelect 0..?
morph 0..8
nextTrig 0..1

example js

spawn('milkdrop', 'x');
set('x', 'bass', 0);
patch('x.out', 'x.audio');

nibbles nibbles

A playable QBasic-Nibbles snake game rendered as a patchable video source. The classic snake roams an 80x50 grid (CPU-rasterised to a 320x200 frame with a gentle CRT scanline darken) eating one pellet at a time, growing its body, and dying on a wall or self collision. Drive it two ways: click the card to focus it and steer with the arrow keys, or flip AUTO on to let the built-in greedy bot self-play (it walks toward the pellet, avoiding its own tail, with no foresight so it eventually traps and dies — then auto-restarts). The game advances at the rate set by Tick. Beyond the video frame, the snake's life becomes control voltage and sound: gate pulses fire on pellet/death/direction-change, a length CV tracks how long the snake has grown, and two square-wave audio outs are pitched by the snake's length (length 4 = A2/110 Hz, every +12 length = +1 octave). Patch the gates into envelopes/triggers and the length CV into pitch or filter cutoff to sonify the game. The card also has a RESET button, a 1x-4x zoom button, and a live LEN readout (a dagger appears when the snake is dead). The card's game screen is resizable: the on-card scale button cycles the 320x200 source through 1x / 2x / 3x / 4x zoom (image-rendering: pixelated, so it stays crisp); the knobs, buttons, and patch jacks stay fixed-size while only the screen grows.

outputs

out video
pellet gate
death gate
dir_change gate
length_cv cv
snake audio
gated audio

params

auto 0..1
tick_ms 40..200

example js

spawn('nibbles', 'x');
set('x', 'auto', 0);

noise noise

Basic noise source. Three independent audio outputs — WHITE (full-spectrum), PINK (1/f, -3 dB/oct via Voss-McCartney), BROWN (1/f², -6 dB/oct via leaky-integrated white). All outputs share a single LEVEL knob. No CV inputs.

outputs

white audio
pink audio
brown audio

params

level 0..1

example js

spawn('noise', 'x');
set('x', 'level', 0.5);

numpad+ numpadPlus

Numpad-driven 4-layer × 16-step sequencer + live keyboard. Each numpad note key fires the active layer's pitch+gate immediately AND, when REC ARM (one-pass record on next play-from-start) or OVERDUB (always-recording) is on, writes the note to the nearest step on the active layer. Default keymap: 1=C, 2=C#, 3=D, 4=D#, 5=E, 6=F, 7=F#, 8=G, 9=G#, 0=A, /=A#, *=B; Numpad+ held = next note +1 octave, Numpad- = -1 octave. Octave 0-8 nudged via on-card arrows. CV inputs: clock (rising-edge external clock — internal BPM ignored while patched) + layer (CV value 0..1 selects active layer, otherwise the activeLayer param wins). CV outputs: l1_pitch / l1_gate ... l4_pitch / l4_gate (8 outputs total) so a patch can route each layer to its own downstream synth — basically a 4-track sequencer. When this module exists in the rack its keyboard listener captures Numpad* event.codes + preventDefault so other modules can't see the keys.

outputs

l1_pitch pitch
l1_gate gate
l2_pitch pitch
l2_gate gate
l3_pitch pitch
l3_gate gate
l4_pitch pitch
l4_gate gate
poly polyPitchGate

inputs

clock gate
layer cv

params

bpm 30..300
isPlaying 0..1
activeLayer 0..3
recArm 0..1
overdub 0..1
octave 0..8
poly 0..1

example js

spawn('numpadPlus', 'x');
set('x', 'bpm', 120);
patch('x.l1_pitch', 'x.clock');

outlines outlines

OUTLINES — stateful particle video generator (LZX-style primitive source; formerly CIRCLES, renamed when the SHAPE selector landed). A GATE event (or the internal RATE clock) spawns a SHAPE at a SEEDED-random position in a 1024-px field; each shape latches its diameter / vector / speed / decay / SHAPE at spawn and moves in that direction, BOUNCING when its CENTER-POINT hits a wall (the velocity reflects; no edge/radius collision math for the WALL, so a fat shape may briefly overhang). SHAPE picks one of six forms — circle, triangle, square, pentagon, hexagon, octagon — each polygon a REGULAR N-gon inscribed in the diameter (every vertex on the circle of radius d/2 — the circumradius), so all six share one bounding-circle radius (d/2) and the COLLIDE math is unchanged across shapes. ROTATION is a LIVE GLOBAL bipolar spin: knob CENTER = no rotation, left extreme = fast CCW, right extreme = fast CW; every live shape shares one rotation angle that accumulates by that angular velocity each frame, so the whole field spins coherently and the spin shows up consistently in the rendered geometry AND in every output (the rotated polygon vertices drive the overlap-count the outputs read; a circle is rotation-invariant so only the 5 polygons visibly turn). With the COLLIDE gate HIGH, shapes ALSO bounce off EACH OTHER: a bounding-circle elastic collision — two shapes collide when the distance between their CENTERS ≤ (r1 + r2), i.e. their circumcircles touch (unlike the center-based wall bounce, this uses the radii), and an equal-mass ELASTIC response swaps the velocity components along the center-to-center normal and separates the pair so they don't stick (each keeps its independent latched SPEED as far as elastic physics allows). Gate LOW / unpatched → shapes PASS THROUGH each other (the default). COLLIDE is a LIVE GLOBAL mode (read every frame), NOT spawn-latched. The inter-shape pass is O(n²) over the active list, bounded by the 200-shape cap (~10k pair tests/frame). Every per-shape property is LATCHED at spawn from the live knob+CV — crucially SPEED and SHAPE: a shape integrates from its OWN latched velocity (and keeps its own latched form) for its whole life, so turning SPD or SHAPE after a shape exists affects ONLY newly-spawned shapes, never the ones already flying. Model: a JS list of active shapes {x,y,vx,vy,diameter,decayS,ageS,alpha,shape,sides,baseAngle} integrated on the engine rAF. Controls — D: DIAMETER (5..270 px, the circumdiameter); V: spawn VECTOR ANGLE (full range = 0..360°, every angle reachable); SPD: SPEED (0 = static scatter, up to 300 px/s ≈ crosses the field in ~3 s; latched independently per shape); DECAY: per-shape FADE-OUT time — 0 = NO decay (the shape PERSISTS, the static-field case, FIFO-capped) ramping up to a 10 s fade where the shape's alpha ramps 1 → 0 and it is removed; SHAPE: the 6-way form selector (circle / triangle / square / pentagon / hexagon / octagon), quantised + latched per shape at spawn; ROT: the bipolar live-global spin (center = still, ± = CW/CCW); RATE: KNOB-ONLY internal clock (0 = spawn ONLY on gate events; turning up spawns faster, hard-capped at 1 shape / 500 ms). Inputs — gate (a rising edge spawns one shape), collide (a LIVE gate: HIGH = shapes bounce off each other elastically, LOW/unpatched = pass through), d / v / spd / decay / shape / rotation (per-param CV; shape latches at spawn, rotation is the live-global spin), video (sampled by the mapped output). Outputs (4, all derived from a per-pixel overlap-COUNT of the active shapes — using the rotated polygon coverage — each shape's contribution scaled by its DECAY fade alpha so a fading shape counts less / draws lighter): OVERLAP (mono-video) white wherever ≥1 shape covers the pixel (dimming as the covering shape fades), black else; CONTOUR (mono-video) shape OUTLINES only, ring width = 10% of that shape's diameter (min 2 px) so many shapes read as "ripples in a pond" (rings lighten as they decay); COMBINE (colour video) the overlap region colourized by overlap COUNT through a hue ramp (1 overlap = one hue; 2,3,4… cycle the spectrum) with brightness + saturation rising as more shapes stack and dimming as the stack fades; MAPPED (colour video) shows the VIDEO input's contents wherever ≥2 shapes overlap, black elsewhere. Bounded sim: shapes bounce forever and accumulate, so a hard cap of 200 active shapes culls the OLDEST first (a safety net even with DECAY) to keep per-frame cost bounded. Determinism: the random spawn position + each shape's seeded initial rotation angle come from a seeded mulberry32 PRNG (fixed default seed; never Math.random), so VRT / per-port / behavioral sweeps are reproducible. Usage: patch a clock/sequencer GATE in (or just turn RATE up) and route OVERLAP / CONTOUR to a SCOPE or mono consumer, COMBINE to OUTPUT for the coloured stack, and a video source → VIDEO in + MAPPED → OUTPUT to punch that source through the ≥2-overlap region. Pick a SHAPE for the spawn (polygons + ROTATION give kaleidoscopic spinning-outline fields), leave DECAY at 0 for an accumulating static field or turn it up for a trail/dissolve look, and gate the COLLIDE input HIGH (any clock/gate/LFO over the high threshold) to switch the field from a soft overlapping wash into a billiards-like cluster where the shapes knock each other around.

outputs

overlap mono-video
contour mono-video
combine video
mapped video

inputs

d cv
v cv
spd cv
decay cv
shape cv
rotation cv
video video

params

d 0..1
v 0..1
spd 0..1
decay 0..1
shape 0..1
rotation 0..1
rate 0..1

example js

spawn('outlines', 'x');
set('x', 'd', 0);
patch('x.overlap', 'x.d');

painter painter

PAINTER — an MS-Paint-style drawing surface as a video SOURCE. The card is a tiny Windows-95 Paint: a tool grid (PENCIL = hard 1px, BRUSH = round sized stroke, ERASER = paints the background colour, LINE, RECT, ELLIPSE, FILL = flood fill, EYEDROPPER = pick a colour off the canvas, TEXT = stamp a string), the classic 28-colour Win95 palette (left-click a swatch = FOREGROUND, right-click = BACKGROUND), a SIZE slider (brush/line width 1..48), a FILL toggle (outline vs background-filled rect/ellipse), and an engine-resolution drawing canvas. Whatever you paint is the single video OUTPUT in real time: the card binds its live canvas to the module once and the engine uploads that canvas every frame (a 1:1 mapping — the canvas IS the frame). MODEL: the drawing is a Y.Doc-synced ordered op log (node.data.ops) — each committed stroke / shape / fill / text appends one PaintOp; on mount and on any remote edit the card REPLAYS the log onto the canvas (deterministic, pure painter-draw.ts), so every rack-mate paints the same picture. Tool / colour / brush-size are LOCAL per-collaborator (only the drawing syncs). UNDO pops the last op; CLEAR empties the log to a blank white page. IO — Inputs: none (a pure source). Output: out (video) — the painted canvas at the engine output resolution. The OUT port lives in the card's yellow drill-down PATCH PANEL (no raw side jacks, #767 standard). A freshly-spawned node renders a blank WHITE page (MS-Paint's default), so it is never a dead black frame. USAGE: paint a logo / title card / doodle and route OUT into a mixer / keyer / effect / OUTPUT; collaborate on one canvas in a shared rack.

outputs

out video

example js

spawn('painter', 'x');

peakstate peakstate

peakstate is a self-running mandala/kaleidoscope generator — a video SOURCE with no video input. An internal "pen" traces a deterministic drifting Lissajous path (penAtTime: x = 0.5·cos(0.7t), y = 0.5·sin(1.3t + 0.4·cos(0.3t))) through a centred unit disc, pushing one sample per frame into a 600-sample ring buffer (~10s of comet trail). Each frame the whole trail is redrawn once per kaleidoscope arm — rotated by 2π/complexity and mirrored about the arm axis — over a translucent black overlay that decays the previous frame, giving the classic mirror-arm bloom. MOVE + OBLONG add a slow spirograph orbit of the mandala's centre (period ~20s at Speed 1): MOVE sets orbit radius, OBLONG squashes the orbit's vertical extent from a circle toward a near-horizontal "rolling tube". The module emits three coherent views of the SAME pen trail with different palette/transform. Usage: drop it in for a generative kaleidoscope bloom, patch an LFO or envelope into the CV jacks to pulse the speed/arm-count/hue, and pick the mono, full-colour, or pseudo-3D output to suit the look.

outputs

mono_out mono-video
rgb_out video
out_3d video

inputs

speed_cv cv
complexity_cv cv
color_speed_cv cv

params

speed 0.1..4
complexity 4..32
color_speed 0..4
move 0..1
oblong 0..1

example js

spawn('peakstate', 'x');
set('x', 'speed', 0);
patch('x.mono_out', 'x.speed_cv');

peertube peertube

PEERTUBE — federated-video SOURCE. Search the open PeerTube fediverse, pick a video, and its picture streams in as a CLEAN (untainted) WebGL video texture plus stereo audio — a real downstream-usable source, NOT play-only. MODEL: a debounced search box queries Sepia Search (sepiasearch.org, the official PeerTube meta-index — CORS-open + anonymous, NO proxy needed); results list title, channel@host, duration, a LIVE badge, and a thumbnail. Click a result → the card fetches that video's per-instance public API (https://<host>/api/v1/videos/{uuid}) and resolves a playable stream: it PREFERS the HLS master playlist (streamingPlaylists[0].playlistUrl → attached via hls.js for adaptive playback) and FALLS BACK to the highest-resolution progressive MP4 (files[].fileUrl, attached as a plain <video src>). The stream attaches to a card-owned <video crossorigin="anonymous"> → the engine samples it into the FBO (the `video` output) + taps stereo audio (audio_l / audio_r via MediaElementSource → ChannelSplitter, with the shared keep-alive so an unpatched source keeps decoding at full rate). WHY THE TEXTURE + AUDIO ARE CLEAN (verified): PeerTube sends Access-Control-Allow-Origin:* on the FINAL media hop (master .m3u8 + the fragmented-mp4 / mpeg-ts segments) under a favorable `credentialless` COEP posture, so a crossorigin <video> fed by hls.js both PLAYS and yields an untainted texture — unlike archive.org video (play-only). IO — Inputs: play_trigger (gate, edge=trigger — a rising edge toggles play/pause), next_trigger (gate, edge=trigger — a rising edge loads the next search result, wrapping). Outputs: video (the live frame texture), audio_l / audio_r (stereo, silent ConstantSource placeholders until a stream attaches), loaded (trigger — one pulse when a new video finishes loading), ended (trigger — pulses when the video reaches its end), playing (gate — HIGH while actually playing), playhead (CV — 0..1 normalized position). CV/PATCHING: all inputs + outputs live in the card's yellow drill-down PATCH PANEL (top-left/top-right affordances → INPUT/OUTPUT → grouped Gates / CV / Audio / Video rows) — there are NO raw side jacks (#767 standard). Trigger inputs are main-thread edge-detected the established video-module way (a single bridge-written cv-param read per tick — never a whole-AnalyserNode rescan). USAGE: type a term, press Enter (or wait for the debounce), pick a video, and route VIDEO into a mixer/keyer/OUTPUT and audio_l/audio_r into AUDIO OUT or a SCOPE/SYNESTHESIA for audio-reactive visuals; clock the next_trigger from a sequencer to channel-surf the fediverse. GRACEFUL: ~1/6 instances misconfigure CORS (raw S3 with no ACAO) → the element taints / the HLS load fails fatally → the card degrades to "display unavailable", surfaces a clear status, and AUTO-SKIPS to the next result (it never crashes, taints the texture, or hangs on loading). An optional instance field biases attribution display. Only { instanceHost, uuid, name, selectedHost } persist on the node + sync to rack-mates (everyone resolves + plays the same video locally); transient playback state stays render-local (never a per-frame synced-store write). The AUDIO TRAP: the <video> is created muted for autoplay, then un-muted ONLY after the MediaElementSource tap succeeds, so audio routes into WebAudio without native speaker double-output. LEGAL: federated PUBLIC videos, not hosted by patchtogether — an in-card disclaimer + attribution to PeerTube + Sepia Search ship with it.

outputs

video video
audio_l audio
audio_r audio
loaded gate
ended gate
playing gate
playhead cv

inputs

play_trigger gate
next_trigger gate

params

gain 0..2
cv_play_trigger 0..1
cv_next_trigger 0..1

example js

spawn('peertube', 'x');
set('x', 'gain', 0);
patch('x.video', 'x.play_trigger');

pentemelodica pentemelodica

Five-voice polyphonic analog-style synth. A POLY input (the polyPitchGate chord bus from MIDI LANE / POLYSEQZ / a chord sequencer) drives five band-limited VCO voices — lane i → voice i — each with TUNE (±36 st) / FINE (±100 ¢) / exponential FM / through-phase PM / pulse width and a continuous tri→saw→square WAVE morph. Each voice has its own gated amplitude envelope, but the A/D/S/R is SHARED across all five voices (one device-level ADSR; aligned with CUBE / WAVECEL / DX7); the gate edge comes from that voice's poly lane, and a released voice holds the played pitch through its release tail. The five post-envelope voices sum through a stereo mixer (per-voice LEVEL + equal-power PAN) and an embedded multimode filter — a continuous LP→BP→HP→Notch MODE dial on a TPT state-variable filter (CUTOFF / RESONANCE) with a WET/DRY bypass — to the stereo OUT_L / OUT_R pair. Each voice is also tapped pre-mixer (post-envelope) to a VOICE1..VOICE5 mono output, and each voice has its own audio-rate FM jack (fm1..fm5) that feeds both its FM and PM depths. 48 panel params (5 voices × 8 + 4 shared ADSR + 4 filter). DSP is own-code: a clean-room polyBLEP band-limited oscillator, a Cytomic/Zavalishin TPT state-variable filter, and a linear-ADSR envelope — not a port of any copyleft source (permissive only).

outputs

out_l audio
out_r audio
voice1 audio
voice2 audio
voice3 audio
voice4 audio
voice5 audio

inputs

poly polyPitchGate
fm1 audio
fm2 audio
fm3 audio
fm4 audio
fm5 audio

params

attack 0.001..5s
decay 0.001..5s
sustain 0..1
release 0.001..5s
cutoff 20..20000Hz
resonance 0..0.99
mode 0..1
wetdry 0..1

example js

spawn('pentemelodica', 'x');
set('x', 'attack', 0.001);
patch('x.out_l', 'x.poly');

picturebox picturebox

Image-file SOURCE with a 7-SLOT ASSET SELECTOR. Click "Choose image…" to load a single picture (downscaled to 1024×768, JPEG-encoded, base64 → node.data and synced to all rack-mates; each peer decodes it back into the WebGL2 source texture). A GAIN knob (CV-modulatable, 0..2) scales the output RGB; output `out` is a video-domain image source. ASSET SELECTOR: right-click the card to open "Load multiple…", a 7-row panel where each row is labelled with a note (C D E F G A B) and loads its own image into one of 7 slots (all 7 base64 images sync + all 7 textures stay resident in GPU memory). A clip player (or any pitch + gate source) then SWITCHES which slot is displayed: patch the clip player's GATE output → ASSET GATE and its PITCH output → ASSET PITCH. On each ASSET GATE rising edge the module reads ASSET PITCH (raw V/oct), maps it to a slot by PITCH CLASS (octave-independent), and instantly shows that slot if it holds an image. THE 7-NOTE → SLOT TABLE (the default clip's in-key rows, C-major from C3): C3 (MIDI 48) → slot 1, D3 (50) → slot 2, E3 (52) → slot 3, F3 (53) → slot 4, G3 (55) → slot 5, A3 (57) → slot 6, B3 (59) → slot 7. Matching is by pitch class, so a C in ANY octave selects slot 1, a B in any octave selects slot 7, etc. A pitch whose class is a black key (C# D# F# G# A#) maps to NO slot → the event is IGNORED (the current image keeps showing). The displayed selection is LOCAL render state (every peer computes it from the same synced gate + synced images), so it is never written to the Y.Doc per gate event. ASSET PITCH/ASSET GATE + GAIN live in the card's yellow drill-down PATCH PANEL (no raw side jacks, #767 standard). Limits: 8 PICTUREBOX per workspace.

outputs

out image

inputs

gain cv
asset_pitch pitch
asset_gate gate

params

gain 0..2
asset_pitch -10..10
asset_gate 0..1

example js

spawn('picturebox', 'x');
set('x', 'gain', 0);
patch('x.out', 'x.gain');

qbert qbert

QBERT is a patchable arcade module modeled on Q*Bert (Gottlieb, 1982) and rendered as a video signal — the premise is hopping the little orange creature around an isometric cube pyramid, recoloring cubes while dodging enemies. It is a VIDEO source that ALSO bridges into the audio domain (same shape as DOOM and NIBBLES). Control is entirely via CV/gate cables — there are NO knobs or sliders on the card by design. Patch a gate into COIN to drop in a quarter (rising edge), a gate into START to begin a credited game (only works once a coin is in), and bipolar CV (-1..+1) into JOY_X / JOY_Y to steer. Because Q*Bert's stick is a 45-degree-rotated 4-way DIAGONAL, the two axes are resolved together into one of NE/NW/SE/SW each frame: only when BOTH axes sit inside the 0.3 dead-band is the result NEUTRAL (no direction) — a single axis past 0.3 still resolves to a diagonal, biasing the inactive axis toward down/right. The card shows a fixed 256x240 screen with INSERT COIN / PRESS START prompts, or a ROM MISSING overlay telling you to run `task setup:qbert` when the ROM zip isn't on the static server. The framebuffer is letterboxed (full height, black side bars) into the engine's 16:9 FBO. Note: this v1 ships the engine SHAPE — the memory map, ROM-name surface, framebuffer pipe, and gate/audio plumbing are real and end-to-end, while full Z80 opcode coverage and the I8039 sound CPU are follow-ups; the move/die/level events and the hop SFX are currently driven by a faithful synthetic stream (move every 8 tics a direction is held, die after a held-NEUTRAL timeout, level every 28 moves) so the outputs are exercisable today. Emulator state is LOCAL per client (no Yjs replication) — each user in a shared rackspace runs their own runtime, like DOOM.

outputs

out video
audio_out audio
evt_die gate
evt_move gate
evt_level gate

inputs

coin_in gate
start_in gate
joy_x cv
joy_y cv

params

cv_coin_in 0..1
cv_start_in 0..1
cv_joy_x -1..1
cv_joy_y -1..1

example js

spawn('qbert', 'x');
set('x', 'cv_coin_in', 0);
patch('x.out', 'x.coin_in');

rings rings

Modal / sympathetic-string resonator (Mutable Instruments Rings archetype). Faithful TypeScript port of the eurorack/rings/ DSP (MIT-licensed). v1 ships two resonator models: (0) MODAL — bank of 24 parallel stiffness-stretched RBJ bandpasses with cosine-weighted Odd/Even pickup taps; (1) SYMPATHETIC — 2 parallel Karplus-Strong delay lines with one-pole damping. STRUCTURE/BRIGHTNESS/DAMPING/POSITION are the canonical Rings knobs; LEVEL is a soft-limited output gain. EXCITER in drives both engines; STRUM rising edge re-ignites a ~10ms noise burst (KS) or impulse (modal). Outputs odd / even — patch both for stereo. Polyphony 1; STRING+REVERB deferred.

outputs

odd audio
even audio

inputs

in audio
pitch pitch
strum gate
model_cv cv
note_cv cv
str_cv cv
bright_cv cv
damp_cv cv
pos_cv cv
level_cv cv

params

model 0..?
note -60..60st
structure 0..1
brightness 0..1
damping 0..1
position 0..1
level 0..1

example js

spawn('rings', 'x');
set('x', 'model', 0);
patch('x.odd', 'x.in');

riotgirls riotgirls

4-voice drum machine. 3x DRUMMERGIRL + 1x Wavetable VCO/ADSR/VCA, per-voice equal-power pan, master QBRT filter, stereo out.

outputs

outL audio
outR audio

inputs

trig1 gate
trig2 gate
trig3 gate
trig4 gate
gate1 gate
gate2 gate
gate3 gate
gate4 gate
pitch1 pitch
pitch2 pitch
pitch3 pitch
pitch4 pitch
v1_tone cv
v1_shape cv
v1_volume cv
v1_decay cv
v2_tone cv
v2_shape cv
v2_volume cv
v2_decay cv
v3_tone cv
v3_shape cv
v3_volume cv
v3_decay cv
v4_fm audio
v4_wavePos cv
v4_attack cv
v4_decay cv
v4_sustain cv
v4_release cv
v4_volume cv
v1_pan cv
v1_sendA cv
v1_sendB cv
v2_pan cv
v2_sendA cv
v2_sendB cv
v3_pan cv
v3_sendA cv
v3_sendB cv
v4_pan cv
v4_sendA cv
v4_sendB cv
bc_decimate cv
bc_bits cv
bc_wet cv
rv_size cv
rv_damp cv
rv_mix cv
flt_cutoff cv
flt_resonance cv
flt_mode cv
flt_pingDecay cv
returnA cv
returnB cv

params

v1_pitch -36..36st
v1_tone 0..1
v1_shape 0..1
v1_volume 0..2
v1_decay 0.001..0.5s
v2_pitch -36..36st
v2_tone 0..1
v2_shape 0..1
v2_volume 0..2
v2_decay 0.001..0.5s
v3_pitch -36..36st
v3_tone 0..1
v3_shape 0..1
v3_volume 0..2
v3_decay 0.001..0.5s
v4_tune -36..36st
v4_fine -100..100¢
v4_wavePos 0..1
v4_fmAmount 0..1
v4_attack 0.001..2s
v4_decay 0.001..4s
v4_sustain 0..1
v4_release 0.001..8s
v4_volume 0..2
v1_pan -1..1
v1_sendA 0..1
v1_sendB 0..1
v2_pan -1..1
v2_sendA 0..1
v2_sendB 0..1
v3_pan -1..1
v3_sendA 0..1
v3_sendB 0..1
v4_pan -1..1
v4_sendA 0..1
v4_sendB 0..1
bc_decimate 1..64
bc_bits 1..16
bc_wet 0..1
rv_size 0..1
rv_damp 0..1
rv_mix 0..1
flt_cutoff 20..20000Hz
flt_resonance 0..0.99
flt_mode 0..1
flt_pingDecay 0.005..0.5s
returnA 0..1
returnB 0..1

example js

spawn('riotgirls', 'x');
set('x', 'v1_pitch', 0);
patch('x.outL', 'x.trig1');

samsloop samsloop

Loop-based sample player. Upload an audio file (≤2 MB — wav / mp3 / m4a / ogg / flac / opus) or record from patched audio inputs in place; the clip is decoded to mono and played back from a fractional read-cursor with linear interpolation, so a single rate control covers varispeed including reverse. IDLE-BY-DEFAULT: a freshly loaded sample sits SILENT and does NOT auto-play — and a saved patch reloads idle too. Playback is started by a TRIGGER, which is MODE-AWARE: in one-shot mode (1-SHOT) a trigger plays the sample through once then returns to silence; in loop mode (LOOP) a trigger starts looping (a re-trigger restarts from the window edge). The trigger comes from BOTH the TRIG gate input (a rising edge) AND the on-card TRIGGER button (a momentary pulse to the worklet that works whether or not a cable is patched into TRIG). The RATE slider spans −2 (reverse 2×) through +1 (forward unity, the centered no-op) to +2 (forward 2×), and a rate CV input sums on top (±1 V = ±100%). START / END faders set the playback window. Holds exactly one sample at a time — a new upload or recording replaces the previous buffer (no playlist, no slots), which keeps the per-instance memory ceiling deterministic.

outputs

out audio

inputs

trig gate
rate_cv cv
audio_l_in audio
audio_r_in audio

params

rate ?..?
mode 0..1
start 0..1
end 0..1

example js

spawn('samsloop', 'x');
set('x', 'rate', 0);
patch('x.out', 'x.trig');

shapedramps shapedramps

SHAPEDRAMPS is a sync-locked parametric ramp generator for video coordinate synthesis — it draws gradients across the raster rather than processing an incoming picture. It emits four mono-video ramps: h_lin/v_lin are stable identity ramps (red channel = screen u or v, untouched by any knob or CV) for clean raster passthrough into geometry modules like RUTTETRA; h_out/v_out are shaped ramps that morph through four canonical shapes via H Shape / V Shape (0..1): linear (t), triangle (abs(2t-1)), soft-fold (0.5 - 0.5*cos(2pi*t)), and radial (H = distance from center scaled so corners read 1, V = angle around center), blending linearly between adjacent shapes. H/V Phase shift the ramp before shaping; H/V Freq scale the axis variable and fract-wrap it, so freq=2 repeats the shape twice across the canvas (a triangle becomes a two-peak zigzag). It also packs two general-purpose 2-channel video crossfade mixers (out = (1-amount)*A + amount*B) so you can blend ramp shapes without an external V-MIXER, though they accept any mono-video signal. Typical use: feed h_lin/v_lin into a coordinate consumer for an identity raster, then crossfade toward h_out/v_out to warp the geometry; all four ramps and both mixers render every frame so downstream consumers always read fresh textures.

outputs

h_lin mono-video
v_lin mono-video
h_out mono-video
v_out mono-video
mix1_out mono-video
mix2_out mono-video

inputs

h_shape cv
v_shape cv
h_phase cv
v_phase cv
h_freq cv
v_freq cv
mix1_a mono-video
mix1_b mono-video
mix2_a mono-video
mix2_b mono-video
mix1_cv cv
mix2_cv cv

params

h_shape 0..1
v_shape 0..1
h_phase 0..1
v_phase 0..1
h_freq 0.5..8
v_freq 0.5..8
mix1 0..1
mix2 0..1

example js

spawn('shapedramps', 'x');
set('x', 'h_shape', 0);
patch('x.h_lin', 'x.h_shape');

shapes shapes

SHAPES is a procedural geometry source: it has no video input and synthesizes a mono-video stream entirely in its fragment shader. Each frame the shader evaluates a signed-distance field for one of three primitives — a circle, a square, or an equilateral triangle pointing up — and renders it white-on-black, antialiased with a soft edge band. The shape is picked discretely (the Shape value is rounded to the nearest integer; there is no morph or blend between primitives). The frame's UV coordinates are rotated and divided by the zoom factor before the SDF is evaluated, so larger zoom grows the shape's footprint while rotation spins it about its cell center; the antialiasing band is scaled by 1/zoom so the outline stays crisp even when the shape fills the frame. With Tile off the whole frame is a single cell holding one centered shape; with Tile on the frame is repeated (via fract of the UVs) into a Grid×Grid array of identical cells, each carrying its own centered copy. Use it as a clean mask/matte or pattern generator feeding compositors, displacement, or feedback stages; patch CV into shape/tile/rotate/zoom to animate the geometry from the audio side.

outputs

out mono-video

inputs

shape cv
tile cv
rotate cv
zoom cv

params

shape 0..2
tile 0..1
tileN 1..16
rotate -3.14159..3.14159
zoom 0.05..10

example js

spawn('shapes', 'x');
set('x', 'shape', 0);
patch('x.out', 'x.shape');

spirographs spirographs

SPIROGRAPHS — a classic-spirograph video GENERATOR (a pure synth SOURCE: no video input). It draws 1–3 INDEPENDENT spirograph curves — HYPOTROCHOIDS (the rolling circle rolls INSIDE the fixed one) or EPITROCHOIDS (OUTSIDE) — each with its OWN full parameter set + matching CV, each DRIFTING around the screen with its fixed circle bouncing off the frame edges like a real spirograph pinned to the page. THE CURVES (a pen at offset p in a rolling circle of radius r rolling on/in a fixed circle of radius R): hypotrochoid x=(R−r)cos t + p·cos(((R−r)/r)t), y=(R−r)sin t − p·sin(((R−r)/r)t); epitrochoid x=(R+r)cos t − p·cos(((R+r)/r)t), y=(R+r)sin t − p·sin(((R+r)/r)t). The parameter t sweeps over exactly enough revolutions to CLOSE the figure — derived from the reduced R:r ratio (revolutionsToClose = the denominator of R/r in lowest terms); irrational-ish ratios are CAPPED at a sane maximum so the curve dense-fills the annulus instead of running forever. COUNT (1..3, DISCRETE knob + CV) sets how many spiros render. Each spiro i∈{1,2,3} owns ten params (port/param id sI_<name>), EACH with a knob AND a CV input: fixedRadius (R), rollingRadius (r), penOffset (p), inside (0=epitrochoid/outside, 1=hypotrochoid/inside — a discrete toggle), rotation, scale, xOffset, yOffset, thickness (real px line-width), and chroma (a colorwheel HUE for that spiro). MOTION: each spiro's CENTER drifts on its OWN per-spiro velocity/phase (the three never move in lockstep); the FIXED-radius circle (R scaled to screen) is CONSTRAINED to stay fully inside the frame and rolls/BOUNCES (elastic reflection) off the perimeter when it hits an edge — only the fixed circle's center+R is bound-constrained (closed-form, deterministic), while the drawn CURVE may extend past the viewport and clip (desired). The reflect/bounce + the curve math live in the pure, unit-tested $lib/video/modules/spirographs-math. RENDERING: Canvas2D polylines (real line-width with round joins/caps) painted to an OffscreenCanvas and uploaded as a GL texture each frame (the SHAPEGEN/TEXTMARQUEE path) — the right tool for thick stroked curves, where a GLSL distance-field would be costlier and read worse. OUTPUTS (all video): out (video) — the full-COLOUR composite, each spiro in its chroma hue additively blended on black so crossings glow; mono_out (mono-video) — every spiro stroked WHITE on black, a clean matte for keying / luma effects (reachable via read('outputTexture:mono_out')); overlap (video, labelled CANDY) — a COLOUR-OVERLAP output: the per-pixel overlap DENSITY (how many lines stack there — self-crossings AND multiple spiros) is colour-mapped into a rainbow that CASCADES with the count (deep cool hue for one line, racing through green→yellow→red→magenta as lines pile up) and blooms toward a white candy core where many overlap — gooey "candy" goodness (reachable via read('outputTexture:overlap')). CARD: a live preview of the colour OUT, the COUNT knob, a 1/2/3 SPIRO SELECTOR that swaps the knob bank to that spiro, an INSIDE/OUTSIDE toggle, a CHROMA colorwheel, and the per-spiro fader bank. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks); the drill-down GROUPS the CV inputs per-spiro (a count section + spiro1 / spiro2 / spiro3 sections). USAGE: dial COUNT, pick a spiro tab, tune R/r/pen for the figure (low gcd ratios make few-lobed flowers, coprime ratios dense rosettes), set INSIDE/OUTSIDE + chroma, then patch out → OUTPUT / a video mixer / an effect — or modulate any per-spiro param from an LFO/sequencer for an animated, drifting spirograph.

outputs

out video
mono_out mono-video
overlap video

example js

spawn('spirographs', 'x');

swolevco swolevco

Buchla 259-style complex waveform generator — the "swole VCO" of the lineup: a primary oscillator and a sine modulator in one module. The primary blends saw → triangle → square via the SYMMETRY control, then passes through a West-Coast wavefolder (FOLD). TIMBRE is audio-rate cross-modulation: the modulator FMs the primary (up to ~±4 semitones of deviation) for the classic Buchla harmonic complexity. Pitch is 1 V/oct (0 V = C4) with tune/fine knobs. Outputs the folded primary, the raw modulator, and a summed mix, plus a mono-video SCOPE output of the primary waveform for cross-domain video patching. Pure Web Audio, modeled after ILLOGIC's structure.

outputs

out audio
mod_out audio
sum_out audio
scope mono-video

inputs

pitch pitch
mod_pitch pitch
fm audio
timbre cv
symmetry cv
fold cv
ratio cv

params

tune -36..36st
fine -100..100¢
mod_tune -36..36st
mod_fine -100..100¢
ratio 0..8
timbre 0..1
symmetry 0..1
fold 0..1

example js

spawn('swolevco', 'x');
set('x', 'tune', 0);
patch('x.out', 'x.pitch');

symbiote symbiote

Self-contained drum + bassline machine — Marbles core running the always-on "Symbiote" alt-firmware (Grids T-section + TB-3PO X-section). The T-section runs the Grids drum engine: BD / SD / HH on t1 / t2 / t3, with a DRUMS sub-mode (Émilie Gillet's 2D drum-map with bilinear node interpolation + perturbation, driven by MAP X / MAP Y / per-voice BD/SD/HH density) and a EUCLIDEAN sub-mode (shared step length, with a bipolar CHAOS knob: CCW adds probabilistic SD fills, CW rotates the pattern). The X-section runs a TB-3PO generative acid sequencer: ACID DENSITY morphs gate/slide/accent + pitch-change density, TRANSPOSE is ±18 semitones (1V/oct), ACID LEN is 1..32 steps, SCALE picks the in-scale degree set, SEED LOCK commits/reseeds the pattern. Outputs: t1/t2/t3 drum gates, x1 step clock, x2 1V/oct pitch (slewed on slides), x3 acid gate, y accent. ALWAYS in Symbiote mode — the hardware T-MODEL long-press and déjà-vu-button sub-mode toggle are dropped; sub-mode + all TB-3PO controls are normal params. Grids drum-maps are GPLv3 (AGPL-compatible); TB-3PO from the O&C Hemisphere applet.

outputs

t1 gate
t2 gate
t3 gate
x1 gate
x2 cv
x3 gate
y gate

inputs

rate_cv cv
submode_cv cv
bd_cv cv
sd_cv cv
hh_cv cv
chaos_cv cv
aciddensity_cv cv
transpose_cv cv
acidlength_cv cv
scale_cv cv

params

rate -60..60st
sub_mode 0..1
map_x 0..1
map_y 0..1
bd_density 0..1
sd_density 0..1
hh_density 0..1
chaos -1..1
euclid_length 1..16
acid_density 0..1
transpose -18..18st
acid_length 1..32
scale 0..?
seed_lock 0..1

example js

spawn('symbiote', 'x');
set('x', 'rate', 0);
patch('x.t1', 'x.rate_cv');

textmarquee textmarquee

TEXTMARQUEE — a rich-text MARQUEE video GENERATOR (source). MODEL: you type a styled paragraph in the card's tiny rich-text editor (a contenteditable region + a small toolbar); it serializes into a small RICH-TEXT MODEL — an array of paragraphs, each a list of styled RUNS `{ text, bold, italic, underline, color }` + a paragraph `align` (left/center/right), plus a layer FOREGROUND (default glyph colour) + BACKGROUND fill. That model persists in node.data.richText (Y.Doc-synced) and is the single source of truth for BOTH the editor DOM and the video texture. CONTROLS (card): the toolbar = ALIGN left/center/right, BOLD, ITALIC, UNDERLINE, per-character TEXT COLOR (pick a colour for the current selection), and the layer FG + BG colour swatches; below the editor are four knobs (ScrlX/ScrlY/PosX/PosY) and a live preview of the OUT layer. RENDERING: the model is laid out + drawn to an OFFSCREEN 2D canvas with SYSTEM FONTS (real glyphs — system-font text cannot be rasterized in GLSL, so a 2D-canvas→texture upload is the clean path: measure each run in its font/weight/style, draw with per-run colour + underline, honour align + bg fill), uploaded as a WebGL texture, and drawn into the module's FBO at a SCROLL offset + screen POSITION — a 90s-screensaver marquee. A freshly-spawned node renders a "textmarquee" placeholder until you type. I/O: OUT (video) — the rendered scrolling text layer. CV (each port id == param id, linear cvScale so a bipolar ±1 source sweeps the param's full range centred on the knob): ScrlX / ScrlY — horizontal / vertical scroll SPEED (BIPOLAR knob; 0.5 = static, <0.5 scrolls one way, >0.5 the other; the text wraps + re-enters from the opposite edge — a continuous ribbon). PosX / PosY — raw screen POSITION 0..1, CALIBRATED so 0 = text fully off one edge, 1 = fully off the other, 0.5 = centred (drawX = -textWidth + posX*(screenW+textWidth)); with the default-centred knob a bipolar LFO patched into PosX/PosY sweeps the text ALL THE WAY across — fully off the left, through centred, to fully off the right, and back. USAGE: type + style your banner, set FG/BG, then either crawl it with ScrlX/ScrlY (a scrolling marquee) or sweep PosX/PosY from an LFO/sequencer for a CV-driven swoosh; patch OUT into OUTPUT, a video mixer, or any video effect to title/overlay another layer. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). The pos/scroll/wrap math + the rich-text layout/measurement are pure, unit-tested helpers in $lib/video/modules/textmarquee-layout.

outputs

out video

inputs

scrollX cv
scrollY cv
posX cv
posY cv

params

scrollX 0..1
scrollY 0..1
posX 0..1
posY 0..1

example js

spawn('textmarquee', 'x');
set('x', 'scrollX', 0);
patch('x.out', 'x.scrollX');

toybox toybox

Multi-layer video compositor. FOUR layers, each rendered into its own framebuffer then reduced to the output by a combine DAG (fade / lumakey / chromakey / map). A layer kind selects its source: GEN = a generative fragment-shader content entry from the bundled bank (noise-fbm domain-warped simplex FBM, worley-cells animated cellular noise; the FX hsv-plasma / cos-gradient palette shaders; the SHADERTOY synthwave-sunset port) with iTime + iResolution + its declared float params on faders — NO scene input. FRAG = a Shadertoy fragment shader that RECEIVES the composited layer below as iChannel0 (recolour / displace / feedback FX, e.g. frag-invert-scan). TOYBOX hosts a faithful SHADERTOY RUNTIME: a `void mainImage(out vec4, in vec2)` source is wrapped through a mainImage→main shim with the FULL Shadertoy uniform set (iTime, iResolution as vec3, iTimeDelta, iFrame, iFrameRate, iMouse vec4 with .z/.w press semantics, iDate, iChannel0-3 + iChannelResolution[4]); the preview canvas routes pointer events to iMouse (client→engine px, GL bottom-origin Y-flip). A GEN/FRAG layer can host a MULTI-BUFFER Shadertoy project (a Common chunk + N buffer passes + an Image pass) — each pass owns its own FBO (RGBA32F via createFloatFbo for intBitsToFloat-packed / signed-precision buffers, degrading to RGBA8), channels resolve to another buffer pass output / its own previous frame (ping-pong feedback) / a keyboard stub / the scene / none, topo-ordered producers-first with Image last; the bundled GROWING PEAK preset is an ORIGINAL multi-buffer project (a growable self-feedback heightmap buffer → a raymarched weather sky Image pass) where CLICKING the preview grows the mountain via iMouse. OBJ = a 3D mesh layer (Phase 3): a bundled CC0 OBJ (Spot the cow, Utah teapot, chess pawn — parsed by an in-house ASCII OBJ parser with auto-center/auto-scale + computed flat normals) OR a built-in procedural primitive (cube / sphere / torus / hypercube tesseract; no asset file), matcap-shaded with depth testing — the matcap is synthesized procedurally in-shader (chrome / clay / neon styles, zero asset-license surface) and the layer carries rotX/rotY/rotZ, scale, spin (auto-rotate) and an RGB tint. An OBJ layer can optionally UV-map ANOTHER layer's rendered output (material.surfaceSource = that layer index, surfaceMix the blend) onto the mesh as a SURFACE TEXTURE in place of (blended with) the matcap — a per-frame dependency-ordered render pass guarantees the source layer renders first, and a self / cyclic / out-of-range source degrades to matcap-only (no WebGL feedback loop). OBJs with no authored texture coords get a planar XY-projected UV so the surface texture isn't collapsed to a single texel. The content/model catalogs + per-shader param schema live in a static manifest (packages/web/static/toybox/manifest.json); GLSL + OBJs are fetched lazily on selection (never JS-bundled) and cached. Persistence: node.data.layers (4-length array of { kind, contentId, params, material }) + node.data.combine. One video output (out).

outputs

out video

inputs

inA video
inB video

example js

spawn('toybox', 'x');
patch('x.out', 'x.inA');

tree.oh.vox treeohvox

TB-303 voice slice — clean-room TypeScript port of the voice subset of Robin Schmidt's Open303 (MIT, https://github.com/RobinSchmidt/Open303). 6 canonical 303 knobs (TUNE ±12 st, CUTOFF 40 Hz – 6 kHz, RESONANCE 0..1, ENVELOPE 0..1, DECAY 50 ms – 3 s, ACCENT 0..1) plus pitch / gate / accent_in audio-rate inputs and per-knob CV. The DSP is the TB_303 mode of rosic::TeeBeeFilter (the diode-feedback ladder with feedback HP — NOT a moogafakkin ladder; that is the whole point of Open303), the rosic::DecayEnvelope on cutoff, a simplified AR amp envelope mirroring rosic::AnalogEnvelope, and a polyBLEP saw replacing the BlendOscillator wavetable (the 303 character lives in the filter, not the oscillator). Cutoff is modulated per-sample via Open303's measured-mapping scaler+offset formula. All 6 knobs have an 80 Hz one-pole WtParamSmoother on the audio thread (per PR #435) so knob drags and CV ride pop-free through the steep filter. Accent boosts both amp peak and filter env contribution on accented notes. The full 404 module — sequencer + transpose + slide + waveform switch + TD-3 smiley — is queued as a follow-up.

outputs

audio_out audio

inputs

pitch_in pitch
gate_in gate
accent_in gate
tune_cv cv
cutoff_cv cv
res_cv cv
env_cv cv
decay_cv cv
accent_cv cv
waveform_cv cv

params

tune -12..12st
cutoff 40..6000Hz
resonance 0..1
envelope 0..1
decay 50..3000ms
accent 0..1
waveform 0..1

example js

spawn('treeohvox', 'x');
set('x', 'tune', 0);
patch('x.audio_out', 'x.pitch_in');

tv librarian tvLibrarian

International live-TV source. Pick a country on the 2D world map (or the country list) → a channel list (filtered to playable HLS streams) → tune a channel and its live picture streams in as an UNTAINTED video texture (validated under the app's COEP require-corp headers: famelack HLS plays + yields a clean WebGL2 texture, so VIDEO out is a real downstream-usable texture, not play-only) plus stereo audio_l/audio_r from the stream's audio track. The "random" button (and the random/next CV trigger inputs) jump channels for happy-accident channel-surfing. Gate outputs: channel_changed pulses on each tune (trigger), stream_online holds high while the stream actually plays (gate). Dead/geo-blocked/unlicensed-pulled streams fail cleanly → marked "unavailable" + auto-skipped, never a hang or a tainted texture. Channel selection persists on the node + syncs to rack-mates (everyone tunes to the same stream). LEGAL: streams are THIRD-PARTY public streams, NOT hosted by patchtogether — this is a player pointed at the same iptv-org-derived directory many "free live TV" sites use; an in-card disclaimer + attribution (Famelack, MIT-licensed dataset fetched at runtime; iptv-org) ship with it, geo-blocked entries are honored/marked, and dead links are filtered. Plan + legal posture: .myrobots/plans/tv-librarian-module-2026-06-14.md.

outputs

video video
audio_l audio
audio_r audio
channel_changed gate
stream_online gate

inputs

next gate
random gate

params

gain 0..2
cv_next 0..1
cv_random 0..1

example js

spawn('tvLibrarian', 'x');
set('x', 'gain', 0);
patch('x.video', 'x.next');

vfpga-runner vfpgaRunner

A HOST module that runs a loaded `.vfpga` declarative effect spec — a "virtual FPGA bitstream" swapped into one reconfigurable card (inspired by, not a clone of, classic video-synth hardware). The module declares the full I/O SUPERSET it can wire — 4 video inputs (vin1..vin4), 4 CV inputs (cv1..cv4), 4 gate inputs (g1..g4), 2 video outputs (vout1 canonical / vout2 via read('outputTexture:vout2')), and an 8-slot generic param bank (p1..p8) — and a loaded VfpgaSpec (node.data.vfpga, picked from the "load preset…" menu) selects which subset is ACTIVE and what GL render-graph runs. The card is manifest-driven: it renders the full port superset as handles (inactive ones dimmed) and shows only the loaded spec's active CV inputs (each with a bipolar SCALE attenuverter + OFFSET + always-on scope), gate inputs (with an activity LED), and its mapped param knobs (p1..pN, labelled + ranged by the spec, MIDI-learnable). CV inputs are linear-scaled into named role uniforms; gate inputs raw-pass into synthetic gN_evt params that the factory hysteresis edge-detects (DOOM/backdraft convention) so a spec's shader can read a held level / rising-edge count. Specs are IN-REPO bundled TypeScript (no user-uploaded code in v1) collected by import.meta.glob; the render runs off-main-thread (renderLocus:'worker') because every catalog VFPGA is pure-GL. Preset change hot-swaps the GL pipeline. This foundation ships ONE VFPGA: smpte-bars, a pure SMPTE-style colour-bar generator (0 video in → 1 video out, one CV SHIFT role + BRIGHT/SAT params) — a deterministic always-on reference source for bringing up downstream effects.

outputs

vout1 video
vout2 video

example js

spawn('vfpgaRunner', 'x');

videobox videobox

videobox is a local-file VIDEO PLAYER: you drop (or pick) a video file from disk and it decodes the file each frame into the module's video output, while the file's stereo audio track is split out to the audio_l / audio_r jacks for patching back into the audio domain. The card owns the actual HTMLVideoElement and object-URL; the engine samples that element through a decode-rate frame uploader (only re-uploading when a genuinely new frame lands, downscaled to the engine resolution) so playback stays smooth even at 1080p. Behind the file picker the card uses File System Access handles (Chromium) to remember your pick and one-click-reload it next session; other browsers and other peers fall back to a "Re-link: drop <name>" prompt. The playhead is multiplayer-synced: play, pause and seek write a shared (isPlaying / lastSyncTime / lastSyncPosition) triple to the node so every peer's local copy follows, drift-correcting whenever it slips more than ~0.5s off the expected position. The card is drag-resizable from the bottom-right corner (whole-rack-unit tiles, default and minimum 360x360) so several videoboxes can be tiled into a wall of TVs; size persists on the node and syncs to peers, and the 16:9 video preview grows to fill the resized card. Right-click the preview for Fullscreen (a LOCAL per-peer state, NOT multiplayer-synced) or Full Frame (in-app, the video consumes the whole card, hiding the title/picker/transport/seekbar; double-click to exit), where ONLY Full Frame is synced to peers. Usage: drop a clip, hit Play, and patch video into a mixer/output and audio_l/audio_r into your audio chain; pulse the TRIG input from a clock or button to toggle play/pause hands-free. Idle (no file) shows a faint blue gradient so an empty card reads as alive-but-empty.

outputs

video video
audio_l audio
audio_r audio

inputs

play_trigger gate

params

gain 0..2
cv_play_trigger 0..1

example js

spawn('videobox', 'x');
set('x', 'gain', 0);
patch('x.video', 'x.play_trigger');

videovarispeed videovarispeed

Local-file VIDEO player with a PERFORMANT varispeed transport AND a 7-SLOT ASSET SELECTOR. SINGLE VIDEO: pick/drop a video (objectUrl + optional FileSystemFileHandle for one-click reload; collaborators re-link their own copy — the bytes stay local, only fileMeta syncs); the frame texture is sampled off requestVideoFrameCallback so the `video` output streams at ANY playback speed (the #291 fix). Transport: SPEED knob (0=-4×…0.5=+1×…1=+4×; reverse scrubs at a throttled ~10 Hz), a START/END window, LOOP vs ONE-SHOT, and rising-edge gates START / PAUSE / RESET / LOOP. Stereo `audio_l` / `audio_r` bridge the file's audio (with a silent keep-alive so an unpatched source keeps decoding at full rate). ASSET SELECTOR: right-click the card → "Load multiple…", a 7-row panel (notes C D E F G A B) that loads up to 7 videos, one per slot; all 7 are PRELOADED as separate <video> elements (first frame decoded) so a switch is instant. Patch a clip player's GATE → ASSET GATE and PITCH → ASSET PITCH: on each ASSET GATE rising edge the module reads ASSET PITCH (raw V/oct), maps it to a slot by PITCH CLASS, and — if that slot holds a loaded video — makes it the active source, RESTARTS IT FROM THE BEGINNING (currentTime=0), plays it (if the transport is playing) under the current speed/window/loop settings, and re-wires its audio to the now-active element. THE 7-NOTE → SLOT TABLE (the default clip's in-key rows, C-major from C3): C3 (MIDI 48) → slot 1, D3 (50) → slot 2, E3 (52) → slot 3, F3 (53) → slot 4, G3 (55) → slot 5, A3 (57) → slot 6, B3 (59) → slot 7. Matching is octave-independent (a C in any octave → slot 1, …); a black-key pitch (C# D# F# G# A#) maps to NO slot → the event is IGNORED (current video keeps playing). MEMORY: 7 preloaded <video> elements are heavy, so each slot's file is capped at 100 MB. The displayed selection is LOCAL render state (computed from the synced gate + per-slot fileMeta), never written to the Y.Doc per gate event. ASSET PITCH / ASSET GATE + the transport gates/CV all live in the card's yellow drill-down PATCH PANEL (no raw side jacks, #767 standard).

outputs

video video
audio_l audio
audio_r audio

inputs

cv_start gate
cv_pause gate
cv_reset gate
cv_loop_toggle gate
asset_pitch pitch
asset_gate gate
speedCv cv
startCv cv
endCv cv

params

speed 0..1
start 0..1
end 0..1
speedCv -1..1
startCv -1..1
endCv -1..1
cv_start 0..1
cv_pause 0..1
cv_reset 0..1
cv_loop_toggle 0..1
asset_pitch -10..10
asset_gate 0..1

example js

spawn('videovarispeed', 'x');
set('x', 'speed', 0);
patch('x.video', 'x.cv_start');

wavecel wavecel

Stereo wavetable oscillator with morph, stereo spread, and a West-Coast wavefolder — a more advanced sibling of WAVETABLEVCO. MORPH scans the wavetable frame position, SPREAD detunes/widens the stereo image, FOLD adds wavefolding harmonics. Ships factory wavetables and accepts runtime upload of E352-format WAV wavetables (frames ride the Y.Doc out to every rack-mate). The card offers a 3D wavetable visualization in addition to the standard scope view. A POLY input (polyPitchGate) accepts the 5-voice chord bus from MIDI LANE (mode=poly) or POLYSEQZ: when any lane is gated WAVECEL renders one wavetable voice per gated lane at that lane's pitch and sums them — the morph/spread/fold timbre is shared across all voices. With nothing patched to poly the mono `pitch` path runs unchanged. A per-voice amplitude ADSR (Attack / Decay / Sustain / Release) plus a BASE VOL knob shape each voice. GATING is decided by what is PATCHED: when the POLY bus OR the mono TRIGGER is connected, WAVECEL is a GATED voice — a lane/voice sounds only while it is gated-or-releasing, and a never-gated lane is SILENT (patching poly never auto-drones). When NEITHER is patched, WAVECEL is a continuous raw VCO. BASE VOL is a per-voice VCA FLOOR the envelope rides on top of: gain = base + (1-base)·env per ACTIVE voice — base=1 (default) means the env does nothing (full gain), base=0 is pure ADSR (silent between notes), 0.5 floors at 0.5 and rises to 1.0 at the env peak. For the raw-VCO case (nothing patched) the env is idle so the gain is exactly BASE VOL, so the default of 1 is the legacy continuous drone (byte-identical) and BASE VOL doubles as the raw-VCO level. In poly mode each lane's gate edge drives its own envelope (one envelope per voice, soft/click-safe retrigger — re-gating a still-releasing voice attacks from the current level, never pops); the mix is normalized over ACTIVE voices (1/sqrt(N)) so a sustain=0 held note doesn't pump the level and a releasing tail doesn't pop. The ADSR + BASE VOL params read live (continuous k-rate) across all stages, so a held chord rides sustain/release in real time and a fresh note attacks at the value present at its trigger moment. Edge detection is block-rate (retrigger granularity floor ≈ one audio block); connectedness (poly/trigger patched) is read from the live patch edges, not bus presence.

outputs

out_l audio
out_r audio
scope_out mono-video
wave3d_out video

inputs

pitch pitch
fm audio
morph_cv cv
spread_cv cv
fold_cv cv
poly polyPitchGate
trigger gate

params

tune -36..36st
fine -100..100¢
morph 0..1
spread 1..5
fold 0..1
attack 0.001..5s
decay 0.001..5s
sustain 0..1
release 0.001..5s
base_vol 0..1

example js

spawn('wavecel', 'x');
set('x', 'tune', 0);
patch('x.out_l', 'x.pitch');

wavesculpt wavesculpt

Hybrid 4-oscillator 3D video synth. Four wavetable "wall oscillators" sit on the faces of a 3D unit box, each emitting a colored wave ribbon (RED / GREEN / BLUE / ALPHA) that points into the box; a single user camera renders the scene, positioned via an XY pad (X/Y) and a HEIGHT slider (Z). Audio out is the sum of the four oscillators, each weighted by its per-osc ADSR and by camera↔source distance — the distance gain is the single source of truth shared by audio and visuals, so "closer = louder = bigger ribbon" stays consistent across both domains. Per oscillator: tune/fine, wavetable morph, stereo spread, wavefolder, thickness, and ADSR; camera zoom + Y-rotation shape the view. All four oscillators run in one worklet for a tight audio-rate path. Six cross-domain VIDEO WALL inputs (wall1–wall6) texture an upstream video module onto the six faces of the room (FRONT/BACK/LEFT/RIGHT/FLOOR/CEILING) seen from inside; each face has a TRANSPARENCY knob (0–100%) blending the wall over the scene and a DISTORT knob (0–1) that morphs the flat wall into a convex dome we look up into. Patch the video output back into a wall input for recursive video feedback.

outputs

L audio
R audio
out_red audio
out_grn audio
out_blu audio
out_alp audio
video_out mono-video

inputs

gate1 gate
pitch_cv1 cv
gate2 gate
pitch_cv2 cv
gate3 gate
pitch_cv3 cv
gate4 gate
pitch_cv4 cv
morph1_cv cv
morph2_cv cv
morph3_cv cv
morph4_cv cv
pos_x cv
pos_y cv
pos_z cv
zoom cv
rot cv
scale cv
wiggle cv
alpha_in video
wall1 video
wall2 video
wall3 video
wall4 video
wall5 video
wall6 video

example js

spawn('wavesculpt', 'x');
patch('x.L', 'x.gate1');

wavetable vco wavetableVco

Wavetable oscillator that morphs saw -> square -> triangle -> sine across a 16-frame table.

outputs

audio audio

inputs

pitch pitch
fm audio
wavePos cv
pm audio
tune cv
fine cv
fmAmount cv
pmAmount cv

params

tune -36..36st
fine -100..100¢
wavePos 0..1
fmAmount -1..1
pmAmount -1..1

example js

spawn('wavetableVco', 'x');
set('x', 'tune', 0);
patch('x.audio', 'x.pitch');

modulation

911 eg moog911

911 Envelope Generator (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). NOT a literal ADSR: a three-time-constant CONTOUR generator with a single sustain LEVEL. On S-trigger (gate high) it ATTACKS over T1 from 0 to the peak (1.0), INITIAL-DECAYS over T2 down to ESUS (the sustain level), then HOLDS at ESUS while the gate is held; on release (gate low) it FINAL-DECAYS over T3 back to 0. Trigger-close forces the T3 final-decay stage regardless of which stage was running, so a short trigger that releases mid-attack still decays over T3 from wherever it reached. T1 / T2 / T3 each span up to 10 s (log knobs); ESUS is a linear 0..1 level. Outputs the unipolar 0..1 contour on env plus an inverted tap (1 - env) on env_inv for ducking / sidechain modulation. CV inputs (t1_cv / t2_cv / t3_cv log-scaled, esus_cv linear) sweep each control. DSP is own-code: a clean-room exponential-segment contour generator (not a port of any moogafakkin schematic or copyleft source - permissive only). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

env cv
env_inv cv

inputs

gate gate
t1_cv cv
t2_cv cv
esus_cv cv
t3_cv cv

params

t1 0.0001..10s
t2 0.0001..10s
esus 0..1
t3 0.0001..10s

example js

spawn('moog911', 'x');
set('x', 't1', 0.01);
patch('x.env', 'x.gate');

911a trig delay moog911a

911A Dual Trigger Delay (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). Two trigger delays for staggering envelope generators. Each trigger input fires its output after a DELAY time (2 ms..10 s log). A MODE switch sets coupling: OFF (independent — trig1->out1, trig2->out2), PARALLEL (trig1 fires BOTH delays), SERIES (trig1 fires delay1->out1, whose pulse then fires delay2->out2). Own-code timing (clean-room). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

out1 gate
out2 gate

inputs

trig1 gate
trig2 gate

params

delay1 0.002..10s
delay2 0.002..10s
mode 0..?

example js

spawn('moog911a', 'x');
set('x', 'delay1', 0.1);
patch('x.out1', 'x.trig1');

912 envelope follower moog912

912 Envelope Follower (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). Tracks the amplitude envelope of an audio input and outputs it as a control voltage, plus a gate when the envelope is above threshold. SENSITIVITY sets the input drive; SMOOTHING sets how fast the envelope tracks (envelope-detector lowpass). Pure Web Audio (rectify -> lowpass -> CV; threshold -> gate). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

env cv
gate gate

inputs

audio audio

params

sensitivity 0..1
smoothing 0..1

example js

spawn('moog912', 'x');
set('x', 'sensitivity', 0.7);
patch('x.env', 'x.audio');

921a driver moog921a

921A Oscillator Driver (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). A CONTROL-VOLTAGE PROCESSOR, NOT a sound source: it generates the two control voltages on a bus that drive N slaved 921B oscillators — a frequency CV (freq_bus, V/oct, encoding pitch) and a pulse-width CV (width_bus, 0..1). The FREQUENCY pot is mapped onto V/oct by a two-position frequency-RANGE switch — SEMITONE (a tight 2-octave fine compass) or OCTAVE (a wide 12-octave coarse compass). Summing FREQ + WIDTH CONTROL INPUTS add onto the buses per-sample (freq_cv is a V/oct pitch cable that sums 1:1 onto freq_bus; width_cv sums onto width_bus). NO audio inputs and NO audio outputs — the outputs are CV cables that feed a 921B's freq_bus / width_bus. DSP is own-code: pure CV math (exponential frequency mapping + width passthrough), not a port of any moogafakkin schematic or copyleft source - permissive only. Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family). Ships together with the 921B (the 921A is meaningless without a slaved 921B).

outputs

freq_bus cv
width_bus cv

inputs

freq_cv pitch
width_cv cv

params

frequency -1..1
freqRange 1..2
width 0..1

example js

spawn('moog921a', 'x');
set('x', 'frequency', 0);
patch('x.freq_bus', 'x.freq_cv');

960 sequencer moog960

960 Sequential Controller (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). A 3-row x 8-step analog step sequencer. Each column has a knob per row (24 step pots); on each advance every row outputs its current column value as CV (row1/row2/row3), scaled by that row's RANGE (x1/x2/x4). Steps advance on an external CLOCK input (rising edge) or, when unpatched, an internal RATE clock; CLOCK OUT pulses each advance. Per-column NORMAL/SKIP/STOP switches skip a column or halt the run; START/STOP gate inputs reset/halt. v1; per-step trigger jacks, third-row-controls-timing, x2 parallel outs + 1V/oct clock CV deferred. Own-code (forks the repo sequencer). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

row1 cv
row2 cv
row3 cv
clock_out gate

inputs

clock gate
start gate
stop gate

params

rate 0.1..20Hz

example js

spawn('moog960', 'x');
set('x', 'rate', 2);
patch('x.row1', 'x.clock');

992 control voltage panel moog992

992 Control Voltage Panel (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). A passive CV summer/attenuator: four CV inputs each pass through a per-channel ATTENUATOR (0..1) into a common summing bus (cv_out). Channel 4 is SIGNAL-INVERTING — its attenuator subtracts from the sum — so the panel can both add and cancel control voltages. No audio path; pure CV math (own-code, permissive). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

cv_out cv

inputs

cv1 cv
cv2 cv
cv3 cv
cv4 cv

params

atten1 0..1
atten2 0..1
atten3 0..1
atten4 0..1

example js

spawn('moog992', 'x');
set('x', 'atten1', 1);
patch('x.cv_out', 'x.cv1');

993 trig moog993

993 Trigger & Envelope Voltages Panel (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). A passive routing patch-bay: two S-trigger inputs (FROM 1 / FROM 2) feed three trigger outputs, each output independently selecting OFF / FROM 1 / FROM 2 via its ROUTE switch; two envelope-CV inputs pass straight through to two envelope outputs. Routing logic only (own-code, permissive). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

trig_out1 gate
trig_out2 gate
trig_out3 gate
env_out1 cv
env_out2 cv

inputs

trig_from1 gate
trig_from2 gate
env_in1 cv
env_in2 cv

params

route1 0..2
route2 0..2
route3 0..2

example js

spawn('moog993', 'x');
set('x', 'route1', 1);
patch('x.trig_out1', 'x.trig_from1');

adsr adsr

Gate-triggered attack-decay-sustain-release envelope. Outputs CV.

outputs

env cv
env_inv cv

inputs

gate gate
attack cv
decay cv
sustain cv
release cv

params

attack 0.001..10s
decay 0.001..10s
sustain 0..1
release 0.001..10s

example js

spawn('adsr', 'x');
set('x', 'attack', 0.005);
patch('x.env', 'x.gate');

buggles buggles

Chaotic random voltage source — clean-room functional implementation of the Buchla / Make Noise wogglebug archetype. Internal "woggle clock" emits triggers at the RATE knob; outputs include SMOOTH (slewed random), STEPPED (sample-and-held), CLOCK (woggle gate), BURST (probabilistic clusters of 3-7 triggers), and RING (smooth × sub-osc ring-mod, the signature dirty texture). CV inputs modulate rate + chaos; EXT CLK replaces the internal scheduler when patched. The "Wogglebug" name is Make Noise's trademark — BUGGLES is our name; no proprietary schematic is copied.

outputs

smooth cv
stepped cv
clock gate
burst gate
ring audio

inputs

clock_cv cv
chaos_cv cv
external_clock gate

params

rate 0..1
chaos 0..1
smoothness 0..1
burst_probability 0..1
level 0..1

example js

spawn('buggles', 'x');
set('x', 'rate', 0.4);
patch('x.smooth', 'x.clock_cv');

cartesian cartesian

4x4 grid sequencer. Steps via clock; X/Y CV inputs scrub freely across the grid. An upper-right S&H toggle (ON by default) bakes in a gate-sampled Sample & Hold on the pitch CV: in the clock-UNPATCHED X/Y-tracking mode the pitch+gate re-emit is suppressed while the prior gate is still high, so the pitch CV latches to the gate edge and holds (the visual playhead still tracks continuously). The clock-PATCHED mode is already gate-sampled. S&H applies to PITCH only — the free-running quadrature LFO (lfo_x/lfo_y) is never held. Turn S&H OFF for legacy continuous re-emit on every pad change.

outputs

pitch polyPitchGate
gate gate
clock gate
lfo_x cv
lfo_y cv

inputs

clock gate
x_cv cv
y_cv cv
lfo_clock gate

params

mode 0..1
octave -2..2
gateLength 0.1..0.95
lfoDiv 0..7
lfoShape 0..3
snh 0..1

example js

spawn('cartesian', 'x');
set('x', 'mode', 0);
patch('x.pitch', 'x.clock');

clip player clipplayer

CLIP PLAYER — an Ableton-Session-style clip launcher with 8 INSTRUMENT LANES. Rotates Ableton's layout 90° to sit on a wide monome grid: ROWS = 8 instruments (lanes), COLUMNS = 8 clip slots per instrument (64 note clips total). Each lane plays its launched clip out its OWN pitch/gate/velocity outputs, so up to 8 clips sound at once — one per instrument (the owner model: "each row reflects a given instrument's materials"). It is the dedicated companion to a monome grid 128 controller (browser-native WebSerial, no native helper — see lib/control/monome) but is fully usable from the card alone. CLOCK: LOCKED TO TIMELORDE (the rack transport) — no internal BPM, no clock cable. It runs only while TIMELORDE.running, at TIMELORDE.bpm, and freezes when it stops (free-runs if no TIMELORDE is in the rack). The only timing control is STEP (1/4 · 1/8 · 1/16 (default) · 1/32 = steps-per-beat). The card's ▶/■ transport writes TIMELORDE.running, and HIDES itself when TIMELORDE is slaved to an external clock (MIDICLOCK → start_in/stop_in). LAUNCH: clicking a clip queues it; with QNT on (default) it takes over on that lane's next loop boundary (off = immediately). Each lane queues independently, so a whole new arrangement can drop in on the bar line. A "scene" is a COLUMN — firing it launches one clip per instrument together. The per-lane playing/queued set syncs over the Y.Doc so collaborators (and a second grid) see the same session; grid LED + serial I/O stay per-user local. CLIPS are tiny note/step patterns (default 16 steps, up to 128 — set non-destructively, so notes past a shortened length are kept and replay when you lengthen again): polyphonic (chords fan out across the lane's poly pitch/gate pairs), per-note length (held gates), per-note velocity (drives the lane's vel CV), per-note probability, and scale-aware (major/minor/pentatonic/chromatic). Clips may be DIFFERENT lengths per lane; lanes free-run as a POLYMETER and all re-align to step 0 on the TIMELORDE transport downbeat (a fresh ▶ is always phase-locked). CARD: a SESSION view (8×8 launch grid, lane-tinted; single-click = launch/queue, click the playing cell = stop, DOUBLE-CLICK = open the clip's editor) and an EDIT view (a piano-roll note editor — X = step, Y = pitch in-key; click a cell to place/remove a note, right-click to cycle its velocity through 6 levels (≈0/20/40/60/80/100%), with scale/root/length controls, per-lane MONO/POLY, ROW/OCT pitch-window scroll + a TIMELORDE-locked playhead). GRID (16×8): left 8×8 = clip matrix, right control strip = per-lane STOP + SCENE launch + COPY/PASTE/PASTE-REVERSE (held modifiers: hold COPY/PASTE/PASTE-REV + tap a clip to copy it to / paste it from a per-machine buffer; PASTE-REV pastes a time-reversed copy) + STOP-ALL + TRANSPORT; HOLD the EDIT pad + tap a clip to turn the whole grid into that clip's note editor. The on-grid note editor pages a clip in up to 8 pages of 16 steps — FOLLOW auto-scrolls the shown page with the playhead, tap it to FREEZE and page with LEFT/RIGHT; DOUBLE dups the first half into a doubled length; a dedicated 2-row LENGTH page sets the clip length (block ×16 then trim to the exact end step). Inputs — STOP ALL: a rising edge stops every lane (canonical windowed edge counter, no double-count). Outputs — PITCH 1-8: each lane's launched-clip pitch as a poly-capable V/oct cable (chords fill lanes), GATE 1-8: high while that lane's note sounds, VEL 1-8: that lane's per-note velocity as a 0..1 CV (patch into a VCA/ADSR amount). Params — STEP (steps per beat), OCT (octave transpose), GATE (per-step gate duty cycle), QNT (quantize launch to the loop boundary), S&H (ON by default). The upper-right S&H toggle bakes in a gate-sampled Sample & Hold across ALL 8 lanes at once — replacing the 8 external S&H modules a user otherwise needs: on a REST (empty step) the lane's gate still closes but its pitch CV HOLDS its last value instead of resetting to C4, so each lane's pitch latches to the gate edge. Turn S&H OFF for the legacy continuous behavior where rests rewrite pitch. SONG MODE (arranger): the header SES/ARR toggle flips between live SESSION play and ARRANGEMENT playback of a recorded TIMELINE of clip launches (an event log over song-beats). The ● REC arm captures launches into that timeline; the RPL/OVR toggle next to it sets the record mode — REPLACE (default: arming clears the log + restarts the song at bar 1) or OVERDUB (arming KEEPS the existing take and merges new launches into it by song-beat). In ARRANGEMENT view the card shows a compact lane×bar timeline whose clip blocks can be DRAGGED in time (bar-snapped) to retime a launch, selected to cycle/delete, with the loop length nudged in bars. The "ARR ⤢" button pops out a FULL-WINDOW arranger editor (like the MAPPY map editor) hosting a large timeline with the same drag-to-move + all the edit ops + a SNAP bar/beat toggle; it reads/writes the SAME synced arrangement so the card, the pop-out, and peers stay in lock-step. The arrangement is Y.Doc-synced; drags commit one transactional write on drop (no per-frame store churn). All ports live on the yellow drill-down PATCH PANEL (no side jacks); knobs are MIDI / control-surface assignable. Usage: build a few note clips per instrument, patch each lane's PITCH/GATE into its own voice, start TIMELORDE, then launch/quantize-switch clips + scenes from the card (or a monome grid) to perform, RECORD a take into the arrangement (REPLACE or OVERDUB) and refine it by dragging blocks on the timeline (in-card or the pop-out editor). A faithful monome Kria step-sequencer ships as the separate `kria` module.

outputs

pitch1 polyPitchGate
gate1 gate
vel1 cv
pitch2 polyPitchGate
gate2 gate
vel2 cv
pitch3 polyPitchGate
gate3 gate
vel3 cv
pitch4 polyPitchGate
gate4 gate
vel4 cv
pitch5 polyPitchGate
gate5 gate
vel5 cv
pitch6 polyPitchGate
gate6 gate
vel6 cv
pitch7 polyPitchGate
gate7 gate
vel7 cv
pitch8 polyPitchGate
gate8 gate
vel8 cv

inputs

stop_all gate

params

stepDiv 0..3
octave -2..2
gateLength 0.1..1
quantize 0..1
snh 0..1

example js

spawn('clipplayer', 'x');
set('x', 'stepDiv', 2);
patch('x.pitch1', 'x.stop_all');

drumseqz drumseqz

4-channel x 16-step drum sequencer with per-track Euclidean fills + quantized CV. Sister module to RIOTGIRLS.

outputs

gate1 gate
pitch1 pitch
gate2 gate
pitch2 pitch
gate3 gate
pitch3 pitch
gate4 gate
pitch4 pitch
clock gate

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
clock gate

params

bpm 30..300
length 1..128
octave -2..2
gateLength 0.1..0.95
swing 0..0.75
isPlaying 0..1
trk1_euclid 0..16
trk1_root 33..114
trk1_octave -2..2
trk2_euclid 0..16
trk2_root 33..114
trk2_octave -2..2
trk3_euclid 0..16
trk3_root 33..114
trk3_octave -2..2
trk4_euclid 0..16
trk4_root 33..114
trk4_octave -2..2

example js

spawn('drumseqz', 'x');
set('x', 'bpm', 120);
patch('x.gate1', 'x.play_cv');

feature cv featurecv

FEATURECV — an audio→CV feature extractor. Takes ONE audio input and turns the WHOLE signal's timbre + dynamics into control voltages plus an onset trigger, time-domain only (no FFT) so it is fully deterministic. Deliberately distinct from SYNESTHESIA (per-band energy/gates/onsets); featurecv analyses the broadband signal. Features — LOUD (cv): broadband RMS = overall loudness/energy. BRIGHT (cv): zero-crossing rate, a cheap spectral-brightness proxy (high = hissy/trebly, low = dark/bassy). PUNCH (cv): crest factor (peak ÷ RMS) = how spiky/transient vs sustained/compressed. ONSET (gate, edge=trigger): a short pulse that fires ONCE on each fresh attack/transient (time-domain spectral-flux peak-pick with an adaptive threshold + debounce). The three feature CVs are emitted BIPOLAR (−1..+1) by DEFAULT so a strong feature sweeps a knob-centred destination's FULL range; the POLARITY toggle switches to UNIPOLAR (0..1) for envelope-style modulation. Controls — GAIN: input trim into the analyser (×0.25..×4 log, unity at noon). ATK / REL: attack + release smoothing (ms, log) of the three feature CVs. POLARITY: BI [-1,+1] (default) / UNI [0,1]. SENS: onset sensitivity (linear; higher fires on smaller transients). DEBNCE: onset debounce (ms, log; minimum gap between triggers). DSP is own-code (clean-room) in packages/dsp/src/lib/featurecv-dsp.ts, reusing the synesthesia EnvFollower one-pole + applyBipolar + the time-domain flux-onset idea; the worklet wraps it (the SYNESTHESIA/SPECTROGRAPH analyser pattern: GAIN GainNode → worklet → per-feature output GainNodes + a muted keep-alive so process() runs while outputs are unpatched). The card shows live LOUD/BRIGHT/PUNCH meters + an ONSET blink (display only — never writes the live Y.Doc). All patching is via the card's yellow drill-down PATCH PANEL — no side jacks; every knob is MIDI / control-surface assignable. Usage: patch LOUD into a VCA/filter to track dynamics, BRIGHT into a filter cutoff so the timbre opens as the source brightens, PUNCH into modulation that should react to transients, and ONSET into an envelope generator or drum voice to fire on each hit.

outputs

loud cv
bright cv
punch cv
onset gate

inputs

in audio

params

gain 0.25..4
attack 0.5..500ms
release 1..2000ms
bipolar 0..1
onset_sens 0..1
onset_debounce 20..1000ms

example js

spawn('featurecv', 'x');
set('x', 'gain', 1);
patch('x.loud', 'x.in');

grids grids

Topographic drum pattern generator (Mutable Instruments Grids port). Walks a 32-step pattern reading a 5x5 "drum map": the (X, Y) coordinate bilinearly interpolates BD/SD/HH step densities between the four surrounding map nodes. Per-channel DENSITY sets each instrument fill, CHAOS adds per-pattern randomness, SWING shifts off-steps, and steps with level > 192 fire an ACCENT. Outputs BD/SD/HH triggers + a combined accent gate + a chained clock. Runs off its internal tempo or an external clock (rising edges advance one step). Alternate EUCLIDEAN mode swaps the drum map for a 32x32 length-vs-density euclidean LUT.

outputs

bd gate
sd gate
hh gate
accent gate
clock gate

inputs

clock gate
reset gate
mapX_cv cv
mapY_cv cv
bdDensity_cv cv
sdDensity_cv cv
hhDensity_cv cv
chaos_cv cv
swing_cv cv

params

tempo 30..300
mode 0..1
mapX 0..1
mapY 0..1
bdDensity 0..1
sdDensity 0..1
hhDensity 0..1
chaos 0..1
swing 0..0.75
isPlaying 0..1

example js

spawn('grids', 'x');
set('x', 'tempo', 120);
patch('x.bd', 'x.clock');

kria kria

KRIA — a 4-track grid step-sequencer, a clean-room reimagining of monome's Kria (inspired by monome Kria; behavior reimplemented from monome's public docs, no monome source or doc prose reproduced). Like CLIP PLAYER it is a browser-native companion to a monome grid 128 (WebSerial, no native helper — see lib/control/monome) but is FULLY usable from the card with a mouse. MODEL: four INDEPENDENT tracks, each with its own per-step sequences edited on separate PAGES selected from a nav row. Pages (Phase A): TRIG (does the step fire? + per-step ratchet subdivisions), NOTE (the Y axis picks a pitch DEGREE within the active scale), OCTAVE (per-step +0..+5 octave offset), DURATION (per-step gate length as a fraction of the step). Per-track extensions: LOOP (per-track loop start + length, wrapping), TIME (per-track clock DIVISION — advance once every N base ticks), DIRECTION (forward / reverse / pingpong / drunk / random), and per-step PROBABILITY (4-level) + GLIDE (pitch slew). A shared SCALE (major / minor / pentatonic / chromatic) maps NOTE degrees to V/oct. 16 PATTERN slots each hold a full snapshot of all four tracks; switching patterns is QUANTIZED — tap a slot to CUE it and the engine swaps it in on the next track-0 loop boundary (or after a cue-clock countdown). CLOCK: locks to the rack's TIMELORDE singleton (runs only while TIMELORDE.running, tempo = TIMELORDE.bpm); patch an external CLOCK IN to override the tempo (each rising edge advances the base grid, via the canonical windowed edge counter — no double-count), and a RESET IN rising edge re-anchors every track to its loop start. Without a TIMELORDE node the card's BPM knob + RUN button drive it. CARD: a TRACK selector (1-4), a PAGE selector (TRG/NTE/OCT/DUR + PAT), a 16-step editor for the selected track+page (with a clock-locked playhead column), and a 16-slot pattern strip (tap empty = create + activate, tap another = cue a quantized switch); a GRID button connects + binds a monome grid (capability-gated, Chromium) so the same edits + cues happen on hardware with live varibright LED feedback. Inputs — CLOCK IN (external clock, rising edge advances), RESET IN (rising edge re-anchors all tracks). Outputs (the Ansible Kria shape) — PITCH 1-4 (per-track V/oct with per-step glide slew) + GATE 1-4 (per-track gates; DURATION shapes the width, ratchet subdivides). All ports live on the yellow drill-down PATCH PANEL (no side jacks); the BPM knob is MIDI / control-surface assignable. USAGE: patch each track's PITCH+GATE into a voice (VCO + VCA/ADSR), clock from TIMELORDE, build trig/note/octave/duration patterns per track from the card or a monome grid, then perform by cueing pattern slots for quantized arrangement changes.

outputs

pitch1 pitch
gate1 gate
pitch2 pitch
gate2 gate
pitch3 pitch
gate3 gate
pitch4 pitch
gate4 gate

inputs

clock gate
reset gate

params

bpm 30..300
running 0..1

example js

spawn('kria', 'x');
set('x', 'bpm', 120);
patch('x.pitch1', 'x.clock');

lfo lfo

Clockable LFO with four phase outputs (0deg / 90deg / 180deg / 270deg).

outputs

phase0 cv
phase90 cv
phase180 cv
phase270 cv

inputs

clock gate
rate cv
shape cv
depth_cv cv

params

rate 0.01..100Hz
shape 0..2
depth 0..1

example js

spawn('lfo', 'x');
set('x', 'rate', 1);
patch('x.phase0', 'x.clock');

macseq macseq

16-step sequencer with a per-step MACROOSCILLATOR voice picker. Each step carries an on/off gate, a MIDI note, and a synthesis-model index. Outputs PITCH (V/oct), GATE (fires on every on-step), CLOCK (a 10 ms pulse per advance for chaining), and MODELCV — a CV cable carrying the step's selected model index, rescaled into the project's bipolar ±1 convention so it lands on MACROOSCILLATOR's discrete model_cv input and reconstructs the integer at the other end. Empty model steps hold the last emitted model (the first emit defaults to model 0 / VA), so sparser patterns "leave it where it was." Lets one sequencer drive both the pitch and the timbre/engine of a MACROOSCILLATOR voice.

outputs

pitch pitch
gate gate
modelcv cv
clock gate

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
queue5_cv gate
queue6_cv gate
queue7_cv gate
queue8_cv gate
next_cv gate
prev_cv gate
random_cv gate
clock gate

params

bpm 30..300
length 1..128
octave -2..2
gateLength 0.1..0.95
isPlaying 0..1

example js

spawn('macseq', 'x');
set('x', 'bpm', 120);
patch('x.pitch', 'x.play_cv');

nine lives ninelives

LFO with NINE CV outputs on a geometric 1/3 rate ladder + a reset trigger. out1 runs at the Rate knob (identical to a normal LFO); each subsequent output is 1/3 the rate of the previous, so out_n = rate * (1/3)^(n-1) — out2 = rate/3, out3 = rate/9, ... out9 = (1/3)^8 = rate/6561 (~0.0001524x). All nine taps share ONE Waveform morph (sine -> saw -> square). A rising edge on RESET re-zeroes every phase so all outputs re-sync to phase 0 together. Ports live on the yellow drill-down PATCH PANEL (no raw side jacks).

outputs

out1 cv
out2 cv
out3 cv
out4 cv
out5 cv
out6 cv
out7 cv
out8 cv
out9 cv

inputs

reset gate

params

rate 0.01..100Hz
shape 0..2

example js

spawn('ninelives', 'x');
set('x', 'rate', 1);
patch('x.out1', 'x.reset');

peaks peaks

Dual-channel multi-mode utility (Mutable Instruments Peaks archetype, Émilie Gillet, 2013, MIT-licensed). Each channel selects one of five modes — KICK (sine carrier + pitch envelope + amp envelope), SNARE (body sine + filtered noise + decay), HIHAT (six-square metallic cluster + bandpass + decay), ENV (attack-decay envelope, CV-output 0..1, re-attacks on gate), LFO (sine/triangle/square, CV-output ±1, phase resets on gate). Two mode-dependent knobs per channel: knob1 = pitch/mix/brightness/attack/rate; knob2 = decay or waveshape. Gate input retriggers the active engine on rising edges. v1 ships five modes; multistage envelope / tap-LFO / BPF mode deferred to follow-up.

outputs

out0 audio
out1 audio

inputs

gate0 gate
gate1 gate
mode0_cv cv
mode1_cv cv
k1_0_cv cv
k2_0_cv cv
k1_1_cv cv
k2_1_cv cv

params

mode0 0..?
mode1 0..?
k1_0 0.001..200
k2_0 0.001..5
k1_1 0.001..200
k2_1 0.001..5

example js

spawn('peaks', 'x');
set('x', 'mode0', 4);
patch('x.out0', 'x.gate0');

polyseqz polyseqz

Polyphonic chord sequencer. 32-step grid; each step holds a root note + chord quality (maj/min/maj7/min7/dom7/sus2/sus4/dim/aug) + inversion (0/1/2) + voicing (closed/open/spread). Outputs the full 5-voice chord on a polyPitchGate cable. HUMANIZE knob adds per-voice timing offsets (linear/uniform at low values, chaotic clusters at high values) for a human-pianist feel. An upper-right S&H toggle (ON by default) bakes in a gate-sampled Sample & Hold on the per-lane pitch CV: each lane's pitch is pinned to the un-jittered nominal step time (keeping only a ~1-sample lead before its gate) and latches to its own gate edge, so the pitch holds cleanly while the GATE keeps its humanize jitter. Turn S&H OFF for the legacy pre-gate-lead write where pitch can drift ahead of the gate under humanize. Tested as the chord source for DX7-style polyphonic synth voices.

outputs

poly polyPitchGate
gate gate
clock gate

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
clock gate
humanize_cv cv

params

bpm 30..300
length 1..128
octave -2..2
gateLength 0.1..0.95
humanize 0..1
isPlaying 0..1
snh 0..1

example js

spawn('polyseqz', 'x');
set('x', 'bpm', 90);
patch('x.poly', 'x.play_cv');

scenechange atlantisCatalyst

SCENECHANGE (internal type id stays `atlantisCatalyst` for save compatibility) — a slow-drift "macro brain" that nudges a whole patch into new states without you touching every knob. Emits eight correlated band-limited random-walk CV outputs (drift1–drift8): a COHERENCE control sets how tightly each channel tracks a shared "weather" voltage versus wandering independently, and the drift rate ranges from a few seconds to minutes between scene changes. A scene_pulse gate fires on each transition to a new attractor, scene_idx CV reports the current scene for downstream sequencing, and a transport row (play + scene1–4 gates) plus a manual NUDGE gate and a FREEZE latch give explicit scene recall. Pure JS (eight ConstantSourceNodes driven by a ~40 Hz orchestrator with smoothed transitions). The "catalyst-controller" of the Atlantis-patch concept.

outputs

drift1 cv
drift2 cv
drift3 cv
drift4 cv
drift5 cv
drift6 cv
drift7 cv
drift8 cv
scene_pulse gate
scene_idx cv

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
nudge gate
freeze gate
seed_cv cv

params

driftRate 0..1
chaos 0..1
coherence 0..1
sceneDepth 0..1
autoMode 0..1
bias -1..1
level 0..1

example js

spawn('atlantisCatalyst', 'x');
set('x', 'driftRate', 0);
patch('x.drift1', 'x.play_cv');

score score

Sheet-music sequencer. 8-bar treble-clef staff, click to place notes. Outputs pitch / gate / env (ADSR x dynamic) / clock.

outputs

pitch pitch
gate gate
env cv
clock gate

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
clock gate
attack cv
decay cv
sustain cv
release cv

params

bpm 30..300
attack 0.001..10s
decay 0.001..10s
sustain 0..1
release 0.001..10s
isPlaying 0..1

example js

spawn('score', 'x');
set('x', 'bpm', 120);
patch('x.pitch', 'x.play_cv');

sequencer sequencer

32-step sequencer with internal BPM clock or external clock input. An upper-right S&H toggle (ON by default) bakes in a gate-sampled Sample & Hold on the pitch CV: the pitch output is (re)written only on a gated step, so it LATCHES to the gate edge and HOLDS constant between gates (no external S&H needed). Turn S&H OFF for the legacy continuous behavior where pitch can drift/reset on rests.

outputs

pitch polyPitchGate
gate gate
clock gate

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
queue5_cv gate
queue6_cv gate
queue7_cv gate
queue8_cv gate
next_cv gate
prev_cv gate
random_cv gate
clock gate

params

bpm 30..300
length 1..128
octave -2..2
gateLength 0.1..0.95
swing 0..0.75
isPlaying 0..1
snh 0..1

example js

spawn('sequencer', 'x');
set('x', 'bpm', 120);
patch('x.pitch', 'x.play_cv');

stages stages

6-segment cascadable function generator (Mutable Instruments Stages archetype, Émilie Gillet, 2017, MIT-licensed). Each segment selects a TYPE — RAMP (phase 0→1 over TIME seconds, shape-warped via the Tides-style curve from the C++ segment_generator), HOLD (constant LEVEL with shape-controlled portamento), or STEP (sample-and-hold of LEVEL on each gate rising edge). Adjacent segments can be LINKed via 5 boundary toggles to form multi-stage envelopes: a single RAMP→HOLD→RAMP chain reproduces an AHD envelope; chaining all 6 segments builds an AHDSR or arbitrary multi-stage curve. The leader segment of each chain group fires on its own GATE input; subsequent linked segments take over in sequence as each completes. A global TRIG input fires every chain group's leader at once. Each segment has its own CV output that mirrors its chain's current value, so any segment can be tapped. v1 ships TYPE + LINK + GATE + TRIG + per-segment CV inputs for primary + shape; Outliner / chord mode, the all-STEP tap-tempo grid mode, and looping LFO mode (with rate CV) are deferred to follow-up PRs.

outputs

out0 cv
out1 cv
out2 cv
out3 cv
out4 cv
out5 cv

inputs

gate0 gate
gate1 gate
gate2 gate
gate3 gate
gate4 gate
gate5 gate
trig gate
primary0_cv cv
primary1_cv cv
primary2_cv cv
primary3_cv cv
primary4_cv cv
primary5_cv cv
shape0_cv cv
shape1_cv cv
shape2_cv cv
shape3_cv cv
shape4_cv cv
shape5_cv cv

params

type0 0..2
type1 0..2
type2 0..2
type3 0..2
type4 0..2
type5 0..2
primary0 -1..1
primary1 -1..1
primary2 -1..1
primary3 -1..1
primary4 -1..1
primary5 -1..1
shape0 0..1
shape1 0..1
shape2 0..1
shape3 0..1
shape4 0..1
shape5 0..1
link0 0..1
link1 0..1
link2 0..1
link3 0..1
link4 0..1

example js

spawn('stages', 'x');
set('x', 'type0', 0);
patch('x.out0', 'x.gate0');

tides2 tides2

Tidal modulator / poly-slope generator (Mutable Instruments Tides 2018 archetype, Émilie Gillet, MIT-licensed). Clean-room TypeScript port of eurorack/tides2 (poly_slope_generator, ramp_generator, ramp_shaper, ramp_extractor). A versatile ramp / LFO / envelope generator with FOUR related outputs whose relationship is set by OUTPUT MODE: GATES (main slope + variant + end-of-attack + end-of-rise pulses), AMP (four amplitude-stepped copies — SHIFT pans a triangular gain window across the four), PHASE (four progressively phase-shifted copies — SHIFT sets the spread), FREQ (four frequency-divided/multiplied copies — SHIFT picks the ratio set from a 21-entry harmonic/subharmonic sequence). RAMP MODE selects AD (one-shot attack-decay), LOOP (free-running oscillator/LFO), or AR (gated attack-release, also follows an external clock). RANGE selects LFO (slow ≈0.03–30 Hz) / AUDIO (≈8 Hz–8 kHz) / TEMPO (external-clock-synced via the ramp extractor). FREQUENCY tracks 1 V/oct; SHAPE morphs the slope wave; SLOPE is the attack-vs-decay pulse width; SMOOTHNESS smooths (below 0.5) or wavefolds (above 0.5). v1 deviations from bit-exactness: the SHAPE morph is a procedural sine→triangle→ramp→expo bank rather than MI's binary lut_wavetable, the ramp extractor is a moving-average period predictor (rhythmic-pattern + constant-PW predictors folded in), and audio-range BLEP anti-aliasing is omitted.

outputs

out0 cv
out1 cv
out2 cv
out3 cv

inputs

voct pitch
trig gate
clock gate
freq_cv cv
shape_cv cv
slope_cv cv
smooth_cv cv
shift_cv cv

params

frequency 0..1
shape 0..1
slope 0..1
smoothness 0..1
shift 0..1
rampMode 0..2
outputMode 0..3
range 0..2

example js

spawn('tides2', 'x');
set('x', 'frequency', 0.5);
patch('x.out0', 'x.voct');

timelorde timelorde

Singleton master clock. Internal or external BPM, twelve clock-divider outputs. A TAP button sets the internal tempo by ear — tap twice in time to lock the BPM, keep tapping to refine it (median of the recent intervals, ~2s timeout starts a fresh count); the Spacebar taps it too while TIMELORDE is the selected node. TAP is greyed out and a no-op while an external clock is patched into CLOCK IN (the measured external tempo owns the BPM then). The card carries a big display of the owl painting whose YELLOW EYES and BLUE BORDER brighten in time with the beat (the body stays steady); patch a feed into VIDEO IN and the display becomes a live monitor while VIDEO OUT passes the feed through (TIMELORDE can sit inline in a video chain).

outputs

1x gate
8x gate
4x gate
2x gate
1/2 gate
1/3 gate
1/4 gate
1/8 gate
1/12 gate
1/16 gate
1/32 gate
1/64 gate
swing gate
video_out video

inputs

clock gate
start_in gate
stop_in gate
gate gate
video_in video

params

bpm 10..300bpm
swingAmount 0..90deg
swingSource 0..10
muteOutputs 0..1
running 0..1
wizardOn 0..1

example js

spawn('timelorde', 'x');
set('x', 'bpm', 120);
patch('x.1x', 'x.clock');

writeseq writeseq

RECORDING step-sequencer: the app's usual step sequencer PLUS live recording from a CV/gate source (e.g. MIDI CV BUDDY / a mini-keyboard via MIDI→CV). The incoming CV (pitch, 0V = C4) + GATE pass through to the outputs at all times (live monitoring) ALONGSIDE sequenced playback — a held live gate WINS over the sequenced step. Arm RECORD (the rec gate input also toggles arm) and each incoming gate writes its sampled pitch+gate to the step nearest the press (snap-to-nearest quantization); recording starts by jumping to step 1. If the sequencer is STOPPED but armed, a gate event STARTS the sequencer + recording (internal clock only — an external clock that is stopped emits no pulses, so a gate there only passes through). NOT overdubbing: record runs one pass up to LENGTH steps then stops recording (auto-disarms) and loops to play through. OVERDUB: keep looping, layering new events on top. STEP CLOCK: an external clock patched into CLOCK IN drives one step per rising edge (respecting its timing); unpatched, WRITESEQ runs its own internal BPM. RUN/RECORD state is INDEPENDENT of TIMELORDE — it is armed + started by the user, never auto-started/stopped with the system clock. Outputs PITCH (V/oct) + GATE (the sequenced outputs, with live pass-through) + CLOCK (a 10 ms pulse per advance). Sharing one clock with a drum module (e.g. DRUMSEQZ / DRUMMERGIRL) records a key in time with the beat onto the SAME step the drum hits — no off-by-one in either direction. The data model reserves a per-step shift field for a future swing-to-1/4-step feature (not yet implemented).

outputs

pitch pitch
gate gate
clock gate

inputs

play_cv gate
reset_cv gate
queue1_cv gate
queue2_cv gate
queue3_cv gate
queue4_cv gate
cv pitch
gate gate
clock gate
rec gate

params

bpm 30..300
length 1..128
octave -2..2
gateLength 0.1..0.95
isPlaying 0..1
recArm 0..1
overdub 0..1

example js

spawn('writeseq', 'x');
set('x', 'bpm', 120);
patch('x.pitch', 'x.play_cv');

filters

904a vcf moog904a

904A Voltage Controlled Low Pass Filter (slice 2 of the moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). The classic moogafakkin transistor-LADDER low-pass filter, 24 dB/oct. Cutoff is set by the FIXED CONTROL VOLTAGE (Cutoff) pot, shifted in 2-octave steps by the RANGE switch (1/2/3 = x1/x4/x16), and swept by the summing 1V/oct CONTROL INPUT (cutoff_cv — each volt = one octave, summed per-sample). REGENERATION is the variable Q / internal feedback: at low settings it is a clean low-pass; turned toward max it sharpens into a strong resonant peak and SELF-OSCILLATES into a clean sine VC oscillator at the cutoff frequency (reso_cv modulates it). Signature moogafakkin growl comes from a tanh saturation per ladder stage that also self-limits the resonance so it stays bounded. DSP is own-code, CLEAN-ROOM: a TPT/Zavalishin zero-delay-feedback ladder (stable under audio-rate cutoff modulation) re-derived from the unpatented textbook algorithm plus the Huovilainen tanh-per-loop technique — NOT a port of the LGPLv3 Huovilainen code, the CC-BY-SA musicdsp model, or any moogafakkin schematic (permissive only). The shared moog-ladder-dsp lib it is built on is reused by the 904B (HPF) + 904C (coupler) in later slices. Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio

inputs

audio audio
cutoff_cv cv
reso_cv cv

params

cutoff 20..20000Hz
range 1..3
regeneration 0..1

example js

spawn('moog904a', 'x');
set('x', 'cutoff', 1000);
patch('x.audio', 'x.audio');

904b vcf moog904b

904B Voltage Controlled High Pass Filter (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). The high-pass companion to the 904A LPF: a 24 dB/oct transistor-LADDER HIGH-pass, built (like the hardware) by SUBTRACTING the ladder's low-passed signal from the input (input - lp4 -> the complementary 4-pole high-pass). Cutoff is set by the FIXED CONTROL VOLTAGE (Cutoff) pot, shifted by a two-position RANGE switch (LOW = the full 4 Hz–20 kHz span / HIGH = +1.5 octaves), and swept by the summing 1V/oct CONTROL INPUT (cutoff_cv — each volt = one octave, summed per-sample). Unlike the 904A there is NO regeneration / resonance knob (the hardware 904B has no resonance pot), so the ladder runs with zero feedback. DSP is own-code, CLEAN-ROOM: it CONSUMES the same shared transistor-ladder core the 904A uses (TPT/Zavalishin zero-delay-feedback ladder via its hpDerive high-pass tap) — NOT a port of the LGPLv3 Huovilainen code, the CC-BY-SA musicdsp model, or any moogafakkin schematic (permissive only). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio

inputs

audio audio
cutoff_cv cv

params

cutoff 4..20000Hz
range 1..2

example js

spawn('moog904b', 'x');
set('x', 'cutoff', 1000);
patch('x.audio', 'x.audio');

904c voltage controlled filter coupler moog904c

904C Voltage Controlled Filter Coupler (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). Chains an internal moogafakkin-ladder low-pass + high-pass into a CV-controlled BAND-PASS / band-reject: CUTOFF, WIDTH (LP/HP spread) and MODE (BP to BR) knobs plus a 1V/oct cutoff CV input. DSP composes two ladder instances (own-code clean-room ladder). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio

inputs

audio audio
cutoff_cv cv

params

cutoff 20..20000Hz
width 0..1
mode 0..1

example js

spawn('moog904c', 'x');
set('x', 'cutoff', 800);
patch('x.audio', 'x.audio');

907a fixed filter bank moog907a

907A Fixed Filter Bank (moogafakkin System 35 clone — categorized under Ports -> moogafakkin). Non-VC fixed filter bank: a high-pass + low-pass + several fixed center-frequency band-pass cells (12 dB/oct), each with its own level knob, summed to one output. Shares the moog-filterbank center-frequency lib with the 914. Own-code (textbook biquad bank). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio

inputs

audio audio

params

hp 0..1
lp 0..1

example js

spawn('moog907a', 'x');
set('x', 'hp', 0.5);
patch('x.audio', 'x.audio');

914 extended fixed filter bank moog914

914 Extended-Range Fixed Filter Bank (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). The extended fixed filter bank: 1 high-pass + 1 low-pass + 12 fixed center-frequency band-pass cells (12 dB/oct), each level-knob-controlled, summed to one output. Shares the moog-filterbank center-frequency lib with the 907A. Own-code (textbook biquad bank). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio

inputs

audio audio

params

hp 0..1
lp 0..1

example js

spawn('moog914', 'x');
set('x', 'hp', 0.5);
patch('x.audio', 'x.audio');

filter filter

Multi-mode resonant filter (low / band / high). CV inputs sum into cutoff and resonance.

outputs

audio audio

inputs

audio audio
cutoff cv
res cv

params

cutoff 20..20000Hz
resonance 0..0.99
mode 0..2

example js

spawn('filter', 'x');
set('x', 'cutoff', 1000);
patch('x.audio', 'x.audio');

qbrt qbrt

Stereo state-variable filter with vactrol-style ping input.

outputs

L audio
R audio

inputs

L audio
R audio
ping gate
cutoff cv
resonance cv
mode cv
pingDecay cv

params

cutoff 20..20000Hz
resonance 0..0.99
mode 0..1
pingDecay 0.005..0.5s

example js

spawn('qbrt', 'x');
set('x', 'cutoff', 1000);
patch('x.L', 'x.L');

effects

aquatank aquaTank

4-channel feedback-delay-network (FDN) reverb / resonator. Four audio inputs feed a Hadamard mixing matrix wrapped in delay lines with per-line feedback (F1–F4), so energy recirculates and cross-mixes between the four channels — short feedback gives lush chorus/early-reflection ambience, long feedback turns it into a ringing metallic resonator. TILT skews the feedback balance across the four lines, DAMP rolls off high frequencies in the loop, CROSS sets how much the channels bleed into each other, SPREAD widens the stereo image, OUT trims level. Four direct mono outs (out1–out4) plus a summed stereo mix (mix_l / mix_r). One of the three ATLANTIS-PATCH support modules, but works standalone as a reverb, chorus, or feedback-resonance unit.

outputs

out1 audio
out2 audio
out3 audio
out4 audio
mix_l audio
mix_r audio

inputs

in1 audio
in2 audio
in3 audio
in4 audio
fb1_cv cv
fb2_cv cv
fb3_cv cv
fb4_cv cv
tilt_cv cv

params

fb1 0..0.95
fb2 0..0.95
fb3 0..0.95
fb4 0..0.95
tilt -1..1
damp 0..1
crossMix 0..1
spread 0..1
outLevel 0..1

example js

spawn('aquaTank', 'x');
set('x', 'fb1', 0.4);
patch('x.out1', 'x.in1');

backdraft backdraft

BACKDRAFT is a video feedback generator. It builds a "source" image by crossfading two video inputs (IN A / IN B) with MIX, then composites that against a processed copy of its OWN previous output, read from an internal ring of past frames so there is no live GL feedback loop (downstream sees frame N while the tap reads N-1..N-30). The fed-back frame is delayed (DELAY, 0-500ms or a clock pulse), colour-processed (per-channel R/G/B gain, then LUMA brightness, then CHROMA saturation), scaled per-pixel by two key masks (KEY+ lightens / KEY- darkens the effect), and geometrically warped a little each pass (ZOOM/ROTATE/OFF X/OFF Y) so the transform COMPOUNDS into tunnels, spirals, and directional trails. Two MIRROR buttons fold the whole composited frame into a kaleidoscope. A SHAPE button cuts the frame to a geometric mask (square = full frame, then circle / pentagon / triangle / octagon), and a PURE GEO button picks the masking SPACE: ON masks the FINAL OUTPUT in screen space (a fixed shape that cuts everything outside it at all zooms), OFF masks the SOURCE in the zoomed feedback space so the shape scales with ZOOM and its content spills out through the feedback tunnel (zoom-in pushes it toward the corners, zoom-out shrinks it). As FEEDBACK approaches its max (and a spatial transform is active) the additive trail-accumulator ramps into a pure recursive hall of mirrors. Usage: patch a camera or generator into IN A, raise FEEDBACK toward ~1 and nudge ZOOM off 1.0 (with a little ROTATE) for the classic infinite-tunnel look; add OFF X/Y for smear, PIXELATE for blocky lo-fi, a SHAPE for a geometric vignette, and clock DELAY CLK for rhythmic echo. Output is the OUT video jack. The card shows a large live video preview on the left that is resizable via the bottom-right corner-drag handle (width/height persist, snapped to rack tiles); right-click the preview for Full Frame / Full Screen / Present-on-another-display.

outputs

out video

inputs

in_a video
in_b video
lighten video
darken video
mix cv
feedback cv
delay cv
delay_clock cv
luma cv
chroma cv
r cv
g cv
b cv
lighten_cv cv
darken_cv cv
pixelate cv
zoom cv
rotate cv
offsetx cv
offsety cv
mirror_x_gate cv
mirror_y_gate cv
shape_gate cv
pure_geo_gate cv

params

mix 0..1
feedback 0..?
delay 0..?
luma -1..2
chroma -1..2
r -1..2
g -1..2
b -1..2
lighten 0..1
darken 0..1
pixelate 0..1
zoom ?..?
rotate ?..?
offsetX ?..?
offsetY ?..?
delayClock 0..1
mirrorX 0..1
mirrorY 0..1
mirrorXGate 0..1
mirrorYGate 0..1
shape 0..?
pureGeo 0..1
shapeGate 0..1
pureGeoGate 0..1
freeze 0..1

example js

spawn('backdraft', 'x');
set('x', 'mix', 0);
patch('x.out', 'x.in_a');

callsine callsine

Spectral-analysis additive resynthesizer (clean-room port of Warren's Spectrum / CallSine, MIT-licensed). Reads incoming mono audio, runs an FFT-based partial tracker (Hann window → peak detection → McAulay-Quatieri-lite tracking → optional F0 harmonic lock) and rebuilds the sound as an additive bank of up to 64 oscillators. Plaits-style macros: HARMONICS sets the partial count, TIMBRE the smoothing/slew time, MORPH the harmonic-LOCK strength (snaps partials to an F0 grid), LEVEL the output gain. A PITCH (V/oct) input transposes the whole resynth; a GATE input toggles FREEZE, latching the current partials at their current frequencies/amplitudes for sustained pads. Ships 14 voice models (SINES, SAW, SQR, PULSE25, TRI, RAMP, CHEBY3/5, HARDSYNC, FOLD, NOISE, FORMANT, SUBOSC, METAL) that swap the per-partial waveform from pure sinusoids to richer/inharmonic shapes.

outputs

out audio

inputs

audio_in audio
pitch pitch
gate gate
model_cv cv
note_cv cv
harm_cv cv
timb_cv cv
morph_cv cv
level_cv cv

params

model 0..?
note -60..60st
harmonics 0..1
timbre 0..1
morph 0..1
level 0..1

example js

spawn('callsine', 'x');
set('x', 'model', 0);
patch('x.out', 'x.audio_in');

cellshade cellshade

Cel-shader (toon / retro-video-game) video PROCESSOR. Takes a video input and emits a cel-shaded version: the colour is QUANTIZED to a retro N-bit palette and the salient CONTOURS are inked in as BLACK outline strokes (a reused EDGES Sobel pass). STATELESS per frame — the look moves/transforms live with the source. Pipeline: (1) quantize the colour to the chosen bit depth; (2) run a 3×3 Sobel on the input's Rec. 601 LUMINANCE (the exact EDGES algorithm — same normalisation, THRESHOLD gate, THICKNESS dilation) to get a 0/1 edge mask; (3) ink the mask as black lines over the quantized colour: color = mix(quantizedColor, vec3(0.0), edge). BITS is a 5-step DISCRETE knob (the param is the step INDEX 0..4; the card shows the bit value + colour count, and the matching CV input uses a discrete cvScale so it snaps to the 5 steps) mapping to RETRO TOTAL COLOR-DEPTH: 1-bit=2 colours, 2-bit=4, 4-bit=16 (default), 8-bit=256, 16-bit=65536. The quantization is done WELL, per-depth: the LOW depths (1/2/4-bit = 2/4/16 colours) use LUMA-BAND quantization — convert RGB→HSV, keep HUE + SATURATION (gently posterized for the 16-colour budget), quantize only BRIGHTNESS (V) into a few bands, reconstruct RGB — so the result reads as hand-painted flat tonal bands (the cel look) rather than the channel-clipped rainbow a naive per-channel RGB floor produces; 8-bit uses the authentic console RGB 3-3-2 allocation (8 R / 8 G / 4 B levels = 256) and 16-bit the RGB 5-6-5 allocation (32 R / 64 G / 32 B = 65536). THRESHOLD (0..1, default 0.2) gates which contours get inked — raise it to ink only the strongest edges, lower it for more outline. THICKNESS (1..8 px, default 2) dilates the ink stroke wider (morphological MAX, same as EDGES). THRESHOLD / THICKNESS / BITS each have a matching CV input (port id == param id). IN takes RGB; OUT is video — patch a source (CAMERA / VIDEOBOX / SHAPES / a generator) → IN, OUT → OUTPUT or a video mixer; sweep BITS for the colour-depth retro step, THRESHOLD/THICKNESS to tune the ink.

outputs

out video

inputs

in video
threshold cv
thickness cv
bits cv

params

threshold 0..1
thickness 1..?px
bits 0..?

example js

spawn('cellshade', 'x');
set('x', 'threshold', 0);
patch('x.out', 'x.in');

charlotte's echos charlottesEchos

Destructive multi-head stereo delay. Pitch-shifted feedback with decay.

outputs

L audio
R audio

inputs

L audio
R audio
delay cv

params

delay 0.001..1.5s
feedback 0..1
decay 0..1
pitchUp 0..0.2
mix 0..1

example js

spawn('charlottesEchos', 'x');
set('x', 'delay', 0.4);
patch('x.L', 'x.L');

chroma chroma

CHROMA is a single-input hue-shifter / colorizer (not a keyer — use CHROMAKEY to composite a foreground over a background). For every pixel of the incoming video it converts RGB to HSV, rotates the hue by the Hue control (in degrees, wrapped with fract() so it cycles cleanly around the color wheel including negative shifts), multiplies the saturation by the Sat control (0 desaturates to grayscale, 1 leaves color untouched, above 1 intensifies toward fully-saturated color — the result is clamped at maximum saturation so it can't exceed it), converts back to RGB, then lerps the result toward the tint color (tintR/tintG/tintB) by the Mix amount. With Mix at 0 the tint is bypassed and you get a pure hue/saturation pass; at 1 every pixel becomes the flat tint color, with values in between producing a duotone-style wash that biases the image toward the chosen color. Use it to recolor a clip, sweep a video through the spectrum (patch an LFO into hue), drain it to black-and-white, or apply a colored grade. With no input connected the output is opaque black.

outputs

out video

inputs

in video
hue cv
saturation cv
tintR cv
tintG cv
tintB cv
tintMix cv

params

hue -180..180
saturation 0..2
tintR 0..1
tintG 0..1
tintB 0..1
tintMix 0..1

example js

spawn('chroma', 'x');
set('x', 'hue', 0);
patch('x.out', 'x.in');

chromakey chromakey

chromakey is a two-input green-screen compositor: it takes a foreground video (the layer shot against a key colour) and a background video, and replaces every foreground pixel whose hue is close to the chosen key colour with the matching background pixel. Per pixel it converts foreground and key colour to HSV, measures the hue distance, and builds an alpha via smoothstep over the thr/soft window (alpha 0 = show background, alpha 1 = keep foreground); near-gray pixels are biased toward keep so shadows and highlights are not punched out, and edge pixels are desaturated by the spill amount to kill the key-colour halo. Pick the key colour with the swatch (defaults to pure green), then tune thr until the backdrop drops out cleanly, raise soft to feather the matte edge, and add spill to remove green fringing on the subject; if no foreground is patched it just passes the background through.

outputs

out video

inputs

fg video
bg video
keyR cv
keyG cv
keyB cv
threshold cv
softness cv
spillSuppress cv

params

keyR 0..1
keyG 0..1
keyB 0..1
threshold 0..1
softness 0..0.5
spillSuppress 0..1

example js

spawn('chromakey', 'x');
set('x', 'keyR', 0);
patch('x.out', 'x.fg');

clouds clouds

Granular texture processor (Mutable Instruments Clouds archetype, Émilie Gillet, 2014, MIT-licensed) — 2-second stereo ring buffer + overlap-added grain cloud (up to 24 grains) + latched FREEZE. Six macros (Position / Size / Pitch / Density / Texture / Blend) with V/oct grain-pitch tracking on the pitch input. v1 ships GRANULAR mode only; STRETCH / LOOPING-DELAY / SPECTRAL modes deferred to follow-up.

outputs

out_l audio
out_r audio

inputs

in_l audio
in_r audio
pitch pitch
freeze_gate gate
position_cv cv
size_cv cv
pitch_cv cv
density_cv cv
texture_cv cv
blend_cv cv

params

position 0..1
size 0..1
pitch -24..24st
density 0..1
texture 0..1
blend 0..1
freeze 0..1

example js

spawn('clouds', 'x');
set('x', 'position', 0.5);
patch('x.out_l', 'x.in_l');

cloudseed cloudseed

Exact algorithm port of Ghost Note Audio's CloudSeed reverb (MIT-licensed, github.com/GhostNoteAudio/CloudSeedCore). Stereo input cross-mixes then per-channel passes through: optional 1-pole HP + LP pre-EQ → modulated pre-delay → multitap early-reflection field (up to 256 taps, seed-deterministic) → AllpassDiffuser (up to 12 stages) → 12 parallel late-field DelayLine voices, each with optional in-loop AllpassDiffuser + LowShelf + HighShelf + LP, with T60-targeted feedback that produces a precise decay-seconds tail. Cross-seed control divides the L/R seeded delay layouts for stereo decorrelation. 45 parameters total — 7 macros (DRY / EARLY / LATE faders, INPUT MIX, LOW CUT, HIGH CUT, CROSS SEED) are exposed as AudioParams for CV summing; 38 toggle/integer/seed/modulation parameters live on the worklet's message port. Bundled v1 preset bank: DIVINE INSPIRATION (DarkPlate from Programs.h verbatim), SHORT ROOM, BRIGHT HALL, INFINITE PAD. Card footer cycles through the preset bank with click-numbered slots, prev/next arrows, and a live DECAY readout that reflects LateLineDecay's computed RT60.

outputs

out_l audio
out_r audio

inputs

in_l audio
in_r audio
dry_cv cv
early_cv cv
late_cv cv
input_mix_cv cv
low_cut_cv cv
high_cut_cv cv
cross_seed_cv cv

params

dry_out 0..1
early_out 0..1
late_out 0..1
input_mix 0..1
low_cut 0..1
high_cut 0..1
cross_seed 0..1
preset_index 0..?

example js

spawn('cloudseed', 'x');
set('x', 'dry_out', 0.87);
patch('x.out_l', 'x.in_l');

cofefve delay cofefve

Analog BBD/tape-style stereo delay — a clean-room, OWN-CODE engine (the replacement for the retired Cocoa Delay; its own DSP, no GPL lineage). A 10-second stereo delay line read at a fractional position with 4-point Catmull-Rom cubic interpolation; the read time is modulated two ways: a WOW LFO (AMOUNT × sin at FREQUENCY) and a slow random FLUTTER drift walk (AMOUNT × random, SPEED) on a fixed-seed PRNG (deterministic). Feedback is bipolar (−1..+1), clamped just below unity for stability, with a STEREO offset that skews the L/R read times apart and a PAN with three modes (STATIC rotation, PING-PONG feedback cross, CIRCULAR rotating the wet image). DUCKING sidechains the wet level by an envelope follower on the dry input (AMOUNT, ATTACK, RELEASE). A multi-mode TONE filter (1/2/4-pole cascade or state-variable) low-cuts + high-cuts inside the feedback path, and a stateful tanh DRIVE saturator (GAIN / MIX / FILTER, run 1–16 ITERATIONS) dirties the loop. DRY + WET set the output mix. The read pointer eases toward its target so TIME changes glide like a tape motor. TEMPO SYNC locks the delay time to a musical division (1/4, 1/8, dotted, triplet…) of a clock period measured from pulses on the CLOCK gate input; the CLK SRC dropdown labels whether that clock is the rack SYSTEM clock (TIMELORDE) or external MIDI (MIDICLOCK). When sync is Off the TIME knob is free-running seconds. CV inputs cover the musical params: time, feedback, mix, drive, WOW amount, FLUTTER, pan, ducking.

outputs

outL audio
outR audio

inputs

inL audio
inR audio
clock gate
time_cv cv
feedback_cv cv
mix_cv cv
drive_cv cv
lfo_cv cv
drift_cv cv
pan_cv cv
duck_cv cv

params

delayTime 0.001..2s
tempoSync 0..19
clockSource 0..1
syncPeriod 0..30s
lfoAmount 0..0.5
lfoFrequency 0.1..10hz
driftAmount 0..0.05
driftSpeed 0.1..10
feedback -1..1
stereoOffset -0.5..0.5
pan ?..?
panMode 0..2
duckAmount 0..10
duckAttack 0.1..100
duckRelease 0.1..100
filterMode 0..3
lowCut 0.01..1
highCut 0.001..0.99
driveGain 0..10
driveMix 0..1
driveCutoff 0.01..1
driveIterations 1..16
dryVolume 0..2
wetVolume 0..2

example js

spawn('cofefve', 'x');
set('x', 'delayTime', 0.2);
patch('x.outL', 'x.inL');

colorizer colorizer

colorizer tints a mono (single-channel) video signal into a solid color. Each incoming pixel is reduced to a single brightness value by averaging its R, G and B channels, and that brightness then scales a tint color you set with the R/G/B faders: the output pixel is (mono x R, mono x G, mono x B). The result reads as a one-color image whose intensity follows the input's luma, so dark areas stay black and bright areas hit the full tint. Feed it a luma key, an oscilloscope-style mono shape or any video, then dial the three faders to recolor it; with no input connected the output is solid black.

outputs

out video

inputs

in mono-video
tintR cv
tintG cv
tintB cv

params

tintR 0..1
tintG 0..1
tintB 0..1

example js

spawn('colorizer', 'x');
set('x', 'tintR', 0);
patch('x.out', 'x.in');

delay delay

Simple stereo delay line — time, feedback, and dry/wet mix. Built on Web Audio's native DelayNode with a feedback gain loop (input → delay → feedback → output, mixed with dry), the canonical delay topology. TIME ranges log from ~1 ms (slapback) to 2 s (ambient washes), FEEDBACK is linear 0–0.95 with a hard ceiling to prevent runaway self-oscillation, and a time CV input sums onto the knob. The same delay type backs WAVESCULPT's FX slot, so its character matches whether patched inline or used as a slot effect.

outputs

audio audio

inputs

audio audio
time cv

params

time 0.001..?s
feedback 0..?
mix 0..1

example js

spawn('delay', 'x');
set('x', 'time', 0.25);
patch('x.audio', 'x.audio');

destroy destroy

Bitcrusher + decimator distortion.

outputs

audio audio

inputs

audio audio
decimate cv
bits cv
wet cv

params

decimate 1..64
bits 1..16
wet 0..1

example js

spawn('destroy', 'x');
set('x', 'decimate', 1);
patch('x.audio', 'x.audio');

destructor destructor

DESTRUCTOR is a single-pass glitch/mangle effect that runs RGB video in and out. The fragment shader stacks three classic digital-decay artifacts: chromatic aberration (the red channel is sampled slightly left and the blue channel slightly right while green stays put, smearing color along the horizontal axis), scanline disruption (alternating rows of a 240-band horizontal grid are darkened), and posterization (each channel is quantized to a discrete number of levels, crushing smooth gradients into hard color steps). The master Mangle amount scales the chromatic aberration and scanline darkening only — posterization is applied independently from the Posterize control and is NOT affected by Mangle. With no input connected the module outputs solid black. Patch it after a source for a CRT/VHS-style decay, or sweep Mangle with an LFO for a pulsing shift/scanline glitch over a steady posterized base.

outputs

out video

inputs

in video
mangle cv

params

shift 0..1
scanline 0..1
posterize 0..1
mangle 0..1

example js

spawn('destructor', 'x');
set('x', 'shift', 0);
patch('x.out', 'x.in');

edges edges

Per-frame Sobel edge-detection video PROCESSOR. Takes a video input, runs a 3×3 Sobel operator on its per-pixel Rec. 601 LUMINANCE (gradient magnitude = sqrt(Gx²+Gy²), normalised so a unit luma step reads ~1.0), and emits a MONO-VIDEO frame: white where an edge was detected, black everywhere else. STATELESS per frame — the detected edges move/transform live with the source (no feedback, no history). THRESHOLD (0..1, default 0.2) gates which gradients count as edges (below → black; raise it to keep only the strongest contours, lower it to let faint gradients through). THICKNESS (1..8 px, default 2) DILATES the detected edge mask (morphological MAX over a square neighbourhood of radius thickness-1 texels) so a 1px edge renders up to `thickness` px wide; thickness=1 is the raw edge. IN takes RGB; OUT is mono-video (white edges on black) — patch it into OUTPUT, a video mixer, COLORIZER (mono→video upcast), or back into another video module as a key mask. THRESHOLD + THICKNESS each have a matching CV input (port id == param id). Pairs well with a moving source (CAMERA / VIDEOBOX / SHAPES) for live rotoscoped outlines.

outputs

out mono-video

inputs

in video
threshold cv
thickness cv

params

threshold 0..1
thickness 1..?px

example js

spawn('edges', 'x');
set('x', 'threshold', 0);
patch('x.out', 'x.in');

feedback feedback

Analog-video-style feedback loop, the on-screen equivalent of pointing a camera at its own monitor. Each frame it re-samples its OWN previous output from a ping-pong framebuffer through a small affine warp — rotate and scale the UV about the canvas center, plus a tiny XY offset — multiplies that warped tap by Decay, then adds the fresh input (weighted by 1 minus the clamped decay) to form a recursive accumulator. That accumulator is cross-faded against the dry input by Wet and clamped to [0,1] so destructive Decay over 1.0 saturates white instead of NaN-ing. With Zoom slightly above 1 and a touch of Rotate you get the classic infinite spiraling "tunnel"; the prior frame is sampled black outside the canvas (no edge smear) so trails decay into darkness rather than melting along the borders. Patch a camera or any video source into IN, feed OUT back to a monitor, and modulate the warp via the CV inputs for evolving, self-oscillating imagery.

outputs

out video

inputs

in video
wet cv
decay cv
zoom cv
rotate cv
offsetX cv
offsetY cv

params

wet 0..1
decay 0..2
zoom 0.9..1.1
rotate -3.14159..3.14159
offsetX -1..1
offsetY -1..1

example js

spawn('feedback', 'x');
set('x', 'wet', 0);
patch('x.out', 'x.in');

freezeframe freezeframe

FREEZEFRAME fuses two video effects in one card. First, a SAMPLE & HOLD "freeze": with nothing patched to GATE the source passes through live; patch a gate and the module captures the current frame only while the gate is HIGH (level >= 0.5) and FREEZES the last-captured frame whenever it drops low — so an LFO square plays while open and stutter-freezes the instant it closes (a continuously-high gate looks live). The first frame always captures so the buffer seeds with real content instead of black. Second, a PER-CHANNEL POSTERIZE: four QUANT knobs each reduce one channel's colour depth, mapping the sweep geometrically in log2 from 256 levels (full depth) at min, through 32 at midway, to 2 (on/off) at max — crank all four for a hard few-bit posterized look. The shader posterizes each channel with floor(c*levels)/(levels-1); the combined output also applies the QUANT-luma reduction as a hue-preserving luma ratio so that knob still shapes the main out. Five outputs let you tap the recombined image, each isolated channel as a grey intensity image, or the Rec.601 luma. Usage hint: drive GATE from an LFO or clock to strobe/freeze a video feed, then dial the QUANT knobs for VHS/8-bit colour crushing; fan the R/G/B/LUMA taps into separate processors for channel-split effects.

outputs

video_out video
r_out video
g_out video
b_out video
luma_out video

inputs

video_in video
gate_in gate

params

quant_r 0..1
quant_g 0..1
quant_b 0..1
quant_luma 0..1
gateLevel 0..1

example js

spawn('freezeframe', 'x');
set('x', 'quant_r', 0);
patch('x.video_out', 'x.video_in');

luma luma

luma is a luminance-domain color processor for a single video stream. It reads the Rec. 601 brightness (0.299/0.587/0.114) of every pixel, runs that luma through a chain of gamma, contrast (scaled around the 0.5 midpoint), posterize (quantize to N steps), then an additive bias, and finally re-applies the new-luma/old-luma ratio to all three RGB channels so chroma (hue and saturation) is preserved while only tonality changes. Patch a video source into in and use it to crush blacks, lift gamma, flatten the image into hard tonal bands, or shift overall brightness; with the defaults (gamma 1, cntr 1, post 16, bias 0) the picture passes through essentially untouched. Note this is NOT a keyer — for foreground/background luma compositing use lumakey instead.

outputs

out video

inputs

in video
gamma cv
contrast cv
posterizeLevels cv
bias cv

params

gamma 0.1..3
contrast 0..2
posterizeLevels 2..16
bias -0.5..0.5

example js

spawn('luma', 'x');
set('x', 'gamma', 0);
patch('x.out', 'x.in');

lumakey lumakey

lumakey is a two-input luminance-key compositor: it lays a foreground frame over a background frame and decides, pixel by pixel, which one shows through based on how bright the foreground is. It computes Rec. 601 luma of the foreground, then builds an alpha mask with smoothstep(threshold - softness, threshold + softness, luma) so bright foreground pixels become opaque (alpha 1, foreground shows) and dark ones drop out (alpha 0, background bleeds through), finally mixing background toward foreground by that alpha. Use it to matte out a black or white plate behind a source, drop text/letterbox overlays onto a scene, or composite a bright source over another video; flip invert to key on the dark areas instead. With no foreground patched it passes the background straight through so a half-wired chain is never a black hole.

outputs

out video

inputs

fg video
bg video
threshold cv
softness cv
invert cv

params

threshold 0..1
softness 0..0.5
invert 0..1

example js

spawn('lumakey', 'x');
set('x', 'threshold', 0);
patch('x.out', 'x.fg');

mapper mapper

Video KEYER / MATTE processor. Shows a VIDEO input ONLY where a KEY input is active, BLACK everywhere else — a generalisation of OUTLINES' `mapped` output (which showed its video input only where ≥2 shapes overlapped) to an ARBITRARY key. STATELESS per frame: the keyed region moves/transforms live with the key source (no feedback, no history) — a pure function of the current video frame, the current key frame, and the THRESHOLD knob. Algorithm (per output texel): read the KEY input's Rec. 601 LUMINANCE (the same luma weights LUMA / EDGES / LUMAKEY use), mask = smoothstep(threshold − 0.03, threshold + 0.03, keyLuma) (a sub-pixel-small soft edge band around the cutoff that keeps the key effectively CRISP — mask → 1 well above threshold, 0 well below — while removing the 1-texel aliasing a hard step shows on a moving key), then out = video × mask (video shows where the key is bright; fades to black below threshold). THRESHOLD (0..1, default 0.5): the key cutoff — RAISE it to SHRINK the keyed area (only the brightest key regions pass), LOWER it to GROW it (dimmer key regions pass too); this is the knob OUTLINES.mapped hard-coded to "≥2 overlaps". THRESHOLD has a matching CV input (port id == param id). VIDEO takes RGB; KEY is declared `video` so BOTH a colour video source AND a MONO-VIDEO source (white-on-black SHAPES / LINES / EDGES output, which upcasts to video for free) can drive it — its luminance is the mask. A half-patched MAPPER (missing VIDEO or KEY) is intentionally BLACK (mirrors OUTLINES.mapped's unpatched-video behaviour) so an unfinished chain reads as "not done yet" rather than passing the raw video through unkeyed. Usage: patch a source → VIDEO, a high-contrast matte (SHAPES / LINES / EDGES / a CAMERA luma) → KEY, OUT → OUTPUT or a video mixer; sweep THRESHOLD to wipe the keyed window open/closed, or modulate it with a CV/LFO for an animated reveal.

outputs

out video

inputs

video video
key video
threshold cv

params

threshold 0..1

example js

spawn('mapper', 'x');
set('x', 'threshold', 0);
patch('x.out', 'x.video');

reverb reverb

Algorithmic reverb. Size / damp / mix.

outputs

audio audio

inputs

audio audio

params

size 0..1
damp 0..1
mix 0..1

example js

spawn('reverb', 'x');
set('x', 'size', 0.5);
patch('x.audio', 'x.audio');

ringback ringback

Stereo crush effect — the TWOTRACKS record-time artifact, extracted and made intentional. While TWOTRACKS fresh-records it writes the live input into INTEGER ring-buffer cells (sample-quantized) at a fractional, varispeed write/read cursor, then reads those same cells back with LINEAR INTERPOLATION at the fractional cursor; the integer-cell write versus the interpolated read makes the read-back a decimated, aliased copy of the input — a metallic "bitcrushed" tone. (That read-back used to leak into TWOTRACKS' monitor while recording, which was a bug; RINGBACK packages the EXACT same mechanism as a deliberate effect.) Stereo in (L IN / R IN) → stereo out (L OUT / R OUT); a mono input is mirrored to both channels. Two independent ring channels (L + R) run the per-sample loop: read = interp(buf, cursor); write buf cells [cursor, cursor+RATE) = input + FEEDBACK·read; cursor += RATE (wrapping the small ring); out = (1−MIX)·input + MIX·read. Four knobs expose the character, all derived directly from the mechanism: RATE (0.05..4, default 0.5) is the write/read cursor advance per sample and the "amount" of the artifact — 1 is the mildest, below 1 the read-back stair-steps and aliases hardest; SIZE (2..4096 samples, default 64, log) is the ring length — a few samples ring like a comb/short metallic resonance, larger sizes become a grainy short-delay smear; FEEDBACK (0..0.98, default 0.3) re-injects the read-back into the ring (the regen "ring" tail), clamped strictly below 1 so it can never self-amplify to infinity; MIX (0..1, default 1) is the dry/wet blend between the clean input and the crushed read-back (0 passes the input through unchanged). The DSP is pure and deterministic (no RNG, no time dependence) so it is stable for VRT/ART; the worklet runs the shared RingChannel core in ringback-core.ts (unit-tested), the same no-mirror discipline as the TWOTRACKS engine. Patch any stereo (or mono) source through it for lo-fi grit, comb-ring resonance, or — at high feedback and small size — a self-oscillating metallic drone.

outputs

out_l audio
out_r audio

inputs

in_l audio
in_r audio
rate cv
size cv
feedback cv
mix cv

params

rate 0.05..4
size 2..4096smp
feedback 0..0.98
mix 0..1

example js

spawn('ringback', 'x');
set('x', 'rate', 0.5);
patch('x.out_l', 'x.in_l');

shimmershine shimmershine

Stereo shimmer reverb. Schroeder-style tank (4 parallel comb filters with damped feedback + 2 series allpasses per channel) feeds a +12-semitone granular-fade pitch shifter; the shifted signal is summed back into the tank input (gain hard-capped at 0.55 to prevent runaway). Decay sets tank tail length, Shimmer the pitch-shifted feedback amount (0 = plain reverb, 1 = strong octave-up halo), Size the comb-feedback scale, Damp the in-loop high-frequency rolloff, Mix dry/wet. More processor-intensive than the plain Reverb module by design.

outputs

out_l audio
out_r audio

inputs

in_l audio
in_r audio
decay_cv cv
shimmer_cv cv
size_cv cv
mix_cv cv

params

decay 0..1
shimmer 0..1
size 0..1
damp 0..1
mix 0..1

example js

spawn('shimmershine', 'x');
set('x', 'decay', 0.6);
patch('x.out_l', 'x.in_l');

tiler tiler

TILER — a video MULTISCREEN / TILE effect PROCESSOR (the classic video-mixer "multiscreen" look). Repeats the input frame in an N×N grid: each cell shows the FULL input scaled to 1/N, so the tiled copies are lower-resolution by nature (a 4×4 grid is 16 thumbnails of the same source, a 16×16 grid is 256 tiny copies). STATELESS per frame — the tiling moves/transforms live with the source (no feedback, no history). Implemented as a single-pass fragment shader; the whole effect is one line: color = texture(input, fract(uv × N)) — uv×N stretches the 0..1 UV across N cells and fract() wraps each cell back to the full input, so every cell samples the entire source. TILE is a 6-step DISCRETE knob (the param is a step INDEX 0..5; the card shows the resulting grid, e.g. "8×8") mapping to the grid dimension N: idx 0 → N=1 (1:1 PASSTHROUGH, no tiling — the lowest step is deliberately a transparent inline node), 1 → 4×4, 2 → 6×6, 3 → 8×8, 4 → 12×12, 5 → 16×16. A matching TILE CV input (port id tile_cv, paramTarget tile, DISCRETE cvScale) MODULATES the grid: the CV snaps onto the index steps and SUMS into the knob index (the same plumbing every per-param CV input uses), and the module then SNAPS the summed (possibly fractional) value to the NEAREST VALID N — so a CV that nudges the knob a little past "6" lands cleanly on 8 (never an invalid 7×7), and a bipolar LFO sweeps the grid through the valid sizes. IN takes RGB; OUT is video — patch a source (CAMERA / VIDEOBOX / SHAPES / a generator) → IN, OUT → OUTPUT or a video mixer; dial TILE for the multiscreen grid or modulate tile_cv for a pulsing/animated grid. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). The pure knob→N mapping + the CV sum-then-snap-to-nearest-N math are unit-tested helpers in $lib/video/modules/tiler.

outputs

out video

inputs

in video
tile_cv cv

params

tile 0..?

example js

spawn('tiler', 'x');
set('x', 'tile', 0);
patch('x.out', 'x.in');

twotracks twotracks

Two-reel tape loop emulator with record, overdub, scrub and Lofi character. Phase 1 ships reel A: patch stereo audio into L/R inputs, arm with the ARM gate or REC gate, and the tape records destructively (REC mode) or additively (OVERDUB mode, with a DECAY knob that fades previous passes by 0.50–0.90× per loop). A draggable blue playhead scrubs the cursor within the current window (START/END markers); rate is varispeed (1.0 = forward unity, negative = reverse, 0 = frozen). Mode toggle selects TAPE (one-shot: record one pass then play, play once then stop) or LOOP TAPE (loops continuously). Transport state is reflected by REC/ARM/PLAY/OVERDUB LEDs. Gate inputs for all transport events so gates or sequencers can drive the transport via cable. Save tape exports the current buffer as a stereo 48 kHz 16-bit WAV. Phase 2 adds reel B, EQ, and filter; Phase 3 adds Lofi saturation; Phase 4 adds CV ins and persistence polish.

outputs

out_l audio
out_r audio

inputs

audio_l_in_a audio
audio_r_in_a audio
rec_start_a gate
rec_arm_a gate
overdub_a gate
audio_l_in_b audio
audio_r_in_b audio
rec_start_b gate
rec_arm_b gate
overdub_b gate

params

rate_a -3..3
mode_a 0..1
echoes_a 1..5
start_a 0..1
end_a 0..1
overdub_flag_a 0..1
playhead_a 0..1
eqLow_a -12..12dB
eqMid_a -12..12dB
eqHigh_a -12..12dB
filterMode_a 0..3
cutoff_a 20..20000Hz
reso_a 0..1
rate_b -3..3
mode_b 0..1
echoes_b 1..5
start_b 0..1
end_b 0..1
overdub_flag_b 0..1
playhead_b 0..1
eqLow_b -12..12dB
eqMid_b -12..12dB
eqHigh_b -12..12dB
filterMode_b 0..3
cutoff_b 20..20000Hz
reso_b 0..1
ab 0..1
a2b 0..1
b2a 0..1
lofi 0..3
monitor 0..1

example js

spawn('twotracks', 'x');
set('x', 'rate_a', 1);
patch('x.out_l', 'x.audio_l_in_a');

vdelay vdelay

A video delay line with feedback echo — the visual analog of a tape/analog audio echo for the picture domain. VDELAY keeps a ring of 32 frame buffers; each frame a WRITE pass renders a new head slot equal to the live input plus a feedback-attenuated copy of the slot one delay-time ago, so the same image re-enters the ring and decays into a chain of repeats spaced by the delay length (this frame, then N frames later, then 2N, 3N...). A separate COMPOSE pass produces the visible output as a dry/wet mix between the live input and that delayed tap, so at low Mix you see the source with a faint trailing ghost and at high Mix you see mostly the echoes. With short Time and high Feedback you get fast, dense smearing/trails; long Time gives discrete stutter-style repeats. Color multiplicatively tints the feedback path toward a warm magenta, and because it is applied each pass the trails drift in hue (and darken slightly) as they age. Wire a video source into IN and route OUT into an OUTPUT, MONOGLITCH, or RUTTETRA card to watch the trails; push Feedback toward 0.95 for long-lived feedback ghosts without runaway.

outputs

out video

inputs

in video
time_cv cv
feedback_cv cv
mix_cv cv

params

delayTime 1..?
feedback 0..0.95
mix 0..1
colorShift 0..1

example js

spawn('vdelay', 'x');
set('x', 'delayTime', 0);
patch('x.out', 'x.in');

warps warps

Meta-modulator / signal masher (Mutable Instruments Warps archetype, Émilie Gillet, 2014, MIT-licensed). Clean-room pure-TypeScript port — four cross-modulation algorithms (0=XFADE equal-power crossfade, 1=RING-MOD digital ring modulation with TIMBRE drive, 2=XOR 16-bit bit-mash crossfaded against a 0.7-sum, 3=COMPARE Warps' direct/threshold/window comparator suite). An internal carrier oscillator (sine / triangle / saw / square selectable via the SHAPE knob) drives the carrier path when carrier_in is unpatched, so the module is usable as a one-input ring modulator or with no inputs at all. PITCH is V/oct on the internal carrier; NOTE is a ±60-semitone offset. LEVEL 1 / LEVEL 2 scale the carrier and modulator inputs. Output is mono softclipped through x/(1+|x|). FOLD / ANALOG-RING / FREQUENCY-SHIFTER / DOPPLER / VOCODER algorithms deferred to a follow-up PR.

outputs

out audio

inputs

carrier_in audio
modulator_in audio
pitch pitch
algorithm_cv cv
carrier_shape_cv cv
timbre_cv cv
level_1_cv cv
level_2_cv cv

params

algorithm 0..?
carrier_shape 0..1
timbre 0..1
level_1 0..1
level_2 0..1
note -60..60st

example js

spawn('warps', 'x');
set('x', 'algorithm', 0);
patch('x.out', 'x.carrier_in');

warrenspectrum warrenspectrum

Stereo 8-band filterbank with vactrol-style ping excitation and acidwarp video viz. Eight RBJ bandpass filters at octave-spaced centers (80, 160, 320, 640, 1280, 2560, 5120, 10240 Hz, Q=6). Each band carries its own ping gate input — rising edges distribute excitation across n±2 neighbors via a 1.0 / 0.35 / 0.12 bleed matrix into a vactrol envelope (soft-attack 10-30 ms with ±10% jitter, exponential decay 100-800 ms with ±10% jitter, tanh-saturated). The envelope simultaneously injects a fast broadband click into the bandpass (filter rings at fc) and pumps the band gain. viz_out is a mono-video cross-domain bridge: the on-card EQ-curve + audio-waveform overlay + cycling acidwarp hue palette + per-band ping flashes are also published as a video texture for downstream video modules.

outputs

out_l audio
out_r audio
viz_out mono-video
band1_out audio
band2_out audio
band3_out audio
band4_out audio
band5_out audio
band6_out audio
band7_out audio
band8_out audio

inputs

in_l audio
in_r audio
level1_cv cv
level2_cv cv
level3_cv cv
level4_cv cv
level5_cv cv
level6_cv cv
level7_cv cv
level8_cv cv
ping1 gate
ping2 gate
ping3 gate
ping4 gate
ping5 gate
ping6 gate
ping7 gate
ping8 gate
global_ping gate
viznoise_cv cv
root_cv cv
spread_cv cv
q_cv cv
decay_cv cv
band1_in audio
band2_in audio
band3_in audio
band4_in audio
band5_in audio
band6_in audio
band7_in audio
band8_in audio

params

level1 0..2
level2 0..2
level3 0..2
level4 0..2
level5 0..2
level6 0..2
level7 0..2
level8 0..2
master 0..2
viznoise 0..1
ping_decay 0..1
tuning_mode 0..1
root 24..108
q 1..40
spread 0..1
bleed 0..1

example js

spawn('warrenspectrum', 'x');
set('x', 'level1', 1);
patch('x.out_l', 'x.in_l');

utilities

4plexvid 4plexvid

4PLEXVID is a 4-in / 4-out video router — the video sibling of the audio 4Plexer. It is NOT a blend or mixer: each of the four outputs carries exactly ONE of the four video inputs, a discrete cross-point switch. Every output has its own selector (sel1..sel4 picking IN1..IN4) and its own gate CV input that advances that selector by one on each rising edge (IN1→IN2→IN3→IN4→IN1, wrapping). The fragment shader is a pure passthrough copy of the selected input texture (it writes the input's RGB straight through, or solid black when that input is unpatched), so there is no color processing — pixels pass straight through. All four outputs render their own FBO every frame regardless of patch state, so downstream modules always sample a fresh texture; OUT1 is also exposed as the canonical single-texture surface. Use it to fan one set of sources out to four destinations, to swap which feed reaches a screen, or to drive rhythmic cuts by clocking the gate inputs from an LFO or sequencer.

outputs

out1 video
out2 video
out3 video
out4 video

inputs

in1 video
in2 video
in3 video
in4 video
gate1 cv
gate2 cv
gate3 cv
gate4 cv

params

sel1 0..?
sel2 0..?
sel3 0..?
sel4 0..?
gate1 0..1
gate2 0..1
gate3 0..1
gate4 0..1

example js

spawn('4plexvid', 'x');
set('x', 'sel1', 0);
patch('x.out1', 'x.in1');

902 vca moog902

902 Voltage Controlled Amplifier (slice 3 of the moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). The classic moogafakkin DIFFERENTIAL VCA. A SIGNAL input is multiplied by a gain driven by a CONTROL SUM measured in volts: the manual GAIN pot ("fixed control voltage", 0..6 V) + the summing CONTROL INPUTS (cv, scaled by the CV-amount knob + sign) + a fixed-control-voltage bias input (fcv). Overall gain is x2 (+6 dB) at pot-max OR at CV = 6 V, and reaches its x3 ceiling near a control sum of ~7.5 V. The LIN / EXP RESPONSE switch picks the gain law: LINEAR rises linearly with the control voltage (6 V -> x2); EXPONENTIAL passes through the same x2 at 6 V then climbs faster, hitting x3 near ~7.5 V (the snappier VCA feel). Two complementary outputs form the differential pair: OUT (the amplified signal) and OUT- (audio_inv, its sample-accurate phase-inverted twin) — handy for stereo widening, sidechain feedback prevention, or mid/side work without a separate inverter. DSP is own-code: an amplifier gain law forked from the repo's own vca, re-implemented with the added exponential branch + the moogafakkin x2-at-6V / x3-ceiling scaling (not a port of any moogafakkin schematic or copyleft source - permissive only). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio
audio_inv audio

inputs

audio audio
cv cv
fcv cv

params

gain 0..1
cvAmount -1..1
mode 0..1

example js

spawn('moog902', 'x');
set('x', 'gain', 0.5);
patch('x.audio', 'x.audio');

961 interface moog961

961 Interface (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). A trigger-format converter / interface: audio crossing the SENSITIVITY threshold fires V-triggers (two parallel outs); an S-trigger input passes through to the V-trigger outs; and V-trigger inputs convert to S-trigger outs — one matching the input gate duration, one re-shaped to a fixed SWITCH-ON-TIME pulse (40 ms..4 s). (In our graph all triggers are gates; the S/V polarity distinction is cosmetic — the timing behaviors are modeled.) Own-code. Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

v_out1 gate
v_out2 gate
s_out_a gate
s_out_b gate

inputs

audio_in audio
s_in gate
v_in_a gate
v_in_b gate

params

sensitivity 0..1
switchOnTime 0.04..4s

example js

spawn('moog961', 'x');
set('x', 'sensitivity', 0.5);
patch('x.v_out1', 'x.audio_in');

962 seq switch moog962

962 Sequential Switch (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). Routes one of up to three signal inputs to a single output, advancing to the next input on each SHIFT (V-trigger) rising edge — a gate-advanced selector (shares the FOURPLEXER selector logic, trimmed to 3-in/1-out). STAGES sets how many inputs are cycled (2 or 3). Own-code. Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

out cv

inputs

in1 cv
in2 cv
in3 cv
shift gate

params

stages 2..3

example js

spawn('moog962', 'x');
set('x', 'stages', 3);
patch('x.out', 'x.in1');

984 matrix moog984

984 4-Channel Matrix Mixer (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). A 4-in x 4-out matrix: each of the 16 cross-points (m_ij) has an independent level knob, so any input can be summed into any output at any amount (out_j = sum over i of in_i * m_ij). Cross-points default to 0 (a fresh matrix is silent until dialed). Own-code gain matrix (permissive). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

out1 audio
out2 audio
out3 audio
out4 audio

inputs

in1 audio
in2 audio
in3 audio
in4 audio

example js

spawn('moog984', 'x');
patch('x.out1', 'x.in1');

994 mult moog994

994 Dual Multiples (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). Two independent passive MULTIPLES: each input is fanned out unaltered to three paralleled outputs (a_in -> a1/a2/a3, b_in -> b1/b2/b3). Type-agnostic — splits audio or CV alike. No knobs, no DSP (a unity passthrough split in the factory). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

a1 audio
a2 audio
a3 audio
b1 audio
b2 audio
b3 audio

inputs

a_in audio
b_in audio

example js

spawn('moog994', 'x');
patch('x.a1', 'x.a_in');

995 atten moog995

995 Attenuators (moogafakkin System 55/35 clone — categorized under Ports -> moogafakkin). Three independent passive variable ATTENUATORS, each input -> level knob (0..unity) -> output. Reduces control or audio amplitude (own-code per-channel gain, permissive). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

out1 audio
out2 audio
out3 audio

inputs

in1 audio
in2 audio
in3 audio

params

atten1 0..1
atten2 0..1
atten3 0..1

example js

spawn('moog995', 'x');
set('x', 'atten1', 1);
patch('x.out1', 'x.in1');

analoglogicmaths analogLogicMaths

Analog-logic mixer inspired by Mystic Instruments ANA (hardware-only — this is a from-spec implementation, not a port). Two continuous-signal inputs A and B feed bipolar attenuverters (-1..+1) and the post-attenuverter signals fan out into FIVE simultaneous algebraic outputs: MIN = min(A',B'), MAX = max(A',B'), DIFF = A'-B', SUM = tanh(A'+B') (soft-clipped), PRODUCT = tanh(A'*B') (soft-clipped, gives ring-mod-ish behavior for audio + smooth blending for CV). MIN/MAX of two waveforms mashes shapes; MAX of two envelopes = "either-trigger fires"; DIFF of two LFOs is anti-correlated motion; PRODUCT of two CVs is smooth blending. Continuous-signal "analog logic" — NOT the digital boolean logic that ILLOGIC ships. Tanh soft-clip on SUM + PRODUCT only (the operations that can leave [-1, +1]); MIN/MAX/DIFF stay bounded naturally.

outputs

min cv
max cv
diff cv
sum cv
product cv

inputs

a cv
b cv
attA_cv cv
attB_cv cv

params

attA -1..1
attB -1..1

example js

spawn('analogLogicMaths', 'x');
set('x', 'attA', 1);
patch('x.min', 'x.a');

attenumix attenumix

The simple mixer — a 4-channel attenuating mixer with per-channel direct outs and a master gain. Each channel's level is knob + CV summed and clamped to 0..1 (attenuators only attenuate, never boost), giving a per-channel direct out; all four sum into a master (0..2) with a tanh soft-clip so pushing the master past unity stays musical. Compared to VEILS (same quad-VCA-plus-mix topology) ATTENUMIX has no per-channel boost and no linear/exponential toggle — it is the no-surprises "the mixer" where every knob does exactly what it says. CV inputs are passthrough-by-design so a ±1 V LFO at knob=0 sweeps a channel's full open range.

outputs

out1 audio
out2 audio
out3 audio
out4 audio
mix audio

inputs

in1 audio
in2 audio
in3 audio
in4 audio
cv1 cv
cv2 cv
cv3 cv
cv4 cv

params

att1 0..1
att2 0..1
att3 0..1
att4 0..1
master 0..2

example js

spawn('attenumix', 'x');
set('x', 'att1', 0);
patch('x.out1', 'x.in1');

cp3 mixer moogCp3

CP3 / CP3A Console Panel — the console mixer slice of the moogafakkin System 55/35 clone (categorized under Ports -> moogafakkin). A multi-function console: (1) a 4x1 summing mixer that presents a (+) output AND a (-) phase-inverted output simultaneously, max per-channel gain x2 (0.5 = unity, 1.0 = x2), mixing AC and/or DC voltages (audio AND cv alike — the per-sample sum is polarity- and DC-transparent); (2) the 4th input adds an EXTERNAL jack (ext4) plus an ATTENUATOR — at "10" (1.0) the attenuator is unity so a direct patch passes through unaltered; (3) a MULTIPLE — input 1 fanned out unaltered to three passthrough outs (1 -> 3); (4) trunk/reference jacks supplying a constant +12V and -6V reference (scaled into the project normalized CV convention). Four 25K-LIN input level knobs (shown 0-10) + the 4th-input attenuator. DSP is own-code: a forked + expanded version of the repo mixer (not a port of any moogafakkin schematic or copyleft source — permissive only). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family). v1 omits the CP3A trunk/routing-switch matrix (the reference jacks are modeled as constant sources); the switch matrix is a planned follow-up.

outputs

out_positive audio
out_negative audio
multiple_one audio
multiple_two audio
multiple_three audio
plus_twelve cv
minus_six cv

inputs

in1 audio
in2 audio
in3 audio
in4 audio
ext4 cv

params

ch1 0..1
ch2 0..1
ch3 0..1
ch4 0..1
attenuator4 0..1

example js

spawn('moogCp3', 'x');
set('x', 'ch1', 1);
patch('x.out_positive', 'x.in1');

depolarizer depolarizer

DEPOLARIZER — a tiny 1-in / 1-out CV utility: the reverse of POLARIZER, converting a BIPOLAR control voltage back to a UNIPOLAR one. Model: out = 0.5 + DEPTH · (in / 2) — it folds a [−1, +1] input into [0, 1]. Computed sample-accurately by a pure Web Audio graph (a GainNode for the scale + a started ConstantSourceNode → GainNode for the fixed +0.5 center, both summed; no worklet, no DSP build). Controls — DEPTH: the single knob, range 0..1 on a LINEAR taper, sets how far the output DEPARTS from the 0.5 CENTER; default 1.0 = the FULL conversion (in=−1 → 0, in=0 → 0.5, in=+1 → 1), 0.5 → output swings only 0.25..0.75, 0 → flat 0.5. DEPTH attenuates only the DEVIATION from center (it scales the slope, not the offset), so the output always rests at the 0.5 unipolar center with nothing patched or at DEPTH 0 — the natural "neutral" value. IO — IN (cv): the bipolar (−1..+1) control voltage to depolarize (the affine map is defined for any value); OUT (cv): the unipolar result centered on 0.5. All patching is via the card's yellow drill-down PATCH PANEL — no side jacks. DEPTH is MIDI / control-surface assignable (right-click → MIDI Learn). Usage: feed a bipolar LFO / sequencer / ±1 modulation source into a destination that expects a 0..1 CV (a level / depth / mix-knob CV), with DEPTH trimming the modulation amount around the 0.5 rest point; the inverse of POLARIZER for the round trip.

outputs

out cv

inputs

in cv

params

depth 0..1

example js

spawn('depolarizer', 'x');
set('x', 'depth', 1);
patch('x.out', 'x.in');

fader fader

Two-source video mixer with a send/return FX loop. IN A and IN B are crossfaded by a horizontal A/B fader (0 = A, 1 = B); the crossfade SHAPE is picked from a transition dropdown — fade (uniform), wipe (soft edge sweeping left→right), dissolve (random per-cell reveal), star (a 5-point iris from the centre), or checkerboard (staggered cells). That A/B mix is exposed on the SEND output as a copy: patch SEND through any external video FX chain and bring the processed result back into RETURN. A second DRY/WET fader (with its own transition dropdown) blends the dry mix (0) against the wet return (1) to produce the main OUT — so you can fade the effect in and out, or transition into it with a wipe/dissolve/star/checker. 3 video inputs (A / B / RETURN), 2 video outputs (OUT = main mix, SEND = pre-FX copy). With nothing patched both outputs are black. The blend math is deterministic + unit-tested; both faders default to fade.

outputs

out video
send video

inputs

in_a video
in_b video
return video

params

fader 0..1
abTransition 0..4
dryWet 0..1
dwTransition 0..4

example js

spawn('fader', 'x');
set('x', 'fader', 0.5);
patch('x.out', 'x.in_a');

flipper flipper

Gate flip-flop. Two gate inputs and two gate outputs (FLIP, FLOP). A gate on EITHER input alternately fires FLIP, then FLOP, then back — the first gate after load fires FLIP. While a gate is high it is mirrored to the currently-selected output (keeping the trigger width) and the other output stays silent. Use it to split one trigger stream into two alternating streams (e.g. ping-pong two envelopes / two voices).

outputs

flip gate
flop gate

inputs

in1 gate
in2 gate

example js

spawn('flipper', 'x');
patch('x.flip', 'x.in1');

illogic illogic

Combined attenuverter / math / logic utility. 4 cv inputs feed bipolar attenuverters (-1..+1); post-attenuverter outputs sum into `sum` and `diff`. Inputs in1+in2 are also gate-thresholded (>= 0.5) and combined into AND/NAND/OR; in1 alone drives a NOT.

outputs

att1 cv
att2 cv
att3 cv
att4 cv
sum cv
diff cv
and gate
nand gate
or gate
not gate

inputs

in1 cv
in2 cv
in3 cv
in4 cv

params

att1_amount -1..1
att2_amount -1..1
att3_amount -1..1
att4_amount -1..1

example js

spawn('illogic', 'x');
set('x', 'att1_amount', 1);
patch('x.att1', 'x.in1');

mappy mappy

MAPPY — a multi-surface MANUAL projection mapper. Spawns up to SIX SURFACES; each surface is fed by a distinct video input (in1..in6) and warped onto its own DRAGGABLE QUAD in the output frame, then composited (painter's order, OVER) into ONE video output → a projector. Use it to DE-SKEW one awkwardly-angled projection (drag the four corners to match the physical screen) or to map up to 6 feeds onto the faces of a white cube (only ~3-4 faces are ever visible from one projector angle). WARP: each surface owns a 4-corner QUAD in NORMALIZED [0,1] output space (corner order TL, TR, BR, BL). The homography (unit-square → that quad) defines the projective warp; the shader runs per OUTPUT texel, applies the INVERSE homography to find the matching SOURCE uv, and samples the input there (sampling only where the source uv is inside [0,1], else transparent so under-layers show through). Surfaces composite in input order (in1 first … in6 last) with OVER blend. FIT vs CROP: each surface has its OWN FIT toggle (default ON; surfaces independent) — one cheap per-surface shader uniform, no extra pass/readback. FIT (zoom-fit) squeezes the WHOLE source [0,1]² into the quad; CROP windows the source at NATIVE scale — the box becomes a moveable window onto the source pinned 1:1 in output space, so MOVING the box pans across the source and RESIZING crops more/less (the quad still masks the shape). DRAG: grab a CORNER to pin it, or grab the surface INTERIOR and drag to move the whole quad bodily (on the card preview AND in the editor). GRIDS-FIRST: a fresh MAPPY shows ONE surface, and a live surface with NO input connected renders its NUMBERED CALIBRATION GRID (a per-surface-tinted checker + border + cross-hairs + a big 7-segment DIGIT naming the input that will feed it). So with nothing patched the output IS the grid(s) — set the geometry up on the physical faces FIRST (drag corners; +/− the SURFACE COUNT up to 6), THEN connect video: the instant inN is connected, surface N swaps grid→warped video in the quad you already mapped (surface↔input is fixed — no reassignment). The GRID toggle FORCES the grid on every live surface (a re-alignment override); connecting inN auto-activates surface N even beyond the count. CARD: a live composite PREVIEW with draggable corner handles + quad outlines (coloured per surface), a +/− surface counter, a MAP button that opens the FULL-WINDOW editor (large canvas, big precise corner-pin handles, drag-inside-to-move a surface, surface tabs, a per-surface FIT/CROP toggle, snap-to-grid), the GRID toggle, and a per-surface legend (focus + FIT/CROP + reset + a ●video / ○grid state). All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). This is the MANUAL mapper — the camera-assisted AUTO-align (point a camera at the projection, solve the homography from detected features) is a LATER phase; there is no camera input and no CV by design. The pure 2D projective math lives in $lib/video/mappy-homography (DLT solve / apply / invert / column-major-for-GLSL), shared by the shader + the unit tests.

outputs

out video

inputs

in1 video
in2 video
in3 video
in4 video
in5 video
in6 video

params

showGrid 0..1
surfaceCount ?..?

example js

spawn('mappy', 'x');
set('x', 'showGrid', 0);
patch('x.out', 'x.in1');

mixer mixer

Four-channel mono summing mixer with master gain.

outputs

audio audio

inputs

in1 audio
in2 audio
in3 audio
in4 audio

params

ch1 0..1
ch2 0..1
ch3 0..1
ch4 0..1
master 0..1

example js

spawn('mixer', 'x');
set('x', 'ch1', 1);
patch('x.audio', 'x.in1');

mixmstrs mixmstrs

6xstereo mixer with EQ, per-channel compressor (single-dial macro + power-user thresh/ratio), two stereo aux sends/returns, per-channel post-fader VU taps (read('levels') → number[6]). Multiple instances allowed. 61 params.

outputs

masterL audio
masterR audio
send1L audio
send1R audio
send2L audio
send2R audio

inputs

ch1L audio
ch1R audio
ch2L audio
ch2R audio
ch3L audio
ch3R audio
ch4L audio
ch4R audio
ch5L audio
ch5R audio
ch6L audio
ch6R audio
ret1L audio
ret1R audio
ret2L audio
ret2R audio
ch1_volume cv
ch1_low cv
ch1_mid cv
ch1_high cv
ch1_thresh cv
ch1_ratio cv
ch1_compEnable cv
comp1 cv
ch1_send1 cv
ch1_send2 cv
ch2_volume cv
ch2_low cv
ch2_mid cv
ch2_high cv
ch2_thresh cv
ch2_ratio cv
ch2_compEnable cv
comp2 cv
ch2_send1 cv
ch2_send2 cv
ch3_volume cv
ch3_low cv
ch3_mid cv
ch3_high cv
ch3_thresh cv
ch3_ratio cv
ch3_compEnable cv
comp3 cv
ch3_send1 cv
ch3_send2 cv
ch4_volume cv
ch4_low cv
ch4_mid cv
ch4_high cv
ch4_thresh cv
ch4_ratio cv
ch4_compEnable cv
comp4 cv
ch4_send1 cv
ch4_send2 cv
ch5_volume cv
ch5_low cv
ch5_mid cv
ch5_high cv
ch5_thresh cv
ch5_ratio cv
ch5_compEnable cv
comp5 cv
ch5_send1 cv
ch5_send2 cv
ch6_volume cv
ch6_low cv
ch6_mid cv
ch6_high cv
ch6_thresh cv
ch6_ratio cv
ch6_compEnable cv
comp6 cv
ch6_send1 cv
ch6_send2 cv
master_volume cv

params

ch1_volume 0..1
ch1_low -12..12dB
ch1_mid -12..12dB
ch1_high -12..12dB
ch1_thresh -36..0dB
ch1_ratio 1..10
ch1_compEnable 0..1
comp1 0..1
ch1_send1 0..1
ch1_send2 0..1
ch2_volume 0..1
ch2_low -12..12dB
ch2_mid -12..12dB
ch2_high -12..12dB
ch2_thresh -36..0dB
ch2_ratio 1..10
ch2_compEnable 0..1
comp2 0..1
ch2_send1 0..1
ch2_send2 0..1
ch3_volume 0..1
ch3_low -12..12dB
ch3_mid -12..12dB
ch3_high -12..12dB
ch3_thresh -36..0dB
ch3_ratio 1..10
ch3_compEnable 0..1
comp3 0..1
ch3_send1 0..1
ch3_send2 0..1
ch4_volume 0..1
ch4_low -12..12dB
ch4_mid -12..12dB
ch4_high -12..12dB
ch4_thresh -36..0dB
ch4_ratio 1..10
ch4_compEnable 0..1
comp4 0..1
ch4_send1 0..1
ch4_send2 0..1
ch5_volume 0..1
ch5_low -12..12dB
ch5_mid -12..12dB
ch5_high -12..12dB
ch5_thresh -36..0dB
ch5_ratio 1..10
ch5_compEnable 0..1
comp5 0..1
ch5_send1 0..1
ch5_send2 0..1
ch6_volume 0..1
ch6_low -12..12dB
ch6_mid -12..12dB
ch6_high -12..12dB
ch6_thresh -36..0dB
ch6_ratio 1..10
ch6_compEnable 0..1
comp6 0..1
ch6_send1 0..1
ch6_send2 0..1
master_volume 0..1

example js

spawn('mixmstrs', 'x');
set('x', 'ch1_volume', 0.8);
patch('x.masterL', 'x.ch1L');

negativity negativity

NEGATIVITY — a tiny 1-in / 1-out CV utility: a pure INVERTER. Model: out = −in — it flips the sign of its input sample-for-sample (in=0.4 → −0.4, in=−0.7 → +0.7). Computed sample-accurately by a single Web Audio GainNode whose gain is a fixed −1 (no worklet, no DSP build). Controls — NONE: there are no knobs or parameters; the inversion is fixed. IO — IN (cv): the control voltage to invert; OUT (cv): the inverted result, out = −in. All patching is via the card's yellow drill-down PATCH PANEL (top-left / top-right affordances → INPUT / OUTPUT) — no side jacks. It is the no-knob, fixed-sign sibling of POLARIZER / DEPOLARIZER (those also reshape range; NEGATIVITY only inverts). Usage: turn a rising modulation into a falling one (or the reverse); derive a complementary CV such as an inverted envelope for ducking / sidechain-style modulation; or phase-flip a bipolar modulation source before it hits a destination.

outputs

out cv

inputs

in cv

example js

spawn('negativity', 'x');
patch('x.out', 'x.in');

one to nine onetonine

ONE TO NINE — a fixed 3×3 SCREEN SPLITTER. Takes ONE video input and divides it into a 3×3 grid of nine equal sub-rectangles; each grid CELL is exposed on its own video output (out1..out9), magnified to FILL the output frame. Designed to be used ALONGSIDE (but NOT wired to) MAPPY — feed each of up to nine projectors a different ninth of one source. CELL NUMBERING is READING ORDER: 1 = top-left, 2 = top-center, 3 = top-right, 4 = mid-left, 5 = CENTRE, 6 = mid-right, 7 = bottom-left, 8 = bottom-center, 9 = bottom-right. OUTPUT N carries ONLY the content of cell N (a 1/9 sub-rectangle of the input), scaled up to the full output frame — so each output is a low-res CROP of one ninth (expected + fine). The nine outputs are CLEAN crops: no grid lines, no numbers. MONITOR: the module's canonical surface (the on-card preview, also the VRT/blit target) shows the input with a 3×3 GRID overlaid and a big readable DIGIT 1..9 drawn in each cell, so the operator can SEE which cell feeds which output. The grid + numbers appear ONLY on the monitor — never in the outputs. GRID toggle: a switch on the card that hides the grid + numbers on the monitor (raw input passthrough) when off; ON by default since the numbered grid is the point of the monitor. No params required beyond the grid toggle (the 3×3 split is fixed). Internally one MONITOR fbo renders the grid+numbers monitor and nine CROP fbos render the clean per-cell crops; the crops are exposed to downstream consumers via read('outputTexture:out1'..'out9') (the multi-output escape hatch), the monitor as the canonical surface.texture. The y-UP vUv convention is handled in the pure cellSourceRect math (cell 1 samples HIGH v / LOW u) so cell 1 is genuinely the top-left and the drawn digits render upright. All ports live on the yellow drill-down PATCH PANEL (IN + OUT1..OUT9, no raw side jacks). USAGE: patch a source (CAMERA / a generator / a clip) → IN, read the numbered MONITOR to learn the layout, then patch each OUT N → its destination (a projector via videoOut, a recorder, a mixer). The pure cell→source-rect crop math lives in $lib/video/modules/onetonine (cellSourceRect / cellRow / cellCol), shared by the crop shader, the monitor digits, and the unit tests.

inputs

in video

params

showGrid 0..1

example js

spawn('onetonine', 'x');
set('x', 'showGrid', 0);

polarizer polarizer

POLARIZER — a tiny 1-in / 1-out CV utility that converts a UNIPOLAR control voltage to a BIPOLAR one. Model: out = (2·in − 1) · DEPTH — it takes a [0, 1] input and stretches it across [−1, +1]. Computed sample-accurately by a pure Web Audio graph (a GainNode for the scale + a started ConstantSourceNode → GainNode for the offset, both summed; no worklet, no DSP build). Controls — DEPTH: the single bipolar-swing knob, range 0..1 on a LINEAR taper; default 1.0 = the FULL ±1 conversion (in=0 → −1, in=0.5 → 0, in=1 → +1), 0.5 → ±0.5, 0 → flat 0. DEPTH scales the swing symmetrically about 0, so the output always stays centered on 0 as you trim it. IO — IN (cv): the unipolar (0..1) control voltage to polarize (the affine map is defined for any value, it just linearly centers + scales); OUT (cv): the bipolar result, out = (2·in − 1)·depth. This is the bipolar counterpart of a unipolar envelope output (e.g. SYNESTHESIA's 0..1 follower). All patching is via the card's yellow drill-down PATCH PANEL (top-left / top-right affordances → INPUT / OUTPUT) — no side jacks. DEPTH is MIDI / control-surface assignable (right-click → MIDI Learn) like every other knob. Usage: patch a 0..1 envelope / LFO / sequencer CV through it to get a ±1 modulation source that can both RAISE and LOWER a destination (e.g. drive a filter cutoff above AND below its rest point from a unipolar envelope); pair with DEPOLARIZER for the round trip.

outputs

out cv

inputs

in cv

params

depth 0..1

example js

spawn('polarizer', 'x');
set('x', 'depth', 1);
patch('x.out', 'x.in');

quadralogical quadralogical

QUADRALOGICAL is a four-input video mixer driven by a single XY joystick. The pad's position (pos_x, pos_y) is mapped over the unit square to four CORNER weights — one per input: in1 top-left, in2 top-right, in3 bottom-left, in4 bottom-right. A bilinear base gives every corner (one input solo) and every edge (a 2-input blend) for free; outside the central yellow DIAMOND the weights are power-sharpened toward a crisp 2-input region, while inside the diamond all four inputs stay balanced (the all-4 composite zone). The model is "logical" because each of the FOUR edges of the joystick cycle (1-2, 2-3, 3-4, 4-1) carries its OWN independently-selectable blend effect (DISSOLVE / ADD / MULTIPLY / WIPE / CHROMA / LUMA / DIFF / IRIS) run on that edge's two adjacent inputs, and the four edge-blends are layered weighted by how active each pair is. Unpatched inputs normal down the chain Eurorack-style (in4 falls to in3 to in2 to in1), so a single source never blends against black. Usage: patch one to four video sources into in1-in4, drag the joystick to a corner for a clean cut to one input, to an edge to crossfade/wipe two of them with that edge's effect, or into the diamond for a four-way composite; set each edge's effect with its FX selector and CV-modulate the joystick or per-edge controls for animated transitions.

outputs

out video
preview video

inputs

in1 video
in2 video
in3 video
in4 video
pos_x cv
pos_y cv
diamond_margin cv
blend_sharp cv
edge1_amount cv
edge1_param cv
edge2_amount cv
edge2_param cv
edge3_amount cv
edge3_param cv
edge4_amount cv
edge4_param cv
keyR cv
keyG cv
keyB cv

params

pos_x -1..1
pos_y -1..1
diamond_margin 0..1
blend_sharp 0..8
edge1_fx 0..7
edge1_amount 0..1
edge1_param 0..1
edge2_fx 0..7
edge2_amount 0..1
edge2_param 0..1
edge3_fx 0..7
edge3_amount 0..1
edge3_param 0..1
edge4_fx 0..7
edge4_amount 0..1
edge4_param 0..1
keyR 0..1
keyG 0..1
keyB 0..1
invert 0..1
freeze 0..1

example js

spawn('quadralogical', 'x');
set('x', 'pos_x', 0);
patch('x.out', 'x.in1');

rasterize rasterize

Audio -> video raster mapper. Each video frame paints a fixed run of audio samples (samples/frame, ~800 at 48k/60fps) as voltage-per-pixel into the 640x480 frame in raster order; a scan cursor drifts + wraps through the frame. Faithful raster mapping (NOT an oscilloscope trace) - a steady tone paints drifting horizontal bands whose spacing tracks the audio frequency vs the line/frame rate. Fully untamed: no limiter, no anti-alias.

outputs

thru audio
out mono-video

inputs

in audio
cursor cv
samplesPerFrame cv
gain cv
wrap cv

params

cursor 0..?px
samplesPerFrame 16..8000
gain 0..8
wrap 0..1

example js

spawn('rasterize', 'x');
set('x', 'cursor', 0);
patch('x.thru', 'x.in');

scaler scaler

SCALER — a tiny 1-in / 1-out signal multiplier (a fixed-gain VCA-without-CV / "gain trim" utility). Model: out = in × AMOUNT, computed sample-accurately by a single Web Audio GainNode (no worklet, no DSP build). Controls — AMOUNT: the single scale-factor knob, range ×0.1 .. ×10 on a LOG taper so unity (1.0) sits at the knob CENTER and the cut/boost is symmetric (left extreme = ×0.1, right extreme = ×10); default 1.0, so a freshly spawned SCALER passes a direct patch through unaltered until you dial it. Below 1.0 it ATTENUATES (down to a tenth), above 1.0 it BOOSTS (up to ten times) — unlike a passive attenuator (which only cuts, 0..1), the SCALER can also amplify. IO — IN: the signal to scale (typed audio so it interops with audio cables directly, and widened to accept the CV family so a CV / gate / pitch source can be scaled too — it is just a multiply, valid for either signal class); OUT: the scaled signal (out = in × amount). OUT is TYPE-TRANSPARENT: its cable type ADOPTS whatever is patched into IN — a CV source makes OUT emit CV, an audio source makes it emit audio (it falls back to audio when nothing is patched). This matters when SCALER feeds a VIDEO module: a CV stays CV through the audio→video bridge so AMOUNT actually scales the modulation, instead of being read as audio (which the bridge envelope-follows and clamps, making the knob do nothing). All patching is via the card's yellow drill-down PATCH PANEL (top-left / top-right affordances → INPUT / OUTPUT) — no side jacks. AMOUNT is MIDI / control-surface assignable (right-click → MIDI Learn) like every other knob. Usage: drop one inline on any audio or CV cable to trim level or boost a quiet source; scale an LFO / envelope / sequencer CV up or down before it modulates a destination; or use it as a simple makeup-gain stage after an effect.

outputs

out audio

inputs

in audio

params

amount 0.1..10

example js

spawn('scaler', 'x');
set('x', 'amount', 1);
patch('x.out', 'x.in');

scope scope

2-channel passthrough oscilloscope. Inputs flow unchanged to outputs while an AnalyserNode samples for display.

outputs

ch1_out audio
ch2_out audio
out mono-video

inputs

ch1 audio
ch2 audio
timeMs cv
ch1Scale cv
ch1Offset cv
ch1Range cv
ch2Scale cv
ch2Offset cv
ch2Range cv
mode cv
intensity cv

params

timeMs 1..200ms
ch1Scale 0.1..10
ch1Offset -1..1
ch1Range 0..1
ch2Scale 0.1..10
ch2Offset -1..1
ch2Range 0..1
mode 0..1
intensity 0..1

example js

spawn('scope', 'x');
set('x', 'timeMs', 20);
patch('x.ch1_out', 'x.ch1');

scoreboard scoreboard

A 4-digit neon 7-segment counter widget, rendered as a digital-alarm-clock face: a zero-padded value (0000-9999) drawn as chamfered hexagonal segments in a hue-tinted glow on soft black (#0a0a0a), with off segments fully invisible (no LCD ghost). It is a pure CV-driven generator with NO video input — a 2D OffscreenCanvas rasterizes the digits via the drawScoreboard helper and uploads them as an RGBA texture; a trivial fragment shader letterboxes that 8:3 source into the 4:3 engine frame, width-locked and centered vertically with pure-black bands top and bottom (and a dark fallback fill before the first paint). Each rising edge on SCORE adds 1 to the counter; it wraps from 9999 back to 0 (a periodic counter, handy for sequencing). RESET zeros it. The COLOR knob sets the lit-segment and glow hue. Patch a clock or sequencer gate into SCORE to count beats/events on screen, and a reset gate to zero it on a bar/loop boundary; the counter always starts at 0 on spawn (it is not persisted).

outputs

out video

inputs

score cv
reset cv

params

color 0..1
scoreTrig 0..1
resetTrig 0..1

example js

spawn('scoreboard', 'x');
set('x', 'color', 0);
patch('x.out', 'x.score');

stereovca stereovca

Stereo VCA + ring modulator. Per-channel multiply: out_l = in_l * (strength_l + offset) * level; out_r = in_r * (strength_r + offset) * level. The same math behaves as VCA gain control when strength is slow (CV / LFO / envelope) and as ring modulation when strength is audio-rate — no mode toggle, the perceptual difference emerges from signal content. INDEPENDENT normalling: if in_r is unpatched it copies in_l (mono → stereo); if strength_r is unpatched it copies strength_l (one strength drives both VCAs). The two halves normal independently, so true-stereo audio + mono strength works, as does mono audio + per-side strength. Audio carriers (in_l/in_r) declare cable type `audio`; strength inputs declare `cv` (raw bipolar carrier consumed in the multiply with no scaling — listed in PASSTHROUGH_BY_DESIGN) so any cv source (LFO, ADSR, sequencer step CV) lands without a cross-type cast.

outputs

out_l audio
out_r audio

inputs

in_l audio
in_r audio
strength_l cv
strength_r cv

params

level 0..1
offset -1..1

example js

spawn('stereovca', 'x');
set('x', 'level', 1);
patch('x.out_l', 'x.in_l');

unityscalemathematik unityscalemathematik

Bipolar CV-shaping utility with three independent channels: a UNITY scaler (input * atten) plus two attenuvert sections (A, B) whose curve knob morphs the response from linear (k=1) to steep exponential (k=3) via y = sign(x) * |x|^k * atten. Sign is preserved across the curve morph so the transform stays bipolar. CV inputs on every atten/curve knob — useful for envelope shaping, LFO sculpting, or driving any modulation through a tunable response curve.

outputs

u_out cv
a_out cv
b_out cv

inputs

u_in cv
u_atten_cv cv
a_in cv
a_atten_cv cv
a_curve_cv cv
b_in cv
b_atten_cv cv
b_curve_cv cv

params

unityAtten -1..1
aAtten -1..1
aCurve 0..1
bAtten -1..1
bCurve 0..1

example js

spawn('unityscalemathematik', 'x');
set('x', 'unityAtten', 1);
patch('x.u_out', 'x.u_in');

v-mixer videoMixer

A 4-channel additive video mixer. Each frame it samples up to four input textures at the same UV and sums them, scaling each by its own amount fader: out = in1*A1 + in2*A2 + in3*A3 + in4*A4, with the final RGB clamped to [0,1] and alpha forced opaque. Unpatched inputs contribute pure black (they read a 1x1 sentinel texture, not the mixer's own output, so there is no feedback loop). Because the sum is linear, it doubles as a crossfader (push A1 up while pulling A2 down for a two-source dissolve) and as a brightness/level control on a single source. Bright sources or amounts summing above 1.0 clip to white per channel. Usage hint: keep the active amounts summing near 1.0 for clean compositing; drive amount1..amount4 from LFOs or envelopes for automated fades and pulses.

outputs

out video

inputs

in1 video
in2 video
in3 video
in4 video
amount1 cv
amount2 cv
amount3 cv
amount4 cv

params

amount1 0..1
amount2 0..1
amount3 0..1
amount4 0..1

example js

spawn('videoMixer', 'x');
set('x', 'amount1', 0);
patch('x.out', 'x.in1');

vca vca

Voltage-controlled amplifier. Multiplies the audio input by base + (cv * cvAmount).

outputs

audio audio
audio_inv audio

inputs

audio audio
cv cv

params

base 0..1
cvAmount -1..1

example js

spawn('vca', 'x');
set('x', 'base', 0);
patch('x.audio', 'x.audio');

veils veils

Quad VCA + soft-clip summing mix (Mutable Instruments Veils archetype — analog hardware, clean-room from-spec impl). Four independent VCAs, each with audio in, CV in (summed with knob), gain knob spanning [0, 2], and a per-channel response toggle: LIN for CV / control signals, EXP (squared) for audio / smooth fades. Per-channel direct outs are pre-mix, pre-clip. A separate MIX out sums all four channels and applies a tanh soft-clip — gain is NOT clamped at 1.0 per channel, so knob + CV can push above unity for warm overdrive on the mix bus.

outputs

out1 audio
out2 audio
out3 audio
out4 audio
mix audio

inputs

in1 audio
in2 audio
in3 audio
in4 audio
cv1 cv
cv2 cv
cv3 cv
cv4 cv

params

gain1 0..2
gain2 0..2
gain3 0..2
gain4 0..2
resp1 0..1
resp2 0..1
resp3 0..1
resp4 0..1

example js

spawn('veils', 'x');
set('x', 'gain1', 0);
patch('x.out1', 'x.in1');

output

audio out audioOut

Terminal stereo output. Two mono inputs (L, R) routed to the host AudioContext destination. Optional output-device dropdown via setSinkId (Chromium 110+).

inputs

L audio
R audio

params

master 0..1gain

example js

spawn('audioOut', 'x');
set('x', 'master', 0.7);

b3ntb0x b3ntb0x

A circuit-level NTSC/composite video destroyer. Where the original BENTBOX does one symbolic RGB/YIQ pass, B3NTB0X runs a real four-stage analog pipeline: it ENCODES the incoming picture into a per-column composite VOLTAGE on a 3.58 MHz subcarrier (with sync tip, blanking, colour burst, and active video), runs that voltage through an analog BEND CIRCUIT (AC/DC coupling, gain, bias, soft-clip + diode clamp, plus four circuit-bend taps), DECODES it back to RGB with a quadrature demodulator and recovered sync, then renders it on a curved CRT (beam blur, phosphor grille, scanlines/interlace, bloom, persistence, overscan, barrel). Sync crush, dot-crawl, rainbow swim and rolling all EMERGE from the signal path — they are not cosmetic filters. Patch a video source into IN and it is the chainable, CRT-rendered OUT. Crank Sync Crush + Bias to tear and roll the picture, starve the Burst to kill colour and bring on herringbone, push Drift for swimming rainbow, and use Bend A–D for wavefold/comb/crush/bleed mangling. The preview is a resizable CRT screen (drag the bottom-right handle; default 540x540, min 360x540) that letterboxes at the live engine aspect with the 4:3 active area, overscan and barrel applied inside the shader; right-click for fullscreen / full-frame / present-on-second-display, and a "reduced precision" badge appears if the GPU cannot allocate the float buffers the composite voltage needs.

outputs

out video

inputs

in video
enhance_cv cv
bias_cv cv
ac_dc_cv cv
sync_crush_cv cv
burst_starve_cv cv
chroma_leak_cv cv
luma_peak_cv cv
bend_a_cv cv
bend_b_cv cv
bend_c_cv cv
bend_d_cv cv
feedback_cv cv
tbc_cv cv
tube_bloom_cv cv
overscan_cv cv
barrel_cv cv
mirror_x_gate cv
mirror_y_gate cv

params

enhance 0..1
bias -1..1
ac_dc 0..1
sync_crush 0..2
burst_starve 0..1
chroma_leak 0..1
luma_peak 0..1
bend_a -1..1
bend_b -1..1
bend_c -1..1
bend_d -1..1
feedback 0..1
tbc 0..1
tube_bloom 0..1
overscan 0..1
barrel 0..1
hue -1..1
sub_drift 0..1
mirrorX 0..1
mirrorY 0..1
mirrorXGate 0..1
mirrorYGate 0..1

example js

spawn('b3ntb0x', 'x');
set('x', 'enhance', 0);
patch('x.out', 'x.in');

bentbox bentbox

A virtual CRT driven by a hand-bent analog composite line. The patched RGB image is resampled to a 240-line raster, converted to NTSC YIQ, given a modeled chroma-subcarrier phase, run through a triangle wavefolder + soft-clip on the composite "voltage", decoded back to RGB, blended with the previous frame (ping-pong feedback, max-blend trails), then painted through a CRT phosphor pipeline: scanline-gap mask (with odd/even field parity), RGB-triad subpixel mask, luma bloom, and RF grain. The result is timing-domain glitch (sync tearing, hue shimmer, ghosting, solarization) rather than pixel mosh. With nothing patched into IN it shows a dim blue idle field so you can see it is alive. Card layout: a resizable 4:3-letterboxed CRT screen over a 4x3 knob grid (timing / chroma+gain / feedback+destruction rows) plus two MIRROR toggle buttons. The image is always letterboxed at the live engine aspect (4:3 by default) and never stretched; the screen has DOM-only chrome (right-click for fullscreen, full-frame in-app expand, and present-on-second-display); OUT is a chainable video pass-through so you can stack BENTBOX into another video processor.

outputs

out video

inputs

in video
hsync_drift_cv cv
hsync_loss_cv cv
vsync_drift_cv cv
chroma_phase_cv cv
chroma_instability_cv cv
feedback_gain_cv cv
feedback_delay_cv cv
wavefold_cv cv
scan_wobble_cv cv
bloom_cv cv
noise_cv cv
master_gain_cv cv
mirror_x_gate cv
mirror_y_gate cv

params

hsync_drift 0..1
hsync_loss 0..1
vsync_drift 0..1
scan_wobble 0..1
chroma_phase -1..1
chroma_instability 0..1
feedback_gain 0..1
feedback_delay 0..1
wavefold 0..1
bloom 0..1
noise 0..1
master_gain 0..2
mirrorX 0..1
mirrorY 0..1
mirrorXGate 0..1
mirrorYGate 0..1

example js

spawn('bentbox', 'x');
set('x', 'hsync_drift', 0);
patch('x.out', 'x.in');

graphic eq graphicEq

A full-screen Winamp-style graphic-EQ / VU-meter video output. Patch a STEREO signal into the L and R audio inputs and GRAPHIC EQ analyses each channel with an FFT, folds it into 8 log-spaced frequency bands (roughly 40 Hz up to 16 kHz, an octave-ish per band), and draws each band as a vertical level meter that rises and falls with the music. A green→yellow→red colour ramp climbs each meter (rotate the whole palette with Hue), and a peak-hold cap floats above each bar and falls back at a rate set by Peak. Two switches shape the look: STYLE toggles between SOLID BARS (one smooth filled bar per band) and STACKED BOXES (the classic LED-ladder of discrete segments); DISPLAY toggles between MONO (8 meters across the full width, the L/R average) and STEREO (the screen splits down the middle — the LEFT channel's 8 meters fill the left half, the RIGHT channel's fill the right half). Gain sets sensitivity. With nothing patched the meter frame still draws dim so the card is never black. The render feeds the chainable video out and the on-card preview; hide the controls to use the card as a resizable full-screen monitor.

outputs

out video

inputs

audio_l audio
audio_r audio

params

style 0..1
display 0..1
gain 0.5..4
peak 0.5..0.99
hue 0..1

example js

spawn('graphicEq', 'x');
set('x', 'style', 0);
patch('x.out', 'x.audio_l');

midi cv buddy out midiOutBuddy

MIDI CV BUDDY OUT — the output complement of MIDI-CV-BUDDY. Turns the rack's gate / pitch / velocity CV into MIDI notes sent to an external MIDI device, so a sequencer, envelope, or LFO inside the patch can play a hardware synth. A gate rising edge sends NoteOn [0x90|(ch-1), note, vel]; the falling edge sends NoteOff [0x80|(ch-1), note, 0]. The pitch input (V/oct, 0V = C4 = MIDI 60) is quantized to the nearest semitone for the note number, and the velocity input (0..1 CV) maps to MIDI velocity 1..127 — both are sampled at the gate rising edge. The module TRACKS the currently-sounding note so the NoteOff matches the note that was turned on even if pitch drifts while the gate is held. Pick the output device from a dropdown (enumerated from MIDIAccess.outputs; persisted by device name across saves) and the MIDI channel 1..16. Uses the browser's built-in Web MIDI output (no companion app); the user clicks "Connect MIDI…" once per origin to grant access. Device hot-plug is handled, and an all-notes-off plus a matched NoteOff are sent on dispose / device-change / channel-change so external gear is never left with a stuck note. CV is read main-thread via AnalyserNode taps polled on the shared scheduler clock — no AudioWorklet. Terminal MIDI sink (no audio outputs).

inputs

gate gate
pitch cv
velocity cv

example js

spawn('midiOutBuddy', 'x');

monoglitch monoglitch

MONOGLITCH is a luma-driven scanline-displacement glitch effect that doubles as a chainable video OUTPUT. It quantizes the incoming video into a stack of horizontal scanlines (Lines count) and, per line, samples the source luminance at the row center and lifts that line's vertical position upward by luma x Z, so bright pixels bow the lines up while dark areas leave them flat. Each line is rendered as a thin tinted band whose thickness is set by Gap and whose color comes from the R/G/B tint (default a green-phosphor look); the source luminance also gives bright bands a subtle brightness bonus (band color scales by 0.4 + luma x 0.8). H Ramp and V Ramp pan the sampled image horizontally/vertically and wrap at the edges, so feeding them saw LFOs scrolls the whole field. Despite the historical RUTTETRA name it is NOT a true Rutt/Etra raster remap (see reshaper/ruttetra for that) - it is a stylized oscilloscope/CRT-glitch aesthetic. Patch a video source into IN, dial Lines and Z for the scan density and warp, tint to taste, then take OUT into another video module or to screen. With nothing patched it shows a dark-navy idle sweep. The card has an on-card video preview screen showing this module's own glitched output; in hide-controls mode the preview is resizable by dragging the corner handle.

outputs

out video

inputs

in video
hRamp cv
vRamp cv
intensity cv

params

hRamp -1..1
vRamp -1..1
intensity 0..1
lines 8..240
spacing 0..0.95
tintR 0..1
tintG 0..1
tintB 0..1

example js

spawn('monoglitch', 'x');
set('x', 'hRamp', 0);
patch('x.out', 'x.in');

output videoOut

output is the screen sink of the video chain — the card body itself is the live picture. Whatever video signal you patch into it is copied frame-by-frame into this card's own framebuffer (FBO) and blitted onto the visible canvas, aspect-fit (the engine render is letterboxed into the card; the engine is 4:3 by default). The shader is a plain texture copy: with a signal patched it shows the input verbatim; with nothing patched it draws a static idle pattern — a dark navy field with a subtle vertical brightness gradient (the blue channel rises toward one edge) — so you can tell the card is alive while you drag a cable in. The pattern does not animate; there is no time uniform, so it's a fixed gradient, not a moving sweep. Each output card pulls its OWN input via engine.blitOutputToDrawingBuffer(nodeId) (multiple outputs in a rack each show their own feed, no last-one-wins coupling). Right-click the picture for true fullscreen, in-app full-frame (hides chrome, fills the card), or present-on-a-second-display. Use it as the monitor/projector at the end of a video patch — or mid-chain, since it passes its input straight through. The card body is the live output screen and is resizable by dragging the bottom-right corner handle; the engine render (4:3 by default, 1024×768) is aspect-fit (letterboxed) inside whatever size you choose, and the size (node.data.width/height) syncs to collaborators via Y.Doc.

outputs

out video

inputs

in video

example js

spawn('videoOut', 'x');
patch('x.out', 'x.in');

recorderbox recorderbox

Video + audio RECORDER sink. Patch a picture into IN and a stereo soundtrack into A·L / A·R, type a filename, hit RECORD, and RECORDERBOX captures it to a HIGH-QUALITY, CRASH-RECOVERABLE H.264 MP4. Model: like OUTPUT, it monitors its video input (live preview + an OUT pass-through so you can chain it inline) while ALSO recording. Encoding runs through WebCodecs (H.264 video at ~14 Mbps VBR, AAC stereo audio) muxed by Mediabunny (MPL-2.0) into a FRAGMENTED MP4 (fastStart:"fragmented") streamed to OPFS scratch via a dedicated Worker holding a FileSystemSyncAccessHandle — the only browser API that writes real disk synchronously AND survives a tab crash. The OPFS scratch is named after your sanitized filename + a .partial marker + the start epoch, so the partial carries your intended name. Controls: an editable FILE field (node.data.filename, synced to rack-mates), a SIZE / quality selector (HIGH / BALANCED / SMALL), and a RECORD ON/OFF toggle. The SIZE selector trades file size against quality: HIGH is the original ~14 Mbps H.264 (the DEFAULT — no change for existing racks); BALANCED and SMALL PREFER a more efficient modern codec (AV1, then VP9, capability-probed at the actual recording resolution via VideoEncoder.isConfigSupported) at a lower bitrate, longer keyframe interval, and lower audio bitrate, falling back to a lower-bitrate H.264 where no modern codec encodes. The codec stays inside the same fragmented MP4 container, so the extension (.mp4) and crash-recovery semantics never change — only the bytes inside get smaller. SMALL is typically ~70-80% smaller than HIGH; BALANCED ~55-65% smaller, both at near-imperceptible quality cost on synth/visualizer output. The chosen tier syncs to rack-mates (node.data.quality) and is locked while a take is in progress. NO "SAVE AS" PROMPT (folder model): on Chromium, pressing RECORD picks a destination FOLDER ONCE via showDirectoryPicker (a valid user gesture); thereafter the recording auto-writes into that folder using the FILE box directly — no per-save dialog — and the folder is remembered so the next record needs no prompt at all. The ONLY remaining prompt is an OVERWRITE confirm when a file with the target name already exists (cancelling the folder picker, or declining the overwrite, does NOT start recording). The chosen FileSystemDirectoryHandle is persisted into the recovery manifest. On STOP the finished MP4 is remuxed to a flat (NLE-importable) container and STREAMED into the folder (never read whole into memory — a long 4K take can be GBs). Firefox/Safari (no directory picker) record to OPFS and download each file via <a download> with the correct name. GOPRO CHUNKING: a long take rolls to a NEW file every ~10 min with a 5-SECOND AUDIO OVERLAP (the last 5 s of chunk N is duplicated as the start of chunk N+1), named FILENAME-CHUNK#-DATETIME.mp4 (RECORDING-001-…, RECORDING-002-…) — unique + Finder-sortable; a take under ~10 min is a single RECORDING-001-<datetime>.mp4. CONSTANT FRAME RATE: video frames are encoded on an even index/fps PTS grid (not jittery wall-clock time), which fixes the macOS Preview/QuickTime "slow-motion" artifact that an irregular variable-rate PTS stream produced. Inputs: in (video, polymorphic), audio_l + audio_r (audio — a NEW cross-domain audio→video audio-input bridge connects each upstream audio source straight into a MediaStreamAudioDestinationNode this module owns; the audio is TAP-ONLY and is NOT monitored through your speakers). Output: out (video pass-through of in). CRASH RECOVERY: because the file is fragmented and each fragment is flushed to disk, a take is playable from whatever reached disk even if the tab dies before you press STOP — on mount the card scans an IndexedDB manifest for any in-flight recording and offers "Recover unsaved recording?" with Save / Discard. If the destination FOLDER was persisted, Save re-requests write permission and streams the partial straight back into it under the chunk's FILENAME-CHUNK#-DATETIME name (no re-picking); if the handle is gone or permission is denied it falls back to a picker/download suggesting the right filename. Recovery is THIS-MACHINE/BROWSER ONLY (OPFS is origin-local and does NOT sync to collaborators). Defaults: 30 fps, ~14 Mbps; locked but overridable later. Graceful degrade: where the runtime has no OS H.264 encoder (headless CI, some platforms) the RECORD button is disabled with a clear "no H.264 encoder available" badge — it never crashes.

outputs

out video

inputs

in video
audio_l audio
audio_r audio

example js

spawn('recorderbox', 'x');
patch('x.out', 'x.in');

reshaper reshaper

RESHAPER is a coordinate-remap video processor that emulates a CRT raster scan whose horizontal and vertical sweeps are patchable instead of fixed. For every output pixel it reads a horizontal coordinate from the X field and a vertical coordinate from the Y field (the red channel of each mono-video texture), then samples the Z source video at that remapped position. With X and Y unpatched it falls back to identity ramps (screen-u, screen-v), so Z passes straight through like a normal display. Feed X/Y from shaped ramps (e.g. SHAPEDRAMPS folds, triangles, or radial fields) and the source video is rebuilt inside that deformed coordinate space — folded, mirrored, or circularised. On top of the field remap, the source's own brightness at each screen pixel pushes the lookup: luma above mid-grey lifts, below pushes back, scaled by X Disp / Y Disp — the classic Rutt/Etra "raised terrain" displacement. The final color is multiplied by Intensity and the R/G/B tint. Usage: patch a video into Z for a quick scanline display; drive X and/or Y from a ramp generator to warp it, or just dial X Disp / Y Disp for a luma-relief effect from Z alone. Output is a standard video texture, so chain it downstream (e.g. LINES into RESHAPER into MONOGLITCH). The card shows a live preview of the remapped output; in hide-controls mode the preview becomes a resizable screen (drag the bottom-right corner; double-click the frame to restore defaults).

outputs

out video

inputs

x mono-video
y mono-video
z video
intensity cv
xDisp cv
yDisp cv

params

intensity 0..2
xDisp -1..1
yDisp -1..1
tintR 0..1
tintG 0..1
tintB 0..1

example js

spawn('reshaper', 'x');
set('x', 'intensity', 0);
patch('x.out', 'x.x');

tempest tempest

TEMPEST (P1) — a Tempest-style vector-tube shooter as a video SOURCE. This phase renders the glowing additive-line "well" (the QuadraScan vector look): a bright near rim ring, a dim far pit ring, and radial lane lines, with the player CLAW riding the near rim. The CV input `rim` (0..1, wraps) drives the claw's position around the rim — the authentic rotary-spinner control, e.g. a gamepad joystick axis — and the SHAPE param picks the tube cross-section (circle / square / star). Every line segment is expanded on the CPU into a glowing quad (1px gl.LINES clamp to a dim, dotted stipple on the real GPU), so the web reads solid + luminous at any orientation. `out` is a normal downstream video texture. Enemies, fire, scoring, the audio-breathing tube and the video-textured surface land in later phases; the pure geometry/projection core lives in tempest-core.ts.

outputs

out video

inputs

rim cv

params

rim 0..1
shape 0..?

example js

spawn('tempest', 'x');
set('x', 'rim', 0);
patch('x.out', 'x.rim');

xyz ruttetra

An authentic forward-scatter Rutt/Etra scan-processor. A 320x180 grid of sample points walks the Z source; for each point it reads the source luma, places it along an internally-generated H/V ramp, then displaces that position by (luma - 0.5) so bright pixels push their scanline outward and dark pixels recede - building a 3D heightmap relief out of the picture. Adjacent grid points within each row are joined into horizontal LINE segments, and the whole raster is drawn with additive (phosphor) blending over a black field, exactly like a CRT scope. With everything at default the ramp is a linear 1:1 mapping and Y Disp = -0.3, so the source is read upright and bright areas raise the terrain - the classic Rutt/Etra "raised landscape" look. Patch any video, image, or keyer into Z; sweep Y Disp (and X Disp) for relief depth, raise Intensity for a brighter glow, morph the X/Y Shape ramps toward triangle/soft/radial for warped scan geometry, and modulate the params with CV for animated topography. Z left unpatched binds a mid-grey sentinel (luma 0.5 = zero displacement), so the card shows flat scanlines rather than a black void. The card has a live preview screen; hiding the controls turns it into a resizable monitor (drag the bottom-right corner, double-click to restore) — a viewport only, it does not change the output resolution.

outputs

out video

inputs

z video
xShape cv
yShape cv
xDisp cv
yDisp cv
intensity cv
xFreq cv
yFreq cv

params

xShape 0..1
yShape 0..1
xDisp -1..1
yDisp -1..1
intensity 0..2
tintR 0..1
tintG 0..1
tintB 0..1
xFreq 0.25..8
yFreq 0.25..8
xPhase 0..1
yPhase 0..1

example js

spawn('ruttetra', 'x');
set('x', 'xShape', 0);
patch('x.out', 'x.z');

utility

4plexer fourplexer

4-in / 4-out discrete signal router for audio AND cv (they share the Web Audio substrate, so either cable type patches in and routes identically). Four signal inputs (in1..in4) and four signal outputs (out1..out4); each output has its own selector knob (sel1..sel4, shown 1..4 on the card) choosing which ONE of the four inputs that output carries — discrete, never a blend or in-between, with a ~4 ms declick crossfade on the switch so audio-rate inputs don't click. Each output also has its own GATE input (gate1..gate4): every rising edge advances that output's selector to the next input (1→2→3→4→1, wrapping). The four outputs are fully independent — different selections, different gate streams. Knobs are directly settable in the UI (click/drag to a position) and the selection persists in node params (synced + saved); a gate-advance posts the new index back so it persists exactly like a manual click. Defaults are a straight pass-through (out1=in1, out2=in2, out3=in3, out4=in4).

outputs

out1 cv
out2 cv
out3 cv
out4 cv

inputs

in1 cv
in2 cv
in3 cv
in4 cv
gate1 gate
gate2 gate
gate3 gate
gate4 gate

params

sel1 0..3
sel2 0..3
sel3 0..3
sel4 0..3

example js

spawn('fourplexer', 'x');
set('x', 'sel1', 0);
patch('x.out1', 'x.in1');

956 ribbon moog956

956 Ribbon Controller (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). A horizontal touch-ribbon: press and slide along the strip and the position maps to a continuous pitch CV, with a GATE that goes HIGH while touched. Outputs pitch (V/oct: 1.0 = one octave, a semitone = 1/12, matching MIDI CV BUDDY) and gate. Like the hardware resistive ribbon, lifting off HOLDS the last pitch — only the gate falls, so the patched VCO stays at the last played note. SCALE sets the ribbon span in octaves (0..5, default 2); OFFSET shifts the base pitch in octaves (-2..2). A UI-driven CV source in the JOYSTICK / GAMEPAD family — the card pointer drives two ConstantSourceNodes; no audio worklet. Beige moogafakkin faceplate. The on-screen keyboards (950/951/952) are intentionally NOT cloned — route hardware MIDI keys through MIDI CV BUDDY instead.

outputs

pitch pitch
gate gate

params

pos 0..1
gate 0..1
scale 0..5
offset -2..2

example js

spawn('moog956', 'x');
set('x', 'pos', 0);

gamepad gamepad

Connected USB / Bluetooth game controller as CV (stick axes + triggers) and gate (face / bumper / dpad / menu buttons). Reads navigator.getGamepads() at requestAnimationFrame rate. Browser security requires the user to press a button on the gamepad once before the browser exposes it. Outputs: lx / ly / rx / ry (cv ±1, Y inverted so +1 = up, 0.08 deadzone), lt / rt (cv 0..1), lb / rb / a / b / x / y / du / dd / dl / dr / start / back (gate). Standard mapping = Xbox layout; PlayStation + generic HID controllers that report 'standard' mapping also work. Slot param picks which of up to 4 simultaneous controllers to read. LEFT-STICK CALIBRATION: "calibrate left stick" arms a calibration mode — sweep the stick through its full range several times (the card records the observed per-axis min/max live), then "complete calibration" locks the swept range in so observed-min→full-min and observed-max→full-max per axis, with the calibrated centre mapped to 0 and a radial deadzone around it (no snap-back drift). Calibration is persisted once to the patch (rides collab + undo) and applied to lx / ly; "clear" reverts to the fixed-deadzone path. This makes worn pads and non-Xbox-layout sticks (e.g. VKB Gladiator NXT flight sticks, which report a non-standard mapping with a reduced raw range) reach the full ±1 output range.

outputs

lx cv
ly cv
rx cv
ry cv
lt cv
rt cv
lb gate
rb gate
a gate
b gate
x gate
y gate
du gate
dd gate
dl gate
dr gate
start gate
back gate

params

padIndex 0..3

example js

spawn('gamepad', 'x');
set('x', 'padIndex', 0);

gatemaiden gatemaiden

Single-input gate↔trigger converter — the convenience utility for the trigger/gate model (think Doepfer A-162 / Make Noise Maths EOR-EOC in one small module). ONE generic CV input (IN) accepts EITHER a gate or a trigger, and produces BOTH a GATE output and a TRIG output, derived from the input's level + rising edges (no mode switch — like Maths, it always emits both). GATE out is a held square that stays high while the input is high, with a MINIMUM width of the Len knob (0.005–2 s, default 50 ms): so a long gate passes through duration-matched, while a short TRIGGER in is widened into a clean usable gate (trigger→gate). TRIG out fires a short pulse on EVERY rising edge of the input: so a GATE in yields one trigger per gate START (gate→trigger), and a TRIGGER in is effectively reshaped through (one pulse per input pulse). The Shape button picks the emitted trigger waveform — △ triangle (default, a 5 ms ramp-up/ramp-down strike) or ▭ square. In the trigger/gate model: ▷ marks the trigger output, ▭ the gate ports. Why you want it: anything that must START an event should be a trigger (edge-fired once), anything that must SUSTAIN should be a gate (level-held); GATEMAIDEN lets you convert freely between the two when you cross-patch — e.g. take a sequencer's held step-gate and get a clean clock trigger out of its starts, or take a drum trigger and open an ADSR's sustain with a real gate. Sample-accurate DSP (pure core in packages/dsp/src/lib/gatemaiden-dsp.ts), so it single-fires by construction.

outputs

gate gate
trig gate

inputs

in gate

params

gateLen 0.005..2s
trigShape 0..1

example js

spawn('gatemaiden', 'x');
set('x', 'gateLen', 0.05);
patch('x.gate', 'x.in');

joystick joystick

Manual XY controller emitting four bipolar CV outputs. Drag a virtual stick inside a square pad: center = (0, 0), the corners reach (±1, ±1). Outputs the raw X and Y plus their inversions (nx = −x, ny = −y) so you can drive quadrature or mirrored modulation from one hand without copying and inverting downstream. The card snaps back to center on pointer-up; at the audio layer the module is pure — whatever the position params say is what comes out (four ConstantSourceNodes).

outputs

x cv
y cv
nx cv
ny cv

params

pos_x -1..1
pos_y -1..1

example js

spawn('joystick', 'x');
set('x', 'pos_x', 0);

sample & hold sampleHold

Sample & hold combined with a musical scale quantizer. On a RISING EDGE at gate_in the module samples cv_in and HOLDS it on cv_out until the next rising edge; cv_quant is that held value snapped to the nearest note of the selected SCALE (1V/oct, root = C / 0V, 12 equal-tempered semitones per octave, 1/12 V per semitone). When NOTHING is patched to gate_in, cv_in passes through CONTINUOUSLY and cv_quant continuously quantizes the live input — so the module becomes a pure QUANTIZER (the gate-connected state is detected at the graph level, mirroring SEQUENCER/SCORE external-clock-vs-internal-BPM and SKIFREE's unpatched-input fallback). The SCALE knob picks the quantize scale from Chromatic, Major, Minor, Dorian, Phrygian, Lydian, Mixolydian, Locrian, Harmonic Minor, Melodic Minor; the current scale NAME is displayed above the knob and updates reactively (knob / CV / MIDI Learn). The latch + nearest-note quantizer are pure functions (packages/dsp/src/lib/sample-hold-dsp.ts) shared verbatim by the worklet, the unit tests, and node-ART. Classic uses: quantize a slow LFO/random voltage into stepped melodies, sample noise on a clock for stepped random pitches, or strip the gate to use it as an inline quantizer in front of a VCO's pitch input.

outputs

cv_out cv
cv_quant cv

inputs

cv_in cv
gate_in gate

params

scale 0..?

example js

spawn('sampleHold', 'x');
set('x', 'scale', 1);
patch('x.cv_out', 'x.cv_in');

slewswitch slewSwitch

Quad slew limiter combined with a 4→1 sequential CV switch. Four CV inputs each pass through an independent slew limiter (per-channel time constant 1 ms–5 s, CV-controllable) for portamento / smoothing, available on out1–out4. A step_clock gate advances a sequential switch that selects among the (slewed) channels and presents the result on `switched`, with a LENGTH (1–4) and MODE control, a crossfade time between selections, a reset gate, a step_idx CV, and an end-of-cycle (eoc) gate. One of the three ATLANTIS-PATCH support modules; broadly useful as a general CV smoother + router.

outputs

out1 cv
out2 cv
out3 cv
out4 cv
switched cv
step_idx cv
eoc gate

inputs

in1 cv
in2 cv
in3 cv
in4 cv
step_clock gate
reset gate
slew1_cv cv
slew2_cv cv
slew3_cv cv
slew4_cv cv

params

slew1 0.001..5s
slew2 0.001..5s
slew3 0.001..5s
slew4 0.001..5s
mode 0..2
length 1..4
xfadeTime 0.001..2s

example js

spawn('slewSwitch', 'x');
set('x', 'slew1', 0.5);
patch('x.out1', 'x.in1');

processors

905 spring reverb moog905

905 Spring Reverberation (moogafakkin System 55 clone — categorized under Ports -> moogafakkin). The classic spring-tank reverb: metallic, dispersive, with the characteristic "boing"/chirp on transients. In-house dispersive-allpass spring model — a cascaded all-pass chain (the dispersion) feeding a modulated feedback delay with damping. MIX blends dry/wet, DECAY sets the tail length, SIZE the spring length/character. Own-code (clean-room; feedback-clamped for stability). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

audio audio

inputs

audio audio

params

mix 0..1
decay 0..1
size 0..1

example js

spawn('moog905', 'x');
set('x', 'mix', 0.35);
patch('x.audio', 'x.audio');

resofilter resofilter

Multi-mode filter — clean-room TypeScript port of gabrielsoule/resonarium's MultiFilter (Source/dsp/MultiFilter.{h,cpp}). 5 modes drawn straight from upstream's MultiFilter::Type enum and filterTextFunction: LP / HP / BP / Notch / Allpass. All five characters share a single Cytomic / Zavalishin TPT state-variable filter per channel, so the MODE knob is a pure output picker — switching modes mid-render is pop-free. Cutoff 20 Hz – 20 kHz (log), resonance 0..1 (k = 2 − 2·res, edge-of-self-oscillation at the top), per-param CV inputs (cutoff_cv, reso_cv) sum into the AudioParams with a 50 Hz internal one-pole smoother on cutoff to prevent the steep transfer function from clicking on rapid CV jumps. Stereo input (independent L/R SVF state). The card displays the long-form mode name (e.g. "Low-pass") in a label next to the MODE knob — the headline UX feature: the dial updates the text reactively as you turn it. Drive is intentionally omitted (upstream MultiFilter has no drive stage; saturation lives in WrappedSVF / Distortion which is out of scope for this port).

outputs

out_l audio
out_r audio

inputs

audio audio
cutoff_cv cv
reso_cv cv

params

cutoff 20..20000Hz
resonance 0..1
mode 0..?
mix 0..1

example js

spawn('resofilter', 'x');
set('x', 'cutoff', 1000);
patch('x.out_l', 'x.audio');

sidecar sidecar

Stereo sidechain compressor — Giannoulis-Massberg-Reiss 2012 JAES topology (cross-checked against Faust's co.compressor_stereo). Stereo audio in, dedicated SC L/R inputs (with normalling fallback: both unpatched → self-detect on the audio pair, the typical "use this as a plain stereo comp" default). The SC detector path runs a one-pole HPF (sc_hpf 20..1000 Hz, default 20 = effectively off) for kick-immune bus compression, then |sL|+|sR| stereo-link rectifier → log2 → 3-region soft-knee gain computer → asymmetric one-pole smoother (attack 0.1..200 ms log, release 1..2000 ms log) → linear gain via 2^(gainDb/6.0205). Stereo-link is always on in v1 so transients never shift the image under compression. Two ENV outputs expose the reduction envelope for cross-patch ducking: env_out = (-gainDb / 24) * envMag (NO clamp — at envMag>1 the output can overshoot 1.0, by spec), and env_inv_out = 1 - env_out (the canonical "patch this into a VCA strength to make it close when the comp fires"). Threshold (-60..0 dB) and envMag (0..2) are CV-modulatable; ratio, attack, release, knee, makeup, and sc_hpf are knob-only. Per-sample param smoothing kills clicks on rapid threshold / envMag changes. The 6.0205 factor (= 20·log10(2)) is the GMR-canonical log2↔dB bridge that lets the smoother run cleanly in the dB domain.

outputs

audio_l_out audio
audio_r_out audio
env_out cv
env_inv_out cv

inputs

audio_l_in audio
audio_r_in audio
sc_l_in audio
sc_r_in audio
threshold_cv cv
env_mag_cv cv
input_level_cv cv

params

threshold -60..0dB
ratio 1..20
attack 0.1..200ms
release 1..2000ms
knee 0..24dB
envMag 0..2
inputLevel 0..2%
makeup 0..24dB
sc_hpf 20..1000Hz

example js

spawn('sidecar', 'x');
set('x', 'threshold', -18);
patch('x.audio_l_out', 'x.audio_l_in');

filter

923 filters / noise source moog923

923 Filters / Noise Source (moogafakkin System 35 clone — categorized under Ports -> moogafakkin). White + pink noise outputs PLUS a fixed filter utility on an external audio input: independent low-pass and high-pass taps with LO PASS / HI PASS cutoff knobs (log-mapped ~40 Hz-20 kHz). Own-code (noise generator + biquad filters). Beige moogafakkin faceplate (the intrinsic always-on look shared by the moogafakkin module family).

outputs

white audio
pink audio
lp audio
hp audio

inputs

audio audio

params

level 0..1
lpCutoff 0..1
hpCutoff 0..1

example js

spawn('moog923', 'x');
set('x', 'level', 0.8);
patch('x.white', 'x.audio');

games

frogger frogger

Interactive Frogger game module (clean-room TypeScript port of Adrian Eyre's React Frogger, MIT-licensed). FULL CV-gate control with NO keyboard exposure on the module: five gate inputs (up_gate / down_gate / left_gate / right_gate / start_gate) are rising-edge triggered to play the game. The start_gate auto-fires once on module-spawn (a synthesized first-tick rising edge) so the user sees a running game by default — the upstream React app's pre-game InfoBoard ("click Start Game") is bypassed via this synthetic pulse. The same start_gate is rising-edge triggered by external CV to restart at any time. Three gate outputs fire one 5 ms pulse per event: home_gate (a frog reached one of the 5 home slots — fires up to 5 times per level), dead_gate (frog hit a vehicle, fell in water without a raft, or the per-level timer ran out), level_gate (all 5 homes filled — level complete). One knob: TIME (10..120 s, default 60) sets the per-level timer budget. Game logic runs at visual cadence on the main thread (no audio worklet); pure deterministic state stepper in frogger-state.ts. vizPassthrough: the on-card 14×13 grid canvas can be portaled into a containing GroupCard for cross-domain video out (same mechanism MODTRIS / PONG / SCOPE use). See docs/design/game-modules.md for the multi-user follow-up path.

outputs

home_gate gate
dead_gate gate
level_gate gate

inputs

up_gate gate
down_gate gate
left_gate gate
right_gate gate
start_gate gate

params

initialTime 10..120

example js

spawn('frogger', 'x');
set('x', 'initialTime', 0);
patch('x.home_gate', 'x.up_gate');

modtris modtris

Interactive Tetris-clone game module (single-user research prototype). Five gate inputs (rotate_l / rotate_r / drop_fast / move_l / move_r) are rising-edge triggered to play the game; two gate outputs fire one 5 ms pulse per event — line_cleared (a Tetris emits four separate staggered pulses, one per line) and overfill (game over). Game logic runs at visual cadence on the main thread (no audio worklet), with a deterministic, tested state stepper. Patch a sequencer or controller into the inputs and route the cleared-line / overfill gates as triggers, turning gameplay into a modulation source. See docs/design/game-modules.md.

outputs

line_cleared gate
overfill gate

inputs

rotate_l gate
rotate_r gate
drop_fast gate
move_l gate
move_r gate

params

gravityBpm 30..240
levelStep 1..20

example js

spawn('modtris', 'x');
set('x', 'gravityBpm', 60);
patch('x.line_cleared', 'x.rotate_l');

pong pong

Interactive Pong game module (single-user research prototype). Two CV inputs (paddle_left / paddle_right) set each paddle's Y position; two gate outputs (score_left / score_right) fire one 5 ms pulse per scoring event, sample-accurate on the audio thread. The deterministic state stepper runs at visual cadence on the main thread (no audio worklet). Drive the paddles from LFOs / envelopes / joysticks and use the score gates as triggers — the game becomes a generative modulation source. Multiplayer is a planned additive follow-up (the design doc lays out the SyncedModuleDef path). See docs/design/game-modules.md.

outputs

score_left gate
score_right gate

inputs

paddle_left cv
paddle_right cv

params

speed 0.25..4
paddleH 0.05..0.5
serveAngle 0..1

example js

spawn('pong', 'x');
set('x', 'speed', 1);
patch('x.score_left', 'x.paddle_left');

skifree skifree

The classic SKIFREE (ski downhill, dodge trees / rocks / jumps, get chased and EATEN by the abominable snowman) as a CV-controlled game module — a thin wrapper around the upstream skifree.js engine (MIT, Daniel Hough 2013). Single-instance per rack (maxInstances:1). Two bipolar CV inputs (x / y, −1..+1) synthesize the mouse cursor the skier steers TOWARD: x = cursor X across the canvas (0 = left edge, +1 = right edge), y = cursor Y (the skier always heads downhill; cursor position sets the steering angle + speed). When x and y are BOTH unpatched AND the card is focused, native mouse control engages — steer the skier with the real mouse directly on the canvas. Any patched CV OVERRIDES the mouse (the factory writes the CV cursor each scheduler tick; the card disables mouse). One gate output: a rising-edge 10 ms pulse on every CRASH (hitting a tree / rock / snowboarder / failed jump) OR when the yeti EATS the skier — hooked to the engine's hasHitObstacle callback (upstream fires it for crashes and, via isEatenBy, for eats), so the game becomes a trigger source for envelopes / sequencers. One video output (out): the game canvas mirrored each video frame via the cross-domain audio→video bridge — patch SKIFREE → VIDEO OUT / BENTBOX / any video module to send the ski-slope render downstream (mirrors the DOOM `out` pattern). vizPassthrough on the on-card canvas so a containing GROUP can portal it across-domain. No audio worklet — the gate is a ConstantSourceNode pulsed on the event (PONG's pattern); the game logic runs at rAF cadence inside the bundle. Bundle committed pre-built at /skifree/skifree.bundle.js (~24 KB, esbuild IIFE of the upstream js/ classes + a thin embed wrapper); sprite sheets at /skifree/*.png. See packages/web/native/skifree/README.md for the regeneration recipe + attribution.

outputs

gate gate
out video

inputs

x cv
y cv

example js

spawn('skifree', 'x');
patch('x.gate', 'x.x');

snes9x snes9x

A Super Nintendo emulator turned into a patchable video+audio module. It runs the snes9x2005 (CAT SFC) libretro core compiled to WASM, rendering the SNES screen (locked 256×224/239, 4:3) to the video out and 32 kHz stereo to audio_l/audio_r. The ROM is user-provided and gitignored: if /roms/snes9x/game.sfc isn't autoloaded the card shows a LOAD A ROM dropzone/file-picker (drop or click a .sfc/.smc — it stays local in your browser). Beyond the picture and sound, it reads the live SNES WRAM each frame to emit game-event CV/GATE: for Super Mario World it pulses on kills and deaths, holds a CV for the current world, and turns clock_in into a clock multiplied by (world+level). Drive it by wiring a GAMEPAD module's gate outputs straight into the 12 SNES button inputs (du→up, a→a, …) plus a clock into clock_in. Single-instance per rack (the WASM core is heavy). DOM-only affordances with no patch port: the ROM dropzone/file picker, and a right-click "see output definition for CV/GATES" panel that explains every game-event output for the loaded ROM; the card's OUTPUT FIT toggle sets the fillMode param (letterbox vs fill). Non-SMW ROMs still boot and show video/audio but the game-event outputs stay inert.

outputs

out video
audio_l audio
audio_r audio

inputs

clock_in gate

params

cv_clock_in 0..1
fillMode 0..1

example js

spawn('snes9x', 'x');
set('x', 'cv_clock_in', 0);
patch('x.out', 'x.clock_in');

video-effects

mandleblot mandleblot

MANDLEBLOT is a 2D Mandelbrot fractal generator rendered on the GPU. A WebGL2 fragment shader runs the escape-time loop (z = z² + c, bailout radius 16) per pixel, then smooth-colours it with the standard fractional-iteration trick (mu = i + 1 - log(log|z|)/log2) so colour bands don't stairstep. The same program renders twice per frame: a greyscale escape-time field to mono_out and an RGB-cycling palette to color_out, where hue is driven by iteration band (mu), time, and log(zoom) so each zoom depth feels like its own palette. It is a pure generator with no video input — it synthesizes the fractal from scratch. Frame it with X/Y, drive Zoom by hand or via zoom_cv (LFO/envelope) for an automatic dive into the seahorse valleys, raise Iter for filament detail in deep zooms, and use Color/Rot to animate the look. Single-precision highp-float caps usable zoom near 1e6×, past which the image goes block-y.

outputs

mono_out mono-video
color_out video

inputs

zoom_cv cv

params

zoom 0..1
rotation 0..1
iterations 50..500
color_cycle 0..4
center_x -2..2
center_y -2..2

example js

spawn('mandleblot', 'x');
set('x', 'zoom', 0);
patch('x.mono_out', 'x.zoom_cv');

shapegen shapegen

shapegen is a generative 3D-shape video synthesizer (extracted from FOXY's shape path). It has no straight video pass-through input: instead it reads three incoming rasters as control surfaces and synthesizes a scene of up to 8 lit primitives (sphere, cube, cone, cylinder, ring/torus, tetrahedron) floating inside a vaporwave wireframe bounding box with a faint perspective floor grid. Each raster is downsampled to an 80x60 RGBA buffer and fed to generateShapes: A's 16x16 mean-luma feature grid yields the top-8 peaks (non-max-suppressed) that place shapes in XY (if A is flat below the variance floor, NO shapes are drawn), B's luma at each peak sets Z depth, and C's luma picks the primitive type bucket (floor(c*6)), the baseline radius (0.05+c*0.25) and the hue (=c). The product of A and B luma at each peak gives a per-shape size factor of 0.5x-2x. The whole scene is painted to an OffscreenCanvas, uploaded as a texture, and blitted out a fullscreen quad. Usage: patch any three video sources into A/B/C, twist ROT to orbit the camera, raise SIZE to fatten the primitives, and flip SOLIDS for shaded vs neon-wireframe looks; patch a gate into CLK to freeze the shape set and only re-roll it on each rising edge (a visual sample-and-hold) while the camera keeps rotating.

outputs

out video

inputs

raster_a video
raster_b video
raster_c video

params

size 0.1..3
rotate 0..1
solids 0..1

example js

spawn('shapegen', 'x');
set('x', 'size', 0);
patch('x.out', 'x.raster_a');

hybrid

spectrograph spectrograph

SPECTROGRAPH — a real-time scrolling sonogram VIDEO generator. Takes ONE mono audio input and renders a log-binned spectrograph: FREQUENCY on the vertical axis (log scale, 20 Hz at the BOTTOM up to 20 kHz / Nyquist at the top), TIME scrolling horizontally with the NEWEST column at the RIGHT (older content slides off the left). Model: an AnalyserNode tap (1024-pt FFT, getFloatFrequencyData dBFS) on the input is log-binned into 128 perceptual rows per column spanning [20 Hz .. 20 kHz] (each row picks the nearest FFT bin to its target Hz, DC skipped); magnitudes are normalized over a -90 dBFS (quiet) .. -10 dBFS (loud) display window and written into a 256-wide circular column buffer that advances at most once per ~16 ms frame (steady scroll independent of how many outputs are patched). The binning + colormap math is the same algorithm WAVESCULPT uses for its spectrograph view (video_mode 2), lifted into a pure GPU-free core. TWO video outputs render the SAME binned dB plane through two different colormaps — both always live regardless of which the on-card preview shows. IO — IN (audio): the mono signal to analyse. COLOR OUT (mono-video): the blue→cyan→yellow→red HEAT colormap (loud = hot/red, quiet = dark blue/black) — the classic colored spectrogram. B/W OUT (mono-video): INVERTED grayscale — quiet = light/WHITE, loud = dark/BLACK — i.e. the classic PRINTED-SONOGRAM look (light page, dark traces). Controls — GAIN: a pre-analysis input trim (×0.25 .. ×4, LOG taper, unity at center) applied by a GainNode BEFORE the analyser, so you can boost a quiet source up into the -90..-10 dB display window (or tame a hot one) without changing the displayed dynamic range. GAIN is MIDI / control-surface assignable (right-click → MIDI Learn) like every other knob. A card VIEW toggle (COLOR / B/W) just switches which output the on-card preview shows — it does not change either output. All patching is via the card's yellow drill-down PATCH PANEL (top-left / top-right affordances → INPUT / OUTPUT) — no side jacks. It is a `domain: audio` module that exposes VIDEO outputs through the audio→video texture bridge (the SYNESTHESIA / WAVESCULPT cross-domain pattern), so you patch COLOR / B/W OUT straight into any video module or the video OUTPUT. Usage: drop it on any audio bus to SEE the spectral content of a synth / drum / mix in real time — patch COLOR into the video OUTPUT for the colored sonogram, or B/W for the printed-paper look; feed it from a SCALER / mixer to pick which signal you scope.

outputs

color mono-video
bw mono-video

inputs

in audio

params

gain 0.25..4

example js

spawn('spectrograph', 'x');
set('x', 'gain', 1);
patch('x.color', 'x.in');

synesthesia synesthesia

Audio→video event processor modeled on the LZX Sensory Translator — two independent copies (A/B), each switchable between AUDIO and VIDEO mode. In AUDIO mode a copy splits its mono input into 4 MUSICAL spectral bands (bass 20–200 / low-mid 200–1k / high-mid 1k–4k / treble 4k+ Hz) so a drum kit lands cleanly across the bands (kick→band1, snare→band2/3, hats→band4). In VIDEO mode the 4 lanes become the R/G/B/Luma channels of a patched video frame (a_video_in / b_video_in cross-domain inputs): the card averages the frame to per-channel 0..1 levels (solid red maxes R, solid white maxes all incl. luma). In BOTH modes each lane derives a gained audio/CV tap, slow (500 ms) + fast (50 ms) envelope-follower CV (real ~2/40 ms attack so a kick onset hits the band CV hard + locked to the transient, without strobing video), boosted by a per-band CV makeup gain so a STRONG kick drives the bass CV to (near) full scale — patch it into a continuous CV input (e.g. OUTLINES rotation) and a strong kick runs the whole range. A hysteresis gate (keyed off the un-boosted envelope, so its timing + the gibribbon game feel are unchanged), a per-band BEAT TRIGGER (a ~10 ms pulse from a spectral-flux onset detector with an adaptive threshold + 80 ms debounce — fires once per kick/snare/hat, NOT continuously on a sustained tone), a 10-bar green→red VU meter, and a mono-video raster. Master gain (0.5–1.5×) sets the floor; per-band gain (1–2×) adds on top. A per-band ENV-OUTPUT DEPTH knob (8 = 2 copies × 4 bands, range 0..2, default 1× = unchanged) scales BOTH that band's env CV outputs (env_slow + env_fast) together — the source-side modulation-depth control: turn it down (0 = silenced) to tame a band's envelopes, or up (toward 2×, clamped at the 0..1 CV ceiling) so even a weak band reaches full modulation depth at the SOURCE. It only touches the two env CV outputs — gate / beat-trigger / band-audio / VU are unaffected. Patch a band trigger into a video switch/flash to cut video on the beat; patch the slow envelopes for smooth colour modulation.

outputs

a_band1_audio audio
a_band1_env_slow cv
a_band1_env_fast cv
a_band1_gate gate
a_band1_trig gate
a_band1_raster mono-video
a_band2_audio audio
a_band2_env_slow cv
a_band2_env_fast cv
a_band2_gate gate
a_band2_trig gate
a_band2_raster mono-video
a_band3_audio audio
a_band3_env_slow cv
a_band3_env_fast cv
a_band3_gate gate
a_band3_trig gate
a_band3_raster mono-video
a_band4_audio audio
a_band4_env_slow cv
a_band4_env_fast cv
a_band4_gate gate
a_band4_trig gate
a_band4_raster mono-video
b_band1_audio audio
b_band1_env_slow cv
b_band1_env_fast cv
b_band1_gate gate
b_band1_trig gate
b_band1_raster mono-video
b_band2_audio audio
b_band2_env_slow cv
b_band2_env_fast cv
b_band2_gate gate
b_band2_trig gate
b_band2_raster mono-video
b_band3_audio audio
b_band3_env_slow cv
b_band3_env_fast cv
b_band3_gate gate
b_band3_trig gate
b_band3_raster mono-video
b_band4_audio audio
b_band4_env_slow cv
b_band4_env_fast cv
b_band4_gate gate
b_band4_trig gate
b_band4_raster mono-video

inputs

a_in audio
b_in audio
a_video_in video
b_video_in video

params

a_mode 0..1
b_mode 0..1
a_bipolar 0..1
b_bipolar 0..1
a_master 0.5..1.5
b_master 0.5..1.5
a_gain1 1..2
a_gain2 1..2
a_gain3 1..2
a_gain4 1..2
b_gain1 1..2
b_gain2 1..2
b_gain3 1..2
b_gain4 1..2
a_envdepth1 0..2
a_envdepth2 0..2
a_envdepth3 0..2
a_envdepth4 0..2
b_envdepth1 0..2
b_envdepth2 0..2
b_envdepth3 0..2
b_envdepth4 0..2

example js

spawn('synesthesia', 'x');
set('x', 'a_mode', 0);
patch('x.a_band1_audio', 'x.a_in');

Limitations & roadmap

Per-tick reads (read('vco1', 'outputPeak.sine')) for engine analyser taps are deferred — only patch-graph reads work today.
The sandbox is new Function-based — it's not a hard security boundary. A determined user can escape via this.constructor.constructor('return process')(). For a LOCAL-USER-OWNS-THEIR-OWN-RACK tool this is acceptable; if you ever embed LIVECODE in a multi-tenant context, replace the sandbox with a Web Worker isolate.
No collaborative editing inside the CodeMirror editor (multi-caret CRDT). Two users typing on the same LIVECODE see last-write-wins on commit-debounce.
MIDI-locked clock: clocked() uses TIMELORDE.bpm as the source of truth. When TIMELORDE is locked to MIDICLOCK its bpm param reflects the locked rate, so this Just Works™ — but the docs page hasn't been verified against every MIDI device.