Learn · JUCE

A JUCE learning path for vibe coders

JUCE is the most widely used C++ framework for building audio plugins and apps. It’s powerful and well documented, and it rewards learning in a sensible order. This is a high-level map — with links out to the official resources that do the detailed teaching.

Before you start

JUCE is worth learning once you have an idea you actually want inside your DAW. If you haven’t yet proved the idea is fun, a browser prototype is a faster first step. When you’re ready, keep these expectations in mind:

  • You’ll be working in C++. You don’t need to master it, but you’ll pick up the basics: classes, references, headers.
  • AI assistants help a lot with JUCE, but they sometimes mix up API versions. Always tell them which JUCE version you’re on.
  • Check JUCE’s licensing terms on the official site before you distribute anything.

Official resources to bookmark

For community learning, The Audio Programmer (YouTube channel and Discord community) is a widely used, friendly resource with beginner-oriented JUCE videos and a place to ask questions.

The path, stage by stage

Stage 1 — Get a blank plugin running

Goal: build the default plugin template and load it in your DAW or the JUCE AudioPluginHost.

  • Install your platform’s toolchain (Xcode or Visual Studio) and download JUCE.
  • Create a plugin project with the Projucer or the CMake examples in the JUCE repo.
  • Build it, find the output VST3/AU, and load it.

Done when: a silent “hello world” plugin appears in a track. This is the hardest-feeling stage and the most common place people quit — push through; it gets easier.

Stage 2 — Understand the processor and editor

Goal: know what AudioProcessor and AudioProcessorEditor each do.

  • The processor handles sound: prepareToPlay (set up), processBlock (fill buffers), state save/load.
  • The editor is the window with knobs. It can be closed while sound keeps running.

Done when: you can make a gain plugin that turns audio up and down. Ask your AI assistant to explain each function in the template in plain English.

Stage 3 — Parameters

Goal: expose controls the host can automate and save.

  • Learn AudioProcessorValueTreeState (often shortened to APVTS) for declaring parameters.
  • Attach sliders to parameters so UI and host stay in sync.
  • Bring over the parameter list, ranges and defaults from your prototype or scope file.

Done when: a knob moves when you draw automation in your DAW, and the value survives saving and reopening the project.

Stage 4 — Making sound: synthesis and MIDI

Goal: for instruments, respond to MIDI and generate audio.

  • Work through the official synth tutorials (the Synthesiser / voice classes).
  • Build a single oscillator with an ADSR envelope before adding anything else.

Done when: you can play notes from a MIDI keyboard or piano roll without clicks.

Stage 5 — The DSP module

Goal: use JUCE’s dsp classes for filters, gain, delay and reverb.

  • Learn the ProcessorChain idea: stages connected in order, much like Web Audio nodes.
  • Port your prototype’s signal flow one stage at a time, listening after each.

Done when: your plugin sounds recognisably like your prototype.

Stage 6 — Real-time safety

Goal: keep the audio thread fast and glitch-free.

  • No memory allocation, locks, file access or logging in processBlock.
  • Smooth parameter changes (JUCE has SmoothedValue) to avoid zipper noise.
  • Add these rules to your AI project rules so every suggestion respects them.

Done when: the plugin runs at small buffer sizes without crackles.

Stage 7 — UI polish

Goal: a clean, usable interface.

  • Learn LookAndFeel for custom knob and slider styles, and basic layout with resized().
  • Keep it simple; clarity beats decoration.

Stage 8 — Testing and sharing

  • Test in at least two DAWs, at several sample rates and buffer sizes.
  • Try validators such as Steinberg’s VST3 validator or pluginval (an open-source plugin tester).
  • If you distribute: read up on macOS code signing/notarization and installers, and re-check licensing.

Learning tips for vibe coders

  • Read the tutorial first, then ask the AI. The official tutorial gives you correct structure; the AI helps you adapt it.
  • Keep a SCOPE.md and a rules file in the project — the same habit described in scope your first plugin.
  • Commit after every working stage. C++ errors can cascade; rolling back is cheap.
  • Paste full error messages. Trimmed errors produce guessed fixes.
  • Don’t skip stages 1–3. Most confusing bugs later come from misunderstanding the processor/parameter structure.

Where to go next

If you haven’t prototyped your idea yet, start with the honest guide to vibe coding plugins and the free sample pad. Spec → Scaffold includes a browser prototype for your idea, a prompt chain and a JUCE path like this one in its delivery — $49 on Gumroad, no compiled plugin included. More reading on the blog and in writing your idea.

Keep going

Want a head start on your own idea?

Spec → Scaffold turns a plain-English plugin idea into a scoped spec, a playable browser prototype, an ordered prompt chain, and a JUCE path for later. It is not a compiled VST/AU. Questions? [email protected]

Get Spec → Scaffold — $49or try the free sample →