Release Notes

Make sure to check the Requirements documentation for information about which VST3 SDK Jamba supports and how to get it.

Version 7.0.1 (2023-05-27)

  • Use download url/hash in blank plugin

Version 7.0.0 (2023-05-25)

  • Migrated Jamba to use VST3 SDK 3.7.8 (release notes). Please check other release notes to see what has changed since 3.7.5 (last Jamba supported version).
  • As explained in issue #16, Jamba is no longer supporting VST2
  • Added a way to patch the SDK by defining the CMake cache string JAMBA_VST3SDK_PATCH_DIR (Jamba uses it on Windows/DLL build to fix an issue with win32resourcestream.cpp, but you can also use it for your own purposes): by defining this variable, 2 things happen
    • Jamba copies the SDK inside the build folder
    • Jamba copies all the files under ${JAMBA_VST3SDK_PATCH_DIR} on top of this copy while never modifying a local version of the SDK
Warning - Migration required

Version 6.3.0 (2023-05-14)

  • Fixed NaN issue with stringToFloat by changing its return convention (0 instead of NaN) due to fast-math option which assumes that there is no NaN in the code.
  • Fixed invalid version.h file generated on Windows
  • Integrated with GitHub actions in order to do a matrix style testing (which uncovered the 2 previous issues)
    • Windows 10 Visual Studio 2019 & 2022
    • macOS 11 (Xcode 13.2) & macOS 12 (Xcode 14.2)

Version 6.2.1 (2023-04-27)

  • Fixes compilation issues with XCode 14+
  • Automatically adds libraries (LINK_LIBRARIES) to the universal build (M1 builds)
  • Removed most warnings coming from the SDK/Jamba

Version 6.2.0 (2023-04-19)

  • Enhanced AudioBuffer API

Version 6.1.0 (2023-04-15)

  • Added support for arrays of properties (see Plugin.h for a full example). For example, you can now write:
    // Parameters
    VstParams<bool, 2> fArrayVst;
    // State
    RTVstParams<bool, 2> fArrayVst;
  • Upgraded GoogleTest to 1.13.0 (and download a zip instead of cloning the repo)

Version 6.0.1 (2022-06-02)

  • Fixed gtest crash on Apple M1 platform

Version 6.0.0 (2022-05-30)

  • Migrated Jamba to use VST3 SDK 3.7.5 (introduces breaking changes)
  • Requires CMake minimum version 3.19 (SDK requirement)
  • Added inspect command to run the VST3Inspector tool
  • Added info command to run the moduleinfotool tool (new since SDK 3.7.5)
  • Generate and bundle moduleinfo.json (new since SDK 3.7.5)
  • On Windows, build a module (.vst3 folder) instead of a DLL when VST2 is disabled
  • Use json format instead of xml (new since SDK 3.7.2)
Warning - Migration required

Version 5.1.5 (2021-09-13)

  • Added support for snapshots
  • Processes Info.plist through CMake replacement, thus allowing to inject dates, versions, etc…
  • Processes Info.plist through Xcode preprocessing when using Xcode generator
  • Fixed issue when plugin was generated without Xcode generator (macOS only) which lead to an Info.plist without proper version
  • Use latest version of GoogleTest (get rid of CMake warnings)
  • Use gtest_discover_tests instead of gtest_add_tests to minimize CMake invocation when building tests
  • Make sure that .rc file gets regenerated properly when resource files change (Windows)
  • Fixed test issue
Warning - The following changes are potentially breaking changes
  • Due to the change in Info.plist processing, you should replace:
    <-- File mac/Info.plist -->
    <-- Replace this (processed only via Xcode preprocessing) -->
    <-- With this (processed with all generators) -->
  • Note that since Audio Unit plugins are only generated with the Xcode generator, this change is not necessary for audio-unit/Info.plist

