World-Class VST3/CLAP Plugins with FAUST + JUCE: The DSP Layer Is the Quality Layer

"Better than JUCE" is the wrong axis. JUCE is a plugin wrapper, GUI toolkit, and utility framework — it is not the thing that limits your analog sound quality. Switching wrappers will not, by itself, make a saturator sound more analog. "Pro/analog" quality is not a single secret either; it is a small set of operationally checkable engineering decisions that live in the DSP algorithm layer, independent of the wrapper — and the most important finding here is that plain JUCE gives you the building blocks (juce::dsp) but not these algorithms. The superior path is JUCE (or a lighter permissive host) plus ADAA / Wave-Digital / AirWindows-grade DSP, composed from vetted, freely-licensed libraries rather than hand-invented raw C++. The honest recommendation is a hybrid stack — DSP authored in FAUST (or Cmajor) plus a permissively-licensed C++ WDF library (chowdsp_wdf, BSD-3) plus hand-finished juce::dsp for the regimes a functional DSP language cannot express — shipped as VST3 + CLAP from one codebase via clap-juce-extensions.

The problem decomposes into three independent layers, and the high-leverage moves are in the bottom two, not the wrapper:

Layer What it decides The quality / AI lever

Wrapper / framework formats (VST3/CLAP/AU), GUI, hosting Lowest quality impact. JUCE is fine; iPlug2 / nih-plug / DPF are leaner VST3+CLAP alternatives.

DSP language how you (and an AI agent) author the DSP The AI-velocity lever — FAUST and Cmajor let an agent write correct, optimized DSP far better than hand C++.

DSP algorithms the actual analog sound The sound-quality lever — AirWindows, chowdsp (WDF + ADAA), proper oversampling.

If you are weighing whether to drop JUCE entirely for a permissive stack, see the companion gap analysis What you must build to replace JUCE with iPlug2 + Dear ImGui + NanoVG + Faust.

Layer	What it decides	The quality / AI lever
Wrapper / framework	formats (VST3/CLAP/AU), GUI, hosting	Lowest quality impact. JUCE is fine; iPlug2 / nih-plug / DPF are leaner VST3+CLAP alternatives.
DSP language	how you (and an AI agent) author the DSP	The AI-velocity lever — FAUST and Cmajor let an agent write correct, optimized DSP far better than hand C++.
DSP algorithms	the actual analog sound	The sound-quality lever — AirWindows, chowdsp (WDF + ADAA), proper oversampling.

Executive summary

The four dominant quality factors, in order of leverage:

Anti-aliasing of nonlinearities. The harshness people blame on a distortion curve is usually aliasing. Fixing it (oversampling, Antiderivative Anti-Aliasing / ADAA, or — best — both together) is the highest-leverage quality move there is.
Circuit-accurate modeling via Wave Digital Filters (WDF) for analog emulation — turning a schematic into a real-time digital model.
Minimal "voiced-by-ear" algorithms (AirWindows-style) — the deliberate opposite of stacking emulation layers — for "character" and summing.
Signal-flow / gain-staging discipline — where conservative multi-stage gain masks the very effect you built.

For the build system: FAUST is excellent for composing well-understood, finite-operation DSP (oscillators, filters, classic reverbs/delays, dynamics) and compiles to portable C++; it is weak exactly where analog "secret sauce" lives (delay-free feedback, implicit-equation nonlinear solvers, iterative VA models). Hence the hybrid stack above.

The biggest non-DSP risk is licensing: "open source" does not mean "safe to ship in a paid product." JUCE (AGPLv3-or-commercial), all chowdsp_utils DSP modules (GPLv3), FFTW (GPL-2.0), Rubber Band (GPL/commercial), Surge/Vital (GPL-3.0) are not drop-in safe for a closed paid plugin. Conversely, chowdsp_wdf (BSD-3), AirWindows (MIT), CLAP (MIT), and — as of October 2025 — the VST3 SDK itself (now MIT) are clean.

The second-biggest risk is trusting agent-authored raw C++ DSP. Practitioner and empirical evidence shows LLM DSP code is "deceptively correct," routinely violates real-time-audio safety rules, and mishandles numerics an agent cannot hear. The mitigation is structural: compose vetted blocks, then gate every output on an objective acceptance battery (compile → null/reference-match → measured aliasing/THD → denormal+NaN guards → RT-safety).

Part 1 — Where professional / analog quality actually comes from

The load-bearing thesis: JUCE gives blocks, not these algorithms

juce::dsp ships generic primitives — Oversampling, WaveShaper, IIR/FIR filters, FFT, convolution, oscillators — but it does not ship ADAA antialiased nonlinearities, Wave Digital Filter circuit models, or voiced analog-character algorithms. JUCE's own dsp::Oversampling documentation describes only the up/down-sampling machinery and leaves the nonlinearity to you [7]. There is no juce::dsp::ADAA and no juce::dsp::WaveDigitalFilter. The algorithms that produce "pro/analog" quality are an additive layer you supply on top of JUCE's blocks — from ADAA/WDF/AirWindows-grade sources — not something JUCE provides. This is why the recommended path is JUCE + ADAA/WDF/AirWindows DSP, and it is the organizing premise of the whole article.

