OWL Groovebox with Ableton Live

You can now control the OWL over USB MIDI from DAWs such as Ableton Live. Here, Adam’s playing the OWL MIDI Groovebox.

Download the patch and have a play with it!


Posted in Uncategorized | Comments Off on OWL Groovebox with Ableton Live

Rebel Technology Algorithmic Beats Tutorial

Martin talks us through some algorithmic beat sequencing on the Rebel Technology Modular system

Martin is using (from left to right):
OWL Modular (*2)
Bit Reactor
Mix 01

Posted in Tutorials | Comments Off on Rebel Technology Algorithmic Beats Tutorial

Max Runs on the OWL

In a collaborative effort with Cycling ’74, we have today introduced support to run Max Gen patches on the OWL hardware range for music production and performance. Max users can now play and perform their patches without having to use a laptop.

OWL input frontThe OWL is available both as a guitar pedal and a Eurorack module. Users can program the OWL themselves, or download ready-made patches from an online library of more than 150, including polyphonic synthesisers, drum machines, glitchers, phasers, flangers, loopers, droners, delays, reverbs, crushers, shapers, screamers, and laughers.


Max is a highly versatile and popular software tool used by musicians, artists and creative coders to make instruments, interactive installations, audio and video effects and more. The visual patching paradigm makes it easy to try out musical ideas. The integration between Max and the OWL is enabled by the Max code generator Gen, and the online OWL compiler.



With a sophisticated ARM processor and plenty of memory, the OWL delivers best in class performance and audio quality. The platform is open source and open hardware.  It runs patches written in C++, FAUST, Pure Data and now Max’s Gen.

Users can sign up for free at hoxtonowl.com to share patches and try out some of the many examples.

Links and References


Posted in Uncategorized | Comments Off on Max Runs on the OWL

OWL Max Tutorial 1: Getting Started

Today we’re going to talk about how to set up a development environment for your OWL and Max’s Gen. First, though, a quick recap of what the OWL is and what Gen is:

The OWL is a Eurorack module which is a blank canvas. You can design your own DSP using C++, Pure Data, Faust and now Max’s Gen. You can make things from oscillators to delays to distortions to any sort of CV processes and run them on the OWL in your modular set up.

Gen is a low-level coding environment developed and distributed as a part of Cycling 74’s Max software, which is a visual programming environment. We can use the visual, user-friendly data-flow paradigm of Max to code low level DSP that runs on GPU/ CPU directly. We can then export our projects as C code which can run on all sorts of things – such as OWLs!



1.) Get your copy of Max (and Gen) from cycling74.com/downloads. Download the bundle of Gen examples and templates from github.com/pingdynasty/OwlGenPatches/archive/master.zip

If you’re familiar with github, you can do a git clone, and stay up-to-date with new examples as we add them: the repository is at github.com/pingdynasty/OwlGenPatches

2.) What we’re looking at today is DevTemplate which you’ll see when you unzip the download. You’ll want to add this folder to your Max search path. If you go to Options>File Preferences… you can amend existing search paths or create new ones. This makes sure Max will load all your files correctly!


3.) If you now open up Dev_default.maxpat, you can see that the patch is a virtual simulation of the controls on the OWL. The OWL has four CV inputs and four attenuators for those CV inputs, and we’re emulating the CV inputs. Each dial in the patch (eg the knob connected to [prepend A)] represents the top row of four knobs on the OWL. The knob connected to [prepend E] is the expression knob. The bang connected to [prepend push] is the button on the OWL. The two inputs and two outputs on the [gen~] object correspond to the pairs of input and output jacks on the OWL


4.) Open the [gen~] object by double clicking on it. Inside you’ll see 6 [param] obects. These correspond to the six inputs set up in the main max patch. The input from knob a / [prepend a] comes in to [param @name A @min 0 @max 1], knob b / [prepend b to [param @name B @min 0 @max 1]. Two inputs ([in 1] and [in 2]) and two outputs  ( [out 1] and [out 2]) correspond to audio in and out. At the moment, there’s nothing in there – it’s a blank patch that you can use to get cracking making some DSP because that’s more fun!

5.) Let’s make a simple two-channel attenuator. First, “save as” for the template patch before we edit it.  We’ll call the main patch SimpleAtten. The max patch and the gen patch co-exist but are also separate entities, and it’s a good idea to save the patch inside Gen separately. If you double click the [gen~] object you can “save as” for this too. It will save as a .gendsp file, in this case, we’ll use SimpleAtten.gendsp.


