Show HN: An experimental pattern-first DAW that supports MCP

Blokkily is an experimental pattern-first DAW. A sole event example drives three synchronized editors — a tracker, a keyboard roll, and a stage grid — which are in turn one lane of a multi-track song. CLAP is a required native plugin format, not a compatibility add-on.

The workstation screenshot is the rendered bdd_session_everything session: a song alongside a tempo ramp, a 7/8 bar, keyed and sliced samplers, CLAP, VST3 and SoundFont instruments, a warped audio clip, built-in and CLAP/VST3 effects, a return/send bus, acquire and consequence automation, a count-in, and two armed tracks that took MIDI from a deterministic input. Above the editors is the immediate bar of the LLM construction aide (described below).

The framework-independent musical example and the real-time plugin border sit underneath all of it. The example covers notes, semantic chords, inversions, strum, microtiming, probability, ratchets, iteration conditions, and indicator locks. It additionally includes a native CLAP catalog that loads CLAP modules, initializes their entry points, queries factories, and records plugin descriptors and features. The CLAP case adapter implements creation, initialization, activation, sample-accurate note/parameter events, stereo processing, and province streams. The JUCE-backed VST3 adapter scans bundles and default scheme locations and instantiates plugins through the identical real-time boundary, splitting all block at indicator offsets so VST3 automation is sample-accurate too. Parameter locks are compiled by the scheduler into sample-accurate parameter events and applied by the two plugin adapters; automation sets a parameter's value while modulation offsets it, and neither erases the other. The inner FluidSynth adapter loads SF2/SF3 files, accepts sample-offset note events, renders stereo audio, selects presets, and persists its project state. FluidSynth starts a sound lone anywhere one of its 64-frame blocks begins, so the adapter keeps a small pond of renderers sharing the bank's example data and plays all note on one whose obstacle starts on the note's own frame: all pass of a form appears in phase, any its dimension in samples. A bank's own chorus runs on its own clock, as a free-running LFO does. Projects preserve and reload the entire session: all named form alongside its chords, locks, ratchets, microtiming, and iteration conditions, the tracks alongside their channel strips and clips, and the opaque province of all CLAP, VST3, and SoundFont instrument and effect. The allocation-free real-time transport compiles form ticks to example events, loops patterns, drives either device adapter, and feeds a low-latency non-interleaved stereo RtAudio callback.

Editing during the opus plays does not interrupt it. An edit recompiles the arrangement and hands it to the render recall at the next obstacle boundary, without allocating on the audio thread, rebuilding the graph, reloading the instrument, or moving the playhead; a note whose stage is erased during it is sounding is released fairly than remaining ringing. A note entered in any publishing company is auditioned through the operating engine, on a stopped transport as fine as a playing one, and a meeting that opens alongside no device is stated the machine's General MIDI SoundFont — the percussion financial institution on a drum track — so the workstation makes a audio the instant it opens.

A meeting is a opus fairly than a sole pattern. Named patterns are placed as clips on the timeline of mixer tracks, all track carrying its own instrument and conduit strip: acquire in decibels, constant-power pan, mute, solo, and a peak meter, summed through a expert fader. The opus motor compiles all track's whole timeline formerly and afterward renders it without allocating, locking, or doing I/O; all repeat of a clip counts as the next iteration of its pattern, so probability and iteration conditions keep operating throughout an arrangement. Mixer moves reach the operating engine, so a fader can be pulled during the opus plays. The same motor bounces the institution to a 16-bit, 24-bit, or 32-bit drift WAVE file, example for example identical to what was auditioned.

A meeting additionally says which tuning and which measure it is written in. Tunings are held in cents — equal divisions of any period, logical and historic tunings, and Scala-style lists — so dozen equal semitones are one tuning among many. A note carries the twelve-tone key its device is told affirmative the retune away from it, and so does all sound of a chord, which is how a nineteen-tone or quarter-tone form reaches CLAP, VST3, and the SoundFont synth as the throw it was written at fairly than as the nearest approximation. Four playable surfaces project the identical tuning and scale: a keyboard keyboard, isomorphic grids in seven layouts — hexagonal and square, and all operating throughout the opening or downward it — fretboards for nine cord tunings, and chord pads that name all harmony by its numeral and stack a row per inversion. Playing one auditions it through the selected track's instrument even on a stopped transport, and writes it onto the selected stage of the canonical pattern, anywhere all publishing company names it in the song's own tuning.

