Instruments

The computer MIDI keyboard

View ▸ Computer MIDI Keyboard (⌘K) turns the QWERTY row into a keyboard for the focused instrument track: A S D F G H J K L ; ' are the white keys from C, W E T Y U O P the black keys, Z / X step the octave (the A key starts at C3, MIDI 60), C / V step the velocity by ten. Chords work; a held key keeps sounding until you lift it. While it is on, the top bar's MIDI caption reads KEYS with the A key's octave, and typing in any text field still types (the keyboard steps aside for a focused field and for ⌘ / ⌥ chords).

Turning it off, or changing octave, releases every held note. The agent sees and sets it as view.computer_keyboard (on, octave, velocity; the snapshot reports computer_keyboard while it is on).

WOOLLY (the 4-oscillator polysynth)

WOOLLY's face is a full hardware console:

• Header — a ⏻ for the whole synth (bypass: silent, patch kept — the dock's Synth box shows the same switch), the WOOLLY nameplate, a ◀ NAME ▶ preset LCD with seven factory patches (INIT, SOFT KEYS, WARM PAD, BIG SAW, PLUCK, SUB BASS, GLASS BELLS), POLY/MONO/LEG voice modes, a VOICES stepper (1–32), GLIDE, and MASTER level. Only the arrow you are pointing at lights — the same for the ± halves of every stepper chip on this face — so a click's direction is never in doubt.
• Four oscillators, each with: a ⏻ power switch, a live phosphor wave scope, shape segments SIN/SQR/SAW/TRI/NSE, a unison stepper (1–8 voices), and knobs TUNE (semitones), FINE (cents), LEVEL, PAN, PW (pulse width), DETUNE, SPREAD.
• Filter — ⏻, types OFF/LP/HP/BP/NT, 12/24 dB slopes, a response screen with a cutoff marker; knobs CUTOFF, RESO, ENV AMT (bipolar), KEY TRK, VELO.
• Filter and Amp envelopes — full ADSR each with a live trace; the filter envelope's ⏻ parks ENV AMT at 0 (and remembers it); the amp envelope adds an ANALOG character chip and a VELO knob.
• Two LFOs — ⏻, shapes SIN/TRI/SW+/SW−/SQR/S&H, tempo SYNC (RATE becomes a beat cell, 1/4 up to 8 beats), DEPTH.
• Two Mod envelopes — ADSR + screens (sources for the matrix).
• MOD MATRIX screen — the patch's routes, editable: each row is SOURCE → TARGET · DEPTH · ×. Click a source or target cell to step to the next one (⇧-click steps back; drag up/down or use the wheel to scrub the list — a rewire keeps the depth and never duplicates a pair the patch already has). Drag the depth cell (1 px = 1 %, ⇧ for fine; wheel ±5 %) — it's live while you drag and lands as one ⌘Z step when you let go. × removes a route; + ADD ROUTE at the foot adds one (a musical default such as MOD ENV 1 → FILTER CUTOFF), and the wheel scrolls the list when the patch has more routes than rows. Sources: LFO 1/2, MOD ENV 1/2, VELOCITY, NOTE, PRESSURE, TIMBRE, and MIDI CCs (MOD WHEEL, EXPRESSION, CC 74 …); targets are the voice parameters (oscillator tune/fine/level/pan/ PW/detune/spread, filter cutoff/reso/env amount/key/velo, both ADSRs, LFO rate/depth, the mod envelopes) — never MASTER or the FX. Depth is added on top of the knob: +30 % means the source can push the parameter up to 30 % of its range above where the knob sits. Every new WOOLLY comes pre-patched so the piano roll's CC lanes are audible: CC74 → cutoff, CC11 → osc levels, CC1 → vibrato, pitch-bend ±12 st.
• FX rack — DRIVE (amount), CHORUS (speed/depth/width/mix), DELAY (beat-synced time, feedback, cross, mix), REVERB (size/damp/width/mix), each behind its own ⏻.

Power switches are the DAW's ⏻ glyph (the same one on every device in the dock: lit when on, dim when off) and every one of them switches something real in the engine — an oscillator off is wave shape none, the filter off is type OFF, an LFO off is shape none, an FX module off is its On flag. AMP ENV, the mod envelopes and the mod matrix have no switch because the engine has no "off" for them (the voice envelope always runs; a mod envelope is only ever heard through a route).

Every knob is a real automatable parameter — automation lanes, modulators, and MIDI Learn all work on them, and the agent can set any of them by name (instrument.set_param); the agent routes the mod matrix with instrument.set_modulation {track, source, target, depth?, clear?} and reads it from the track's mod_matrix / mod_targets.

Every control on the face has a hover tip — the rails answer per cell, the mod matrix names its source / target / depth / × / + ADD ROUTE zones, and a synced LFO's BEAT cell explains itself — and the ? toggle or Preferences turns tips off.

The Sampler (Simpler-class)

A pitched sampler with three modes — CLASSIC (looped/sustained playback), ONE-SHOT (trigger and forget), and SLICE (chop to pads) — chosen from the header chips of its editor, alongside LOOP and WARP toggles. The header is the dock's title bar: a ⏻ at the left (bypass — the sampler goes silent, its settings stay; the dock's Sampler box shows the same switch) and the ✕ at the right that closes the editor.