Version 5.1.4 (2021-02-06)

  • Fixed issue #11: instructions point to wrong configure script
  • Fixed issue #10: jamba is for python 3.7+

Version 5.1.3 (2021-01-04)

  • Fixed compilation issue on Windows

Version 5.1.2 (2021-01-02)

  • Added support for Apple Silicon / universal build and macOS target deployment (no code change)
  • Added (optional) ARCHIVE_FILENAME and ARCHIVE_ARCHITECTURE to the main jamba_add_vst_plugin CMake api
Note - Optional migration
  • Apple Silicon support is optional but if you want to benefit from it you need to change your CMakeLists.txt

Version 5.1.1 (2020-12-07)

  • Added JambaPluginFactory::GetNonDistributableVST3PluginFactory function to create a plugin that would not be distributable
  • Added default implementation to IParamSerializer methods
  • Fixed Audio Unit build (changes in VST 3.7.0)
  • Added missing uninstall-au command to

Version 5.1.0 (2020-11-23)

  • Migrated Jamba to use VST3 SDK 3.7.1
Warning - The following changes are potentially breaking changes
  • SDK 3.7.1 made a number of changes in the cmake based build files (mostly renaming) and it is all covered by Jamba unless you have been using those symbols directly in your own cmake build files
  • SDK 3.7.1 renamed the define EXPORT_FACTORY into SMTG_EXPORT_SYMBOL. Jamba is adding it back for backward compatibility (in PluginFactory.h) but you may want to update it.

Version 5.0.0 (2020-08-26)

  • Migrated Jamba to use VST3 SDK 3.7.0

  • Major refactoring of CMake files to make it easier to use and extend/customize (check CMake Build)

  • Replaced main dev script implementation with a python script (with the added benefit that the Windows version is now on par with the macOS one).


    The wrapper shell scripts ( and jamba.bat) are still the official way to invoke it and should be treated as an implementation detail.

  • Improved main script to run multiple commands (ex: test validate)

  • Replaced configure script with a python script (blank plugin now uses it)

  • Added many new (cmake) targets so that you no longer have to rely on the script. For example running the editor can now simply be achieved by building the jmb_run_editor target.

  • Jamba itself has not changed (no new API) and only very few tweaks were required to migrate to 3.7.0

Warning - Migration required
  • You will need to migrate your main CMakeLists.txt to invoke jamba_add_vst_plugin which is the new (cmake) API to add a VST3 plugin (single call).
  • Note that the zip file generated by the archive command / target is slightly different due to the use of cpack (but due to the CMake refactoring it is easy to turn it off entirely or implement your own)
Warning - The following changes are potentially breaking changes
  • Because Jamba now uses VST3 SDK 3.7.0 there might be APIs that you were using from the SDK that have changed (for example Drag’n’Drop is handled differently)
  • Because the latest VST3 SDK does not include VST2 anymore, you need to provide it as a separate path (VST2_SDK_ROOT)
  • Jamba now has a requirement on python (3) for the script (note that you can disable generation of the script by using the CMake option JAMBA_ENABLE_DEV_SCRIPT in which case python is not required)
  • install command no longer deletes the folder before installation. Use ./ uninstall install if you want this behavior.
  • prod command has been removed from main dev script (equivalent to -r -b test validate archive but check migration guide for details on how to add it back as a target if you really need it)
  • Requires CMake 3.17
  • Tested on macOS 10.14.6 with Xcode 11.3.1 (may work with prior versions but untested). Note that there is no requirement changes for Windows.

