How are VST Plugins made?
VST plugins are typically made using programming languages like C++, following and basing them on Steinberg SDK (Software Development Kits). The industry standard for creating plugins is JUICE, a C++-based framework. Alternatively, noncoders can also use modular and visual-programming tools to assemble pre-programmed audio processing modules.
Let’s break down the above answer. VST (Virtual Studio Technology) plugins are typically made using software development kits (SDKs) provided by the founding company of VST, Steinberg. The VST SDK by Steinberg comprises C++ classes built on a core C API. You can access and download the SDK directly from Steinberg’s website.
The SDK includes documentation, example code, and libraries necessary to create VST plugins. If you’re planning to build your VSTs, I suggest that you go through and understand the official SDK provided by Steinberg.
The process first includes mapping out the signal flow and the overall plugin sketch. Then, it involves development through frameworks or libraries like JUCE (C++ framework), WDL-OL, or RackAFX that provide tools and structures specifically for audio plugin development. This requires building or using algorithms, user interfaces, and handling the plugin’s interactions with digital audio workstations (DAWs).
Once the initial code is written, developers do rigorous testing, and debugging is crucial to ensure the plugin works correctly in various environments and with different DAWs. Testing involves checking for issues like audio artifacts, compatibility problems, or unexpected behavior.
The code is then compiled into a format that the target platform (Windows, macOS, etc.) and DAWs can understand. This involves generating specific binary files or libraries according to the VST specifications.
Finally, after successful testing and compilation, the plugin is packaged into an installable format (e.g., .vst or .vst3 files for VST plugins). Developers may create installer packages or zip files for distribution.
Noncoders can use environments that let you patch and map different sound modules together to create a plugin. This alternate doesn’t require coding. For that, you can start with tools like Max/MSP and SyntheEdit.
Best Tools To Develop VST Plugins
Tools that require coding
JUCE, which stands for Jules’ Utility Class Extensions, is a powerful C++ framework widely used in audio plugins and software development. It enables developers to write code once and deploy it across various platforms such as Windows, macOS, iOS, Android, and Linux, making it highly versatile.
Note that you will need to know the basics of C++ to operate these frameworks. JUCE provides a comprehensive set of libraries and tools for audio processing, MIDI handling, graphical user interface (GUI) creation, and more.
JUCE offers a modular architecture, allowing developers to create reusable components and easily extend functionality, which is particularly valuable in creating complex audio applications.
Plugin manufacturers like Arturia, Serato, Izotope, UVI, Waves, etc., use the JUCE framework for their plugin development. In addition, it also has a vibrant and active community of developers, providing forums, tutorials, and extensive documentation, making it beginner-friendly and supportive for developers at all levels.
JUCE provides support for various industry standards, including VST, VST3, AU (Audio Units), AAX, and more, making it a popular choice for building audio plugins compatible with different digital audio workstations (DAWs).
Steinerb VST SDK
The SDK serves as a set of guidelines and tools for developers who use programming languages like C++ to create VST plugins. It includes the necessary resources, headers, APIs, examples, and documentation to assist developers in building audio plugins that adhere to the VST specifications.
It also offers sample code and example projects demonstrating how to use the SDK effectively. These examples serve as a starting point for developers, showcasing how to structure and implement various functionalities within a VST plugin.
The SDK ensures compatibility with the VST standard, allowing developers to create plugins that seamlessly integrate with a wide range of DAWs that support the VST format.
C++ with frameworks/libraries (WDL-OL, RackAFX, or others)
C++ is a powerful and commonly used programming language for creating VST plugins due to its performance, flexibility, and compatibility with the VST standard. Developers write the plugin logic, audio processing algorithms, and interface functionalities using C++.
These frameworks and libraries ( WDL-OL, RackAFX, etc.) often offer abstraction layers, templates, and helper functions that simplify tasks such as managing audio buffers, handling parameter changes, interfacing with DAWs, and complying with the VST standard.
They often provide pre-built components, templates, and sample projects that serve as starting points for developers, accelerating the development process by providing a foundation upon which to build.
Faust is a simplified alternative for C++ and is specifically designed for the development of synthesizers, virtual instruments, fx tools, and other real-time signal processing applications.
It uses a functional programming paradigm, allowing developers to describe signal processing algorithms using mathematical expressions, signal operators, and functional blocks. Developers can express audio processing algorithms using mathematical equations and functional constructs, making it easy to represent complex signal processing operations concisely.
Faust can generate highly optimized code for efficient real-time audio processing. It can compile optimized C++ code, which can then be integrated into VST plugins. It enables the conversion of any Faust digital signal processing (DSP) blueprint into various non-domain-specific languages like WebAssembly, C++, Rust, C, LLVM bit code, and more.
Super Collider is essentially a programming language for real-time sound synthesis, sound generation, and other musical applications. Basically, you use code instead of instruments to create music.
However, with its sc3 plugins repository, you can also use it to create plugins. That acts as a wrapper or a bridge that can package your SuperCollider code as a VST plugin. Use this guide to learn and understand how SuperCollider works.
Tools that do not require coding
Have you ever used a Patcher plugin? A patcher is available for FL Studio as well. Max/MSP functions like a patcher, where you can flexibly map and drag-drop different audio processing modules.
You can also use it in combination with Jitter for audio-visual applications. You must have seen DJ sets that modulate graphics with music. Max/MSP allows you to do that. Technically, Max/MSP is a visual programming language used extensively for audio and multimedia applications.
It offers a graphical environment where you can connect visual objects (or “patches”) to create custom audio effects, synthesizers, and interactive media systems. Its versatility and flexibility make it popular for prototyping and creating innovative audio plugins.
You can also use Max/MSP with Ableton, in a platform called Max For Live.
SynthEdit is a modular synthesizer application that lets you create audio plugins without traditional programming. Using a drag-and-drop interface, creators can design signal flows by connecting modules visually, enabling the creation of custom synthesizers, effects, and instruments.
For example, you can drag-drop envelopes, oscillators, LFOs, etc., in different arrangements to create your own signal flow and synth design.
FL SynthMaker has an interesting workflow that allows you to patch different audio modules to create a plugin. It has various categories like Flow, DSP, String, FL Studio, Element, etc., each consisting of different modules.
For example, you can put together the Audio Input (L/R) module with a “Moog Filter” module from the DSP category, route their signals, and create a filter plugin. Similarly, you can load various modules like PWM, State Variable Filter, Slew Limiter, etc., create signal maps of your own choice, and make your own synths.
Pure Data (Pd)
PureData lets multimedia creatives like visual artists, musicians, graphic designers, music producers, etc., create audio-visual applications without having to code. It is an open-source tool that provides a visual canvas where you can connect modules (represented as objects) to create audio processing chains.
You can also design modular components for various audio effects, synthesis methods, or signal manipulations. These modules can then be interconnected and reused in different plugin designs. One can design effects, filters, equalizers, and diverse audio processing algorithms.
You can use it to develop unique and personalized audio effects or processing techniques by combining different modules and customizing their parameters.
What programming language is best for VST plugins?
C/C++ is the best programming language for developing VST plugins. Even the industry-standard tool, JUCE is a C++ framework. Additionally, most of the modular-based plugin development platforms are also based on the underlying C++ code.
Skills you need to develop a VST plugin
- Audio Signal Processing: Understanding digital signal processing (DSP) principles is crucial for manipulating and processing audio effectively within plugins.
That includes knowing about sampling and quantization, time/frequency domain analysis, filtering, convolution, FFT, etc.
- Programming Languages: Proficiency in programming languages like C++ is essential for writing the code that defines the plugin’s behavior and functionality.
- Frameworks and SDKs: Familiarity with audio development frameworks (e.g., JUCE) and the VST SDK itself is crucial for implementing the plugin according to industry standards.
- Mathematics and Algorithms: Knowledge of mathematics, especially in areas like Fourier transforms, filters, and other mathematical concepts, is beneficial for creating complex audio algorithms.
Can you make VST with Python?
Yes, you can create VST plugins using Python, but it’s not as straightforward as using languages like C++, which are more commonly used for plugin development due to their performance and compatibility with industry-standard frameworks like JUCE.
Some libraries like Pyo or Csound allow you to work with audio in Python. However, creating a VST plugin involves complying with the VST SDK (Software Development Kit) provided by Steinberg, which is primarily C++-based. While there might be wrappers or ways to interface Python with C++ for VST development, it might not be as direct or widely supported as using C++.
If you’re determined to work with Python for audio processing, you might consider creating standalone applications or utilizing Python for other parts of audio production (e.g., scripting, processing, analysis) and then integrate those functionalities into a VST using a C++ framework like JUCE or a lower-level language that is compatible with the VST SDK.
What can I do to get started?
If you’re a beginner with no background in computer science or maths, I suggest you start with environments like Max/MSP, CSound, Synth Edit, Pure Data, Reaktor, Super Collide, etc. If you want to get into VST plugin development more deeply, start with studying audio signal processing.
Then, I would suggest you start learning the basics of C++, like its syntax, variables and data types, operators, structures, functions, arrays, etc. Once you get familiar with that, JUCE is the best platform to develop your plugins.
VST development, like any other application development, requires technical skills and mathematical aptitude. In addition, it also requires knowledge of audio engineering, signal processing, DAWs, and musical knowledge.
C++ rules the audio development world because of its efficiency, cross-platform compatibility, multi-threading, third-party integration, and, most importantly, the industry-standard SDK set by Steinberg in the foundational years. That has led to C++ having the most libraries and modules for plugin development.
However, with the rise of technology, we have easier tools that do not require coding. However, even these visuals and patching tools can be more intuitive and user-friendly. These tools also require DSP knowledge.
But who knows, we might get AI-powered prompt-based plugin generators and development applications in the future (fingers crossed). I hope this article answers your question. Thank you for reading!