Loading: drag a sample from the browser or Finder onto its waveform, or use the browser's Add as Sampler Instrument (pitches the whole keyboard from one root note, default C3). The sampler holds up to 60 seconds. A longer file loads its first minute, and the status line says so (the engineer sees truncated_to_s in the reply).

The editor (takes over the bottom band): a large zoomable waveform with draggable START/END flags, aqua LOOP flags (with crossfade), and amber numbered SLICE markers (click one to audition it); a global LCD well with drag-editable TRANSP / DETUNE / GLIDE / VOICES / VEL / GAIN / ROOT / FADE cells; an audition keyboard (C1–C5, growing to reach every slice); and a rack of full-bleed phosphor modules — AMP ENV, FILTER, LFO — whose graphs you can drag as well as their knobs. Every control, flag, cell and key explains itself on hover (Tooltips).

The loop always lives inside START and END: dragging a region flag into the loop pushes the loop along, and a loop flag stops at the region's edge. The header's title zone grows to fit the sample's name.

Loading, three ways: drop a file from the browser or Finder on the wave (or the dock box); click the empty + to choose a file; or right-click the wave (or the dock box) for Load / Replace sample… and Reveal in Finder. A drop of several files takes the first.

The wave's right-click menu also holds Normalize (sets GAIN so the peak lands at −0.3 dBFS — a parameter, the file is untouched), Reverse (plays the sample backwards; the wave draws reversed and the START/END/LOOP/slice markers keep their positions), Zoom to fit, Crop to region, and the slicing items below.

Crop to region makes the START/END region the whole sample: the region is written as a new wav in the project folder (<name> crop.wav) and loaded in place, so START/END reset to the whole file and the loop and slices go with them. Undo brings the old file back; the cropped file stays on disk like a glued clip's. The agent's twin is sampler.crop.

Multi-sample layers. A layer is another file with a key range and a velocity range; inside that zone it plays instead of the main sample (whole, pitched from its own root), and the main sample covers everything else. Drop a file on a key of the audition keyboard to add a one-key layer there; it appears as a numbered band along the top of the keys. Drag a band's edge to widen its key range. Right-click a key the band covers for its velocity range (Full, Soft 1–63, Hard 64–127, Low / Mid / High thirds), its crossfades, to make that key the layer's root, or to remove it.

Up to 16 layers; every layer whose zone holds the note plays; slice mode plays the main sample only. The agent shares all of it (sampler.add_layer / set_layer / remove_layer; the snapshot lists sampler.layers).