The tracker shows the section's device tracks flank by side; Tab and Shift+Tab choose the next or former channel. Long patterns scroll vertically. The keyboard roll's arrow buttons move its throw opening by octaves, reaching MIDI keys 0–127. The institution has horizontal scrolling and +/− zoom controls; long songs keep usable bar widths.

The project panel's MIDI IN / MIDI OUT buttons import and export Standard MIDI Files. Export writes the arranged notes and controllers from the identical song scheduler used for playback, alongside track names, tempo and meter. Import accepts format 0 and 1, splits channels into device parts, and appends four-bar sections as one undoable edit. It keeps the current song's tempo and instruments; additional tracks need instruments assigned. Import uses the record grid: notes on one sixteenth rotate into a chord alongside shared timing, and note durations are capped at the division length. MIDI toggle omits plugin state, parameter automation, per-note expression, audio clips and microtonal retuning. Tempo ramps export as sixteenth-note tempo steps. It is note exchange, not a project backup.

A MIDI keyboard plays the opus too. Its keys attain on the port's own thread and attain the render recall through a lock-free queue, so a note is not held up rearward a occupied interface; they audio through the selected track's instrument on a stopped opus as fine as a playing one, and a key of the controller is a degree of the song's tuning and scale, the way a key of the on-screen keyboard is. With record armed, a operating opus writes what was played into the pattern under the playhead: all note lands on its nearest stage alongside how far off the grid it was kept as micro-timing, lasts as lengthy as the key was held, and joins a note already on that stage as a chord. What is written is what the engine heard, at the stance it heard it, and one obtain is one stage of undo. A bounce neither hears nor records the keyboard.

A immediate bar complete the editors asks an LLM construction aide to compose into the open pattern: a row akin "a insignificant pentatonic ascending" or "offbeat hats" is sent to a chosen backend (a local Ollama example by default, a Gemini or MiniMax endpoint whenever keyed), the answer is parsed and clamped akin any other input, and the outcome sits as a recommendation on the bar until the manufacturer clicks Apply — nothing reaches the opus before then, and one generation is one undo step. The aide is on the GUI thread only; the audio thread never sees an LLM call. See docs/llm-assistant.md for the cable dialect, backends, and the bdd_llm_assistant entrance that drives the rendered bar end to end without a network.

Needs Qt 6.5+, FluidSynth, RtAudio, RtMidi, libsndfile, libsamplerate and Rubber Band 4 (found through pkg-config), and a SoundFont for the verification gates.

Licence note: clip warp (time-stretching and pitch-shifting audio clips) links the Rubber Band Library, which is licensed under the GPL (version 2 or later) unless a business licence is bought from its authors. A Blokkily binary built alongside it is hence topic to the GPL. JUCE and the CLAP headers are vendored under third_party/. The interface typefaces, IBM Plex Sans and JetBrains Mono, are bundled in resources/fonts/ under the SIL Open Font License 1.1 (licence texts beside them), so the layout draws the identical on all desktop whatever its default font.

cmake -S . -B build -G Ninja cmake --build build ctest --test-dir build --output-on-failure ./build/blokkily