Anti-aliasing of nonlinearities — the highest-leverage factor

The problem. A naive per-sample tanh() or hard-clip waveshaper aliases badly: each order of a polynomial nonlinearity roughly doubles the aliasing, and practitioners routinely misattribute the resulting harshness to the curve rather than to the aliasing it generates [57]. Critically, post-hoc low/high-pass filtering does not fix it, because aliased components fold back into the mid-band; only proper up/down-sampling (or ADAA) removes them at the source [57].

Oversampling. The traditional fix: raise the sample rate, apply the nonlinearity, low-pass, and decimate. juce::dsp::Oversampling implements factors of 2×/4×/8×/16× by cascading half-band stages, with two filter families — filterHalfBandFIREquiripple (linear phase, maximum latency) and filterHalfBandPolyphaseIIR (minimum latency, phase compromise near Nyquist) [7]. The canonical chain is processSamplesUp() → nonlinearity at N× → processSamplesDown() [7]. But oversampling alone is far from ideal, because a nonlinearity can generate an infinite series of harmonics that still alias [1]. Quantitatively, for a hard-driven saturator (spectral falloff ∝ 1/f), oversampling buys only about 6 dB of aliasing reduction per 2× factor (2×→6 dB, 4×→12 dB) [4]. Cost scales linearly: 4× oversampling makes a process about ¼ as efficient [5].

Antiderivative Anti-Aliasing (ADAA). Instead of evaluating f(x), ADAA analytically convolves the nonlinearity with an anti-aliasing kernel under piecewise-linear input interpolation. First-order ADAA is:

y[n] = (F₀(x[n]) − F₀(x[n−1])) / (x[n] − x[n−1]), where F₀ is the antiderivative of f [1].

Second-order (triangular kernel) additionally needs F₁, the antiderivative of x·f(x), giving stronger suppression at the cost of a more complex expression [1]. Worked tanh example: F₀(x)=log(cosh(x)); the second-order F₁ involves a dilogarithm Li₂ term — expensive enough that table-lookup variants exist [1], [5]. Bilbao, Esqueda, Parker & Välimäki (IEEE SPL 2017) generalize ADAA to higher-order antiderivatives that offer considerable improvement in signal-to-noise ratio while needing fewer operations than oversampling [2].

The headline quantified tradeoff. DAFx-16 Table 1 (hard clipper, input gain 10, target ≈46–47 dB SNR): naive processing needs 12× oversampling (529.2 kHz); the rectangular ADAA kernel reaches the same SNR at 4× (176.4 kHz); the triangular kernel at 3× — i.e. first-order ADAA buys roughly a 3× reduction in required oversampling at equal aliasing [1].

The hybrid is best — and three independent parties agree. ADAA steepens the harmonic falloff so that oversampling regains efficiency; ADAA combined with 4× oversampling makes aliasing practically a non-issue even for a hard clipper [4]. Chowdhury independently recommends pairing ADAA with a modest amount of oversampling [5], and the DAFx-16 table quantifies it [1]. A 2025 result on antialiased recurrent models finds the best configuration is a 3× oversampled first-order ADAA model, not ADAA alone [9].

Reference implementation. Jatin Chowdhury's open ADAA repo provides a VST3/AU plugin with hard-clip, tanh, and nonlinear-waveguide nonlinearities, each in six variants (standard, 1st/2nd-order ADAA, plus table-lookup forms), combinable with 2×/4×/8× oversampling — the canonical bridge from the papers to JUCE code [6].

Circuit-accurate modeling via Wave Digital Filters (WDF)

WDFs digitize a lumped analog circuit by replacing Kirchhoff voltage/current variables with incident/reflected wave variables, connecting elements through series and parallel adaptors (scattering junctions); each delay element corresponds physically to stored energy in a capacitor or inductor [11]. The canonical reference is Fettweis, "Wave Digital Filters: Theory and Practice," Proc. IEEE 74(2):270–327, 1986 [10]; the standard audio-DSP pedagogy is Julius O. Smith's Physical Audio Signal Processing (CCRMA) [11].

Classic WDFs were restricted to tree-like topologies (pure nested series/parallel) to avoid non-computable delay-free loops [18]. Kurt Werner's Stanford dissertation (2016) broke that ceiling with the R-type ("Rigid") adaptor — a scattering matrix that is neither series nor parallel — enabling arbitrary topologies and multiple/multiport nonlinearities (tone stacks, full amp circuits, Pultec-style EQ) [12], [13]. WDF is demonstrated on real circuits, e.g. the Dunlop Fuzz Face, at CCRMA [12]. This is the basis of high-end analog emulation: a WDF model is derived from the schematic (resistor/capacitor/inductor/diode/tube values), so it tracks the circuit's actual behavior rather than approximating its output curve.

