In the first instalment of this series we looked at creating a monosynth in Reaktor, from the absolute basics through to creating oscillators, MIDI inputs, a basic ADSR envelope and filter before finishing with an introduction to macros.

If you’ve not read it, I’d recommend familiarising yourself with what we talked about:

Reaktor 101: Getting Started

Today we’re going to expand our synth by looking at developing our oscillators and noise sources a bit more and we’ll also get onto introducing some modulation. In future articles we’ll improve the MIDI capabilities, look at the master section, expand our filters and more.

Everything but the Kitchen Sync

Let’s start by building on our oscillator section. Start off by deleting Osc 2 and Osc 3 macros (we’ll work on Osc 1 and duplicate it to save repeating the same process over and over). Double click on Osc 1 macro to look inside.

There are numerous oscillators available to us in the Built-In Modules > Oscillator section, however we’re going to add the Sync ones in place of our current oscillators. Delete them and add Sine Sync, Tri Sync, Pulse Sync and Saw Sync.

You can begin by connecting the outputs to our switch and the P and A input terminals to our new oscillators, leaving our PW knob for now. If you’ve done everything correctly it should look something like this:

We can see some new inputs here: F, Snc and Ph. If ‘show info/hints’ is enabled you can read about what they do by hovering over them with the cursor. F is for linear frequency control, which can be used for frequency modulation. Create an In Port (Built-In Modules > Terminal) and name it F.

We will want to be able to control how much frequency modulation we have so take the newly-created F terminal and connect it to a multiply module (Built-In Modules > Math), create a knob and name it ‘FM depth’ and connect that to the multiplier. Set the range from 0 to 5000 in the side pane Function tab. Finally, connect this multiplier to our F inputs on each oscillator. We should have something like this:

Next we have Snc and Ph. Snc is an audio input for controlling the synchronisation of our oscillator’s phase, which we can snap with a gate on signal (which is useful for phatter basslines and such). Ph determines where the oscillators phase would start on that gate on signal, ranging from -1 to 1 (-180 degrees to 180 degrees). Create a constant of 0 and wire this to all of the Ph inputs. Next create an In Port, name it G and connect it to the Snc inputs.

N.B If you wanted more control over the phase of each oscillator you could create a control ranging from -1 to 1, but I can’t see a reason you’d want out of phase oscillators for a monosynth. Just bear in mind it’s possible. In later articles we’ll remove the constant and replace it with a button in our master section to enable/disable phase restart with a gate on signal.

Finally delete our PW knob and create an In Port named PW. As before, create a multiply module and connect PW to it. Cntrl + click on the remaining port and create a control. We can leave the range from 0 to 1. Name this new control PWM (pulse-width modulation) and connect that to the W input for the Pulse Sync oscillator.

This isn’t perfect because we can’t have individual control over PW and PWM (say if the PWM is disengaged) but we’ll fix that in later weeks.

With a bit of tidying our front panel should look something like this:

Our Oscillators are in pretty good shape now so let’s move back a level and connect our G output from the MIDI macro to the G input on our Osc 1 macro. Now, duplicate the Osc macro twice and rename our two new ones Osc 2 and Osc 3. Connect these to the relevant inputs on our Osc mix macro:

The Rest is Noise

Now we’ll add a white noise generator. Create a new macro and name it ‘Noise’. Take the A output from our ADSR macro and cmd + click + drag the wire to create an input on the Noise macro. Inside the macro create an Out Port. Now, create a Noise oscillator, which is found in Built-In Modules > Oscillators, and connect the A input and output to the Out Port.

In future articles we’ll create a sample and hold effect to get a digital-type white noise and add a low-pass filter to change the colour; however for now this is fine:

Jumping back a level, connect the output of the Noise macro to the Osc Mix using cmd + click + drag and in the Osc Mix connect the new input to the Amp/Mixer in the same way and create a new control called ‘Noise’.

You might notice that there’s an empty looking macro in the front panel – this is because there’s nothing to interface with such as controls, menus, buttons etc. You can either leave it as is or, in Properties > View in the side pane, untick the ‘Visible’ tickbox.

Pushing the Envelope

Our synth is sounding okay with three oscillators and a noise source but really we need some ways to stop it becoming so static. There are a couple of options available to us: LFOs (standing for low-frequency oscillators) and envelopes. We already have one envelope controlling our amplitude, so let’s start there.

N.B If you’re unfamiliar with concepts like LFOs and Envelopes, brush up on the basics of subtractive synthesis here.

Using alt + click + drag, copy our first ADSR macro. Name the macros Amp, ADSR and Filter ADSR to avoid confusion. Now, connect it to a new port on our Filter macro and name the input Env. Inside our Filter macro, create a multiply operator (Built In Modules > Math > Multiply) and connect our Env input terminal to it along with a knob named Env Mod, ranging from 0 to 5000. Connect this the F input to the 2-Pole Filter:

This is fine but we want the option to invert the filter envelope, so change the range of our Env Mod knob to -5000 to 5000, set the default to 0 and the step size to 1. Now, with negative values, we have inverse envelope modulation.

Let’s make a few small changes to our filter before moving on. Currently, the cutoff knob ranges from 0 – 120; if you have Show Info/Hints enabled and hover over the P input on the 2-Pole Filter, you will see it says it is has logarithmic control over the filter cutoff with MIDI values. This is fine but not really that useful visually, as we tend to think in frequency rather than MIDI notes when applying filtering to a sound.

Create a new knob called Cutoff and set the range from 0 to 5000. We want to convert these linear frequency values to logarithmic pitch values so our filter module can understand the desired frequency. In Built In Modules > Math add the Log. (F) module, connect our new cutoff knob to it and connect its output to the P terminal:

Once we tidy up the front panel a bit we get this:

Let’s move on to some LFOs.

How Low Can You Go?

LFO stands for low-frequency oscillator. Typically, they operate subsonically (below 20 Hz) and are used to control/modulate such parameters as pulse-width, filter cutoff, pitch or amplitude.

For now we’re just going to create an LFO and have it connected to pulse-width and filter modulation points, with knobs to increase or decrease their modulation accordingly.

Start off by creating a new macro and naming it LFO. Inside it create a new LFO, found in Built In Modules > LFO, Envelope > LFO. We have input controls for linear Frequency, Amplitude, Width, Sync (Snc) and Phase. Create controls for F, A, W and Ph by cntrl + clicking on each of the input terminals and creating a control (I’ve renamed SncPhase just Phase for simplicity):

We have outputs for Sine, Triangle and Pulse waves but we’ll want to expand this a little further. I’m going to add Ramp Osc (Built In Modules > Oscillator > Ramp) to provide a Sawtooth and inverse Sawtooth. Connect the Freq, Ampl and Phase to our new Ramp Osc:

Next, add a Random oscillator from Built In Modules > Oscillator > Random. You can connect Ampl to the A terminal but, like our filter cutoff, we’ll need to convert our Freq knob (which is linear) to logarithmic values as the Random oscillator takes logarithmic pitch (P) values. Add the Log. (F) from Built In Modules > Math and connect it all up:

Now, we need a switch to select the wave we want our LFO to use. The switch module is in Built In Modules > Panel. Connect the Sin, Tri and Pls outputs from our LFO module and name them. You can also connect the Ramp Osc and name it Ramp or Saw (as you wish).

We also want an inverse Ramp/Saw so add the Invert module from Built In Modules > Math, connect a duplicate of the Ramp Osc’s output to that and connect the invert module to our switch, naming this something like Ramp Inv or Saw Inv.

Finally, connect the Random and we have something that should look like the below (I opted for Saw + and Saw – to save space, I also named the switch Wave).

I also changed the switch to a menu rather than buttons, to save space on my front panel:

Let’s deal with the Snc input. Add an input terminal named G and outside of our macro, connect the G output to it from the MIDI macro. I’ve added the G input to a switch named Retrigger and added that to the Snc inputs of the LFO and Ramp Osc. Add an Out terminal that the switch connects to, rearrange the front panel (I renamed some of the knobs) and you should have something like this:

Front panel:

Outside the macro we can connect the output of our LFO to the W inputs of Oscillators 1, 2 and 3 and create input terminals (cmd + drag) on the Filter macro, naming them LFO.

Our PWM knob should start working straight away: at lower LFO rates we get a nice warbly, detuned-type sound. Let’s move on to the filter. Inside the filter macro we have a new input terminal called LFO. Connect this to a multiply (Built In Module > Math) and connect the LFO terminal and a knob, named LFO mod, ranging from 0 to 5000 to it:

Now, we need to add the output of our LFO modulation to the output of our envelope modulation and connect that to our F input on the filter:

Front panel:

Next Steps

That’s it for now: download the ensemble here. In coming weeks we’ll add keytracking to our filter, sort out our frequency modulation, pimp our noise oscillator a bit and add some global MIDI parameters like pitch bend and velocity modulation. Stay tuned!