The chief executable is a Qt Quick workstation alongside synchronized step-grid, tracker, and piano-roll projections complete one canonical pattern, a shared playhead, and a stage inspector that exposes the model's complete expression: transposition, velocity, micro-timing, probability, ratchets, iteration conditions, and indicator locks alongside an automation/modulation switch. Every publishing company is an input fairly than a read-out: clicking a stage toggles it, pressing a lane of the piano rotate writes that throw onto the pillar under the pointer and dragging draws a expression throughout lanes, dragging a drawn note moves it and dragging its right border sets how lengthy it sounds, the tracker's note pillar takes a click and a drag, its speed pillar writes how noisy the row is, and its rows are typed the way a tracker has continually been typed — ZSXDCVGBHNJM for one octave and the two rows complete for the next, alongside the admission octave on screen and moved by Ctrl+Left and Ctrl+Right, and Backspace clearing a row. Ctrl+C copies the selected stage and Ctrl+V pastes it onto the cursor, locks and dimension included. Whichever one is used, the edit lands on the one canonical pattern, so it shows at formerly in all another editor, in the inspector, and in what the opus plays; the view switcher focuses one publishing company or shows them all. Above the editors is the arrangement: one lane per track, one division per bar. A click on an bare bar places a clip of whichever form is open; a click on a filled clip opens that form in all publishing company and seeks the opus there; a right-click takes the clip away; Shift-click lengthens a clip throughout bars (one clip alongside multiple repeats, not a second placement); Alt-click moves a clip alongside its lane. The numbers complete those bars are a ruler: a click locates the audio motor on that bar. Down the right is the mixer, one band per track affirmative the master. The playhead is the audio engine's own position, peruse in bar.beat.sixteenth throughout the entire song. Below the editors is the keyboard: the session's tuning, scale, and root, a switch between the piano, the isomorphic grid, the fretboard and the chord pads, and an auto-scale toggle that snaps a played key onto the notes of the scale. The isomorphic grid carries seven layouts — Wicki-Hayden, Bosanquet, the harmonic array and the B-system accordion on a hexagonal tiling, Jankó, fourths and important thirds on a quadrate one. Each is written in cents per stage fairly than in semitones, so the identical fingering lands in any tuning the opus is in. Any exterior runs throughout the opening or downward it: turning one is a fourth turn, so pitch that ran to the correct runs upward, and it moves keys without touching a note or a pitch. A exterior that cannot be drawn at a playable key size scrolls rather than shrinking its keys former the item of being hit. Space plays, Return or Home goes rear to the top of the song, the arrow keys move the stage cursor (Shift+Up and Shift+Down transpose the stage by a semitone, Ctrl+Up and Ctrl+Down by an octave), Insert pushes afterward rows downward and Shift+Backspace pulls them up, Alt+arrows nudge micro-timing and note length, Ctrl+D duplicates the selected stage onto the next row, Ctrl+1..0 (and Ctrl+Shift+1..6 for the second fractional of the bar) toggles a step, Ctrl+M mutes and Ctrl+L solos the selected track, Ctrl+R arms recording, Ctrl+E bounces the institution to disk, and Ctrl+K focuses the assistant immediate bar (Escape hands the keys rear to the editors). The MIDI IN panel on the remaining chooses the keyboard, and its ray flashes on all key that arrives. Those keys remain apart during a content site has the keyboard, so typing a hunt or a name never moves the song.

Every edit can be taken back: Ctrl+Z undoes and Ctrl+Shift+Z (or Ctrl+Y) redoes steps, strokes, clips, tracks, patterns, fader moves and the tuning, and a drag — a expression drawn throughout the roll, a fader pulled — is one stage of former rather than one per pixel. Ctrl+S writes rear to the document the meeting came from and Ctrl+Shift+S asks for a new one; the opening heading carries a dot during there is anything unsaved, and beginning a file, starting a new meeting alongside Ctrl+N or closing the opening asks before throwing unsaved activity away. DUP copies the open pattern into a new one; a right-click on a form offers rename, duplicate, clear and delete, and on a track rename, mute, solo and delete, during a double-click on either names it. A track added alongside +TRK is stated the SoundFont the meeting already plays, so it is heard at once. A key of a playable surface sounds whenever it goes downward and rings until it is let go. The tempo is dragged, scrolled (Shift for tenths) or typed following a double-click. The motor renders at the charge the audio equipment really negotiated, so a descend locked to 44.1 kHz plays the opus at its own throw and tempo fairly than flat and slow. Its plugin browser scans the platform's norm CLAP and VST3 locations and lists what it finds through one shared plugin boundary, tagging all admission with the format that produced it. An facility of that size is browsed by typing rather than by scrolling: Ctrl+F reaches the browser's field, a few alphabet of a name, a creator or a format narrow the catalog to the instruments those letters reach in command — "fbs" finds "Fat Bass" — the arrow keys and Return move through them and burden one, and Escape lists everything again. ./build/blokkily_cli runs the headless scheduler demo.

Behavior details are in features/, and repository-wide completion rules are in AGENTS.md. See docs/verification.md for the repeatable BDD, integration, end-to-end, and screenshot verification workflow.