Software. chowdsp_wdf (Jatin Chowdhury) is a header-only C++, BSD-3-Clause WDF library supporting R/C/L, diodes (Wright–Omega), op-amps and R-type adaptors, with a compile-time template API that inlines away virtual dispatch (the generated assembly contains zero call instructions) and explicit SIMD; the author reports it outperforms RT-WDF and FAUST's wdmodels library [14], [15]. It ships in a real product, ChowDSP BYOD (GPLv3) [17]. WDF in FAUST is a separate library, wdmodels.lib (GRAME), not chowdsp_wdf — a nuance worth not getting wrong [16].

AirWindows-style minimal, voiced-by-ear algorithms

The deliberate opposite of stacking emulation layers. AirWindows (Chris Johnson, MIT-licensed, ~400 single-file plain-C++ plugins) tunes small, single-purpose algorithms by ear [19], [20]. Examples: Density uses sin()-based overdrive plus a gentle high-pass that dials back the amount of saturation on heavy basses (signal-dependent / dynamic saturation) [19]; the Console system (4/5/6/7) replaces a DAW's digital summing with a ConsoleChannel encode on every track and one ConsoleBuss decode, at unity gain, so channels interact nonlinearly only when summed — newer versions add a harmonics-dependent "slew" encode/decode through which a pure sine passes almost totally untouched, and the summing reduces to a single add per channel, no multiplies [21]. The explicit philosophy: no claim of circuit-accuracy — character by voicing, not by modeling [19].

A worked reference: the harmonic exciter

A concrete, fully open-source target ties these factors together. Jatin Chowdhury's Complex Nonlinearities, Episode 2: Harmonic Exciter documents a complete design (GitHub ComplexNonlinearities, VST/AU): a signal chain of level detector (rectifier + ~10 Hz low-pass) → saturating nonlinearity → dynamic asymmetry, where the detector "ramps" with transients for an analog feel and the dynamic asymmetry yields both even and odd harmonics [64]. Rectifier options are full-wave, half-wave, and Shockley-diode (a less-ideal half-wave); 8× oversampling is sufficient to push aliasing artifacts down to roughly −100 dB [64]. For cross-reference, the classic APHEX Aural Exciter topology is a 2nd-order Butterworth high-pass → asymmetric soft clipper → mix back the generated highs, where the asymmetry again generates both odd and even harmonics. This is the most directly actionable saturation/enhancer recipe in this article: a documented, code-available algorithm to re-implement (ideally in FAUST or Cmajor) and then gate on the acceptance battery.

The synthesis of Part 1

"Pro/analog quality" decomposes into checkable factors: (a) kill the aliasing in every nonlinear stage (oversampling + ADAA); (b) for analog emulation, derive from the circuit (WDF) rather than approximate the curve; (c) for character/summing, a small voiced algorithm can beat a stack of emulations; and (d) get the signal flow / gain-staging right (Part 4). None of (a)–(c) are in juce::dsp — they are the additive DSP layer this article catalogs.

Part 2 — The DSP-language layer: authoring with FAUST (or Cmajor)

The DSP-language layer is the AI-velocity lever. Hand-writing real-time C++ DSP — with correct oversampling, denormals, SIMD, and state handling — is exactly where LLMs make subtle mistakes. A high-level DSP language moves the agent's job up to the algorithm, where it is far more reliable, and both leading options compile to optimized native code and export to a JUCE (or CLAP) plugin. FAUST is the safer "sound-quality-first + free" pick (mature virtual-analog and wave-digital libraries, a license exception that makes the generated C++ yours, and working LLM/MCP tooling); Cmajor is the more "C-family, agent-friendly" pick with proven Claude/MCP use, gated on confirming its license.

What FAUST gives you

FAUST (Functional Audio Stream, GRAME-CNCM) is a functional/block-diagram DSP language whose compiler emits efficient C, C++, Rust, LLVM IR, WebAssembly and more; -lang cpp selects the C++ backend [22]. Three properties make it attractive for a library-leaning, agent-driven stack:

Vetted standard library. faustlibraries implements hundreds of DSP functions by domain: os.lib (oscillators), fi.lib (filters), re.lib (reverbs — freeverb, zita_rev1, dattorro_rev, Schroeder jcrev/satrev), co.lib (dynamics), en.lib (envelopes) [25], [26]. These are textbook topologies whose correctness is independently established — ideal "blocks" for an agent to compose.
Bounded CPU + browsable block diagram. Each sample computes in a finite number of operations, giving a strong guarantee on the upper bound of CPU cost, and the compiler auto-generates a browsable block diagram very useful for debugging [24].
Tunable emitted code. By default FAUST emits one scalar compute() loop; -vec/--vectorize emits separated loops modern compilers auto-vectorize (--vec-size, default 32) [23]. FAUST ships faustbench/faustbench-llvm/faust2bench to search for optimal compilation flags [23].

