Getting Started
Overview
Thanks for your interest in the Gorilla Engine SDK. Gorilla Engine is a powerful suite of tools designed to make virtual instrument and audio plugin development easy. This guide will provide a quick, high-level overview to help you understand the various components of Gorilla Engine and how they work together to help you produce your plugins.
Gorilla Engine Components
The following components make up the Gorilla Engine SDK:
Gorilla Editor
Installed in the “Applications” folder of your operating system.
This application is where you will create the “sound core” of your plugin (i.e., everything other than graphical user interface). It is where you will do things like grouping, looping, stacking/splitting and mapping the audio samples for your instrument. Or defining signal flow and processing within an effect plugin. You can also add audio processing (like filters or reverb) or create modulators (envelopes and LFOs) and route them to the desired destinations within your plugin. Finally, you can use Gorilla Script (described below) to define what controls you would like to expose to end users when they use your plugin.
When you have finalized the sound core your instrument in Gorilla Editor, the next step is to export .blob (Binary Large Object) files from the editor. These funny sounding files contain all of the information from your Gorilla Editor instrument in one place (samples, instrument scripts, layer and split points, routing, filters and effects, etc). You will need these .blob files for the next step of the development process.
Gorilla Script and Examples
Gorilla Script is a scripting language that lets you bind your plugin’s internal parameters (like filter cutoff, resonance amount, etc.) to on-screen controls (knobs, sliders, etc.) It also lets you develop new functionality like arpeggiators, crossfaders or tempo sync. You can create your own custom scripts from scratch or adapt any of the useful examples we have included in the SDK > Examples > Script Examples folder to save you time. Think of these scripts as LEGO blocks that you can use to build the instrument you want. If you are familiar with Kontakt Script, you will find many similarities in Gorilla Script and won’t have to start as a complete novice.
Tip: We have created Gorilla Script Syntax Highlighting files for the popular Sublime Text and Visual Studio Code editors. These files are included in the SDK > Tools > GorillaScript Syntax Highlighting folder along with installation instructions. We recommend you install them as they will make working with Gorills Script easier.
Gorilla Tester (VST/AU plugin)
Gorilla Tester is a VST or AU plugin that loads your .blob files and lets you preview your product in a real world context without having to compile the instrument.
If you have developed a user interface for your instrument, Gorilla Tester will display it just like a finished compiled plugin. If you haven’t developed the user interface yet, no problem, Gorilla Tester will auto-generate a basic user interface so that you can access its controls. This auto-generated interface will not win any design awards, but it will let you audition your sounds in a real-world context and make sure your plugin sounds great.
By default, Gorilla Tester loads an example instrument called “Piano Pad”, but you can configure it to load any other instrument by following the instructions in the Gorilla Tester User Guide.
About .blob files
Your exported .blob files, by themselves, have no user interface. They are simply a description of sound content of your instrument. The user interface of the instrument is developed separately using your graphical assets (like background images, “filmstrips” and so on) along with YAML and JavaScript code. We feel this split between sound content and user interface is very useful. It allows teams to work on the sound and visual aspects of an instrument separately, which can greatly speed up product development.
About .yaml and .js files
Gorilla Engine SDK uses a YAML formatted file to describe the visual layout of an instrument (i.e., size of the window, location of controls, colors, etc.) and JavaScript files to determine the application logic of the controls.
Gorilla Tester lets you iterate and fine-tune the YAML based visual layout of your instrument “on the fly”. This lets you move controls around and change many other things (product skins, colors, etc.) until they are pixel-perfect without without having to go through the time-consuming step of recompiling the instrument and then unloading/reloading the plugin from your DAW.
Gorilla Compiler
Installed in the “Applications” folder of your operating system.
This is the last stop for your instrument! The Gorilla Compiler accepts the .blob file, UI Layout (YAML), application logic (JavaScript) and other assets. It generates an installer containing the compiled plugin that you or your customers can load into their DAWs. Within Gorilla Compiler, you can enter a variety of details about your plugin such as the product’s name, manufacturer’s name, version, output formats (VST/AU/AAX) and many others. On top of that it can display your end user license agreemtn (EULA) and handle code signing, copy protection and installer signing given that you have the required certificates installed. To try it out, please load an example Gorilla Compiler project file (.ugep file extension) from the SDK > Examples > Gorilla Compiler folder.
Example Instruments
This folder contains example instruments showing what you can do with Gorilla Engine. These are basic instruments with simple user interfaces. They will give you an idea of the powerful things you can do with the Gorilla Engine SDK.
Open the .inst file for any of the example instruments in Gorilla Editor and have a look around. You can play the instrument with the on-screen keyboard (or an attached MIDI controller) and make adjustments to hear the results of your changes. If you are feeling adventurous, select one of the “Groups” and click the “+” button to add new function like a Filter, ADSR Envelope or Oscillator.
Some examples included in the SDK:
- Minimal: Literally the simplest thing we could devise—a volume knob! The idea here is to help beginners get comfortable with the Gorilla Editor.
- Basic Synth: A basic virtual analog synthesizer.
- Piano Pad: A basic sample-based instrument.
- UI Control Demo: This is a demonstration of all the most basic types of controls that you can use in Gorilla Engine. Like the other demos, the UI Control Demo is not intended to look pretty; it is designed to give you an idea of the options and how you can create and modify layouts on screen.
The each of these instruments contains a subfolder called ‘plugin_assets’ containing all of the files necessary to load this example in Gorilla Tester. Please refer to the Gorilla Tester User Guide to learn how to do this.
Next Steps
We hope this document has given you a good overview of Gorilla Engine. As a next step, we recommend taking a look at the Gorilla Editor User Guide and to learn more.