Tag Archives: algorithmic

Video Tutorial: Antonio Blanca’s NOD-E

Leave a reply

In this video, Brent Kallmer of BluewaterVST takes us through the wonderful NOD-E ensemble by Antonio Blanca, an algorithmic music machine that generates MIDI note data based on the positions of nodes moving on the instrument panel.

Says Brent:

You might think of NOD-E as the sequencer that you get when the nodes in Spiral reach escape velocity and break out of orbit. In NOD-E, 8 nodes travel around an XY-field and trigger notes when they cross certain boundaries (defined by you). Movement along the X-axis triggers notes; movement along the Y-axis determines the triggered note’s velocity (in other words, a note that is triggered at a high Y-value will play more loudly than one that is triggered at a low value. The nodes are propelled throughout the XY field by two polyphonic LFOs (one for each axis).

The cool thing about NOD-E is it can sound like anything – you can route the MIDI data to other plugins, even to hardware synths – or record and edit the sequence in a sequencer. Big ups to Brent for this great video introduction to the ensemble.

Sending Random Notes from Reaktor part 2: Turning Off Notes

Leave a reply

Last time we looked at sending random notes from Reaktor, everything was hunky dory except the ensemble didn’t send note-off signals to its destination.

Note-offs are required because otherwise you end up with stuck and hanging notes. If you’re sending to a synth patch you could inadvertently create drones. If you’re sending to a drum synth or other percussion instrument, you might not hear a drone when the note fades but it might still be active, consuming CPU. This has happened to me when I’ve tried to trigger Drumspillage from Reaktor.

The fix is very simple and uses part of the same structure we used to send MIDI out from Krypt – a note-off macro.

There’s also a NoteLen control, unlike the earlier version in Krypt. This control determines the length of the triggered note, so it doesn’t require a new note to turn off the previous one.

Now let’s have a look inside the NoteOff macro:

It’s a bit complex, but the gist of it is – the Value modules on the right, just before the merge modules and P and G terminals, hold the value of the previous note and a zero. The Order module is wired up so that when a new note is received, the macro first sends out the pitch of the previous note with a zero velocity. That’s one way to send a note-off. The macro then sends out the new note with whatever velocity came in through the G terminal.

The Hold module holds the note on for however many milliseconds you’ve set as the length of the note, then drops the value to zero, which again sends out a note-off.

You can download the updated ensemble here and experiment with it yourself.

Update: here is a version of the note off macro that is more suitable for popping into other sequencer ensembles, which often have trouble with stuck notes when sending to external synths and hardware.

Sending Random Notes from Reaktor

Leave a reply

Here’s a quick structure and mini tutorial that demonstrates how to send a random note from Reaktor on triggered input – you can use OSC or MIDI to map a control to the trigger button here:

…and the RandomNote will then send a note to the ReceiveNote instrument – or, in the properties, you can set up RandomNote to send the note to a different instrument, or a different plugin, or even a hardware synth. Use the Connect tab of the RandomNote instrument properties to select a destination.

The center pitch and rand. range knobs control the range of notes that can be selected randomly.  The velocity knob sets the volume of the triggered note. This is not a finished instrument, but a demonstration of a technique. A recipe ingredient, if you will.

Here’s what it looks like inside:

The Trigger button triggers a core cell that outputs a random value between -1 and 1. This is multiplied by the Rand Range knob to produce a value, in this case between -12 and 12. A quantize module turns this into an integer, a whole number, which will correspond to a MIDI note. This value is then added (or subtracted if it’s negative) to the value from the Center Pitch knob. An Order module sends the note value first to the P(itch) input port on a Note module, and then to the Trig(ger) input on a Value module that holds the Velocity, or volume, of the triggered note. The Note module only sends when it receives a value at its G(ate) port, and it sends a note with whatever pitch was at its P input at the time.

Download the ensemble here and start hacking away at it. Replace the Rand. Range and Center Pitch controls with a scaled LFO, and the Trigger button with a clock, for example. Another recipe ingredient that might come in handy here is my Roux basic sequencer macro.

You’ll quickly notice, in sending this control signal to a synth, that it’s missing a note-off. We’ll add that next time!

Algorithmic Music in Reaktor

1 Reply

It occurs to me that it’s been ages since I posted an actual, you know, Reaktor tutorial around these parts. Which is what this blog was originally created for! So here’s something nice and meaty: a tutorial on basic algorithmic music generation techniques in Reaktor.

What this tutorial and its associated instruments will do is give you a basic feel for how events in Reaktor can be wrangled and manipulated into musically meaningful forms. What it WON’T do is compose your next masterpiece or write a top ten hit:

However, what you might do is take some of these techniques and create instruments that go further towards realizing your musical ambitions. I’ve always thought of Reaktor as a tool that blurs the distinction between instrument and composition. If you think along the same lines then you will find this information useful. Happy building!

Download the tutorial here (PDF and instruments)