The FAUST → JUCE integration path

A FAUST architecture file wraps the generated mydsp class (subclass of base dsp, providing init()/compute()/buildUserInterface()); the JUCE side defines FaustPlugInAudioProcessor : juce::AudioProcessor, creating DSP in the constructor, calling init() in prepareToPlay, and compute() in the process callback [27]. Polyphonic instruments use mydsp_poly with an nvoices metadata setting [27]. Tooling: faust2juce / faust2api generate the wrapper (verify the exact faust2api -juce switch against current FAUST tooling docs). The architecture-file wrapping layer is itself the integration friction cited as a FAUST weakness.

FAUST's licensing posture is friendly to closed products: the compiler is GPL, but it ships a license exception — code you generate with FAUST is yours, so the generated C++/plugin can be licensed however you like, free or commercial-closed [22].

The Cmajor alternative — C-family DSP authoring

Cmajor (Cmajor Software Ltd) is the other AI-friendly DSP language: a C-family language (closer to C/C++/JS than FAUST's functional model), LLVM-backed with JIT hot-reload, exporting to a native C++ JUCE project, CLAP, pure C++, or WASM/HTML [62]. Its performance goal is to match (and often beat) C/C++, and it is comfortable mixing event handling with DSP and multi-rate processing — the regimes where FAUST's functional model fights you. AI integration is proven: amorph ("Describe it. Play it.") is a plugin with native MCP support that generates real Cmajor DSP on the fly (BYOK: Claude/GPT/Gemini/Ollama) [65], and a widely-shared project used Cmajor plus an LLM to recreate a hardware unit from schematics, patents, and ROMs. License caveat: the public repo is open source, but the engine is © Cmajor Software Ltd with commercial/educational tiers; read cmajor-lang/cmajor/LICENSE.md directly and confirm free redistribution of an exported plugin before committing [63].

AI integration is real and current

The "AI agent assisting coding" requirement is what tips authoring toward a DSP language. For FAUST, a plan → act → observe → refine loop is workable today through a FAUST MCP server (faustbrowser-mcp, plus community "LLM and FAUST MCP" work) that compiles and plays FAUST DSP. For Cmajor, amorph's native MCP server is the equivalent. Either way the principle is the same: keep the agent reasoning about block diagrams and DSP math, not pointer-level C++, and keep the measurement loop (Part 2's acceptance bar) objective.

The decision rule: FAUST vs `juce::dsp` vs a dedicated WDF/library

FAUST is deliberately not Turing-complete — the generated code computes the sample in a finite number of operations, so certain classes of algorithms cannot be expressed (Newton-style iterative VA solvers are the cited example) [24]. Feedback uses the ~ operator, which inserts a mandatory implicit one-sample delay, so delay-free loops (zero-delay-feedback / TPT filters in textbook form, implicit-equation nonlinear models) cannot be expressed directly [24]. select2(i,x,y) evaluates all three arguments eagerly, so it cannot guard a divide-by-zero or sqrt-of-negative [24].

Use …	When the algorithm is …	Examples
FAUST	a well-understood, finite-operation block diagram; portability + auto-vectorization pay off	oscillators, BLEP, filters, classic reverbs/delays, compressors, EQ, additive/FM synthesis
Hand-written `juce::dsp`	data-dependent iteration, zero-delay feedback, modulated state-variable, tight hand-SIMD, or where you must debug C++ line-by-line	ZDF/TPT ladder filters with modulation, oversampling glue, parameter smoothing, RT plumbing
Dedicated WDF / iterative library (`chowdsp_wdf`)	implicit-equation nonlinear analog circuits, multi-nonlinearity solves	tube/diode clippers, tone stacks, Pultec EQ, transformer/console circuits

A practical default: treat FAUST as the authoring surface for the 80% of DSP that is finite-op, and escalate to hand juce::dsp or chowdsp_wdf for the analog/feedback 20% — which is precisely where the "sounds expensive" quality lives.

Exploiting AI agents safely — composition over authorship

The safe pattern is compose vetted blocks, don't author raw DSP: have the agent assemble FAUST library functions (re.lib/fi.lib/co.lib, whose correctness is independently established [25], [26]) or wire chowdsp_wdf circuit elements, then gate the result on an objective acceptance bar:

Compiles clean (and, for FAUST, the block diagram is inspectable) [24].
Null / reference-match test — subtract the gain-matched output against a trusted reference; a deep null (residual near the noise floor) is strong evidence of equivalence [59]. Caveat: nulls mislead under tiny gain/phase/latency offsets — align exactly first [59].
Measured aliasing / THD within bounds for every nonlinear stage (upsample → brick-wall LP → downsample is the measurement and the fix) [60].
Denormal flush-to-zero (FTZ/DAZ) + NaN guards — IIR filters and reverbs generate denormals as feedback decays to zero, causing severe CPU spikes; set FTZ on the audio thread [60].
Real-time safety — no allocation, no locks, no blocking on the audio callback [56].

Why this bar is non-negotiable is the subject of Part 4's anti-patterns and the bounding evidence later.

Part 3 — Quality-tiered catalog of freely-licensed core DSP libraries

All licenses below were verified by fetching the actual LICENSE file / module header on GitHub (not inferred from READMEs). "Paid-resale-safe?" = can it ship inside a closed-source, paid VST3/CLAP product. Tier is engineering judgment (S = best-in-class, A = production-grade, B = solid/dated). Maintenance dates are as of mid-2026.

Framework / core

Name	License (SPDX)	Paid-resale-safe?	Best at	Tier	Maturity
JUCE [35]	`AGPL-3.0-only OR commercial EULA`	Conditions — closed paid build needs a paid tier; AGPLv3 forces source disclosure	Complete cross-platform plugin framework (VST3/AU/AAX/standalone, GUI, `juce::dsp`, params/state)	S	Very active
iPlug2 [36]	zlib/permissive (WebView=MIT)	Yes	Lean permissive JUCE alternative; VST2/3/AU/AAX/CLAP/Web; FAUST can target an iPlug2 project	A	Active
DISTRHO DPF [37]	`ISC`	Yes	Ultra-minimal framework; first-class LV2 + CLAP + VST3 + VST2; strong on Linux	A	Active
nih-plug [66]	`ISC`	Yes	Rust "JUCE without the boilerplate"; best-in-class CLAP; Rust = strong safety, smaller LLM audio corpus	A	Active
CPLUG [67]	permissive	Yes	Tiny C multi-format abstraction (VST3/CLAP/AUv2); very new	B	New

Synthesis (oscillators / BLEP / wavetable / FM)

Name	License	Paid-resale-safe?	Best at	Tier	Maturity
Mutable Instruments (eurorack) [38]	STM32 modules = MIT; AVR = GPL-3.0; HW = CC-BY-SA	Yes for the MIT (STM32) modules; no for AVR	Reference oscillator/voice algorithms — Plaits, Braids, Clouds, Rings	S (MIT modules)	Archived/frozen, proven
FAUST `oscillators.lib` [25]	LGPL + linking/STK exception (some funcs MIT/STK-4.3; a few GPL)	Yes with exception — check the specific function	Pipeline-native oscillators in a FAUST stack	S	Active (GRAME)
Signalsmith DSP [41]	`MIT`	Yes	Clean header-only primitives (oscillators, delay lines, FFT helpers)	A	Active
Surge XT [39]	`GPL-3.0`	No (study/reference only)	Complete hybrid synth reference	A (reference)	Very active
Vital / Vitalium [40]	`GPL-3.0` (commercial exception purchasable)	No unless you buy the exception	Spectral/warp wavetable engine + modulation UI	A	Frozen

Filters / EQ

Name	License	Paid-resale-safe?	Best at	Tier	Maturity
Cytomic SVF / TPT papers [42]	Public domain	Yes (you implement from the paper)	The reference zero-delay-feedback TPT state-variable filter math	S	Stable, widely ported
cycfi/Q [43]	`BSL-1.0`	Yes	Modern C++ DSP — filters, pitch detection, envelope following	A	Active
chowdsp_filters [→ chowdsp_utils]	`GPL-3.0`	No (commercial relicense via ChowDSP)	Vicanek-corrected/higher-order/conformal-map analog filters	A (reference)	Active
Vinnie Falco DSPFilters [44]	`MIT`	Yes	Classic analog-prototype IIR (Butterworth/Chebyshev/Elliptic/Bessel)	B	Frozen

Saturation / nonlinear / analog modeling

Name	License	Paid-resale-safe?	Best at	Tier	Maturity
chowdsp_wdf [14],[15]	`BSD-3-Clause`	Yes	Wave Digital Filters — circuit-accurate analog modeling (tube/diode/transformer), header-only, compile-time-optimized	S	Very active
AirWindows [20]	`MIT`	Yes	~400 effects — voiced saturation/console/tape/dither "character"	A (idiosyncratic per-sample code; adapt not drop-in)	Very active
ADAA (technique) [1],[2],[6]	N/A — published method	Yes (implement it; check any repo you copy)	Alias-suppressed waveshaping without heavy oversampling	S (technique)	Established literature

Oversampling / SRC

