Make audio plugins
for macOS & iOS.
juce-dev sets up everything you need to build an audio plugin — synth, effect, instrument, whatever you want. Name it, answer a few questions, and you've got a project that builds in Xcode. Add GPU-rendered UI with Visage, add an iOS target, and Claude knows how to help with each — a bundled juce-visage skill activates automatically when you're working on Visage UI.
Using Codex? See the Codex FAQ and the Codex juce-visage skill.
1. Checks your dev tools are installed (offers to set them up if not)
2. Loads your developer settings or walks you through first-time setup
3. Asks about optional features (GPU-rendered UI, crash reporting)
4. Creates the project with all your settings baked in
5. Sets up git, optionally creates a GitHub repo
6. Ready to build and open in Xcode
How It Works
Answer a few questions,
start building.
Starting a new audio plugin usually means wiring up build systems, configuring code signing, setting up project identifiers, and writing boilerplate. It's tedious before you write a single line of audio code.
juce-dev handles all of that. Give it a name, confirm your developer settings, pick your options, and you get a project that compiles immediately. If it's your first time, it checks your tools and walks you through setup.
Context-aware assistance: If you add Visage GPU UI to your project, a bundled juce-visage skill automatically provides Claude with deep knowledge of Metal view embedding, event bridging, keyboard handling in DAW hosts, and more. No Visage? The skill stays out of the way — it only activates when relevant.
Want to go further? Use Chainer to describe what your plugin should do and let Claude build it for you.
What You Get
A complete project — not a tutorial, not a starter guide. A project that builds.
- Audio Unit, VST3, and Standalone app — all from one project
- Works in Logic Pro, Ableton Live, and other macOS DAWs
- Code signing and notarization config ready for distribution
- Optional GPU-rendered UI with Visage (Metal-accelerated)
- Optional iOS/iPadOS app target with auto-detected UI mode
- Bundled juce-visage skill — activates only when working on Visage UI
- Optional crash reporting for your users
- Git repo initialized, GitHub repo created if you want
- Checks your dev environment and installs missing tools
- Developer settings saved — next project is even faster
Installation
Two steps.
Requires Claude Code and macOS. The plugin checks for other dependencies (Xcode, CMake, etc.) and helps you install anything missing.
/juce-dev:create
Commands
Four commands.
Full lifecycle.
Create, configure, build, ship. Each does one thing well — combine with Chainer for automated workflows.
standalone with au, vst3, or all for other formats.
setup-ios adds an iOS/iPadOS app target — it auto-detects Visage and creates a matching Metal UI with native touch handling. Both platforms share the same codebase. There's no --ios flag on create because the iOS target needs the project to exist first.
Reference
All the options.
Every argument shown with an example. Most have smart defaults — you only need what's relevant to you.
What Gets Generated
From name
to namespace.
All the identifiers your plugin needs are derived automatically from the name you give it.
FAQ
Common questions.
JUCE is the most widely used C++ framework for building audio plugins and music software. It's used by companies like Ableton, ROLI, and hundreds of independent plugin developers. If you've used a software synth or effect in a DAW, there's a good chance it was built with JUCE.
juce-dev uses the JUCE-Plugin-Starter template — a pre-configured project setup that includes build scripts, version management, code signing, and distribution tooling on top of JUCE. You don't need to download JUCE separately; it's fetched automatically when you build.
Just Claude Code and a Mac. The plugin checks for everything else (Xcode command-line tools, Homebrew, CMake, GitHub CLI) and offers to install whatever's missing.
Optional: An Apple Developer account if you want to code-sign and distribute your plugin. You can skip this and add it later — you don't need it to build and test locally.
Anything that processes or generates audio on macOS: synthesizers, effects (delay, reverb, distortion), MIDI processors, samplers, drum machines, audio analyzers — whatever you can code in C++.
Each project builds three formats from one codebase: Audio Unit (for Logic Pro, GarageBand), VST3 (for Ableton, Reaper, etc.), and a Standalone app for testing without a DAW.
Yes. juce-dev sets up your project. To go from project to working plugin, install Chainer and describe what you want to build. Chainer will find the right tools and start implementing your idea.
For example: create a project with /juce-dev:create "Shimmer Delay", then tell Chainer you want "a stereo delay with pitch-shifted feedback and a wet/dry mix control." It handles the rest.
Visage is a GPU-accelerated UI framework for audio plugins on macOS. Instead of the standard JUCE graphics, Visage renders your plugin's interface using Metal at 60fps — smooth knobs, sliders, and animations with no CPU overhead.
It's optional. If you enable it, juce-dev sets up the framework, applies compatibility patches, and gives you a Visage-powered editor template to start from.
Bundled skill behavior: This plugin includes a juce-visage skill that is available after the plugin is installed. It works independently from command execution, so you don't need to run a separate command just to "turn it on." When you're working on Visage UI code, Claude uses that skill automatically for guidance (Metal view embedding, event bridging, DAW keyboard handling, popups/modals, iOS touch handling, and the Visage API).
If your JUCE project does not include Visage, the skill stays out of the way and won't push Visage-specific patterns. Add Visage first (for example via /juce-dev:create ... --visage or /juce-dev:setup-visage) to make that guidance relevant.
You can use Codex with the Codex juce-visage skill. It provides Visage-focused implementation guidance (Metal embedding, JUCE↔Visage event bridging, DAW keyboard behavior, popups/modals/dropdowns, iOS touch handling, and debugging patterns).
What it does not replace: the Codex skill is guidance-only. It does not provide the command workflow this plugin provides (no /juce-dev:create, no automated dependency checks/setup, no automatic Visage clone+patch flow, and no project bootstrapping/repo setup commands).
Recommended workflow: scaffold first using this plugin (in Claude Code) or the JUCE-Plugin-Starter, then use Codex + juce-visage for day-to-day Visage implementation and troubleshooting. If Visage is not added to the project, the skill stays out of the way.
Install the Codex skill:
This uses a sparse checkout to pull just the skill folder without downloading the entire repository.
Yes. Developer credentials (Apple ID, certificates, API keys) are stored in .env files which are listed in .gitignore. They're never committed or pushed to GitHub.
The template's .env is read-only — juce-dev reads your settings from it but never modifies it. All settings go to the new project's .env only.
Yes. Code signing settings (Apple ID, Team ID, certificates) are only needed when you're ready to distribute your plugin to other people. Skip them during setup and add them to your project's .env later.
You can build, test, and develop locally with no Apple Developer account at all.
Making an audio plugin from scratch means learning a build system, configuring Xcode, understanding plugin formats (AU vs VST3), setting up code signing, figuring out bundle identifiers, and writing a lot of boilerplate — all before you write a single line of audio code.
juce-dev skips all of that. You get a project that compiles and runs immediately. The build scripts handle everything from debug builds to signed, notarized releases you can distribute. You just focus on making your plugin do something interesting.
If you already have a JUCE workflow, this saves you the boilerplate of starting new projects. Beyond the template setup, you get:
• Build script with multiple actions: build.sh au debug, build.sh all publish, build.sh unsigned (fast installer testing), build.sh vst3 test (PluginVal integration)
• Code signing + notarization configured from .env — no manual Xcode setup
• Automatic versioning that increments on every build with proper AU version integers
• Visage integration with pre-applied patches for keyboard handling, popup positioning, FPS caps — plus a bundled juce-visage skill that helps Claude navigate the tricky parts (Metal view embedding, event bridging, DAW keyboard conflicts, iOS touch handling)
• GitHub release publishing with auto-download landing pages
• Shared JUCE cache at ~/.juce_cache/ so you don't re-download JUCE for each project
Use /juce-dev:build from Claude Code, or run build.sh directly. Both support the same targets and actions:
Local development:
• /juce-dev:build standalone — Build and launch standalone app
• /juce-dev:build au — Build Audio Unit
• /juce-dev:build vst3 — Build VST3
• /juce-dev:build au vst3 — Build multiple targets at once
Testing:
• /juce-dev:build all test — Build and validate with PluginVal
• /juce-dev:build unsigned — Create an unsigned installer for quick testing
Distribution:
• /juce-dev:build all sign — Build and code-sign
• /juce-dev:build all notarize — Build, sign, and notarize with Apple
• /juce-dev:build publish — Full pipeline: build, sign, notarize, and publish to GitHub Releases
• /juce-dev:build pkg — Signed installer without GitHub release
• /juce-dev:build uninstall — Remove all installed plugin components
Smart builds: The /juce-dev:build command auto-detects whether CMake regeneration is needed. If nothing changed in CMakeLists.txt or .env, it skips regeneration for faster builds.
Use /juce-dev:build --help for the full reference, or ./scripts/generate_and_open_xcode.sh to open the project in Xcode.
macOS only for now. The build system uses Xcode and the code signing setup is Apple-specific. JUCE itself supports all platforms, but this plugin and its tooling are built for Mac development.
We use GitHub issue templates so you can report the right thing in the right place:
JUCE Dev (Claude Code plugin)
• Report a bug — command/setup/scaffolding issues
• Request a feature — plugin workflow improvements
juce-visage (Codex skill)
• Report a bug — incorrect or missing Codex skill guidance
• Request a feature — new Codex skill coverage or patterns