Rebel Technology Open Sound Module & Reaktor 6

In 2025 I’m dedicated to clearing my drafts folder. This dates back to 2015(!) which is incredible I’m bothering to publish but funnily enough the content is still relevant.

Reaktor is near-limitless world of musical potential. Native Instruments’ flagship digital semi-modular saw a sixth incarnation released in September 2015 and with it the introduction of their new concept: Blocks. The idea behind Blocks was to marry the already flexible modular capabilities of Reaktor with a sleeker UI, taking a lot of influence from the recent rise in popularity of eurorack modular.

This article however, is not going to focus solely around Blocks, but about using Reaktor with your eurorack system. There’s already a plethora of articles out there about using the Expert Sleepers products with your modular, so I wont tread on that ground.

A downside of the Expert Sleepers stuff is that is requires a dedicated soundcard that has DC-coupled outputs. This allows controlled voltage (CV) to be sent over a light-pipe connection, signal that would ordinarily be filtered out.

Just before the release of Reaktor 6 I had be working with London-based modular company Rebel Technology on beta-testing a new module of theirs: the innovative Open Sound Module (OSM). This clever unit allowed CV to be transmitted back and forth from a eurorack modular over Open Sound Control (more commonly known as OSC) to a DAW, smart phone, tablet or programming environment.

What I liked about this is that it allowed control between the modular and computer without the need for buying a new soundcard. This was something I’d been interested in for a while – using the modular to generate CV to control synths, drum machines and samplers in my DAW. And, while I may not be an expert Reaktor builder, I was fascinated to see how I could get the OSM working with Reaktor.

Before Getting Started

There’s a few articles that are worth familiarising yourself with, just to get a nice overview of the topic:

Reaktor: Having at least some experience with building in primary will set you in good stead. The examples in this article with be quite simple but if you want to expand on them, then understanding signal flow and some basic logic gates would be a great start. This article was written before Reaktor 6 but the principles are the same.
Modular synthesis: Understanding CV and triggers in a eurorack environment will help too, even though most of the legwork will be done in Reaktor.
Using and setting up TouchOSC: The OSM is pretty simple to set up, but if you run into problems, this article might be a good starting point, and also if you want to take things a step further and combine the OSM with a smart phone, Ableton Live or other environment.
Clocking modulars with your DAW: Unless you’re making ambient music or experimental sonic art, most of us still use tempos, and ensuring you can send clocks to and from the modular via either MIDI or OSM is really useful for keeping things in time.
Using external hardware with your DAW: This is really an expansion on the above article, less focused on modular and more on broader hardware/MIDI devices. It details sending sync/clock information from Logic and Ableton Live.

I also want to add that using Reaktor’s low-level DSP engine Core would give you more control but from my experience more people are familiar with primary than core.

Setting up Open Sound Module

Before we starting twiddling around with LFOs and sequencers, we need to get OSM working correctly. Setting up the OSM is relatively simple – once it’s powered up and settled down, check your available WIFI networks and connect to the module. The passwords are located on the back of the module so either write it down or retrieve it from your documentation.

If you can’t see if refer to this troubleshooting document. Be sure to have a read through the official Getting Started and Instructions if you’re still struggling.

OSC in Reaktor

In Reaktor, navigate to your OSC settings (File > OSC Settings or alt + cmd + .) and ensure OSC is activated. Set the Receive Port to 9000 and the Send to 8000. You should now be ready to test the module.

The OSM sends and receives triggers and CV across two channels, A and B. These are displayed as osm/a/tr and osm/a/cv (replacing a for b for the second channel).

Reaktor contains four dedicated OSC modules, the Send, Receive, Send Array and Receive Array, however it’s only the first two that we’ll be using today. Both modules can be found in Built-In Module > OSC (or Built In Module > Terminal if you’re using Reaktor 5).

Setting them up is pretty easy if you’re familiar with how OSC works, let’s deal with the OSC Receive first. In the Connect tab (Properties > Connect),

Let’s start off by testing that Reaktor is receiving OSC from the module. I’ve got my intellijel Dual ADSR in Cycle mode, and we can make a crude triangle wave LFO with the attack and decay stages. When we connect that to OSM’s CV input on channel A and we can see the relevant channel in Reaktor receiving that CV as OSC data.

Let’s ensure Reaktor is now sending OSC back to the module. I’ve created a simple LFO and sent connected it to an OSC Send module. Firstly set the LFO to mono and the OSC send module to “always active”. You’ll need to set the correct target in the Connect tab (osm/a/cv in my case).

As we can see on the O’Tool+, the LFO is being received loud and clear.

There are alternative ways of using OSC in Reaktor but I like the dedicated modules as they are simple and easy to build with. Alternative methods can be read about here.

Sending Triggers from Reaktor

The OSM can send and receive two types of signals – triggers (ranging from 0 to 1) and CV (from -1 to 1). Let’s start by dealing with triggers, as they are arguably the easiest thing to get right.

I’ve created two OSC Send modules with targets of osm/a/tr and osm/b/tr. I’ve created a Note Pitch module and connected it to a numeric readout to display the incoming MIDI note number. This is a really handy module for troubleshooting. Like the OSC Send and Receive modules ensure it’s “always active”.

I’m going to use C3 and C#3, which correspond to MIDI notes 36 and 37. Create two Compare/Equal modules and compare each to constants of 36 and 37 at the B inputs respectively. I’m using the != output and then running that into a Compare module, comparing that input with the Gate input.

Firstly, using a Compare module we can compare the Gate input to a constant of 0. Every time the gate is high we output a 1 from the Greater Than output (>). We’ll take this and multiply it by the Note Pitch input, sending the result to two Compare/Equal modules.

