Table of contents

• Introduction
  • What you need to know
  • Supported Operating Systems
  • Installing Gorilla Editor
    • Special Requirement for building Rack Extensions:
  • Installing Custom Effects
  • MIDI and Audio Connections
  • Importing Scripts and Content from Other Samplers
• Gorilla Editor Overview
  • The User Interface
  • Showing/Hiding and Resizing Windows
  • Undo/Redo
  • Editing Parameters
  • Saving Your Instruments
  • Preferences Menu
• The Toolbar
• The Module Editor
  • An Overview
  • Working with Modules
  • Module Reference
• The Mapping Editor
• Let’s Build a Simple Instrument!
  • Creating a New Instrument
  • Load a Sample into your Instrument
  • Playing Your Instrument
  • Adding a Filter to Your Instrument
  • Adding a Filter Envelope with Velocity Sensitivitity
  • Adding an Effect
  • Preparing Your Instrument for Export
    • About the Export Blob Settings:
• Appendix A: Supported Files and Formats
  • Supported Files
  • Starting with a folder containing your audio files
  • REASON NN-XT Instrument (.SXT)
  • REX LOOPS (.RX2)
  • SFZ FORMAT (.SFZ)
  • LOGIC EXS-24 INSTRUMENT (.EXS)
  • NI Kontakt Instrument (.nki)
• Appendix B: Sample Importing and Mapping
  • All on one key:
  • Read from sample meta data:
  • Read form sample file names:

Introduction

Thanks for checking out Gorilla Editor!

Gorilla Editor is the heart of the Gorilla Engine Software Development Toolkit (SDK) and lets you author virtual instruments and sound processing plugins in various formats (VST, AU, AAX and Rack Extension).

With this tool, you can 1) create sound content, 2) define the signal flow of your product, and 3) specify the controls that are presented to your end users. While Gorilla Editor can be used to create any kind of plugin you like (sample-based instruments, oscillator-based synthesizers, audio effects, etc.) it includes powerful sampler functionality to assist in the creation of detailed sample-based instruments. This lets you import and work with audio samples just like in any other sampler, except that your finished sound set ends up in your very own instrument and not a software sampler created by a third party.

Gorilla Editor comes with dozens of powerful “modules” like oscillators, filters, LFOs and envelope generators, effects, and much more. You can freely arrange and interconnect these modules to create your desired instrument. If you need custom functionality that is not provided by one of the existing modules (for example, a specialized arpeggiator or key-switching mechanism), you can create it in the Gorilla Script scripting language and drag-and-drop it into Gorilla Editor. Doing so lets you add highly customized functionality to your products that will wow your customers.

This manual focuses only on the Gorilla Editor part of the Gorilla Engine SDK. After reading this document, you should be able to do things like import samples, arrange samples in groups and zones, set signal flows, define modulation and effects, and generally build up the sound of an instrument. However, subjects like compiling a VST/AU/AAX or Rack Extension, adding the graphical user interface (GUI) to an instrument or working with Gorilla Script are outside the scope of this guide and will be covered elsewhere in the Gorilla Engine SDK documentation.

What you need to know

We would like to give you a heads-up that this guide assumes you will have some familiarity with virtual instrument design and is not intended for total beginners just getting into software instrument building. Don’t worry, you won’t need to have deep programming skills, we do expect you to have some basic knowledge including the following:

• You are familiar with the basic concepts and functionality of samplers and synthesizers.

• You have created some sound content for hardware or software-based products (like Kontakt, Reaktor, EXS-24 or Reason’s NN-XT sampler).

Beyond these basics, it is tremendously helpful if you have scripted some custom functionality in another sampling engine. Again, don’t worry if you haven’t done this—it is not difficult to learn. However, please do plan to spend some time to learn our Gorilla Script language. Doing so will let you build customized and amazingly powerful instruments that do exactly what you desire.

Let’s get started!

Supported Operating Systems

Gorilla Editor comes with native Apple Silicon support and is currently available for macOS 10.14 (or later) and Windows 10 64bit (or later).

Installing Gorilla Editor

Gorilla Editor is installed along with the rest of the Gorilla Engine SDK. To install the SDK, download the appropriate package for your operating system from our website (note that there is an application process for being granted access to the Gorilla Engine SDK). Once downloaded, run the installer and and follow the on-screen instructions.

Special Requirement for building Rack Extensions:

The Gorilla Engine SDK contains everything needed to build VST/AU/AAX plugins out of the box. However, if you would like to build Rack Extensions for use in Reason software, you will also need the Jukebox SDK 2.5 (or later) from Reason Studios. Note that instruments created with the Gorilla Engine and Jukebox SDKs can only be used in Reason 8 / Reason Essentials 2.1 or later.

Installing Custom Effects

In order to use custom effects (such as the Overdrive effect provided for compatibility with older Rack Extension projects) just place your .dylib (macOS) or .dll (Windows) file in the following folder:

macOS:

• /Users//Library/Application Support/UJAM/Gorilla Editor/PlugIns

Windows:

• C:\Users\\AppData\Local\UJAM\Gorilla Editor\PlugIns

Once a module is installed, it can be accessed by clicking the relevant parent module in the Module Tree and clicking the “+” icon. Refer to The Module Editor section to learn about how to work with modules.

MIDI and Audio Connections

Gorilla Editor automatically uses all available MIDI inputs and your computer’s default audio outputs. This means any connected MIDI controller can be used to play instruments while you are working and you can hear the results on your default audio outputs. If you don’t wish to use these settings, go to the Gorilla Editor > Preferences and set the inputs and outputs as desired.

Importing Scripts and Content from Other Samplers

The Gorilla Engine SDK ships with lots of GorillaScript examples to illustrate how things work and give you an idea of what you can achieve. The script examples can be found under Gorilla Engine > SDK > Examples > Script Examples and we recommend you spend some time to explore these.

To use a script, the process is generally to drag-and-drop the script into Gorilla Editor (note that in some cases, the script files have their own required .inst files with certain settings applied). Scripts will appear under Instrument (at the top-left of the Module Editor) and parameters created using GorillaScript will be found inside each script’s module. Please refer to The Module Editor to learn more about working with modules.

You can open and edit GorillaScript files using virtually any text editing software but we recommend using a code editor for the best experience. We have developed Gorilla Script Syntax Highlighting for the popular Visual Studio Code and Sublime code editors so that Gorilla Script is colorized and displayed properly on-screen. You can find these syntax files and installation instructions under Gorilla Engine > SDK > Tools > GorillaScript Syntax Highlighting

Tip: While GorillaScript is the most powerful and comprehensive scripting option when working with Gorilla Editor, the Gorilla Engine SDK can (with certain limitations) import content and scripts from other samplers. This makes it easier for you to create Gorilla Engine-based instruments from products you may have already built using other samplers. Please see Appendix A: Supported Import Formats to learn more about this.

Gorilla Editor Overview

The User Interface

The image above shows Gorilla Editor when it is first launched. Its user interface breaks down neatly into three rows:

• Along the top of the screen is the Toolbar. Here you have easy access to commonly used controls and displays like the master volume slider and audio/CPU meters, show/hide buttons and more.
• The middle section is called the Module Editor. Modules are the building blocks of Gorilla Engine-based Instruments and here you can create, arrange and configure them to suit your needs.
• The lower section is the Mapping Editor. Here you can do things like set the mapping of samples, create zones and edit zone parameters.

Showing/Hiding and Resizing Windows

Gorilla Editor is designed to be flexible and to adapt to your needs as you work.

• The application can be resized vertically or horizontally by dragging the edges.

• The Module and Mapping editors and their sidebar sections can also be resized by dragging the vertical or horizontal dividing lines between the sections.

• Buttons at the right side of the Toolbar can be used to show and hide various parts of the user interface.

These features are useful as you work through the sound design process. For example, if you are done defining the key mapping of an instrument and no longer need to see the Mapping Editor, you can choose to hide that section and use the entire interface to view the Module Editor instead. The reverse of this is also true—the entire screen can be used to view the Mapping Editor while the Module Editor is hidden.

Undo/Redo

Gorilla Editor supports unlimited undo/redo actions. This can be done with the Edit > Undo, Edit > Redo commands or via standard keyboard shortcuts:

Editing Parameters

To change on-screen parameters in Gorilla Editor:

• Most parameters can be edited by either click-dragging or by double-clicking and typing in a specific value.
• Musical notes can be entered by note name (“C3”) or by MIDI note number (“60”).
• Value displays can be adjusted by dragging up and down.
• Sliders can be dragged left or right. While dragging, you can move the cursor down and further away from the slider for finer adjustment.
• Parameters can be reset to Gorilla Editor’s default value by holding CTRL (Windows) or CMD (Mac) when clicking the parameter.

Saving Your Instruments

Selecting File > Save or pressing Cmd/Ctrl+S saves your instrument under its current filename and location. Selecting File > Save As… or pressing Cmd/Ctrl+Shift+S brings up a prompt letting you set the filename and location of your instrument.

