FreeEQ8 / ProEQ8 — Lock-Free, Allocation-Free Parametric EQ Architecture Using Simper SVF (Open Source Core)
Hey everyone,
I wanted to share a project I’ve been building called FreeEQ8 (with a commercial counterpart, ProEQ8).
The goal was to explore what a modern JUCE-based EQ architecture looks like when it is designed around:
- strict real-time safety
- lock-free concurrency
- allocation-free audio paths
- stable high-frequency filter behavior
- and deterministic, explainable DSP assistance
Repository:
https://github.com/GareBear99/FreeEQ8
Technical paper / architecture breakdown:
https://github.com/GareBear99/FreeEQ8/blob/main/PAPER.md
Core DSP Architecture
The filter engine expands beyond the classic RBJ biquad implementation with a Simper-style State Variable Filter (SVF) topology using trapezoidal integration and analytically pre-warped cutoff mapping.
The motivation is to address well-known high-frequency cramping behavior in standard biquad designs near Nyquist, especially in bell and shelf filters at higher sample rates.
At 44.1kHz, this distortion becomes increasingly noticeable in narrow high-frequency boosts. The SVF approach preserves:
- frequency symmetry
- Q stability under modulation
- smoother automation response
- more consistent high-end behavior without oversampling dependency
Supported filter types:
- Bell
- Low / High Shelf
- Low / High Pass
- Band Pass
- Notch
- All Pass
Design characteristics:
- double-precision internal state
- trapezoidal integrators
- stable coefficient modulation
- low-cost recalculation per parameter change
Real-Time Safety & Concurrency Model
A major focus of the project was enforcing strict separation between audio, UI, and background systems.
Key design choices:
- processBlock() is fully allocation-free
- all runtime objects preallocated in prepareToPlay()
- lock-free SPSC triple-buffer system for spectrum + UI data (writeSlot / midSlot / readSlot)
- audio thread never blocks on UI thread
- linear-phase FIR kernel rebuilds moved to a dedicated worker thread
- async callbacks protected using weak references
The goal is deterministic behavior even under heavy UI interaction (fast node dragging, spectrum repaint bursts, automation changes).
Dynamic EQ + Semantic DSP Layer (Experimental)
The project also explores deterministic assistive DSP systems instead of black-box ML approaches.
Current modules:
- ResonanceDetector.h
- IntentMode.h
- FrequencyExplainer.h
These operate on spectral analysis data to:
- detect resonant or problematic frequency regions
- classify mix issues (mud, harshness, sibilance, etc.)
- adapt detection behavior based on intent profiles
- provide explainable feedback directly tied to DSP behavior
The goal is interpretability over automation.
Performance Work
Recent optimization focus:
- removing expensive transcendental calls from hot paths where possible
- caching Match EQ gain computations after analysis
- reducing per-sample coefficient overhead in dynamic mode
- improving stability under dense multi-band sessions
The SVF path is designed for predictable scaling across real-world DAW sessions.
Recent Coverage
FreeEQ8 was recently featured on rekkerd.org, which was a nice milestone for the project and helped bring more visibility to the open-source DSP direction.
Feature article:
https://rekkerd.org/free-freeeq8-parametric-eq-effect-plugin-by-gary-doman/
This feedback has been encouraging because it reflects interest not just in the plugin, but in the underlying architecture:
- realtime-safe DSP design
- lock-free JUCE systems
- explainable processing
- transparent engineering approach
Feedback Welcome
I’d really appreciate feedback from other JUCE / DSP developers on:
- SVF vs RBJ tradeoffs
- lock-free concurrency edge cases in real plugin hosts
- SIMD/vectorization strategies for multi-band EQs
- DAW compatibility issues
- realtime safety blind spots
The architecture is still evolving, but it’s stabilizing enough now for deeper critique.
Thanks for reading.
— Gary Doman / GareBear99
Top comments (0)