6.) Open the [gen~] object and unlock it – you’ll have to click on the pencil icon in the bottom left corner to enable you to modify a read only file. Select the two [param] objects for inputs a and b.


Add two multiplication objects. [*]. Break the connection between [in 1] and [out 1], and insert one of the [*] objects. The audio input goes into the left, the control into the right. The multiplied signal goes to the output. In the world of DSP, multiplying the number from 0 to 1 is the equivalent of volume control from complete silence to maximum volume.


7.) Before we export this as code, let’s make sure it works. We can set up a sine wave, at 440hz, using [cycle~ 440], in the main patch. If we connect it to the inputs of the [gen~] object, and turn audio on, we can use the dials connected to [prepend A] and [prepend B] to fade the sine wave into the left are right channels.


8.) Create a message box called (exportcode) and connect this to the left inlet of [gen~]. Click the message to bring up a menu asking you where to save the exported code too. Check for your exported code in Finder or Windows Explorer. Don’t worry about the contents of the gen_dsp folder – we just need the .cpp and .h files.


9.) To run this code in the browser and on your OWL, go to the OWL patch library at hoxtonowl.com (if you’ve not register, do so for free). Go to “My patches” and click create patch, Name it what you want; then click choose files and select the .cpp and .h files, making sure you set compilation type to gen. Now, hit “Save and Compile”! Once it’s compiled properly you’ll get a message saying patch compilation succeeded.


Click play, and you can select the microphone input or any of the four sample loops to test your patch – fading up dials a and b will control the left and right audio channels in the browser.


10.) Make sure you’re using a web midi enabled browser (such as Chrome) to load patches onto the OWL. If you’re connected to an OWL, hit “load”. You’ll see when your patch is loaded, how much CPU and memory you’re using. Here we’re testing it with a synth loop on the OWL, and it’s working!

Posted in Tutorials | Comments Off on OWL Max Tutorial 1: Getting Started

Performance at Sines and Squares Festival

We’ll be heading up to the glorious northern paradise of Manchester to do a concert (and a workshop!) at the Sines and Squares Festival, from 18th – 20th November: come join us!


Our concert is on Saturday 19th November at 19.00 at the Cosmo Concert Hall, The Martin Harris Centre, University of Manchester. We will be performing a new piece, Apophenia. This is a modular performance with Leafcutter John, Steph Horak, Martin Klang and Adam Parkinson. The piece uses sonification of environmental data to control an 8-channel modular synthesizer processing and sampling live vocals, charting a sonic journey from ethereal textures and processed vocals to a glitchy and fractured polyrhythmic landscape.

More details and tickets at the Sines and Squares Website: http://sines-squares.org/

You can also see us ‘workshopping’ the piece at Crux 2.4 on Saturday 12th November at the New River Studios in North London: http://crux-events.org/

Posted in Uncategorized | Comments Off on Performance at Sines and Squares Festival

November 2016: Sines and Squares Workshop

We’ll be heading up to the glorious northern paradise of Manchester to do a workshop (and a concert) at the Sines and Squares Festival: come join us!

Rebel Technology Sines and Squares Workshop
When: 11.00 – 15.00,  Friday 18th November 2016
Where: NOVARS Research Centre, Manchester

Rack 15

This workshop will serve as both an introduction to musical programming and music making with modular synthesisers, and as a showcase of some of the emerging, hybrid ways of working with computers and Eurorack modular synthesisers.

We begin by building a simple synthesis patch in C++. Focusing on fun, goal-oriented tasks is a great way to learn the basics of this powerful programming language.

We will then show how easily the patch can be compiled and uploaded to the OWL Modular synthesizer. Through some hands on patching and sequencing, you will see (and hear!) how the synthesis patch just created on a computer can be controlled, played and performed in new and exciting ways when it becomes part of a modular system.

In the final part of the workshop, we will show ways in which the modular system can be sequenced and played from the computer, integrating it with a DAW.