Preferences Menu

Selecting Gorilla Edior > Preferences… brings you to the Preferences menu.

Here you can set various global parameters: General

• Script Editor: Gorilla Editor can be configured to open your scripts in whatever code editor you prefer using. Click Choose Editor to select which application you would like to use. Checking the Automatically Reload Scripts checkbox lets Gorilla Editor automatically reload a script any time it is saved in your text editor. This saves you from having to manually re-load an edited script in Gorilla Editor.

  Using GorillaScript’s Syntax Code Highlighting: We have developed syntax code highlighting files for the popular Visual Studio Code and Sublime editors. If you use one of these editors, we recommend that you install our package as it will colorize your code. More information about this can be found here.

• MIDI Input Devices: This drop-down menu lets you select which device you would like to use to control Gorilla Editor. Unchecking the Use MIDI to set zone parameters checkbox disables the ability to set root, velocity and key ranges with your MIDI controller. By default, this box is checked because it is a convenient way of setting zones, however, some users may prefer to switch this off to prevent unintended changes when adjusting parameters in the Parameter Editor.
• Autosave Instrument: The Autosave system periodically backs up your work. To use the system, make sure the check box is active. You can set how frequently the system backs up your work using the Intervals (in minutes) and the Amout of Backups sets the number of earlier copies that are retained.
• Automatically reload midi file modules: This lets Gorilla Editor automatically reload imported midi files when they are saved using an external editor.

Audio Output

• Audio Output Devices: These menus let you select your audio Output Host (Windows only), Output Device and Output Channels (if the device has multiple sets of outputs). This list gets updated when launching Gorilla Editor and after clicking the Rescan button.
• Sample Rate: Sets the sample rate of your audio interface.
• Latency: Sets the buffer size of your audio interface. Lower settings result in lower latency but increased demands placed on your CPU.
• RAM Usage: Here you can set how much of your samples are pre-loaded in memory for disk streaming. Setting longer times here may result in smoother playback, particularly on spinning disk systems. However, doing so will place increased memory demands on your system, since more of each sample will need to be loaded into memory. The default setting is to load the first 0.50 seconds of each sample into memory.
• Rescan: This updates the list of connected audio output devices. In case you connected an audio interface while the Gorilla Editor was already running, you need to rescan for the device to be available. If on startup Gorilla Editor could not find the previously set audio device, the device will automatically be set if found after clicking this button.

The Toolbar

The Gorilla Editor Toolbar includes a number of useful controls:

1. Reset Audio Engine - This button resets the Gorilla Editor audio engine. This is similar to the MIDI Panic button found on many hardware and software synthesizers.
2. Tempo - This area displays the tempo of the instrument or plugin. It is used as the time reference for tempo-synced plugins and can be set by click-dragging or double-clicking and entering a value directly.
3. Transport Controls - This area shows the transport controls of the plugin or instrument. It is similar to the controls found in your music software and provides a reference for your instrument’s tempo-based modules (sequencers, arpeggiators, etc.) The display shows bars:beats. The play button starts the sequencer and stops and rewinds when pressed again. The Pause button stops the active sequencer and rewinds it to the zero position.
4. CPU and Audio Level Meters - These meters display the CPU and audio levels. The top (green) meter shows audio output level whereas the bottom (blue) meter displays CPU load.
5. Volume Controls - This section sets the output level of Gorilla Editor. The slider sets the output level from low (left) to max (right) and clicking on the speaker icon mutes the output of Gorilla Editor. The slider is dimmed and un-moveable when the mute is engaged.
6. Show/Hide Sidebar - This button shows and hides the sidebar on the left.
7. Horizontal Split controls - These buttons work together. The right button splits the module editing area of the screen letting you view two modules at the same time. The right button removes the split and returns Gorilla Editor to single-module view.
8. Show/Hide Mapping and Module Editor - These three buttons let you (from left to right), show the Mapping Editor only, show the Module Editor only and to show both the Mapping and Module editors at the same time.

Pro Tip: The show/hide controls can be very useful on smaller computer monitors with a limited display area. They can also be useful when you would like to focus your full attention on a specific task (such as arranging modules or setting key zones) without being distracted by anything else on screen.

The Module Editor

Gorilla Editor instruments are built using building blocks called “Modules.” Modules let you add functionality and control features to your instrument. They include things like filters, envelopes, effects, groups and more.

An Overview