Crossfades. A layer's Key crossfade (2, 4, 7, or 12 keys) ramps it in over that many keys at the bottom of its range and out over the same at the top; Velocity crossfade (16, 32, or 64 steps) does the same across velocity. Overlap two layers by their fade widths and the note plays both, their gains summing to one, so a walk up the keyboard (or a harder hit) glides from one sample into the next instead of switching. The band thins out over its fade keys so the overlap reads at a glance. The agent's fields are key_fade and vel_fade.

One gesture grammar for every cell (the well's and the header's, same as the knobs): drag up or down (⇧ for fine), double-click to type a value — ROOT takes note names like F#2 — and ⌥-click to reset. GLIDE drags on a curve, so the musical 0–100 ms is not a few pixels of a two-second range. FADE is the loop crossfade, as a share of the loop's length; it sits dim while LOOP is off.

The graphs are handles. Drag the AMP ENV nodes: the first for attack, the second for decay (its height is sustain), the third for release. The FILTER module's response glass is cutoff × resonance (drag anywhere on it); its ENV inset is the filter envelope's own ADSR with the same three nodes, drawn quiet while F.ENV is 0; the row also carries KEY (key tracking) and VEL (velocity to filter). The LFO glass is rate × amount, its picture cycles faster as the rate rises, and the HZ / SYNC segment switches the RATE knob between hertz and tempo-synced beats (1/16 to 16, snapped to powers of two).

The envelope follows the mode. In ONE-SHOT the release leg is drawn dashed with an END mark, because a one-shot ignores key-up and REL fades the tail at the region's end. In SLICE the release is a drop at the boundary and the REL knob sits dim and inert — it refuses the drag rather than moving a value the mode ignores: a slice stops where the next begins, with a 3 ms anti-click.

The keyboard is a piano silhouette (short black keys, each C labelled). Click to audition, drag for a glissando, ⌥-click a key to make it the root note (or right-click it, or drag the ROOT cell). The root plays the sample at its own pitch and is drawn jade.

The filter ships OFF, and while it is OFF its four knobs (CUT / RES / DRV / F.ENV) sit dimmed — they do nothing until a type is chosen. Turning any of them switches the filter to LP in the same gesture, so the knob you touched does what it says; pick HP or BP from the segments if you meant those. The dock box's CUT knob follows the same rule.

WARP needs the sample's own tempo. When you turn it on, the editor reads a bpm tag in the filename (_85bpm) if there is one, otherwise it guesses from the region's length as a whole number of bars nearest the song's tempo. The guess appears beside the WARP chip as a BPM cell: drag it up or down to correct it (⇧ for fine), ÷2 / ×2 fix an octave miss (a two-bar loop read as one), and double-click asks for the guess again. The same number is warp_bpm for the agent (sampler.set with 0 = guess again).

The full parameter set (all also agent-settable via sampler.set): gain −24…+12 dB · attack 0–5000 ms · decay 1–10000 ms · sustain 0–1 · release 1–10000 ms · transpose ±48 st · detune ±50 ct · glide 0–2000 ms (mono) · velocity→level 0–1 · filter cutoff 20 Hz–20 kHz, resonance 0–1, drive 0–24 dB, type off/LP/HP/BP · bipolar filter-envelope amount ±4 octaves with its own ADSR and velocity amount · key tracking 0–1 · LFO rate 0.01–40 Hz (or beat-synced 1/16…16 beats) with shapes sine/triangle/saw/square/S&H and targets cutoff/pitch/pan/volume · sample start/end and loop start/end/crossfade · root note · up to 32 voices · warp on/off to the project tempo (pre-stretched, cached, deterministic — it follows tempo changes) with warp_bpm, the tempo it stretches from · reverse (playback orientation).

