kria

kria · modulation

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.

A four-track grid sequencer modelled on the monome Kria, where each track is not one pattern but several layered ones: separate per-step lanes for trigger, note, octave, duration, probability, glide and ratchet, plus its own loop window (start + length), clock division and play direction (forward / reverse / ping-pong / drunk / random). All four tracks share a base 16th-note clock (from a TIMELORDE node, an external CLOCK IN, or the local BPM) but each can run at its own division and loop length, so the tracks drift in and out of phase to build long evolving lines. A shared scale and root quantize the note + octave lanes into pitch CV, and you can stash 16 whole patterns and cue between them quantized to the loop boundary. Each track emits a pitch CV (with optional glide) and a gate (shaped by its duration and subdivided by its ratchet). The card edits one track/page at a time; an optional monome grid drives the same edits.

the faceplate

2 inputs · 8 outputs · 2 params

about this module

Hover a control, or open the patch panel and hover a jack.

inputs

id	cable	what it does
`clock`	gate	External base clock: each rising edge advances the shared 16th-note grid one tick, from which every track derives its own stepping via its clock division. When patched it overrides the internal BPM for step timing (the rack tempo still sets gate/glide durations), and the pulses themselves run the sequencer. gate / trigger; trigger — fires once per rising edge
`reset`	gate	A rising edge (a trigger) re-anchors all four tracks to the start of their loop windows at once and clears any pending pattern cue, so everything restarts cleanly together. gate / trigger; trigger — fires once per rising edge

outputs

id	cable	what it does
`pitch1`	pitch	Track 1's pitch CV (V/oct): the current step's note + octave lanes mapped through the shared scale and root, with the glide lane slewing the ramp between steps for portamento. V/oct pitch CV
`gate1`	gate	Track 1's gate: goes high on steps whose trigger lane is set and whose probability roll passes; the duration lane sets how wide it stays high and the ratchet lane subdivides it into 1–4 evenly-spaced re-hits within the step. gate / trigger; gate — acts while the level is high (reacts to both edges)
`pitch2`	pitch	Track 2's pitch CV (V/oct), quantized through the shared scale/root with its own glide slew. V/oct pitch CV
`gate2`	gate	Track 2's gate: goes high on its own trigger-lane steps, with track 2's duration lane setting how wide it stays high and its probability and ratchet lanes shaping the rest. gate / trigger; gate — acts while the level is high (reacts to both edges)
`pitch3`	pitch	Track 3's pitch CV (V/oct), quantized through the shared scale/root with its own glide slew. V/oct pitch CV
`gate3`	gate	Track 3's gate: goes high on its own trigger-lane steps, with track 3's duration lane setting how wide it stays high and its probability and ratchet lanes shaping the rest. gate / trigger; gate — acts while the level is high (reacts to both edges)
`pitch4`	pitch	Track 4's pitch CV (V/oct), quantized through the shared scale/root with its own glide slew. V/oct pitch CV
`gate4`	gate	Track 4's gate: goes high on its own trigger-lane steps, with track 4's duration lane setting how wide it stays high and its probability and ratchet lanes shaping the rest. gate / trigger; gate — acts while the level is high (reacts to both edges)

params

id	label	range	default	curve
`bpm`	BPM	30..300	120	linear
`running`	Run	0..1	0	discrete

controls

control	what it does
BPM	Internal fallback tempo in beats per minute, used only when there is no TIMELORDE node in the rack AND nothing is patched into CLOCK IN; when a TIMELORDE is present its tempo wins, and an external clock overrides both.
Kria cell {n}	A cell of the per-step editor grid for the selected track — this is where you enter each step's value, INCLUDING its note. The same grid is reused by the lane selector (TRG / NTE / OCT / DUR / PRB / GLD / RAT): on the NOTE (NTE) lane it IS the per-step note entry — the lit row picks that step's scale DEGREE (bottom row = degree 0, up to degree 6), which the shared SCALE + ROOT then quantize into the track's pitch CV; on the other lanes the same cell instead sets the step's trigger, octave, gate duration, probability, glide time or ratchet count. Click a cell to set/clear it for the active lane; the column tracking the playhead is highlighted as it runs. A lane with fewer values than the grid has rows (OCTAVE has six, PROBABILITY and RATCHET have four) leaves the surplus rows visibly INERT rather than accepting clicks it cannot display. The same surface flips to the sixteen pattern slots, where a tap CUES a pattern and the engine swaps on the next loop boundary. (An attached monome grid drives these same edits through the same write path.)
Kria direction {n}	Which way the SELECTED track walks its loop window: forward, reverse, ping-pong (bouncing off both ends without repeating them), drunk (a ±1 random walk) or random. Drunk and random re-roll every advance, so they never repeat exactly.
Kria loop length {n}	How many steps the SELECTED track plays before wrapping (1–16). The window wraps past step 16 if it starts late, so FROM 15 / LEN 4 plays steps 15, 16, 1, 2. Set to 16 the track never wraps early.
Kria loop start {n}	The first step of the SELECTED track's loop window (1–16). Together with LEN this is what lets each track run a different length from its neighbours, so the four tracks drift in and out of phase instead of repeating in lockstep.
Kria mute {n}	Silences the SELECTED track's gate output while leaving its pattern and its playhead intact — the track keeps walking, it just stops firing. Mute is not a per-step lane; it is a property of the whole track.
Kria root {n}	The MIDI root note the ACTIVE pattern's scale is built on (C3 by default). Degree 0 of every track sounds this note; the per-step OCTAVE lane then adds whole octaves on top of it.
Kria scale {n}	The scale the ACTIVE pattern quantizes every track's note lane into (major, minor, pentatonic or chromatic). The note lane stores a DEGREE, so changing the scale re-voices every step of all four tracks at once without editing a single note.
Kria time division {n}	The SELECTED track's clock division: how many base 16th-note ticks pass per step advance. 1 advances every tick, 4 advances once a beat, 16 once a bar. The divisions are a fixed roster (1, 2, 3, 4, 6, 8, 12, 16) rather than a free range, because a value between two of them is not a musical division.
Run	Local play/stop transport (1 = running, 0 = stopped), exposed as the card's RUN button. When a TIMELORDE node exists its run state drives playback instead, and an external clock's pulses can run the tracks regardless.

source

kria.ts on GitHub.