Plugboard pulls sources from every audio interface in your rack — plus Dante, other apps' audio, and its own signal generators — and lets you solo, group, sum, or duck them into listen mixes, sent to as many outputs as the show needs.
Every device in the rack is a pool of sources. Every listen mix is a bus. A bus can feed as many outputs as you route it to — one soloed channel can land on your headphones and a stream monitor at the same time.
A source is a channel on a device — or a whole interface, or a channel that isn't hardware at all. Each one is a tile you drag onto a bus.
Bind to a device UID + channel. Every interface opens independently — no macOS Aggregate Device, so no shared clock domain to fight.
Drag-select a range of ports to grab a stereo pair, or pull in an entire interface as one multi-channel source tile.
Patch any transmitter's channel straight off the network — not limited to one dedicated Dante tile per source.
Capture another running app's output as a source tile — a process tap, no virtual audio cable required.
Sine at a typed exact frequency, pink noise, or white noise — a line check without extra gear.
Unplug an interface and its sources show an offline badge and drop out cleanly. Replug it and everything reattaches, bound by device UID.
A bus is a destination, not a device. Give it a kind, add members, and route it to as many outputs as the moment calls for.
A named solo bus monitors a single source at once — tap a different source and it replaces the last. Run as many solo buses as you need, each routed to its own output.
Add or remove sources from a group freely. Useful for "everything in booth 2" or "every wireless" as one switchable listen point.
Every member sums in at unity — a clean, predictable mix with no per-member trims to lose track of mid-show.
A priority input — talkback, a page, a cue — attenuates a group or mix while it's active, fading in over an attack time, holding, then releasing back on its own.
Meters and analyzers are tiles, same as everything else — drop one on a source, a bus, or an output, and it reads that exact point in the signal path. Six display modes, patched in wherever you need eyes on the signal:
Live peak on every source, bus, and output tile — not just the ones you're actively soloing. Switch the scale per-meter between dBFS, dBu, and a classic VU ballistic.
K-weighted loudness per EBU R128 — momentary (400 ms) and short-term (3 s) — so you can watch level move in real time, not just after the fact.
Gated integrated program loudness plus a 4×-oversampled true-peak max — restart the measurement whenever the program does, so the number maps to something you can defend.
A real-time spectrum analyzer in fractional-octave bands on any tile — calibrated so full-scale pink noise reads flat.
Waveform for transients and clipping, phase/stereo image on the goniometer — the two views engineers actually reach for before trusting a fader move.
Frequency content over time, for chasing down a hum, a feedback ring, or an intermittent noise you can't quite place by ear.
Decode LTC off any input channel and read it right on the canvas alongside your meters — no separate timecode window.
Meters and analyzers patch in exactly like a bus does — as many as you want, on as many sources, buses, or outputs as you're tracking.
Sources, buses, and outputs are square tiles you place free-form on a snap grid. Wires show the routing at a glance — teal from a source into a bus, amber from a bus out to a destination.
Plugboard runs a tiny built-in web server that serves a read-only view of the canvas — the same tile layout, with live meters — so anyone on the network can check what's being monitored without touching the Mac running it.
The routing model and the real-time mix math are pure and unit-tested; the risky parts — device I/O, clock drift — are proven against real hardware before they touch the app.
Each interface opens on its own — no macOS Aggregate Device — so one device's clock never has to agree with another's.
A resampler trims each source against the target rate continuously, so nothing overruns or underruns over a long show.
A wait-free single-producer/single-consumer ring buffer is the only boundary between an audio callback and the mix engine.
A missing device or an out-of-range channel shows up as a diagnostic — it's never silently substituted or faked.
The whole patch — layout, wiring, levels — is one .plugboard file. Reopening rebinds a running engine live.
Pure Swift Package Manager. No third-party frameworks, no bundled runtimes — Core Audio and Foundation only.
Adding or pulling an interface rebuilds the engine live, debounced so one plug event doesn't cause a stutter.
The routing model, ring buffer, resampler, and drift controller are all proven with a deterministic test suite before they meet real audio.
Native macOS. Built on Core Audio, tested against real hardware, one release away.