The Mumble Live Rig (Patreon)

[Please enjoy Mumble Prime, the latest Research Release from 65LABS. Research Releases are pieces of music that, for whatever reason, do not become standalone releases that we put out into the wider world, but we still feel are worth sharing to some degree, even if they are flawed in some way. Usually they have some kind of accompanying explanation or contextualisation to help whoever is interested make sense of them. Bandcamp codes for Mumble Prime will be hitting your email inboxes in the next day or two. Cheers. - 65LABS Research Release Comms Team]

-------

The Mumble Live Rig was a project started at some point during the first lockdown, back when we were still trying to establish the specific shape of what would eventually become Wreckage Systems. It had the same broad idea, which was to create and then explore a space where human agency and intention could interact with algorithmic inputs and outputs.

The Mumble Live Rig was built using Ableton and Max For Live. The aim was that musical patterns could be created algorithmically in realtime, but in such a way that their output could be curated, edited or at the very least dj-ed live; the human hand very firmly still in charge of how the musical output itself ended up being shaped.

At the heart of the Mumble Rig was a relatively simple Euclidean Beat script we wrote, (check THIS post from the Wreckage Systems Technical Overview series for a clear overview of what that exactly means). Since this specific script, EuclidToClip.js was running inside a Max For Live patch, it had direct access to the Ableton Live API, meaning it could actually control a lot of things that you would normally expect to have to do manually. EuclidToClip.js worked by taking in two numbers, the first being the number of pulses or ‘on beats’, and the second the number of steps to distribute the pulses across. Again, how this worked is explained in more detail in the previous post, but essentially the result was that the numbers fed into the script can be used to reliably create satisfying rhythmical patterns.

So EuclidToClip.js first created a pattern, and then it split it up across four different types of drum: kick, snare, hi-hat and ‘misc percussion’ (which in our case is almost always some kind of glitch sample). It then created a MIDI clip for each of these four patterns on Ableton Live channels, with each channel routing the MIDI inside the clip to a different rack of samples. Each type of instrument had its own rack of different samples associated with it, for example, the Kick Drum Rack looked like this:

This meant that sending a MIDI note 60 to this collection of kicks would play one particular sample, whereas note 61 would trigger a different one. The EuclidToClip.js script knew this and also knew the range of possible notes that held kick samples (and the ranges of all the other drum types). Each time it made a pattern, it would choose just one sample/note number for each instrument type and apply that to the pattern. The result of this was that even on rare occasions where the rhythmical pattern created has been used before, chances were that there would still have been a variety in the sound palette it had picked.

So the script created a drum pattern across four MIDI clips, created those clips inside an Ableton project, and then it did this ten times. So a single click generated something that looked like this:

What you see here are ten rows of patterns. Each row is a Euclidean variation and each column is a type of drum. While each row will sound good within itself, once you have heard a lot of Euclidean rhythms, to our ears they can quickly get a bit same-y. But here comes the human element: as you can see in the screenshot, the clips can be mixed and matched across patterns. Not all the combinations will sound good, but plenty of them do, and by blending different Euclidean rhythms you can get unique-but-still-rhythmical loops going on.

ENTER MELODY

That’s how the beats work. If you’re any good at minimal techno production then perhaps that is all you need. Alas, 65LABS rarely has the patience or restraint for that kind of elegance and so we keep piling layer upon layer of noise on top of our songs until we get that tickling in our ears and hearts that mean we have made something we like. And so next came the melodic content. Similar to our approach for the Decomposition Theory live shows, rather than create separate sequencers or algorithms, we chose to run the melodies locked tightly together with the beats. This was done by collecting all the MIDI coming off the drum pattern clips in dedicated MIDI channels, and then further collecting those four individual channels in a single ‘ALL MIDI’ channel. This simple bit of routing meant that any instruments running inside of Ableton (or externally if we wanted) could tap into any individual instrument or pattern. For example:

In this screenshot, we have two different Reaktor synths on the left. The first one is set to listen to only the kick drum MIDI, whereas the second one is listening to all the MIDI. On the right you can see the channels that are doing the MIDI routing.

This gave us rhythmical, melodic triggers that were locked exactly with the beats. But the immediate problem with this was that the notes being used to trigger the drum samples are not remotely melodic. This is solved using a very simple Max patch we made called Basic Random Note:

All this does is listen for a MIDI note trigger. When it gets one, instead of passing that note through to the instrument, it picks a different one from a random pool of notes chosen by us. There’s a few added dials to also adjust the velocity, note length, and transpose all of the possible notes up or down.

This flow of generating, cataloguing and then distributing MIDI data creates a kind of live playground where it is possible to semi-improvise but without getting stuck in repetitive loops. By letting the algorithms take care of the rhythmical skeleton of the track, it allowed us to perform by routing data, evolving sounds, and noting interesting combinations of sounds and rhythms. This initial iteration of The Mumble Rig was a prototype for what could have become a much more advanced live system if the first 65LABS project had moved in a different direction.

THE RELEASE

The release available here uses a skeleton captured entirely live using the Mumble Rig. You may well be able to hear the improvisational nature of it compared to our other, more deliberately composed pieces. That being said, a bonus of capturing live recordings as MIDI rather than audio means that all kinds of manipulation is possible after the fact. In this case, although the structure and electronic instrumentation is the same as had been originally performed, extra production in the form of reverb, sidechaining and general warming/mixing etc. was employed. You can also hear guitar, which was added afterwards remotely (this was very much a lockdown production remember).

ALGOCRITIQUE

As far as we are concerned, this is not a bad piece of music. If it was we wouldn’t share it with you at all. But the original source material fell into a weird space between algorithmic and improvisational that didn’t allow for us to sculpt, re-compose, de-compose, or find any other kind of post production technique that raised it to a quality where we felt like it could survive as a standalone release, despite multiple attempts to get it to that place. Perhaps other performances of the same algorithms would have produced more interesting work, as we became familiar with the best places to focus our live composing efforts. If there hadn’t been a lockdown and we had been able to put this rig into 65HQ and force it to interact with a very really four-piece band it could have taken us somewhere new, or it might have taken us back to the Decomposition Theory sound. As it happened, like so many other prototypes, it fell victim to our algo-dilettantism, never to be developed into a more complex, sophisticated system. Perhaps one day we will return to it, but more likely it will take its place in the 65 Hard Drive Graveyard, left for future digital archaeologists to also ignore for eternity.

Thanks, Mumble Rig, and farewell. We hardly knew you.