Name	License	Paid-resale-safe?	Best at	Tier	Maturity
HIIR (Laurent de Soras) [45]	`WTFPL`	Yes	Extremely efficient 2× polyphase IIR up/downsampling + Hilbert (minimum-phase)	S	Frozen/stable
r8brain-free-src [46]	`MIT`	Yes	High-quality linear-phase SRC/oversampling (complements HIIR)	S	Active
juce::dsp::Oversampling [7]	JUCE (dual)	Conditions (your JUCE tier)	Drop-in FIR/IIR oversampling wired to JUCE buffers	A	Tied to JUCE

Reverb / delay / time

Name	License	Paid-resale-safe?	Best at	Tier	Maturity
FAUST `re.lib` (zita-rev1/Dattorro) [26]	LGPL + exception (mostly STK/MIT; some GPL)	Yes with exception (verify the function)	Production algorithmic reverbs generated into your C++	S (in a FAUST pipeline)	Active
signalsmith-stretch [48]	`MIT`	Yes	High-quality time-stretch / pitch-shift — the permissive alternative to Rubber Band	S	Stable
Freeverb [47]	Public domain	Yes	Cheap classic Schroeder-Moorer reverb	B	Frozen

Dynamics / FFT / SIMD / math

Name	License	Paid-resale-safe?	Best at	Tier	Maturity
FAUST `co.lib` [25]	LGPL + exception	Yes with exception	Compressor/limiter/expander/gate primitives	A	Active
PFFFT [49]	BSD-3-style (FFTPACK)	Yes	Small fast SIMD FFT, no GPL strings	A	Active
KissFFT [50]	`BSD-3-Clause`	Yes	Dead-simple dependency-free FFT	B	Maintained
XSIMD [52]	`BSD-3-Clause`	Yes	Portable C++ SIMD wrapper (SSE/AVX/AVX-512/NEON)	S	Active
Eigen [53]	`MPL-2.0` (use `EIGEN_MPL2_ONLY`)	Yes (with the flag)	Linear algebra for filter design / state-space / offline math	A	Active

NOT paid-resale-safe — explicitly flagged