1. The sidebar (or “Module Tree”) on the left is where you create and organize modules. Select a module by clicking on it or rearrange your modules by dragging them. Selected modules are highlighted and clicking the triangles can show/hide sub-modules. Note that you can also use the arrow keys to navigate the tree.
2. This “Module Details” area is where you define the parameters of the currently selected module. You can also define how modules are connected to each other (i.e. modulation routings) and the strength of those connections (modulation depths).
3. This section lets you create new modules (using the “+” button) and also show/hide different categories of modules. Complex instruments can have dozens of modules and the ability to show or hide categories of modules can tremendously helpful in maintaining organization and clarity.

Note: The “+” button is context senstive and reveals different options depending on what is selected below. For example, if a Group is selected, you will see group-related parameters (like ADSR envelopes, filters, etc.); if a Bus is selected, you will see various bus effects (chorus, reverb, etc)

Working with Modules

Gorilla Engine-based instruments always have the “Instrument” and “Instrument Voices” modules (these modules are automatically generated when creating a new instrument and cannot be deleted). You can see these in the Sidebar of each instrument you create. Beyond these required modules, it is up to you to add any other modules you need to build your instrument or effect.

The following rules and concepts apply to modules:

• The top entry in the Module Tree is always the Instrument module.This is a required module for all plugins and is always found at the top of the Module Tree.
• Modules are added by right-clicking in the sidebar and selecting the module to insert from the context menu. You can also click “+” button at the top-right of the sidebar.
• Modules can be deleted by pressing the [Delete] key or by right-clicking on the module and selecting “Delete”.
• You can use the Cut, Copy, and Paste commands when working with modules. This can be done through the Edit context menu or via the standard shortcut keys shown below. The Instrument and Instrument Voices modules are the only exceptions to this.

• You can reorder modules of the same category by dragging them.
• Similar categories of modules are grouped together. Therefore, if you are creating or moving a different module on top of a group of similar modules, your new module will be placed after the other modules of the same type.
• If you try to drop or paste a module in an invalid location (for example, an effect anywhere other than an effect bus), it will not be inserted.
• GorillaScript (in .txt format) can be added via drag and drop and become script modules inside Gorilla Editor.
• MIDI and CSV files can also be dragged and dropped into Gorilla Editor. They are added to the Module Tree.
• Modules can be cut/copied/pasted between different instances of Gorilla Editor. To do this, make sure that you select the right parent module before pasting, otherwise the module will not be added. In other words, Groups can only be added if the Instrument module is selected (the only place where Groups can be created); you will not be able to paste a Group if a different module is selected.
• Top open a new instance of Gorilla Editor, select Window > Open New Window.

Module Reference

For a complete description of all available modules and their parameters, please refer to the “Gorilla Module Reference” in the Gorilla Engine SDK.

The Mapping Editor

The Mapping Editor is where you create zones to position samples (or oscillators) across the keyboard, and to edit zone parameters.

1. The sidebar on the left shows all groups, mappings, and zones. It allows for sorting by key, name, velocity, or sample length. Alt/⌥-click a zone to audition the sample. Ctrl/⌘+click can be used select multiple elements in the sidebar. Shift/⇧+click creates a selection of all elements between the first and last selected elements.

2. The central part of the Mapping Editor panel (called the “Mapping Editor View”) shows how your zones are mapped. The vertical axis represents velocity ranges while the horizontal axis represents key ranges. Click on a zone to select it. Move a zone by click-dragging its center and resize a zone by dragging its edges.

3. The vertical and horizontal zoom sliders to the top right allow you to zoom in or out on the Mapping Editor View. The squarish icon resets the vertical and horizontal zoom and fits the Mapping Editor view back default.

4. An on-screen keyboard is available at the bottom of the Mapping Editor View. This can be used to play the instrument if no MIDI keyboard is available. To play the instrument using the on-screen keyboard, simply click and hold on a key. The keyboard also provides a simulation of velocity: Clicking lower on the notes will play at higher velocity and vice-versa.

5. All of the parameters for the currently selected zone are displayed here.

6. “Auto map selected zones” lets you choose to either sort the currently selected zones based on meta data that is burned into you samples or analyze and map your samples based on our level and pitch detection.

7. This field displays the file path of the currently selected zone.

   Tip: Certain fields such as root note and key range can be derived from a sample’s filename by selecting the field for editing then Alt/Option-clicking a numeric value or note number in the sample filename displayed at the top of the mapping editor.

Let’s Build a Simple Instrument!

The quickest and best way to learn about Gorilla Editor is to jump in and build a simple instrument from scratch.

Creating a New Instrument

