clip player

clipplayer · modulation · schema v2

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

A clip launcher in the style of Ableton's Session view, with 8 instrument lanes. The grid's rows are the 8 lanes (instruments) and the columns are 8 clip slots, for 64 note clips in all; each lane independently plays whichever clip you launch out its OWN pitch/gate/velocity outputs, so up to 8 clips can sound at once (one per lane). Click a pad to launch its clip, double-click to open the piano-roll editor and draw notes into it. There's no internal clock or BPM — CLIP PLAYER is locked to TIMELORDE (the rack transport): it runs at TIMELORDE's tempo, only while TIMELORDE is running, and the STEP control sets how many steps fall per beat. Launches can fire immediately or be quantized to snap cleanly at the playing clip's loop boundary. It also has a SONG / arrangement mode that records your launches onto a timeline for non-real-time playback, and pairs with a monome grid for hardware launching. Drive its lanes into eight voices for a full multitrack clip-based performance instrument.

Full guide: Clip launcher, monome grid & song mode The full illustrated guide — launching clips, scenes & quantize, editing notes on the pads, driving it from a monome grid 128, and recording a session into a song-mode arrangement.

the faceplate

1 inputs · 24 outputs · 5 params

about this module

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

inputs

id	cable	what it does
`stop_all`	gate	Stop-all trigger: a rising edge immediately stops every lane (a panic/stop button), in both session and arrangement modes. gate / trigger

outputs

id	cable	what it does
`pitch1`	polyPitchGate	Lane 1's pitch output — the launched clip's notes as a poly chord cable (a mono pitch input receives just the root; a poly voice plays the whole chord), shifted by the OCT control. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate1`	gate	Lane 1's gate — goes high while a note in lane 1's clip plays (its width set by GATE; tied/held notes stay high across their span); low on rests. Patch into an envelope/VCA. gate / trigger
`vel1`	cv	Lane 1's velocity CV — each note's velocity as a control voltage, for velocity-sensitive patching (e.g. into a VCA or filter depth). control voltage (CV)
`pitch2`	polyPitchGate	Lane 2's pitch output (poly chord cable), from lane 2's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate2`	gate	Lane 2's gate — high while lane 2's notes play, low on rests. gate / trigger
`vel2`	cv	Lane 2's velocity CV. control voltage (CV)
`pitch3`	polyPitchGate	Lane 3's pitch output (poly chord cable), from lane 3's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate3`	gate	Lane 3's gate — high while lane 3's notes play, low on rests. gate / trigger
`vel3`	cv	Lane 3's velocity CV. control voltage (CV)
`pitch4`	polyPitchGate	Lane 4's pitch output (poly chord cable), from lane 4's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate4`	gate	Lane 4's gate — high while lane 4's notes play, low on rests. gate / trigger
`vel4`	cv	Lane 4's velocity CV. control voltage (CV)
`pitch5`	polyPitchGate	Lane 5's pitch output (poly chord cable), from lane 5's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate5`	gate	Lane 5's gate — high while lane 5's notes play, low on rests. gate / trigger
`vel5`	cv	Lane 5's velocity CV. control voltage (CV)
`pitch6`	polyPitchGate	Lane 6's pitch output (poly chord cable), from lane 6's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate6`	gate	Lane 6's gate — high while lane 6's notes play, low on rests. gate / trigger
`vel6`	cv	Lane 6's velocity CV. control voltage (CV)
`pitch7`	polyPitchGate	Lane 7's pitch output (poly chord cable), from lane 7's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate7`	gate	Lane 7's gate — high while lane 7's notes play, low on rests. gate / trigger
`vel7`	cv	Lane 7's velocity CV. control voltage (CV)
`pitch8`	polyPitchGate	Lane 8's pitch output (poly chord cable), from lane 8's launched clip. poly pitch+gate bus; 10-channel poly bus (5 pitch + 5 gate lanes)
`gate8`	gate	Lane 8's gate — high while lane 8's notes play, low on rests. gate / trigger
`vel8`	cv	Lane 8's velocity CV. control voltage (CV)

params

id	label	range	default	curve
`stepDiv`	Step	0..3	2	discrete
`octave`	Oct	-2..2	0	discrete
`gateLength`	Gate	0.1..1	0.9	linear
`quantize`	Qnt	0..1	1	discrete
`snh`	s&h	0..1	1	discrete

controls

control	what it does
Clipplayer cell {n}	A note cell in the piano-roll editor (rows are scale degrees/pitches, columns are steps). Click to toggle a note on or off at that pitch and step; right-click cycles the note's velocity. The cells make up the clip you're editing for the selected lane+slot.
Clipplayer mono {n}	Lane {n}'s mono/poly toggle — switches that lane between MONO (one note per column) and POLY (up to five notes per column, played as a chord out the lane's poly pitch output).
Clipplayer pad {n}	A clip slot in the launch grid (one cell of the 8 lanes × 8 slots). Click to launch that lane's clip (immediately or quantized per QNT), click the playing pad to stop the lane, and double-click to open the clip in the piano-roll editor. An empty pad shows differently from a filled or playing one.
Gate	GATE — how much of each step the per-note gate stays high, from short staccato stabs to near-legato (held/tied notes ignore this and stay high across their full span).
Oct	OCT — transposes every lane's pitch output up or down by whole octaves (-2..+2).
Qnt	QNT — launch quantization: on, a clip you launch waits and drops in cleanly at the playing lane's next loop boundary; off, it launches immediately. (A first launch into an empty lane is always immediate.)
s&h	S&H — one global sample-and-hold toggle for all 8 lanes' pitch outputs: on (default), on a rest the gate closes but each lane's pitch HOLDS its last note (latched to the gate edge); off, rests reset pitch to 0 (the legacy continuous behavior).
Step	STEP — how many steps fall per TIMELORDE beat (1/4, 1/8, 1/16, 1/32), i.e. the playback resolution of the clips.

source

clipplayer.ts on GitHub.