This is a unique opportunity to learn about musical programming, modular synthesis and hybrid workflows whilst using state-of-the-art technologies. Participants do not need to bring anything but themselves: we will bring Rebel Technology modular systems for all participants to get hands-on with and computer workstations will be available.

No prior programming experience is required. Numbers are however limited and pre-booking is essential.

Book now at Eventbrite.

Read more about Sines and Squares 2016.

Posted in Workshops | Comments Off on November 2016: Sines and Squares Workshop

Pure Data Tutorial 3: Open Sound Module

This tutorial is a bit different to the previous tutorials. Instead of making a Pure Data patch to run on the OWL, we’ll be making a Pure Data patch that runs on your computer. The patch is a sequencer that lets you send triggers and CV as OSC (Open Sound Control) messages over WiFi to the Rebel Technology Open Sound Module. This opens up the door for lots of interesting ways of controlling modular synths from your computer (from Arduinos to biosenors!)

The tutorial relies on Pure Data 0.47-0, which is a different release to what we’ve previously used, but it’s free and has some essential objects for OSC. Download it here:


You can download the patch we’ll be building in this tutorial via Patchstorage:


1.) At the heart of the sequencer is a clock. The clock is driven by the [metro] object (remember you can always look at the “put” menu to add new objects or find keyboard shortcuts). [metro] outputs bangs at regular intervals set using the right inlet and/or the initial argument (the number written after metro – control click or right click an object to view the help file for more info like this about what inlets, arguments and messages they expect). We will give the [metro] an initial argument of 200, so it sends out bangs every 200ms. It can be turned on and off using a [toggle] object (which looks like a clickable square), and a number box connected to the right inlet allows us to change the initial value of 200 to speed up or slow down the sequencer.

metro2.) The metro outputs bangs, and we need to convert those into numbers to step through our sequencer, so we need to make a counter. We do this with the float object (written as [f] or [float]) and the [+] object. The [+] object needs an argument of 1 (ie [+ 1]), so it adds 1 to any number that enters the left inlet. The [f] object stores numbers that it receives in the right inlet, and outputs them when it receives a bang in the left inlet. If we connect the bangs from the outlet of [metro] into the left inlet of [f], connect the outlet of [f] to the input of [+], and send the output of [+] into the right (or “store”) inlet of [f], then we have a simple counter coming from the outlet of [f].

float3.) The only problem with this counter is that it keeps on counting, and we want it to repeatedly go through the 8 steps of our sequence. The object that will let us do this is [mod]. This object divides the input by the argument and outputs the remainder. Therefore, [mod 8] will make our counter cycle from 0 to 7. We are going to use this master clock throughout the sequencer, so we use the [send] or [s] object, and in this case call it clock, so the object is [s clock]. This means wherever we put [receive clock] or [r clock] in the patch, we will get the master clock output (and everything can be in time, if you want it to be!).

timer4.) Now lets make a way of sequencing CV. We will use the [array] object, created using the “put” menu. Set the size to 8 (for the 8 steps), and right click or control click to adjust the properties, setting the y range to 1 – 0.

array_propertiesBy adjusting the sliders on the array, we will be able to change the 8 notes in our sequence.

array5.) In order to retrieve values from the array, we will use the [tabread] object. [tabread] needs an argument to tell it which table (or array) to read from, so we call it [tabread array1].

read_array6.) To send this data over OSC, we need to use the [netsend] object. This needs to be given two attributes, “-u -b” (because we are using UDP and binary), so it will look like [netsend -u -b]. We need to connect a message to it to tell it the IP address of the OSM module and the port to connect to – “connect 8000”

netsend7.) We need to format the data from our [array] object before it goes to [netsend]. We do this using the [oscformat] message. This needs an argument to give the osc path of the data. We want to send it to the CV out of channel A on the OSM, so the arguments are [oscformat osm a cv]. We then to to add “send” to this list, so we use [list prepend send]. Finally, we need to remove the word “list” from the list, so we use [list trim]. Remember, you can use the [print] object to see the outputs at different stages and what they look like.

listformat8.) Next, we want to be able to send triggers with our sequencer. We can use a combination of [toggle] and [f] to do this. [toggle] will output 1 or 0, and this can be stored in [f], with 1 being a trigger.

