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('cartesian',   '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('TIMELORDE1.1x', 'seq.clock');  // clock the grid from the rack's TIMELORDE
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);

// ── 4-note melody on the grid's clocked diagonal walk ──────────
// With no X/Y CV patched the cursor visits pads 0, 5, 10, 15.
setData('seq', 'cells', Array.from({ length: 16 }, function (_, i) {
  const d = [0, 5, 10, 15].indexOf(i);
  return d < 0 ? { on: false, midi: 60, chord: 'mono' }
               : { on: true, midi: [60, 64, 67, 72][d], chord: 'mono' };
}));

// ── 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; the master clock's
// quarter-note pulse 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('timelorde', 'tl');
spawn('audioOut', 'mainout');

patch('lead.sine',       'duck.audio');
patch('ducker.env_inv',  'duck.cv');
patch('tl.1x',           '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; run the transport so the quarter-note pulse fires on
// the beat.
set('tl', 'bpm',     120);
set('tl', 'running', 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 (63)modulation (17)filters (7)effects (31)utilities (31)output (15)utility (8)processors (3)filter (1)games (4)video-effects (3)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) adds +/-Hz rather than octaves — it is one-sided in practice, because the core clamps at a positive 0.01 Hz floor, so a large negative excursion parks the oscillator instead of driving it through zero. A sync input drives the three-position SOFT / OFF / HARD sync switch for classic sync timbres. RANGE sets the coarse octave (+/-5 oct) and FREQ the fine tune (+/-12 st): together those two dials span 12 octaves, 4.09 Hz to 16.74 kHz, and both read 0 at the factory settings where it sings C4. WIDTH sets the rectangular duty cycle (with audio-rate width_cv) and is a pure timbre control — the tap level does not change across its span; LEVEL is the output gain on all four taps. The four jacks are NOT level-matched: at one LEVEL setting they sit within 4.8 dB of each other, rectangular loudest and sawtooth quietest. 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 — clamped to 0.01 Hz at the bottom and to just under Nyquist at the top (23 520 Hz at a 48 kHz sample rate), not the hardware's nominal 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

One phase accumulator, six taps: saw / square / triangle / sine, a saw→sine→square morph, and a sync pulse. Exponential FM and phase modulation, plus hard sync in.

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 — and a LOUDER one than a pair that shares nothing (1+4 beats 1+5 by 1.76 dB). No musical AD you can dial — bare on/off sines through a one-pole anti-click ramp (τ ≈ 1 ms), inaudibly fast on the way up and about 15 ms to silence on release. The mono sum is scaled by 1/4: one digit sits 18 dB below full scale, eight simultaneous digits reach it, and all twelve keys overshoot by about 2.5 dB.

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.

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');

clap clap

Analog-modeled HANDCLAP voice — the fourth member of the drum family (KICK DRUM / SNARE DRUM / TOM DRUM), at deliberately CURATED complexity: one synthesis engine, eight voice knobs + level, spanning the classic clap circuits in one continuous space (TR-808 canonical twin-VCA burst+tail, TR-909 dense bright machine burst, Simmons-ClapTrap spread, LinnDrum-era dark room clap). DSP (own-code, packages/dsp/src/lib/clap-dsp.ts): seeded white noise → COLOR one-pole tilt (log-swept 9 kHz→700 Hz, white→dark, gain-compensated) → Chamberlin band-pass at TONE (400–3000 Hz; the 808 sits near 1 kHz, the 909 near 1.14 kHz) with WIDTH morphing ringy Q≈5.5 → broad splash (1/√q loudness-compensated) → the 808 twin-VCA topology: a BURST of PULSES (2–5) retriggered envelopes SPREAD ms apart (4–25, latched per hit; each pulse decays −60 dB in exactly the spacing — the quad-comparator sawtooth cycles — and the FINAL pulse rings 2× longer, the uninterrupted last discharge) summed with a separate smooth reverb TAIL envelope (30–800 ms, fired at the last pulse, fed one pole darker — the fake room). SNAP is the equal-power burst↔room balance (1 = bone-dry machine clap, 0 = room only); DRIVE a 2×-oversampled warm-tanh; then 20 Hz DC block, dB LEVEL, and a true-peak tanh bound (|out| < 1 always). Inputs: trigger_in (edge-trigger STRIKE — burst geometry + accent latched, noise reseeded: every hit bit-identical), accent_in (per-hit 0..1 CV latched at the strike edge: up to +80 % velocity AND +60 % room excitation — a harder clap is bigger, not just louder), tone_cv (±1.5 oct/V — ±1 V covers the whole knob range), tail_cv (2 oct of tail time per volt), spread_cv (±1.3 oct/V, latched per hit — the ClapTrap random-spread trick, deterministic). Output: ONE mono audio_out. Card: compact BURST·NOISE·ROOM/OUT fader band + a press-to-fire CLAP pad (the `strike` param, OR-ed with trigger_in in the worklet — one clap per press edge).

outputs

audio_out audio

inputs

trigger_in gate
accent_in cv
tone_cv cv
tail_cv cv
spread_cv cv

params

pulses 2..5
spread 4..25ms
tone 400..3000Hz
width 0..1
tail 30..800ms
color 0..1
snap 0..1
drive 0..1
level -24..12dB
strike 0..1

example js

spawn('clap', 'x');
set('x', 'pulses', 3);
patch('x.audio_out', 'x.trigger_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=pwm-sweep, CEILING=harmonic-sweep — ALL THREE must differ or one control dies by arithmetic: FLOOR=CEILING makes MORPH algebraically inert, and either connector slot matching WALL sends the occupancy function into its degenerate hard-step branch and kills CONNECT and CONNECT STRENGTH outright. The faceplate's table-stack panel draws the three heightfields and names the casualty when it happens), 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, and the separate ports mean the offset survives patching into mono inputs; measured, the resulting image is NARROW, about -36 dB of side against mid at the stop with the two channels 0.99998 correlated, so treat SPREAD as a widener rather than a stereo field). View-only Zoom + Rot X/Y orbit the WebGL2 3D cube visualization (dragging the faceplate hero writes the same two angles) (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=0 (the default) is pure ADSR (silent between notes), 0.5 floors at 0.5 and rises to 1.0 at the env peak, base=1 means the env does nothing (full gain while active). It applies ONLY to gated voices: the raw-VCO case (nothing patched) runs at unity independently of BASE, so the legacy continuous drone is byte-identical at every setting. 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. A VIDEO OUT port carries a live render of that same 3D view to any video module. SYNC is a pure sine off the playback phase that is NOT scaled by LEVEL and runs about 6 dB hotter than the L/R pair, so mixing it alongside them is a level surprise. Only PITCH is audio-rate: every other CV jack is summed into an AudioParam the worklet samples once per block (~375 Hz), quantised to 1/512 of range and 80 Hz-smoothed, so an audio-rate source into one of them aliases rather than modulates.

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

outputs

out audio

inputs

poly polyPitchGate
pitch_cv cv
gate gate

params

algorithm 1..32
feedback 0..7
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');

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');

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');

karplus karplus

Extended Karplus-Strong STRING/HARP VOICE built on the COFEFVE DELAY's own fractional delay-line core (owner directive — no parallel delay implementation): a strike fires a seeded noise burst into a recirculating delay-line "string" and the ring IS the note, decaying like a real vibrating string. The full Jaffe–Smith/CCRMA EKS extension set, curated to 6 voice knobs + CV: DECAY is t60 in real SECONDS, frequency-compensated with the ρ = 0.001^(1/(f0·t60)) per-period loss law so low notes do NOT ring 10× longer than high ones (the classic K-S sin, fixed); BRIGHT is the string material — an in-loop damping low-pass whose cutoff TRACKS the note (fc = f0·2^(0.5+5.5·knob), so ≈1.4×f0 felt-dark … 64×f0 steel-bright, the Rings damping vocabulary), phase-compensated at f0 so it never detunes the note (below BRIGHT ≈0.1 the safety cap on loop gain does shorten it — a dark string cannot ring for 10 s); POS is the pick position (feedforward comb at β of the period — β=0.5 cancels even harmonics for a hollow mid-pluck, small β = bridge-thin); STIFF adds dispersion allpasses that stretch upper partials SHARP toward piano wire / bell / gong; COLOR (200 Hz mallet → 10 kHz pick low-pass) and BURST (0.1–4 PERIODS of noise, energy-normalized: near-impulse tick → classic 1-period pluck → scraped/bowed onset) shape the exciter. Tuning: 1 V/oct (f0 = Tune × 2^V, 30 Hz–4.2 kHz) with every loop stage's phase delay at f0 compensated in closed form and the fraction realized by the cofefve Catmull-Rom read — measured ≤ 0.1 cents across C2–C7 (unit-gated < 3). Inputs: trigger_in (edge-trigger STRIKE, burst reseeded per hit — deterministic), pitch (1 V/oct), accent_in (per-hit velocity latched at the edge: louder + brighter), damp_in (level-sensitive palm mute WHILE high, ~50 ms choke), plus a per-control CV on EVERY one of the eight knobs (tune_cv/decay_cv/bright_cv/position_cv/stiff_cv/color_cv/burst_cv/level_cv — each ±1 sweeps its param full-range around the knob, all 80 Hz-smoothed in the worklet, so `pitch` is the module's only genuinely audio-rate input). Mono out (the string tap, taken pre-damping) with LEVEL −24..+12 dB. Card: STRING·EXCITER fader bands + a PLUCK audition button (fires the canonical shared trigger pulse). RACKLINE face (?shell=1): hero ranks DECAY + BRIGHT with a live output scope; pages string·ring / pick·strike / output; rear card groups the four play jacks into a striking hand (STRIKE + ACCENT) and a fretting hand (1 V/OCT + DAMP). Stability is proven, not hoped: modes k ≥ 1 are bounded by ρ < 1 and the k = 0 loop mode is pinned below unity by an f0-tracked DC blocker (unit-gated at the hostile knob extremes).

outputs

out audio

inputs

trigger_in gate
pitch pitch
accent_in cv
damp_in gate
decay_cv cv
bright_cv cv
position_cv cv
stiff_cv cv
color_cv cv
tune_cv cv
burst_cv cv
level_cv cv

params

tune 55..1760Hz
decay 0.1..10s
brightness 0..1
position 0.02..0.5
stiffness 0..1
color 0..1
burst 0.1..4
level -24..12dB

example js

spawn('karplus', 'x');
set('x', 'tune', 220);
patch('x.out', 'x.trigger_in');

kick drum kickdrum

Layered stereo kick VOICE — the "shake the house" deep-bass kick (own-code). 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), PLUS a per-control CV input for every one of the 25 voice knobs (tune_cv … level_cv — each ±1 sweeps its param full-range around the live knob, cvScale matched to the knob curve). Level spans −24..+12 dB with deliberate headroom, 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
tune_cv cv
sub_decay_cv cv
sub_level_cv cv
pitch_amt_cv cv
pitch_time_cv cv
tension_cv cv
body_decay_cv cv
body_level_cv cv
body_shape_cv cv
click_len_cv cv
click_tone_cv cv
click_level_cv cv
drive_cv cv
hard_cv cv
translate_cv cv
sub_eq_cv cv
body_eq_cv cv
attack_eq_cv cv
tilt_cv cv
attack_cv cv
sustain_cv cv
glue_cv cv
ceiling_cv cv
width_cv cv
level_cv cv

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 current tab is captured via the Screen Capture API (getDisplayMedia({ video: { displaySurface: "browser" }, preferCurrentTab: true, selfBrowserSurface: "include" })), run 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 (re-measured every frame by a node-scoped pump that outlives any one card mount, and 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, the live preview is intentionally recursive (a video-feedback tunnel). Params: gain (0..2 RGB multiplier), crop (viewport vs whole-tab, ON by default). STARTING A CAPTURE ALWAYS TAKES A CLICK — getDisplayMedia has no already-granted state, so unlike CAMERA nothing can resume a capture automatically: every capture needs a fresh user gesture and a fresh trip through the picker. That gesture is START CAPTURE on the faceplate under the default shell, or the card's Start capture button under ?shell=legacy. A capture ends with STOP or from the browser's own share bar (the module returns to idle with a re-capture button); getDisplayMedia is feature-detected, degrading to a disabled unsupported state with the reason where the API is missing.

outputs

out video

params

gain 0..2
crop 0..1

example js

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

lush garden lushgarden

LUSH GARDEN — generative layered-garden video SOURCE. Assembles a dense 2D English-garden bed from a bank of plant cutouts (flowers/bushes/small trees, ~70/20/10 spawn mix) on a ground plane running from the bottom edge up to an INVISIBLE horizon (the HORIZON knob moves placement geometry only — no line is ever drawn at it). Plants spawn continuously at RATE spawns/sec, grow in from their ground anchor (~350 ms ease-out), scale down with depth (perspective) on top of the tree > bush > flower kind scale, and composite back-to-front; VIEW pans a viewport across a ~2.5-frame-wide world with depth-proportional 2D parallax (near sweeps, far crawls). At the 350-plant cap each spawn replaces the OLDEST plant so the bed keeps evolving. Patch a gate into GROW and continuous spawning stops — exactly ONE plant grows per rising edge ([GATED] badge); a RESET edge clears the bed. FOUR simultaneous outputs render the same scene: CLEAN (plain composite, the card preview), MONO (white silhouette outlines via an alpha-Sobel baked per cutout), WATERCOLOR (colours bled strictly inside each silhouette), PSYCHEDELIC (animated hue-cycled colours, per-plant phase). An optional BACKGROUND video passes through unprocessed behind the plants on all four outputs. Cutouts load lazily from static/lushgarden (manifest-driven; outline+watercolor baked once per cutout at load so the 4 outputs stay cheap; unconnected outputs are skipped). All ports live on the yellow drill-down PATCH PANEL (no raw side jacks, #767).

outputs

mono video
watercolor video
psychedelic video
clean video

inputs

background video
rate cv
horizon cv
view cv

params

rate ?..?
horizon 0..1
view 0..1
fov 0..1
freeze 0..1

example js

spawn('lushgarden', 'x');
set('x', 'rate', 0);
patch('x.mono', 'x.background');

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 ?..?
freeze 0..1

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');

mirrorpool mirrorpool

MIRRORPOOL — a WebGL2 VIDEO source rendering a hemisphere pool of liquid inside a box, viewed by a full-PTZ camera you fly around within it. TWO video inputs feed the optics: POOL is surface-mapped to the INSIDE of the hemisphere (the underwater view you see refracted through the water, with Beer-Lambert depth absorption + chromatic dispersion) and SCENE is the surroundings, reflected off the surface as an overhead backdrop (projected to the box ceiling so a camera pan slides a RECOGNISABLE reflection, not a lat-long smear). A single REAL height field drives all the optics — not a flat normal-map fake: WIND raises a set of 4 directional swell waves whose amplitude grows with wavelength (dispersion omega=sqrt(g*k), so bigger crests are genuinely TALLER and travel FASTER), and RAIN runs a seeded Poisson scheduler spawning raindrop impacts that punch one-shot dimples which expand into propagating rings — sparse shallow drizzle up to a dense deep downpour. The surface NORMAL reconstructed from that height field (by finite differences, one consistent sign convention shared by the sim + swell so they never cancel) drives a physically-based Schlick FRESNEL split (water F0=0.02, eta=1/1.33). In the default REFRACT mode (MODE=0) you see the reflected scene layered over the refracted, caustic-lit pool beneath; sweep MODE toward MIRROR (1) and the surface becomes a near-full mirror of the sky/scene that the ripple normals shatter and distort — one continuous CV-friendly scalar, no branch. BRIGHT is a virtual sun scaling overall scene light uniformly (no sun disc drawn yet). The camera is a repositionable ORBIT + FREE-LOOK rig surfaced as the card's TWO X-Y pads: pad 1 POSITIONS the eye on a sphere around the pool (Orbit = azimuth around it, Elev = elevation from straight overhead down BELOW the water surface, plus a Dist dial), and pad 2 is the free-LOOK offset (Look X = yaw, Look Y = pitch) off the default aim-at-centre so the view can point any direction; Zoom sets a 70..20 degree FOV. Dropping the elevation below the surface flips the render into an underwater Snell-window path (a bright refracted cone of the sky/scene overhead, ringed by total-internal-reflection of the pool interior). Every control has a matching CV input (port id == param id + `_cv`), so patch an LFO into orbit_az_cv for a slow orbit, noise into rain_cv to gust the storm, or an envelope into surface_mode_cv to melt between a clear pool and a hard mirror. The rain wave sim runs as a float ping-pong wave-equation FBO when the GPU exposes renderable float targets, and falls back to an analytic expanding-ring model in the render shader when it does not (isFloat=false, e.g. some SwiftShader configs) so rain is never a dead field. Rendered at half engine resolution and LINEAR-upscaled (the mandelbulb perf discipline). With nothing patched it still renders a live procedural sky + rippling water, so it doubles as a standalone generative source. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). The pure physics (Fresnel / swell gradients / normal reconstruction / Poisson rain / orbit + free-look camera) is unit-tested in $lib/video/mirrorpool-core (the exact CPU mirror of the shader).

outputs

video_out video

inputs

pool video
scene video
wind_speed_cv cv
wind_dir_cv cv
rain_cv cv
brightness_cv cv
surface_mode_cv cv
orbit_az_cv cv
orbit_el_cv cv
orbit_dist_cv cv
look_yaw_cv cv
look_pitch_cv cv
zoom_cv cv

params

wind_speed 0..1
wind_dir ?..?
rain 0..1
brightness 0..2
surface_mode 0..1
orbit_az ?..?
orbit_el -1.45..1.45
orbit_dist 0.4..5
look_yaw ?..?
look_pitch -1.45..1.45
zoom 0..1
freeze 0..1

example js

spawn('mirrorpool', 'x');
set('x', 'wind_speed', 0);
patch('x.video_out', 'x.pool');

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 (leaky-integrated white: flat below a ~77 Hz corner at 48 kHz, -6 dB/oct above it). All outputs share a single LEVEL knob, which is one multiplier and not one loudness — brown leaves 7.1 dB and pink 12.3 dB below white. 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, with Numpad+ / Numpad- bound to OCTAVE UP / OCTAVE DOWN. All fourteen bindings are REMAPPABLE to any physical key — left-click a key cap on the faceplate (or right-click for the Remap / Reset menu) and press the key you want — and the map is saved with the patch, per node. Octave 0-8 (named c0..c8 by the note the first key plays) also moves from the faceplate. CV inputs: clock (rising-edge external clock — internal BPM ignored while patched) + layer (unipolar 0..1 CV selecting the active layer, otherwise the activeLayer param wins). CV outputs: l1_pitch / l1_gate ... l4_pitch / l4_gate so a patch can route each layer to its own downstream synth — basically a 4-track sequencer — plus a POLY bus carrying the active layer's voices for a poly-aware voice, NINE outputs in total. When this module exists in the rack its keyboard listener captures whatever event.codes its keymap binds and preventDefaults them, so other modules never see those keys; text fields and a focused DOOM card are excluded. The listener lives in the module itself rather than on any card, so it works with no UI open.

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 ?..?
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
freeze 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');

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');

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
start_cv cv
end_cv cv
audio_l_in audio
audio_r_in audio

params

rate ?..?
mode 0..1
start ?..?
end ?..?
poly 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');

six strum sixstrum

SIX STRUM — a 6-string guitar/bass/harp INSTRUMENT: six of our KARPLUS extended-Karplus-Strong string voices side by side, each behind its own amplitude ADSR, summed to MONO through a tuning-matched resonant BODY. Three ways to play it, all into one engine: STRUM by hand via six edge-trigger inputs NORMALLED low→high (patch only strum #1 to barre all six with one gate; patch #1 and #4 for two independent strum groups; STRUM SPREAD + DIR set the roll speed and down/up/alternate direction); play polyphonically from the POLY input (the 16-lane polyPitchGate cable — lanes 1–6 → strings 1–6, note-on plucks, note-off releases); or feed one root to the mono CHORD pitch-CV input and it voices a real guitar chord across the strings (each string takes the lowest chord-tone at/above its open pitch; the CHORD selector picks maj/min/dom7/maj7/min7/sus4/power5/octaves). Six MUTE gates model a finger laid loosely on a string — while high that string goes dead and near-unpitched (a palm-mute thunk; MUTE depth sets how dead), gate all six to choke the chord. GUITAR/BASS/HARP are NOT hidden presets: they are knob states of this ONE engine — TUNING (open-string set: guitar EADGBE / a low six-string bass / a diatonic harp), REGISTER (octave), RING (string sustain, calibrated to real plucked-string decay research — ~2.5 s guitar, long dark bass, very long harp), MATERIAL (nylon↔steel), PICK POS/TONE/GRAIN (where + how hard it is plucked), STIFF (inharmonicity toward wound/metal), plus SPREAD (per-string detune + always-distinct excitation seeds so a barre chord choruses instead of phase-combing) and BODY (the box resonance). Per-string ADSR: fast ATTACK, SUSTAIN held at 1 so the string's own physical ring IS the sustain, RELEASE bites on note-off / mute. ACCENT is a shared per-hit velocity CV (louder + brighter), plus a per-knob CV input on the voice + strum controls (tone_cv/grain_cv/spread_cv/body_cv sweep PICK TONE/GRAIN, SPREAD, BODY full-range around the knob; strum_cv sweeps the STRUM roll; the DISCRETE dir_cv/chord_cv quantize a −1..+1 CV across the DIR 0..2 and CHORD 0..7 selector indices). Mono out; no per-voice controls beyond the shared panel. Card: a STRUM audition button barres all six strings; the rear PatchPanel groups the inputs per string (strum + mute) plus POLY / CHORD / ACCENT and the PICK · STRUM CV modulators.

outputs

out audio

inputs

poly polyPitchGate
chord pitch
strum1 gate
strum2 gate
strum3 gate
strum4 gate
strum5 gate
strum6 gate
mute1 gate
mute2 gate
mute3 gate
mute4 gate
mute5 gate
mute6 gate
accent cv
tone_cv cv
grain_cv cv
spread_cv cv
body_cv cv
strum_cv cv
dir_cv cv
chord_cv cv

params

register -24..24st
ring 0.1..10s
material 0..1
pickPos 0.02..0.5
stiffness 0..1
pickTone 0..1
pickGrain 0.1..4
attack 0.0005..5s
envDecay 0.001..5s
sustain 0..1
release 0.001..5s
muteDepth 0..1
strumSpread 0..1
strumDir 0..2
spread 0..1
body 0..1
level -24..12dB
tuning 0..2
quality 0..7

example js

spawn('sixstrum', 'x');
set('x', 'register', 0);
patch('x.out', 'x.poly');

snare drum snaredrum

Deep, flexible stereo SNARE VOICE with a polyphonic two-hand DRUMROLL — the mate to KICK DRUM (own-code). Four decoupled acoustic layers the way a real snare works: a HEAD modal bank at inharmonic Bessel-zero ratios (1.0/1.03/1.593/2.135 — the pitchless membrane "thunk", self-ringing Chamberlin resonators struck by an impulse, with a downward pitch-drop at the strike), band-passed noise BODY around the head (TONE crossfades HEAD↔BODY), the SNARE-WIRE buzz — the defining sizzle — as bright HP-tunable noise on a SHARED re-excitable bed that breathes with the rectified head displacement AND rings out between strokes, and a short CRACK stick-contact transient. TWO strike inputs into one synth: trigger_in fires ONE hit per rising edge; gate_in runs the drumroll WHILE high. The roll is genuinely POLYPHONIC — two alternating hands 180° interleaved, each stroke (and each buzz sub-stroke) allocating its own voice from a 10-voice lowest-energy-steal pool while the shared wire bed sustains continuity, so overlapping decaying tails SUPERPOSE into a continuous roll (NOT a pulsed one-shot retrigger). ROLL SPEED sets 4–24 strokes/hand (+ roll_speed_cv at 1V/oct), BOUNCE morphs single-stroke → double/open → dense multi-bounce buzz/press roll (a coefficient-of-restitution bounce train, ≤6 sub-strokes, more as the hands slow), HUMANIZE adds seeded (deterministic) timing/velocity/detune jitter, and a hard per-second allocation budget routes excess buzz density into bed re-excitation only. The summed pool + bed run ONE shared bus: an oversampled DRIVE with a single HARD character switch (clean-warm tanh @2× vs aggressive wavefold+asym @4×), a 20 Hz DC block, and a per-channel true-peak CEILING soft-clip. Stereo: SPREAD pans the two hands (constant-power) + detunes them, WIDTH decorrelates only the bright wire sizzle; head/body stay centered so width=0 AND spread=0 → L==R exactly (mono-safe fold-down). Inputs: trigger_in (edge-trigger STRIKE), gate_in (edge-gate DRUMROLL), roll_speed_cv, accent_in (per-hit velocity + drive/level macro, latched at each strike), pitch_cv (1V/oct whole-voice transpose), choke_in (level-sensitive hand-on-head mute), PLUS a per-control CV input for each of the 21 remaining voice knobs (tune_cv … level_cv — each ±1 sweeps its param full-range around the live knob, cvScale matched to the knob curve), alongside the existing roll_speed_cv. Level −24..+12 dB, guarded by the ceiling. Wide 3u banded card: HEAD·BODY·WIRE / CRACK·ROLL·DRIVE / STEREO·OUT. Ships as a clean, punchy snare; hold a long gate for a continuous two-hand roll.

outputs

audio_l audio
audio_r audio

inputs

trigger_in gate
gate_in gate
roll_speed_cv cv
accent_in cv
pitch_cv cv
choke_in gate
tune_cv cv
head_decay_cv cv
damping_cv cv
damp_cv cv
pitch_amt_cv cv
pitch_time_cv cv
tone_cv cv
body_decay_cv cv
wire_cv cv
wire_tone_cv cv
wire_decay_cv cv
crack_cv cv
crack_tone_cv cv
bounce_cv cv
humanize_cv cv
drive_cv cv
hard_cv cv
ceiling_cv cv
spread_cv cv
width_cv cv
level_cv cv

params

tune 90..400Hz
tone 0..1
damping 0..1
head_decay 30..600ms
body_decay 20..300ms
pitch_amt 0..12st
pitch_time 3..80ms
wire 0..1
wire_tone 1500..9000Hz
wire_decay 40..700ms
crack 0..1
crack_tone 800..7000Hz
damp 0..1
roll_speed 0..1
bounce 0..1
humanize 0..1
spread 0..1
drive 0..1
hard 0..1
ceiling 0..1
width 0..1
level -24..12dB

example js

spawn('snaredrum', 'x');
set('x', 'tune', 180);
patch('x.audio_l', 'x.trigger_in');

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');

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');

tidy vco tidyVco

TIDY VCO — flagship virtual-analog SUBTRACTIVE SYNTH VOICE: two polyBLEP oscillators with a continuous saw↔pulse SHAPE morph per osc, shared PW + audio-rate PWM CV, OSC2 octave switch + cents detune, and a −1-octave sub square, into an ALL-NEW nonlinear zero-delay-feedback DIODE LADDER filter (EMS VCS3 / TB-303 lineage — bidirectionally-coupled stages, soft warm knee into 24 dB/oct, feedback squelch limiter for a bounded near-sine self-oscillation, CUTOFF calibrated to the resonant pitch within 3 cents so keytracked self-osc plays in tune, DRIVE tanh saturation at 2× oversampling, part-compensated squelch bass dip). Two RC-curve "punch" ADSRs (CEM3310-style exponential segments, overshoot-target convex attack, analog resume-from-level retrigger): a filter EG with bipolar ±4-octave ENV amount + keytracking, and an amp EG into an OTA-flavored soft-knee VCA whose tanh bias blooms gentle even harmonics with level. 5-voice POLY on the polyPitchGate chord bus (lane i → voice i, release tails hold their pitch) AND a mono pitch/gate pair driving a REAL 2-voice unison (±7¢·WIDTH drift panned to opposite sides — true stereo beating); WIDTH also fans the poly voices across the stereo field (root anchored center). Stereo out_l/out_r pair (auto-wires R when L is patched), HOLD pad for droning the voice from the card, and a CV jack for EVERY control (27 inputs): the six original CVs — cutoff (4 oct/V, audio-rate), res, pwm (audio-rate), drive, fold (audio-rate), sym (audio-rate) — PLUS a GLOBAL block-rate per-knob CV for each remaining control: shape1/shape2/mix/sub/fsus/sus/track/width (0..1 full-swing), detune (±50¢), oct2 (discrete ±1 step/V), env (±4-oct bipolar), the six EG times (4 oct/V), and level (±18 dB/V). Every law is scaled in the shared core (lib/tidy-vco-dsp.ts) so cv = 0 is a byte-exact no-op. The rear patch panel groups its jacks into OSC·WAVEFOLD·DIODE FILTER·FILTER EG·AMP EG·OUT·POLY/OUT sections mirroring the card headers.

outputs

out_l audio
out_r audio

inputs

poly polyPitchGate
pitch cv
gate gate
cutoff_cv cv
res_cv cv
pwm_cv cv
drive_cv cv
fold_cv cv
sym_cv cv
shape1_cv cv
shape2_cv cv
detune_cv cv
oct2_cv cv
mix_cv cv
sub_cv cv
env_cv cv
track_cv cv
fatk_cv cv
fdec_cv cv
fsus_cv cv
frel_cv cv
atk_cv cv
dec_cv cv
sus_cv cv
rel_cv cv
width_cv cv
level_cv cv

params

shape1 0..1
shape2 0..1
pw 0.05..0.5
detune -50..50¢
oct2 -1..1
mix 0..1
sub 0..1
fold 0..1
sym -1..1
cutoff 40..14000Hz
res 0..1
drive 0..1
env -1..1
track 0..1
fatk 0.0005..5s
fdec 0.001..5s
fsus 0..1
frel 0.001..5s
atk 0.0005..5s
dec 0.001..5s
sus 0..1
rel 0.001..5s
width 0..1
level -24..12dB
hold 0..1

example js

spawn('tidyVco', 'x');
set('x', 'shape1', 0);
patch('x.out_l', 'x.poly');

tom drum tomtom

Analog-modeled TOM DRUM voice — the third member of the drum family (KICK DRUM / SNARE DRUM), at deliberately CURATED complexity: one synthesis engine, seven voice knobs + level, spanning the classic analog tom lineage in one continuous space (808-woody bridged-T ring, 909-punchy swept osc + overtone, Simmons SDS-V "piuuu" dive-bomb, deep floor tom). DSP (own-code, packages/dsp/src/lib/tomtom-dsp.ts): a MEMBRANE fundamental (Tune 60–400 Hz) plus the inharmonic 1.593× Bessel second mode (TONE tilts fundamental ↔ overtone, with its own faster decay) riding ONE exponential pitch-BEND envelope (Bend 0–24 st depth — 0 = stable pitch, 24 = a two-octave zap; B Time 10–300 ms), a band-passed BREATH noise layer tracking ~2.5× the settled pitch (NOISE balances membrane ↔ breath, the SDS-V tone/noise mix law — 808 breath at low settings, full Simmons noise hit at the top), a 2×-oversampled warm-tanh DRIVE, 20 Hz DC block, dB LEVEL, and a true-peak tanh bound (|out| < 1 always). DECAY (40–1500 ms) is FREQUENCY-COMPENSATED: the −60 dB ring time is set in ms regardless of Tune, so a 60 Hz floor tom and a 400 Hz timbale ring equally long at the same knob. Inputs: trigger_in (edge-trigger STRIKE — phases reset, envelopes fire), accent_in (per-hit 0..1 CV latched at the strike edge: up to +80 % velocity AND +50 % bend depth, like a harder stick), pitch_cv (1V/oct whole-voice transpose incl. the breath band), bend_cv (±24 st/V into Bend — full-swing), decay_cv (2 oct of decay TIME per volt), tone_cv / noise_cv (sum into the balances). A per-knob CV now covers EVERY continuous control: tune_cv (2 oct/V on the TUNE knob — distinct from the whole-voice pitch_cv), bend_time_cv (2 oct of sweep-settle time/V), drive_cv (sums into DRIVE), and level_cv (±18 dB/V — the full 36 dB range centered on the knob). Each law is scaled in the shared core so cv = 0 is a perfect no-op. Output: ONE mono audio_out. Card: compact MEMBRANE·COLOR·OUT fader band + a press-to-fire STRIKE pad (the `strike` param, OR-ed with trigger_in in the worklet — one hit per press edge); the rear patch panel groups its jacks into MEMBRANE·COLOR·OUT·TRIG/OUT sections mirroring the card headers. Control set modeled on the Vermona DRM1 tom channel (tune / bend / decay / noise / drive).

outputs

audio_out audio

inputs

trigger_in gate
accent_in cv
pitch_cv cv
bend_cv cv
decay_cv cv
tone_cv cv
noise_cv cv
tune_cv cv
bend_time_cv cv
drive_cv cv
level_cv cv

params

tune 60..400Hz
bend_amt 0..24st
bend_time 10..300ms
decay 40..1500ms
tone 0..1
noise 0..1
drive 0..1
level -24..12dB
strike 0..1

example js

spawn('tomtom', 'x');
set('x', 'tune', 110);
patch('x.audio_out', 'x.trigger_in');

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), enumerated through the dynamic asset-provider seam (bundled + session-registered runtime assets); GLSL + OBJs are fetched lazily on selection (never JS-bundled) and cached. IMAGE = a synced still picture (bytes ride the Y.Doc); VIDEO = a local-file / webcam / patched-feed (inA-inB) / layer-input-tap texture, rounding out the seven layer kinds. RANDOMIZE: the RANDOM button (preset row) rolls a complete curated random patch from a seeded pure engine — it picks among hand-designed structural ARCHETYPE families (weighted, with anti-repeat across consecutive presses), draws content through the asset-provider seam, rolls scalars from designer-tuned ranges (never uniform noise), and INCORPORATES whatever is patched in: a feed on inA/inB becomes a live, load-bearing video layer in every roll and every patched cv1..cv6 port gets a route to a param that exists in the result; rack cables are never created, moved or severed. Rolls RESTRUCTURE the combine graph itself (branch-and-merge diamonds, mid-chain transforms, feedback taps — not just new content in a fixed ladder). LOCKS: a padlock toggle on each layer tab and a Lock item in each op node's right-click menu mark elements IMMUNE from randomize — a locked layer is byte-identical across rolls at its index, a locked node survives with its params, position and upstream feeds (which implicitly locks the source layers it consumes), and existing cv routes onto locked targets are preserved; lock flags ride the locked objects in node.data (synced, saved, exported). Each roll applies atomically in ONE Yjs transaction (one Cmd-Z undoes one roll) and a REVERT button restores the patch as it stood before the session's first roll — honoring locks exactly like a roll does (locked parts keep their current state). 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.

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 on the MAIN thread (#1811 — the render worker has no cross-thread input textures for vin1..vin4, its return protocol carries one picture per node so vout2 could not be served, and the card polls read('gateState') every frame). 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');

videocube videocube

VIDEOCUBE — the VIDEO version of the audio CUBE oscillator. It ingests THREE 60-frame video rings — A (FLOOR), B (WALL/connector), C (CEILING) — each generated LIVE from a connected video input or loaded from a .frametable.png atlas, and combines them exactly the way audio CUBE combines its three wavetables: an OCCUPANCY-WEIGHTED trilinear morph. For every output pixel it reads a colour from each ring, derives an occupancy position from the WALL luma, and blends the three by the SAME cube-dsp occ weights — MORPH cross-fades A↔C through B, CONNECT (+ CONNECT STRENGTH) reshapes/swells the interior binding, CRUSH posterizes colour depth, SPACE CRUSH mosaics the sampling grid, SPACE DIFFUSE smears the coords, MATERIAL switches soft-blend↔hard mosaic and WRAP mirror-folds — so video_out is a recognizable MORPHED IMAGE of the sources. It ALSO emits AUDIO: the same three rings are reduced to luma heightfields and scanned by the IDENTICAL cube-dsp surface-height slice the audio CUBE plays, so audio_out is a mono wavetable-oscillator drone whose timbre is driven by the SAME knobs (MORPH/CONNECT/CRUSH/SPACE/slice Y·ROT/WRAP/MATERIAL) — the picture and the sound move through one shared field structure. TUNE/FINE set pitch, LEVEL the gain, FOLD a west-coast wavefolder on the audio (audio-only). A global READER (SMOOTH/MORPH/CHAOS) reads each ring's 60-frame history, FREEZE holds the live rings and LIVE forces the real-time read. Beyond video_out + audio_out it exposes SIX dedicated slice-visualizer video jacks — SCOPE (the 256-sample surface-height wave the audio plays), SLICE (the 2-D cutting-plane cross-section), DEPTH (the intersection-depth heightmap, bright=deep/loud), and a SMOOTH/MORPH/CHAOS triptych (the cross-section forced through each reader treatment) — each a different readout of the SAME field/slice, each PER-PORT gated so an unpatched jack costs ZERO GPU, and the SLICE VIEW toggle (TEXTURED/XRAY/WEIGHTS) recolours slice+triptych. Rendered at half engine resolution with a renderer-gated tap count (the FrameTable budget ×3); the audio slice is GPU-reduced + recomputed off the audio thread on a throttle. v1 ships MONO-DRONE-first (poly/ADSR = follow-up). The occupancy combine + colour blend + luma reduction are a 1:1 CPU mirror unit-tested in $lib/video/videocube-core, reusing the audio-CUBE field math (cube-dsp) wholesale. All ports live on the yellow drill-down PATCH PANEL. Look-affecting new WebGL shader — held for owner visual preview.

outputs

video_out video
audio_out audio
scope_out video
slice_out video
depth_out video
smooth_out video
morph_out video
chaos_out video

inputs

video_a video
video_b video
video_c video
morph_cv cv
connect_cv cv
connect_strength_cv cv
crush_cv cv
space_crush_cv cv
space_diffuse_cv cv
slice_y_cv cv
slice_rx_cv cv
slice_ry_cv cv
slice_rz_cv cv
view_x_cv cv
view_y_cv cv
fold_cv cv
spread_cv cv
scan_cv cv
tune_cv cv
chroma_depth_cv cv
motion_cv cv
hue_mode_cv 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
scan 0..1
chroma_depth 0..1
motion 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
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
wrap 0..1
material 0..1
screen_on 0..1
reader_mode 0..2
freeze 0..1
live 0..1
slice_view 0..2
hue_mode 0..1

example js

spawn('videocube', 'x');
set('x', 'tune', 0);
patch('x.video_out', 'x.video_a');

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). CROP: a second video output `crop` re-samples a boxed sub-region of the `video` output, scaled up to the full output resolution (a live zoom). Press "add crop" on the card to overlay a resizable, aspect-locked rectangle (thin red border, dimmed outside) on the preview — drag inside to move, drag a corner to resize; the box always keeps the current OUTPUT aspect (16:9 or 4:3) and re-fits when the aspect flips. The rect is stored normalized on the node (x,y,w in 0..1, height derived from the aspect; synced + undoable; ONE per node, unaffected by slot switches). Until a crop is added — or after "remove crop" — the `crop` output passes the full frame through unchanged, so it never goes black and always streams. Reusable crop core ($lib/video/crop-core + crop-render + ui/video/CropOverlay) so other video modules can adopt the same Crop output later.

outputs

video video
crop 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');

vst instrument vstInstrument

Plays one of YOUR installed instrument plugins (AU builds of your VSTs) as a first-class rack voice via the vst-bridge native helper — poly/gate/vel CV converted to sample-accurate MIDI in the worklet, plugin audio returned into the lane, native editor window on your machine.

outputs

out_l audio
out_r audio

inputs

poly polyPitchGate
pitch cv
gate gate
vel cv

example js

spawn('vstInstrument', 'x');
patch('x.out_l', 'x.poly');

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 widens the stereo image by reading NEIGHBOURING frames into progressively harder-panned taps (a wavetable spread, not a pitch detune — one shared phase), 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=0 (the default) is pure ADSR (silent between notes), 0.5 floors at 0.5 and rises to 1.0 at the env peak, base=1 means the env does nothing (full gain while active). It applies ONLY to gated voices: the raw-VCO case (nothing patched) runs at unity independently of BASE, so the legacy continuous drone is byte-identical at every setting. 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. One roll of the dice per woggle tick, five correlated views of it. Internal "woggle clock" emits triggers at the RATE knob (0.1-50 Hz, log); outputs are SMOOTH (slewed random), STEPPED (sample-and-held), CLOCK (woggle gate), BURST (probabilistic clusters of 3-7 triggers) and RING (smooth × sub-osc ring-mod). RING is typed audio so it reaches the audio path, but its carrier is a QUARTER of the woggle rate and therefore SUB-AUDIO everywhere on the dial (0.025 Hz at the bottom, 0.30 Hz at spawn, 12.5 Hz flat out) — a slow shuddering product to modulate with, not a tone. 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

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

example js

spawn('cartesian', 'x');
set('x', 'octave', 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 a companion to a monome grid 128 controller AND to a one- or two-unit Novation Launchpad Mini Mk3 (both browser-native — WebSerial for the grid, WebMIDI for the Launchpad, no native helper — see lib/control/monome + lib/control/launchpad) 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). LAUNCHPAD (Novation Launchpad Mini Mk3, one or two units over WebMIDI): the same clip matrix + note editor, plus a command deck exposing per-lane MONO / MUTE / clock-RATE / SWING / per-clip CLIP-DIV, a RESET pad, tempo nudge, and a KEYS isomorphic keyboard for live note entry + clip-record. Its scene-launch column is a SCROLLING window (shift-layer amber UP/DOWN) reaching up to 64 scene slots per lane — FIXED stride-64 clip storage means clips can live in scenes past the first 8 (older saves migrate once on load) — and a TYPED clipboard COPY/PASTEs whole SCENES (all 8 lanes at a slot, full-replace) as well as single clips: scene→scene and clip→clip apply, the cross-type pastes are no-ops with dimmed targets, and a scene paste is one undo step. SCENE REPEATS (Deluge-style): scenes loop forever by default (repeats = infinite), but HOLD GRID + HOLD a scene-launch button (position-relative through the scene scroll) to open the orange REPEAT-COUNT view — tap pad k to set k repeats (1–63; pad 64 = infinite; pads 1..N stay lit for count N, all 64 = infinite) — and after N passes of the scene's longest clip (frozen at launch) the player auto-launches the next content scene down through the normal quantized launch path, skipping empty rows and keeping the last content scene looping; manual launches always win (relaunching resets the count, an individual clip launch cancels it), muting never voids it, whole-scene COPY/PASTE carries the count with the scene, and the card shows a read-only "×N" flair (live "p/N" while counting) at the right of each scene row. PER-CLIP AUTOMATION (Deluge-like): right-click a MODULE'S CARD → "Assign to automation lane" (1–8; MODULE-level — one lane per module, re-assigning moves it; the assigned card gets a thin border in the lane's colour and the AUTO block shows per-lane assigned-module counts), then arm THAT LANE's teal ◉ (per-lane arm, under its channel column next to RATE; on a Launchpad, SHIFT+the lane's top-row button, lane 8 = double-tap SHIFT) — while a lane is armed and its note clip plays, TOUCHING any control of a module assigned to it (screen / MIDI / Electra — NEVER CV: automation records your hands, a CV cable is performance signal and is never captured) records by CONTINUOUS OVERDUB into the PLAYING clip's OWN automation (punch-in at that clip's next loop start; each clip in a lane carries its own envelopes, stored beside the notes so note edits never clobber them; only moved params are written, max 16 recorded controls per clip; touching an unassigned module's control records nothing — assignment is explicit; per-lane single-writer, so two collaborators can record two lanes at once). Launching a clip launches its envelopes with it (linked to the clip's length); the ENVELOPE BELONGS TO THE CLIP — copy/paste + scene-duplicate carry it (PASTE-REV time-reverses it), pasting over a clip replaces it, clearing/emptying a clip clears it, carriers show a teal dot on their cell, and if two lanes' clips automate the same control exactly ONE drives it (its module's assigned lane wins, else lowest). Deletion is explicit + undoable: right-click → "Clear recorded automation" (per control; distinct from the module menu's "Remove automation assignment", which only stops future recording) and the editor's CLR AUTO (per clip). Playback is transient on every peer and never rewrites the saved patch; grabbing an automated control suspends its automation until you physically release it, and the on-card override dot re-enables all. Two current limits: the on-card grid shows only the first 8 scenes (card scene-scroll is a follow-up), and the arranger records session launches of scenes 1–8 (scene 9+ arranger recording is a follow-up). 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
reset gate

params

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

example js

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

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), which is a RATE CEILING of 1000÷ms — 12.5 Hz at the shipped 80 ms. Three measured facts the dials cannot print, and the faceplate does: the three feature CVs REST at −1.00 (bipolar) with nothing patched, not at 0; GAIN reaches only LOUD, because ZCR and crest are both scale-invariant; and LOUD PINS at full scale above −6.02 dBFS RMS at unity trim. 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 legacy card shows live LOUD/BRIGHT/PUNCH meters + an ONSET blink (display only — never writes the live Y.Doc); the FACEPLATE replaces them with the three drawn maps, because the snapshot behind those bars is the UNSMOOTHED, always-unipolar target and disagrees with the jacks it names. 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');

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. LANES, each edited on the same 7×16 grid and picked from a nav row: TRG (does the step fire?), NTE (the Y axis picks a pitch DEGREE within the active scale), OCT (per-step +0..+5 octave offset), DUR (per-step gate length as a fraction of the step), PRB (per-step probability, Kria's 4-level fader), GLD (per-step pitch slew) and RAT (per-step ratchet, 1-4 sub-hits). A lane with fewer values than the grid has rows leaves the surplus rows visibly INERT rather than taking clicks it cannot display. Per-track: LOOP (start + length, wrapping), TIME (clock DIVISION — advance once every N base ticks), DIRECTION (forward / reverse / pingpong / drunk / random) and MUTE. 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. SURFACE: a TRACK selector (1-4), a LANE selector (TRG/NTE/OCT/DUR/PRB/GLD/RAT + PAT), a 16-step editor for the selected track+lane (with a clock-locked playhead column), a 16-slot pattern strip (tap empty = create + activate, tap another = cue a quantized switch), the per-track LOOP / TIME / DIRECTION / MUTE controls and the pattern-level SCALE + ROOT; a GRID button connects + binds a monome grid (capability-gated, Chromium) so the same edits + cues happen on hardware with live varibright LED feedback. Under the workflow shell the same instrument is a FACEPLATE: the step grid is the dock hero picture and everything per-track is a band cell, reading and writing through the same helpers the card calls. 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 patterns lane by lane per track from the card, the faceplate 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');

nine lives ninelives

LFO with NINE CV outputs on a geometric 1/3 rate ladder + a reset trigger. out1 runs at the Rate knob; 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). At the shipped Rate of 1 Hz that is 1.00 s per cycle on out1 and 1.8 HOURS on out9, so the bottom of the ladder reads as DC rather than as modulation — that is the module working, not a dead jack. All nine taps share ONE Waveform morph (sine -> saw -> square) and are fixed full-scale +/-1: there is no depth control, so attenuate downstream. out1 is bit-identical to a normal LFO only at that LFO default Depth of 0.5, where its own Depth*2 scaling reaches unity. 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');

score score

Sheet-music sequencer. A treble-clef staff of 16 bars per page, up to 4 pages, in 4/4 — 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');

timelorde timelorde

Singleton master clock. Internal or external BPM, twelve clock-divider outputs. Its two transport controls name their own states — RUNNING / STOPPED beside GATES LIVE / MUTED — because a stopped clock and a muted one are silent in exactly the same way at all thirteen jacks, so seeing both is the only way to tell which one is silencing your rack. A TAP pad sets the 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 does nothing while an external clock is patched into CLOCK IN — the measured external tempo owns the BPM then, and your own setting is put aside and handed back when you pull the cable out. The big display shows 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 it becomes a live monitor while VIDEO OUT passes the feed through (TIMELORDE can sit inline in a video chain). A SCREEN switch hides the display to reclaim its space — the picture keeps being made either way, so VIDEO OUT never goes dark.

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..11
muteOutputs 0..1
running 0..1
wizardOn 0..1

example js

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

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 VCF — three 2-pole (12 dB/oct) Faust sections running in parallel with a MODE switch picking one: 0 = LOWPASS, 1 = HIGHPASS, 2 = BANDPASS (that order, not LP/BP/HP). CUTOFF 20 Hz-20 kHz log; RES 0..0.99 mapped to Q = res x 20 + 0.7, so maximum resonance peaks ~26 dB over a unity passband — it rings hard but never self-oscillates. Two CV jacks, each with its own attenuverter knob: cutoff CV is exponential (+/-1 = +/-5 octaves around the knob at full depth, clamped to the 20 Hz-20 kHz window), res CV is additive on the 0..0.99 scale. Both CV values pass the DSP's ~7 Hz one-pole smoother, so this is an envelope/LFO modulation input, not an audio-rate FM input.

outputs

audio audio

inputs

audio audio
cutoff cv
res cv

params

cutoff 20..20000Hz
resonance 0..0.99
mode 0..2
cutoff_cv_amt -1..1
res_cv_amt -1..1

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

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-60). The fed-back frame is delayed (DELAY, 0-1000ms 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. A FLICKER control (OFF / 6 / 24 / 50 / 60 / 120 Hz) models the display's pulsed emission as the virtual camera actually captures it, and then models what the CAMERA does to it: the emission rate beats against the camera's 60 fps sampling, so the per-frame loop gain oscillates around unity instead of being constant, and light can build up over several frames and then fade away rather than pinning at white — with a rolling-shutter band crawling down the frame at the beat rate. The captured light then passes through the sensor's multi-frame charge storage (a low-pass on the BEAT, so fast beats become soft shimmer while slow ones keep their full swing) and its saturating shoulder (so the modulation stops acting where the image is already hot and reads as contour shimmer rather than a full-field flash). That is what makes the fast positions breathe instead of strobe. 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 carries NO in-rack picture. It used to show a 320×240 display, and that display was the single biggest consumer of the card's width and height; taking it out bought the module a narrower rack tier and taller faders, which is the better trade for a panel with this many controls. Feedback is still steered by watching it, so the output is one click away rather than always-on: the ⛶ OUTPUT button opens Full Frame (the card itself becomes a video panel in the rack), Full Screen, and Present-on-another-display, all of which grow the SAME surface — the button is now the only entry point, since there is no picture to right-click. For an arbitrarily-sized monitor, patch OUT into VIDEO OUT. The controls sit in two rows. Down the left of the first row are the discrete switches — MIRROR X / MIRROR Y, SHAPE and PURE GEO — with TV MODE, its fill/band readout and the OUTPUT button to their right and the six-position FLICKER switch beneath them; beside and below them run the labelled fader banks: LOOP (Mix/FB/Delay), COLOUR (Luma/Chroma/R/G/B), KEY (Lighten/Darken), GEOMETRY (Zoom/Rotate/Off X/Off Y/Pixelate), TV SCREEN (Room/Border/Phosphor/Drive — BORDER is the bezel, i.e. the screen frame's thickness) and VIRTUAL CAMERA, whose two 2-D pads steer the camera's TILT and POSITION with a DIST fader beside them. A control that does nothing in the current mode is DIMMED rather than hidden or disabled, so it stays draggable, resettable and MIDI-learnable and the card never changes height with the mode: the TV SCREEN bank dims while TV MODE is OFF (its title becomes a button that turns TV MODE on), and PURE GEO dims in PURE TV / CRITICAL, where SHAPE means only the screen's outline.

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
tv_gate cv
room cv
phosphor cv
drive cv
cam_tilt_x cv
cam_tilt_y cv
cam_pos_x cv
cam_pos_y cv
cam_dist cv
panic 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
flicker 0..?
tvMode 0..?
tvGate 0..1
room 0..1
bezel 0..1
phosphor 0..1
drive 0..1
camTiltX ?..?
camTiltY ?..?
camPosX ?..?
camPosY ?..?
camDist 0..1
freeze 0..1
panicGate 0..1

example js

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

cellshade cellshade

Real cel-shader (toon) video PROCESSOR — the canonical live-video cel pipeline (Winnemöller's Real-Time Video Abstraction) as a 4-pass chain. Takes a video input and emits a cel-shaded version: (1) an edge-preserving SEPARABLE BILATERAL smoothing pass (SMOOTH, 0..1, default 0.35 — 0 is a true bypass: the passes are skipped entirely) flattens low-contrast texture/noise into the large flat regions that read as hand-painted while keeping strong contours crisp; (2) a SOFT LUMINANCE QUANTIZATION pass collapses the smoothed image's Rec. 601 luma into N flat tonal bands — BANDS is a 5-step DISCRETE knob mapping to {2, 3, 4 (default), 6, 8} bands (the param id stays the legacy `bits`, same 0..4 index range, so saved patches + CV cables load with zero migration) — with a smoothstep transition whose half-width SOFT (0..1, default 0.25) widens from hard-edged bands to a near-continuous ramp; reconstruction is the additive luma shift out = clamp(rgb + (Yq − Y)) (YCbCr Y-replacement), so CHROMA IS NEVER QUANTIZED — hue and saturation ride through and each band is a flat tonal step of consistent colour (a yellow stays yellow, a skin tone stays warm); (3) a Sobel INK pass (the exact EDGES algorithm — same Rec. 601 luma, normalisation, THRESHOLD gate and THICKNESS dilation — measured on the SMOOTHED image so sensor noise never inks) composites the salient contours as dark outline strokes scaled by INK (0..1, default 1: 0 = no lines, 1 = solid black). STATELESS per frame — the look tracks the live source with no feedback. THRESHOLD (0..1, default 0.2) gates which contours get inked; THICKNESS (1..8 px, default 2) dilates the strokes wider. All six params have matching CV inputs (port id == param id; BANDS uses a discrete cvScale so CV snaps to the 5 steps). IN takes RGB; OUT is video — patch a source (CAMERA / VIDEOBOX / SHAPES / a generator) → IN, OUT → OUTPUT or a video mixer; drop BANDS + raise INK for bold comic cels, raise SMOOTH for painterly abstraction, use SOFT to trade crisp band edges against shimmer-free gradients on live video. (The old 8/16-bit per-channel RGB retro posterize modes were dropped in the rebuild — that look is posterization, not cel, and belongs to the POSTERBOX module.)

outputs

out video

inputs

in video
threshold cv
thickness cv
bits cv
softness cv
smooth cv
ink cv

params

threshold 0..1
thickness 1..?px
bits 0..?
softness 0..1
smooth 0..1
ink 0..1

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

example js

spawn('charlottesEchos', 'x');
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 that is chromatically close to the chosen key colour with the matching background pixel. Per pixel it measures the DISTANCE IN THE CHROMA PLANE (full-swing Rec. 601 Cb/Cr) between the pixel and the key colour, normalized by the key's own chroma strength — the industry-standard keying metric — and builds an alpha via smoothstep over the thr/soft window (alpha 0 = show background, alpha 1 = keep foreground). A neutral gray always sits at exactly distance 1.0 from a saturated key, so shadows, highlights and low-saturation subject pixels survive the key without any special gating. Spill suppression then limits the key colour's dominant channel on the KEPT foreground (for a green key: green is pulled down toward max(red, blue)), removing green contamination from the subject itself — not just from the matte edge. Pick the key colour with the swatch (defaults to pure green), then tune thr: the default 0.5 keys real-world screen variation (shading, off-tint) while keeping subjects; lower it toward 0.15 to key only near-pure key pixels, raise soft to feather the matte edge, and raise spill to remove key-colour fringing from the subject. If no foreground is patched it just passes the background through. Note: an achromatic (black/white/gray) key colour has no chroma to measure against, so ALL neutral pixels key out together regardless of brightness — for keying off a black or white backdrop use lumakey instead.

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
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');

colour of magic colourofmagic

COLOUR OF MAGIC — a multi-colorspace video PROCESSOR. One video IN runs through FIVE parallel colorspace blocks — RGB, YDbDr (the SECAM luma+chroma broadcast space), HSV-or-HSL, YIQ (the NTSC composite space, its orange↔cyan flesh-tone I axis + green↔magenta Q axis), and YCbCr BT.601 STUDIO-SWING (the broadcast-legal 16–235 / 16–240 window whose ~1.16× decode expansion CRUSHES super-black/white like a proc-amp) — each block encoding the picture into that space, adjusting each component, then decoding back to RGB. Every block has, per channel: a BIAS knob (additive offset, identity at 0) that also sums CV patched into its cv input; a MONO OVERRIDE input that REPLACES that channel with an incoming grayscale/video stream (bias still adds on top, so a patched key can still be offset); and an OVER/CLAMP toggle — CLAMP clips out-of-range to 0..1 (a legal clip) while OVER wraps it around via fract() (the LZX chroma-wrap look where over-driven values fold back through the spectrum). Bipolar chroma rides a 0.5 pedestal (YDbDr Db/Dr, YIQ I/Q) or the authentic 128/255 = 0.502 pedestal (studio-swing Cb/Cr); HUE always wraps regardless of its toggle (which is advisory). The third block switches HSV↔HSL. TWENTY-TWO outputs run in parallel: pass (the untouched source); rgb / ydbdr / hsvhsl / yiq / ycc (each block colorized); and per-block grayscale channel taps — r / g / b / luma (RGB), ydb_y/db/dr (YDbDr), hsv_h/s/v (HSV·HSL), yiq_y/i/q (YIQ, its mono I tap a ready-made warmth/skin key), ycc_y/cb/cr (studio-swing). The RGB block also has a palette REPLACE mode: three colour-picker swatches remap the adjusted R/G/B channels to chosen output colours (a duotone/tritone recolour) before the rgb out — picking a swatch auto-enables REPLACE and the swatches default to a non-identity teal/orange/violet so it recolours immediately. Only the outputs you PATCH downstream (plus the one you PREVIEW) are rendered each frame, so the many taps stay cheap. With nothing patched all outputs are opaque black. All colorspace math is a 1:1 mirror of the pure, unit-tested $lib/video/colourofmagic-colorspace core. The card has a live preview (with a 22-way output selector), the five block columns of knobs + OVER/CLAMP pills, the HSV/HSL toggle, and the palette REPLACE swatches; all CV + mono-override jacks + the 22 outputs live in the sectioned yellow drill-down PATCH PANEL (IN / RGB / YDbDr / HSV-HSL / YIQ / YCbCr / OUT, no raw side jacks).

outputs

pass video
rgb video
ydbdr video
hsvhsl video
r mono-video
g mono-video
b mono-video
luma mono-video
ydb_y mono-video
ydb_db mono-video
ydb_dr mono-video
hsv_h mono-video
hsv_s mono-video
hsv_v mono-video
yiq video
yiq_y mono-video
yiq_i mono-video
yiq_q mono-video
ycc video
ycc_y mono-video
ycc_cb mono-video
ycc_cr mono-video

inputs

in video
rgb_r_cv cv
rgb_r_in mono-video
rgb_g_cv cv
rgb_g_in mono-video
rgb_b_cv cv
rgb_b_in mono-video
ydb_y_cv cv
ydb_y_in mono-video
ydb_db_cv cv
ydb_db_in mono-video
ydb_dr_cv cv
ydb_dr_in mono-video
hsv_h_cv cv
hsv_h_in mono-video
hsv_s_cv cv
hsv_s_in mono-video
hsv_v_cv cv
hsv_v_in mono-video
yiq_y_cv cv
yiq_y_in mono-video
yiq_i_cv cv
yiq_i_in mono-video
yiq_q_cv cv
yiq_q_in mono-video
ycc_y_cv cv
ycc_y_in mono-video
ycc_cb_cv cv
ycc_cb_in mono-video
ycc_cr_cv cv
ycc_cr_in mono-video

params

bias_r -1..1
bias_g -1..1
bias_b -1..1
bias_y -1..1
bias_db -1..1
bias_dr -1..1
bias_h -180..180deg
bias_s -1..1
bias_v -1..1
bias_yiq_y -1..1
bias_yiq_i -1..1
bias_yiq_q -1..1
bias_ycc_y -1..1
bias_ycc_cb -1..1
bias_ycc_cr -1..1
over_r 0..1
over_g 0..1
over_b 0..1
over_y 0..1
over_db 0..1
over_dr 0..1
over_s 0..1
over_v 0..1
over_h 0..1
over_yiq_y 0..1
over_yiq_i 0..1
over_yiq_q 0..1
over_ycc_y 0..1
over_ycc_cb 0..1
over_ycc_cr 0..1
mode_hsl 0..1
replace 0..1
pal_r 0..0
pal_g 0..0
pal_b 0..0
preview 0..21
freeze 0..1

example js

spawn('colourofmagic', 'x');
set('x', 'bias_r', 0);
patch('x.pass', 'x.in');

delay delay

The primitive single-tap echo — one MONO audio jack in, one out, and the canonical time / feedback / mix trio, with no colour of its own. Built on Web Audio's native DelayNode plus a feedback gain loop (input → delay → feedback → output, crossfaded against dry), so it is the cheapest delay in the catalogue to instantiate — no worklet, no DSP thread. TIME ranges log from 1 ms (comb/flange) through slapback to 2 s (ambient washes); FEEDBACK is linear 0–0.95, hard-ceilinged below self-oscillation and deliberately NOT CV-able so the clamp is absolute; MIX is an equal-power dry/wet crossfade. The one CV jack is TIME, and it is audio-rate and unsmoothed: because the delay line reads at a fractional position, modulating it VARISPEEDS the buffer (the echoes Doppler-shift in pitch while the time moves — measured at ~498 Hz for a 1 kHz sine under a +0.5 s/s ramp), which is what makes it a chorus/flanger at small depths and a tape pitch-dive at large ones. No tempo sync, no clock input, no in-loop filtering or saturation, no stereo — COFEFVE is the full tape/BBD machine with all of those, CHARLOTTE'S ECHOS the destructive multi-head shimmer.

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');

frametable frametable

FRAMETABLE — a video WAVETABLE oscillator. It continuously records the last 60 rendered input frames into a GPU frame ring (a TEXTURE_2D_ARRAY, one layer per frame) and treats that 60-frame history like the single-cycle waves of a wavetable synth: MORPH scans a centre point through the table and SPREAD sets how wide a window around that centre each output pixel may draw from. For EVERY output pixel the shader draws exactly ONE source frame — a whole-pixel dither/mosaic, NEVER an alpha-average across frames — chosen probabilistically from a bell distribution over the window (centre frame most likely, periphery least). The frame index is picked in O(1) by an analytic inverse-CDF (one sqrt, one branch, one texture-array fetch — never a 60-frame loop). The per-pixel choice is fixed in SCREEN space by a static per-pixel threshold with NO time term, so a STILL input yields a stable image (no TV-static shimmer) even while the ring keeps refreshing, while MOVING content becomes a coherent, morph-scannable time-smear mosaic that scanning MORPH slides through like a soft crossfade. SPREAD 1 collapses to a single frame (a delta — crisp playback of one moment); wider SPREAD blends more of the history into the bell, centre frame still most likely. SHAPE morphs the bell from triangular (default, compact) to gaussian (smooth). SHIMMER (default 0 = fully static) animates the threshold along a golden-ratio sequence for a gentle living grain on moving content while the time-averaged distribution stays exactly the target bell. FREEZE (a toggle button, plus a freeze gate that holds the ring frozen while the gate is held high) stops the ring from advancing so you can scrub a held 60-frame window with MORPH/SPREAD; SAVE (a momentary button, also a rising edge on the SAVE trigger) snapshots the current 60-frame ring into an in-GPU slot for later recall (and to feed a future video Cube — the snapshot + live ring are readable through the handle). Beyond that in-GPU slot, FRAMETABLE saves + loads REAL FILES, mirroring the wavetable file workflow: SAVE FILE writes the whole 60-frame ring to a lossless .frametable.png sprite-sheet atlas (a fixed 10×6 = 60-tile contact sheet, no video codec) via the save-file picker (with a download fallback); LOAD reads a .frametable.png back into the ring, freezing it so the loaded table can be morphed/scanned. The multi-megabyte frame bytes persist PER-BROWSER in IndexedDB (never the Y.Doc — only a tiny file descriptor syncs), so a loaded/saved table survives a reload on the same machine. Rendered at half engine resolution (SwiftShader/CI budget); an unpatched input renders black. The selection math (triangular + gaussian inverse-CDF, ring wrap, head→layer mapping, freeze/save reducers) is a 1:1 CPU mirror unit-tested in $lib/video/frametable-core. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). Look-affecting new WebGL shader — held for owner visual preview.

outputs

video_out video

inputs

video_in video
morph_cv cv
spread_cv cv
shimmer_cv cv
weightShape_cv cv
waveFreqX_cv cv
waveAmtX_cv cv
waveShapeX_cv cv
waveFreqY_cv cv
waveAmtY_cv cv
waveShapeY_cv cv
freeze_gate gate
save_trig gate
chaos_gate gate
live_gate gate

params

mode 0..2
live 0..1
chaos 0..1
morph 0..1
spread 1..60
shimmer 0..1
weightShape 0..1
freeze 0..1
waveFreqX 0..8
waveAmtX 0..1
waveShapeX 0..1
waveFreqY 0..8
waveAmtY 0..1
waveShapeY 0..1
liveGate 0..1
chaosGate 0..1
freezeGate 0..1
saveTrig 0..1

example js

spawn('frametable', 'x');
set('x', 'mode', 0);
patch('x.video_out', 'x.video_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 image FREEZES, and the GATE jack then honours both readings of the gate cable at once. Send a TRIGGER at it and each rising edge updates EXACTLY ONE frame, after which it is still again. Hold the gate HIGH (level >= 0.5) and you get that same one-frame update at the edge, and then — once the level has STOOD high for about 75 ms — continuous live updating for as long as it stays high. That 75 ms is deliberate and is the shortest honest answer available: the patch bridge does not stream the gate waveform to a video module, it re-reports the level roughly every 25 ms, so for the first tick or two a 5 ms trigger and a gate that has just opened are literally the same bytes. Anything held shorter than the window is therefore classified as a TRIGGER and updates exactly one frame — including a gate DERIVED from a trigger by GATEMAIDEN, whose default width is 50 ms, so inserting GATEMAIDEN into the path does not change the frame count. In practice a square LFO below roughly 6.6 Hz plays while open and stutter-freezes the instant it closes (at 1 Hz about 44 percent of frames update, at 4 Hz about 26 percent); faster than that knee each cycle contributes only its one edge frame and the module reads as a strobe, which is the frame-rate-independent reading anyway. Short pulses cannot be missed or double-counted — the rising edge is detected as the gate value arrives rather than sampled once per rendered frame, and the one-shot is a latch a single frame consumes. 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. Third, PHOSPHOR DECAY: switch DECAY on and a held frame no longer just sits there — it fades exponentially to black over the DECAY TIME knob's 0.05 to 2 seconds, the way a CRT phosphor gives up once the beam stops refreshing it, and INVERT sends it to white instead. DECAY TIME reads as "gone by": at the time you dial in the frame has reached the target exactly and stays there, rather than the 37 percent a 1/e time constant would leave behind. It is only visible WHILE THE IMAGE IS FROZEN, which is not a limitation but what the effect IS — decay is the age of the held frame, so with GATE unpatched (live passthrough) or held open every frame is brand new and the switch legitimately does nothing. The fade is evaluated from elapsed TIME rather than accumulated per frame, so it takes the same real half-second whether the renderer is managing 8 frames a second or 240, and it is applied after the posterizer (a signal is quantized, then a display persists it) so it still fades smoothly even with all four QUANT knobs at max. 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; add DECAY for trailing strobe ghosts; 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
decay 0..1
decay_invert 0..1
decay_time ?..?s
gateLevel 0..1

example js

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

grains of vision grainsOfVision

GRAINS OF VISION — a granular VIDEO synthesizer. It shatters the incoming picture into a swarm of tiny windowed patches (grains) sampled from source A at jittered positions AND jittered moments in time (from a short frame-history ring, so grains have a real TEMPORAL axis — the novel part of granular VIDEO), re-scatters them into a new frame, then runs that through a FEEDBACK block and a video REVERB block on ONE fixed linear chain (video -> granular engine -> feedback -> reverb -> out) — NOT a node graph. The grain engine is a single fullscreen pass that is O(1) per pixel regardless of density: the frame is a jittered grid of cells (DENSITY = cells across), each cell hosts one hashed grain, and every pixel gathers its 3x3 cell neighbourhood, window-weights each grain and normalises — so density changes grain SIZE, not the cost. Knobs map the audio-granular vocabulary onto the image: SIZE (window radius), WINDOW (hard chip -> soft gaussian), SPRAY (position scatter of the grain + source-read; 0 reconstructs the picture faithfully, rising clouds it into abstraction), RATE (how far back in the frame history grains read — the pitch/rate analog), T-SPRAY (temporal scatter for a shimmering time-smear), ORIENT (per-grain rotation). The FEEDBACK block mixes the transformed previous OUTPUT back in (FB amount / decay / per-pass zoom + rotate that compound into tunnels and spirals); FB amount 0 (or FB Dry) is a transparent dry passthrough. The REVERB block is a true VIDEO reverb — the image analogue of an FDN/Schroeder tail: a decaying, spatially-diffused temporal accumulator (rev = blur(feedbackImg + decay*prevRev)), so each bright grain blooms outward (Rev Size = room size, Rev Diffuse = tap scatter) and lingers, fading over frames (Rev Decay = tail length), mixed dry/wet by Rev Mix; Rev Mix 0 (or Rev Dry) is a transparent dry passthrough (its blur passes skipped). Patch a second source into B and pick a COMPOSITE mode to have B modulate A grains region-by-region: density-map (B brightness thins/thickens grains), displace (B chroma warps where grains read from), size-map (B scales grain size), rate-map (B scrubs the per-region history time); with only A patched it runs mono-source (composite off). TWO video outputs: OUT (the full chain) and GRAINS (the raw granular scatter tap, pre-feedback/pre-reverb, resolved via read outputTexture:grains — a clean grains-only output to key/mix elsewhere, optional). Rendered at half engine resolution (SwiftShader/CI budget). Like every video processor an unpatched input renders black; the defaults are tuned so any patched source is immediately alive. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). The grain window / hash / temporal-blend / feedback-UV / reverb-accumulate / composite-mode math is a 1:1 CPU mirror unit-tested in $lib/video/modules/grainsOfVision.

outputs

out video
grains video

inputs

in_a video
in_b video
density cv
grain_size cv
spray cv
time_spray cv
rate cv
orient cv
window cv
feedback cv
fb_decay cv
fb_zoom cv
fb_rotate cv
rev_mix cv
rev_size cv
rev_decay cv
rev_diffuse cv
composite cv
comp_amount cv

params

density 2..48
grain_size 0.2..2.5
spray 0..1
time_spray 0..1
rate 0..1
orient 0..1
window 0..1
feedback 0..0.98
fb_decay 0..1
fb_zoom ?..?
fb_rotate ?..?
fb_dry 0..1
rev_mix 0..1
rev_size 0..1
rev_decay 0..0.99
rev_diffuse 0..1
rev_dry 0..1
composite 0..?
comp_amount 0..1
freeze 0..1

example js

spawn('grainsOfVision', 'x');
set('x', 'density', 0);
patch('x.out', 'x.in_a');

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; 16 = off), 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. Gamma uses the Levels-style INVERSE convention pow(luma, 1/gamma): values above 1 brighten midtones, below 1 darken them (this is the Photoshop-Levels convention, not display-gamma out = in^gamma). 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 transfer is a true identity — the picture passes through 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');

posterbox posterbox

POSTERBOX — retro PALETTE-CRUSH (posterizer) video PROCESSOR. Takes a video input and truncates every pixel to an authentic retro per-channel bit allocation — the classic "8-bit"/"hi-colour" palette crush. This is the dedicated home of the per-channel RGB posterize looks CELLSHADE's rebuild dropped (they are posterization, not cel shading): the 8-bit RGB 3-3-2 and 16-bit RGB 5-6-5 floor-quantization paths are ported EXACTLY, so an old cellshade retro patch recreates byte-for-byte by swapping in POSTERBOX. "Tints neutral grays" is a FEATURE, not a bug — an asymmetric allocation has different level grids per channel, so gray 0.2 at 3-3-2 quantizes to (36,36,0), a dark olive; that channel-clipped cast IS the period-correct look. DEPTH is a 5-step DISCRETE knob (the param is the step INDEX 0..4; the card shows the allocation name + palette size, and the matching CV input uses a discrete cvScale so it snaps to the 5 steps) stepping the ladder: 1-1-1 = 8 colours (3-bit RGB, ZX-Spectrum brutal), 2-2-2 = 64 (EGA master palette), 3-3-2 = 256 (VGA-era 8-bit truecolor, the default), 4-4-4 = 4096 (Amiga OCS), 5-6-5 = 65536 (RGB565 hi-colour, subtle). DITHER (0..1, default 0) is the classic companion: a Bayer 4×4 ordered dither that perturbs the quantizer threshold per screen pixel (the same offset-before-truncate scheme the PlayStation used before truncating to 15-bit) — at 0 the palette bands are HARD (the pure legacy crush); raising it dissolves band edges into alternating checkered pixels so gradients render as retro cross-hatch instead of banding. MIX (0..1, default 1) is a straight dry/wet. DEPTH / DITHER / MIX each have a matching CV input (port id == param id). STATELESS per frame — one texture sample + one Bayer lookup per pixel (single-pass shader, no neighbourhood taps). IN takes RGB; OUT is video — patch a source (CAMERA / VIDEOBOX / SHAPES / a generator) → IN, OUT → OUTPUT or a video mixer; step DEPTH for the era, raise DITHER for the cross-hatch, back off MIX to soften. All ports live on the yellow drill-down PATCH PANEL (no raw side jacks). The pure quantizer + Bayer math is unit-tested in $lib/video/modules/posterbox (the exact CPU mirror of the shader).

outputs

out video

inputs

in video
depth cv
dither cv
mix cv

params

depth 0..?
dither 0..1
mix 0..1

example js

spawn('posterbox', 'x');
set('x', 'depth', 0);
patch('x.out', 'x.in');

reverb reverb

The plain room — Faust's mono Freeverb (8 parallel damped comb filters into 4 series Schroeder allpasses), mono in / mono out, three knobs, no CV. The comb taps are FIXED (25.3–36.7 ms), so SIZE is decay TIME (comb feedback 0.50–0.95, measured audible T60 ~0.33 s to ~4.4 s — never infinite), not room size; DAMP is the one-pole lowpass inside each comb's feedback, darkening AND shortening the tail until at 1 the loop closes and only ~0.14 s of allpass diffusion is left; MIX is a linear dry/wet crossfade. Caveat: the tank is unscaled, so the wet leg is ~+10 dB (up to +18 dB at SIZE 1) hotter than the dry — MIX is also a loudness control and fully wet + large will clip. Reach for SHIMMERSHINE for an octave-up tail, CLOUDSEED for a real diffusion engine, MOOG905 for spring.

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 ?..?
size ?..?smp
feedback ?..?
mix ?..?

example js

spawn('ringback', 'x');
set('x', 'rate', 0);
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');

sourcery sourcery

SOURCERY — a two-input region-transplant recolorizer video PROCESSOR. It edge-detects video A (top) and video B (bottom), segments each edge map into bounded regions (the connected non-edge areas walled off by the detected edges), then for every region in A finds the B region most similar in SHAPE (angles + geometry) first and SIZE second, and paints A's region with B's colors placed at the SAME relative position inside the shape (a corner of A samples the matching corner of B). A B shape may be reused by many A regions and EVERY part of A maps to some region (tiny/culled regions and the edge walls are absorbed into their nearest surviving region, so the output has no holes — the whole-screen background becomes one giant region filled by some B shape). Two global controls move all the transferred color: SKEW rotates the hue of every filled pixel (bipolar, 0.5 = no shift), ROT rotates the sampling frame inside each region (bipolar, 0.5 = no rotation). The look is a shifting stained-glass / photomosaic where A's edge structure is the cell boundaries and each cell is a warped fragment of B chosen by shape similarity; region boundaries are intentionally BLOCKY (segmentation runs at a coarse 128×96 grid, nearest-upscaled) while the colors are full-res sharp. For real-time performance the shape/segmentation stage is temporally amortized (recomputed every few frames) while the color fill sampling live B runs every frame; on live noisy video at low threshold the regions shimmer/boil frame-to-frame (a disclosed v1 limitation). The CCL, moments, Hu shape descriptors, z-score match and rel→uvB transform are a 1:1 mirror of the pure, unit-tested $lib/video/sourcery-core; the two THRESHOLD knobs (each + a CV input) gate A/B segmentation. Patch a structural source into A and a colorful source into B; with nothing in B the module passes A through (hue-skewed only).

outputs

out video

inputs

a video
b video
thresholdA cv
thresholdB cv
colorSkew cv
rotate cv

params

thresholdA 0..1
thresholdB 0..1
colorSkew 0..1
rotate 0..1

example js

spawn('sourcery', 'x');
set('x', 'thresholdA', 0);
patch('x.out', 'x.a');

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 independent tape decks in one box, mixed to a stereo output. Each reel (A and B) records the stereo audio at its own L/R inputs onto a fixed-length blank tape, then plays the take back: patch audio in, arm with the ARM gate or fire the REC gate, and the tape records destructively (TAPE mode) or layers sound-on-sound (OVERDUB). Set a loop window by dragging the START and END markers on the reel picture, and drag anywhere else on it to scrub the playhead. RATE is varispeed — 1 is forward unity, 0 freezes the tape, negative plays it backwards, and it pitches the audio the way a real reel does; ECHOES (1–5) sets how many times the loop re-circulates and decays like a tape echo. Each reel then has its own 3-band EQ and a multimode filter (OFF / HP / LP / BP) to colour the playback. Globally, the A/B crossfader blends the two reels, A→B and B→A cross-feed one reel into the other for runaway tape textures, LOFI adds four grades of tape degradation, and MONITOR passes the live input through so you can hear what you are about to record. Every transport event has a gate input, so a sequencer can drive both reels by cable, and RATE CV per reel sweeps the full varispeed range for wow, flutter and tape-stops. SAVE TAPE exports a reel as a stereo 48 kHz 16-bit WAV, and a recorded take rides along in a saved performance.

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
rate_cv_a cv
audio_l_in_b audio
audio_r_in_b audio
rec_start_b gate
rec_arm_b gate
overdub_b gate
rate_cv_b cv

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
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
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');

vst fx vstFx

Runs one of YOUR installed effect plugins (AU builds of your VSTs) as a stereo insert via the vst-bridge native helper — 100% wet, bit-transparent bypass while nothing is mounted, local bypass when the helper is off so a lane never goes silent.

outputs

out_l audio
out_r audio

inputs

in_l audio
in_r audio

example js

spawn('vstFx', 'x');
patch('x.out_l', 'x.in_l');

warren's spectrum warrensspectrum

Spectral-analysis resynthesizer — a port of the SPECTRAL engine of the Warren's Spectrum VST (a.k.a. CallSine, MIT-licensed). Runs a rolling 2048-point FFT over whatever is patched into AUDIO IN, picks the loudest sinusoidal peaks, ranks them by SALIENCE (a harmonic-series bonus, so thinning the bank collapses toward the fundamental rather than toward the loudest formant), tracks them frame to frame with McAulay-Quatieri matching, and rebuilds the sound as up to 256 oscillators. It also replays what the tracker DISCARDS: leftover bin energy is measured in 16 log-spaced bands and re-synthesised as band-passed noise (the SMS residual) — the difference between a vocoder and a voice. PARTIALS sets density and CPU; LOCK snaps partials onto a harmonic comb (self-disengaging on unpitched input); RESIDUAL fades the noise half; SLICE sets the analysis period over a full 2-200 ms (the plugin declares that range but internally clamps at ~21 ms — here all of it works); SHAPE morphs every partial sine→saw→square; FREEZE (control or GATE input) holds the current spectrum as a drone; FLOOR/STABILITY gate which peaks earn an oscillator; SLEW smears them in time; CENTER and a V/oct PITCH input transpose the whole bank post-analysis. Mono in, mono out, monophonic — it is an EFFECT, so nothing patched into AUDIO IN means silence. Phase 1: no filterbank, no WAVETABLE or MASSPASS engine, no built-in FX.

outputs

out audio

inputs

audio_in audio
pitch pitch
gate gate
partials_cv cv
lock_cv cv
residual_cv cv
shape_cv cv
slice_cv cv
center_cv cv

params

engineMode ?..?
spectralBandCount ?..?
spectralPartials ?..?
spectralLock ?..?
spectralResidual ?..?
spectralSlice ?..?ms
engineFreeze ?..?
spectralShape ?..?
spectralFloor ?..?dB
spectralStab ?..?
spectralSlew ?..?s
spectralCenter ?..?cents
resynthLevel ?..?
inputMix ?..?
gain ?..?dB

example js

spawn('warrensspectrum', 'x');
set('x', 'engineMode', 0);
patch('x.out', 'x.audio_in');

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');

chroma console chromaconsole

Control surface for the Hologram Chroma Console pedal — sends MIDI CC to the hardware, carries no audio. All 34 documented CCs are available; eight assignable SLOTS back them with real parameters, so those eight are what clip automation, MIDI learn, Electra and the Push 2 card can drive. The pedal is receive-only, so the card shows what was sent, never what the pedal holds — PUSH ALL re-asserts every slot.

example js

spawn('chromaconsole', 'x');

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');

dockscope dockscope

Slim 1u single-trace oscilloscope built for the workflow dock rails — the trace is vector-redrawn at live on-screen pixel size so it stays crisp at every dock zoom step. Terminal visualiser: ch1 in (accepts audio/CV/pitch/gate), no outputs.

inputs

ch1 audio

params

timeMs 1..200ms
scale 0.1..10
range 0..1

example js

spawn('dockscope', 'x');
set('x', 'timeMs', 20);

es-9 es9

Full 16×16 audio+CV I/O with a real Eurorack system via the Expert Sleepers ES-9 and the es9-bridge native companion app — every DC-coupled jack individually patchable, with per-jack audio/cv/pitch/gate voltage scaling.

outputs

in1 audio
in2 audio
in3 audio
in4 audio
in5 audio
in6 audio
in7 audio
in8 audio
in9 audio
in10 audio
in11 audio
in12 audio
in13 audio
in14 audio
spdif_l audio
spdif_r audio
in1_cv cv
in2_cv cv
in3_cv cv
in4_cv cv
in5_cv cv
in6_cv cv
in7_cv cv
in8_cv cv
in9_cv cv
in10_cv cv
in11_cv cv
in12_cv cv
in13_cv cv
in14_cv cv

inputs

out1 audio
out2 audio
out3 audio
out4 audio
out5 audio
out6 audio
out7 audio
out8 audio
usb1 audio
usb2 audio
usb3 audio
usb4 audio
usb5 audio
usb6 audio
usb7 audio
usb8 audio

params

in1_class 0..3
in2_class 0..3
in3_class 0..3
in4_class 0..3
in5_class 0..3
in6_class 0..3
in7_class 0..3
in8_class 0..3
in9_class 0..3
in10_class 0..3
in11_class 0..3
in12_class 0..3
in13_class 0..3
in14_class 0..3
out1_class 0..3
out2_class 0..3
out3_class 0..3
out4_class 0..3
out5_class 0..3
out6_class 0..3
out7_class 0..3
out8_class 0..3

example js

spawn('es9', 'x');
set('x', 'in1_class', 1);
patch('x.in1', 'x.out1');

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..?
dryWet 0..1
dwTransition 0..?

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: out = (in1×Ch1 + in2×Ch2 + in3×Ch3 + in4×Ch4) × Master. Levels are LINEAR AMPLITUDE 0..1 (0.5 = −6 dB, 0.1 = −20 dB — fine fades live near the bottom of the travel), all default to unity, and all five are one-pole smoothed (≈23 ms) so moves are click-free but control-rate — never a VCA. The sum is NOT limited, clamped or headroom-compensated and Master maxes at 1.0 (attenuate only, no make-up gain), so four hot unity channels can leave at up to 4× full scale (+12 dB) and clip downstream: trim the channels or pull Master, and watch the face level meter. Audio cables only (the inputs declare no CV widening) — for per-channel CV, direct outs and soft-clip use ATTENUMIX; for stereo with EQ and aux sends use MIXMSTRS.

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

8xstereo 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[8]). Multiple instances allowed. 81 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
ch7L audio
ch7R audio
ch8L audio
ch8R 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
ch7_volume cv
ch7_low cv
ch7_mid cv
ch7_high cv
ch7_thresh cv
ch7_ratio cv
ch7_compEnable cv
comp7 cv
ch7_send1 cv
ch7_send2 cv
ch8_volume cv
ch8_low cv
ch8_mid cv
ch8_high cv
ch8_thresh cv
ch8_ratio cv
ch8_compEnable cv
comp8 cv
ch8_send1 cv
ch8_send2 cv
master_volume cv
send1Pre cv
send2Pre cv
ret1_volume cv
ret1_low cv
ret1_mid cv
ret1_high cv
ret2_volume cv
ret2_low cv
ret2_mid cv
ret2_high 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
ch7_volume 0..1
ch7_low -12..12dB
ch7_mid -12..12dB
ch7_high -12..12dB
ch7_thresh -36..0dB
ch7_ratio 1..10
ch7_compEnable 0..1
comp7 0..1
ch7_send1 0..1
ch7_send2 0..1
ch8_volume 0..1
ch8_low -12..12dB
ch8_mid -12..12dB
ch8_high -12..12dB
ch8_thresh -36..0dB
ch8_ratio 1..10
ch8_compEnable 0..1
comp8 0..1
ch8_send1 0..1
ch8_send2 0..1
master_volume 0..1
send1Pre 0..1
send2Pre 0..1
ret1_volume 0..1
ret1_low -12..12dB
ret1_mid -12..12dB
ret1_high -12..12dB
ret2_volume 0..1
ret2_low -12..12dB
ret2_mid -12..12dB
ret2_high -12..12dB

example js

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

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 1024x768 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 ?..?
cvAmount ?..?

example js

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

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
freeze 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');

cv buddy cvBuddy

Sends a clip lane out to a real Eurorack voice through an ES-9. Hand-patch a lane's pitch / gate / velocity into its inputs and CV Buddy passes them through to CV/gate outputs, which the CV-Buddy↔ES-9 reconciler auto-routes to the ES-9's physical output jacks by slot (first instance → jacks 1-3, second → 4-6) and sets each jack's voltage class (pitch → 1 V/oct, gate → +5 V, velocity → ±5 V). The v/oct rides a plain CV cable (not a pitch/poly cable) so CV Buddy stays a note SINK a lane can drive — the 1 V/octave scaling happens on the ES-9 jack. The id-smallest (owner) instance also generates two transport signals: RUN on jack 7 (a gate held high while the rack transport plays) and CLOCK on jack 8 (a DIN-sync pulse train at a selectable PPQN, phase-locked to TIMELORDE) — patch RUN + CLOCK into a Pam's New Workout to slave it to the rack. A third+ CV Buddy sits inert (no free ES-9 jacks). No audio output, so it never appears as a mixer send; with no ES-9 in the rack it is idle and harmless.

outputs

pitchCv cv
gate gate
velCv cv
run gate
clock gate

inputs

gate gate
pitch cv
velocity cv

params

clockOffsetMs -20..20ms

example js

spawn('cvBuddy', 'x');
set('x', 'clockOffsetMs', 0);
patch('x.pitchCv', 'x.gate');

cv buddy mini cvBuddyMini

The two-jack CV BUDDY: pitch and gate only, no velocity. The full CV Buddy spends THREE of the ES-9's eight outputs per voice, so two of them fill the device; a mini spends two. That buys the two layouts that matter — THREE minis fit in outputs 1-6 and leave jacks 7 and 8 doing RUN and CLOCK (three voices and still a clock for Pam's), or a SINGLE mini takes 1, 2, 7 and 8 and leaves four outputs free for audio sends and returns. Hand-patch a clip lane's pitch and gate into its inputs; the CV-Buddy↔ES-9 reconciler auto-routes them to physical jacks and sets each jack's voltage class (pitch → 1 V/oct, gate → +5 V). Slots are shared with any full CV BUDDYs on the rack — both kinds draw from ONE pool in node-id order, so they can never claim the same physical jack. The id-smallest instance of either kind owns RUN (jack 7, held high while the transport plays) and CLOCK (jack 8, a DIN-sync pulse train at a selectable PPQN locked to TIMELORDE). An instance that does not fit in the remaining outputs sits inert and says so. No audio output, so it never appears as a mixer send; with no ES-9 in the rack it is idle and harmless.

outputs

pitchCv cv
gate gate
run gate
clock gate

inputs

gate gate
pitch cv

params

clockOffsetMs -20..20ms

example js

spawn('cvBuddyMini', 'x');
set('x', 'clockOffsetMs', 0);
patch('x.pitchCv', 'x.gate');

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

poly polyPitchGate
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. There is a live preview screen with the picture, and two switches beside it that do opposite things: SCREEN turns the preview off to reclaim its space (the module goes on rendering either way), and MONITOR hides the control bands so the picture has the whole plate to itself - drag the bottom-right corner to size it, and click MONITOR again to bring the controls back. Either way it is a viewport only; neither changes the output resolution.

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');

out to launch outToLaunch

OUT TO LAUNCH — turns a Novation Launchpad Mini Mk3 into a live 9×9 RGB VIDEO MONITOR. Takes ONE video input, downsamples it to a 9×9 grid on the GPU (each cell is a TAPS×TAPS box-average of its slice of the frame, so it does not alias/flicker on moving video), and pushes those 81 pixels to a BOUND Launchpad's LEDs in real time via the batch-RGB SysEx. The Mini Mk3's WHOLE addressable surface IS a 9×9 grid — the 8×8 pads (11..88) + the top CC row (91..98) + the right scene column (19..89) + the corner logo (99) — and in programmer-mode numbering every button is row*10+col for row/col 1..9, so the downsample maps DIRECTLY onto the hardware, UPRIGHT: the bottom-left of the frame lands on pad 11 (bottom-left), the top-right on the logo (99). It has NO video output — it is a SINK, an endpoint (like a monitor at the end of a chain, except the monitor is a grid of buttons). BIND from the card: Connect (gesture-gated Web-MIDI sysex, no eager prompt) then pick a Launchpad output; bindMonitor claims EXCLUSIVE LED control of that device (it enters programmer mode + its LEDs are driven by the video), so a bound Launchpad CANNOT be used for control at the same time — out to launch takes it over. Two knobs shape the look: BRIGHT (0..1) scales overall LED brightness; GAMMA (0.5..3, default 2.2) deepens/lifts the mid-tones (both applied identically to the LEDs AND the on-card preview, so the preview matches the hardware exactly). Architecture: the module's pure-GL factory box-averages the input into a tiny 9×9 FBO and readPixels the 81 RGBA texels each frame (exposed via read('grid9x9')); the CARD's throttled ~30 fps rAF loop reads that grid, draws the 9×9 preview, maps it to LED colours (monitorGridToLeds), and setMonitorFrame()s it (diffed → only changed LEDs sent, batched into one SysEx ≈413 bytes/frame — trivial over USB-MIDI). pullExempt keeps the readback fresh even when the card is off-screen. The monitor binding is INDEPENDENT of the clip-launcher's L/R units, so out to launch on one Launchpad and LAUNCHPAD CONTROL on another run simultaneously (one owner per physical device; same-device sharing is refused via isOutputClaimed). On unbind / node-delete the device is released (LEDs cleared, returned to Live mode). USAGE: patch a source (CAMERA / a generator / a clip) → VIDEO in, Connect + pick your Launchpad, and dial BRIGHT/GAMMA — a tiny confidence monitor, a lo-fi VJ output, or lighting a Launchpad from a live feed. The pure surface mapping (lpMonitorIndex / rgb8ToLp / monitorGridToLeds) lives in $lib/control/launchpad/launchpad-sysex.

inputs

in video

params

bright 0..1
gamma 0.5..3

example js

spawn('outToLaunch', 'x');
set('x', 'bright', 0);

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). Use it as the monitor/projector at the end of a video patch — or mid-chain, since it passes its input straight through. In the rack it is a compact tile showing a live thumbnail of its own feed; the tile itself is not resizable. To see the picture bigger, right-click it: DETACH DISPLAY floats the output free of the rack as its own window — resizable by its bottom-right corner, draggable by its title bar, carrying no patch jacks or cables — and RE-ATTACH puts it back. The floating window is owned by the module, so deleting the module removes it and deleting the floating window removes the module. Its size and position live in node.data and sync to collaborators via Y.Doc. Expand the module to its faceplate for the same picture plus the display menu: true fullscreen, in-app full frame, detach, or present-on-a-second-display; right-clicking the picture anywhere opens that menu too. DELETING an output that sits mid-chain, with both its input and its output patched, re-joins the module feeding it directly to whatever it was feeding — so pulling a monitor out of a chain leaves the chain intact rather than cut in two. An output patched to itself is the one shape that cannot be re-joined, and it is deleted plainly.

outputs

out video

inputs

in video

example js

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

ptz cam ptzcam

CV control of a physical PTZ camera (NexiGo P610, Logitech PTZ Pro 2) — pan/tilt/zoom knobs plus matching CV inputs, sent as MIDI sysex to the native PT-PTZ helper (tools/pt-ptz), which drives the cameras over USB (one MIDI pair and one module per camera). Each axis follows the mode the camera reports in the bind handshake: absolute axes take normalized positions, velocity axes take signed rates with a watchdog-guarded stop; sends are coalesced to ~10 Hz. Carries no audio or video — the camera picture arrives through a normal camera input.

inputs

pan_cv cv
tilt_cv cv
zoom_cv cv

params

pan -1..1
tilt -1..1
zoom 0..1
slew 0..1

example js

spawn('ptzcam', 'x');
set('x', 'pan', 0);

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). There is a live preview screen showing the remapped output, and two switches beside it that do opposite things: SCREEN turns the preview off to reclaim its space (the module goes on rendering either way), and MONITOR hides the control bands so the picture has the whole plate to itself - drag the bottom-right corner to size it, and click MONITOR again to bring the controls back. Either way it is a viewport only; neither changes the output resolution.

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. There is a live preview screen with the picture, and two switches beside it that do opposite things: SCREEN turns the preview off to reclaim its space (the module goes on rendering either way), and MONITOR hides the control bands so the picture has the whole plate to itself - drag the bottom-right corner to size it, and click MONITOR again to bring the controls back. Either way it is a viewport only; neither changes 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

