Reaktor 101: Getting Started

Reaktor is an incredibly powerful digital semi-modular by Native Instruments. A lot of producers might have it as part of the Komplete bundle, but few I’ve spoken to have even scratched the surface of its potential.

Admittedly the interface can be a little overwhelming: although I purchased it as a standalone many years ago, it wasn’t until after a few years that I really began to become acquainted with it and a few years more before I began to be happy with what I was building.

One of Reaktor’s strengths is that the synths, drum machines, effects and sequencers it comes bundled with are incredibly powerful, esoteric creations – even blindly noodling with them can produce some really quite quirky results – but this is really just the tip of the iceberg of what the synths can do.

As I mentioned before, Reaktor is a digital semi-modular – but what does this mean? Modular means that the individual components that make up the synths/drum machines/effects/sequencers in Reaktor can be hooked up however you like. Well, sort of: there are some restrictions and this is why it’s really a semi-modular.

One of the beauties of Reaktor is that everything is editable and can be customised and tweaked to an extremely high degree but before getting on to anything this complex, it’s worth getting your head around the basics. I’m going to show you how you can put together a simple one-voice mono synth and hopefully inspire you develop it further and learn about the architecture of some of the more exotic things in Reaktor.

I’m going to assume that if you’ve read this far you’ve probably opened Reaktor up once or twice and at least dicked around with some of the factory content. If you’ve not, it’s certainly worth exploring what it has to offer: Lazerbass, Carbon2 and OkiComputer are some of my favourite synths while SpaceDrone, Vectory, Space Master 2 and Fast FX are all worth exploring, too. What’s great is that loads of other Reaktor users have built their own machines and uploaded them to NI’s website for free download, so check them out too.

Before Starting

There are some things worth knowing before you actually get into building anything in Reaktor, as the interface can be slightly jarring. Reaktor is almost like a DAW within a DAW, so it has its own File, Edit, Settings etc.

Reaktor can be run within a DAW, like Ableton or Logic, or in standalone. For simplicity, today I’m going to be running it in standalone. Anything you do in standalone can be opened when Reaktor is a run as an Audio Unit or VST, so don’t worry about losing your work.

One huge advantage of running in standalone is that all the hot keys work in Reaktor rather than applying to the DAW you’re in. This certainly speeds works-flow up when you’re designing/building synths and effects. They can be properly road-tested in a DAW  later down the line.

Reaktor standalone can be found (like other Native Instruments standalone devices) in Applications > Native Instruments (for OSX; sadly I don’t have a PC to find out exactly where it is but I’m sure it’ll be in Program Files or something). When you open the program up, you’ll be confronted with something like this:

The left column is where we’ll start. The magnifying glass is the browser, navigating your hard drive and the factory content. The camera is for browser ‘snapshots’, which is Reaktor-speak for presets. Finally the box with sliders is the panel control.

The hierarchy of Reaktor starts at the top level with what’s called ensembles. An ensemble can contain Instruments; Instruments can contain a combination of Macros, modules and core cells (we’ll come on to Macros in more detail a bit later on and core cells will be covered with in a later article). Confusingly, ensembles can contain other ensembles too, but we won’t be getting that deep this time around.

Modules are the smallest thing in Reaktor and might be something like a triangle wave oscillator, an ADSR envelope generator, a number, a slider or even a mathematical function like subtract, divide or multiply.

The first thing we’ll need to do is create a new ensemble, so either hit cmd + n (on a mac) or File > New Ensemble. What we can see in front of us is an empty Instrument because creating a new ensemble creates a blank Instrument within it automatically.

Let’s have a look at the top panel first as there are some important things to note here:

From left to right we have several icons: the magnifying glass shows/hides our side pane we detailed earlier; next to that is an internal drop-down menu which we don’t need for now. The flow chart icon shows/hides our edit mode, and we’ll need this enabled for the next steps.

Next, we have the snapshot name, tempo and some basic transport functions. Moving on we have a rudimentary waveform icon (brings up the sample map editor), a tape player icon (enables Reaktor’s file player/recorder, which is useful when creating effects) and finally an ‘i’ icon, which shows info/hints when you hover over modules. Enable this!

Finally we have input and output meters and a CPU monitor for Reaktor that are worth keeping an eye on.

If we’re going to start building our Instrument we’ll want to be able to see the front panel as well as the internals. For this reason I like working in horizontal split view, which can be accessed by pressing Fn + F2 on mac, but it can also be accessed here:

Once it’s enabled, you should see this:

Of course, you don’t have to work in this view, but I’ve found it’s by far the easiest way to keep tabs on what’s going on with the front end design of your Instrument whilst being able to edit the functionality/build of it.

Now let’s look at Edit Mode panel:

