A Dante AoIP software patchbay and DSP mixer for venue audio systems. Runs as a single binary — no separate web server, no database, no runtime dependencies.
This patchbay is named Minos after the judge in Dante Alighieri's Divine Comedy — the figure who stands at the entrance to the Inferno and routes each soul to where they belong. Just as Minos directs souls to their proper circle, this software routes audio sources to their proper destinations. All credit for the Dante protocol implementation goes to the creators of the Inferno AoIP project — this patchbay builds on their work.
⚠️ AI-ASSISTED CODE — READ BEFORE RUNNINGThis repository is substantially AI-assisted. The Rust source code, web UI, and configuration were written with the help of an AI coding assistant. Do not blindly run code in a production environment without understanding what it does. Review the source before deploying.
That said: this is being actively developed and tested against real Dante hardware. Phase 0 through Phase 3 are all complete and running on production hardware, including the full web UI, DSP panels, and scene management. "AI-assisted" doesn't mean untested — it means you should still read what you're running.
Minos accepts Dante audio streams as RX inputs, routes them through a configurable NxM DSP matrix, and transmits processed audio back onto the Dante network as TX outputs. A browser-based web interface provides:
- Full mixer/matrix UI — dark-themed SPA with Matrix, Mixer, Zones, Scenes, and Settings tabs
- Routing matrix — NxM crosspoint grid; route any source to any output zone; crosspoint level glow, DSP badges per input row, angled output column headers, zone colour grouping
- Per-input gain staging — vertical fader strips with mute, solo, and polarity; per-output horizontal fader strips
- Channel/output renaming — double-click any input or output label to rename inline; resizable input label column
- DSP panels — per-output parametric EQ, brick-wall limiter, compressor, and gate — opened via DSP badges on the matrix
- Scenes — save and load named routing + gain + DSP presets via scene REST API and Scenes tab
- Zone views — per-zone touchpanel UI for bar staff
- Live metering — WebSocket VU meters at 20fps with dB scale markings (0/−10/−20/−40 dBFS) on matrix rows, mixer fader strips, and zone views
- Authentication — PAM + JWT, role-based (admin / operator / zone staff)
Dante network
│
├─ RX: sources in (appliances, AVIO adapters, DVS PCs, any Dante TX)
│ ↓
│ [Minos — dante-patchbox]
│ NxM routing matrix + DSP
│ ↓
└─ TX: zone outputs (subscribed to by amp AVIO adapters / Shure MXWANI8)
Minos is part of the Inferno AoIP Ecosystem — a family of open-source Dante-compatible audio tools:
| Component | Name | Role |
|---|---|---|
| Appliance OS | Virgil | Headless Fedora IoT node — Spotify, AUX, iRadio → Dante |
| Patchbay | Minos | Dante routing matrix, DSP, zone control |
| Fleet management | inferno-central | Node discovery, health monitoring, OTA |
| Phase | Description | Status |
|---|---|---|
| Phase 0 | Routing matrix, gains, scenes, auth, web UI, metering | ✅ Complete |
| Phase 0.5 | Real Dante audio via Inferno AoIP, hardware testing | ✅ Complete |
| Phase 1 | Per-output DSP (3-band parametric EQ + brick-wall limiter), latency tuning, idempotent deploy script | ✅ Complete |
| Phase 2 | Zone ownership, PAM + JWT auth, role-based access, WebSocket live metering | ✅ Complete |
| Phase 3 | Scene save/load, named scenes, scene REST API | ✅ Complete |
| Web UI | Dark-themed SPA — Matrix, Mixer, Zones, Scenes, Settings tabs | ✅ Complete |
See docs/PROJECT.md for the full architecture and roadmap, and docs/AUDIO_ENGINE.md for the hardware-tested audio-path notes.
Minos includes a dark-themed single-page app served from the binary. Five tabs:
- Matrix — NxM crosspoint grid with per-row VU meters, crosspoint level glow (orange/amber), DSP badges (EQ / LIM / GATE / COMP) on each input row, zone colour grouping, angled output column headers, resizable input label column, and inline rename by double-clicking any input or output label.
- Mixer — per-input vertical fader strips (mute / solo / polarity) and per-output horizontal fader strips, both with live VU meters and dB scale markings.
- DSP panels — full parametric EQ, brick-wall limiter, compressor, and gate panels per output, opened via the DSP badges on the matrix row.
- Scenes — list, save, and recall named routing + gain + DSP presets.
- Zones — simplified per-zone view for bar staff.
Live metering runs over WebSocket at 20 fps with scale markings at 0/−10/−20/−40 dBFS.
# Build (stub audio — no Dante hardware required)
cargo build --release
# Run
./target/release/patchbox --config config.toml.exampleOpen http://localhost:9191 — log in with a Linux system user account.
To build with real Dante audio support (requires a PTP daemon plus cap_net_raw and cap_sys_nice on the deployed binary):
cargo build --release --features inferno
sudo setcap cap_net_raw,cap_sys_nice+ep ./target/release/patchboxcap_net_raw is required for Dante raw sockets; cap_sys_nice is required so the DSP callback can elevate to SCHED_FIFO.
See config.toml.example for a minimal configuration. Key fields:
rx_channels = 4 # Number of Dante RX inputs
tx_channels = 3 # Number of Dante TX outputs
zones = ["Bar 1", "Bar 2", "Stage"]
sources = ["Main Bar", "DVS PC", "Podium", "Spare"]
dante_name = "minos" # Dante device name as seen on network
dante_nic = "eth0" # Network interface for Dante
dante_clock_path = "/tmp/ptp-usrvclock" # Statime PTP clock socket
port = 9191Minos is a single Rust binary built on:
- axum — HTTP and WebSocket server
- inferno_aoip — Dante protocol implementation (feature-gated)
- rust-embed — web UI embedded in the binary
- PAM + JWT — authentication via Linux system accounts
The audio DSP path runs in the Inferno RX callback with no allocations and no locks — RT-safe by design. Config changes propagate via a lock-free triple buffer so the web API never blocks the audio thread.
The live Dante path was tuned and debugged on real hardware. The important fixes were: correct Dante 24-bit sample scaling, gap-free TX ring advancement, event-driven inferno wakeups, SCHED_FIFO callback scheduling, and a silence guard for inferno's external TX ring. See docs/AUDIO_ENGINE.md for the full chronology, root-cause notes, and current latency model.
Minos builds on the work of:
- lumifaza / inferno-aoip — the open-source Dante protocol implementation that makes this possible. All credit for the protocol reverse-engineering goes to its original authors.
- teodly / statime — the PTP implementation used for clock synchronisation.
- legopc / inferno-aoip-releases (Virgil) — the appliance that provides Dante audio sources this patchbay routes.
AGPLv3 — see LICENSE.