When first unboxing Reaktor 5 back in 2000-and-something I was blown away by the capabilities of these other-worldly synths, drum machines, granular sample destroying effects and sequencers, but it was some of the generative tools that really captured my imagination.

Whilst I’m still not quite au fait with the monstrously complex Skrewell, SpaceDrone is a neat tidy little unit capable of some beautiful sounds without too much work. Most interestingly it’s actually a quite simple machine when you peek at what’s behind the curtain.


SpaceDrone is a self-playing ensemble, creating sounds ranging from lush, ethereal ambient soundscapes, not dissimilar to the weird and wonderful noises captured by NASA of other planets and moons, cold industrial tones, insect-like chattering and sounds that wouldn’t be out of place in a Andrei Tarkovsky film.

This is what Reaktor’s blurb has to say about it:

SpaceDrone generates atmospheric pads which range from light rain or howling wind noises to deep and uncanny space sounds. Technically, the instrument is based on 96 parallel voices spread across the frequency spectrum. Each voice consists of a noise generator; the signal’s amplitude is shaped by an envelope, its frequency content gets modified by a bandpass filter, and finally it gets positioned in the stereo field.

To simplify this a little, SpaceDrone is a 96 (yes, ninety-six!) voice synthesiser. It generates white noise tones that are pseudo-randomly band-pass filtered, given an amplitude envelope shape and spread across the panoramic spectrum. Let’s investigate the front panel.

The Front Panel

There are two graphic displays to get out of the way first. They display the volume (in white, on the left) and the position within the stereo spectrum (blue, on the right) of the 96 voices.

They’re quite pretty but don’t really contribute to the functionality of the ensemble so I wont be dealing with them any further than this. We’re also just focusing on the ‘A’ view, which is the sound generation bit, while the ‘B’ view is a reverb unit.

Screen Shot 2016-05-18 at 19.04.41-5.png

In green I’ve highlighted the remaining controls. Starting off with the top left and middle left we have two knobs for Attack and Decay. These control our amplitude envelope of our voices. When you look at what’s going on, we actually have an ADR (attack, decay and release) envelope with the Decay knob controlling both decay and release, although sonically it wont make huge amounts of difference.

The Pitch dial is a bipolar control of the amount of modulation our amplitude envelope has on the sounds perceived pitch. As it is bipolar it means when at 12’o’clock the dial is having no effect, and moving it clockwise and counter-clockwise will increase the modulation. It’s most easily heard when cranked to extremes, adjusting the Attack and Release settings you can hear the pitch and timbres produced.

The Density, Rnd and Dynamic knobs are all related to the Geiger macro which we’ll delve into properly later. Density sets the rate at which our amplitude envelope is retriggered, Rnd sets the randomness of the retriggering and Dynamic sets the range of our potential amplitudes. When fully clockwise we have a wider dynamic range of sounds and when fully counter-clockwise all voices are at a more constant maximum volume.

The Res dial relates to the resonance or Q of our band-pass filter. Turning it up to maximum can produce more tonal sounds, akin to a resonator. Here’s a simple patch with the resonance being slowly turned up:

To finish the top row of dials off we have control for the rate of panning of the voices and an associated Rnd dial, which controls the amount of random panning.

The Damp is a simple way to control the frequency content of the sound. Whilst it sounds a bit like a low-pass filter or low-shelf EQ it’s actually a bit more complicated than that. Turn it counter-clockwise to open up the higher frequencies and clockwise to attenuate them.

The numeric readouts in the middle control the perceived pitches of our patch. The Fundamental actually controls our band-pass filter (more on this later). Rapidly adjusting this will give something between a filter sweep and running up a chromatic scale.

Offset is a little harder to understand – this ascends the harmonics associated with the fundamental. Harmonics are integer multiples of our frequency and are a naturally occurring phenomena. Increasing this will give you a similar sound to the Fundamental but less “musical”. Here’s the Fundamental and Offset being increased and then decreased one at a time.

