It happened again, I wrote a new book!
One of the places I hang out online is The Audio Programmer Discord, a nice and friendly community for people who are into creating audio software. New folks show up on a regular basis, wanting to learn how to create audio plug-ins such as synthesizers, and ask for book recommendations.
The problem is, until now there wasn’t any book I could recommend as a good place to start from. To learn audio programming, you have to piece the information together yourself from all over the place: college textbooks, blog posts, videos, obscure forums, old mailing list archives… That’s a big hurdle to take, especially for people who are new to programming.
Books about making synths do exist, but none of them offer a complete starter course that takes you from zero knowledge to a finished plug-in. The closest is Will Pirkle’s Designing Software Synthesizer Plugins in C++, but I can’t really recommend the second edition to beginners and the first edition is hard to find (and outdated). Books like that are definitely very useful, but not as a first book.
And so I figured here is a book I could write:
How to get started from scratch with no audio programming or DSP knowledge, and through step-by-step explanations learn to build a real synthesizer plug-in.
Great idea… but a tutorial-style book like that requires an example project, and while I did have some synthesizer code lying around, none of it was suitable as teaching material.
Then one day I stumbled upon MDA JX10. The MDA plug-ins are a legendary set of freeware audio plug-ins from the early 2000s that were graciously donated as open source by their author. Being two decades old, these plug-ins are obviously not the latest and greatest in audio technology — that said, they do demonstrate the fundamentals of audio signal processing quite well.
JX10 in particular is a fun little virtual analog synth that has a bit of everything you need to know to write your own synths. So, I took this existing project, modernized the code and ported it to the JUCE framework, and turned it into what I think is a compelling story of how to make sound with computers.
Now when someone asks, “How do I get started in synthesizer programming?”, I can point them to my own book, Code Your Own Synth Plug-Ins With C++ and JUCE.
What is this book about? It’s 360 pages of detailed explanations of how to create a software synthesizer plug-in that can be used in all modern DAWs such as Logic Pro, REAPER, FL Studio, Cubase, Bitwig Studio, GarageBand, and others. You’ll learn the theory of how synthesizers work and how to implement the underlying digital signal processing (DSP) algorithms.
Even if you’re not really into synths, this book is a good place to start because you’ll learn the foundations of dealing with digital audio and making plug-ins, and that knowledge transfers to any kind of audio programming.
Even better: you only need high-school level math to follow along. There is some math in this book — you can’t escape this when doing DSP — but the focus is on code, not math.
The audio framework used is JUCE. Pretty much everyone making audio plug-ins uses JUCE, as this allows you to program the whole thing just once — including the user interface — and deploy to Mac, Windows, Linux, and iOS from the same codebase. I’m generally not a fan of cross-platform frameworks but for JUCE I’m making an exception!
The book is for sale at Leanpub. You can download a free sample PDF or EPUB with the first three chapters to try before you buy. The book’s source code is on GitHub, so you can already check out the finished synthesizer project. That repo also has some audio demos of what the synth sounds like.
Here is a screenshot of the synth plug-in running in REAPER:
The table of contents for the book:
- Chapter 1: What is a synth, exactly?
- Chapter 2: Getting started with JUCE
- Chapter 3: MIDI in, sound out
- Chapter 4: Handling MIDI events in JUCE
- Chapter 5: Introduction to oscillators
- Chapter 6: The sawtooth oscillator
- Chapter 7: Plug-in parameters
- Chapter 8: The ADSR envelope
- Chapter 9: Combining oscillators
- Chapter 10: Polyphony & voice management
- Chapter 11: Modulation
- Chapter 12: The filter
- Chapter 13: User interface
- Chapter 14: Where to go from here
If this sounds like something you’d be interested in, go get the book. Cheers!
First published on Wednesday, 14 September 2022.
If you liked this post, say hi on Twitter @mhollemans or LinkedIn.
Find the source code on my GitHub.
New e-book: Code Your Own Synth Plug-Ins With C++ and JUCE
Interested in how computers make sound? Learn the fundamentals of audio programming by building a fully-featured software synthesizer plug-in, with every step explained in detail. Not too much math, lots of in-depth information! Get the book at Leanpub.com