The B inputs to these are constants of 36 and 37 (C1 and C#1, or the first two pads on Push). Using the Equal To output (=) we can send to our OSC Send modules.

This is a simple bit of boolean logic that isolates the correct midi note and only outputs it when the gate is high, ensuring we send the correct note to the correct send. Notice I’m using a Numeric Readout and two Lamps to troubleshoot at each stage.

The OSM is sending the A and B trigger outputs to a TipTop Audio BD808 and SD808, their results are mixed and routed back into the soundcard’s audio input.

WARNING: As with all eurorack modular equipment, the signal is very hot (up to 10 volts peak to peak) so ensure you have any input gain turned right down before blowing your ear drums up (or speaker cones).

Sending Triggers to Reaktor

Let’s work on generating some trigger from with the modular and sending them to Reaktor. Firstly let’s set up a MIDI clock to be sent to the modular. This isn’t mandatory but certainly helps keep thing in time. In the Audio and MIDI Settings make sure that the corresponding port is enabled in the MDI Output tab.

Additionally in the Settings dropdown menu in the top navigator, click Send Clock to MIDI Output, which is in turn connected to a Kenton Solo Euro. We should be ready now to send clock data from Reaktor.

I’ve created a couple of basic triangle wave oscillators with different pitches. They each have an AD envelope being triggered by OSC Receive modules (osm/a/tr and osm/b/tr).

On the modular I’ve connected the Clock 1 output from my Kenton Solo Euro to the clock input on another Rebel Technology module, the Στοιχεῖα (or, Stoicheia), a Euclidian trigger generator. The Stoicheia has two channels with the clock inputs normalled by default so we can use both outputs in sync. Connect them to the OSM’s corresponding inputs et voilà!

Sending CV Modulation

Much like in our test example, we can repeat a near identical setup here to show how to send OSC and convert it into CV.

I have an LFO with switchable wave shape being sent to the Mod A input on a Synthesis Technology E330, which is in in morph mode. This will scan the wavetable index of the corresponding output. The E330 is routed to an intellijel µFold with an AD envelope from Reaktor being connected to the Folds CV input, using an Audio to Event converter in between the envelope and OSC Send.

There’s no reason that once this CV is in modular-land it can’t be mult’d or mixed with other CV sources too. Look out for mixers and VCAs that can accept audio and CV signals.

When researching this post I came across this article on scaling values in Reaktor from the excellent blog Reaktor Tips. This can be handy for controlling modulation values, making them increase more rapidly as the value increase. You can use a simple multiply module (with both inputs the value you want to scale), creating a parabolic curve (Y = X²).

Receiving CV Modulation

This is where it can start getting interesting. Let’s fire up a Reaktor factory library ensemble, Lazerbass. Load the Wobble Lazer snapshot and change the MOD LFO from BPM to Hz.

While in Edit mode, Ctrl + Click on the rate and hit “Show Structure in Other Pane” – this is the simplest way to navigate to the relevant modules under the hood.

Rather than unplugging the knob from everything it’s connected to we can use our OSC Receive and connect it to an IC Send. This creates a dropdown menu and lists all of Lazerbass’s parameters then can be controlled. Use the Unlock Panel tool to tidy up the display.

I’ve hooked up the Sum output from MATHS using both channels 1 and 4 in cycle mode and mixed the results with two channels from the MFB Dual LFO to create a complex modulation source.

You can learn more about Make Noise MATHS here.

Sending Pitch from Reaktor

This was trickier than I first assumed. First, let’s get some background. We know that Reaktor will be sending out MIDI pitches ranging from 0 – 127 (however Blocks has a more elegant solution – more on this later) and Eurorack uses volts/oct (1v/8va).

We have to convert a traditional MIDI signal to voltage, ranging fro -1 to 1. After a little reading around the topic and consulting MuffWiggler, the Reaktor forum and some legends like Tim Exile and Salamander Anagram, it was clear my maths was a little off.

Firstly, rather than having 128 steps of MIDI ranging from 0 to 127, most MIDI to CV modules in Reaktor cap at 120. I don’t know if this is because it makes the maths easier or what, but that’s the done thing.

The patch below is alarmingly simple. I started by dividing the MIDI input by 60, giving me a range of between 0 and 2. Then you can simply subtract 1 and you’re done.

I did experience some tracking issues and occasional lag, so this isn’t necessarily something I’d suggest for live usage, but that could be down to my ropey broadband connection or even the eurorack oscillators I used.

Sending Pitch to Reaktor

Finally, how can we generate pitch CV within eurorack and translate that to Reaktor and convert it to useable MIDI?

My first attempt was to take our CV (-1 to 1) and add 1, giving us a range of 0 to 2 (left). Like a reverse of the above patch we multiply this by 60 and then use the Modulo’s Div[ide] output to round the resulting decimal to the nearest whole integer. In theory in worked perfectly, outputting exactly the ranges I was expecting.

Here’s a post of Muff Wiggler regarding alternative solutions to this, however I found the above method the simplest.

I found this post by Noise Engineering about tuning to be very insightful and useful to researching this post. It’s a little nerdy for probably 90% of my readership, and some of it was too deep for me, but I want to include it also because Noise Engineering’s site is super awesome and worth bookmarking.

Lastly, here’s Owen Vallis from Kadenze discussing using OSC with the Moog Mother 32. Like a lot of tutorials focused on Eurorack and Reaktor it relies on the DC coupled outputs of MOTU, which is something I wanted to avoid adding to. It’s more of a broad overview of OSC and using it for simpler modulation, but it’s still worth a look even if you don’t own this soundcard