Differentiable audio keeps producing seductive research demos that collapse at the handoff: the model that learns inside PyTorch still has to become stable, sample-accurate, real-time DSP before a musician can put it on a send bus and abuse it at 2 a.m. ADAC, short for Automatic Differentiable Audio Compilation, matters because it treats that last mile as compiler work instead of artisanal rewrite labor.
I wrote last week about Reactive Audio’s Growth and the way reaction-diffusion makes modulation behave like a living system. ADAC points at a different layer of the same music-tech shift. Growth is an instrument-facing artifact. ADAC is the plumbing that can move learned audio processors out of research code and into the plugin formats, web targets, embedded boxes, and weird hardware paths where electronic music actually happens.
The paper, “Compiling Differentiable Audio Graphs to Real-Time DSP”, describes a pipeline that traverses a trained differentiable audio graph, extracts learned parameters, lowers the graph into a framework-agnostic JSON intermediate representation, then emits FAUST code. FAUST already has the boring superpower this needs: one DSP specification can compile toward C++, LLVM, WebAssembly, plugin wrappers, embedded targets, and hardware flows. The ADAC move is to use that ecosystem as the backend for models trained in differentiable frameworks such as FLAMO.
The direct claim from the paper is specific enough to matter. The generated FAUST code matches the source model’s impulse response within single-precision arithmetic noise. The arXiv summary gives a peak difference around 7 × 10^-5. On an Apple M2 at 48 kHz, the reported feedback-delay-network examples run at roughly 90x real time for a 32-line FDN and 14x real time for a 64-line FDN. Those numbers are demo-paper numbers, so yes, bring salt. Still, they are the right order of ambition: compiled audio code has to clear the real-time bar by enough margin that hosts, buffers, automation, and user stupidity do not immediately ruin the party.
The compiler details are where the project gets sharper. ADAC maps graph structure into FAUST operators: series composition to :, parallel composition to split routing, recursion to ~, gains and matrices to sums of products, cascaded biquads to FAUST filter forms, delays to integer or fractional delay primitives. That sounds straightforward until feedback enters the room. FAUST’s recursion operator adds an implicit one-sample delay, so ADAC compensates by reducing in-loop line delays to preserve the source model’s timing. This is the kind of tiny semantic mismatch that turns a neat demo into a broken reverberator if nobody handles it.
The repository describes the same architecture in implementation terms: map-aware extraction, effective parameter serialization, raw trainable weight preservation, JSON IR, FAUST generation, and tests that compare behavior through the pipeline. It also exposes the emotional core of the tool: hot reload. During training, ADAC can republish a model into a running FAUST plugin so the researcher can hear optimization happen. The paper reports about 0.2 ms for re-emission and under 10 ms for FAUST recompilation in the described loop. A plugin that updates after every gradient step sounds like cursed lab equipment in the best way.
The safety piece matters because feedback networks are little demons. A learned FDN can sound wonderful right before it becomes unstable garbage. ADAC adds a small-gain stability certificate around feedback loops and refuses to export models marked unstable or unproven in strict mode. The generated plugin can also expose macro-controls such as RT60, dry/wet balance, and pre-delay without making the user drag raw learned matrix entries around like a punishment ritual. That is the right split: let training discover internal structure, then expose controls a human can reason about while under sleep debt.
This is why the project feels more important than another neural audio demo. The audio software world already has enough models trapped in notebooks, enough Colab demos with impressive spectrograms, enough GitHub READMEs that quietly assume the user wants to become a build engineer before hearing one reverb tail. ADAC puts pressure on the conversion boundary. It asks whether differentiable audio can have a repeatable toolchain: train, extract, certify, compile, install, audition.
The FAUST backend is a good political choice too. Neural audio often arrives with the stink of platform capture: giant frameworks, GPU assumptions, fragile Python environments, versioned CUDA misery, and the general sensation of being mugged by a dependency graph. FAUST comes from a different lineage. It is a domain-specific language for signal processing with a long memory: functional composition, sample-level semantics, portable compilation, and an ecosystem that understands plugins, browsers, embedded systems, and hardware. Compiling learned graphs into FAUST gives differentiable audio a way to borrow that older discipline.
There are constraints. The current story is centered on graph families that can be represented through the supported series, parallel, recursive, delay, gain, matrix, and filter structures. The paper’s main demo leans into feedback delay networks and scattering delay networks, which makes sense because reverbs are a sweet spot for differentiable audio: high perceptual payoff, compact parameter sets, lots of structure, and immediate musical utility. Nobody should read this as a magic bridge from arbitrary neural soup to pristine low-latency DSP. That fantasy belongs in a vendor keynote, preferably one with a stock-photo producer grinning at a fake modular rig.
The stronger reading is narrower and better. ADAC suggests a path for learned processors that retain enough structure to compile. That includes reverbs, resonators, filters, spatial effects, nonlinear-ish blocks wrapped with care, and hybrid systems where learning tunes a known DSP topology instead of replacing audio engineering with a black box. That is the lane where machine learning has a chance to become musically useful without turning every plugin into a mystery appliance.
For electronic music, the fun part is obvious. Imagine training a room, plate, spring, or impossible resonator against examples, then exporting a real plugin with deterministic timing, host automation, and a few sane macro-controls. Imagine hearing an optimizer mutate a reverb while a drum loop runs through it. Imagine putting the trained result on a Raspberry Pi, a web page, a Eurorack-adjacent box, or a CLAP plugin and having the same generated DSP survive the trip. The point is not that every producer needs differentiable training in the studio. The point is that instrument builders need a shorter route from learned sound behavior to playable tools.
The last decade of music tech has been polluted by two bad instincts: neural fairy dust on one side, skeuomorphic nostalgia on the other. ADAC is better because it is boring in the right places. It serializes parameters. It corrects delay semantics. It emits a real DSP language. It checks stability. It installs plugins. It cares about the moment where research stops being a PDF and starts surviving a DAW session.
That seam is where the future of audio ML gets judged. A trained model that cannot run in real time is a sketch. A trained model that cannot be controlled is a specimen. A trained model that cannot be exported, inspected, certified, and rebuilt is academic furniture. ADAC makes a serious bet that differentiable audio becomes useful when it behaves like a compiler pipeline, with all the ugly mechanical sympathy that implies.