Reaktor is a visual programming environment dedicated to creating audio processors, tools and instruments.
It can run standalone or as a plugin, with practically no functional differences between the two modes. Many of Native Instruments’ synths, effects and sound expansions are built on Reaktor technology, and there’s also a free Reaktor Player that allows you to build virtual modular synths using Reaktor Blocks, and to load synths and effects created by NI and their development partners.
Brush up on your Reaktor basics before following the steps below to build your own very own synth.
Ensembles are the top level entity in Reaktor. They are the outer wrapper for all of the different modules and connections that comprise an effect or instrument, and an instance of Reaktor can host only one ensemble at a time.
There are a number of other wrapper modules available too, the most important being Instruments, Macros and Core Cells.
Instruments are very similar to Ensembles in that they create their own GUI panel, and define visual settings that affect any modules they contain (note that the word “Instrument” is used as in “tool” or “device”, and doesn’t imply Instrument modules are intended only for building synths).
Macros are essentially just a container for other modules, and display any visual elements they contain within their parent Instrument or Ensemble’s panel.
To explain Core Cells we need first to talk about Reaktor’s three editing levels: Blocks, Primary and Core. Blocks are fully self-contained Instruments that conform to NI’s Reaktor Blocks standard.
That standard ensures easy inter-compatibility with all other Blocks, and this allows you to quickly assemble any combination and signal flow that you like, much like working with a hardware modular system.
Reaktor’s Primary level contains all of the essential modules and tools you need to create practically any effect, processor or synth. Some Primary modules perform very basic tasks, such as applying mathematical operations to incoming values; others, such as oscillators, are more complex in their makeup and function.
Primary also includes a built-in library of pre-defined Macros, most of which include GUI elements and so provide another quick way to assemble effects and synths.
Core is where you get down to the nitty-gritty of things. Core modules can only be created inside of a Core Cell and allow a deeper level of control over proceedings, and complex DSP routines to be created.
After a Core Cell has been edited, Reaktor compiles the structure into efficient-to-run machine code. While Core editing looks similar to Primary editing, and Core contains many useful modules and its own library of pre-built Macros, it is in fact much more akin to writing program code due to the concepts it uses.
In order to make Reaktor’s modules do anything useful they need to be connected together in some way, which is why almost every module has at least one terminal on it.
Terminals on the left of a module are inputs, while those on the right of a module are outputs. Connecting the modules is simply a case of dragging between inputs and outputs to create signal paths.
At the Blocks and Primary levels, connector terminals can operate in one of two modes, audio or event, the latter being conceptually similar to control signals such as MIDI or CV/Gate.
This means the event terminals run at a lower data rate than do audio terminals, and so the two can generally not be interconnected without using a converter module in-between (there are some exceptions to this, but using them can weigh heavily on CPU usage).
The “Building In Primary” manual shows how to make a simple synth using the included library of pre-defined Macros. It’s a big help, but the library Macros don’t show how to structure such modules, nor define panel control elements like knobs. Let’s build one using only the more primitive Primary modules…
Step 1: Fire up Reaktor in standalone mode, create a new Ensemble, and adjust the split-screen layout to taste. We don’t need the Ensemble’s default In Port modules, so delete these. Undocking the Properties Manager can be useful whilst building in Reaktor, allowing you to keep the parameters you’re working on close to hand – you can do this from the program’s View menu.
Step 2: Click an empty area of the editor and hit [Enter] or [Return] to open the Searchbox. Type “MIDI” then in the results list locate and click on Note Pitch MIDI In. Repeat to add a Gate MIDI In. Take a moment to hold the mouse pointer over the new ports and their terminals to read the popup hint text.
Step 3: Let’s create a multi-mode oscillator for our synth. It makes sense to pack this into a Macro so that it’s self-contained. Right-click in the editor and select New Macro from the popup menu. Double click the new Macro’s name field and change it to “impleMultiOsc. Double-click the SimpleMultiOsc Macro to view its internal structure, which is empty.
Step 4: Our Macro needs to receive the pitch and gate events from the Ensemble, so it needs In Port modules. Right-click and select Built-In Modules > Terminal > In Port, then name the new port as “P” (ie pitch). Repeat this process in order to create an In Port module labelled “A” (ie amplitude), and a main Out Port for the oscillator’s audio.
Step 5: Add a Triangle Oscillator to the structure. Connect your In and Out ports to the matching terminals on the oscillator module. Double-click an empty area of the editor to back-out of the Macro and return to the Ensemble, then connect the Note Pitch and Gate ports to SimpleMultiOsc’s “P” and “A” ports (respectively), and its outputs to the Ensemble’s Out Ports.
Step 6: Play your oscillator, noticing that it’s monophonic. Click an empty area so that the Ensemble’s properties are shown in the Property Manager, and increase the Voices value to 8. The oscillator is now polyphonic, but the Ensemble’s main Out Ports are always monophonic. Fix this by inserting a pair of Audio Voice Combiners prior to the Out Ports.
Step 7: Reopen SimpleMultiOsc, create a Pulse and Sawtooth osc, and wire the Macro’s In Ports to them. Create a Switch module, name it Waveform, and set its Min Num of Ports to 3. Double-click terminals to rename them Tri, Pulse and Saw. Connect the Osc Outputs to corresponding Switch Inputs. Connect the Switch’s Output to the Macro’s Out Port.
Step 8: Hold your mouse over the Pulse oscillator’s W terminal and read the popup hint text, noting the value range it suggests. Create a Knob module, name it “Width” and enter the suggested values as the Knob’s Max and Min values. Set the Knob’s Default to 0 and Step Size to 0.01, then connect it to the Pulse oscillator’s W terminal.
Step 9: Hold your mouse over the Pulse oscillator’s W terminal and read the popup hint text, noting the value range it suggests. Create a Knob module, name it “Width” and enter the suggested values as the Knob’s Max and Min values. Set the Knob’s Default to 0 and Step Size to 0.01, then connect it to the Pulse oscillator’s W terminal.
Step 10: Notice that the maximum value of PitchEnv’s output depends on the value arriving at its G terminal. We’ll use the Macro’s A In Port to drive PitchEnv’s G input, but A is affected by playing velocity, and so the amount of pitch shift provided by the envelope will also be velocity-affected. So we need G to be either 0 or 1.
Step 11: A Compare module will do this for us – create one with the Searchbox. Connect the A In Port to the Compare’s upper Input, and a Constant module with value 0 to the lower Input. Now, when A is greater than 0, the Compare’s upper Output will have a value of 1, otherwise it will be 0. Connect this upper Output to PitchEnv’s G Input.
Step 12: Read the hint text for the envelope’s other Input terminals and create suitably-configured Knob modules for each. Layout the knobs in the GUI panel. PitchEnv’s Output is an audio signal, but we will be using it to manipulate event signals, so create an A to E (ie Audio to Event) module and connect it to the envelope’s Output.
Step 13: Create a new Knob and call it “EnvAmt”. The Knob’s Max value should be the maximum amount of pitch shift that you want the envelope to be able to apply, in semitones; the Min should be negative the same value. We’ve gone for two octaves, so have set Max at 24, Min at -24, and default at 0.
Step 14: Create a Multiply module and connect the A to E module and EnvAmt Knob to its inputs. This will scale EnvAmt’s value by PitchEnv’s value. Disconnect the P In Port from the oscillators, and then connect it to a new Add module. Connect the Multiply’s Output to the Add’s other input. Wire the Add’s output to the oscillators’ P Input terminals.
Step 15: The release phase is being lost because the oscillators are stopping as soon as the note is released. We can fix this by preventing A In Port values of 0 from being passed to the oscillators – this is a job for a Core Cell! Right-click in an empty area and select New Core Cell from the popup. Name the Core Cell “GateCntrl”.
Step 16: Double-click GateCntrl to enter it, and notice the slightly different appearance – the columns to the left and right are where you create In and Out ports (respectively), whilst the central area is where you add Core modules and macros. Create an In and Out port, name both “A”, and ensure their Signal Mode property is set to Event.
Step 17: Add a Compare (Flow) module. This compares two incoming values based on the module’s “Criterion” property, and outputs a value of True or False from the module’s BoolCtl (Boolean control) port, represented by a green arrow. Set Criterion to >, connect the A In port to Compare’s upper Input, and connect a Constant of value 0 to the lower Input.
Step 18: Create a Router (Flow) module. This will send the incoming signal to its top Output if its BoolCtl receives a True value, otherwise it will route the input to the lower Output. Connect the Cell’s In port to Router’s lower Input, and Compare’s BoolCtl Output to Router’s BoolCtl Input. Create a Merge (Flow) module and connect’s Router’s upper Output to its upper Input.
Step 19: We need to store incoming “A” values that are greater than 0 to use them when the note is released. Create a Write (Memory) module and connect Router’s upper Output to its upper Input. Create a Read (Memory) module and connect its lower OBC (Object Bus Connection) Input to Write’s OBC Output. This OBC connection ensures both modules access the same memory address.
Step 20: Read will send the stored value when a signal arrives at its upper Input, so connect this to Router’s lower Output – this means when A equals 0, Read will send its stored value. Connect Read’s Output to Merge’s lower Input, then connect Merge’s Output to the Cell’s Out port. Return to SimpleMultiOsc and insert GateCntrl between the A In Port and the oscillator’s A inputs.
Step 21: If you were to play the synth now the notes would carry on forever, so we need an amp envelope. Select and copy PitchEnv, all of its Knobs, the Compare module and its constant. Return to the Ensemble, create a new Macro named AmpEnv, open the Macro and then paste the structure. Create and connect a “G” In Port and audio Out Port.
Step 22: Back in the Ensemble, combine the SimpleMultiOsc Output with AmpEnv’s Output using a Multiply module, and feed the output of the Multiply to the Audio Voice Combiners. Play your synth and notice that envelope release stages are working, but that this synth needs a filter. Create a new Macro and name it “MultiModeFilter”, and place it near SimpleMultiOsc in the structure.
Step 23: Delete the connection between SimpleMultiOsc and the Multiply module. Hold down [Cmd] (Mac) or [Cntrl] (Windows), then drag from SimpleMultiOsc’s output to the left edge of MultiModeFilter – this is an easy way to create new ports in Macros. Repeat to link the Macro to the Multiply module’s Input. Open MultiModeFilter and move the auto-generated ports into convenient positions.
Step 24: Add a Multi 2-Pole Filter to the Macro and connect the Macro’s In Port to the Filter’s In terminal. Create a Knob for driving the filter’s P input, using a Min value of 16 and a Max of 140. Also create a Knob for driving the Res input, using the settings suggested in the port’s Hint text.
Step 25: The Filter module outputs High Pass, Band Pass and Low Pass filtered signals from a single module, so we need to control which is active. Create a Switch module, give it three input ports and name the ports “HP”, “BP” and “LP”. Connect the Filter’s outputs to the Switch, and the Switch’s Output to the Macro’s Out Port.
Step 26: Drop back to the Ensemble and save your synth. Have a play of your synth to see what sorts of sounds you can coax from it, and think about what more you could add. A filter envelope is definitely needed, and you should explore adding some LFO too. If you’ve been paying attention then you know what to do!