Slicing: the SLICE chip finds onsets deterministically (the agent's sampler.slice, at a sensitivity you choose or with hand-set positions) — up to 64 slices from C1 upward, each playing to the next boundary. In slice mode the header grows a SENS cell (drag it and the sample re-slices on release) and a → MIDI chip that lays a clip replaying the slices in their original timing (sampler.slice_to_midi). Edit the map by hand on the wave: drag a marker to move it, ⌥-click empty wave to add one, ⌥-click a marker to remove it; the right-click menu offers the same plus Re-detect slices.

The keyboard widens past C5 so slices beyond the 49th still have a key. Every hand edit is one undo and lands in the agent's snapshot.

Drum Kits

Add track ▸ Drum Kit track (and the browser's Drum Kit instrument) creates an instrument track with a blank kit: the dock box shows sixteen empty pads from C1 (note 36) up, each named by its note, and you drop a sample on a pad to give it a sound (right-click ▸ Load sample… does the same). Its MIDI clip opens as a normal piano roll and folds to named drum rows the moment the first pad has a sound.

The agent's track.add_drum_kit seeds the 14-piece synthesised GM kit by default (kick 36, rim, snare, clap, low/mid/high toms, closed/pedal/open hats, crash, ride, tambourine, cowbell — level-balanced, generated locally, no sample downloads) so a composed beat sounds; kit:"empty" gives it the blank kit, and track.set_instrument {instrument:"drums", kit:"gm"} loads the GM kit onto an existing track.

• The dock's instrument box is the pad grid: click a pad to audition; right-click for Play / Load sample… / Clear pad; drop a sample on any pad to swap that pad's sound in place (keeping its note, gain, and pan). The agent shares this (sampler.replace_sound, sampler.add_sound, sampler.remove_sound, sampler.set_sound for gain/pan/one-shot/tune/choke — all addressable by note), and the audition too: a pad click is note.audition {track, note}, the same command the engineer uses to prehear a pad.
• The box shows one 4×4 page. A kit with more than sixteen pads shows its first fifteen and a +N cell; click it to open the Drum Rack editor, which pages through all of them.
• Pads and the drum roll are one instrument, two views. The grid stacks low notes at the bottom (kick bottom-left, ascending left→right then up — Drum-Rack style), mirroring the roll's pitch axis; the small corner number on each pad is its MIDI note, printed again on the matching roll row. Pressing a pad flashes its row in an open drum roll, and auditioning a row (click its name) flashes the pad.
• Drum tracks fold the piano roll to named rows, and can also hold step clips for the Step Grid.

The Drum Rack editor

Double-click the kit's instrument box (or run view.drum_rack) to open the Drum Rack in the mixer band — the same slot the piano roll and sampler editor use. Its title bar is the dock's: ⏻ at the left (bypasses the whole kit; the dock's kit box shows the same switch), ✕ at the right to close. It is the kit's full surface:

Every pad is a Simpler. Select a pad and press EDIT (or double-click the pad) to open that pad's own sampler editor in the band: envelopes, filter, LFO, START/END, reverse, warp, and velocity layers (drop a second sample on the pad's key, then set the layers' velocity ranges and crossfades) — everything in The Sampler above, per pad. The first time a pad is edited this way the kit is promoted to per-pad Simplers (its own undo step); closing the editor hands the band back to the Drum Rack. The agent addresses a pad the same way: sampler.set, sampler.crop, the layer commands, and view.sampler_editor all take note, and the snapshot's drum_rack pads carry a compact sampler block.

• A 4×4 pad page over all 128 notes. Pads ascend left→right then up (kick bottom-left on the default page). Filled pads wear their sample name; empty pads are named by note ("C1", "C#1"…) and every one is a drop target — drop a sample on an empty pad to add it there, on a filled pad to swap it in place.
• The bank mini-map on the left shows all 128 notes as 32 mini-rows of 4 (lit = a pad lives there) with the visible window outlined. Click or drag it to bank; the mouse wheel over the page banks a row at a time, and the pad that lights afterwards is the one under your pointer, not the one that was there before.
• The selected-pad strip on the right: the pad's name and note, a 2×2 LCD well of GAIN / PAN / TUNE / CHOKE cells (drag vertically, ⇧ for fine steps, double-click resets — one undo per gesture), a ONE-SHOT toggle (lit = a note-off never cuts the sample, the drum default), and PLAY / LOAD… / CLEAR. On an empty pad only LOAD… remains — everything that needs a sample, EDIT PAD included, is hidden rather than offered and then refused.
• TUNE re-pitches the pad's sample in semitones (fractional, ±48). CHOKE puts the pad in a choke group (OFF, G1–G16): a hit on any pad in the group instantly cuts every other pad still ringing in the same group — the classic open-hat/closed-hat behaviour, and the stock kit ships its three hats in G1. A choke cuts one-shots too. The cut lands exactly where the choking hit does, with a short fade so it never clicks — a hat struck a few milliseconds before its partner still sounds for those milliseconds, and a hit that lands together with (or after) the choking one is never cut by it.
• Clicking a pad auditions it and flashes the matching dock pad and drum-roll row.

Note names use one octave convention app-wide: middle C (MIDI 60) is C3, so the kick (36) reads C1 — the piano roll, step grid, and sampler editors all agree.

Per-pad device chains (the promoted Drum Rack)

Every pad can host its own effects chain. Ask the engineer to put an effect on one pad (or run pad.device_add {note, device} for one of Zammoth's own devices — comp, eq, saturation, … — or {note, name} for a scanned VST3/AU) and the kit promotes: each pad becomes its own chain — a note gate, its sample player, then that pad's effects — summed at the rack output. Everything you know keeps working: the same pads, the same editor, the same gain/pan/tune/choke cells, the drum roll's rows, drops and swaps — but now a compressor on the snare touches only the snare.

The promotion is one undo step — and so is an auto-promoting pad.device_add, so a single ⌘Z takes the whole thing back (drum_rack.promote runs the promotion on its own), old projects stay un-promoted until asked, and the selected-pad strip lists the pad's FX under PAD FX. One behavioural refinement comes with it: re-hitting a pad retriggers its voice instead of stacking tails.

The Arpeggiator

A real-time MIDI-effect device sitting before the instrument, transforming held notes (from your keyboard or a clip's held chord). Add it from the browser's MIDI FX section or the device dock's "+" menu. It needs no instrument in place: drop it into the empty space below the tracks and it makes a blank track of its own, then drop a Sampler, Synth or Drum Kit onto that track (or pick one from the dock's "+") and the instrument lands behind the arp. It works with every instrument — the synth, the Sampler, a Drum Kit, or a hosted synth plug-in. The one thing it refuses is an audio lane (a track carrying audio clips).

Its face: the ⏻ (bypass: held notes pass through untouched — the dock's Arp box shows the same switch), HOLD (latch) and RETRIG (off / note / bar) controls; the step lane showing exactly what it will play (a preview chord when idle; while playing it follows the playhead two bars at a time); a 12-entry STYLE rail — Up, Down, Up-Down, Random, Down-Up, Up & Down, Converge, Diverge, Pinky, Thumb, Played, Chord; RATE rails (1/1 to 1/32 × straight/dotted/triplet); and knobs GATE (0.05–1), OCT (1–8), SWING (0.5–0.75), REPEAT (1–8 ratchets), CHANCE (0–1, deterministic), VEL DEC (velocity decay ±1), SHIFT (±24 st); plus SCALE (12 scales) and KEY cells that constrain output to a key.

Each of those two is split down the middle — the left half steps back, the right half steps forward — and the half under the pointer lights, so you can see which way a click will go before you make it. KEY only means something while SCALE is on, so with SCALE off the KEY cell is drawn disabled and stops answering the pointer entirely, instead of taking clicks that changed nothing. Every control has a hover tip (the ? toggle or Preferences turns tips off).

It free-runs while the transport is stopped (so you can jam), follows the tempo map and the time signature (a tempo change mid-song keeps it on the bar lines; RETRIG Bar and the Random re-deal use the real bar, so 3/4 restarts every three beats), is fully deterministic on export, and has its own bypass that guarantees no stuck notes. Stopping the transport silences it: whatever the arp was sounding — a clip's chord, or keys you were holding — is released, and a chord held across the stop needs a re-press. Keys pressed after the stop arpeggiate as usual. (Separately, midi.arpeggiate can bake a pattern into a clip once, as notes.)