yapf

An audio plugin framework. One C++ processor class compiles into VST3, AU, CLAP, LV2, WebAssembly for a browser host, and a standalone application through a single CMake function. A seventh target is yapf's own format, where the plugin loads into a capability-secured runtime instead of a host. Version 0.1.0. Proprietary, copyright 2026 Quilio.

Build

Same gain plugin, yapf against stock JUCE 8.0.12, interleaved medians on one development Mac. Cold build with caches off: JUCE 19.8 s, yapf 7.6 s, 2.6x. Second tree with a shared cache: JUCE 20.7 s, yapf 4.9 s, 4.3x. Edit one source and rebuild: JUCE 2.22 s, yapf 0.31 s, 7.1x. The second-tree row has been run four times on this machine and come out at 4.8x, 3.4x, 1.9x and 4.3x, because a wall clock reads whatever else the machine is doing. The mechanism under it does not move: a second build tree recompiles zero framework translation units and serves 459 objects from the cache, while the JUCE second tree costs what its first cost.

Runtime

Realtime multiples on one core, Release, 10 seconds per primitive at 48 kHz. Full DSPModule chain of 14 modules at 8x oversampling: 34.9x. One-second impulse response convolver: 93.9x. 8x oversampled waveshaper: 318.1x. Reverb 1524.3x, ladder 1161.0x, Lagrange delay 4011.5x, biquad 6769.9x, state variable filter 7205.5x, TPT filter 8332.2x, one pole 14043.3x. The first three repeat to within a tenth across runs. The rest do not: one_pole came out at 4384x and then 14043x on consecutive runs, because at that speed the measurement reads the machine rather than the filter.

Determinism

A seventeen-case golden corpus is byte-exact within one architecture, across both slices of a universal build, with the x86_64 slice checked under Rosetta. Across architectures it agrees within 4 ulps plus a 1e-6 floor. arm64 fuses a multiply and an add into one instruction where baseline x86_64 has nothing to fuse into, and the platform implementations of sinf, cosf, tanhf, expf and powf each disagree with themselves between the two by a single ulp on some inputs.

Verification

The gate runs 130 stages. 14 unit suites, 9 of them under address and undefined behaviour sanitizers and 3 more under ThreadSanitizer. A 17-case golden corpus. 36 Linux artefacts cross-compiled with zig, and a Windows cone that compiles and links. A locked public surface of 1308 declarations across 92 headers, covering the runtime's C ABI and the capability names as well as the framework, plus the CMake keywords and the saved state format. Six stages deferred by default: pluginval at strictness 10, auval, clap-validator and the SDL2 demos. Every stage was committed alongside a deliberate break that made it fail.

The yapf format

The other six shells put a processor inside somebody else's host. The seventh is a host: modules load into a runtime, register services and reach each other by message. There are 21 example modules, and a host running them in order leaves a project of 7 tracks, 3 automation lanes and 2 rendered stems; six blueprint workflows drive the same runtime end to end. A module receives a view of the runtime rather than the runtime itself, and every call it can make goes through that view. The grant it holds is the overlap of what the host offered and what its own manifest declared, so a generous host cannot widen a plugin past its own declaration. The capability an action needs is read off the action's name against a closed vocabulary of 30, and a module without it is refused with YAPF_ERR_DENIED before the target is found.

Findings

Four defect classes that passed pluginval at strictness 10, auval and clap-validator. A guard present in two plugin shells and missing from the third, found by comparing VST3, AU and CLAP line by line, which produced around fifteen defects. An allocation trap linked into 2 test suites out of 12 while the README described it as armed in CI. Five CMake paths naming the top of the build where they meant this tree, invisible until a consumer project outside the tree read them out of its own directory. An infinite table column weight producing a NaN that every later column edge inherits, which makes the backend drop the draw call and render an empty panel with nothing logged.

The session

Twenty one modules run in order leave a project of 7 tracks, 6 clips, 3 automation lanes, 2 rendered stems and 6 graph edges, built from 68 messages. Every one of those figures is pinned by ci/test_runtime_demos.sh, so this page and the binary cannot disagree without a stage going red.

A worked example

One of the six blueprint workflows, run headless: yapf_daw_blueprints collab-handoff. It loads six modules, scans the session, explains the routing dependencies, balances rough levels, writes a vocal ride automation lane, imports a reference track and exports collaborator stems. What comes out is a preview mix and two stems of 960,001 samples each, peaking at 0.591, 0.267 and 0.187, a session report describing 5 tracks, 5 clips, 3 automation lanes, 2 rendered stems, 5 graph edges and 49 messages, and a manifest naming 4 deliverables and the 5 checks that ran. ci/test_handoff_artifacts.sh runs the same binary, opens the audio rather than counting it, and pins every one of those figures.

Session replay

The same session is published message by message at /yapf/session: ten modules, thirty four messages, the capability each one needed and whether it was granted. Five runs of the same host, each withholding one capability, so the refusals and the smaller project that follows are the consequence of that one withheld word. Recorded by the runtime rather than reconstructed.

Capability

The vocabulary is 35 names and closed: the derivation returns one of them or nothing, and never composes a name no host can grant. It reads the capability off what a message asks for and what it asks of, because an action carries its noun most of the time and when it does not the thing it is sent to does. A module holds the overlap of the host's offer and its own manifest, and neither side widens the other: a capability the manifest does not name is dropped even when the host offered it, and a module that declares nothing, or registers no manifest at all, holds nothing. A handle can be made weaker, and the check walks the chain, so a derived view cannot name what the view it came from lacks; taking a capability off a module refuses it in every view standing on that module. Refusals are recorded with the module, the action and the capability. The runtime also names the actions it saw that needed nothing.

Capability findings

Capability security was declared everywhere and enforced nowhere. Every plugin listed the capabilities it needed and no plugin was ever refused anything: the send path had no caller identity and the loader threw the declared list away, while the security document said the runtime enforced at every privileged operation. Turning it on refused five actions across four plugins, each one doing more than its manifest admitted. Then a second gap: the capability an action needs is read off its name, so a noun outside the guarded set derives nothing, which is right for a plugin messaging its own objects and wrong for a kernel service that acts with the host's authority. Nine actions were in the second case, so a plugin could render a file, edit a clip, read a mix and move the playhead holding no capability at all, because the nouns were called synth, pianoRoll, analysis and selection rather than audio, midi and project. A gate now reads every action the examples send back through the derivation.

Later findings

The locked public surface did not cover the runtime, which is the ABI the format exists for. Seven public functions and a struct were added to it in one afternoon and the gate reported the surface unchanged, because it read only the framework's C++ headers and the runtime is C. The lock now covers the runtime's declarations and the capability names. Separately, three readings of the sources each missed a different way of sending a message. The gate that checks every action derives a capability worked by grepping for one helper; a plugin can also build a message by hand, and four plugins define a private copy of a second helper. Each miss left actions governing nothing, and one of those misses caused the least-authority lint to strip a capability a plugin was using. The runtime now records the actions it saw that needed nothing, because it is the only thing that sees a send however it was written. Separately, a verb with no noun governed nothing, and the holes were being patched one at a time: seek, play, stop, state and autoplay were each aliased by hand as somebody noticed them. The derivation now takes the target as well, so state sent to a transport reads a transport and the same verb sent to a piano roll reads MIDI.

LV2

The LV2 shell in the vendored fork had never been compiled: it named a macro that does not exist, so nothing built it, and its run() copied input to output instead of calling the processor. It also kept one pointer per audio bus while LV2 connects one buffer per channel, so a stereo bus overwrote its own first pointer. It is now a real shell with a per-channel port model, MIDI atom parsing and transport, and a Turtle generated from the same declarations the shell walks. Four bundles build with 61 ports between them. ci/test_lv2.sh reads the port layout out of the Turtle rather than assuming it, renders a known gain through the effect and plays a note into the instrument. No LV2 host has loaded it yet, which is the same standing the other formats have before a DAW sees them. LV2 is refused under a cross toolchain, because its Turtle is written by a generator that links the plugin and a cross build cannot run what it just built.

WebAssembly

WCLAP is the same plugin compiled to wasm32 for a browser host. The shell was vendored and nothing built it, so a stage type-checked it and docs/parity.md called it unproven. Four plugins compile to WebAssembly now. The format asks that the module export clap_entry, export malloc, and import or export memory, and none of that follows from a link succeeding: clap_entry is a data symbol no code references, so the linker collects it, and the first build here was 588 bytes and linked without a warning. The gate decodes the module's import and export sections and reads the answers off the table, which is what a host does. A host in the page loads one now: runtime/web/wclap_host.c drives the CLAP entry, factory and process from inside the module, and quilio.dev/yapf/live runs all three through Web Audio.

Limits

macOS carries VST3, AU, CLAP, LV2 and Standalone with a GPU editor, and is the only platform with a rendered UI. Linux is CLAP only and headless. Windows compiles and links and has never been executed. No plugin has been loaded in a DAW: validators pass and the probes drive the three host APIs directly, and neither is the same as a DAW agreeing. A native module loaded in-process shares the host's address space, so the capability check governs what a module can ask the runtime to do; what it can reach in memory is a separate question and this does not answer it. Separate address spaces are what the WebAssembly shell gets from the browser. There is no ABI compatibility, because yapf compiles into the plugin rather than shipping beside it, so a new version means a rebuild. Proprietary licence, copyright 2026 Quilio, all rights reserved; five third-party projects are compiled in and every bundle carries their notices.