DAUx Plugin Platform

A native plugin platform for Futureboard (and future external use), built around a stable C ABI with language wrappers and an out-of-process host.

Three layers:

1. DAUx Plugin Core — the C ABI (daux/Core/include) + a C++ host-side helper library (daux_core).
2. Wrapper SDKs — write plugins in Rust (daux-plugin) or C#/.NET (Daux.Plugin); both call the same C ABI.
3. DAUxHost.exe — loads/runs .dauxplug out-of-process, hosts editors, scans metadata, and (planned) bridges to the DAW over IPC.

DAUx/
├─ CMakeLists.txt   # C/C++ build root (Core + Host + C++ examples)
├─ Cargo.toml       # Rust workspace root (SDK crates + Rust example)
├─ DAUx.slnx        # .NET solution (Daux.Plugin + Avalonia example)
├─ Core/            # C ABI headers + daux_core C++ helper lib
├─ Wrappers/
│  ├─ Rust/         # daux-plugin-sys (raw FFI) + daux-plugin (safe)
│  └─ DotNet/       # Daux.Plugin (NativeAOT bridge)
├─ Host/
│  ├─ DauxHost/     # DAUxHost.exe (load/scan/headless; editor+IPC skeleton)
│  └─ DauxScan/     # DAUxScan.exe (standalone scanner)
├─ Examples/
│  ├─ GainCppHeadless/    # reference C++ plugin (DSP only)
│  ├─ GainCppWin32/       # native C++ plugin + working Win32 editor
│  ├─ GainRustGpui/       # Rust plugin (+ GPUI editor scaffold)
│  └─ GainDotnetAvalonia/ # C# plugin + working Avalonia editor + preview
├─ Docs/            # ABI spec, SDK guides, host protocol
└─ Scripts/         # build.cmd / build.sh

Each language ecosystem has one root project you can open or build directly: the CMake tree for C/C++, the Cargo.toml workspace for Rust, and DAUx.slnx for .NET (dotnet build DAUx.slnx, or open it in Visual Studio / Rider).

Status: the audio path works end-to-end in all three languages. The C#/Avalonia example has a working editor (runnable via the preview app and reachable through the C ABI / DAUxHost --mode=editor); host-side window hosting and IPC are scaffolded with clear TODOs. See Docs/.

Build & run

One command (recommended)

Build everything (Core + host + all three example plugins) and verify with a scan:

daux\Scripts\build.cmd            # Windows  (all | core | rust | dotnet)

chmod +x daux/Scripts/build.sh
daux/Scripts/build.sh             # Linux / macOS  (all | core | rust | dotnet)

The scripts pick the right runtime identifier and library extension per OS, assemble the .NET Avalonia plugin as a bundle, and drop all plugins in build/plugins. The sections below show the equivalent manual steps.

Core + host + C++ example (CMake)

cmake -S daux -B build -A x64
cmake --build build --config Release

Produces build/bin/Release/DAUxHost.exe, DAUxScan.exe, and (on Windows) both build/plugins/Release/daux_gain_cpp.dauxplug and daux_gain_cpp_win32.dauxplug — each a .dauxplug bundle directory (Exec/<module> + manifest.xml).

build\bin\Release\DAUxHost.exe --mode=headless --plugin=build\plugins\Release\daux_gain_cpp.dauxplug

The GainCppWin32 example is a native C++ plugin with a working editor built on the Win32 toolkit through the C++ editor SDK. Open its window:

build\bin\Release\DAUxHost.exe --mode=editor --plugin=build\plugins\Release\daux_gain_cpp_win32.dauxplug --hold=10

Editors are framework-agnostic: the same plugin glue drives Win32, Cocoa, Qt, FLTK, X11, and more via ready-made adapters — see Native C++ SDK and GUI framework layer.

Rust example (cargo)

The Rust crates live in one root Cargo workspace (Cargo.toml): daux-plugin-sys, daux-plugin, and the gain-rust-gpui example. Build from the repo root — artifacts land in the shared target/:

cargo build --release -p gain-rust-gpui
Copy-Item target\release\gain_rust_gpui.dll build\plugins\daux_gain_rust.dauxplug

.NET example + Avalonia editor (NativeAOT)

All .NET projects are gathered in the DAUx.slnx solution — the Daux.Plugin SDK plus the example's three projects: Daux.Examples.Gain (plugin DSP + Avalonia editor), Plugin (the NativeAOT .dauxplug shell), and Preview (a runnable GUI harness). Restore/build everything at once, or open the solution in Visual Studio / Rider:

dotnet build DAUx.slnx -c Release

Preview the editor GUI without a DAW:

cd daux\Examples\GainDotnetAvalonia\Preview
dotnet run -c Release

Build the shippable plugin as a bundle (.dauxplug folder with Exec/ + Library/ + Resources/ + manifest.xml — see Packaging):

cd daux\Examples\GainDotnetAvalonia
dotnet publish Plugin\gain-dotnet-avalonia.csproj -r win-x64 -c Release
$pub = "Plugin\bin\Release\net8.0\win-x64\publish"
$bundle = "..\..\..\build\plugins\daux_gain_dotnet.dauxplug"
New-Item -ItemType Directory -Force "$bundle\Exec","$bundle\Library","$bundle\Resources" | Out-Null
Copy-Item "$pub\gain-dotnet-avalonia.dll" "$bundle\Exec\daux_gain_dotnet.dll"
Copy-Item "$pub\libSkiaSharp.dll","$pub\libHarfBuzzSharp.dll","$pub\av_libglesv2.dll" "$bundle\Library"
Copy-Item manifest.xml "$bundle\manifest.xml"

(The C++ examples are packaged as .dauxplug bundles by CMake — the Exec/module + manifest.xml assembly is automated in each example's CMakeLists.txt. The Rust example ships single-file. Both bundle and single-file .dauxplug load identically.)

(If publish reports 'vswhere.exe' is not recognized, run from a Developer PowerShell for VS — see Docs/plugin-sdk-dotnet.md.)

The editor is reachable through the C ABI; verify cross-language editor creation with:

build\bin\Release\DAUxHost.exe --mode=editor --plugin=build\plugins\daux_gain_dotnet.dauxplug

Verify all three

build\bin\Release\DAUxScan.exe build\plugins

Expected: three [OK] lines (C++, Rust, .NET), 0 failures — all loaded through the same C ABI by the same host.

Documentation

• Plugin ABI
• Parameters & Events (MIDI)
• Native C++ SDK
• Rust SDK
• .NET SDK
• GUI framework layer
• Automation
• DAUxHost protocol