Jamba C++ API  5.1.1
What is Jamba?

Jamba is a set of helpers (classes, concepts, build files, etc...) built on top of the VST SDK to provide a lightweight framework to build a VST2/3 plugin. Jamba has been designed to help in building VST2/3 plugin, not to replace it: you are still writing a VST2/3 plugin, not a Jamba plugin.

Jamba is a free and open source project hosted on github.

The Jamba main website contains more information about the project.



  • generate a fully buildable, testable, editable and deployable plugin (see Quick Starting Guide)
  • automatically download dependencies

Build & Deploy

  • simple script to build, test, validate, edit and install the plugin from the command line (see jamba.sh (.bat))
  • build a self contained plugin that depends on the VST3 SDK
  • optionally builds a VST2 compatible plugin
  • optionally wraps the VST3 plugin into an Audio Unit plugin (macOS)
  • easily adds resources (images) in a cross platform way
  • easily write unit tests for your project
  • build on macOS and Windows 10
  • package your project as an archive (zip file) for production release

C++ classes & concepts

  • pick and choose which feature is useful to you (lots of options to override/change the default behavior)
  • define your VST parameters in one location (inherit from Parameters) and use both in real time processing (RT) and GUI code
  • define typed VST parameters (ex: a boolean (bool) parameter, a gain (Gain) parameter, etc...)
  • use typed VST parameters directly in RT processing code as well as GUI code
  • use Jamba parameters for handling non VST parameters (ex: a label/text string cannot be represented by a VST parameters). Jamba parameters can be automatically saved/restored part of the state
  • use Jamba parameters to easily exchange messages between RT and GUI (both directions) in a thread safe fashion
  • easily create custom views with their creators (so that they appear in the GUI editor)
  • easily use multiple parameters in a custom view (ex: a custom display which displays a gain value (parameter 1) in a color depending on parameter 2)
  • store/read state in a thread safe fashion (includes version)
  • Jamba Views

Getting Started

Check the Quickstart section to getting started.

Quick documentation links


VST parameters are what the host DAW deal with (for example a knob is usually tied to a VST parameter). Both the GUI and the RT (Real Time) are "sharing" those parameters. As a result Jamba makes them front and center: you define them in one place and use them in the GUI and RT.

Note: the Jamba framework introduces a new kind of parameters that go beyond VST parameters (which are limited to a double value in the range [0.0, 1.0]) called Jamba parameters (Jmb).

Start by inhering from this class to register your own parameters.


After declaring your parameters, you should inherit from RTState which is the class that is being used from the RT (real time) processor.


The Real Time (RT) processing code is where the main logic of the plugin resides. The DAW repeatedly calls the process method (actually pongasoft::VST::RT::RTProcessor::processInputs32Bits or pongasoft::VST::RT::RTProcessor::processInputs64Bits in Jamba) to process a batch of samples. This is usually called a "frame". The processor uses the pongasoft::VST::RT::RTState class. You simply need to inherit from pongasoft::VST::RT::RTProcessor.


After declaring your parameters, you should inherit from pongasoft::VST::GUI::GUIState which is the class that is being used in the UI (only necessary for Jmb parameters as Vst parameters are direcly accessible in the UI)


The entry point of the GUI is the GUI controller. Jamba takes care of most of the details of the implementation for you: you simply need to inherit from pongasoft::VST::GUI::GUIController. The controller uses the pongasoft::VST::GUI::GUIState class and makes it available to all the views). /