// AUDIO ENGINEERING SERVICES
C++ Audio Plugin Development Services
Audio plugin development turns a sound idea into a VST3, AU, AAX, or AUv3 product. We design, build, and optimize those plugins in JUCE and modern C++. We test every build in Logic Pro, Cubase, Pro Tools, and Ableton Live, and ship it as a signed installer you own.
VST3, AU, AAX, AUv3
We build and test every format you plan to sell: VST3, AU, and AAX on macOS and Windows, AUv3 and standalone on iPadOS.
JUCE UI Implementation
Your Figma or PSD becomes a working JUCE editor: resizable layout, correct scaling on Retina and Windows DPI, and repaint work kept clear of the audio callback.
Real-Time DSP Engineering
Allocation-free processBlock code, lock-free handover between editor and processor, denormal protection, and SIMD where profiling shows it earns its complexity.
CMake Builds and CI
One CMake project that builds on your machine as well as ours, with pluginval runs, signed installers, and macOS notarization produced on every tagged release.
// THE TECHNICAL GAP
Where do plugin projects stall?
The audio callback has no slack
Most plugin projects stall in the audio callback, where processBlock has about 1.3 milliseconds to finish at 48 kHz with a 64-sample buffer. A single heap allocation, mutex, or log line inside that callback becomes a click the user hears. None of this shows up on a quiet test project. It shows up in a 40-track session on a laptop running on battery.
Every host breaks a different assumption
macOS runs auval against your AU before Logic Pro will load it. Pro Tools hosts AAX out of process and expects exact latency reporting. Cubase remembers the VST3 parameter list between sessions, so a renumbered parameter breaks saved projects. Ableton Live and FL Studio drive automation at block rate, which exposes any gain change you forgot to smooth.
How we work the problem
We keep the real-time path free of allocations and locks, then prove it with sanitizer builds, pluginval at high strictness, and manual passes in Logic Pro, Cubase, Pro Tools, Ableton Live, Reaper, and FL Studio. The validation logs ship with the build.
// ENGAGEMENT
From First Call to Signed Installer
Each stage ends with something you can open, install, or hand to another developer.
Scope and proposal
One call about the product, then a written proposal: feature list, target formats, milestones, estimate, and the assumptions it rests on. NDA first if you prefer.
Architecture document
Before the DSP work starts you receive a short architecture document: processor and editor split, parameter layout, preset and state format, threading model.
Prototype build
A signed prototype you install and open in your own DAW. It makes sound and saves state while the interface is still a placeholder.
Milestone builds
Every milestone delivers signed macOS and Windows installers, a pluginval report, and a changelog written for a non-programmer.
Release and handover
A release candidate, a notarized macOS installer, a signed Windows installer, a release checklist, and the full source and CMake project in your repository. Maintenance afterwards is quoted separately.
// WHAT YOU RECEIVE
What do you get at the end of a plugin project?
Formats and platforms
You get VST3, AU, and AAX as macOS universal binaries and Windows x64, plus standalone applications, AUv3 for iPadOS, and host-specific variants when the product needs them. Playbeat 4 ships a MIDI FX version for Logic Pro.
Installers, signing, and notarization
macOS packages are signed with a Developer ID, notarized, and stapled so Gatekeeper installs them without a warning. Windows installers are signed with your certificate. AAX requires PACE signing through your Avid developer account, and iLok copy protection is wired in if you sell that way. The certificates and accounts stay in your company's name.
Source, build system, and CI
You get a CMake project that configures on a clean machine, the CI workflow that produces the installers, and the JUCE version pinned so releases stay reproducible. When the engagement ends, your team can cut the next release without us.
// WHAT GOES WRONG
Pitfalls We Design Around
Allocation on the Audio Thread
A std::vector that resizes, a log line, a mutex guarding shared state: each is a dropout waiting for a loaded session. Work that cannot be allocation-free moves to a lock-free FIFO.
Denormals and NaN
Reverb tails and IIR filters decay into denormal territory, where CPU cost climbs on inaudible output. One NaN from an uninitialised buffer silences the whole mix bus. We flush denormals, guard feedback paths, and test with silence and clipped input.
Host Automation Quirks
Hosts restore state before the editor exists and index VST3 parameters by ID forever. Change an ID between versions and every saved Cubase or Ableton Live project recalls the wrong value, so we version the parameter layout from the start.
Signing and Notarization
An expired certificate, a missing hardened runtime entitlement, or an unstapled package turns a finished plugin into an installer macOS refuses to open. Signing, notarization, and AAX PACE requirements belong in the build pipeline, not the last day before launch.
The AUv3 Sandbox
On iPadOS an AUv3 runs sandboxed, with its own memory ceiling and no access to arbitrary paths. Sample content and presets need an App Group container, so the iPad version gets planned rather than ported late.
Builds That Live on One Mac
When only one engineer can produce a release, the product stops when that person does. One CMake project, a CI matrix covering macOS and Windows, and pluginval on every tag keep releases reproducible through team changes.
// SHIPPED WORK
Plugins You Can Buy Today
CLIENT: AUDIOMODERN
Playbeat 4
End-to-end development of the full application and the sequence randomization engine in JUCE and C++. Released 5 March 2025 with eight independent sequencers as VST3, AU, AAX, and standalone on Windows and macOS, AUv3 and standalone on iPadOS, plus a MIDI FX build for Logic Pro. Performance and stability improved across complex sessions, CPU spikes dropped, and crashes in high-load scenarios were eliminated.
CLIENT: DISCODSP
OB-Xd, Discovery Pro, Corona
UI and UX implementation and maintenance across the DiscoDSP plugin line, with interface rewrites for OB-Xd, Discovery Pro, and Corona. The result was better visual feedback, smoother interactions, and a renewed lifespan for instruments that already had a user base.
CLIENT: CODWAVES
WaveBalance
Auto gain staging plugin development with transparent real-time gain control, metering, and a focused mixing workflow. A stable level-management tool for keeping tracks balanced before downstream processing.
Several engagements stay undisclosed by contract, including embedded neural network work for a confidential client.
// FIT
When are we the wrong choice for your plugin?
We are the wrong choice when you need a commercial plugin finished in three weeks. We are a small senior team and we turn work down, and formats beyond VST3, AU, AAX, AUv3, and standalone have to be agreed during scoping. Tell us the constraint on the first call. If we are the wrong supplier we will say so.
// FAQ
Common Questions
How long does building an audio plugin take?
Timeline depends on complexity. A focused effects processor typically takes 2–3 months; an instrument or complex multi-feature plugin runs 6–12 months. We give you a realistic scoped estimate after the first call.
What plugin formats do you deliver?
VST3, AU, AAX, and standalone builds for macOS and Windows, plus AUv3 and standalone for iPadOS. We test in Logic Pro, Cubase, Pro Tools, Ableton Live, Reaper, and FL Studio, and run pluginval before every delivery.
Can you work with our existing JUCE codebase?
Yes. We regularly join projects mid-development to add features, fix bugs, or refactor. We start with a code review to assess scope and identify any structural issues upfront.
Do you sign NDAs?
Yes, NDAs and white-label arrangements are standard for us. All engagements are confidential by default. Several of our case studies remain undisclosed for this reason.
Do I need to know C++ to work with you?
No. You focus on the product vision and sound design. We translate that into working, production-ready code and communicate in plain language throughout.
Who owns the source code and the build pipeline?
You do. The source, the CMake project, the CI workflow, and the installer scripts live in your repository, and the signing certificates stay in your company's name. We keep no licence over the DSP we write for you.
Can you take over a plugin another developer or an AI tool started?
Yes. We start with a code review covering real-time safety, DSP correctness, host behaviour, and release readiness, then quote the work from what we find. If the project was built mainly with Claude, ChatGPT, or Cursor, our AI audio code review is the better entry point.
// RELATED SERVICES