JUCE under AGPLv3 — closed binaries need a paid tier; verify the free tier's revenue cap against live pricing [35].
All chowdsp_utils DSP modules — chowdsp_filters, chowdsp_dsp_utils, chowdsp_compressor, chowdsp_sources, chowdsp_waveshapers are GPL-3.0. Only the standalone chowdsp_wdf repo is BSD-3. People wrongly assume "ChowDSP = BSD."
FFTW = GPL-2.0 (commercial MIT license sold separately) [51]. Rubber Band = GPL/commercial dual [61]. Surge XT / Vital = GPL-3.0 [39],[40]. Mutable AVR-era code = GPL-3.0 [38]. Signalsmith reverb-example-code = no detected license (don't ship as-is) [41].

Highest-tier resale-safe picks per domain

Framework: iPlug2 (zlib) or DISTRHO DPF (ISC) for zero-fee + CLAP; JUCE if you accept its tiers and want the richest ecosystem.
Synthesis: Mutable MIT modules (Plaits/Clouds/Rings) + FAUST os.lib + Signalsmith DSP.
Filters/EQ: Cytomic SVF/TPT (public-domain papers, implement yourself) + cycfi/Q (BSL-1.0).
Analog/saturation: chowdsp_wdf (BSD-3) + AirWindows (MIT) + your own ADAA.
Oversampling: HIIR (minimum-phase) + r8brain-free-src (linear-phase) — pair them.
Reverb/time: FAUST re.lib + signalsmith-stretch (MIT).
FFT/SIMD: PFFFT + XSIMD. Never FFTW in a closed product.

Part 4 — Superior sound-design technique at two levels

Signal-path / circuit-theory level

Gain-staging that masks the effect (anti-pattern). A chain of conservative, individually-safe gain reductions across multiple stages can attenuate the very nonlinearity you built — the effect "works" in isolation but is inaudible in the full path. Audit gain staging early; drive the nonlinear stage at the level it was voiced for, and make up gain after it, not before.
Derive from the circuit, not the curve. For analog emulation, the WDF approach (Part 1) keeps the circuit's signal path — interacting reactive components, feedback loops, nonlinear elements — rather than fitting an input→output transfer curve. The commercial "missing last few percent" (inter-winding parasitic capacitance, core saturation, hysteresis, resonant loops) lives in those circuit interactions [58].

DSP-algorithm level — architecture, not just function calls

Order of operations and where the nonlinearity sits. The best-sounding products place oversampling around the nonlinear stage (upsample → nonlinearity → downsample), not globally, and put filters where they shape the aliased-free signal [1],[7],[57].
Dynamic / signal-dependent modulation. AirWindows dials saturation back on heavy low-frequency content and uses harmonics-dependent slew so that a clean sine passes nearly untouched — character that responds to the signal rather than a static curve [19],[21].
Minimal voiced algorithm vs stacked emulations. A small, well-voiced algorithm (one sin() overdrive + a gentle HP) can beat a stack of "accurate" emulation layers — fewer layers, less phase smear, less masking [19].
Validate across many input signals, not one. The difference between "academically correct" and "sounds expensive" is iterative refinement across program material — it must work with many inputs, not one [58].

Part 5 — Where to get higher-quality information

Source	What it uniquely provides	Reachable at
DAFx proceedings (Intl. Conf. on Digital Audio Effects)	The primary venue for ADAA, WDF nonlinearities, antialiasing — full open archive	dafx.de/paper-archive
Julius O. Smith III / CCRMA	The canonical online books — Physical Audio Signal Processing (WDF, physical modeling), Introduction to Digital Filters, Software Implementation in Faust	ccrma.stanford.edu/~jos
Kurt Werner dissertation + DAFx-15 papers	The modern WDF enabling work — R-type adaptor, multiple/multiport nonlinearities	ccrma.stanford.edu/~kwerner
V. Välimäki et al. (Aalto) antialiasing papers	Authoritative oscillator/nonlinearity antialiasing (BLEP/BLIT, higher-order ADAA)	research.aalto.fi; IEEE SPL [2]
FAUST `faustlibraries` documentation	The exact vetted DSP blocks an agent should compose, with per-function license tags	faustlibraries.grame.fr
Core WDF literature (Fettweis 1986; Werner; Bernardini/Sarti)	The theory of wave variables, adaptors, nonlinear resolution	Proc. IEEE [10]; DAFx [13]
Vadim Zavalishin, The Art of VA Filter Design	The key freely-available virtual-analog filter design text	freely available as PDF
AES (Audio Engineering Society) library	Peer-reviewed audio engineering beyond DAFx	aes.org/e-lib
Cytomic technical papers (Andrew Simper)	Public-domain reference TPT/SVF derivations	cytomic.com/technical-papers [42]

Part 6 — Recommended stack and reference architecture

Goal: an AI-agent-driven, library-leaning FAUST + JUCE + CLAP system that emits both synthesizers and production/mixing/mastering plugins at world-class quality, freely-licensed and safe to ship paid or free.

Choose the wrapper for ergonomics and format reach, not sound — quality lives below this layer. JUCE (keep, add CLAP) or iPlug2 (lighter, VST3+CLAP+AU+Web) are the pragmatic picks, and both pair cleanly with FAUST/Cmajor output. If you want to drop JUCE entirely for a fully permissive base, the companion piece What you must build to replace JUCE with iPlug2 + Dear ImGui + NanoVG + Faust is a subsystem-by-subsystem gap analysis of exactly that path.

Chosen libraries per domain

Domain	Pick	License	Why
Host framework	JUCE (accept tier) or iPlug2 / DPF if zero-fee + CLAP-native is required	AGPL/commercial · zlib/ISC	JUCE for ecosystem; iPlug2/DPF for permissive + native CLAP
Finite-op DSP authoring	FAUST + `faustlibraries`	LGPL+exception	oscillators, filters, reverbs, dynamics — composed, not hand-written
Analog/circuit modeling	chowdsp_wdf	BSD-3	circuit-accurate, header-only, permissive
Anti-aliasing	your own ADAA + HIIR (min-phase) / r8brain (linear-phase)	method · WTFPL · MIT	the hybrid (ADAA + modest oversampling)
Character/summing	AirWindows algorithms (ported)	MIT	voiced saturation/console
Filters reference	Cytomic SVF/TPT (implement) + cycfi/Q	public domain · BSL-1.0	ZDF filter math
Time/pitch	signalsmith-stretch	MIT	permissive Rubber Band alternative
FFT / SIMD	PFFFT + XSIMD	BSD	no GPL strings
Format	VST3 SDK (now MIT) + CLAP + clap-juce-extensions	MIT · MIT · MIT	dual-emit from one codebase

FAUST ↔ JUCE ↔ CLAP integration path

Author finite-op DSP in FAUST; generate the mydsp (or mydsp_poly with nvoices) via the JUCE architecture file [27].
Wrap it in a juce::AudioProcessor; add hand-written juce::dsp / chowdsp_wdf for the FAUST-inexpressible regimes (ZDF feedback, implicit nonlinear solvers) [24].
Build with CMake + juce_add_plugin(... FORMATS VST3 ...) and clap_juce_extensions_plugin(TARGET ... CLAP_ID ... CLAP_FEATURES ...) → one codebase emits VST3 + CLAP, sharing parameter IDs and get/setStateInformation [29]. Proven by shipping plugins (Surge XT, ChowDSP, Dexed) [29].
CLAP (MIT [28]) adds per-note expression, polyphonic modulation, and a DAW↔plugin thread-pool [33] — valuable for the synth targets. JUCE 8 has no native CLAP; native authoring is slated for JUCE 9 (no committed date), so plan on clap-juce-extensions today [32]. Ship VST3 as the universal baseline + CLAP for the modulation niche — CLAP DAW adoption is still partial (full in Bitwig/REAPER/FL; absent in Logic/Pro Tools) [34].

Agent guardrails (the trust contract)

The agent composes vetted blocks; it does not author raw DSP unsupervised. Every generated/ported DSP unit must pass, mechanically, before merge:

Compiles + (FAUST) block diagram inspected [24].
Null / reference-match against a trusted reference, exact-aligned [59].
Measured aliasing/THD within spec on every nonlinear stage [60].
Denormal FTZ/DAZ + NaN/Inf guards set on the audio thread [60].
RT-safety: no allocation, locks, or blocking on the audio callback — pre-allocate; do heap work off the RT thread [56].
Parameter-boundary check: verify formulas at param = 0 and param = 1 (filter coefficient conditioning is fragile in float at low cutoff / high SR).
License gate: every dependency's SPDX is resale-safe for the product's distribution model (block GPL/AGPL/FFTW/Rubber Band unless a commercial license is held).

Build / packaging flow

CMake (FetchContent JUCE + clap-juce-extensions + chowdsp_wdf) → FAUST pre-compile step (faust -lang cpp -vec) → JUCE plugin target → clap_juce_extensions_plugin() → VST3 + CLAP artifacts → automated acceptance battery (above) → install and rescan in REAPER/Bitwig.

What NOT to do (anti-pattern checklist)

Naive per-sample tanh/hard-clip with no oversampling/ADAA — it aliases; post-filtering won't save it [57].
Over-conservative multi-stage gain that masks the effect — audit gain staging.
Reflexively stacking emulation layers instead of one voiced algorithm [19].
Trusting agent-authored raw C++ DSP without the trust-contract backstop [54],[56].
Pulling "open source" GPL libs (FFTW, Rubber Band, chowdsp DSP modules) into a closed paid product [51],[61].

Bounding the recommendation: what limits it

These findings bound the recommendation rather than refute it, plus two genuine hard qualifications:

Unbacked agent-authored C++ DSP is not production-safe. A DSP toolmaker's hands-on test of LLMs found skipped complex sections, wrong comments, library-parameter confusion, indexing errors, and worse quality at C/C++ than Python — closing with "Test! Test! Test!" [54]. Empirical studies show LLM code is "deceptively correct" with hallucinated APIs [55], and RT-safety is a discipline generic code generation violates by default (hidden allocation/locks → priority inversion) [56]. This is why the trust contract is mandatory, not optional.
For closed paid products, "freely-licensed" collapses without care. JUCE (AGPL/paid) [35], FFTW (GPL-2.0) [51], Rubber Band (GPL/commercial) [61], and all chowdsp DSP modules (GPL-3.0) are ship-blockers without commercial licenses. A CLAP-first / VST3(now-MIT) + BSD/MIT-library posture is the best defense.
ADAA is regime-specific. It is ill-conditioned when consecutive samples are nearly equal (divide-by-near-zero on quiet/sustained material) [5]; it adds group delay (0.5 sample 1st-order, 1 sample 2nd-order) that skews resonance and risks instability in feedback/stateful systems — ADAA has been applied almost exclusively to memoryless systems [8]; and it is insufficient alone (the field pairs it with oversampling) [9]. Oversampling beats ADAA for steep-falloff nonlinearities and in feedback loops; ADAA beats oversampling for CPU-constrained, mild-falloff/hard-clip memoryless waveshaping. The honest stack is hybrid [1],[4],[5],[9].
FAUST friction is real but not disqualifying. Its functional model fights stateful/feedback structures (letrec recursion is not an efficient way to implement a filter), default emitted code is a scalar loop dependent on host auto-vectorization [23], and emitted C++ is hard to read. None of this blocks clean/surgical DSP; it defines where to escalate to hand C++/WDF.
WDF is not free lunch: classic WDFs require tree topology [18], and multiple nonlinearities create delay-free loops needing iterative (Newton/fixed-point) solves with per-sample cost and convergence risk at extreme drive [13]. This is the empirical reason AirWindows-style minimalism stays competitive.

A few facts are worth flagging as historical or still open. The VST3 SDK was relicensed from GPLv3-or-proprietary to MIT in v3.8.0 on 2025-10-20 (Steinberg press release + repo LICENSE.txt + multiple industry outlets) [30],[31]; the older GPLv3 framing is superseded. (The ASIO SDK separately moved to GPLv3 — don't conflate.) The IEEE SPL 2017 paper gives relative SNR improvement and "fewer operations than oversampling," not absolute dB; the cleanest absolute numbers are DAFx-16 Table 1 [1] and Vicanek's 6 dB/2× [4]. No source in this sweep published a clean head-to-head ×CPU benchmark of ADAA vs N× oversampling at matched SNR — an open question.

Sources