Lastly we have Speed and Amt (amount), both of which control a Slow Random LFO module; this affects the incoming pitch to the band-pass filter. Set the Amt at 0 to more clearly hear the fundamental frequency and increase it to diffuse it. Speed sets the rate of the LFO.

There’s quite a lot to swallow there, so don’t worry if you didn’t fully understand all of it, some of the best sounds from this can come through simple experimentation. Looking at the structure and signal path of the module actually cleared a few things up for me.

Under the Hood

Let’s examine the architecture of SpacedDrone by going into edit mode and delving into the instrument.

Screen Shot 2016-05-18 at 17.12.21.png

This may look a little fiddly, but I can assure you it’s a hell of a lot simpler and easier-on-the-eye than some other Reaktor ensembles.

Firstly you should notice that there are four macros (highlighted in pinky/red), two named Display, the Geiger macro and one titled Space.

Screen Shot 2016-05-18 at 17.12.21.png

Macros are like a folders containing other modules and core cells within Reaktor. I’m going to ignore the two Display macros as they’re solely concerned with the visual side to SpaceDrone, which I don’t want to focus on.

In addition I’m going to ignore the Space macro right at the end of the signal path – this is just the reverb unit. Disabling it really roughens the patch up (not in an always pleasing way).

Signal Path

Much like all synths, the signal path of SpaceDrone is actually quite simple. Yes there’s loads of modulation from all-sorts of pseudo random sources but here are the nuts and bolts:


This isn’t the prettiest diagram I’ve ever made, and this is an oversimplification, but we can expand on it. Let’s start with the green route. This is how most subtractive synthesisers work.

We have some sort of tone generation (in this case a white noise oscillator), a filter, and then an output or amp. SpaceDrone’s output is slightly more advanced, allowing panning within a stereo spectrum and it has it’s own dedicated reverb. Aside from that it’s fairly standard.

In Orange we have the ADR (attack, decay, release) envelope, which controls both our amplitude and filter cutoff. This is triggered by our Geiger macro, which we’ll deal with in more depth later. In Purple/red is a Slow Random LFO module controlling the rate of triangle wave LFO, which in turn determines the pan position of our voices.

Screen Shot 2016-05-18 at 17.12.21 2.png

Granular Fever

Of course SpaceDrone is not as simple as it first seems and there’s a lot of maths going on thatScreen Shot 2016-05-25 at 11.08.51.png I’m not going to go into in this write up. Whilst SpaceDrone is not technically a granular synthesiser, it has a similar sonic effect to one. Each voice is assigned a filter frequency cutoff and position within a stereo field, not dissimilar to the grains in the context of a granular synth.

Screen Shot 2016-05-25 at 11.10.52.pngAt the heart of this all this is a simple 2-pole band-pass filter. The In and Res inputs are relatively simple. The In takes the output of the Noise module and Res(onance) has a simple knob on the front panel. However the P (for Pitch) input is slightly more complex, and this is largely what gives SpaceDrone its unique, musical sound.

As mentioned previously the Fundamental and Offset determine each voice’s pitch and harmonic; this effect is not dissimilar to the Aetherizer, which users of Absynth may be familiar with. It’s a granular effect based on short delays, pitch-shifting and a musical sounding filter that is capable of creating very tonal cloud-like swarms of sound.

The Geiger Macro

Geiger Counters are used to measure ionizing radiation, such as in radiological protection, experimental physics and the nuclear industry (so says Wikipedia, you might be able to tell that I’m not a physicist!). You would have heard the sound in any post apocalyptic or cold war paranoid era film about a nuclear fall-out.

Screen Shot 2016-07-12 at 13.57.29.pngReaktor 5 actually has a module dedicated to replicating this sound (left). The information from the manual says it “generates events at random intervals, much like a Geiger Counter radiation particle detector”. To understand this it’s useful to understand radioactive decay, which Wikipeida describes as:

…a stochastic (i.e. random) process at the level of single atoms, in that, according to quantum theory, it is impossible to predict when a particular atom will decay. The chance that a given atom will decay never changes, that is, it does not matter how long the atom has existed.

Mind-numbing eh? Oddly, inside the Geiger macro we don’t see the Geiger primary module that Reaktor supplies. Instead we have a trigger generator similar to a Geiger Counter module but with slightly more flexibility. We have input terminals for P, Rnd and Dyn, and a simple output terminal that leads to ADR envelope.

Screenshot 25:05:2016, 11:03.png

P is controlled by the Density knob on the front panel while Rnd (random) and Dyn (Dynamic) which have been described above. There are two Randomize modules. P is added to the output of one of these. This in turn receives part of its input from a pulse that is driven by said the other Randomize module.

The LFO’s rate is determined by the P value. This is a logarithmic value converted to linear frequency. This outputs a pulse wave – perfect for triggering envelopes. This is run into an A to E Trig module which converts an audio event into an event output. Phew!

Processing SpaceDrone

Let’s fire up SpaceDrone in Ableton Live and get some big ‘ole ambient pads moving. I’ve tweaked the default preset, moving the Fundamental to 60 (MIDI note C3 or C4 depending on who you believe), increased the resonance and pan, reduced the dampening and slowed the speed right down.

I next brought the reverb mix down a little (in the ‘B’ view). I’ve just added some EQ and compression too. Nothing special so far.

Screen Shot 2016-07-12 at 22.18.20.png

Screen Shot 2016-07-12 at 22.22.34.png

Adding Live’s Resonator tuned to a C minor 7 chord (C, Eb, G, Ab) gives us a nice Tanpura-like quality to it (you can read about some more awesome stuff to do with Live’s Resonator here). I’ve disabled the input filter, increased the decay and set it to 70% wet.

Screen Shot 2016-07-12 at 22.25.52.png

I’ve added some SoundToys Crystallizer (using the Phillip Glass Echoes preset) and some Valhalla Shimmer. I’ve finished the sound off with a dulling low-pass filter to send it right back in the mix. Feels like dropping acid on the Floating Islands level on Tomb Raider II (without all the gunshots, though).

Screen Shot 2016-07-12 at 22.28.08.png

Screen Shot 2016-07-12 at 22.28.27.png

Hacking SpaceDrone

Reaktor allows us to dive into the architecture of its ensembles at the same level afforded to the sound designers that programmed them. As SpaceDrone contains some relatively low-level primary modules structured in a simple way, we can hack it to allow some more flexibility. I’m not going to focus on making it look pretty, as this would require some Photoshop wizardry that I’m not up for. So with that in mind let’s go.

There are four main changes I’m going to make:

  • Add an external input. We could take signals from our DAW, other Reatkor ensembles or even the external input on our sound card.
  • Add different waveforms other than just white noise to switch between when the external input is not engaged. Waveforms with more harmonics will work much better.
  • Add a MIDI input option for determining the fundamental tone.
  • Include a simple bit of boolean logic (AND gate) for the ADR envelope, so we can use this with the above MIDI keyboard to “play” SpaceDrone.

Screen Shot 2016-07-19 at 17.10.40.png

Start off by adding an In Port module (Built-In Module > Terminal) and connecting it to a switch (Built-In Module > Panel). Add in any additional oscillators you want now (I’ve opted for the Bi-Saw and Bi-Pulse, but FM or even samplers would work a treat) and connect then to the Switch naming each port. Connect the ‘1’ constant from the Noise module to the A (amplitude) inputs of each oscillator and replace the ‘in’ on the 2-Pole-Filter with the output from the Switch. Go back a level in the breadcrumb trail you’ll need to add an input terminal SpaceDrone at the Instrument level too.