The spanner (or wrench, depending on which side of the pond you’re from) rearranges our panel, or the visual aspect of our Instrument (we’ll be dealing with this later on). The insect is ‘wire-debugging’ which shows the data passing through virtual cables – certainly worth having on if something is going wrong and you need to troubleshoot. Finally you have screensets, which I don’t really use.

Okay, not far to go before we actually start making a noise! Next, let’s look at the Instrument itself:

We can see two input ports and two output ports. Seeing as we’re going to be building a synth, we don’t need to deal with audio inputs so select them both and hit delete. Click on the Instrument and in the left side pane click on the properties icon that’s appeared (a tick box). Underneath that, click Function and change the Voices to 1.

We’ll be modifying the info on the Functions, Info and View tabs quite a bit, so familiarise yourself with them.

Now, double-click on the Instrument and you’ll be taken inside it where you’ll see the input ports and output ports. In addition you’ll see two voice combinators. These modules mix polyphonic signals to monophonic ones. Don’t worry about them too much at the moment.

Building a Monosynth

Now we can start actually building our synth! There are two ways to access modules. Firstly, you can cntrl + click on the background and a menu will appear: here we have built in modules, core cells, Macros, Instruments etc etc. (we’ll be primarily working within just the built-in modules section of the menu for now):

Secondly, once you’re more familiar with modules names, you can simply hit return and a small text box will appear where you can type the name of the module you’re looking for and hit return again to add it.

Let’s start by deleting the input ports from inside our Instrument. Now to make our synth make a sound, we’re going to need an oscillator, so add a Sine Oscillator from Built-In Modules > Oscillators > Sine. You should see that the module has two inputs and one output. The ins are labelled P for Pitch and A for amplitude. Notice P is red (an event input) and A black (an audio input) – this is because they take different data types.

Don’t worry too much about the difference between these two at the moment but understand that under normal circumstances, you can’t plug an event signal into an audio input or an audio signal into an event input.

By hovering the cursor over the P and A we can get a brief description of what type of signal they’re expecting and how they process it. This is only available if you have Show Info Hints enabled so, if you didn’t earlier, make sure you do now!

Cntrl + click on the P port and you’ll see we can create a constant or a control. Creating constants and controls this way is useful because Reaktor takes the ranges the module is expecting to receive into consideration. Create a control for P and a constant for A.

You’ll now notice our panel has a knob labeled Pitch on it. The Pitch knob ranges from 0-127 (the same range as all MIDI data), so 60 represents a pitch (middle C). If we connect our sine oscillators output to our voice combinators we should now hear a sound, and changing the Pitch knob will change the oscillator’s pitch.

So, to summarise what’s going on here: the Pitch knob is just sending a value to P and the constant is sending a value of 1 to our A input. Amplitude in Reaktor ranges from 0 to 1, so 1 is our maximum and 0 is off, so a constant of 1 being sent to our A input would make our sound continuous. The value being sent from a control, constant or module can be inspected when you hover over the wire if wire-debugging is enabled.

We will want to control our synth with a keyboard, so delete the Pitch knob and constant value we just created and add Note Pitch and Gate from Built-In Modules > MIDI In. Connect those to our oscillator by dragging their output to the input of the oscillator to manually create a wire. Now you can control it with either a MIDI keyboard or a QWERTY keyboard.

Next, we’ll want to be able to control our volume with more than just an on/off message. Create an ADSR found in Built-In Modules > LFO, Envelope. There are five ports, G, A, D, S and R. The last four control how a signal is shaped over time and the G is a gate input. Connect the out from our MIDI Gate port to G and create controls for A, D, S and R by cntrl + clicking on them. Finally connect the Out to A on our oscillator. If you’ve done this correctly you should see something like this:

This is great, however our knobs for the ADSR will have been created all in the same space. Use the Spanner/Wrench tool to move them into a line:

At this stage you can start making decisions about the visuals of your synth. Click on the Attack knob and look in the view panel in the side pane. I’ve changed mine to Vertical Sliders, Medium size with a length of 53 and disabled the ‘Show Value’ tick box. You might want to rename then A, D, S and R rather than Attack, Decay, Sustain and Release to save some horizontal space.

Clicking on the ADSR module, I’ve turned ‘Visible’ to On in the view tab in the side pane and changed the height to 65. Finally I’ve unticked ‘Show Label’. After a bit of tidying up our panel we have something like this:

Of course you can style yours however you want, but this is fine for me at the moment. Now we’re able to shape the amplitude of our sound, let’s move on to developing it to be a bit more useful. Create Triangle, Pulse and Sawtooth oscillators from the Built-In Modules > Oscillators section and connect the Note Pitch and ADSR to the relevant P and A ports.

Again, we have options for how we approach the next step. We could either have a switch between these oscillators or have a mixer, blending between them: I’m going to opt for the former. Create a Switch, which is found in Built-In Modules > Panel. Connect our Sine Oscillator to the input then, using cmd + click + drag, connect the Triangle, Pulse and Sawtooth Oscillators to new ports on the switch.