example js

spawn('fourplexer', 'x');
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), ax / ay (cv ±1 — the AUX stick, a third X/Y pair that ships bound to NOTHING and reads a hard 0 until you bind it, for the axes a flight stick has and a gamepad does not: a twist/rudder, a throttle lever, a slider), 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; it is the module's only param, and it is the one ranked cell on the faceplate — everything else a player configures lives on the dock's MAPPING BOARD. REMAP: right-click ANY cell on the board — a button LED, a trigger row, or an X / Y button under a stick — to arm a listener, then move the physical control you want bound to that output; alt-click resets a cell. (The axis buttons used to arm on LEFT-click and RESET on right-click, the inverse of every other cell, so right-clicking the one you wanted to bind silently cleared it instead of listening.) The Gamepad API has no events, so the armed listener diffs each poll against the reading captured when you armed it and takes the first control past a 0.5 threshold; Escape cancels. STICK CALIBRATION, on BOTH sticks independently: "calibrate left/right" arms a sweep mode — move that stick through its full range several times (the board draws the swept extent as a box inside the stick pad, which fills as you go), then "complete" locks the swept range in so observed-min→full-min and observed-max→full-max per axis, with a captured true rest centre mapped to 0 and a radial deadzone around it (no snap-back drift). A separate per-stick "set center" captures that rest centre on its own, for a stick that physically rests off-centre. INVERT: a per-axis sign flip on every stick axis (lx / ly / rx / ry / ax / ay) that composes on top of any remap. Each of these is persisted once to the patch (rides collab + undo); "clear" reverts a stick to the fixed-deadzone path. SAVE / LOAD MAPPING bundles every binding, both calibrations and every invert into a .json you can reload or share, and built-in presets ship for the NXT Gladiator and for the Gladiator EVO R (whose TWIST is physical axis 5, a full-range bipolar axis, routed to the AUX X output). Presets are OFFERED in the picker and never auto-applied on a device-id match. This is what 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
ax cv
ay 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

example js

spawn('gamepad', 'x');

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 ?..?s
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');

tempolock tempolock

Beat-tracking clock: a raw onset train in (e.g. SYNESTHESIA band trigger firing on every kick) -> tracked STEADY quarter-note clock out, never a passthrough of input edges. Inter-onset gaps are read as integer multiples of one base pulse (tolerance-window greatest-common-pulse), folded into a selectable BPM band by octave (60-120 / 90-180 / 120-240) with hysteresis toward the current lock, then a phase accumulator emits the clock with gentle PLL correction from onsets near predicted beats/half-beats. Silent from cold until the first lock; free-runs forever through input dropouts (locked gate drops after ~4 missed beats); bpm CV = tracked BPM / 300.

outputs

clock gate
bpm cv
locked gate

inputs

in gate

params

range 0..2

example js

spawn('tempolock', 'x');
set('x', 'range', 0);
patch('x.clock', 'x.in');

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

example js

spawn('resofilter', 'x');
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-life timer ceiling, and it applies to the RUNNING game — lowering it clamps the life already in progress, raising it takes effect on the next life. Game logic runs at visual cadence on the main thread (no audio worklet); pure deterministic state stepper in frogger-state.ts with NO RNG anywhere, so the board is a pure function of tick count. The 14×13 grid renders at the head of the module's dock faceplate and on the legacy card. 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
freeze 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');

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');

warren's visions warrensvisions

The visual analogue of WARREN'S SPECTRUM — a 2D spectral video resynthesizer. Every SLICE frames it downsamples VIDEO IN to a 128×128 luma plane, runs a 2D FFT, and picks the strongest peaks in the WAVEVECTOR plane: each peak is a sine grating whose radius is how fine the pattern is, whose angle is its orientation, whose magnitude is contrast and whose phase is where it sits. Peaks are ranked by SALIENCE, snapped toward a detected lattice comb by LOCK, matched frame to frame as tracks, and everything unclaimed is measured in 16 log-spaced RINGS and replayed as procedural texture (the SMS residual — grain, foliage, smoke). The bank is summed back through an inverse FFT and composited against the source. COHERENCE is the control the module exists for and has no audio counterpart: at 1 each component's phase is re-seated on the phase measured in the incoming frame, giving a recognisable sparse reconstruction; at 0 phase is seated at track birth and free-runs — the literal audio behaviour — and the picture drifts off into a moving interference painting with the source's spectrum and none of its geometry. COMPONENTS (1-256) sets density and CPU; FLOOR/STABILITY gate which peaks earn a slot; SLEW smears contrast; DRIFT gives each component its own phase velocity so the picture boils; SHAPE morphs every grating sine→saw→square by harmonic injection; CENTER transposes every wavevector, zooming the reconstruction; FREEZE (control or GATE) holds the bank as a still; MIX crossfades against the source. Resynthesizes LUMA and keeps the source's chroma. An EFFECT — nothing patched in means black — and capped at ONE instance. v1 defers MASSPASS, the editable post-filterbank, independent RGB tracking and a 256² grid.

outputs

out video

inputs

video_in video
gate gate
components_cv cv
coherence_cv cv
residual_cv cv
shape_cv cv
center_cv cv
drift_cv cv
mix_cv cv

params

visionsCoherence ?..?
visionsComponents ?..?
visionsFloor ?..?dB
visionsStability ?..?fr
visionsSlew ?..?s
visionsSlice ?..?fr
visionsResidual ?..?
visionsShape ?..?
visionsCenter ?..?ct
visionsDrift ?..?
visionsMix ?..?
engineFreeze ?..?

example js

spawn('warrensvisions', 'x');
set('x', 'visionsCoherence', 0);
patch('x.out', 'x.video_in');

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
view 0..1

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.