Signalsmith Audio always has great posts. Their article on pitch shift is also worth a look! I have also posted before:

https://news.ycombinator.com/item?id=36706588

Speaking of reverb, I implemented a Dattorro reverb (https://ccrma.stanford.edu/~dattorro/EffectDesignPart1.pdf) in Rust before.

https://github.com/chaosprint/dattorro-vst-rs

It's based on Glicol source code here:

https://github.com/chaosprint/glicol/blob/main/rs/synth/src/...

You can play with it here:

https://glicol.org/demo#handmadedattorroreverb

Also you don't want to miss the Tom Erbe's reverb patches in Pure Data. Patches demonstrating several types of reverb (Schroeder, Moorer, Moore, Gerzon, Dattorro):

https://tre.ucsd.edu/wordpress/?p=625

Whoah - the author (Signalsmith) here! This was a fun way to wake up, and I'm happy to answer any questions.

Easily the most approachable yet complete writeup I've seen on the topic. I've always noticed an aura of esoteric dark magic around writing good algorithmic reverbs, this makes it seems less daunting.

Since the author does a quick comparison between convolution and algorithmic reverbs, I'll mention how I often combine them: a small/medium convolution reverb, plus a long algorithmic reverb. The convolution can perfectly diffuse the signal and it can also give a precise character to the sound, depending on the impulse response. It's great for adding a "body" to a raw sound generator. The algorithmic layer then adds a subtle ambience that can be extra long if desired.

Very nice tutorial, and extremally nicely done!

It's worth knowing that some of those effects can also be achived (of course much much more simplified) in all modern browsers using the Web Audio API. I created mobbler[0] using that, and I also wrote a small tutorial on how some of the effects can be achieved using simple modules (it might seem too complex at first glance, but you can just look at the pictures)[1].

[0]: https://github.com/Megaemce/mobbler

[1]: https://github.com/Megaemce/mobbler/wiki/Tutorials

Fantastic article from start to finish. Great explanation, great audio samples, and from a first skim the C++ example looks very readable.

> I haven't found any good resources on this particular diffuser design. I found a couple of forum posts and a paragraph from a book

When I read this my first thought was "this is a link to a comment by mystran on KVR, isn't it?" And yep. If you're looking for some obscure DSP knowledge, all Google searches eventually lead to a comment by mystran.

>throw a random-number generator at all the delay times

Reverb algorithms are indeed random enough, a leading audio plugin brand once came up with a randomizing reverb freeware[0] embedded with a "submit when it sounds cool" button.

https://www.kvraudio.com/forum/viewtopic.php?t=453229

I wonder where do you find information like this? E.g. how a reverd is made, how those electronic drum sounds from classic drum machines are made and so on? Is there something like a big catalogue of different tricks and algorithms?

I have a Yamaha FX-500 multi-effects processor from 1989.

Original owner; got it in 1989.

I was fiddling with it recently to try to get a decent reverb. The main algorithms don't sound good; they have not aged well. These algorithms have a delay parameter, but it doesn't produce enough of a separation somehow.

Instead of a reverb-only block you can choose a combined delay with reverb (R->D, D->R or D+R). The delay block takes its own resources, leaving fewer for the reverb, which is simplified. You cannot choose the type of reverb (plate, hall, ...) and there are fewer parameters.

The interesting thing is that with the D->R and R->D, I can get much better sounds.

The D->R can produce a pretty lush/deep long reverb, where the main signal stands out clearly.

(I should mention that I'm using an external analog mixer for mixing the dry signal: the FX-500 is 100% wet. Thus, in general, I can get the best possible sound out of it: the full resolution is allocated to the effect, not to propagating the dry signal.)

Less can be more; a simpler reverb can sound better. A completely separate delay before the reverb can be better than playing games with built-in pre-delay.

Basically, in combining the resources of the delay and reverb into a more complicated reverb effect, Yamaha somehow made a mess.

Is it possible to model reverb using a neural network (e.g. wavenet or LSTMs) for real-time use? Is this what something like Neural DSP is doing under the hood?

On my personal laptop (Mac), I used AU Lab to apply effects to the music I listened to, and discovered that I like the ambience provided by adding a little reverb.

I'm interested in doing the same at work, but the office PCs run Windows and I'm somewhat limited in what I can install.

The Arduino Audio Tools library seemed like it would work, but it only applies effects on one channel.

https://github.com/pschatzmann/arduino-audio-tools/wiki/Audi...

I discovered the Wishing Well stereo reverb pedal, and am wondering whether building one will allow me to apply the effect to music from an iPod, rather than a guitar.

https://scientificguitarist.wixsite.com/home/wishing-well

If anybody would like to group-buy the Wishing Well, please let me know - if I order PCBs and parts, I'll have spares.

FTA: There are some interesting designs here - and they work, but they often require careful tuning. As well as finding a good compromise for the delay time, using too much inter-channel mixing can lock the delays together so they act like a cohesive unit, which isn't great for longer tails.

Made me wonder whether there’s a connection with linear feedback shift registers (https://en.wikipedia.org/wiki/Linear-feedback_shift_register)

If you have a LFSR that produces a decent but not too good pseudo-random signal, can you use its parameters to create a decent reverb?

I came expecting DSP code but was pleasantly surprised by this!

If anyone has any other interesting ones to share about how audio hardware and software are built, I'd love to see them!

Using convolution I found that applying some random variation between the stereo channels made a much more satisfying stereo result, though only on later reflections, earlier it makes for unhelpful stereo effects. Is that something you have tried?

Interesting article, however in drums demo the reverb sound increases after the drum is hit, and this doesn't seem natural. I would expect the reverb to have only decay phase, but here the reverb has a slow attack as well.

I wrote a synthesizer last year. It was a lot of fun. Just through trial and error I learned how sound waves work. It's really enjoyable to build things that aren't websites

Is there a way to get "realistic" reverb using GPU computation?

The trick is not to use NNs for DSP but to discover the parameters for the DSP. In other words you hardcode the signal flow architecture using a common technique like an FDN but then train a NN to find "good" sounding parameters, like comparing to a convolution reverb or recordings.

The thing about reverb is they require a lot of state and nonlinearity is undesirable.

For reverb I don't see much practical use, mainly because you can capture a pretty-much-perfect recreation of a real space with an impulse response. No need for thousands or millions of rounds of training a network. For unrealistic reverbs, you have the problem that to get training data you'd have to invent several unrealistic reverb effects to apply to sounds. And once you've made those effects, there's not really any reason to neural-netify them.

For NeuralDSP it's a bit different because they use NN's to simulate a guitar amp circuit which is a nonlinear system and so there's no simple way to "capture" the effect the way that you can for reverb sims or speaker sims. And while you can make a very accurate model using something like SPICE, that won't run in realtime. With traditional amp modeling you basically take the SPICE version and try to optimize and cheat as much as you can so it can run in realtime, at the cost of accuracy.

So that's what NeuralDSP's goal is, a system that approximates the amplifier but can also be computed in real-time, except done using a trained NN instead of a human-optimized variant of the SPICE circuit.

They have a couple whitepapers on their website, though none of them go deep enough to really give away their secret sauce. But basically according to them, making a NN model of an amplifier at a fixed setting is fairly simple. Where they had to get novel with it is adjustable settings/parameters. E.g. turning the drive up, or turning the treble down. Just capturing a few hundred or thousand models based on adjusting parameters and cross-fading between them doesn't sound realistic. So they had to come up with a larger model architecture that can "learn" those parameter changes.

https://arxiv.org/pdf/2403.08559

Not sure about Neural DSP or reverbs in general, but real-time neural network based DSP seems very possible. The open source Neural amp modeler[1] would be a good place to start diving in.

[1] https://www.neuralampmodeler.com/the-code