If you want to benefit from the new configure python script (, simply copy it from the blank plugin (it is 100% generic so it will work for any Jamba project)

Version 4.5.0 (2020-08-03)

  • Improved messaging (GUI <-> RT) and VST2 performance by using FastWriteMemoryStream (a faster implementation of MemoryStream)
  • Added the ability to show and dismiss a dialog view (for example, an About view or an alert):
    // Example from some controller (aboutButton is a TextButtonView)
    aboutButton->setOnClickListener([this] {
    // From another controller tied to the about_dialog view (set via the sub-controller attribute)
    dismissButton->setOnClickListener([this] {

Version 4.4.0 (2020-04-26)

  • Updated loguru to latest (as of master on 2020-03-31)

  • Added missing using types and toUTF8String() methods to XXXParam classes

  • Added resetToDefault() method to all parameters (since a default value is provided when the parameter is created, it is a very convenient way to get back to it without having to know about it and using some global constant)

  • Added ExpiringDataCache concept (using Timer from the VST3 SDK)

  • Renamed the plugin file from the blank plugin to Plugin.h (instead of the name of the plugin)

  • Changed the way the plugin gets registered to the VST3 world (implements the main GetPluginFactory() function) with an easier and less error prone syntax:

    EXPORT_FACTORY Steinberg::IPluginFactory* PLUGIN_API GetPluginFactory()
      return JambaPluginFactory::GetVST3PluginFactory<
        pongasoft::test::jamba::RT::JambaTestPluginProcessor, // processor class (Real Time)
        pongasoft::test::jamba::GUI::JambaTestPluginController // controller class (GUI)
      >("pongasoft",                 // vendor
        "", // url
        "",     // email
        stringPluginName,            // plugin name
        FULL_VERSION_STR,            // plugin version
        Vst::PlugType::kFx           // plugin category (can be changed to other like kInstrument, etc...)


    This new syntax is optional and the old/macro based syntax is still valid and acceptable (new blank plugins will be created using this new methodology). If you want to migrate your codebase to the new factory you can check this commit for the JambaSampleGain project as an example.

Version 4.3.0 (2020-03-30)

  • Handle state deprecation which allows a plugin to change the state saved by a previous version in a non backward compatible way (for example removing parameters)
  • Added StepPadView to allow a parameter value to be changed by dragging the mouse (useful for lcd displays, etc…)
  • Fixed MomentaryButtonView to decouple the state of the button with the value of the parameter (which caused several rendering issues)

Version 4.2.0 (2020-03-16)

  • Added ParamImageView to render a parameter value as an image (very useful for status LEDs, etc…)
  • Added ImageView to render an image (useful for static images, logos, decals, stickers, etc…)
  • Upgraded googletest to 1.10.0 (due to CMake caching, this requires deleting the CMake build folder to take effect on existing projects)

Version 4.1.0 (2020-02-09)

  • Due to issues with implicit conversion triggering potential hard crash, deprecated implicit conversion to T for all params (RTRawVstParam, RTParam, GUIRawVstParam, GUIVstParam, GUIJmbParam, GUIOptionalParam).
  • Added convenient dereference operator (operator *) to all params as a shortcut to invoke .value() (which is the preferred way to fix the deprecated warnings)
  • Added convenient equality and relational operators to all params so that the params still continue to behave like the underlying type (T) in many instances
  • Handle toUTF8String() for Jmb parameter when no serializer is provided by checking the availability of ostream<< for T
  • Allow the use of the template name _ for the switch container view (for example to use as an overlay that is shown/hidden)

Version 4.0.1 (2019-11-29)

  • Added Visual Studio Code configuration files for Windows 10

Version 4.0.0 (2019-10-28)

This release contains a lot of big changes. Although I tried my best to be backward compatible there may be a few changes that might be breaking.

  • Build requirements: Jamba now requires C++17 and Visual Studio Build Tools 2019 (for Windows) (note that XCode 9.2 remains the requirement for macOS)

  • Major GUI parameter refactoring:

    • Introduced IGUIParameter and typed hierarchy (ITGUIParameter<T>) as the base of all GUI parameters
    • Introduced GUIOptionalParam to handle Vst, Jmb or no parameter in a consistent fashion
    • Introduced the concept of discrete parameter (IGUIParameter::asDiscreteParameter(int32 iStepCount)) to convert (if possible) any parameter into a discrete parameter (which is a parameter backed by an int32 with a given number of steps)
    • Refactored most views to use the new optional and discrete parameter concepts, thus making them way more flexible
    • Changed MomentaryButtonView and ToggleButtonView to use discrete parameter concept (thus allowing other types than bool) and allowing to override the value of the steps representing on and off.
    • Changed SwitchViewContainer to use discrete parameter concept, thus allowing to use any Vst or Jmb parameter that is (or can be interpreted as) a discrete parameter.
  • Major renaming: introduced ParamAware (formerly GUIParamCxAware) and StateAware (formerly PluginAccessor) (added deprecation warnings for old names) and related.

  • Jmb GUI parameters no longer needed to be explicitly added to GUIState (similar to Vst parameters)

  • Added IDiscreteConverter<T> concept for Jmb parameters to be able to convert a Jmb parameter to a discrete parameter

  • Added ParamDisplayView to display the value of any parameter (Vst or Jmb)

  • Added DebugParamDisplayView to display and highlight the value of a parameter (very useful during development)

  • Added ListAttribute to handle attributes backed by a list of values (for example enumeration)

    // Example (from StepButtonView.h)
                                             {"auto", EArrowDirection::kAuto},
                                             {"up", EArrowDirection::kUp},
                                             {"right", EArrowDirection::kRight},
                                             {"down", EArrowDirection::kDown},
                                             {"left", EArrowDirection::kLeft}

  • Simplified parameter initialization by allowing to use initializer list and added more generic DiscreteTypeParamConverter:

    // Example: with DiscreteTypeParamConverter, no need to specify size in advance. Also note the 
    //          use of the initializer list to initialize it.
    fEnumClassVst =
      vst<DiscreteTypeParamConverter<EEnumClass>>(EJambaTestPluginParamID::kEnumClassVst, STR16("EnumClassVst"),
                                                    {EEnumClass::kEnumClass0, STR16("kEC0 (vst)")},
                                                    {EEnumClass::kEnumClass1, STR16("kEC1 (vst)")},
                                                    {EEnumClass::kEnumClass2, STR16("kEC2 (vst)")},
                                                    {EEnumClass::kEnumClass3, STR16("kEC3 (vst)")},

  • Added jamba-test-plugin to the Jamba project as a unit test/development plugin for Jamba (demonstrates ALL available views)

  • Added to conveniently run the jamba tests (which are declared by jamba-test-plugin) from the command line

  • Added test_jamba target to run the jamba tests from the IDE

  • Added 2 different sets of UUIDs in blank plugin to handle Debug vs Release deployments

Warning - The following changes are potentially breaking changes
  • Changed the way Jamba handles parameter registration:
    • Introduced ICustomViewLifecycle which is now used instead of GUIParamCxAware (in CustomViewFactory)
    • The default behavior is now to call ParamAware::unregisterAll() followed by ParamAware::registerParameters()
    • The consequence is that the registerParameters method that you implement in your view is much simpler because it does not have to handle previously registered parameters (which was not trivial to keep an accurate track of)
    • Allow multiple registrations per paramID. Prior to this release, registering multiple callbacks per paramID resulted in only the last one registered being called. Now all of them will be called.
  • StepButtonView and DiscreteButtonView now use discrete values only (no longer double). Check the documentation on how to use it instead (ex: an increment of 0.1 can be converted to an increment of 1 with a step count of 10).
  • Changed TagID to be an unsigned int (ParamID aka uint32)
  • Changed default template type for DiscreteValueParamConverter to be an int32
  • Although care has been taken with renaming/adding deprecation warnings for old names, there is a chance (mostly with templated parameters) that it may impact compilation.

Version 3.2.4 (2019-08-03)

  • fixed blank plugin initialize API to match superclass

Version 3.2.3 (2019-08-01)

  • Implemented #6: added cmake targets build_vst3, test_vst3, install_vst3, install_vst2, build_au and install_au
  • This change allows those targets to be used directly in an IDE and for example use them for debugging (ex: attach a DAW executable to install_vst2 or install_vst3)
  • Modified and jamba.bat to use the new cmake targets (making the scripts more generic)
  • Added ability to customize (extend or completely override) the following targets:
    • build_vst3 by setting an optional BUILD_VST3_TARGET variable
    • test_vst3 by setting an optional TEST_VST3_TARGET variable
    • build_au by setting an optional BUILD_AU_TARGET variable

Version 3.2.2 (2019-07-23)

  • released Jamba website with Quickstart section to make it very easy to generate a blank plugin (answer a few questions in the browser)
  • added (optional) VST3 SDK automatic download to the blank plugin (web and command line)
  • fixed blank plugin creation issue when no company was provided

Version 3.2.1 (2019-05-19)

  • fixed script to handle filename with white spaces and install audio unit before validation (validation tool unfortunately works from an installed component, not a file…)

Version 3.2.0 (2019-05-19)

  • added audio unit validation to script ( validate-au) which runs the auvaltool utility on the audio unit plugin
  • added switch container view to handle tab like switching (check Views::SwitchContainerView)
  • added (optional) image for text buttons (Views::TextButtonView)
  • added (optional) disabled state for momentary buttons (Views::MomentaryButtonView)
  • added discrete button view (a button which is “on” only when the backing discrete parameter matches the step value). This button can be used for radio groups, tabs, etc… (check Views::DiscreteButtonView)
Warning - The following changes are potentially breaking changes
  • There is a small potentially breaking API change with function Views::createCustomView (defined in Views/CustomViewCreator.h). Check commit. The function takes an additional 2 parameters which can be safely ignored if you don’t need them.

Version 3.1.0 (2019-02-10)

  • added ability to conveniently register a global key hook (check Views::registerGlobalKeyboardHook)
  • parameters now copy the provided strings (title, short tile and units) so that they no longer have to be static and for example can be computed
  • added convenient methods to AudioBuffers and Channel (copyFrom and forEachSample). Defined const and non const versions.
  • added Step Button view which is a button that increment/decrement a parameter by a fixed amount when clicked. Another amount (tied to shift click) can be provided.

Version 3.0.2 (2019-01-06)

  • fixed minor bugs

Version 3.0.1 (2019-01-04)

  • Use shallow cloning to avoid downloading the (unused) project history

Version 3.0.0 (2019-01-03)

  • This is a major release with many changes (a few breaking APIs)

  • Added TextViewButton on which you can register a onClickListener or implement onClick. Also handles disabled state.

  • Added ScrollbarView which implements a scrollbar tied to 2 parameters (offset and zoom)

  • Added CustomController to implement a custom controller tied into Jamba (access to Vst/Jmb parameters and state)

  • Added ability to easily switch to a new view (GUIController::switchToView)

  • Added GUIJmbParameter::updateIf to update the value in place when necessary

  • Added callback APIs to GUIParamCxAware

                           [this] (GUIVstParam<bool> &iParam) {

  • Added registering callbacks and parameters on a view without inheriting from it (can be used from controllers verifyView method):

    auto button = dynamic_cast<Views::TextButtonView *>(iView);
    if(button) {
      auto callback = [] (Views::TextButtonView *iButton,
                          GUIJmbParam<SampleData> &iParam) {

  • Added optional arguments to Parameters::vst<>() (resp. Parameters::jmb<>()) that get passed through the converter (resp. serializer) allowing syntax like

    fPlayModeHold =
      vst<BooleanParamConverter>(1201, // param ID
                                 STR16("Play Mode"), // param title
                                 STR16("Trigger"), STR16("Hold")) // BooleanParamConverter args

  • Requires C++14

  • Added EnumParamConverter for Vst parameters backed by an enum

  • Added Range concept

  • Refactored CustomViewCreator code to simplify writing individual attributes. Introduced MarginAttribute, RangeAttribute, and GradientAttribute

Warning - The following changes are potentially breaking changes
  • Refactored Lerp class to deal with type parameters differently (TFloat for math precision, X for type of x, Y for type of y). Introduced SPLerp (single precision) and DPLerp (double precision) as well as several convenient methods. Example:

    // this will interpolate (SP=single precision)
    // X -> the time (long) from the range [0, fFadeDuration]
    // Y -> to the alpha (uint8_t) range [255, 0] (opaque -> transparent)
    // Note that although X and Y types are integer flavors, the interpolation will use floats
    // and the value returned will be cast to uint8_t
    fColor.alpha = Utils::mapValueSPXY<long, uint8_t>(iTime, 0, fFadeDuration, 255, 0);
  • GUIParamCxAware (which is the class used for registering parameters) has been simplified with registerParam methods (when the type is known).

  • Moved PluginAccessor into its own header file

  • Removed CustomViewInitializer

Version 2.1.2 (2018-10-11)

  • AudioBuffers now properly handles null buffers
  • Fixed issue with non Xcode build (Xcode generator is only required for audio unit building) and allow building with CLion

Version 2.1.1 (2018-10-06)

  • Fixed #4: Generate AU Plugin Manufacturer code from name instead of company

Version 2.1.0 (2018-10-06)

  • Implemented #1: Eliminate resource declaration duplication
  • Implemented #2: Optionally generate audio unit wrapper
  • Implemented #3: Make VST2 support truly optional
  • Upgraded to cmake 3.12
  • Consolidated dev scripts into a single (resp jamba.bat) script
  • Uses Xcode as the cmake generator on macOS

Version 2.0.2 (2018-09-02)

  • Updated license terms

Version 2.0.1 (2018-08-28)

  • Added ability to create a jamba enabled blank plugin: the plugin simply copies the input to the output and offers all the capabilities of jamba (build, test, edit, validate, install, etc…).

Version 2.0.0 (2018-08-25)

  • Introduced Jamba parameters to handle non VST parameters and messaging RT <-> GUI

  • Added Debug::ParamTable and Debug::ParamLine to display parameters => example

    | ID   | TITLE      | TYP | OW | TRS | SHA | DEF.N | DEF.S          | STP | FLG   | SHORT  | PRE | UID | UNS |
    | 1000 | Bypass     | vst | rt |     |     | 0.000 | Off            | 1   | 65537 | Bypass | 4   | 0   |     |
    | 2010 | Left Gain  | vst | rt |     |     | 0.700 | +0.00dB        | 0   | 1     | GainL  | 2   | 0   |     |
    | 2011 | Right Gain | vst | rt |     |     | 0.700 | +0.00dB        | 0   | 1     | GainR  | 2   | 0   |     |
    | 2012 | Link       | vst | ui |     |     | 1.000 | On             | 1   | 1     | Link   | 4   | 0   |     |
    | 2020 | Reset Max  | vst | rt |     |     | 0.000 | Off            | 1   | 1     | Reset  | 4   | 0   |     |
    | 2000 | VuPPM      | vst | rt | x   |     | 0.000 | 0.0000         | 0   | 1     | VuPPM  | 4   | 0   |     |
    | 3000 | Stats      | jmb | rt | x   | x   |       | -oo            |     |       |        |     |     |     |
    | 2030 | Input Text | jmb | ui |     |     |       | Hello from GUI |     |       |        |     |     |     |
    | 3010 | UIMessage  | jmb | ui | x   | x   |       |                |     |       |        |     |     |     |

  • Implemented lock free, memory allocation free and copy free version of SingleElementQueue and AtomicValue

  • Generate build, test, validate, edit and install scripts

  • Added jamba-sample-gain documentation project

Version 1.0.0 (2018-08-05)

  • first public release / free / open source