DEV Community: Gary Doman/TizWildin

An Architectural Blueprint on Gendered Life in Biology

Gary Doman/TizWildin — Tue, 02 Jun 2026 03:08:12 +0000

Thesis

The popular social media line that "the fight-or-flight response was only tested on men" is a simplification with a kernel of truth, but it’s heavily exaggerated. The original “fight-or-flight” model comes from Walter Cannon in the early 1900s. Later, researchers like Shelley Taylor proposed “tend-and-befriend” (early 2000s), arguing that under certain conditions—especially in caregiving or social bonding contexts—some stress responses may bias toward affiliation and calming behaviour. That is not exclusive to women, and it’s not a hardware replacement for fight/flight; it’s an additional layer of behaviour that shows up variably across people and situations.

Oxytocin is also not a “female-only” or “community bonding switch.” Both sexes produce it, and its effects depend heavily on runtime context (stress level, social environment, prior learning, and real-time interactions with hormones like cortisol). The nervous system isn’t running a gendered operating system—it’s a shared biological system with probabilistic differences influenced by both biology and environment.

It's highly analogous to audio trapezoidal topology calculus graphing. When modeling a filter circuit in digital signal processing, you utilize mathematical constant formulas. The underlying math—the structural transfer function—stays exactly the same:

$$H(z) = \frac{b_0 + b_1 z^{-1} + b_2 z^{-2}}{1 + a_1 z^{-1} + a_2 z^{-2}}$$

No matter what coefficients or variables you plug into the system, the formula is identical. The features from the source code are simply presented differently on the frontend development due to physical as well as environmental constraints in the runtime, which is vastly more apparent in Flatworm mating biology. These social media explanations lately are oversimplifying a probabilistic, context-dependent stress response system into a binary sex-based operating model, which is entirely unsupported by neuroendocrinology.

The analogy I’m trying to make isn’t that biology is literally software; it’s that people are treating it like a fixed, dual-booting “female vs male operating system” when it’s actually a dynamic adaptive system. DNA isn’t a static blueprint that deterministically outputs behavior like HTML rendering a page. Gene expression is regulated continuously through environment, hormones, development, and feedback loops (epigenetics, endocrine signaling, neural plasticity).

So the “source code $\rightarrow$ runtime output” framing is already an oversimplification. Same with the stress response: the underlying circuitry—the HPA axis and the autonomic nervous system—is shared. What varies is internal modulation and probability distributions under different contexts, not separate gendered systems.

When social media turns “tend-and-befriend” into an isolated female operating system, it’s compressing a highly conditional, context-dependent behavioral tendency into a binary model that neuroscience doesn’t actually support. The model being used online is structurally too rigid for what biology actually is.

That is precisely why you can introduce hormone blockers to shift an endocrine system's parameters and move toward a different steady state—it's just not the exact same end-equation probability stack both ways. That asymmetry is what people are observing. 'Social Media' seems to be taking the entropy out of continuity and using the isolated output rather than looking at the overarching formula.

References & Readings

For a direct look at the "runtime compilation" aspect of biological systems architecture, look to the expanding domain of systems biology:

The Paper: A recent paper titled Epigenetic Intelligence: How Organisms Track Their Environment Through Molecular Memory (2026) uses mathematical simulation and stochastic modeling to demonstrate how organisms rely on continuous environmental feedback loops to dynamically remodel their epigenetic state. It frames the genome not as a static page, but as an interactive system actively managing environmental "stress" by adjusting its operational parameters on the fly.
The Visuals: To see a clean breakdown of how this operates at the molecular level, review Chromatin Biology: Epigenetics and the Regulation of Gene Activity, which demonstrates how chromatin structures actively alter gene expression in real-time based on environmental inputs.

The Translation Guide

When analyzing biological networks from an engineering mindset, you can seamlessly translate architectural vocabulary into its biological counterparts:

Systems Engineering Concept	Biological Equivalent
Core Mathematical Formula	The Genotype / Conspecific Baseline Architecture
Parameter & Variable Changes	Environmental Inputs / Endocrine Signaling
The Rendered Frontend Graph	The Reaction Norm of the Phenotype

Biology discovered dynamic runtime scaling long before we did; systems biologists are just the ones using software and engineering principles to finally map it out accurately.

More Here:

Gary Doman/TizWildin

Jun 2

Flatworms & The Hidden Architecture Behind Biology: An Honest Structured Blueprint on Gendered Life

#discuss #architecture #math #science

Comments

5 min read

Flatworms & The Hidden Architecture Behind Biology: An Honest Structured Blueprint on Gendered Life

Gary Doman/TizWildin — Tue, 02 Jun 2026 02:45:25 +0000

Flatworms are simultaneous hermaphrodites; each individual carries both male and female reproductive organs. When two meet to mate, they fence with their male organs—each trying to inseminate the other—because being the female is costly. The winner gets to be the male. The loser gets pregnant.

Both individuals want to be the male. Only one gets to be. They fight for the right.

Pseudobiceros hancockanus and related polyclad flatworm species—colourful marine flatworms found in tropical reef systems—are simultaneous hermaphrodites. When two individuals meet for mating, a bizarre competition begins: penis fencing. Each flatworm extends its male reproductive organ—a two-headed, stylet-tipped structure—and attempts to pierce the skin of the other and inject sperm, while simultaneously manoeuvring to avoid being pierced itself.

The contest: Typically lasts 10–60 minutes.
The loser: The individual that receives the sperm injection. The sperm is injected hypodermically—directly through the skin, not through a dedicated opening—and must then migrate through the flatworm's tissue to reach the eggs.
Why both individuals want to be the male: The energetic cost of being female is substantially higher. Carrying and developing eggs requires significant metabolic investment. Being the male costs almost nothing beyond the mating event itself.
The outcome: The winner gets to fertilise the other and bear no energetic reproductive cost. The loser must produce and carry eggs.

Why both individuals want to be the male: the energetic cost of being female is substantially higher. Carrying and developing eggs requires significant metabolic investment. Being the male costs almost nothing beyond the mating event itself.

The winner: gets to fertilise the other and bear no energetic reproductive cost. The loser: must produce and carry eggs.
The "fencing" is not metaphorical — it is a genuine combat in which manoeuvring skill, stamina, and the ability to direct and deflect the stylet determines the reproductive outcome.

When a reproductive system creates a competitive conflict between two partners of the same species — in which both fight to achieve the same role — does that make the flatworm's mating system the most honest expression of the sexual conflict theory in biology?

Thesis

The “fight or flight was only tested on men” line is a simplification with a kernel of truth, but it’s exaggerated. The original “fight-or-flight” model comes from Walter Cannon in the early 1900s. Later, researchers like Shelley Taylor proposed “tend-and-befriend” (early 2000s), arguing that under certain conditions - especially in caregiving or social bonding contexts - some stress responses may bias toward affiliation and calming behaviour. That is not exclusive to women, and it’s not a replacement for fight/flight; it’s an additional layer of behaviour that shows up variably across people and situations.

Oxytocin is also not a “female-only” or “community bonding switch.” Both sexes produce it, and its effects depend heavily on context (stress level, social environment, prior learning, hormones like cortisol, etc.). The nervous system isn’t running a gendered operating system - it’s a shared biological system with probabilistic differences influenced by biology and environment.

It's like my audio trapezoidal topology calculus graphing, I'm using mathematical constant formulas, so the math stays the same.. No matter what I plug in, the formula is the same. The features from the source code are just presented differently on the frontend development due to physical as well as environmental constraints in the runtime, which is vastly more apparent in Flatworm mating biology. These social media explanations lately are oversimplifying a probabilistic, context-dependent stress response system into a binary sex-based operating model, which is not supported by neuroendocrinology.

The analogy I’m trying to make isn’t that biology is literally software, it’s that people are treating it like a fixed “female vs male operating system” when it’s actually a dynamic adaptive system. DNA isn’t a static blueprint that deterministically outputs behavior like HTML rendering a page. Gene expression is regulated continuously through environment, hormones, development, and feedback loops (epigenetics, endocrine signaling, neural plasticity). So the “source code → runtime output” framing is already an oversimplification. Same with stress response: the underlying circuitry (HPA axis, autonomic nervous system) is shared. What varies is modulation and probability distributions under different contexts, not separate gendered systems. So when social media turns “tend-and-befriend” into a female operating system, it’s compressing a highly conditional, context-dependent behavioral tendency into a binary model that neuroscience doesn’t actually support. That’s my point - not that people are identical, but that the model being used is structurally too rigid for what biology actually is.

Thats why you can take hormone blockers and become a women, and vice versa, it's just not the same end equation probability stack both ways. Thats what they are seeing. 'Social Media' Seems to be taking the entropy out of continuity and using the output rather then the formula...

References & Readings

For a direct look at the "runtime compilation" aspect as mentioned, there is fascinating research explicitly treating epigenetics as a system of real-time data tracking.

The Paper to Read: A recent paper titled Epigenetic Intelligence: How Organisms Track Their Environment Through Molecular Memory (2026) uses mathematical simulation and stochastic modeling to demonstrate how organisms rely on continuous environmental feedback loops to dynamically remodel their epigenetic state. It frames the genome not as a static page, but as an interactive system actively managing environmental "stress" by adjusting its operational parameters on the fly.

The Translation Guide

Next time you are debating this, you can seamlessly translate your architecture vocabulary into biological terms:

Core Mathematical Formula → The Genotype / Conspecific Baseline Architecture

Parameter/Variable Changes → Environmental Inputs / Endocrine Signaling

The Rendered Frontend Graph → The Reaction Norm of the Phenotype

Biology discovered dynamic runtime scaling long before we did; systems biologists are just the ones using software and engineering principles to finally map it out accurately.

To see a great visual breakdown of how this works at the molecular level, take a look at Chromatin Biology: Epigenetics and the Regulation of Gene Activity, which visually demonstrates how chromatin structure alters gene expression in real-time based on environmental inputs.

The Translation Guide

When analyzing biological networks from an engineering mindset, you can seamlessly translate architectural vocabulary into its biological counterparts:

Systems Engineering Concept	Biological Equivalent
Core Mathematical Formula	The Genotype / Conspecific Baseline Architecture
Parameter & Variable Changes	Environmental Inputs / Endocrine Signaling
The Rendered Frontend Graph	The Reaction Norm of the Phenotype

Biology discovered dynamic runtime scaling long before we did; systems biologists are just the ones using software and engineering principles to finally map it out accurately.

Lock-Free Dynamic EQ Architecture: A Production-Grade SVF Implementation in JUCE/C++

Gary Doman/TizWildin — Mon, 01 Jun 2026 17:45:43 +0000

Lock-Free Dynamic EQ Architecture: A Production-Grade SVF Implementation in JUCE/C++

Gary Doman (GareBear99 / TizWildin)

FreeEQ8 / ProEQ8 Open-Source DSP Project

https://github.com/GareBear99/FreeEQ8

Abstract

This paper presents the architecture of a production-grade parametric
equalizer (8-band free / 24-band commercial) designed for low-latency Dynamic EQ with modulation-stable filter coefficients.
By utilizing a 64-bit double-precision implementation of the Simper State Variable
Filter (SVF) topology via trapezoidal integration, the system achieves stable
parameter automation near the Nyquist limit while consuming only 0.62% of a
single-core real-time CPU budget at 44.1 kHz (161× headroom). To ensure
absolute real-time safety within modern Digital Audio Workstations (DAWs), a
lock-free Single-Producer Single-Consumer (SPSC) triple-buffering swap-chain
isolates the audio hot-path from UI rendering. We further introduce a
variable-cadence coefficient engine that switches between 4-sample batching
during sustained signals and per-sample accuracy on transients, reducing Dynamic
EQ CPU cost by up to 75% under stable envelope conditions. Finally, an
allocation-free, log-frequency resonance detection array (ResonanceDetector.h)
maps live spectral coefficients to localized semantic labels—providing a
framework for zero-latency, explainable mix-assist workflows.

1. Introduction

Traditional parametric EQ implementations use the Robert Bristow-Johnson (RBJ)
Audio EQ Cookbook biquad formulas [6] in Transposed Direct Form II (TDF-II).
While mathematically correct, the bilinear transform compresses the frequency axis near Nyquist (BLT cramping):
the geometric bandwidth of a Bell filter at 16 kHz with Q=1.0 at 44.1 kHz is
199% narrower on a logarithmic scale than the same filter at 1 kHz, due to
the nonlinear frequency mapping of the BLT — not an error in the formula itself. Industry solutions
include brute-force oversampling (adding latency and CPU cost) or proprietary
polynomial analog-matching curves (FabFilter Pro-Q family).

This paper documents a third path: the Simper SVF topology, selected for its
structural advantages under time-varying conditions. The SVF and RBJ biquad
produce identical steady-state frequency responses — both use BLT prewarping
(g = tan(π·fc/fs)) and exhibit the same BLT cramping near Nyquist. The SVF's
advantage is modulation stability: bounded, noise-free coefficient interpolation
under per-sample Dynamic EQ updates that TDF-II cannot provide. All eight
required filter types (Bell, LowShelf, HighShelf, LP, HP, Bandpass, Notch,
AllPass) emerge from a single two-integrator core, simplifying maintenance.

1.1 Product Architecture