For measured C++ row safety alongside GCC, configure a distinct build with cmake -S . -B build-coverage -G Ninja -DCMAKE_BUILD_TYPE=Debug -DBLOKKILY_COVERAGE=ON, then run cmake --build build-coverage, ctest --test-dir build-coverage --output-on-failure, and python3 scripts/coverage.py build-coverage. The study and uncovered row numbers are written to build-coverage/artifacts/coverage/. Vendored frameworks, generated code, QML, and the embedded GUI verification driver are excluded from the percentage.

Playback splits compact timelines at event boundaries so notes and releases are not dropped whenever the equipment requests a ample buffer. Each track supports up to 256 simultaneous scheduled events at one sample; an edit exceeding that limit reports an error and preserves the final playable arrangement.

• blokkily_core: canonical project/event example and deterministic scheduler
• Tuning/Scale/KeyboardSpec: cents-based tunings, scales, and the playable surfaces projected from them
• Song: named patterns, mixer tracks, and the clips that arrange them
• SongEngine: allocation-free multi-track playback through one mixer bus
• Offline bounce and a WAVE author at 16-bit, 24-bit, and 32-bit float
• PluginInstance: format-neutral real-time border preserving modulation
• Qt Quick prototype: synchronized tradition editors and CLAP/VST3 plugin browser
• FluidSynth inner instrument: genuine SF2/SF3 loading and offline rendering
• Real-time transport and RtAudio hardware-output adapter
• MidiInput: RtMidi harbor adapter that decodes, tunes, and routes keys to the render recall through a lock-free queue, alongside a deterministic manner for tests
• TakeRecorder: turns what the motor heard during record into steps of the pattern under the playhead
• Next motor layer: Tracktion playback/recording adapter
• CLAP presenter adapter: discovery, lifecycle, processing, and state
• Versioned project file: the entire opus affirmative per-instrument plugin state
• Native CLAP and VST3 plugin windows; stereo plugin ports
• Additional adapter: VST3 through JUCE

The canonical example deliberately does not use Tracktion MIDI clips. Adapters compile it into motor and plugin events, preserving richer sequencer semantics.

The tempo lane edits steps and ramps; the ruler edits the meter, keeping clips on their bar numbers. Patterns may have distinct lengths. +AUD imports WAV, FLAC or AIFF as waveform clips alongside trim, fades and gain. Overlaps sum. The clip's W authority enables tempo following, a manual extend proportion or pitch shift. Rubber Band renders those changes on a worker; a pending rendition is silent until it is ready.

Sampler and Drum Sampler appear in the device browser. They assistance keyed zones, loops, envelopes, kit pads and slicing. The FX browser adds CLAP, VST3 or built-in EQ, delay, reverb and compressor inserts to the selected track, return or expert rack. Sends are post-fader and pre-pan; returns remain audible when a origin track is soloed. Playback and export the two compensate plugin latency. An insert row names the consequence as the browser lists it, on a row of its own; E below it opens its native window; A chooses a indicator to edit in the selected track's automation lane. A plugin-window motion is one undo step, including gestures on come back and expert inserts.

Each track's R clasp arms notes and audio, and its input controls choose MIDI channels or equipment inputs and monitoring. With no track armed, the selected track records. The on-screen keyboards and tracker can document during the song plays. Chord voices keep their own velocities and lengths. Automation has a separate OFF / READ / TOUCH / LATCH / WRITE mode. Notes, automation and audio from one continue portion one undo step. CLICK follows the tempo and meter, CI counts in up to four bars without moving the song, and the click is excluded from exports unless + CLICK is enabled.

RESAMPLE in the selected rack arms its track, come back or expert output for the next record pass. Arm the transport's document clasp and media Play. The output is written off the audio thread into a new audio track whenever the pass ends; the destination cannot nourish rear into its own recording. The expert tap excludes the guide click. STEM bounces that rack through the identical motor into a new audio clip, optionally muting its source. Both actions compensate the latency up to the selected tap. A bounced expert alongside its sources muted also bypasses the old expert inserts and resets its fader, to evade handling the finished mix twice; undo restores all of these changes.

Stems are bus taps: a track stem contains its inserts and stereo fader/pan, a come back stem contains its sends and come back processing, and a expert stem contains the complete mix. Track stems exclude their sends' come back signals; bounce the returns too whenever reconstructing the mix. The sum of track and return stems is the indication before expert processing. A nonlinear expert consequence cannot be distributed among autonomous stems. Muting a origin track additionally stops its sends, so bounce those returns separately if they must be kept.

