Darvaza is a VST/AU plug-in which provides a gating effect. The gate can use different waveforms and its speed is individually controllable across channels. The gates oscillators are synchronized to the host tempo and time signature. What sets the plugin apart from the usual oscillator based gates is that the gate functions using quid pro quo. When the gate closes on your input signal, you get a signal in return. This signal is based on your input, but a plethora of things have gone wrong with it. Basically you get your incoming sound as if it was part of a bad dream.

If you must know exact details, the returned sound can be time stretched, down sampled, reversed, bit crushed, reverberated and frozen. Kinda what you'd imagine is left of a soul after all Hell has chewed it out.

VST3 is great and all, but support across DAW's is poor (looking at a certain popular German product). You can however build as a VST2.4 plugin and enjoy it on a wider range of host platforms.

However: as of SDK 3.6.11, Steinberg no longer packages the required ./pluginterfaces/vst2.x-folder inside the vst3sdk folder. If you wish to build a VST2 plugin, copying the folder from an older SDK version could work (verified 3.6.9. vst2.x folders to work with SDK 3.7.6), though be aware that you need a license to target VST2. You can view Steinbergs rationale on this decision here.

Once your SDK is "setup" for VST2, simply uncomment the following line in CMakeLists.txt:

set(SMTG_CREATE_VST2_VERSION "Use VST2" ON)

And rename the generated plugin extension from .vst3 to .vst (or .dll on Windows). Alternatively, pass "vst2" as an argument to the build.sh and build.bat files without having to edit the make file or rename the generated VST manually. E.g.:

sh build.sh vst2

Depending on your host software having 32-bit or 64-bit support (either Intel or M1), you can best compile for a wider range of architectures. To do so, replace all invocations of cmake in this README with the following:

macOS:

cmake -"DCMAKE_OSX_ARCHITECTURES=x86_64;arm64;i1386" ..

Which will allow you to compile a single, "fat" binary that supports all architectures (Intel, M1 and legacy 32-bit Intel).

Windows:

cmake.exe -G "Visual Studio 16 2019" -A Win64 -S .. -B "build64"
cmake.exe --build build64 --config Release

cmake.exe -G "Visual Studio 16 2019" -A Win32 -S .. -B "build32"
cmake.exe --build build32 --config Release

Which is a little more cumbersome as you compile separate binaries for the separate architectures.

Note that the above also needs to be done when building the Steinberg SDK (which for the Windows build implies that a separate build is created for each architecture).

While macOS has been fully 64-bit for the past versions, building for 32-bit provides the best backward compatibility for older OS versions. And musicians are known to keep working systems at the cost of not running an up to date system...

The project uses CMake to generate the Makefiles and has been built and tested on macOS, Windows 10 and Linux (Ubuntu).

Apart from requiring CMake and a C(++) compiler such as Clang or MSVC, the only other dependency is the VST SDK from Steinberg (the projects latest update requires SDK version 3.7.10+).

Be aware that prior to building the plugin, the Steinberg SDK needs to be built from source as well. Following Steinbergs guidelines, the build target should be a /build-subfolder of the /vst3sdk-folder. To generate a release build of the library, execute the following commands from the root of the Steinberg SDK folder:

cd vst3sdk
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
cmake --build .

The result being that {VST3_SDK_ROOT}/build/lib/Release/ will contain the Steinberg VST libraries required to build the plugin. NOTE: Windows users need to append --config Release to the last cmake (build) call as the build type must be defined during this step.

If you intend to build VST2 versions as well, run the following from the root of the Steinberg SDK folder (run the .bat version instead of the .sh version on Windows) prior to building the library:

./copy_vst2_to_vst3_sdk.sh

And if you are running Linux, you can easily resolve all dependencies by first running the following from the root of the Steinberg SDK folder:

./tools/setup_linux_packages_for_vst3sdk.sh

Run CMake to generate the Makefile for your environment, after which you can compile the plugin using make. The build output will be stored in ./build/VST3/darvaza.vst3 as well as symbolically linked to your systems VST-plugin folder (on Unix).

You must provide the path to the Steinberg SDK by providing VST3_SDK_ROOT to CMake like so:

cmake -DVST3_SDK_ROOT=/path/to/VST_SDK/vst3sdk/ ..

mkdir build
cd build
cmake -DVST3_SDK_ROOT=/path/to/VST_SDK/vst3sdk/ ..
make .

Assuming the Visual Studio Build Tools have been installed:

mkdir build
cd build
cmake.exe -G"Visual Studio 16 2019" -DVST3_SDK_ROOT=/path/to/VST_SDK/vst3sdk/ ..
cmake.exe --build .

You can copy the build output into your system VST(3) folder and run it directly in a VST host / DAW of your choice.

When debugging, you can also choose to run the plugin against Steinbergs validator and editor host utilities:

{VST3_SDK_ROOT}/build/bin/validator  build/VST3/*.vst3
{VST3_SDK_ROOT}/build/bin/editorhost build/VST3/darvaza.vst3

For this you will need a little extra preparation while building Steinberg SDK. Additionally, you will need the CoreAudio SDK and XCode. Execute the following instructions to build the SDK with Audio Unit support, replace SMTG_COREAUDIO_SDK_PATH with the actual installation location of the CoreAudio SDK:

cd vst3sdk
mkdir build
cd build
cmake -GXcode -DCMAKE_BUILD_TYPE=Release -DSMTG_COREAUDIO_SDK_PATH=/path/to/CoreAudioSDK/CoreAudio ..
cmake --build . --config Release

Now execute the following command to build the plugin as an Audio Unit:

• Run sh build_au.sh from the repository root, providing the path to VST3_SDK_ROOT as before, e.g.:

VST3_SDK_ROOT=/path/to/VST_SDK/vst3sdk sh build_au.sh

The subsequent Audio Unit component will be located in ./build/VST3/darvaza.component as well as linked in ~/Library/Audio/Plug-Ins/Components/

You can validate the Audio Unit using Apple's auval utility, by running auval -v aufx trem IGOR on the command line. Note that there is the curious behaviour that you might need to reboot before the plugin shows up, though you can force a flush of the Audio Unit cache at runtime by running killall -9 AudioComponentRegistrar.

NOTE: Updates of the Steinberg SDK have been known to break Audio Unit support. If the above steps don't work, you can always try building the plugin as part of the VST SDK by checking out the repository inside the /samples/vst/-folder (move CMakeLists.txt in /audio-unit-folder down one level). Then build the VST3_SDK as documented above.