Tidy up the panel and name the switch Oscillator 1 (or whatever you want) and also name these new ports appropriately. Once the Switch is connected to our voice combinators, we should see something like this (note only the oscillator with output engaged by the switch will be active):

Let’s add a filter. The filters can be found in Built-In Modules > Filter (unsurprisingly). We’re going to add the Multi 2 Pole Filter FM because it has all the functionality we need. Hook the switch up to the In port and create controls for P and R but leave the F port unconnected for now. As with the previous step, create a switch after the Filter and create inputs for the LP, BP and HP outputs (Low-Pass, Band-Pass and High-Pass for those who don’t know). I’ve renamed the P and Res knobs Cutoff and Q, respectively. Tidying of the front panel a bit we should have something like this:

Finally, we’re going to add a master volume control to our synth before taking stock. We can do this with a simple bit of maths. Create a new fader or knob (Built-In Modules > Panel) and name it Master. Set the range from 0 to 1 and the step size to 0.01 in the Function tab. Now take the output from our filter switch and multiply the result against our knob. Multiply is found in Built-In Modules > Math. At a value of 0 (0 x 1 is 0) our sound will be silent, at 1 we’re multiply 1 x 1 so it’d be the same volume and at 0.5 it’ll be half the volume. Here’s our final stage of the synth:

Introduction to Macros

We’re going to have a look at what are called Macros now. Macros are a way of organising modules into a clearer layout, making it easier to copy and paste and clearly navigate the complexities of your synth. At the moment, our Instrument has the ADSR, MIDI information, oscillators, filter and outputs stages altogether. We can easily separate them using Macros.

Start by creating a blank Macro, which is found in Macro > _New – Empty. Anything we place inside the Macro can be viewed in a nice contained window. We can input signals in and out of the Macros, too. Let’s start by adding our ADSR to the Macro. Select the ADSR module and the A, D, S and R knobs, using shift + select. Now, using cmd + x cut them, double click on the new Macro and paste (cmd + v) in there.

Our Macro needs an input for our Gate signal and output for the resulting ADSR shape. In Built-In Modules > Terminal add an In Port and Out Port, name them G and A, respectively, and connect them to our ADSR module.

Double-click on the background of our Macro to navigate back to our Instrument and connect the Gate to our G input. Name the Macro ADSR and we should see something like this:

Next, we’ll move to our oscillators. Shift + select the four oscillators and the switch and paste them into a new Macro. Name this Macro Osc 1, or similar. Inside the Macro create In Ports named P and A and an out port. The A input can be simply connected to all of the A inputs and the Output to the switch, but we’re going to create tuning parameters for the pitch input.

Create a switch named Range and add three constants to its inputs (Built-In Module > Math): 12, 0 and -12 (named as such, too). The result of this switch should be added (Built-In Module > Math) to P, giving you something like this:

Add the result to a knob with a range of 11 to -11 with a step size of 1 and name this knob Coarse. Finally add that to another knob with a range of 0.5 to -0.5 with a step size of 0.01 and name this Fine. This can be connected to the P inputs of our four oscillators.

Lastly, in the oscillator Macro, create a control on the W input for our pulse (pulse width) and name it PW. We can worry about this more later; for now, this is the basis of our oscillator and can be duplicated several times:

Going back a level, connect the Note Pitch and the ADSR Macros to our new Osc 1 Macro then, using alt + click drag, copy the oscillator 3 times and name the two new Macros Osc 2 and Osc 3.

Next, you’ll need to connect the Note Pitch and output from the ADSR to the new Macros’ inputs. Drag the cables while holding cmd to create a new input or inputs can be created within the module.

Our oscillators will need to be mixed together so create a blank Macro and, using cmd + click drag, connect the outputs of our oscillator Macros to the new Macro. Name the ports as you wish, something like Osc 1, Osc 2 etc. Our new Macro can be named Osc Mix, or something similar.

Inside the Macro, create an Amp/Mixer found in Built-In Modules > Signal Path and connect the inputs to it using cmd + click drag to create new inputs where needed. Create controls for each Lvl input. I’ve styled them to be knobs rather than sliders:

Create Macros for the Filter and Master section and finally for the MIDI input (adjust the Macro’s ‘Visible’ to ‘off’ in the ‘View’ side pane). With some tidying up on the front panel we should have something that looks like this:

And that’s our completed monosynth! Over the coming articles I’ll look to develop this into something a bit more functional, adding other noise sources, developing the oscillators and filter and adding an oscilloscope as well as other modulation sources.

Hopefully you can begin to see how powerful and customisable Reaktor is, even with this simple design. There’s a plethora of options available to us not only for how we can style it but how the functionality can be changed to suit your needs and wants. The ensemble for this synth can be downloaded here.

Check out part two here.