Ctrl + click (or right click) on the W input (width, or symmetry) on the Bi-Pulse and click Add Control. This will create a knob which you can rename whatever you want (I’ve opted for Sym) and also connect it to the W input on the Bi-Saw. You’ll need to repeat this for any other oscillators you’ve added.

Screen Shot 2016-07-19 at 17.23.12.pngAlternatively, to keep things looking pretty you can copy and paste one of SpaceDrone’s knobs (for e.g Attack) and change the values to suit to the W inputs in the Properties > Function tab. Oddly the ranges expected on the W input for the Bi-Pulse (-1 to 1) differ from the Bi-Saw (0 to 6) so we’ll have to do some maths to get the ranges matching up nicely.

I’ve set the Sym knob to range from -1 to 1 and plugged that directly into the Bi-Pulse. For the Bi-Saw multiply the result by 6 (now ranging from -6 to 6) and connect that to the Bi-Saw.

Let’s move on to the ADR envelope. Add a Gate MIDI In module (Built-In Module > MIDI In) to receive MIDI note on and note off messages. This will output MIDI velocity as a decimal between 0 and 1.

Multiply this by the output of the Geiger Macro and add the result to a switch naming the port “MIDI” or something. Now the Geiger will only sound if the velocity is greater than 0, effectively a boolean AND gate.

Add the Geiger Macro (without the MIDI In multiplication) to a new port on the Switch and name this “Drone” or similar. Connect this Switch to the input of the ADR module and now you can flick between a MIDI input and the original self-playing style. I’ve found it best to switch the Gate MIDI In module to Mono (see how it’s orange rather than yellow).

Screen Shot 2016-07-19 at 17.35.39.png

The only problem is that lower velocities will produce much quieter sounds, so I’m going to create a simple if statement. This will take an incoming velocity value and output a 1 if the value is greater than 0, and still output 0 for note off.

Take the the Gate MIDI In module into the Ctl input of a Router module (Built-In Module > Event Processing > Router 1, 2). This will only output when Ctl is greater than 0. Then run both the outputs of the Gate MIDI In and Router modules into the A and B inputs of a Compare module (Built-In Module > Math) and take the Greater than (>) output to the multiply module. It should look something like this:

Screen Shot 2016-07-20 at 21.52.34.png

*edit* Owen Vallis has correctly pointed out to me that the Router is unnecessary in primary as:

The Primary version includes the router conditionals by offering different output ports (> and <=), and doesn’t require any other modules to work; however, it has a limited set of fixed outputs to choose from (although there is also the compare equals).

…so you can just use the Compare module alone in your version of this.

Now let’s move on to the fundamental. Add a Note Pitch MIDI In (Built-In Module > MIDI In). This outputs our MIDI input as a logarithmic pitch (MIDI pitches range from 0 to 127, or C-2 to G8). Add this to a switch and use the output of the Fundamental knob as the other input on the switch.

Make sure you take the output of this before the P to F  Expo module. This module is an exponential function converting logarithmic pitches to linear frequencies.Screen Shot 2016-07-19 at 17.42.58.png

Ensure the Note Pitch MIDI In module is set to Mono too. Finally connect the output of the switch to the P (pitch) inputs on any oscillators that require them.

You can download the finished ensemble here.

Here are some audio examples of the external input, firstly me tapping the pinhole mic on my MacBook Pro (with some air conditioning on backing vocals):

Here’s a looped pad (didn’t sound as awesome as I’d hoped tbh):

And lastly a breakbeat:

Digging around for alternative approaches I found this from Reaktor Tips. They’ve approached it differently adding an envelope after the Reverb unit and doing the pitch in a slightly different way, but we achieve a similar result.

That’s all Folks!

If that has whet your appetite, do check out other Reaktor tutorials I’ve done on the generative pattern sequencer and drum synth NewScool, the pocket-sized wavetable synth OkiComputer.

If you’re interested in learning more about building within Reaktor, then this getting started guide might be your thing.

Here’s a short video I’ve made highlighting some of the above topics, albeit in slightly less detail: