Nebula 0.3.0-alpha.278: a faster live mixer, the whole MIDI hardware phase, and CLAP plug-ins

Six units landed together in 0.3.0-alpha.278 (3 November 2026): a faster live mixer, the whole of Phase 11 (MIDI controllers and hardware), and plug-in hosting. Every number below is a measurement from the build.

The live mixer uses your cores now

Playback used to render tracks one at a time, leaving most of the machine idle. Independent tracks now render at the same time, in waves that respect sidechain keys — a track that ducks against another one still renders after its source — and the mix is summed in exactly the same order as before.

That last part is the point: the mix is identical, sample for sample, at any thread count. A busy four-track project went from 422 ms to 139 ms (3.13x) per pass, with the peak unchanged.

Phase 11 is finished

MIDI learn, the CC maps, auto-detect and clock send were already there. What was missing was everything pointing the other way:

• Nebula can follow external gear. Pick a MIDI input as the clock source and the transport follows it — start, continue, stop, song position, and a tempo smoothed from the incoming ticks. If the clock stops, the app free-runs again instead of sitting still.
• MIDI Timecode in and out, including exact 29.97 drop-frame, with a frame-rate setting.
• Program change in (it selects a track's preset) and out (emitted when the preset changes), plus a per-track MIDI channel and a per-track output port — so a rig with drums on one interface and a synth on another no longer has to be split outside Nebula.
• MPE. Each note on its own member channel keeps its own bend, pressure and CC74 with its own voice, over a ±48 semitone range, in and out. It is off by default, so an ordinary keyboard behaves exactly as it did.
• Lua controller scripts. A sandboxed Lua host turns MIDI input into actions — through the same path MIDI learn uses, so a script cannot do anything a mapped knob could not.
• CC automation goes out. A track's volume and pan curves are emitted as CC 7 and CC 10 when they change, so a hardware synth follows your mix moves and not only your notes.
• Tighter MIDI timing. The drain interval is now configurable (the default is unchanged). At 1 ms, the measured mean departure wait dropped from 2.04 ms to 0.56 ms.

Plug-ins: CLAP hosting

Load and host CLAP plug-ins, with their parameters appearing as ordinary knobs — so they draw, save, automate and MIDI-learn like anything built into the app — their reported latency feeding delay compensation, and their state saved inside the project. A plug-in that crashes in its setup calls is contained rather than taking the app down with it.

VST3 is not supported, and cannot be. Its SDK is dual-licensed GPLv3-or-Steinberg-proprietary, and a GPL dependency cannot go into an FSL binary. The old dependency ledger's "VST3 SDK — MIT" line was simply wrong, and that is now recorded in the decision records.

CLAP was chosen because it is licence-clean (MIT headers, a C ABI with no runtime to link), has documented search paths, and ships an open validator.

An out-of-process bridge

Two kinds of plug-in can never be loaded into a 64-bit FSL program: a 32-bit one, and one whose licence the app cannot take on. Both are covered by a bridge that runs the plug-in in a process of its own.

The interesting constraint is that the audio thread may never wait. So it does not: it hands over block N and plays block N-1's answer. A slow or dead bridge therefore costs you a block of silence, never a glitch. A real 32-bit bridge program was built and driven by the 64-bit app with exact audio.

Also in this pass

• The MCP server (0.3.0-alpha.276) exposes 11 tools over the existing Control API, so an assistant that speaks the Model Context Protocol can open a project, set the tempo, play and stop, browse the instrument and device catalogues, and render — a render is one tool call that waits for the finished file, not a poll loop.
• A Control API fix (0.3.0-alpha.277): if a script disconnected before reading its answer, that answer used to be handed to whichever client connected next. Every message now carries the connection it belongs to.

Honest limits

• No real MIDI hardware was attached while this release was built. The driver paths are verified against test drivers and a compiler check — not against a drum machine on a desk.
• CLAP fault containment is Windows-only (it uses structured exception handling).
• A plug-in's own GUI is never shown. Its editor window is not offered at all; the only controls are the mapped knobs in Nebula's interface.
• Nothing in the app's audio path or its interface calls the bridge yet. The protocol, the host side, the bridge process and the 32-bit case are built and tested; wiring them to a track is the next step.
• The POSIX bridge transport is written but has not been run.
• macOS remains unverified — a build script exists, but there is no Mac in the toolchain.

The shared test tree passes 1340 of 1340 cases, with one skipped case that needs a 32-bit bridge path to be pointed at. The six non-Qt suites also run green on Linux from a clean build, at 1010 cases.