CamillaEQ

March 14, 2026 · View on GitHub

A browser-based graphical equalizer and spectrum analyzer for CamillaDSP.

CamillaEQ is a web UI that gives you direct, visual control over your CamillaDSP audio pipeline. Drag EQ tokens, watch the spectrum respond in real time, and tune your sound with immediate feedback.

Try It in Your Browser

There's a hosted demo at camillaeq.his.house/#/connect

Click Connect to play with a simulated CamillaDSP (includes spectrum analyzer)
Or enter your own CamillaDSP host (e.g., localhost) and control port (usually 1234)

If you don't have a spectrum service set up, you'll be in degraded mode—EQ editing works, but no spectrum overlay. See tools/README.md if you want to add spectrum.

CamillaEQ is a browser-based interface for controlling CamillaDSP, the powerful audio processing engine. You run it on a small device (like an Orange Pi or Raspberry Pi), and control it entirely from any browser on your network.

It's designed for people who appreciate good UX and want a tool that feels good to use. No configuration files, no command-line editing—just drag, adjust, and hear the difference.

Why This Exists

I'm not an audio engineer. I just wanted better sound for my daily work calls.

My laptop doesn't allow installing applications, and I'm on Zoom for hours every day. My microphone and room acoustics weren't great, and I couldn't fix it in software on the laptop itself.

The solution was simple: insert an EQ between the microphone and the laptop. CamillaDSP became the audio engine, running on a tiny Orange Pi Zero 2W. I needed a way to control it—something visual, responsive, and accessible from a browser.

So I built CamillaEQ: a UI focused on clarity, direct manipulation, and immediate feedback.

What Makes It Different

Visual feedback is everything.

Most EQ tools show you numbers and sliders. CamillaEQ shows you:

Real-time frequency response curves that update as you drag tokens
A spectrum analyzer overlay behind the EQ curve
Bandwidth markers and visual cues that help you understand what each filter is doing

You're not just editing parameters—you're seeing what the audio will sound like.

The Killer Features

Built-In Spectrum Analyzer

CamillaEQ includes a real-time spectrum analyzer that runs at ~10 Hz and displays your audio signal behind the EQ curve. This isn't a native CamillaDSP feature. It's a clever abuse of CamillaDSP's filter bank capabilities: we generate a log-spaced bandpass filter configuration and read the output levels. It's not perfect, but it provides immediate visual feedback while you're tuning. This makes EQ tuning feel alive. You adjust a band, and you see the spectrum change instantly.

Muting of filter bands

In CamillaEQ you can mute and unmute individual filter bands at any time, even when they're part of a filter group. You can also enable "solo" mode which will temporarily mute all bands except the one your're editing. This provides you with the ability to clearly identify the effect of a single filter on the whole.

Inspiration

CamillaEQ was inspired by CamillaNode and the work of its author. CamillaNode proved what was possible with a browser-based CamillaDSP interface.

CamillaEQ takes a different direction—focusing heavily on UX, visual interaction, and direct manipulation—but the inspiration and respect for what came before is real.

Who This Is For

🎧 End Users

You want to tune your audio and see what's happening. You don't need to understand DSP internals.

Start here: End User Documentation

Overview - What CamillaEQ does
Quick Start - Get up and running in 5 minutes
Spectrum Analyzer Guide - Understanding what you see
Troubleshooting - When things don't work

🛠️ Developers

You want to understand the architecture, extend functionality, or contribute.

Start here: Developer Documentation

Architecture Overview - Module responsibilities and boundaries
Runtime Topology - What runs where, and why
Data Flow - How config changes propagate
Frontend Architecture - Svelte, Canvas rendering, state management
Backend Architecture - Fastify, REST API, persistence
State and Persistence - State ownership model
Extension Points - How to add features safely

🚀 Power Users / Deployers

You want to run this on a headless device and make it reliable.

Start here: Power User Documentation

Deployment Models - Dev vs production, network topology
Linux Services - systemd installation and management
Headless SBC Deployment - Orange Pi, Raspberry Pi, resource tuning
Recovery and Backups - Disaster recovery procedures

Try It Now

Run It Locally

Prerequisites:

Node.js 18+
npm 9+
A running CamillaDSP instance (or use the included mock server)

Quick start:

# Clone the repository
git clone https://github.com/AlfredJKwack/camillaEQ.git
cd camillaEQ

# Install dependencies
npm install

# Start the development server
npm run dev

The UI will be available at http://localhost:5173

Try Without Real Audio Hardware

You can test the full UI locally without a real CamillaDSP device using the included MockCamillaDSP server:

# In a separate terminal, start the mock server
npm -w server exec -- tsx -e "import { MockCamillaDSP } from './src/services/mockCamillaDSP'; (async () => { const s = new MockCamillaDSP(); await s.start(); console.log('Mock CamillaDSP running: control=3146 spectrum=6413'); setInterval(() => {}, 1<<30); })().catch(e => { console.error(e); process.exit(1); });"

Then in the UI:

Navigate to the Connect page
Set Server to localhost
Set Control Port to 3146
Set Spectrum Port to 6413
Click Connect

You'll see a live spectrum analyzer and be able to adjust EQ bands, even without real audio passing through.

What You Get

Interactive EQ editor with draggable tokens and real-time curve rendering
Real-time spectrum analyzer (pre/post-EQ modes)
Pipeline editor for managing filters, mixers, and processors
Preset library with save/load functionality
Direct CamillaDSP integration via WebSocket (browser connects directly, no proxying)
Runs on low-power devices (Orange Pi, Raspberry Pi, etc.)
Fully tested (240+ tests, 80%+ code coverage)

Project Status

Current Release: v0.1.5

CamillaEQ is production-ready but still evolving. The core features—EQ editing, spectrum analyzer, preset management, and pipeline editing—are stable and tested.

What works:

✅ Full CamillaDSP control (config upload, volume, reload)
✅ Real-time spectrum analyzer with smoothing and averaging
✅ Interactive EQ with 7 filter types (incl. peaking, shelves, HPF/LPF, bandpass, notch)
✅ Pipeline editor (reorder filters, edit mixers, add/remove blocks)
✅ Preset library with search and keyboard navigation
✅ Auto-reconnect with exponential backoff
✅ Degraded mode (EQ works even if spectrum socket fails)

What's on the backlog: Check ou the enhancements tag from the issues for an up to date view of what's being considered for upcoming versions.

Intentional limitations:

Spectrum analyzer is approximate (bandpass filter bank, not FFT)
No multi-tab coordination (last-write-wins)
No authentication (designed for trusted LAN)

Architecture at a Glance

┌─────────────────────────────────────────────┐
│  Browser (your laptop, phone, tablet)       │
│                                             │
│  - Loads UI from CamillaEQ server           │
│  - Connects directly to CamillaDSP via WS   │
│  - Stores presets via REST API              │
└─────────────────────────────────────────────┘
         │                    │
         │                    │
    ┌────▼────────┐     ┌─────▼──────────┐
    │ CamillaEQ   │     │  CamillaDSP    │
    │ Server      │     │                │
    │ :3000       │     │  :1234 control │
    │             │     │  :1235 spectrum│
    │ (Node.js)   │     │  (Rust)        │
    └─────────────┘     └────────────────┘