Developing VST plugins

Over the years, I’ve primarily focused on developing traditional audio manipulation plugins. These plugins were designed to process and manipulate audio in various ways, such as EQ, compression, reverb, and distortion. However, with the release of AutoGain, I decided to venture into a new direction—creating plugins that actively interact with the host DAW, opening up new opportunities for automation and real-time adjustments.

Unlike most conventional plugins that focus solely on processing audio, AutoGain had a distinct requirement: it needed to communicate dynamic changes back to the host. This posed a unique set of challenges because the plugin wasn’t merely adjusting or affecting the audio signal directly—it was interacting with the DAW’s automation system. To achieve this, I had to ensure that AutoGain could communicate with the DAW in real-time and send information about the computed gain, allowing the DAW to adjust automation tracks or other control elements dynamically.

One of the first hurdles I encountered during the development of AutoGain was the lack of uniformity in how different DAWs implement the VST protocol. The VST specification, while incredibly detailed and comprehensive, doesn’t provide clear, strict guidelines on how every feature should be implemented. The specification provides the foundation for how plugins and DAWs should interact, but it allows flexibility for interpretation. This flexibility means that various DAW manufacturers and plugin developers can take different approaches to handling VST plugins, which leads to a broad range of inconsistencies when it comes to how the plugins operate within different environments.

To achieve the behavior I needed, AutoGain had to be capable of sending and receiving automation data in real-time. For this, the plugin needed to inform the host DAW whenever the gain values were updated. The VST specification does indeed have a dedicated callback function for this purpose, but in practice, not all DAWs implement this in the same way. What works in one DAW might not work as expected in another. This posed a considerable challenge when trying to create a plugin that would work across multiple DAWs, especially when the goal was to write automation data dynamically during audio processing.

During the development of the Audio Unit and VST 2.4 versions of AutoGain, I encountered relatively few issues with DAWs such as Ableton Live, Reaper, and Logic Pro. These DAWs exhibited behavior that I expected from the plugin. The hosts were responsive to the changes in gain and allowed the automation data to be passed seamlessly during the audio processing thread. Everything worked as anticipated, and I was able to achieve smooth, dynamic control over the gain changes, which is precisely what I wanted for AutoGain.

However, when I moved to the development of the VST3 version, I started facing a different set of challenges, especially with certain DAWs such as Cubase. VST3, while an advancement over VST2, presented some new complexities, particularly when interacting with hosts that were not fully aligned with the VST3 protocol. Specifically, some DAWs required the automation callback to be triggered not from the audio processing thread, but from the graphic user interface (GUI) thread. This was contrary to how I had implemented the automation in the earlier versions of the plugin, where the callback was triggered directly during audio processing.

To make matters more complex, some hosts that I tested failed to accept the automation command when sent from the audio processing thread. In fact, this mismatch led to complete crashes in some DAWs. This is a problem that many plugin developers face—DAWs and plugins don’t always play nice with each other, especially when it comes to complex features like real-time automation and audio processing. The solution to this problem wasn’t immediately obvious, but after extensive testing and iteration, I realized that the answer lay in adjusting how the automation callback was triggered.

To solve this, I adapted the plugin by moving the automation callback into the draw function of the gain indicator within the plugin’s GUI. The draw function, or redraw method, is responsible for updating and rendering the plugin’s interface. So, instead of trying to communicate the gain changes through the audio processing thread, I ensured that every time the gain indicator was redrawn, it would update the gain value and communicate it to the host. This method, while unconventional and outside the typical textbook approach to plugin development, proved to be effective.

The result was that AutoGain now successfully communicated the gain changes to the host without triggering crashes or instability, even in DAWs that initially had issues with VST3. This solution worked across a variety of environments, which was a significant relief. It was an important reminder that sometimes in software development, the best solutions come from thinking outside the box and being willing to adapt, even if it means bending the rules a bit. The main goal was always to ensure that the plugin could function smoothly in a variety of real-world situations.

While this solution worked for the VST3 version, it also highlighted the need for plugin developers to deeply understand the nuances of DAW interaction and the intricacies of different plugin formats. Developing a plugin that works well across multiple platforms requires a deep understanding of how DAWs handle VSTs and AU plugins and how those interactions can affect performance and stability. It’s one thing to develop a plugin that processes audio in a standard, predictable way, but it’s another thing entirely to develop one that has to dynamically interact with the host’s automation system in real-time.

Ultimately, the experience of developing AutoGain was incredibly valuable and educational. It taught me the importance of thoroughly testing across multiple DAWs and plugin formats. Even small variations in how different DAWs handle certain functions can have a significant impact on the user experience. By addressing these challenges and finding creative solutions, I was able to create a plugin that works reliably across a broad range of environments.

Please enjoy using AutoGain in your projects. It’s designed to simplify the process of managing gain changes and ensure that your mixes maintain consistent dynamics. If you encounter any issues or bugs, please don’t hesitate to reach out. I’m always happy to hear your feedback and continue improving the plugin. Your input is invaluable in making AutoGain an even better tool for everyone.

Thank you for your support, and I look forward to continuing to improve AutoGain and other plugins in the future!