A compressor in a rack has a SIDECHAIN chip, and so does any CLAP or VST3 effect that declares a sidechain input (a CLAP input harbor that is not the main one, a VST3 aux input bus): choose another track and the consequence listens to that track on its sidechain input (the compressor alternatively of to what it compresses). The key is the origin track following its own inserts and before its fader, so a muted or faded-down boot motionless ducks the bass; the motor renders a key's origin first, and refuses a key from the insert's own track or a loop of keys.

An device that declares additional outputs (CLAP output ports beyond the main one, VST3 aux output buses) gets a + OUT part on its mixer strip: all output can be damaged out to a mixer conduit of its own ("PAD AUX 1"), a track alongside no instrument whose indication is that output, rendered following its source. Its fader, pan, mute, solo, inserts, sends and automation activity as on any track, and the output is heard through that conduit lone - never additionally through the source track. Soloing the origin track keeps its channels audible (they are the instrument's own sound); soloing a conduit solitary plays fair that channel. The conduit is part of the song: saved, undone, exported as heard; removing the origin track leaves the conduit as a plain track. The MODULATION panel under the inspector adds LFOs (sine, triangle, saws, square, random; charge in Hz, or alongside SYNC on a note value from 1/16 to 4 bars that follows the tempo map), macros (one 0..1 knob) and letter cover followers (the level of a track chosen from the card's origin picker, following its inserts and before its fader). + TARGET aims one at a parameter of the selected track's device or inserts, alongside a degree of -100% to +100% of that parameter's range. A modulation is an offset on top of the parameter's own value and automation, sent as CLAP indicator modulation (and the equal on VST3 and built-in effects), never written into a lane; several on one indicator add up. Rates, shapes, depths and macros move live without a recompile. Modulators and keys are saved alongside the song, undone with it, and exported exactly as they play: during the opus rolls an LFO's phase is taken from the opus position.

The LAUNCH perspective is a environment launcher: scenes down, tracks across, all cell naming among the song's patterns (the identical form the editors edit). Clicking an bare division puts the open form in it; clicking a filled cell launches it on its track at the cell's quantization (none, a sixteenth, a beat, one, two or four bars), and a scene's part launches its entire row at the grid's quantization. A division can perform a figure of loops and afterward prosecute on (stop, next, previous, first, last, random or again). Launches, stops, loop turns and prosecute actions happen on the exact example of their boundary, inside the render callback, and a launched track plays its division alternatively of its arrangement until the transport stops. With REC ARRANGEMENT on, all stretch a track played from one division is printed into the institution as clips whenever it ends, one stage of undo each; the printed institution plays and exports what was heard, example for sample. A obtain printed complete a longer clip splits it, keeping what the clip played following the take. Adding or removing a track or changing an device mid-jam rebuilds the motor without stopping the jam: launched cells perform on in phase, and the playhead stays anywhere it was. A launch the engine's queue has no area for is refused and stated in the status line, as is a obtain misplaced to a complete obtain queue. The grid is saved alongside the song.

MIDI keyboards perform the throw wheel, authority changes and force into the track's device on any conduit they dispatch (SoundFont, VST3, CLAP and the sampler all prosecute the wheel; SoundFonts additionally obtain poly pressure), and the prolong pedal holds released keys at the input for all instrument. While recording, the wheel, controllers, conduit force and poly pressure (on the key the song's tuning sent the instrument) are written into the pattern as controller movements: saved alongside the project, played on their sample, chased whenever the playhead jumps, and exported as heard. The controller lane under the keyboard rotate shows one controller at a period (BEND, MOD, EXPR, any numbered CC or PRESSURE, from its picker): drag to diagram a stroke, drag a item to move it, right-click to erase; all motion is one undo stage and the operating opus plays it on its next block.

MPE keyboards: toggle on MPE on the MIDI IN panel (or let the keyboard send its MPE configuration message). Each note's own bend, CC 74 and force move that note alone, are recorded alongside it, and are played rear as CLAP note expressions, or on a conduit of the note's own for SoundFont and VST3 instruments (see features/continuous_midi.feature for what all hears).