triggerstore9.) We create 8 of these, one for each of the 8 steps of the sequence. We can then use the clock to trigger them. If we connect [r clock] to [sel 0 1 2 3 4 5 6 7], the [sel] object will have 9 outlets (the last being for inputs outside the range to pass through), and send a bang out of each corresponding outlet: a bang from the first outlet when it receives a 0, from the second outlet when it receives a 1 and so on.

manytriggers10.) We can now connect this to the same objects to format it for osc, except the [oscformat] object is sending it as a trigger, so will be [oscformat osm a tr].

list_format 11.) We’ve now built our sequencer! Make sure you are connected to the WiFi network created by the OSM module, click the “connect 8000” message, and you should be ready to go! Use the toggle above the metro to start the sequencer, trigger note ons by clicking the toggles, and use the array to change the CV output. You can hear the sequencer in action in the video, controlling the PolyBlep patch available here: https://hoxtonowl.com/patch-library/patch/PolyBlep/

fullpatchYou can duplicate this to create a second set of trigger / cv sequencers for the OSM, using the [oscformat] objects with the arguments [oscformat osm b tr] and [osmfromat osm b cv].

Posted in Tutorials | Comments Off on Pure Data Tutorial 3: Open Sound Module

Pure Data Tutorial 2: Sampler / Looper

In this tutorial, we’ll make a sampler / looper. We’ll be building on the last tutorial which you can watch again here, and assume you have Pure Data installed and know how to load the finished patch onto the OWL using hoxtonowl.com.

1.) Pure Data stores audio in an object called [table], so begin by creating this. It needs a name – which can be anything (I call mine sampler) – and a length, in samples. The sample rate of the the OWL is 48,000 hz, meaning that every second of audio is cut into 48,000 slices or samples. So, if we want to record up to 3 seconds of audio, we need the size of our table to be 144000 samples (3 * 48,000).  2a2.) To get audio into Pure Data and the OWL, we use an object called [adc~]. This has a left and right output, which correspond to the left and right inputs of the OWL. To record the audio input into the [table], we connect the [adc~] to the [tabwrite~] object. [tabwrite~] needs a name which tells it which table to write into, so here we call it [tabwrite~ sampler] – if your [table] object has a different name, you’ll need to use this.

3.) We need a way to turn the recording (writing to the table) on and off, and for this we will use the push button on the OWL. To access the push button, use an object called [r Channel-Push] – the “r” is short for receive. This receives a 1 when the button is pushed, and a 0 when it’s released. To convert the  1 and 0 into something that [tabwrite~] can use, we use the [select] object, which can be written as [sel]. [sel] examines the numbers coming into it, and looks out for certain ones. It needs to be told what to look for – in this case, 1 and 0. It will output what Pure Data calls a “bang” when it sees a one or a zero. Because it has two “arguments”, 1 and 0, it has three outputs. The far left output sends a bang when the input is 1, the middle output when the input is 0, and any other inputs go out of the far right outlet.

2c4.)  We can use the bang caused by the 1 to start [tabwrite~] recording, and the bang caused by the 0 to trigger a “stop” message. Notice how the message box looks slightly different to an object box. You can create messages using the “put” menu or keyboard shortcuts. Different objects have different sets of messages that affect their behaviour: right clicking on an object and looking at the help file will show you these messages. You don’t have to remember them all, and you’ll quickly pick up what sort of messages objects require (many, like “stop” to stop recording, are quite intuitive). To read samples from the table, we use the [tabread~] object, connected to the [dac~] for audio output. Again, [tabread~] needs to be told which table to read from, so in this case we call it [tabread~ sampler].

2d5.) The input to [tabread~] tells it what point of the table to read back from, so to play back our recording we need an object which creates a repeating ramp from the beginning to the end of the table. We can use the [phasor~] object to do this, which creates a continuous ramp from 0 to 1 (notice how it’s got a tilde, which means its audio rate, so its outputting numbers 48000 times per second, giving us smooth playback). However, we don’t want it to go to just 1 – the end of the first sample – so we will multiply it by something. That something is dependent upon the length of the recording (which will of course change each time you make a new recording). We will create a [*~ 1] object for now, but notice how there is a right inlet. By inputting a number to the right inlet we change the “1” (even though that change isn’t visible on screen), and thus change what we multiply the 0 to 1 from the [phasor~] by.2da

6.)  As we just mentioned, the length of the recording will change each time we make a new recording, and we want to know what this is. The [timer] object will help us here. This has two inlets – right and left. The left inlet starts timing when it receives a bang, and a bang to the right inlet outputs the time in milliseconds, so we can connect it to the [sel] object controlling recording. In this way, starting recording starts the timer, and stopping recording stops the timer and outputs the length of the recording.


7.) Now, an output from the [timer] object tells us we’ve finished recording and want to start playing back the sample, so we want this output to make a few things happen. We want it to control the frequency of the [phasor~] – that is, how long it takes to get from 0 to 1 – so the recording is played back at the correct speed. We also want to know what to multiply the [phasor~] output by, so it plays the whole length of the recording. To make the one number output do several things, we use the [t] object (short for trigger). If we write [t b f f], it will output (in right to left order, from the different outlets) two floats followed by a bang. The float – or floating point number – is the time from [timer]. Inputting this float (which happens when recording is stopped) will then cause a series of events (the output of two floats and a bang) which will make sure the full length of the recording is played back at the correct speed. To begin, we use the third outlet – an f – to multiply the [phasor~] output. The length from the timer is in milliseconds, so we multiply it by 48 (because of the 48,000 hz sample rate), to get the length (in samples) of the recording (every 1s, or 1000 ms, is 48000 samples) which we can multiply the output of the [phasor~] by, so the 0-1 range of the [phasor~] becomes 0-end of recording.

2f8.) We can use the remaining bang and float to trigger a maths operation that gives us the frequency of the [phasor~]. We do this by dividing 1000 by the length (in milliseconds) of the recording. This is when the right-to-left order of the outputs is important – the “f” is sent to the divide object’s right inlet, before the “1000” to the left inlet which triggers the calculation (for most Pure Data objects, it is an input into the right inlet which will make them do something). This is sent to the left inlet of the [phasor~] to set the frequency.2g
9.) We can test our patch if we want. We can use a toggle object to simulate what we’d get from [r Channel-Push], and if we turn audio on (using Media> Audio On, or clicking ‘computer audio’ in the main Pure Data window), we can use the toggle to record and loop our recording. Clicking on the [table] object will let you view the waveform of the recording.

You can download the patch from our patch library here: https://hoxtonowl.com/patch-library/patch/PD_Sampler_Looper_tutorial/



Posted in Tutorials | Comments Off on Pure Data Tutorial 2: Sampler / Looper

Rebel Technology Educational Workshops

We love teaching and delivering workshops and are experienced in doing so. The content of these workshops can be changed according to the availability, interests and abilities of those involved. Workshops can take place over an afternoon and cover part of the topics listed, or last for a couple of days and span a range of topics. The maximum number of workshop participants is 16. For workshops 2 and 3, participants will need a computer (at least one between two.)

1.) Introduction to Modular Synthesis Workshop

This workshop covers the basics of modular synthesis such as CV and trigger, and then getting hands-on making some different patches that explore demonstrate how to start making music with modular synthesisers. This workshop is suitable for anyone with an interest in modular synthesisers and requires no background knowledge in music or electronics, just a willingness to plug, play and have fun.

2.)  Learning Pure Data for the OWL Pedal or OWL Modular

This workshop teaches participants how to build a series of basic patches in the Pure Data visual programming environment and upload them to the OWL Pedal or OWL Modular. Whilst a background in Pure Data (or a similar visual coding language such as Max MSP) can be helpful, it is not essential, and the workshop can be adapted to accommodate complete beginners, serving as a great, practical introduction to Pure Data. The patches built can be varied depending upon time and the ability of the students, and all result in useful musical instruments and tools. Patches that we usually develop include (but are not limited to) a tone generator, an FM synthesiser, a delay effect and a looper. You can see our online tutorial on Pure Data on the OWL here.

3.) Learning C++ for the OWL Pedal or OWL Modular

Much like the Pure Data workshop, this workshop teaches participants how to build patches for the OWL using the C++ coding language, but relies on a little more knowledge of coding from the participants.

4.) Modular DIY Workshop

This is a workshop where participants build their own Rebel Technology modules. The assembly is relatively easy and no previous soldering experience is required. People of all ages and abilities are welcome.