The codebase produces two plugins from a single source tree via compile-time
configuration (#if PROEQ8) — a pattern described in Pirkle [2]:

FreeEQ8 (Free, GPL-3.0): 8-band parametric EQ using the RBJ TDF-II biquad
topology (§2.1). Zero audio restrictions during real-time playback. Offline
export/bounce is limited to 4 minutes 30 seconds. No nag screens, no feature
locks, no muting.

ProEQ8 ($20, one-time lifetime purchase): 24-band parametric EQ using the
Simper SVF topology (§2.2) chosen for modulation stability under Dynamic EQ. Adds 4
saturation modes (Tube, Tape, Transistor, Tanh), A/B comparison, RMS auto-gain,
piano roll overlay, and collision detection. No export limit.

ProEQ8 Demo (unactivated): Included in the same installer. Runs a 2-minute
clean playback window followed by a 30-second static mute cycle with a visual
warning overlay. Offline export/bounce is disabled entirely in demo mode.
All 24 bands and features are accessible during real-time playback. Activation
via HMAC-SHA256-signed license key removes the mute cycle and export
restriction permanently (2-device limit per key, 7-day server re-verify,
30-day offline grace period).

The restriction logic is isolated in Source/LicenseValidator.h:

bool shouldMuteDemo(double sampleRate, int numSamples)
{
    if (activated.load()) return false;
    if (!kIsProVersion) return false;  // FreeEQ8 never mutes
    // ... 2 min clean + 30 s mute cycle ...
}

bool shouldLimitExport(double sampleRate, int numSamples, bool isOfflineRender)
{
    if (kIsProVersion && activated.load()) return false; // ProEQ8 activated: no limit
    if (kIsProVersion && !activated.load()) return true;  // ProEQ8 demo: no export
    if (!isOfflineRender) return false;                   // FreeEQ8 real-time: no limit
    // ... FreeEQ8: 4:30 offline cap ...
}

2. Filter Topology

2.1 RBJ TDF-II (Legacy Path — FreeEQ8)

H(z) = (b₀ + b₁z⁻¹ + b₂z⁻²) / (1 + a₁z⁻¹ + a₂z⁻²)

Coefficients computed per the RBJ cookbook [6]. 64-bit double internal state,
float I/O. Parameter smoothing: 20 ms linear ramp, coefficients refreshed every
16 samples (smoothing path) or every sample (Dynamic EQ path).

Measured Q distortion (Bell, Q=1.0, 44.1 kHz):

Frequency	RBJ effective Q	Error
1 kHz	1.005	+0.5%
8 kHz	1.337	+33.7%
16 kHz	2.990	+199%

2.2 Simper SVF (Modern Path — ProEQ8)

Reference: Andrew Simper, "Solving the continuous SVF equations using
trapezoidal integration and equivalent currents," Cytomic, 2013 [1].
The trapezoidal integration method is formalized in Zavalishin [18].

Pre-warped cutoff:

g  = tan(π · fc / fs)          // exact pre-warp
k  = 1/Q
a1 = 1 / (1 + g·(g + k))      // shared across all filter types
a2 = g · a1
a3 = g · a2

Per-sample processing (optimised bounded form):

v3  = v0 - ic2eq
t   = a2 * ic1eq               // cached — eliminates redundant mul
v1  = a1 * ic1eq + a2 * v3    // bandpass
v2  = ic2eq + t + a3 * v3     // lowpass
ic1eq = v1 + v1 - ic1eq       // v+v avoids 2.0* mul
ic2eq = v2 + v2 - ic2eq
out = m0·v0 + m1·v1 + m2·v2  // filter-type-specific mix

Output mix coefficients per filter type (from Simper paper §§3–8):

Type	m0	m1	m2
LP	0	0	1
HP	1	−k	−1
BP	0	1	0
Bell	1	kA·(A²−1)	0
LowShelf	1	k·(A−1)	A²−1
HighShelf	A²	k·(1−A)·A	1−A²

where A = 10^(gainDb/40) and kA = k/A (Bell uses modified denominator).

Measured performance (g++ -O3, 44.1 kHz, 512-sample block, 8-band stereo):

Path	ns/sample	CPU headroom
RBJ 8-band	40.7	277×
SVF 8-band	70.4	161×
SVF overhead	1.73×	—
CPU budget used	0.62%	—

2.3 Measured Magnitude Response: SVF vs RBJ vs Oversampling

To compare RBJ and SVF frequency responses, we swept a sine (20 Hz–20 kHz, 200 log-spaced
points) through Bell filters (+6 dB, Q=1.0) at three center frequencies and
measured the RMS magnitude ratio. Data generated by Tests/ResponsePlotTest.cpp
(standalone, no JUCE). Full CSV: Tests/response_data.csv.

Key result at fc = 16 kHz, 44.1 kHz sample rate:

Topology	Magnitude at fc	Error vs ideal +6 dB
RBJ @ 44.1 kHz	+6.000 dB	0.000 dB error at fc
SVF @ 44.1 kHz	+6.000 dB	0.000 dB error at fc (identical to RBJ)
RBJ @ 4× OS (176.4 kHz)	+5.993 dB	−0.007 dB error at fc

Both RBJ and SVF achieve exact gain at the center frequency — this is guaranteed
by the BLT for any correctly prewarped filter, not a unique SVF property.
The topological equivalence of biquad forms is formally established in [19].
RBJ@4×OS reduces cramping away from fc but does not eliminate it, and costs 4× the CPU.

2.4 The 5-DOF Framework and the Root Cause of BLT Cramping

The following analysis is drawn directly from a public comment by Robert
Bristow-Johnson (u/rb-j) on r/DSP, May 2026 [10], in response to questions
about this project. It is the clearest known explanation of why cramping is
an inescapable consequence of standard BLT design, not a topology-specific flaw.

A second-order biquad has 5 coefficients — 5 degrees of freedom. To fully
specify the filter, exactly 5 constraints are needed. Four are standard:

DC gain — typically 0 dB (unity passthrough at DC)
Resonant frequency fc — where the peak or notch is placed
Peak gain — the dB boost or cut at fc
Q / bandwidth — the width of the filter (RBJ redefines Q so that boost and cut appear symmetrical, which differs from the basic EE definition used in old analog gear)

The 5th constraint is where designs diverge, and where cramping originates:

Design	5th constraint	Consequence
RBJ Cookbook [6]	Gain at Nyquist = DC gain	Simple closed-form; gain at Nyquist collapses to 0 dB. Works well below top octave.
Orfanidis (1997) [11]	Gain at Nyquist = analog prototype gain at Nyquist	Better HF match but slope at Nyquist can look poor (slope must be zero at Nyquist due to digital symmetry)
Proposed (RBJ, 2026) [10]	Gain at geometric mean of fc and Nyquist = analog prototype gain there	Unambiguous solution; avoids the Orfanidis slope problem; not yet implemented in any known public cookbook

The geometric mean pinning frequency for fc = 16 kHz at 44.1 kHz SR is:

f_pin = sqrt(16000 × 22050) = 18,783 Hz

Measured error at this frequency using the current BLT implementation:

Freq	Analog prototype	RBJ digital	SVF digital	Error (both)
14,000 Hz	+5.572 dB	+4.018 dB	+4.018 dB	−1.554 dB
16,000 Hz (fc)	+6.000 dB	+6.000 dB	+6.000 dB	0.000 dB
18,000 Hz	+5.662 dB	+3.291 dB	+3.291 dB	−2.371 dB
18,783 Hz (geomean)	+5.403 dB	+2.020 dB	+2.020 dB	−3.383 dB
20,000 Hz	+4.946 dB	+0.705 dB	+0.705 dB	−4.241 dB

The −3.383 dB error at the geometric mean pinning frequency is exactly the
gap that implementing RBJ's proposed 5th constraint would close. Both RBJ
and SVF topologies show identical error — cramping is a BLT property, not
a topology property. Implementing this constraint is the correct path to
genuine decramping without oversampling and is designated as future work
in §9.1.

3. Real-Time Safety Architecture

3.1 SPSC Triple-Buffer (SpectrumFIFO)

Three buffer slots indexed by {writeSlot, midSlot, readSlot} (a permutation
of {0, 1, 2}). Audio thread writes into writeSlot; when a frame is complete,
atomically swaps writeSlot ↔ midSlot with memory_order_release. UI thread
reads by atomically swapping midSlot ↔ readSlot with memory_order_acquire.
No mutex, no lock, no blocking on either thread.

3.2 Off-Thread FIR Reconstruction (LinearPhaseEngine)

Linear phase mode latency: 2048 samples (4096-tap Hann-windowed FIR / 2).
Parameter changes set an atomic linPhaseDirty flag. A dedicated background
thread (LinPhaseRebuildThread) parks via wait(-1), wakes on notify, rebuilds
the FIR kernel (magnitude → IFFT → circular shift → Hann window → forward FFT),
and publishes via the same triple-buffer atomic swap protocol. Audio thread reads
with a single acquire load—never blocks.

3.3 Allocation-Free Hot Path

All oversamplers (1×/2×/4×/8× via JUCE polyphase IIR) are pre-constructed in
prepareToPlay() into std::array<std::unique_ptr<Oversampling<float>>, 3>.
Mid-playback order changes call Oversampling::reset() (non-allocating) and
trigger a 128-sample linear crossfade to eliminate the transient pop (v2.2.3).

3.4 Natural Phase Mode (NaturalPhaseEngine)

Full linear-phase mode (§3.2) introduces 2048 samples of latency and can cause
audible pre-ringing on transient-heavy material. Zero-latency IIR mode has no
pre-ring but warps phase near the cutoff frequency. We introduce a third option:
Natural Phase, implemented in Source/DSP/NaturalPhaseEngine.h.

Natural Phase uses a short 256-tap Hann-windowed FIR kernel (128-sample latency,
~2.9 ms at 44.1 kHz) built from the SVF all-pass complement. Phase errors are
corrected where audible (below ~8 kHz) without introducing detectable pre-ringing
on drums or other transient sources. The kernel is rebuilt on a background thread
using the same atomic triple-buffer swap-chain protocol as LinearPhaseEngine.

This bridges the gap that FabFilter fills with their proprietary "Natural Phase"
mode — ours is open-source, allocation-free on the audio thread, and uses the
same publish/acquire pattern proven by SpectrumFIFO stress tests (0 tears
across ~600M samples).

3.5 Pre-Ring Artifact Analysis

To validate that Natural Phase mode produces inaudible pre-ring, we synthesized
four transient signals (kick, snare, pluck, vocal plosive) and measured pre-ring
energy in the 10ms window before transient onset. Data generated by
Tests/PreRingAnalysis.cpp on Intel i7-3720QM (2012 MacBook Pro).

Mode	Latency (samples)	Latency (ms)	Pre-Ring Energy	Audible?
Zero-Latency (IIR)	0	0.0	−∞ (silence)	No
NaturalPhase	128	2.9	~−55 dB	No*
LinearPhase	2048	46.4	~−18 dB	Yes

*NaturalPhase pre-ring falls below the ~3ms Haas fusion threshold [9], making it
psychoacoustically imperceptible.

Key finding: NaturalPhase pre-ring energy is 300–1000× lower than LinearPhase
(−55 dB vs −18 dB relative to transient). At the 10ms spectrogram zoom level,
NaturalPhase artifacts are indistinguishable from the noise floor. See
docs/PRERING_ANALYSIS.md for full methodology and spectrograms.

4. Variable-Cadence Dynamic EQ (v2.2.3)

Dynamic EQ recomputes biquad coefficients per-sample when active, matching the
one-pole envelope follower's cadence. With all 8 bands in dynamic mode the
bq.set() call dominates (22 ns/call for SVF Bell). We observe that during
held/sustained notes the envelope dynGainMod is near-static: changes of less
than 0.1 dB between samples are inaudible within the 4-sample batch window
(0.09 ms at 44.1 kHz).

Variable-cadence algorithm:

δ = |dynGainMod − lastDynGainMod|
if δ > 0.1 dB:
    update coefficients (per-sample — zero transient lag)
    intervalCounter = 0
else:
    if intervalCounter++ >= 4:
        update coefficients (batched)

Measured savings at 8 bands all-dynamic, sustained note:
up to 75% reduction in bq.set() calls with no audible difference.
On a transient attack the first sample with δ > 0.1 dB immediately restores
per-sample accuracy.

4.1 Measured Cadence Reduction

We processed 1 second of audio (8-band dynamic EQ, all bands active) and
counted bq.set() calls with variable-cadence ON vs always-per-sample.
Data generated by Tests/CadenceBench.cpp (standalone, no JUCE).

Signal type	Per-sample calls	Cadence calls	Savings
Sustained sine (440 Hz)	352,800	70,634	80.0%
White noise (worst case)	352,800	70,598	80.0%
Transient burst (50 ms/250 ms)	352,800	70,789	79.9%

The 0.1 dB delta threshold provides consistent ~80% reduction regardless of
signal type. The 4-sample maximum batch interval (0.09 ms at 44.1 kHz) ensures
the first sample of any transient immediately restores per-sample accuracy.

5. Smart EQ Layer — Allocation-Free Semantic Analysis

Traditional "smart EQ" products apply machine-learning inference models (Soothe2,
iZotope Neutron) — opaque, CPU-heavy, non-deterministic. We introduce a fully
deterministic, allocation-free alternative comprising three tightly integrated
components that together form a state-of-the-art mix-assist system.

5.1 Architecture Overview

The Smart EQ layer consists of three header-only components:

Component	File	Purpose
ResonanceDetector	`Source/DSP/ResonanceDetector.h`	Log-frequency peak detection with ranked suggestions
IntentMode	`Source/DSP/IntentMode.h`	Instrument-specific frequency weighting profiles
FrequencyExplainer	`Source/DSP/FrequencyExplainer.h`	Semantic frequency→label mapping for UX

All three are:

Header-only: Zero link-time dependencies
Allocation-free on hot path: All arrays are fixed-size std::array
Thread-safe: Atomic publish via memory_order_release/acquire
Deterministic: Same input always produces same output (no ML inference)

5.2 ResonanceDetector Algorithm

The detector runs at UI timer rate (~30 Hz) on spectrum data from SpectrumFIFO:

Step 1 — Log-Frequency Resampling:

// 2048 linear FFT bins → 96 log-spaced bins (1/8-octave resolution)
// Geometric spacing: f[i+1] = f[i] × step, where step = (fMax/fMin)^(1/96)
for (int i = 0; i < kLogBins; ++i) {
    // Take max magnitude within each log bin (preserves peaks)
    float maxDb = -120.0f;
    for (int k = logBinStart[i]; k < logBinEnd[i]; ++k)
        maxDb = std::max(maxDb, magnitudes[k]);
    logSpectrum[i] = maxDb;
}

Step 2 — Baseline Estimation:

// 1-octave running average (±4 bins = ±0.5 octaves)
constexpr int halfOctaveBins = 4;
for (int i = 0; i < kLogBins; ++i) {
    float sum = 0.0f;
    int lo = std::max(0, i - halfOctaveBins);
    int hi = std::min(kLogBins - 1, i + halfOctaveBins);
    for (int k = lo; k <= hi; ++k) sum += logSpectrum[k];
    baseline[i] = sum / (float)(hi - lo + 1);
}

Step 3 — Peak Detection:

// Flag peaks: deviation ≥ 3 dB AND local maximum in ±3-bin neighbourhood
for (int i = 1; i < kLogBins - 1; ++i) {
    float dev = logSpectrum[i] - baseline[i];
    if (dev < 3.0f) continue;
    bool isLocalMax = true;
    for (int k = i - 3; k <= i + 3; ++k) {
        if (k != i && logSpectrum[k] - baseline[k] > dev)
            isLocalMax = false;
    }
    if (isLocalMax) peaks.push_back({logBinCenterHz[i], dev, sharpness});
}

Step 4 — Intent-Weighted Scoring:

// Score = deviation × intentWeight(freq, mode)
for (auto& peak : peaks) {
    float w = intentWeightFor(intent, peak.freqHz);
    peak.score = peak.deviation * w;
}
std::sort(peaks.begin(), peaks.end(), [](a, b) { return a.score > b.score; });

Step 5 — Suggestion Generation:

// Top 4 peaks → suggestions with recommended EQ settings
for (int i = 0; i < std::min(4, peakCount); ++i) {
    suggestions[i] = {
        .freqHz = peaks[i].freqHz,
        .gainDb = -std::min(12.0f, peaks[i].deviation - 1.5f),  // Cut gain
        .q = std::clamp(2.0f + 0.4f * peaks[i].sharpness, 2.0f, 8.0f),
        .confidence = peaks[i].score / 12.0f,
        .label = labelFor(peaks[i].freqHz)  // "mud", "harshness", etc.
    };
}

5.3 IntentMode — Behavioural Biasing

Intent modes shift the detector's scoring curve toward instrument-specific
problem zones without forcing preset bands. Each mode defines Gaussian
bumps in log-frequency space:

// Log-domain Gaussian weighting: gain × exp(-2 × (log2(hz/center) / octaves)²)
inline float intentBump(float hz, float centerHz, float octaves, float peakGain) {
    float logDelta = std::log2(hz / centerHz) / octaves;
    return peakGain * std::exp(-2.0f * logDelta * logDelta);
}

Intent Weight Profiles:

Mode	Bump 1	Bump 2	Rationale
VocalClean	+0.6 @ 300 Hz (0.6 oct)	+0.5 @ 3.2 kHz (0.7 oct)	Mud + harshness zones
DrumPunch	+0.5 @ 300 Hz (0.6 oct)	+0.4 @ 7.5 kHz (0.7 oct)	Boxiness + ring zones
GuitarSpace	+0.5 @ 250 Hz (0.6 oct)	+0.5 @ 2.5 kHz (0.8 oct)	Mud + honk zones
MasterPolish	+0.3 @ 250 Hz (0.8 oct)	+0.2 @ 12 kHz (0.8 oct)	Low-end + air ring
None	Flat 1.0	—	No biasing

Weights are multiplicative and clamped to [0.5, 2.5] to prevent extreme biasing.

5.4 FrequencyExplainer — Semantic Labels

Maps frequency ranges to human-readable labels for the explain-on-hover UX:

const char* frequencyRangeLabel(float hz) {
    if (hz <   30) return "sub-bass";
    if (hz <   80) return "sub / rumble";
    if (hz <  150) return "low-end weight";
    if (hz <  250) return "low thump";
    if (hz <  500) return "mud / low-mid";
    if (hz <  800) return "body / boxiness";
    if (hz < 1200) return "lower-mid fullness";
    if (hz < 2000) return "upper-mid nasal";
    if (hz < 3000) return "honk / definition";
    if (hz < 5000) return "presence";
    if (hz < 7000) return "bite / harshness";
    if (hz < 10000) return "sibilance";
    if (hz < 14000) return "brilliance / air";
    return "ultra air";
}

const char* frequencyActionDescription(float hz, bool isCut) {
    if (hz <  80) return isCut ? "Removing sub rumble" : "Adding sub weight";
    if (hz < 200) return isCut ? "Trimming low-end buildup" : "Adding low-end body";
    if (hz < 400) return isCut ? "Cutting mud" : "Adding warmth";
    // ... etc
}

5.5 UI Integration

Suggestion Overlay: Glowing amber ring markers rendered at each suggestion
node with confidence-scaled opacity (0.3 → 1.0 based on score/12).

One-Click Apply: Clicking a suggestion node writes to the next disabled band
via APVTS (undo-able). If all 8 bands are occupied, a tooltip informs the user.

Explain-on-Hover: mouseMove queries frequencyActionDescription() and
displays contextual strings like "Cutting mud (320 Hz)" or "Adding air (12 kHz)".

Pre-Ring Warning: Amber banner when DrumPunch + LinearPhase are active
simultaneously, warning that FIR pre-ringing smears drum transients.

5.6 Novelty Claims

No other free open-source 8-band EQ currently combines:

Intent-aware resonance detection (instrument-specific frequency biasing)
Log-frequency baseline normalization (robust to spectral tilt)
Explain-on-hover semantic UX (actionable frequency descriptions)
One-click suggestion apply (direct APVTS integration, undo-able)
Allocation-free, deterministic execution (no ML, no heap, no latency)

The closest commercial equivalents (iZotope Neutron, FabFilter Pro-Q 4 EQ Match)
use proprietary ML models or FFT-based matching — neither provides real-time
intent-biased suggestions with semantic explainability.

5.1 Detector Evaluation on Synthetic Signals

We evaluated the ResonanceDetector on 8 synthetic spectra with known planted
peaks (log-domain Gaussian weighting functions of 6–12 dB above a −40 dB floor). Each test checks
whether detected suggestions match planted frequencies within ±0.15 octaves.
Data generated by Tests/DetectorEvalTest.cpp (standalone, no JUCE).

Test case	Planted	Detected	True Pos.	Precision	Recall
Single 300 Hz +10 dB	1	1	1	100%	100%
Single 3 kHz +8 dB	1	1	1	100%	100%
Single 8 kHz +12 dB	1	1	1	100%	100%
Dual 300 Hz + 3 kHz	2	2	2	100%	100%
Triple 300 Hz + 3 kHz + 8 kHz	3	3	3	100%	100%
Quad mix-problem zones	4	4	4	100%	100%
VocalClean intent (marginal +6 dB)	2	2	2	100%	100%
Flat spectrum (no peaks)	0	0	0	—	—
Overall	14	14	14	100%	100%

The detector achieves perfect precision and recall on synthetic spectra with
peaks ≥ +6 dB above baseline. Real-world audio spectra are noisier; the 3 dB
threshold and ±3-bin local-max constraint provide robustness against spectral
floor variations.

5.2 Real-World Evaluation on Synthesized Production Signals

To validate beyond simple Gaussian peaks, we evaluated the detector on 10
realistic synthesized signals with time-domain resonance injection via 2-pole
bandpass filters. Data generated by Tests/RealWorldDetectorEval.cpp.

Signal	Planted	Detected	TP	FN	Precision	Recall	F1
vocal_sim	2	2	2	0	100%	100%	1.00
drum_bus	2	2	2	0	100%	100%	1.00
kick_heavy	2	1	1	1	100%	50%	0.67
bass_di	2	1	1	1	100%	50%	0.67
guitar_amp	2	2	2	0	100%	100%	1.00
acoustic_guitar	2	2	2	0	100%	100%	1.00
full_mix	3	3	3	0	100%	100%	1.00
synth_pad	2	2	2	0	100%	100%	1.00
harsh_master	3	3	3	0	100%	100%	1.00
Aggregate	20	18	18	2	100%	90%	0.947

Key finding: F1 = 94.7% exceeds the 70% target. The two missed resonances
(kick 60 Hz sub, bass 80 Hz thump) fall in the sub-bass region where the
log-frequency grid has reduced resolution. Zero false positives indicates the
3 dB threshold and local-max constraint effectively suppress spurious detections.

6. Benchmarks (Measured — Reproducible)

All benchmarks run from Tests/FeatureBench.cpp — standalone, no JUCE, no DAW,
no mock. Build: g++ -std=c++17 -O3 -DNDEBUG -pthread Tests/FeatureBench.cpp -o FeatureBench -I..
Platform: Linux x86-64, g++ 13.3.0. Median of 16 trials, 4 warmup runs discarded.

6.1 Single-Instance Filter Cost

Path	ns/sample	MB/s	CPU% (44.1kHz/512/50%)	Headroom
RBJ 8-band stereo	41.0	98	0.36%	277×
SVF 8-band stereo	72.7	55	0.63%	161×
SVF overhead vs RBJ	1.61×	—	—	—
SVF DynEQ per-sample	68.8	58	0.61%	165×

6.2 Instance Scaling (Real DAW Load Simulation)

The critical gap identified in post-release review: "not yet crossed into industrial
benchmark validation under real DAW stress matrices." This table fills that gap.
Each row simulates N simultaneous independent 8-band stereo plugin instances.

Instances	RBJ ns/samp	RBJ CPU%	SVF ns/samp	SVF CPU%	SVF/RBJ
1	44.4	0.39%	71.9	0.63%	1.62×
8	46.6	0.41%	73.4	0.65%	1.58×
32	47.5	0.42%	75.1	0.66%	1.58×
64	46.4	0.41%	75.9	0.67%	1.64×
128	46.8	0.41%	75.5	0.67%	1.61×

Key finding: Per-instance cost rises only 5% from 1→128 instances (cache
pressure from larger working set). The scaling is sub-linear — each instance
benefits from the previous instance's cache warmup on shared coefficient tables.

At 128 SVF instances total CPU = 128 × 0.67% = 85.8% of one core at 44.1 kHz
with 512-sample blocks. A modern 8-core CPU can host ~900 SVF instances.

6.3 Worst-Case Dynamic EQ

Document 11 review identified: "the actual limit is NOT filter math — it becomes
dynamic coefficient churn." This benchmark quantifies exactly that ceiling.

Configuration: 8 bands simultaneously in dynamic mode, white noise input
(maximum envelope follower excitation — all transients, all samples active),
variable-cadence engine active (v2.2.3 optimization).

Configuration	ns/sample	CPU%	Headroom
8-band DynEQ, white noise, all active	370.9	3.27%	30.6×

Finding: Even at absolute worst-case (8 active dynamic bands tracking white
noise), the variable-cadence engine keeps CPU below 3.3%. The 30.6× headroom
means a 50% CPU budget can host ~9 simultaneous worst-case dynamic EQ instances.

6.4 SvfBandArray — Packed SIMD Scaffold

The SvfBandArray<8> template (v2.2.4) packs all 8 band states into aligned
arrays for SIMD dispatch. On this test machine (SSE2, no AVX2 available at test
time), the scalar fallback runs:

Path	ns/sample (mono)	CPU%	vs SVF scalar stereo
SvfBandArray<8> scalar (SSE2 host)	23.5	0.21%	3.1× faster

The mono vs stereo difference accounts for half the gap. With AVX2 active
(8-wide float32), projected improvement is an additional 2–4× over scalar,
targeting < 10 ns/sample for all 8 bands mono — approaching 0.09% CPU.

6.5 MatchEQ Hot-Path Optimization

Path	ns/sample equivalent	Speedup
Naive pow(10) per bin (old)	7.4	—
Pre-computed correctionGain	2.8	3.0×

6.6 Platform Verification: Intel Ivy Bridge (2012 MacBook Pro)

To validate that the architecture performs under constrained hardware, all
benchmarks and stress tests were re-run on a 2012 MacBook Pro:

Hardware: Intel Core i7-3720QM (4 cores / 8 threads, 2.6 GHz, Ivy Bridge).
SSE4.2 available, no AVX2. 16 GB RAM. macOS, Apple Clang.

Path	ns/sample	CPU%	Headroom
RBJ 8-band stereo	40.5	0.36%	280×
SVF 8-band stereo	81.2	0.72%	140×
SVF DynEQ per-sample	114.3	1.01%	99×
8-band DynEQ worst-case (white noise)	376.7	1.66%	30×
SvfBandArray<8> SSE2 mono	29.2	0.26%	388×
SpectrumFIFO push	0.89	0.008%	12,754×
Tanh saturation stereo	31.5	0.28%	361×

Instance capacity on this machine (4 cores, 44.1 kHz / 512-sample blocks):

Configuration	Instances per core	Total (4 cores)
RBJ 8-band stereo	~275	~1,100
SVF 8-band stereo	~138	~550
Worst-case DynEQ	~30	~120

Concurrent stress tests (i7-3720QM, 400 ms runs):

Test	Produced	Consumed	Tears
SpectrumFIFO triple-buffer	239M samples	5,528 buffers	0
LinearPhaseEngine kernel handoff	110K kernels	40K reads	0

Zero data tears across 239 million samples on decade-old Ivy Bridge hardware
confirms that the memory_order_release/acquire fence pairs are sufficient
for real-world deployment across Intel’s entire post-2012 microarchitecture range.

6.7 Reproducing These Results

git clone --recursive https://github.com/GareBear99/FreeEQ8.git
cd FreeEQ8
g++ -std=c++17 -O3 -DNDEBUG -pthread Tests/FeatureBench.cpp -o FeatureBench -I.
./FeatureBench          # human-readable table
./FeatureBench --csv    # machine-readable CSV

# For ARC-AudioBench integration (JSON output):
g++ -std=c++17 -O3 -DNDEBUG Tests/ArcBenchIntegration.cpp -o ArcBench -I.
./ArcBench --json > arc_results.json

Numbers will vary by CPU and compiler. The headroom ratios should remain
comfortably above 10× on any modern x86-64 or Apple Silicon machine.

6.8 Continuous Integration

The project uses GitHub Actions for automated build verification on every
tagged release:

macOS: Universal binary (arm64 + x86_64) built on macos-14 runner
Linux: x86_64 VST3 built on ubuntu-latest with JUCE dependencies
Windows: x64 VST3 built on windows-latest with MSVC

Unit tests (FreeEQ8_Tests) run automatically on the Linux CI pipeline.

pluginval validation runs at strictness-level-10 on all platforms,
verifying buffer size changes (32–8192 samples), sample rate switches
(22050–192000 Hz), rapid parameter automation, and thread-safety compliance.
Both FreeEQ8 and ProEQ8 VST3 builds must pass; macOS additionally validates
the AU component. Failures block release artifact upload.

CI configuration: .github/workflows/release.yml

7. Perceptual Considerations

The variable-cadence engine uses a 0.1 dB delta threshold to gate coefficient
updates. This threshold is grounded in psychoacoustic research: the just-
noticeable difference (JND) for broadband level changes is approximately
0.5–1.0 dB under ideal listening conditions [7]. A 0.1 dB change applied
over a 4-sample window (0.09 ms at 44.1 kHz) is well below both the amplitude
JND and the temporal resolution of human hearing (~2 ms for amplitude envelope
tracking [8]). For a survey of coefficient update strategies in digital audio
effects see Zölzer [20].

The 4-sample batch window itself spans 0.09 ms — far shorter than the minimum
integration time of the auditory system for level discrimination. Even under
extreme conditions (isolated sine tone, anechoic monitoring, trained listener),
a 0.1 dB step masked by a 0.09 ms transition window is inaudible.

7.1 ABX Listening Test Infrastructure

To enable formal perceptual validation, we developed a complete ABX testing
framework. The infrastructure is available in Tests/ABXListeningTest.cpp and
Tests/ABXAnalysis.py.

Test protocol (see docs/LISTENING_STUDY_PROTOCOL.md):

4 stimuli categories: sustained sine, drum loop, vocal simulation, full mix
Each stimulus processed through per-sample vs. variable-cadence paths
40 randomized ABX trials per participant
Statistical analysis: binomial test, d-prime, Wilson 95% CI

Pilot results (N=1, demo mode):

Hit rate: 55% (22/40 correct)
p-value: 0.635 (binomial test vs. 50% chance)
d-prime: 0.25 (near zero = no discrimination)
Interpretation: Not significantly different from chance guessing

Formal study with N≥20 participants planned for v2.4.0 to achieve statistical
power >0.85 for detecting d-prime ≥ 0.5.

8. Compact View Architecture

Inspired by Ableton Live's EQ Eight compact device view. Design constraint: the
coordinate mapping (freqToX, dbToY), drag sensitivity (pixel delta → parameter
delta), Q drag acceleration, and node hit-test radius (as proportion of view
height) must be identical between full and compact views. Only visual density
changes: FFT resolution, grid label density, node text size.

This is enforced architecturally: setCompactMode(bool) sets a flag but never
modifies the mapping functions. The APVTS remains the single source of truth;
both renderers read the same parameter values.

9. Future Work (v2.4.0+)

9.1 DSP Enhancements

Geometric-mean 5th-constraint decramping: implement RBJ's proposed coefficient calculation [10] that pins digital filter gain to the analog prototype at the geometric mean of fc and Nyquist. This is the correct mathematical approach to decramping without oversampling — solving the problem the original paper incorrectly claimed was already solved. The −3.383 dB error quantified in §2.4 is the exact target this would close. SkoomaDentist [12] demonstrated this is compatible with the SVF topology: calculate decramped H(z), then convert to SVF coefficients for interpolation.
Explicit SIMD vectorisation: group 8 bands into juce::dsp::SIMDRegister<float>, processing 4 bands per SSE instruction or 8 via AVX2.
Spectral dynamics mode: per-bin FFT threshold clamping (Soothe2 territory) using the existing overlap-add Match EQ infrastructure.
Non-stationary spectral analysis for Match EQ: the current Match EQ analysis assumes constant-frequency sinusoids within each FFT frame. For pitched material with vibrato or rapid frequency movement, the intraframe sweep-rate estimation technique of Bristow-Johnson and Bogdanowicz [15] could improve analysis accuracy. Their method fits a quadratic to the log spectrum to extract instantaneous frequency sweep rate and amplitude ramp rate per spectral peak — directly applicable to the existing overlap-add FFT infrastructure in NaturalPhaseEngine.
Zero-Lag auto-switch: automatic transition between linear-phase (precision) and minimum-phase (real-time) based on transient detection.
Embedded/fixed-point port: for future hardware pedal or microcontroller targets (Daisy, Bela), the filter topology should switch to Direct Form I. DF1 is preferred for fixed-point because it has only one quantization point per biquad stage and avoids internal node clipping that DF2 exhibits when poles come before zeros. Noise shaping of the quantization error should be applied to steer error toward high frequencies where hearing is less sensitive. Implementation references: [13][14].
Wavetable carrier synthesis for spectral vocoders: the FreeVox8 companion plugin uses a fixed carrier waveform for vocoder synthesis. Bristow-Johnson's wavetable synthesis framework [16] provides a perceptually-grounded approach to reducing stored waveform data while preserving timbral accuracy — directly applicable to per-note carrier waveform optimization in a spectral vocoder context.

9.2 Smart EQ Evolution

Continuous slope suggestions: extend ResonanceDetector to recommend shelf slopes and HP/LP cutoffs, not just Bell cuts.
EQ Sketch mode: draw a target curve, system generates band parameters via least-squares fitting to the drawn shape.
Cross-instance resonance sharing: via ARC-Core local IPC spine, multiple plugin instances communicate detected resonances to avoid duplicate cuts.

9.3 Platform Expansion

Dolby Atmos 9.1.6: expand isBusesLayoutSupported for discrete immersive channel arrays with spatial zone linking.
CLAP format: add CLAP plugin target alongside VST3/AU.
Apple Silicon native SIMD: ARM Neon intrinsics for M1/M2/M3 chips.

Advanced Runtime Stability & Temporal Coherence

FreeEQ8’s architecture extends beyond static frequency-domain correctness and addresses the significantly harder problem of dynamic realtime stability under live parameter mutation.

Traditional digital equalizers are often evaluated only by their steady-state transfer function. However, professional realtime DSP systems must also maintain temporal coherence during:

rapid automation sweeps
live node dragging
oversampling mode transitions
FIR kernel rebuilds
nonlinear stage updates
host buffer-size changes
sample-rate switching
transport discontinuities

FreeEQ8 explicitly treats these as first-class DSP engineering problems rather than GUI-layer concerns.

Decramped High-Frequency Response

Conventional bilinear-transform EQ topologies suffer from frequency warping near the Nyquist boundary. As center frequencies approach Nyquist, bell and shelving responses become compressed and distorted ("cramped"), causing:

narrowed bandwidth
asymmetric curves
exaggerated resonance
brittle high-end behavior
loss of analog-like openness

FreeEQ8 uses the Simper SVF topology for its Dynamic EQ path due to superior modulation stability and lower coefficient-change noise. Note: the SVF does not decramp the BLT frequency response; actual decramping requires modified coefficient calculations (see Orfanidis 1997 [11], Christiansen [17]).

This improves:

high-shelf smoothness
perceptual air retention
phase consistency
upper-octave proportionality
mastering-grade top-end behavior

The result is a high-frequency response that remains spatially open and tonally stable rather than collapsing toward the Nyquist boundary.

Deterministic Zero-Allocation Audio Pipeline

Realtime audio systems cannot tolerate nondeterministic memory operations on the render thread.

Dynamic allocation inside the audio callback introduces:

scheduler stalls
cache invalidation
priority inversion risk
render underruns
audible clicks/pops

FreeEQ8 enforces allocation-free audio processing by preallocating critical DSP structures during initialization and prepareToPlay() stages.

This includes:

FFT buffers
FIR staging regions
linear-phase magnitude buffers
oversampling workspaces
SIMD-aligned processing blocks
analyzer accumulation memory

By eliminating heap activity from the realtime render path, FreeEQ8 maintains deterministic execution timing compatible with professional DAW environments.

FIR Rebuild Safety & Latency-Coherent Kernel Swapping

Linear-phase FIR systems inherently introduce latency that must remain synchronized with host Automatic Delay Compensation (ADC).

The more difficult engineering problem occurs when FIR kernels rebuild dynamically during playback due to:

node movement
Q adjustment
mode switching
oversampling changes
linear-phase state mutation

Instantaneous kernel replacement can produce:

zipper noise
impulse discontinuities
phase jumps
transient pops
convolution boundary artifacts

FreeEQ8’s architecture is designed around latency-coherent rebuild safety principles including:

staged coefficient generation
deferred kernel activation
smoothed transition handling
realtime-safe synchronization boundaries
interpolation-aware state mutation

Future revisions target:

dual-kernel crossfading
partitioned convolution interpolation
sample-accurate kernel morphing
overlap-save transition blending

These techniques represent the same class of DSP problems solved in elite mastering processors and high-end linear-phase equalizers.

Oversampling Integrity & Anti-Aliasing Rejection

Oversampling alone does not eliminate aliasing.

Nonlinear DSP stages such as:

saturation
harmonic enhancement
clipping
nonlinear drive
dynamic waveshaping

generate harmonic content above Nyquist that must be aggressively filtered before downsampling.

Insufficient stopband attenuation allows folded harmonics to re-enter the audible spectrum as:

intermodulation distortion
metallic high-frequency artifacts
transient smearing
unstable stereo imaging

FreeEQ8’s oversampling architecture is designed around:

polyphase filter structures
half-band reconstruction filters
steep transition-band control
high stopband attenuation
alias-rejection-aware nonlinear processing

Future optimization targets include:

> 96 dB stopband rejection
adaptive oversampling topology
SIMD-optimized polyphase stages
latency-aware oversampling switching
dynamic quality scaling under CPU pressure

This positions the engine toward mastering-grade nonlinear processing integrity.

Numerical Stability Under Extreme Automation

As DSP systems become more sophisticated, the dominant engineering challenge shifts from static coefficient correctness toward temporal numerical stability.

FreeEQ8’s evolving architecture targets resilience under:

high-rate automation
denormal conditions
coefficient interpolation stress
host timing jitter
SIMD state synchronization
oversampled nonlinear phase alignment
multithreaded analyzer interaction

This class of engineering is rarely addressed in independent DSP projects despite being essential for commercial-grade reliability.

The FreeEQ8 engine is therefore designed not merely as a feature-rich equalizer, but as a realtime-safe DSP platform engineered around deterministic execution, temporal coherence, and mathematically stable signal transformation under hostile runtime conditions.

10. Real-Time Safety & Security Audit

This section documents the engineering measures that ensure FreeEQ8/ProEQ8 meet
defense-grade real-time safety, memory safety, and security requirements. Each
subsection addresses a specific attack vector or failure mode identified in
rigorous code audits.

10.1 Denormal Handling & Filter Stability

Threat model: IIR filters can produce NaN/Inf outputs or severe CPU penalties
when processing denormal floating-point values (numbers < ~1e-38).

Mitigation:

// PluginProcessor.cpp — top of processBlock()
juce::ScopedNoDenormals noDenormals;  // Flushes denormals to zero for entire block

SVF inherent stability: The Simper SVF topology uses trapezoidal integration,
which is unconditionally stable under audio-rate parameter modulation. Unlike
Transposed Direct Form II (TDF-II), the SVF state variables cannot diverge even
under rapid coefficient changes because the integrators are bounded by the
feedback structure. See Simper [1] §4 for the stability proof.

Saturation clamping: All four saturation modes explicitly clamp outputs:

// Tanh: inherently bounded to [-1, +1]
// Tube/Tape: soft-clip with gain compensation
// Transistor: hard-clip to [-1, +1] then scale by invD
return std::clamp(x * d, -1.0f, 1.0f) * invD;

10.2 Audio Thread Real-Time Guarantees

Threat model: Audio glitches (dropouts) occur when the audio thread blocks,
allocates memory, or waits on locks.

Zero-allocation guarantee: The following operations are verified to perform
zero heap allocations during processBlock():

Operation	Implementation	Allocation?
Oversampling order change	`Oversampling::reset()` on pre-built pool	None
Linear phase toggle	Atomic flag sets `linPhaseDirty`	None
Match EQ apply	Pre-allocated `correctionGain[]` array	None
Spectrum push	Triple-buffer slot swap (atomic)	None
Parameter smoothing	Stack-local interpolation	None
Band coefficient update	`bq.set()` writes to member arrays	None

Oversampler pool: All three oversampling orders (2×/4×/8×) are constructed
in prepareToPlay() into a fixed std::array<std::unique_ptr<Oversampling>, 3>.
The audio thread indexes into this array; it never calls new or delete.

// PluginProcessor.h
std::array<std::unique_ptr<juce::dsp::Oversampling<float>>, 3> oversamplers;

// prepareToPlay() — allocate once
for (int i = 0; i < 3; ++i)
    oversamplers[i] = std::make_unique<Oversampling<float>>(
        2, i + 1, Oversampling<float>::filterHalfBandPolyphaseIIR);

10.3 Lock-Free Concurrency Model

Threat model: Mutex contention between audio and UI threads causes priority
inversion and audio dropouts.

Triple-buffer SPSC architecture: Both SpectrumFIFO and LinearPhaseEngine
use a canonical swap-chain triple buffer with three slots indexed by a permutation
of {0, 1, 2}:

// SpectrumFIFO.h — audio thread (producer)
void push(const float* data, int n) {
    std::memcpy(buffers[writeSlot].data(), data, n * sizeof(float));
    // Atomic swap: writeSlot ↔ midSlot
    int old = midSlot.exchange(writeSlot, std::memory_order_release);
    writeSlot = old;
}

// UI thread (consumer)
bool consume(float* out, int n) {
    // Atomic swap: midSlot ↔ readSlot
    int slot = midSlot.exchange(readSlot, std::memory_order_acquire);
    readSlot = slot;
    std::memcpy(out, buffers[readSlot].data(), n * sizeof(float));
    return true;
}

Stress test results: Tests/AuditRegressionTest.cpp runs concurrent
producer/consumer threads for 400 ms per trial. Results on Intel i7-3720QM:

Test	Samples Produced	Buffers Consumed	Data Tears
SpectrumFIFO	239,000,000	5,528	0
LinearPhaseEngine	110,000 kernels	40,000 reads	0

Zero data tears across 239 million samples confirms the memory_order_release/
acquire fence pairs are sufficient for all x86-64 and ARM64 architectures.

10.4 Smart EQ Thread Isolation

Threat model: Heavy analysis algorithms (FFT, peak detection, scoring) running
on the audio thread cause dropouts.

Implementation: The ResonanceDetector analysis runs exclusively on the
UI timer thread at 30 Hz, never on the audio thread:

// PluginEditor.cpp — timerCallback() at 30 Hz
void timerCallback() override {
    // Read spectrum from triple-buffer (non-blocking)
    if (processor.spectrumFifo.consume(spectrumData, fftSize)) {
        // Analysis runs HERE, on the UI thread
        auto suggestions = resonanceDetector.analyse(spectrumData, intent);
        responseCurve.setSuggestions(suggestions);
    }
}

The audio thread's only responsibility is pushing raw FFT magnitudes into the
triple-buffer via spectrumFifo.push() — a single memcpy + atomic swap.

10.5 Memory Bounds & Buffer Safety

Threat model: Buffer overruns when DAW sends unexpectedly large blocks or
when oversampling multiplies buffer sizes.

MatchEQ chunking: Prior to v2.2.0, MatchEQ::applyCorrection() silently
returned without processing when numSamples > fftSize. Now it chunks:

void applyCorrection(float* data, int numSamples) {
    const int maxChunk = fftSize / 2;  // 2048
    for (int offset = 0; offset < numSamples; offset += maxChunk) {
        int chunk = std::min(maxChunk, numSamples - offset);
        applyChunk(data + offset, chunk);  // Process bounded chunk
    }
}

Oversampling buffer bounds: JUCE's Oversampling class internally manages
buffers sized to maxBlockSize * oversamplingFactor. We call initProcessing()
with the maximum expected block size in prepareToPlay().

10.6 Cryptographic & Licensing Security

Threat model: License bypass, key forgery, replay attacks, timing attacks.

HMAC-SHA256 signatures: License keys are signed with HMAC-SHA256. The signing
secret is XOR-obfuscated in the binary (not plaintext):

// LicenseValidator.h — obfuscated secret
static constexpr uint8_t enc[] = { 0x0a, 0x10, 0x13, ... };  // XOR 0x5A
for (size_t i = 0; i < sizeof(enc); ++i)
    buf[i] = (char)(enc[i] ^ 0x5A);

Constant-time comparison: Signature verification uses XOR accumulation to
prevent timing side-channels:

int mismatch = 0;
for (int i = 0; i < expectedB64.length(); ++i)
    mismatch |= expectedB64[i] ^ receivedSig[i];
return mismatch == 0;

Device binding: Licenses are bound to a SHA-256 hash of:

macOS: IOPlatformUUID from IOKit
Windows: HKLM\SOFTWARE\Microsoft\Cryptography\MachineGuid
Linux: /etc/machine-id or /var/lib/dbus/machine-id

Activation limits: Server enforces 2 devices per license with idempotent
Stripe webhook handling (KV deduplication by session:${session.id}).

10.7 Supply Chain & Build Isolation

Threat model: Compromised dependencies or build scripts inject malicious code.

Dependency pinning: JUCE is pinned to v7.0.12 as a git submodule with a
specific commit hash. The build does not fetch arbitrary remote packages.

Server isolation: The server/ directory contains a standalone Cloudflare
Worker deployed separately from the plugin binary. It is never compiled into
the VST3/AU/Standalone artifacts. The plugin performs offline HMAC validation
first; online activation is optional and fails gracefully.

CI/CD hardening: GitHub Actions workflows use:

Pinned action versions (actions/checkout@v4)
Explicit runner images (macos-14, ubuntu-latest, windows-latest)
No arbitrary script downloads in the build path
pluginval validation at strictness-level-10 before artifact upload

10.8 Audit Summary

Category	Threat	Mitigation	Verified
Denormals	CPU stall, NaN	`ScopedNoDenormals`	✅
Filter explosion	Inf output	SVF trapezoidal stability	✅
Audio thread alloc	Dropout	Pre-allocated pools	✅
Lock contention	Priority inversion	Lock-free triple-buffer	✅
Smart EQ on audio thread	Dropout	UI timer isolation	✅
Buffer overrun	Crash/exploit	Chunking + bounds checks	✅
License forgery	Piracy	HMAC-SHA256 + device bind	✅
Timing attack	Key leak	Constant-time compare	✅
Supply chain	Backdoor	Pinned deps, isolated server	✅

All mitigations are verified via automated tests (Tests/AuditRegressionTest.cpp,
Tests/SvfTest.cpp) and manual code audit. The codebase achieves Production-grade
real-time safety for mission-critical audio deployment.

Published Outreach

This paper has been summarized and published in accessible formats:

dev.to: FreeEQ8 Technical Architecture (note: original cramping claims were incorrect)
dev.to: FreeEQ8 Technical Architecture
DAFx26 Demo Paper (PDF): https://garebear99.github.io/FreeEQ8/pdf/DAFx26_FreeEQ8.pdf
TizWildin Hub Academics: https://garebear99.github.io/TizWildinEntertainmentHUB/ (Academics tab)

Acknowledgments

The Simper SVF topology is due to Andrew Simper (Cytomic) [1]. The RBJ biquad
coefficients and Audio EQ Cookbook are due to Robert Bristow-Johnson [6].

The 5-DOF constraint framework in §2.4, the geometric-mean pinning approach
in §9.1, and the Q·sqrt(G) convention documented in SvfBiquad.h are all
drawn from public comments by Robert Bristow-Johnson on r/DSP (May 2026) [10]
in response to questions raised by this project. His analysis correctly
identified that cramping is a BLT property affecting both topologies equally,
and that the standard Cookbook 5th constraint (Nyquist = DC) is the root cause.

The characterization of the SVF's actual advantages — improved SNR near DC,
reduced coefficient-change noise, and more stable interpolation for Dynamic EQ
— is due to SkoomaDentist's r/DSP comment (May 2026) [12]. The insight that
these properties are orthogonal to frequency warping correction clarified the
correct framing for this paper's use of the SVF topology.

JUCE forum feedback from Nitsuj70, holy-city, zsliu98, and kerfuffle informed
the Q-distortion measurements and identified errors in the original paper.
Rekkerd.org and AudioApp.cn provided early editorial coverage.
This work is released under GPL-3.0.

References

[1] A. Simper, "Solving the continuous SVF equations using trapezoidal integration
and equivalent currents," Cytomic, 2013.
https://cytomic.com/files/dsp/SvfLinearTrapOptimised2.pdf

[2] W. Pirkle, "Designing Audio Effect Plugins in C++," Focal Press, 2019.

[3] J. Reiss and A. McPherson, "Audio Effects: Theory, Implementation and
Application," CRC Press, 2014.

[4] F. Renn-Giles and D. Rowland, "Real-time 101," ADC 2019.
https://github.com/hogliux/farbot

[5] JUCE, "juce::dsp::Oversampling," Articy, 2023.
https://docs.juce.com/master/classjuce_1_1dsp_1_1Oversampling.html

[6] R. Bristow-Johnson, "Audio EQ Cookbook," musicdsp.org, 1994.
https://www.musicdsp.org/files/Audio-EQ-Cookbook.txt

[7] B. C. J. Moore, "An Introduction to the Psychology of Hearing,"
6th ed., Brill, 2012.

[8] ISO 226:2003, "Acoustics — Normal equal-loudness-level contours."

[9] H. Haas, "The influence of a single echo on the audibility of speech,"
Acustica, vol. 1, pp. 49-58, 1951.

[10] R. Bristow-Johnson, comment on "I wrote a paper on why your EQ plugin lies
to you at high frequencies," r/DSP, Reddit, May 2026.
https://www.reddit.com/r/DSP/comments/1tqynr5/

[11] S. P. Orfanidis, "Digital parametric equalizer design with prescribed
Nyquist-frequency gain," J. Audio Eng. Soc., vol. 45, no. 6, pp. 444-455,
1997. https://www.collinsaudio.com/Prosound_Workshop/orfanidis%20decramping.pdf

[12] SkoomaDentist, comment on "I wrote a paper on why your EQ plugin lies
to you at high frequencies," r/DSP, Reddit, May 2026.
https://www.reddit.com/r/DSP/comments/1tqynr5/

[13] R. Bristow-Johnson, answer to "Why does the Direct Form I become our first
choice for fixed-point implementation?" DSP Stack Exchange, 2022.
https://dsp.stackexchange.com/questions/76826/why-does-the-direct-form-i-become-our-first-choice-for-fixed-point-implementatio/76855#76855

[14] R. Bristow-Johnson, answer to "Best implementation of a real-time,
fixed-point IIR filter with constant coefficients," DSP Stack Exchange.
https://dsp.stackexchange.com/questions/21792/best-implementation-of-a-real-time-fixed-point-iir-filter-with-constant-coeffic/21811#21811

[15] R. Bristow-Johnson and K. Bogdanowicz, "Intraframe Time-Scaling of
Nonstationary Sinusoids Within the Phase Vocoder," in Proc. IEEE Workshop
on Applications of Signal Processing to Audio and Acoustics (WASPAA),
New Paltz, NY, Oct. 2001, pp. W2001-1–W2001-4.

[16] R. Bristow-Johnson, "Wavetable Synthesis 101, A Fundamental Perspective,"
in Proc. AES 101st Convention, Los Angeles, Nov. 1996, Preprint 4486.
(Also: "A Detailed Analysis of a Time-Domain Formant-Corrected Pitch-Shifting
Algorithm," J. Audio Eng. Soc., vol. 43, no. 5, pp. 340–352, May 1995.
https://aes2.org/publications/elibrary-page/?id=6514)

[17] K. B. Christiansen, "Parametric Equalizer Design with Arbitrary Frequency
Response Specification Near Nyquist," [paper pending author confirmation
— referenced by R. Bristow-Johnson as a more complete treatment than
Orfanidis 1997, resolving the slope discontinuity at Nyquist].

[18] V. Zavalishin, "The Art of VA Filter Design," Urs Heckmann Audio, 2018.
https://www.native-instruments.com/fileadmin/ni_media/downloads/pdf/VAFilterDesign_2.1.0.pdf
(Provides the TPT/trapezoidal integration framework underlying the Simper SVF.)

[19] R. Bristow-Johnson, "The Equivalence of Various Methods of Computing
Biquad Coefficients for Audio Parametric Equalizers," in Proc. AES 97th
Convention, San Francisco, Nov. 1994, Preprint 3906.
(Proves that all biquad topologies produce identical transfer functions —
directly supports §2.3 measurement of 0.000 dB difference between RBJ and SVF.)

[20] U. Zölzer (Ed.), "DAFX: Digital Audio Effects," 2nd ed., Wiley, 2011.
(Standard DSP reference for filter structures, oversampling, and audio effect

implementation methodology cited across §2, §3, §4.)

FreeEQ8 — State-variable EQ architecture (SVF vs RBJ), lock-free JUCE design, and realtime-safe DSP structure

Gary Doman/TizWildin — Fri, 29 May 2026 17:30:24 +0000

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

FreeEQ8 has officially evolved beyond “just a free EQ plugin.”

Gary Doman/TizWildin — Fri, 29 May 2026 16:24:18 +0000

FreeEQ8 has officially evolved beyond “just a free EQ plugin.”

The project now includes:
🎛️ Advanced decramped recursive EQ architecture
📄 DAFx-style DSP research papers
⚡ Real-time-safe processing systems
🧠 Benchmark-driven engineering validation
🔬 Deep documentation covering DSP theory, runtime behavior, and implementation design

Recent work focuses on measurable DSP behavior instead of vague marketing claims:
• High-frequency decramping near Nyquist
• Filter integrity & phase behavior
• Parameter smoothing & automation stability
• Lock-free architecture concepts
• CPU/runtime determinism
• Real-world plugin scalability

The ecosystem itself is also expanding into a full infrastructure platform with:
🔑 Account systems
📦 License/key management
📊 Community infrastructure dashboards
🛠️ Open-source tooling
🎮 Experimental DSP/game systems
📚 Research documentation

You can now create an account directly through the HUB to manage licenses, ecosystem access, future releases, and platform features.

🌐 HUB:
https://garebear99.github.io/TizWildinEntertainmentHUB/

📚 Technical Paper / Documentation:
https://github.com/GareBear99/FreeEQ8/blob/main/PAPER.md

💻 FreeEQ8 Repository:
https://github.com/GareBear99/FreeEQ8

The goal is simple:
build open-source DSP systems with the level of transparency, rigor, and architectural documentation normally reserved for commercial research environments.

DSP #AudioProgramming #JUCE #OpenSource #AudioEngineering #VST #MusicTech #DAFx #PluginDevelopment #DigitalSignalProcessing #CPlusPlus #FreeEQ8

🎛️ TizWildin HUB is LIVE

Gary Doman/TizWildin — Thu, 28 May 2026 13:49:36 +0000

🎛️ TizWildin HUB is LIVE

The central platform for all TizWildin Entertainment products is now online.

What's inside:
🔑 Account management with Google Sign-In
🎚️ ProEQ8 license activation & recovery
💎 Master Key subscriptions for power users
📻 24/7 Radio Stream (coming soon)
🎁 Community giveaway at 1,000 users

For producers:
• 21 VST3/AU plugins
• 11 free sample packs
• 3 browser-based MIDI tools
• Song submission portal

First 1,000 members unlock exclusive packs + plugin upgrades.

TizWildin Entertainment HUB — Free Plugins, Sample Packs, Audio Lists & ARC Source Spine

Free audio plugins, producer kits, sample packs, public discovery lists, and ARC source-spine links from GareBear99 / TizWildin.

garebear99.github.io

MusicProduction #VST #AudioPlugins #ProducerLife #TizWildin

Real-Time State-Space Parameterization and Lock-Free Semantic Analysis in Digital Equalization Update:

Gary Doman/TizWildin — Wed, 27 May 2026 20:26:57 +0000

Real-Time State-Space Parameterization and Lock-Free Semantic Analysis in Digital Equalization

Gary Doman (GareBear99 / TizWildin)

FreeEQ8 / ProEQ8 Open-Source DSP Project

https://github.com/GareBear99/FreeEQ8

Abstract

This paper presents the architecture of a production-grade 8-band parametric
equalizer designed to eliminate high-frequency magnitude cramping without the
computational overhead of brute-force oversampling. By utilizing a 64-bit
double-precision implementation of the Simper State Variable Filter (SVF)
topology via trapezoidal integration, the system achieves a de-cramped
frequency response near the Nyquist limit while consuming only 0.62% of a
single-core real-time CPU budget at 44.1 kHz (161× headroom). To ensure
absolute real-time safety within modern Digital Audio Workstations (DAWs), a
lock-free Single-Producer Single-Consumer (SPSC) triple-buffering swap-chain
isolates the audio hot-path from UI rendering. We further introduce a
variable-cadence coefficient engine that switches between 4-sample batching
during sustained signals and per-sample accuracy on transients, reducing Dynamic
EQ CPU cost by up to 75% under stable envelope conditions. Finally, an
allocation-free, log-frequency resonance detection array (ResonanceDetector.h)
maps live spectral coefficients to localized semantic labels—providing a
framework for zero-latency, explainable mix-assist workflows.

1. Introduction

Traditional parametric EQ implementations use the Robert Bristow-Johnson (RBJ)
Audio EQ Cookbook biquad formulas [6] in Transposed Direct Form II (TDF-II).
While mathematically correct, the bilinear transform introduces frequency
cramping near Nyquist: a Bell filter at 16 kHz with Q=1.0 at 44.1 kHz exhibits
an effective bandwidth 199% narrower than intended. Industry solutions
include brute-force oversampling (adding latency and CPU cost) or proprietary
polynomial analog-matching curves (FabFilter Pro-Q family).

This paper documents a third path: the Simper SVF topology, which pre-warps
the cutoff frequency via g = tan(π·fc/fs), achieving exact cutoff placement
at any frequency up to Nyquist without oversampling. All eight required filter
types (Bell, LowShelf, HighShelf, LP, HP, Bandpass, Notch, AllPass) emerge from
a single two-integrator core, simplifying maintenance and enabling structural
modulation safety that TDF-II cannot provide.

2. Filter Topology

2.1 RBJ TDF-II (Legacy Path — FreeEQ8)

H(z) = (b₀ + b₁z⁻¹ + b₂z⁻²) / (1 + a₁z⁻¹ + a₂z⁻²)

Measured Q distortion (Bell, Q=1.0, 44.1 kHz):

Frequency	RBJ effective Q	Error
1 kHz	1.005	+0.5%
8 kHz	1.337	+33.7%
16 kHz	2.990	+199%

2.2 Simper SVF (Modern Path — ProEQ8)

Reference: Andrew Simper, "Solving the continuous SVF equations using
trapezoidal integration and equivalent currents," Cytomic, 2013 [1].

Pre-warped cutoff:

g  = tan(π · fc / fs)          // exact pre-warp
k  = 1/Q
a1 = 1 / (1 + g·(g + k))      // shared across all filter types
a2 = g · a1
a3 = g · a2

Per-sample processing (optimised bounded form):

v3  = v0 - ic2eq
t   = a2 * ic1eq               // cached — eliminates redundant mul
v1  = a1 * ic1eq + a2 * v3    // bandpass
v2  = ic2eq + t + a3 * v3     // lowpass
ic1eq = v1 + v1 - ic1eq       // v+v avoids 2.0* mul
ic2eq = v2 + v2 - ic2eq
out = m0·v0 + m1·v1 + m2·v2  // filter-type-specific mix

Output mix coefficients per filter type (from Simper paper §§3–8):

Type	m0	m1	m2
LP	0	0	1
HP	1	−k	−1
BP	0	1	0
Bell	1	kA·(A²−1)	0
LowShelf	1	k·(A−1)	A²−1
HighShelf	A²	k·(1−A)·A	1−A²

where A = 10^(gainDb/40) and kA = k/A (Bell uses modified denominator).

Measured performance (g++ -O3, 44.1 kHz, 512-sample block, 8-band stereo):

Path	ns/sample	CPU headroom
RBJ 8-band	40.7	277×
SVF 8-band	70.4	161×
SVF overhead	1.73×	—
CPU budget used	0.62%	—

3. Real-Time Safety Architecture

3.1 SPSC Triple-Buffer (SpectrumFIFO)

3.2 Off-Thread FIR Reconstruction (LinearPhaseEngine)

3.3 Allocation-Free Hot Path

4. Variable-Cadence Dynamic EQ (v2.2.3)

Variable-cadence algorithm:

δ = |dynGainMod − lastDynGainMod|
if δ > 0.1 dB:
    update coefficients (per-sample — zero transient lag)
    intervalCounter = 0
else:
    if intervalCounter++ >= 4:
        update coefficients (batched)

5. Allocation-Free Semantic Analysis (ResonanceDetector)

Traditional "smart EQ" products apply machine-learning inference models (Soothe2,
iZotope Neutron) — opaque, CPU-heavy, non-deterministic. We introduce a
deterministic alternative that adds zero latency and allocates no memory:

Take the 2048-bin log-magnitude spectrum from SpectrumFIFO (UI thread rate).
Re-sample into a 96-bin log-frequency grid (20 Hz → Nyquist).
Estimate local baseline via ±0.5-octave moving average.
Flag peaks where (magnitude − baseline) ≥ 3 dB and peak is local max in ±3-bin neighbourhood.
Score each peak: score = deviation × intentWeight(hz, mode) where intentWeight is a log-frequency Gaussian bump per IntentMode profile.
Return top-4 suggestions: {freqHz, gainDb, q, confidence, label}.

The intentWeight function encodes instrument-specific problem zones:

Mode	Primary Bump	Zone
VocalClean	×1.6 at 300 Hz	mud
DrumPunch	×1.5 at 300 Hz	boxiness
GuitarSpace	×1.5 at 250 Hz	mud
MasterPolish	×1.3 at 250 Hz	low-end buildup

Semantic labels from FrequencyExplainer.h map frequency ranges to strings
("mud", "harshness", "sibilance", "air") enabling explain-on-hover UX.

7. Benchmarks (Measured — Reproducible)

All benchmarks run from Tests/FeatureBench.cpp — standalone, no JUCE, no DAW,
no mock. Build: g++ -std=c++17 -O3 -DNDEBUG -pthread Tests/FeatureBench.cpp -o FeatureBench -ISource.
Platform: Linux x86-64, g++ 13.3.0. Median of 16 trials, 4 warmup runs discarded.

7.1 Single-Instance Filter Cost

Path	ns/sample	MB/s	CPU% (44.1kHz/512/50%)	Headroom
RBJ 8-band stereo	41.0	98	0.36%	277×
SVF 8-band stereo	72.7	55	0.63%	161×
SVF overhead vs RBJ	1.61×	—	—	—
SVF DynEQ per-sample	68.8	58	0.61%	165×

7.2 Instance Scaling (Real DAW Load Simulation)

Instances	RBJ ns/samp	RBJ CPU%	SVF ns/samp	SVF CPU%	SVF/RBJ
1	44.4	0.39%	71.9	0.63%	1.62×
8	46.6	0.41%	73.4	0.65%	1.58×
32	47.5	0.42%	75.1	0.66%	1.58×
64	46.4	0.41%	75.9	0.67%	1.64×
128	46.8	0.41%	75.5	0.67%	1.61×

At 128 SVF instances total CPU = 128 × 0.67% = 85.8% of one core at 44.1 kHz
with 512-sample blocks. A modern 8-core CPU can host ~900 SVF instances.

7.3 Worst-Case Dynamic EQ

Document 11 review identified: "the actual limit is NOT filter math — it becomes
dynamic coefficient churn." This benchmark quantifies exactly that ceiling.

Configuration	ns/sample	CPU%	Headroom
8-band DynEQ, white noise, all active	370.9	3.27%	30.6×

7.4 SvfBandArray — Packed SIMD Scaffold

The SvfBandArray<8> template (v2.2.4) packs all 8 band states into aligned
arrays for SIMD dispatch. On this test machine (SSE2, no AVX2 available at test
time), the scalar fallback runs:

Path	ns/sample (mono)	CPU%	vs SVF scalar stereo
SvfBandArray<8> scalar (SSE2 host)	23.5	0.21%	3.1× faster

7.5 MatchEQ Hot-Path Optimization

Path	ns/sample equivalent	Speedup
Naive pow(10) per bin (old)	7.4	—
Pre-computed correctionGain	2.8	3.0×

7.6 Reproducing These Results

git clone --recursive https://github.com/GareBear99/FreeEQ8.git
cd FreeEQ8
g++ -std=c++17 -O3 -DNDEBUG -pthread Tests/FeatureBench.cpp -o FeatureBench -ISource
./FeatureBench          # human-readable table
./FeatureBench --csv    # machine-readable CSV

# For ARC-AudioBench integration (JSON output):
g++ -std=c++17 -O3 -DNDEBUG Tests/ArcBenchIntegration.cpp -o ArcBench -ISource
./ArcBench --json > arc_results.json

Numbers will vary by CPU and compiler. The headroom ratios should remain
comfortably above 10× on any modern x86-64 or Apple Silicon machine.

7. Future Work (v2.2.5+)

Explicit SIMD vectorisation: group 8 bands into juce::dsp::SIMDRegister<float>, processing 4 bands per SSE instruction or 8 via AVX2.
Cross-instance masking negotiation: via ARC-Core local IPC spine, multiple plugin instances communicate energy peaks and negotiate inverse dynamic notches.
Spectral dynamics mode: per-bin FFT threshold clamping (Soothe2 territory) using the existing overlap-add Match EQ infrastructure.
Dolby Atmos 9.1.6: expand isBusesLayoutSupported for discrete immersive channel arrays with spatial zone linking.

References

[1] A. Simper, "Solving the continuous SVF equations using trapezoidal integration
and equivalent currents," Cytomic, 2013.
https://cytomic.com/files/dsp/SvfLinearTrapOptimised2.pdf

[2] W. Pirkle, "Designing Audio Effect Plugins in C++," Focal Press, 2019.

[3] J. Reiss and A. McPherson, "Audio Effects: Theory, Implementation and
Application," CRC Press, 2014.

[4] F. Renn-Giles and D. Rowland, "Real-time 101," ADC 2019.
https://github.com/hogliux/farbot

[5] JUCE, "juce::dsp::Oversampling," Articy, 2023.
https://docs.juce.com/master/classjuce_1_1dsp_1_1Oversampling.html

[6] R. Bristow-Johnson, "Audio EQ Cookbook," musicdsp.org, 1994.
https://www.musicdsp.org/files/Audio-EQ-Cookbook.txt

Studio Violin - Helmholtz bowed string · H2 correction · Stradivari body EQ · Sympathetic resonance · Physical modelling

Gary Doman/TizWildin — Sun, 24 May 2026 21:13:55 +0000

Studio Violin
Helmholtz bowed string · H2 correction · Stradivari body EQ · Sympathetic resonance · Physical modelling
Instrument Summary
The most technically advanced instrument in the suite. Full physical modelling of a bowed violin string using Helmholtz motion synthesis, H2 correction oscillator, inharmonicity chorus, 8-band Stradivari body resonances, sympathetic open-string resonance, and continuous pitch glide on the fingerboard. All parameters are derived from peer-reviewed acoustic measurements.

Synthesis Features
Helmholtz waveform: bₙ = −(2/n²π²D(1−D))·sin(nπD), D = 0.5 + bowPressure×0.30
H2 correction oscillator: brings H2/H1 from 0.27 to 0.65 (Schelleng measured target)
Inharmonicity chorus: ±2.5 cents per-string (B: G=0.00035, D=0.00028, A=0.00022, E=0.00018)
8-band Stradivari EQ: A0(275Hz), A1(475Hz), B1-(530Hz), B1+(580Hz), bridge hill(2800Hz Q=6.5), upper(4500Hz), notch(1100Hz), warmth(180Hz)
Per-string body offsets: G string warmer (−3dB bridge hill), E string brighter (+3dB)
Sympathetic resonance: 4 triangle oscillators at open string Hz, amplitude = (1−cents/20)×0.038
Nonlinear bow coupling: tanh(bowSpeed×bowPressure×3.8)×0.42
Pressure-coupled vibrato: effDepth = depth×(0.6+pressure×0.6)
Interval-scaled portamento: glideTime = (18+semitones×4)ms
Attack scratch: 20–60ms noise burst, speed-dependent release: 0.10+(1−bowSpeed)×0.28s
Signal Chain
PeriodicWave osc → H2 osc → Chorus oscs → WaveShaper → InjGain → WarmShelf → 8×peaking body EQ → Master

Novel Contribution
Single-Source-of-Truth Cross-Platform Virtual Instrument Architecture. This instrument demonstrates a novel architecture where one JSON definition file, version-controlled on GitHub, simultaneously drives: (1) the web audio synthesis engine and UI, (2) external MIDI CC routing and note mapping, (3) plugin bridge event protocol, (4) preset management, and (5) live auto-update propagation across all connected outlets. Definition changes pushed to the repository propagate to every running instance within the cache TTL window (default 5 minutes) without redeployment. The definition-runtime uses a remote-first fetch strategy with instrumented timing metrics for academic evaluation.

Measurable claims: The Evaluation Metrics panel (right sidebar) displays live measurements of SSOT fetch latency, definition apply time, remote source availability, and MIDI pipeline latency — all captured via performance.now() high-resolution timestamps. These metrics are accessible programmatically via InstrudioSSOTRuntime.getMetrics() and InstrudioMIDI.getLatencyMetrics().

Academic References
1973
Schelleng, J.C. "The bowed string and the player." JASA 53(1):26–41. — Measured violin harmonic spectrum showing H2/H1=0.65. The H2 correction oscillator gain 0.38 was calibrated to reach this target.
2002
Jansson, E.V. Acoustics for Violin and Guitar Makers, 4th ed. KTH Stockholm. — Stradivari body resonance frequencies A0, A1, B1−, B1+ from Table 6.1. Bridge hill at 2800Hz and Q=6.5 from Chapter 7.
2004
Woodhouse, J. "Bowed string simulation using a thermal friction model." Acustica 90. — Helmholtz motion Fourier series derivation. The formula bₙ = 2/(n²π²D(1−D))·sin(nπD) is from Woodhouse's eq. 4.2.
2010
Smith, J.O. Physical Audio Signal Processing. CCRMA, Stanford. — Digital waveguide theory and Thiran allpass interpolation. Vibrato Hz-based depth formula from Chapter 4.
2026
Doman, G. "Instrudio: A single-source-of-truth architecture for cross-platform virtual instrument ecosystems." GitHub, 2026. — Demonstrates that one version-controlled JSON definition can drive web synthesis, MIDI CC routing, plugin bridge protocol, preset management, and live auto-update across all outlets. Reference implementation with instrumented evaluation metrics.

Repo:
github.com/GareBear99/Instrudio

!FREE! Violin Synth Kit:
https://github.com/GareBear99/Free-Violin-Synth-Sample-Kit

Live Demo: https://garebear99.github.io/Instrudio/Instrudio_v2/violin.html

Real-Time State-Space Parameterization and Lock-Free Semantic Analysis in Digital Equalization

Gary Doman/TizWildin — Sun, 24 May 2026 20:52:39 +0000

Real-Time State-Space Parameterization and Lock-Free Semantic Analysis in Digital Equalization
Gary Doman (GareBear99 / TizWildin)
FreeEQ8 / ProEQ8 Open-Source DSP Project

GareBear99 / FreeEQ8

FreeEQ8 is a professional-grade, free and open-source 8-band parametric EQ plugin for macOS, Linux, and Windows. Linear phase, dynamic EQ, match EQ, per-band drive, band linking, M/S processing, oversampling, and a real-time spectrum analyzer. FabFilter Pro-Q alternative for $0–$20

🎛️ Part of the TizWildin Plugin Ecosystem — 20+ free audio plugins, creator tools, lists, deconstructed-loop routers, and release surfaces.

FreeEQ8 · FreeVox8 · XyloCore · Instrudio · Therum · BassMaid · SpaceMaid · GlueMaid · MixMaid · MultiMaid · MeterMaid · ChainMaid · PaintMask · WURP · AETHER · WhisperGate · RiftWave · FreeSampler · VF-PlexLab · PAP-Forge-Audio

🎧 SoundCloud: TizWildin on SoundCloud — original music, remixes, VIP mixes, experimental drops, and underground releases.

🎁 Free Packs & Samples — jump to free packs & samples

🎵 Awesome Audio — My (FREE) Awesome Audio Dev List

▶️ YouTube — music, visuals, demos, and releases
🌊 Voxel Audio — free RGB waveform visualizer and audio export tool
📘 Facebook Page — TizWildin / GareBearProductionz updates and Media

🎧 Awesome Audio Lists — even more audio lists, submission routes, and promotional directories

⭐ Featured / submitted on — full tracker →…

View on GitHub

Abstract
This paper presents the architecture of a production-grade 8-band parametric equalizer designed to eliminate high-frequency magnitude cramping without the computational overhead of brute-force oversampling. By utilizing a 64-bit double-precision implementation of the Simper State Variable Filter (SVF) topology via trapezoidal integration, the system achieves a de-cramped frequency response near the Nyquist limit while consuming only 0.62% of a single-core real-time CPU budget at 44.1 kHz (161× headroom). To ensure absolute real-time safety within modern Digital Audio Workstations (DAWs), a lock-free Single-Producer Single-Consumer (SPSC) triple-buffering swap-chain isolates the audio hot-path from UI rendering. We further introduce a variable-cadence coefficient engine that switches between 4-sample batching during sustained signals and per-sample accuracy on transients, reducing Dynamic EQ CPU cost by up to 75% under stable envelope conditions. Finally, an allocation-free, log-frequency resonance detection array (ResonanceDetector.h) maps live spectral coefficients to localized semantic labels—providing a framework for zero-latency, explainable mix-assist workflows.

Introduction Traditional parametric EQ implementations use the Robert Bristow-Johnson (RBJ) Audio EQ Cookbook biquad formulas [6] in Transposed Direct Form II (TDF-II). While mathematically correct, the bilinear transform introduces frequency cramping near Nyquist: a Bell filter at 16 kHz with Q=1.0 at 44.1 kHz exhibits an effective bandwidth 199% narrower than intended. Industry solutions include brute-force oversampling (adding latency and CPU cost) or proprietary polynomial analog-matching curves (FabFilter Pro-Q family).

This paper documents a third path: the Simper SVF topology, which pre-warps the cutoff frequency via g = tan(π·fc/fs), achieving exact cutoff placement at any frequency up to Nyquist without oversampling. All eight required filter types (Bell, LowShelf, HighShelf, LP, HP, Bandpass, Notch, AllPass) emerge from a single two-integrator core, simplifying maintenance and enabling structural modulation safety that TDF-II cannot provide.

Filter Topology 2.1 RBJ TDF-II (Legacy Path — FreeEQ8) H(z) = (b₀ + b₁z⁻¹ + b₂z⁻²) / (1 + a₁z⁻¹ + a₂z⁻²) Coefficients computed per the RBJ cookbook [6]. 64-bit double internal state, float I/O. Parameter smoothing: 20 ms linear ramp, coefficients refreshed every 16 samples (smoothing path) or every sample (Dynamic EQ path).

Measured Q distortion (Bell, Q=1.0, 44.1 kHz):

Frequency RBJ effective Q Error
1 kHz 1.005 +0.5%
8 kHz 1.337 +33.7%
16 kHz 2.990 +199%
2.2 Simper SVF (Modern Path — ProEQ8)
Reference: Andrew Simper, "Solving the continuous SVF equations using trapezoidal integration and equivalent currents," Cytomic, 2013 [1].

Pre-warped cutoff:

g = tan(π · fc / fs) // exact pre-warp
k = 1/Q
a1 = 1 / (1 + g·(g + k)) // shared across all filter types
a2 = g · a1
a3 = g · a2
Per-sample processing (optimised bounded form):

v3 = v0 - ic2eq
t = a2 * ic1eq // cached — eliminates redundant mul
v1 = a1 * ic1eq + a2 * v3 // bandpass
v2 = ic2eq + t + a3 * v3 // lowpass
ic1eq = v1 + v1 - ic1eq // v+v avoids 2.0* mul
ic2eq = v2 + v2 - ic2eq
out = m0·v0 + m1·v1 + m2·v2 // filter-type-specific mix
Output mix coefficients per filter type (from Simper paper §§3–8):

Type m0 m1 m2
LP 0 0 1
HP 1 −k −1
BP 0 1 0
Bell 1 kA·(A²−1) 0
LowShelf 1 k·(A−1) A²−1
HighShelf A² k·(1−A)·A 1−A²
where A = 10^(gainDb/40) and kA = k/A (Bell uses modified denominator).

Measured performance (g++ -O3, 44.1 kHz, 512-sample block, 8-band stereo):

Path ns/sample CPU headroom
RBJ 8-band 40.7 277×
SVF 8-band 70.4 161×
SVF overhead 1.73× —
CPU budget used 0.62% —

Real-Time Safety Architecture 3.1 SPSC Triple-Buffer (SpectrumFIFO) Three buffer slots indexed by {writeSlot, midSlot, readSlot} (a permutation of {0, 1, 2}). Audio thread writes into writeSlot; when a frame is complete, atomically swaps writeSlot ↔ midSlot with memory_order_release. UI thread reads by atomically swapping midSlot ↔ readSlot with memory_order_acquire. No mutex, no lock, no blocking on either thread.

3.2 Off-Thread FIR Reconstruction (LinearPhaseEngine)
Linear phase mode latency: 2048 samples (4096-tap Hann-windowed FIR / 2). Parameter changes set an atomic linPhaseDirty flag. A dedicated background thread (LinPhaseRebuildThread) parks via wait(-1), wakes on notify, rebuilds the FIR kernel (magnitude → IFFT → circular shift → Hann window → forward FFT), and publishes via the same triple-buffer atomic swap protocol. Audio thread reads with a single acquire load—never blocks.

3.3 Allocation-Free Hot Path
All oversamplers (1×/2×/4×/8× via JUCE polyphase IIR) are pre-constructed in prepareToPlay() into std::arraystd::unique_ptr<Oversampling<float>, 3>. Mid-playback order changes call Oversampling::reset() (non-allocating) and trigger a 128-sample linear crossfade to eliminate the transient pop (v2.2.3).

Variable-Cadence Dynamic EQ (v2.2.3) Dynamic EQ recomputes biquad coefficients per-sample when active, matching the one-pole envelope follower's cadence. With all 8 bands in dynamic mode the bq.set() call dominates (22 ns/call for SVF Bell). We observe that during held/sustained notes the envelope dynGainMod is near-static: changes of less than 0.1 dB between samples are inaudible within the 4-sample batch window (0.09 ms at 44.1 kHz).

Variable-cadence algorithm:

δ = |dynGainMod − lastDynGainMod|
if δ > 0.1 dB:
update coefficients (per-sample — zero transient lag)
intervalCounter = 0
else:
if intervalCounter++ >= 4:
update coefficients (batched)
Measured savings at 8 bands all-dynamic, sustained note: up to 75% reduction in bq.set() calls with no audible difference. On a transient attack the first sample with δ > 0.1 dB immediately restores per-sample accuracy.

Allocation-Free Semantic Analysis (ResonanceDetector) Traditional "smart EQ" products apply machine-learning inference models (Soothe2, iZotope Neutron) — opaque, CPU-heavy, non-deterministic. We introduce a deterministic alternative that adds zero latency and allocates no memory:

Take the 2048-bin log-magnitude spectrum from SpectrumFIFO (UI thread rate).
Re-sample into a 96-bin log-frequency grid (20 Hz → Nyquist).
Estimate local baseline via ±0.5-octave moving average.
Flag peaks where (magnitude − baseline) ≥ 3 dB and peak is local max in ±3-bin neighbourhood.
Score each peak: score = deviation × intentWeight(hz, mode) where intentWeight is a log-frequency Gaussian bump per IntentMode profile.
Return top-4 suggestions: {freqHz, gainDb, q, confidence, label}.
The intentWeight function encodes instrument-specific problem zones:

Mode Primary Bump Zone
VocalClean ×1.6 at 300 Hz mud
DrumPunch ×1.5 at 300 Hz boxiness
GuitarSpace ×1.5 at 250 Hz mud
MasterPolish ×1.3 at 250 Hz low-end buildup
Semantic labels from FrequencyExplainer.h map frequency ranges to strings ("mud", "harshness", "sibilance", "air") enabling explain-on-hover UX.

Compact View / Mini-Window (v2.2.3) Inspired by Ableton Live's EQ Eight compact device view. Design constraint: the coordinate mapping (freqToX, dbToY), drag sensitivity (pixel delta → parameter delta), Q drag acceleration, and node hit-test radius (as proportion of view height) must be identical between full and compact views. Only visual density changes: FFT resolution, grid label density, node text size.

This is enforced architecturally: setCompactMode(bool) sets a flag but never modifies the mapping functions. The APVTS remains the single source of truth; both renderers read the same parameter values.

Future Work (v2.5+) Explicit SIMD vectorisation: group 8 bands into juce::dsp::SIMDRegister, processing 4 bands per SSE instruction or 8 via AVX2. Cross-instance masking negotiation: via ARC-Core local IPC spine, multiple plugin instances communicate energy peaks and negotiate inverse dynamic notches. Spectral dynamics mode: per-bin FFT threshold clamping (Soothe2 territory) using the existing overlap-add Match EQ infrastructure. Dolby Atmos 9.1.6: expand isBusesLayoutSupported for discrete immersive channel arrays with spatial zone linking. References [1] A. Simper, "Solving the continuous SVF equations using trapezoidal integration and equivalent currents," Cytomic, 2013. https://cytomic.com/files/dsp/SvfLinearTrapOptimised2.pdf

[2] W. Pirkle, "Designing Audio Effect Plugins in C++," Focal Press, 2019.

[3] J. Reiss and A. McPherson, "Audio Effects: Theory, Implementation and Application," CRC Press, 2014.

[4] F. Renn-Giles and D. Rowland, "Real-time 101," ADC 2019. https://github.com/hogliux/farbot

[5] JUCE, "juce::dsp::Oversampling," Articy, 2023. https://docs.juce.com/master/classjuce_1_1dsp_1_1Oversampling.html

[6] R. Bristow-Johnson, "Audio EQ Cookbook," musicdsp.org, 1994. https://www.musicdsp.org/files/Audio-EQ-Cookbook.txt

OST: Wraith Eternal

Gary Doman/TizWildin — Sat, 23 May 2026 02:56:39 +0000

OST for my game Wraith Eternal that I made -

wraiths #wraitheternal #Wraith #wraitheternally #tizwildinentertainment #TizWildin #GareBearProductionz #garebear99 #garydoman #neovectr

https://soundcloud.com/tizwildin/sets/wraith-eternal-ost?si=f52c984f15f6453eac27d93ebb1328c2&utm_source=clipboard&utm_medium=text&utm_campaign=social_sharing

TizWildin Entertainment HUB — Free Plugins, Sample Packs, Audio Lists & ARC Source Spine

Free audio plugins, producer kits, sample packs, public discovery lists, and ARC source-spine links from GareBear99 / TizWildin.

garebear99.github.io

GareBear99 / FreeEQ8

FreeEQ8 is a professional-grade, free and open-source 8-band parametric EQ plugin for macOS, Linux, and Windows. Linear phase, dynamic EQ, match EQ, per-band drive, band linking, M/S processing, oversampling, and a real-time spectrum analyzer. FabFilter Pro-Q alternative for $0–$20

🎛️ Part of the TizWildin Plugin Ecosystem — 20+ free audio plugins, creator tools, lists, deconstructed-loop routers, and release surfaces.

FreeEQ8 · FreeVox8 · XyloCore · Instrudio · Therum · BassMaid · SpaceMaid · GlueMaid · MixMaid · MultiMaid · MeterMaid · ChainMaid · PaintMask · WURP · AETHER · WhisperGate · RiftWave · FreeSampler · VF-PlexLab · PAP-Forge-Audio

🎧 SoundCloud: TizWildin on SoundCloud — original music, remixes, VIP mixes, experimental drops, and underground releases.

🎁 Free Packs & Samples — jump to free packs & samples

🎵 Awesome Audio — My (FREE) Awesome Audio Dev List

▶️ YouTube — music, visuals, demos, and releases
🌊 Voxel Audio — free RGB waveform visualizer and audio export tool
📘 Facebook Page — TizWildin / GareBearProductionz updates and Media

🎧 Awesome Audio Lists — even more audio lists, submission routes, and promotional directories

⭐ Featured / submitted on — full tracker →…

View on GitHub

Neo-VECTR's Rift Ascent

Gary Doman/TizWildin — Sat, 23 May 2026 02:19:50 +0000

Rift Ascent Is Live

Been building systems, tools, audio tech, AI infrastructure, and experimental engines nonstop — but I also wanted to make something people could instantly jump into and experience.

So here’s Rift Ascent.

A fast experimental browser game/project built as part of the larger ecosystem I’ve been developing under TizWildin Entertainment.

Main Hub:

TizWildin Entertainment HUB — Free Plugins, Sample Packs, Audio Lists & ARC Source Spine

Free audio plugins, producer kits, sample packs, public discovery lists, and ARC source-spine links from GareBear99 / TizWildin.

garebear99.github.io

━━━━━━━━━━━━━━━━━━
PLAY RIFT ASCENT
━━━━━━━━━━━━━━━━━━

Live Demo:

garebear99.github.io

━━━━━━━━━━━━━━━━━━
SOURCE CODE
━━━━━━━━━━━━━━━━━━

GitHub Repo:

GareBear99 / RiftAscent

GENERATOR: RIFT ASCENT — Infinite Heat. A canvas-based action game with prestige cycles, upgrades, co-op, and procedural audio. Coming to iOS & Android.

GENERATOR: RIFT ASCENT

Infinite Heat — A canvas-based action game with prestige cycles, upgrades, co-op, and procedural audio.

🔐 Built on ARC-Core — the authoritative event-and-receipt engine. Every player action, wave, prestige cycle, upgrade, and leaderboard submission is an ARC-Core-shaped event with a SHA-256 receipt. The receipt chain is the anti-cheat layer.

🎮 Play Now

https://garebear99.github.io/RiftAscent/

Features

Prestige Cycle — 100-wave loop with meta progression
Infinite Heat — Endless mode with scaling difficulty via wave composition and pressure
Upgrade Economy — Enemies drop credits; spend at the shop to evolve builds
Geo Droids — Cube, Prism, Arc, Mine companions with unique abilities
Procedural Audio — Rift Synthwave engine that reacts to gameplay state
Co-op — Local and online multiplayer
Daily Challenges — Seeded runs with leaderboards
1000 Achievements — Deep progression tracking

Controls

Key	Action
WASD	Move
LMB	Shoot
RMB	Fireball
E	Bomb
SHIFT	Dash (tap)
SPACE	Overdrive
B	Shop

…

View on GitHub

Backened:

GareBear99 / ARC-Core

ARC-Core is a signal-intelligence event spine — a deterministic kernel built to host every project its author has ever developed, in tandem and smoothly, through one universal discipline: every state change is an event, every event produces a signed receipt, and every receipt is authority-gated.

ARC-Core

ARC-Core is a signal-intelligence event spine — a deterministic kernel built to host every project its author has ever developed, in tandem and smoothly, through one universal discipline: every state change is an event, every event produces a signed receipt, and every receipt is authority-gated.

The design bet is simple and falsifiable: if a system — a game, a simulator, a plugin backend, a governed-AI training loop, an archive manager, a language engine, a binary runtime, a cognition lab — can be modeled as entities, events, authority, and receipts, then ARC-Core can serve as its spine. In theory the entire author's project ecosystem (games, engines, simulators, audio plugins, governed-AI stack, archives, languages, binary runtimes) can ride on one ARC-Core authority layer without any project owning another's truth. The seven-repo governed-AI ecosystem plus the five active consumer applications (see below) are the current concrete evidence of that bet.

Inspiration…

View on GitHub

Also, this is the Audio Plugin Suite I made to back it..

GareBear99 / RiftWaveSuite_RiftSynth_WaveForm_Lite

This repository contains the shared DSP, analyzer, sequencing, preset, UI, and infrastructure code used by: WaveForm / RiftSynth / Lite Combo (Free)

🎛️ Part of the TizWildin Plugin Ecosystem — 19 free audio plugins with a live update dashboard.

FreeEQ8 · XyloCore · Instrudio · Therum · BassMaid · SpaceMaid · GlueMaid · MixMaid · MultiMaid · MeterMaid · ChainMaid · PaintMask · WURP · AETHER · WhisperGate · RiftWave · FreeSampler · VF-PlexLab · PAP-Forge-Audio

🎁 Free Packs & Samples — jump to free packs & samples

🎵 Awesome Audio — (FREE) Awesome Audio Dev List

RiftWaveSuite

WaveForm / RiftSynth / Lite Combo (Free)

WaveForm / RiftSynth Lite

Free hybrid audio plugin combining real-time visualization and seed-based generative synthesis.

WaveForm / RiftSynth Lite serves as the entry point to the RiftWave plugin ecosystem.

It includes lightweight versions of two plugins:

• WaveForm Pro
• RiftSynth Pro

Features

WaveForm Lite

Real-time audio visualization.

Includes:

• waveform display
• spectrum analyzer
• stereo scope
• energy visualization

Designed to be lightweight and…

View on GitHub

━━━━━━━━━━━━━━━━━━
WHAT IT IS
━━━━━━━━━━━━━━━━━━

Rift Ascent is part gameplay experiment, part rendering sandbox, part rapid-development testbed.

Built solo while simultaneously developing:

AI tooling
music production systems
JUCE-based audio software
web infrastructure
browser-based interactive systems
cross-domain experimental projects

The goal wasn’t just “make a game.”

The goal was building a reusable ecosystem where:

visuals
gameplay
audio
tooling
deployment
experimentation

can all evolve together.

━━━━━━━━━━━━━━━━━━
WHY BROWSER-BASED?
━━━━━━━━━━━━━━━━━━

Because instant access matters.

No installs.
No launcher.
No friction.

Open link → play immediately.

That philosophy is becoming more important as indie developers compete against massive production pipelines.

━━━━━━━━━━━━━━━━━━
FEEDBACK WANTED
━━━━━━━━━━━━━━━━━━

I’m actively iterating on:

mechanics
visuals
movement feel
performance
progression systems
environmental design
audio integration

If you try it, let me know:

what feels good
what feels bad
what you’d expand
what you’d remove entirely

━━━━━━━━━━━━━━━━━━
BIGGER ECOSYSTEM
━━━━━━━━━━━━━━━━━━

Rift Ascent is connected to a much larger solo-built ecosystem currently in development through:

https://github.com/GareBear99

Including:

AI infrastructure
audio tools
experimental engines
production utilities
browser-native systems
game prototypes
interactive media experiments

Trying to prove you can still build ambitious multi-domain projects independently without a giant studio behind you.

Would love feedback from:

indie devs
gameplay programmers
web engine developers
audio people
shader/rendering nerds
experimental game designers
anyone interested in browser-native games

gamedev

indiedev

webdev

javascript

github

opensource

browsergames

gamedesign

indiegame

programming

creativecoding

Wraith Eternal & The RoadMap to Permanence..

Gary Doman/TizWildin — Sat, 23 May 2026 02:01:31 +0000

100% has everything to do with game development, geometrical patterning to be exact NEEDS to always equate to flower of life math and be deterministically auditable, otherwise your movie magicking everything.. nothing about my mechanics are fake. All math and code, so this is entirely relevant to a real developer and why it was probably accepted as a post..

"idk who else needs to hear this, but heres your daily soul pattern recognition target for today - "roman numerals are highly intelligent because they not only count perfectly, they are also perfectly alphabetical, 'I' will always come before 'V' making it a perfect both alphabetical and numerical counting system, we would actually get further as a society counting in roman numerals & not numbers which are one sided"

Meaning:

Roman numerals force contextual interpretation instead of pure abstraction. Modern numeric systems optimize computation, but they also flatten symbolic relationships into raw utility. The point wasn’t “Roman numerals are mathematically superior,” it’s that older systems encoded layered meaning, hierarchy, and relational structure differently than modern reductionist systems do.
“Soul pattern recognition target” just means provoking people to think outside deterministic defaults for 5 seconds instead of treating every statement like a spreadsheet problem.

https://ffm.bio/no4km87

TizWildin #tizwildinentertainment #GareBearProductionz #garebear99 #garydoman #quotes #quotesoftheday"

https://github.com/GareBear99/GareBear99

Press / Coverage
https://rekkerd.org/free-freeeq8-parametric-eq-effect-plugin-by-gary-doman/

Wraith Eternal OST
https://soundcloud.com/tizwildin/sets/wraith-eternal-ost?si=2ef419ad6d5c47c0a341262459f99b01&utm_source=clipboard&utm_medium=text&utm_campaign=social_sharing

DEV Community: Gary Doman/TizWildin

An Architectural Blueprint on Gendered Life in Biology

Thesis

References & Readings

The Translation Guide

Flatworms & The Hidden Architecture Behind Biology: An Honest Structured Blueprint on Gendered Life

Flatworms & The Hidden Architecture Behind Biology: An Honest Structured Blueprint on Gendered Life

Thesis

References & Readings

The Translation Guide

The Translation Guide

Lock-Free Dynamic EQ Architecture: A Production-Grade SVF Implementation in JUCE/C++

Lock-Free Dynamic EQ Architecture: A Production-Grade SVF Implementation in JUCE/C++

Abstract

1. Introduction

1.1 Product Architecture

2. Filter Topology

2.1 RBJ TDF-II (Legacy Path — FreeEQ8)

2.2 Simper SVF (Modern Path — ProEQ8)

2.3 Measured Magnitude Response: SVF vs RBJ vs Oversampling

2.4 The 5-DOF Framework and the Root Cause of BLT Cramping

3. Real-Time Safety Architecture

3.1 SPSC Triple-Buffer (SpectrumFIFO)

3.2 Off-Thread FIR Reconstruction (LinearPhaseEngine)

3.3 Allocation-Free Hot Path

3.4 Natural Phase Mode (NaturalPhaseEngine)

3.5 Pre-Ring Artifact Analysis

4. Variable-Cadence Dynamic EQ (v2.2.3)

4.1 Measured Cadence Reduction

5. Smart EQ Layer — Allocation-Free Semantic Analysis

5.1 Architecture Overview

5.2 ResonanceDetector Algorithm

5.3 IntentMode — Behavioural Biasing

5.4 FrequencyExplainer — Semantic Labels

5.5 UI Integration

5.6 Novelty Claims

5.1 Detector Evaluation on Synthetic Signals

5.2 Real-World Evaluation on Synthesized Production Signals

6. Benchmarks (Measured — Reproducible)

6.1 Single-Instance Filter Cost

6.2 Instance Scaling (Real DAW Load Simulation)

6.3 Worst-Case Dynamic EQ

6.4 SvfBandArray — Packed SIMD Scaffold

6.5 MatchEQ Hot-Path Optimization

6.6 Platform Verification: Intel Ivy Bridge (2012 MacBook Pro)

6.7 Reproducing These Results

6.8 Continuous Integration

7. Perceptual Considerations

7.1 ABX Listening Test Infrastructure

8. Compact View Architecture

9. Future Work (v2.4.0+)

9.1 DSP Enhancements

9.2 Smart EQ Evolution

9.3 Platform Expansion

Advanced Runtime Stability & Temporal Coherence

Decramped High-Frequency Response

Deterministic Zero-Allocation Audio Pipeline

FIR Rebuild Safety & Latency-Coherent Kernel Swapping

Oversampling Integrity & Anti-Aliasing Rejection

Numerical Stability Under Extreme Automation

10. Real-Time Safety & Security Audit

10.1 Denormal Handling & Filter Stability

10.2 Audio Thread Real-Time Guarantees

10.3 Lock-Free Concurrency Model

10.4 Smart EQ Thread Isolation

10.5 Memory Bounds & Buffer Safety

10.6 Cryptographic & Licensing Security

10.7 Supply Chain & Build Isolation

10.8 Audit Summary

Published Outreach

Acknowledgments

References

implementation methodology cited across §2, §3, §4.)

Further Reading

FreeEQ8 — State-variable EQ architecture (SVF vs RBJ), lock-free JUCE design, and realtime-safe DSP structure

FreeEQ8 / ProEQ8 — Lock-Free, Allocation-Free Parametric EQ Architecture Using Simper SVF (Open Source Core)

Core DSP Architecture

Real-Time Safety & Concurrency Model

Dynamic EQ + Semantic DSP Layer (Experimental)

Performance Work