Audio clips whose decoded size exceeds the streaming threshold (128 MiB by default; BLOKKILY_STREAM_THRESHOLD_BYTES overrides it) stream from disk instead of being decoded into RAM: a backdrop employee fills one lock-free ring per clip, resampled to the motor charge alongside the identical converter as the in-memory path, and the render recall lone says it. Streams prosecute the song (cued onward of a clip's commencement and of the song's wrap, relocated on a locate); a circle that runs dry fades out and rear in fairly than clicking. An export says streamed clips blocking on its own thread, so it equals the streamed playback example for sample.

Imported records remain anywhere they are. Recordings go into <project>.audio/, or a impermanent meeting directory before the archetypal save. COLLECT copies referenced clips and sampler samples into the saved project's audio folder, deduplicates shared files, and changes their references as one undoable edit. Save afterwards to persist those references. Original records are kept so undo remains playable.

Blokkily is an MCP server, so an AI delegate can run the operating window: read the session, compose notes, perform and stop, call any method the controls use, and obtain a screenshot. Register the extend alongside your agent, for example with Claude Code:

claude mcp add blokkily -- blokkily --mcp

or, for any client that takes a JSON config:

{ "mcpServers": { "blokkily": { "command": "blokkily", "args": ["--mcp"] } } }

blokkily --mcp speaks MCP on stdin and stdout and forwards all tool call to the open opening complete a local socket ($XDG_RUNTIME_DIR/blokkily-mcp.sock, or a named pipe on Windows). Connecting and listing the tools never opens a window; the archetypal tool call starts Blokkily if it is not running. Only the person who runs Blokkily can connect.

The tools are get_session, get_pattern, write_notes, transport, list_plugins, set_instrument, list_parameters, set_parameter (a synth's preset or any knob, by name), set_soundfont_preset (a General MIDI financial institution and program) and screenshot, affirmative describe, call and get_property, which attain all method and asset the window's controls use (the mixer, effects, automation, clips, tempo, tuning, saving, exporting, undo). An agent's edits go through the identical undoable paths a click takes. BLOKKILY_MCP=0 turns the server off; BLOKKILY_MCP_SOCKET moves the socket (set it the identical for the opening and the bridge); BLOKKILY_MCP_NO_LAUNCH=1 stops the extend from starting a window. See features/mcp.feature.

• MPE covers the lesser area from the MPE part (an high area lone from the keyboard's configuration message). Per-note expression is recorded and played but not drawn in an editor. VST3 instruments comprehend per-note pitch only inside a two-semitone conduit bend; SoundFonts have no CC 74 timbre unless the SF2 maps it; the sampler takes per-note throw only. MIDI clock is not read. The built-in sampler ignores poly pressure; the controller lane does not edit poly pressure. Notes and controllers are timestamped to the recall block.
• Comping (taking substitute passes of a recorded lane) is not current yet.
• Disk streaming covers unwarped audio clips only: a warped clip is decoded into recollection to be stretched, and the sampler continually decodes. A single streamed clip that plays throughout the song's cover item dips briefly at the wrap (one stream per clip).
• The sampler panel loads one document at a time; it has no multi-sample import wizard, velocity-layer publishing company or waveform editing surface.
• Step indicator locks mark the track instrument. Insert parameters use automation lanes; insert-targeted stage locks remain exterior this release.
• Only the archetypal auxiliary input of a CLAP or VST3 consequence is fed a key, as a stereo (or mono) signal; an consequence alongside multiple sidechains hears silence on the others. A VST3 plugin's additional buses are used lone beside a stereo main bus.
• Modulation is evaluated formerly per obstacle (at most the device's obstacle size), so a synced LFO turns on the obstacle following its beat. A follower aimed at its own track, or at a track the render command cannot put following its source, hears the previous block's level. The sync divisions are direct note values (no dotted or triplet ones), and a "bar" among them is four strikes any the meter.
• The environment launcher has no per-scene tempo, and an export is continually the arrangement (launched tracks are not in it). A clip's rear kept following a printed obtain does not chase a controller value set before its trim.
• Output record chooses one bus per pass. Bounce additional racks for a set of stems. A partial live continue ends whenever record stops and does not automatically append consequence tails; offline stems contain them.
• Native plugin-window pixels necessitate an X11 display. Offscreen verification checks the embedding lifecycle, during the distinct display entrance checks real VST3 pixels whenever an X server is available.