1. If you haven’t done so already, launch Gorilla Editor.
2. Create a new instrument by selecting File > New.
3. Click “New Folder” and create a new folder called “Simple Pad” on your desktop.
4. Click on the Simple Pad folder to make sure you’re working inside that folder.
5. Enter a name for the instrument file. Let’s call it “Simple Pad” and click “Save”.

At this point, we have created a Gorilla Engine-based instrument file called “Simple Pad.inst” and placed that file in the “Simple Pad” folder that you created in step 3.

Pro Tip: When building sample-based instruments the following folder structure will help to keep things organized. This structure also ensure that all files related to the project are saved with a path relative to the project folder.

• Content
  • Instruments
    • SUBFOLDER
      • PLACEHOLDER.inst
  • Samples
    • SUBFOLDER
      • PLACEHOLDER.wav
  • Impulses
    • PLACEHOLDER.wav

Load a Sample into your Instrument

For our instrument, we’re going to use a sample called “pad.wav” found in the Gorilla Engine SDK > Examples > Piano Pad > Instrument > Samples.

• Copy “pad.wav” into the Samples subfolder that you just created.
• First click the Instrument icon to select it and name it by typing “My New Pad” in the Name field.

• Now Click the “+” icon in the Module Editor and select “Standard Group”. A new Standard Group module will be created called “Group 0”.

• From Windows Explorer / macOS Finder, drag and drop the “pad.wav” sample onto “Group 0” in the Mapping Editor.
• The Import Samples prompt appears on screen. This prompt is very helpful when bringing in large groups of samples because it helps you sort and place samples automatically. This is covered in Appendix B: Sample Importing and Mapping. For this example, let’s select “Key”

• The pad.wav is added to Standard Group “Group 0”.
• Click the “pad.wav” sample in the Mapping Tree to ensure it is selected, as shown below.

• Adjust the key range of the “pad.wav” zone so that it spans the whole keyboard: C2 (0) to G8 (127). You can do this by click-dragging the second key range parameter in the right sidebar of the Mapping Editor. Alternatively, you can click-drag the right edge of the green zone window all the way to the right edge of the on-screen keyboard. The “pad.wav” zone will now spread across the whole range of the Mapping Editor.

Pro Tip: If the “Use MIDI to set zone parameters” box is checked in the Preferences Menu, you can use your MIDI controller to conveniently set Key ranges, Velocity ranges and Root note. To do this, simply click on the parameter you would like to edit and tap a key on your MIDI controller to set its value.

• Finally, switch Loop to “On” so the pad sample will be looped.

Pro Tip: Once you’ve roughly set up your zones, you can fill empty spaces or resolve overlapping zones. Do so by selecting multiple zones, using right-click and either choosing the Fill empty space… or Resolve overlapping zones… option. This is a major time save compared to manually adjust each zone. Depending on your initial zone layout, you might have to do some manual touchups to finish things up.

Playing Your Instrument

If you have followed the steps in the previous sections, Gorilla Editor should look like the image below. If so, congratulations—you’ve built your first (very basic) Gorilla Engine-based instrument!

Take a moment to play your new instrument. You can do so using the on-screen keyboard or via a MIDI controller, if you have one connected and configured for use with Gorilla Engine.

Adding a Filter to Your Instrument

Let’s build on our basic instrument from the previous section by adding a filter to it.

1. Right-click “Group 0” and select “LP24 Filter”. This adds a 24dB / Octave Low Pass filter to Group 0.
2. Click “LP24” to ensure it is selected. To hear the effect of the filter on your sound, you can adjust the parameters with your mouse while playing the instrument.
3. Right-click “LP24” and select “Mod Routing” to add modulation routing to this filter. This lets you route a modulation source to control the filter.
4. Your screen should now look like the one below. Notice that an “Amp Env > Cutoff” module has been added below “LP24” when you created the Mod Routing in the previous step.
5. Click “Amp Env > Cutoff” to ensure that it is selected.
6. Try adjusting some parameters while you play your instrument. You can select the “Source” of the modulation (i.e. what is causing the change in sound), the “Depth” of the effect (how much effect is the source having on the filter), and the “Destination” of the modulation (what part of the filter is the source affecting?)

Summary: We have added a filter to the Simple Pad instrument and have created some modulation routings to control that filter. The process for adding other modules and modulation routes is the same as what we have done here for the filter, so you can work with other modules in the same way.

Adding a Filter Envelope with Velocity Sensitivitity