The workshop leaders

Martin Klang is the developer of the OWL Pedal and the Rebel Technology Modular system. Martin has extensive experience in leading workshops at events such as hackdays, festivals and modular meet-ups, and is an experienced programmer and maker. Martin studied at the University of Gothenburg, Chalmers University of Technology and Université Paris-Sorbonne, and spent 10 years as a software engineer and systems architect before setting up his own consultancy and then founding Rebel Technology.

Dr Adam Parkinson is an Associate Lecturer in Music and a Research Associate in Computing at Goldsmiths University . He has extensive experience teaching Max MSP and Pure Data to people of all abilities.

Posted in Educational | Comments Off on Rebel Technology Educational Workshops

Rebel Technology in Teaching and Research

We believe that our work has great potential for use as educational and research tools: for people learning to code, learning musical languages such as Pure Data, or working with Open Sound Control and new interfaces. Below is an introduction to a few of our products, and how they be useful for teaching and research:

The OWL Modular and the OWL pedal

The OWL began life as a pedal but now also exists as the OWL Modular. The OWL is completely re-programmable and allows the user to write and upload their own code onto it. The platform can run C++, FAUST or Pure Data, and can be used as an educational tool for students learning these languages, or researchers developing libraries and prototypes.

The OWL Modular

The OWL Modular

It provides a great introduction to hybrid modular electronics and how to understand analogue sound and electronics. Part of the usefulness of the OWL as an education tool is that it helps give musical goals and applications for what might seem abstract programming tasks to students, for instance, “build a delay pedal” or “build a drum machine”. This delay pedal or drum machine can then be detached from the computer, and used as an instrument in its own right.

Programming the OWL

OWL patches can be developed, tested and loaded onto the OWL using only a browser and our online tools, without the need to install any software. Patches are written in C++, FAUST or Pure Data, uploaded to hoxtonowl.com, and our online compiler generates optimised machine code packaged as MIDI SysEx. Have a look at our tutorial for writing and running Pure Data patches o the OWL.

The OWL is a class-compliant USB MIDI device, and can load and run patches dynamically. Patches are sent to the OWL directly from the browser using Web MIDI. The compiler also generates Javascript, so the patch can run in the browser with audio input from a set of samples or the microphone.

The OWL toolchain is entirely open source, and can be used offline as well as online. We can provide training and workshops for both teachers and students on using and programming the OWL.

The Open Sound Module

The Open Sound Module allows you to connect a modular system to a tablet (such as an iPad), a computer, another Open Sound Module (and hence another modular synth) or even the internet, all over WiFi. It uses the OSC (Open Sound Control) Protocol. The module has two Control Voltage inputs and two outputs, along with two trigger inputs and outputs, for bi-directional wireless communication.The module is a great tool for teaching User Interface Design: interfaces developed for tablets, touchscreens or computers can be used to control modular synth systems.

The Open Sound Module

The Open Sound Module

It can also be used as a research tool allowing for novel inputs to control a modular synthesiser. Through software such as Max MSP, biosignals, brainwaves or a whole range of alternative inputs  such as light sensors or heat sensors can be sent as OSC over WIFI to control a modular synthesiser. We’ve made set-ups that allow commercial biosensors (the Myo) to play a modular set up using muscle movements. The Open Sound Module opens up a multitude of possibilities for collaborations with theatre, art, media and other disciplines.

The OWL Digital Board

The OWL is also available as a DIY circuit board, and can be used in the teaching of electrical engineering, or for researchers and designers wishing to use the technology powering the OWL in novel ways or to develop new products.

Workshops and Educational Discounts

All our products are available at an educational discount. We are happy to come and demonstrate the range of Rebel Technology products, and run workshops on programming in C++ or Pure Data for the OWL; these can be tailored to the ability of the students. Read more about our range of educational workshops here.

We believe our technology provides a great way for students to engage with the musical possibilities of programming, turning code into musical instruments, and inspiring the next generation of musical makers, as well as opening up multiple possibilities for researchers who want to to integrate new ideas and technologies with the power and possibilities of modular synthesis.

For more information, contact adam@rebeltech.org and visit http://hoxtonowl.com to see some of the patches available for the OWL.




Posted in Educational | Comments Off on Rebel Technology in Teaching and Research