simplyaudio

nexusopen source

Let an agent explore a plugin’s presets and parameters

Nexus is a VST3 / CLAP plugin host in Rust with a headless MCP server. An agent loads any installed plugin, steps through its presets, sets parameters, renders offline and gets back the audio and its levels. No GUI, no audio interface.

github.com/simply-audio/nexusMIT licensed.

Exploring a plugin with an agent

Point an MCP client at nexus-mcp and the agent can work through a plugin on its own:

  1. list the installed plugins and load one;
  2. list its presets and load them one by one, or list its parameters and set them;
  3. render a performance offline, notes, CC automation and parameter ramps included, at full CPU speed, and get back 32-bit float 48 kHz WAV with peak and RMS level, duration and a silence flag;
  4. snapshot the plugin’s saved state, change a parameter, and diff, to see what the change did to the state;
  5. save what it found as a preset.

It runs headless on macOS, Linux and in Docker, over stdio or streamable HTTP; on Linux it needs no ALSA, PulseAudio or PipeWire.

Tools

The same tools over MCP and REST:

  • list_plugins, load_plugin: discover installed CLAP and VST3 plugins in the standard paths and load any of them.
  • list_presets, load_preset, save_preset: browse, load or save .nexuspreset files.
  • list_params, get_params, set_params: inspect and set parameters.
  • render_audio: render an offline performance (notes, CC automation, parameter ramps) to 32-bit float 48 kHz WAV, with peak and RMS level, duration and a silence flag.
  • decode_state, edit_state, diff_state, snapshot_state: decode a plugin's saved state into structure, apply JSON-pointer edits, snapshot and diff it.

Quickstart

Build the MCP server:

cargo build --release --bin nexus-mcp

Add it to your MCP client (.mcp.json or claude_desktop_config.json):

{
  "mcpServers": {
    "nexus": {
      "command": "/path/to/nexus/target/release/nexus-mcp",
      "args": ["--stdio"]
    }
  }
}

Or serve it over HTTP, at http://127.0.0.1:9997/mcp:

cargo run --bin nexus-mcp -- --port 9997

Or open the GUI host (macOS):

cargo run --bin nexus-app

Overview

Nexus is built in layers. The foundation is a format-agnostic hosting engine that loads and runs VST3 and CLAP plugins behind a single interface, so callers never branch on the format. Everything else is built on that engine: a standalone app, a headless MCP server, a REST API, and a plugin that hosts another plugin.

Inside a DAW

nexus-wrap is a CLAP plugin with the engine inside: it loads another plugin and runs it in the DAW, its parameters automatable and its state open to the same tools.

Crates

nexus-host
The engine that discovers, loads and runs VST3/CLAP plugins. Fast offline rendering without audio drivers; no device I/O at all.
nexus-tools
Transport-agnostic tool traits, registry, state codecs, snapshot store and main-thread bridge.
nexus-mcp
Standalone MCP server exposing every tool over stdio or streamable HTTP.
nexus-rest
In-process REST API and a browser-based debug UI.
nexus-app
Standalone GUI host (macOS): egui UI, CPAL audio out, MIDI in, plugin browser and editor windows.
nexus-wrap
A CLAP plugin that hosts another plugin.

Under the hood

  • CLAP hosting through clack; VST3 hosting through the pure-Rust vst3 COM bindings, with no Steinberg SDK needed to host.
  • Realtime-safe processing: no allocation in the process call on either format; parameter changes, the transport and plugin notices are realtime-safe too.
  • MIDI 2.0 events to both formats.
  • The GUI is egui on wgpu (Metal); plugin editors are native child windows.
  • Stable Rust, edition 2024, rustc 1.90 or later.

Next

  • VST3 export of nexus-wrap through clap-wrapper, so one implementation ships in both formats.
  • Full VST3 / CLAP extension parity.
  • A diff-probing explorer: set a parameter, snapshot, diff, and map a plugin's state bytes to its parameters.