Let’s dig a little deeper into the Gorilla Editor and add an ADSR envelope to our LP24 Filter. Doing so will give us more control over the filter over time.

1. Right-click the “Group 0” and select “ADSR Env”.
2. Double-click new “Mod Src 2– ADSR Env” and rename it to “Filter Envelope”. Pro Tip: Complex instruments can often have many modules with very similar sounding default names. This can become confusing, so we recommend getting in the habit of renaming modules with descriptive names that work for your specific needs. Doing so will make your sound design and editing process much more harmonious!
3. Right-click “ModSrc 2 – Filter Env” and select “Mod Routing”.
4. In the newly created Filter Envelope mod routing, set the Source to “Velocity”
5. Set Curve Active to “On” and select “Concave” from the list of preset curves.

> Pro Tip: There are three shortcuts that can make working with curves easier.

To edit a single step: Click a step to select it and hold alt/⌥ while clicking or dragging anywhere in the curve display. Only your selected step will be modified regardless of your mouse cursor’s position.

To draw a straight (horizontal) line: Click a step to select it and hold ctrl/cmd key while click-dragging the mouse left & right. This will draw a straight line at the level of the selected step.

To draw a stright line connecting two points: Click and hold a step to select it. While keeping the mouse clicked, press and hold Alt/⌥ + Ctrl/cmd. While moving the mouse to another location on the curve display. Release the Alt/⌥ key to connect your original position to where the mouse is currently located.

1. Click the LP24 Filter’s “Amp Env > Cutoff” to select it and Set Source to “Filter Envelope”
2. Play the instrument and try adjusting some parameters (such as “Depth”) so you can hear the effect of the ADSR envelope on your filter and your overall sound.

Summary: We have created an ADSR Envelope for our instrument, renamed it to make its purpose clear, and connected that envelope to the Filter’s cutoff. We’ve also enabled a “curve” for velocity modulation of the filter envelope intensity for even more control over the modulation.

Adding an Effect

Now let’s route the Group output to an effect.

1. Click the “+” icon (or right-click the instrument module) and select “Effect Bus”. This will create the Effect Bus where the delay effect will be placed.
2. Right-click “Bus 1” and select “Delay”. This will insert the delay effect but you won’t hear it until sound is routed to it.
3. Now click the “Group 0” module and set its Output setting to “FX Bus 1”. This will let you hear the delay since the sound is routed through the delay on FX Bus 1.

Pro Tip: Effect bus outputs can also be routed to another effect bus to build up complete chains of effects. When doing this, it is best to route to a later bus and avoid routing to earlier busses as doing so will add latency. Adventurous users wishing to go even further can always place a “send” in a bus as well.

Summary: We have created an Effect Bus and inserted a Delay Effect into that bus. However, we don’t hear the effect of that delay until we route the output of Group 0 to the bus where the effect is located. You can insert more effect busses, and each group can output to any bus.

Preparing Your Instrument for Export

When you are happy with your instrument, the next step is to export it from Gorilla Editor so that it can be used as the basis of a VST/AU/AAX or Rack Extension instrument.

1. Click Instrument module in the module tree to select it.

2. Under “Blob Path” enter “Output/Blob”

   About BLOB files: The output of Gorilla Editor is a Binary Large OBject (or “.blob”) file. It containing all the instrument settings, samples, scripts and other data that describe the sonic elements of your instrument, but not its graphical user interface. By entering “Output/Blob” in the Blob Path, you are instructing Gorilla Editor to place your instrument’s .blob file in an “output > blob” subfolder of your instrument.

3. Select File > Export Blob
4. Click OK to export your instrument.
5. Please refer to the Gorilla Tester and Gorilla Compiler documentation to learn about the next steps in building an instrument.

Note: If you have created an instrument script, please make sure that all parameters have a proper initial (default) value defined in the script. This will ensure the sound matches the parameter settings when your plugin is loaded by a user. To do this, select script in module tree, and select in the menu bar “Script > Set All Parameters to Default Value”.

About the Export Blob Settings:

• Default Format: Use this setting when creating VST, AU, or AAX instruments.
  • Separate Headers: Splits the blob into two files. The first file contains metadata, instrument(s) and the attacks of each sample. The second file contains the rest of the samples. This can be useful if you have large amounts of sample data and want to implement content encryption. Encrypting only the first (much smaller) file is usually sufficient as samples without attacks are virtually useless. This setting is enabled by default.
  • Only rewrite Part1: Allows to separately rewrite _part1.blob. Saves time by not exporting the entire sample content when a blob export is required due to e.g., script changes. Assumes that the sample content did not change since the previous export. Off by default.
  • Include Preload: Include the start of each sample in the separate header file. Select this option if you also want to encrypt a portion of the sample data. The length of audio included depends on the Preload setting in the editor preferences.
  • Compressed (Lossless): Enables a proprietary compression algorithm that saves about 50% of the size depending on sample material.
