Feedback Delay Networks in Python

A 90-minute tutorial at DAFx 2026 · Cambridge, MA

▶ Open the slides — they work in any browser, offline included. Press S for speaker notes, O for the slide overview, ? for all shortcuts.

Feedback Delay Networks (FDNs) are the workhorse of efficient artificial reverberation. This tutorial builds one from first principles, analyzes what makes it sound good or bad, and then optimizes it with gradients — using pyFDN, an open-source Python toolbox released at DAFx 2026.

No prior experience with FDNs is required. You should be comfortable with Python and with basic DSP: filtering, convolution, and what a pole is.

Before you arrive

A — Run in molab (recommended)

molab is marimo’s hosted notebook workspace. Nothing needs to be installed on your laptop; the notebooks and Python runtime run through your browser.

1. Create a free molab account or sign in to an existing one.
2. Open the pyFDN starter notebook in molab — this is Hands-on 1.
3. On the preview page, choose Fork to copy the notebook into your own molab workspace.
4. Start the runtime and run the notebook once before the tutorial. molab provides the compute environment and can install missing Python packages in the workspace.
5. Do the same for the Hands-on 2 notebook, which trains an FDN against a measured room. It pulls in PyTorch, so the first run takes a few minutes — worth doing before you travel.

This is the path we will assume during the hands-on sections. The GitHub-backed preview always opens the current notebook, while your fork is yours to edit.

B — Run locally (optional)

Choose this route if you prefer a local Python environment or want the complete repository on your machine. Install the toolbox and notebook extras:

# any environment manager works — uv shown here
uv venv --python 3.11
source .venv/bin/activate
uv pip install "pyfdn[examples]"

During the active tutorial run, this install intentionally follows the newest published pyFDN release. We will freeze and record the exact version only for the final conference snapshot.

Clone the repository and check the install:

git clone https://github.com/artificial-audio/pyFDN
cd pyFDN
python -c "import pyFDN; print(pyFDN.__version__)"
marimo edit examples/

pyfdn[examples] installs marimo, matplotlib, plotly and — via flamo — PyTorch. That last one is a large download, so do it on hotel Wi-Fi rather than in the room. Only Hands-on 2 needs it: the starter notebook and all of Hands-on 1 run on NumPy alone.

If molab or the local install does not work, come anyway. Every notebook is rendered on the website with its plots and audio, and needs nothing but a browser.

What we will cover

Time	Duration	Segment	Content
0:00	15 min	What is an FDN?	Why a recursive reverberator instead of a convolution. The vanilla structure — input gains, delay bank, feedback matrix, output gains — and the three points where a filter hooks into the loop, heard one at a time: absorption, output EQ, a moving matrix, a non-linearity. Then the structures those hooks open up: early reflections, allpass FDNs, reverberation enhancement — and the four things that are still hard about all of it.
0:15	15 min	pyFDN, the tour	Design principles and marimo notebooks, the three backends (process_fdn, td, FLAMO), the FDNBuild data class, the representation translators, and a reverb in five lines of code. Then real time: compiling a pyFDN design to FAUST with adac, stability-certified, and running it in the browser.
0:30	10 min	What to do next?	The research frontier, with a notebook for each direction: allpass and paraunitary FDNs, SDN, coupled rooms and multi-slope decay, time-varying FDNs, shimmer, decorrelation. DecayFitNet as a pip install, the open research questions, and how to contribute.
0:40	25 min	Hands-on 1 — build an FDN	Seven steps: choose delay lengths, swap feedback matrices, set the input/output gains and render your first impulse response, prescribe a frequency-dependent \(T_{60}\) and measure whether you got it, then analyze and listen. Then one filter in the loop — the same three hooks from part 1 — and a closing section that hands you a measured concert-hall impulse response as a target to match by hand. Widening the output gains to two rows turns it into a stereo reverb. Plain NumPy, no torch.
1:05	20 min	Hands-on 2 — match a room with gradients	The same concert hall, this time fitted by an optimizer. A generic 1 s reverberator goes in; a trained decay filter and output EQ come out, scored against octave-band numbers the fit never saw. Along the way: why the obvious loss picks the wrong decay, and why filter coefficients cannot be trained directly. Needs torch, via FLAMO.
1:25	5 min	Q&A	Ask the awkward questions.

Notebooks we will use

All of these live in examples/ and are rendered in the examples gallery.

Segment	Notebook
Hands-on 1	example_process_fdn
Hands-on 2	example_train_fdn_to_rir

Presenters

Sebastian J. Schlecht is Associate Professor of Signal Processing at Friedrich-Alexander-Universität Erlangen-Nürnberg. His research covers artificial reverberation, differentiable audio processing and spatial audio, and he is the lead developer of pyFDN.

Facundo Franchino is a graduate student at MIT. His BEng work at the University of York proposed structured pruning for feedback delay networks; his interests are FDNs, real-time audio and machine listening.

Room requirements

• Projector and screen
• Audio playback for listening examples
• Power for participant laptops, ideally at every seat