• Reduce bit depth to…:
  • Optionally reduce the resolution of all exported sample data to a maximum of 16 or 24 bits. This can be used to reduce the size of the exported blob, but can raise the noise floor of samples (which can be particularly audible if heavy compression or distortion is applied). The original sample files on disk are not affected. Using 32 bit if not enabled.
• Maximum sample rate…:
  • Optionally reduce the sample rate of all exported sample data exceeding the specified maximum rate (24000Hz, 32000Hz, 44100Hz, 48000Hz). Note that resampling audio can affect the sound of sample startpoints and loops and can result in slight detuning compared to the original sample. Do not use this option if multiple samples should stay exactly phase-coherent with each other but have different lengths or loop points. The original sample files on disk are not affected.
• Trim unused sample data:
  • Sample data after the end or loop point which can never be played will not be included in the exported. Do not use this option if your instrument adjusts the Zone settings related to which parts of a sample gets played while it is running. The original sample files on disk are not affected.
• Legacy Format (RE): Use this setting when creating Rack Extension instruments
  • Compressed: Compression algorithm specific to Rack Extension format (only un-looped 16-bit samples are compressed).
  • Split Mappings: Use this option when creating a Rack Extension that loads and unloads individual mappings to save RAM. The samples for each mapping are then saved in separate files.

Missing Files Notification: A missing file notification appears if you try to export a .blob file with missing samples. Click the red text to see which files are missing. Note that missing samples are displayed in red in the mapping editor and these missing samples can be located via the File > Locate Missing Samples option. This feature does not restore samples that are missing from a Convolution or Sample Player effect.

Appendix A: Supported Files and Formats

Supported Files

• Only uncompressed .WAV, .AIF, .AIFF and .CAF files are supported.
• Files with any sample rate and number of channels can be loaded, but only the first 8 channels are played.
• Files can be 16-bit, 24-bit or 32-bit floating point.
• Note that 32-bit integer files are not suppoted.

Starting with a folder containing your audio files

This is the method most people use when they have recorded their own samples or are converting from another sampler and want to re-build the instrument “from scratch”.

When importing folders containing audio files, Gorilla Editor will create a new Group for each folder. The following “Sample Attributes” (as defined in the editing software WaveLab) are imported from the audio files if they are present:

• Root Key
• Tune
• Key Range
• Velocity Range
• Loop Start
• Loop End
• Slice and tempo information from Apple and ACID loop files
• Gain

It is also possible to set root note, key range, etc. for one or more selected zones from values in the sample filename. See the Mapping Editor section of this document to learn how to do this.

REASON NN-XT Instrument (.SXT)

NN-XT instruments can be converted into a Rack Extension by importing the patch into Gorilla Editor and turning it into a virtual instrument.

With this method, samples are loaded if they are found in the correct location relative to the .sxt file and the following parameters are imported:

• Groups
• Root Key
• Key Range
• Velocity Range
• Tune
• Sample Start
• Sample End
• Loop Start
• Loop End

Note: The audio files used in your NN-XT insturment must be individual files on disk. The audio files can not be packed inside a ReFill.

REX LOOPS (.RX2)

Dragging a REX loop to the Gorilla Editor window creates a Group containing the REX loop, with one slice mapped to each key. A REX loop can also be dropped on an existing instrument to create a new Group containing the slices. Note that a .wav file is created for each slice, but these are only used internally by the Gorilla Editor.

Note: When using this method, only the slices are imported and the loop does not play automatically. If you require loop playback (or any other kind of more sophisticated functionality), it can be achieved with scripting.

SFZ FORMAT (.SFZ)

Gorilla Editor supports this text-based format for defining musical instruments from a bare set of sound recordings. Samples are loaded if they are found in the correct location relative to the .sfz file. The following parameters are imported:

• group
• region
• sample
• key
• lokey
• hikey
• lovel
• hivel
• tune
• pitch_keycenter
• offset (sample startpoint)
• end (sample endpoint)
• loop_start
• loop_end

LOGIC EXS-24 INSTRUMENT (.EXS)

Gorilla Editor reads the layers and samples from EXS-24 instrument. The following parameters are imported:

Note: It’s best to save the .exs file somewhere relative to the samples (e.g. in the folder above Samples, or a parallel instruments folder) so it can find the samples without making a long relative path.

NI Kontakt Instrument (.nki)

Kontakt by Native Instruments is one of the industry standards for sample development. As a result, many sound content developers may choose to convert their existing Kontakt-mapped instruments into Gorilla Engine based instruments.

For the latest information on how to do so, please refer to the Kontakt Instruments Conversion Guide.

Appendix B: Sample Importing and Mapping

Gorilla Editor has powerful sample import features that help speed up the importing and mapping of samples. The screen above appears when importing individual samples or folders containing lots of samples. The options are as follows:

##1 per key:

Dropping samples into the Zone Editor…

Starting at the position in the zone editor at which the drop occurs, the samples get added to the currently selected group or mapping and consecutively mapped to each key and across the entire velocity range. If no mapping/group is selected, a new mapping will be created. If the amount of samples exceeds the key range, the excess samples will be mapped from C-2 and onward.

Dropping samples outside the Zone Editor:

When dropping samples outside the zone editor (e.g “Mapping Tree”, “Module Details Section”), a new mapping will be created and C-2 will be the starting point from which the samples will be consecutively mapped to each key, across the entire velocity range. If you drop samples into a specific group or mapping in the “Mapping Tree” your samples will be added there.

##1 per velocity:

Dropping samples into the Zone Editor:

Starting at the velocity step in the zone editor at which the drop occurs, the samples get added to the currently selected group or mapping and consecutively mapped to each single velocity step. If the amount of samples exceeds the velocity range, the excess samples will be mapped to velocity step 1 and of the following note. Each sample will be mapped across the entire key range.

Dropping samples outside the Zone Editor:

When dropping samples outside the zone editor (e.g “Mapping Tree”, “Module Details Section”) a new mapping will be created and velocity step 1 will be the starting-point from which the samples will get mapped to each single velocity step. Each sample will be mapped across the entire key range. If your samples are dropped into a specific group or mapping in the “Mapping Tree” your samples will be added there.

All on one key:

Dropping samples into the Zone Editor:

Starting at the key in the zone editor at which the drop occurs, all samples get stacked across the velocity range of the same key and added to the currently selected group or mapping. Each sample will cover a single velocity step. If the amount of samples exceeds the velocity range, the excess samples will start out with being mapped to velocity step 1 and onward.

Dropping samples outside the Zone Editor:

When dropping samples outside the zone editor (e.g “Mapping Tree”, “Module Details Section”) a new mapping will be created and all samples get stacked across the velocity range of the C-2 key. If the amount of samples exceeds the velocity range, the remaining samples will start out with being mapped to velocity step 1 and onward. In case you dropped your samples into a specific group or mapping in the “Mapping Tree” your samples will be added there.

Read from sample meta data:

Dropping samples into the Zone Editor:

If your samples include meta data/sample attributes you can use all or a selection of them to automatically map your samples across the currently selected group or mapping. The following parameters are supported:

• Root
• Key Range
• Velocity Range
• Tuning
• Start & End points
• Loop points
• Slices
• Gain

Dropping samples outside the Zone Editor:

When selecting this option after dropping samples outside the Zone Editor (e.g “Mapping Tree”, “Module Details Section”) your sample will be added to a new mapping. In case you dropped your samples into a specific group or mapping in the “Mapping Tree” your samples will be added there.

Read form sample file names:

Filenames can include tokens separated by an underscore (_), minus (−) or space (␣) to speed-up the mapping process. In the top right you can select which separator to use. Tokens can be assigned to the following parameters:

• Group
• Mapping
• Round Robin
• Root Key
• Low Key
• High Key
• Low Velocity
• High Velocity

Naming Examples:

• sample1_low_D-2_C-2_E-2_1_32.wav
• sample55 medium 1 A#-2 A-2 B-2 33 63.aif
• pad_C#2-D2_100-127.wav

All imported samples that follow the syntax you set up in the sample import dialog, will get mapped accordingly.

If a single token contains both values for low velocity & high velocity or low key & high key (100-127), apply the same token in both files of the import dialog. The value on the left will be applied to low and the value on the right to high.

Once the sample import is done, you will have the option to view a log listing samples that failed to import. That’s if any failed at all.

Note on default behaviors:

• Group and Mapping can not be set simultaneously when importing samples.
• When dropping samples outside the Zone Editor (e.g “Mapping Tree”, “Module Details Section”) a new mapping will be created.
• When not assigned any tokens, all samples will get mapped across the entire key and velocity range.

---