Bitwig 2.5 generative music primer

This will be a tutorial on a way to create generative music on Bitwig.

It will sound like this:

Everything here is written from the point of view of version 2.5 and upwards. Later versions might have different tools with what to expand of this considerably (The Grid in V3, etc). There’s a link to the completed project at the end of the post.

We need:
Notes.
Pitches.
Movement.

I’m writing this from the point of MTPLTLT (Music That People Like To Listen To), but you can go as experimental as you want.

Basically, we’ll be using the DC and Replacer devices to create the basics, and then build on that with various other effects and modulators.

The Replacer device generates a MIDI note whenever the audio it receives passes a certain threshold.

Let’s create a pulsing pattern.

Create an instrument track, turn the volume completely down (to avoid some sudden clicks that the DC device creates.)

Create a DC audio effect. The DC is a device that creates a constant value, which we can use here.

Now, insert a Steps modulator in the DC.
Create an 16-step pattern that looks like this, and modulate the DC value at +0.5:

Leave the play mode to “transport” this is a good value to use on all modulators in the track, so that starting the playback from a certain position always gives the same results.

Press play on transport, you will see a pulse of audio being generated.

Now create a replacer device after the DC.

Create a Polysynth after the Replacer.

Now turn up the volume, you will hear a single note being played.

The first thing to try is to tweak the speed of the Steps pattern. You will notice that it can’t keep up with fast notes. Decrease the “Hold” value in the replacer to something around 10ms for example. Now the minimum distance between note is 10 milliseconds.

Turn the speed of the steps back to “1.00” to keep things in check for the time being.
Now think of any melodic phrase. The way human mind works, we tend to look for patterns and we like repetition. Also most melodic phrases in MTPLTLT tend to consist of rising and falling patterns, with a lack of very abrupt steps. Anything more broken we tend to start to hear as arpeggiated chords or several melodic patterns interwoven. This of course only perception, and one way of looking at things. But it’s something good to keep in mind if you want to avoid sounding too random.

What goes up and down? A LFO (or a Steps pattern, or sidechained and filtered audio… Well you get the idea, but we’ll use an LFO).

Create a LFO modulator inside the Replacer.

Switch the bipolar setting to “off” in the LFO, this way the generated notes never go below your root note, which helps to keep things in control. Modulate the “Key” value in the Replacer with +12.00. That’s semitones by the way.

Set the LFO shape to a descending saw, set the running option to “sync”, set speed to 1.0 and set the sync value to 2nd.

You will hear a random sounding descending melody, the Replacer now looks about like this:

Now let’s create some harmonic movement.

In the “Note” chain of the Polysynth, create a Note FX Selector layer.

Place a Transposition map inside the Note FX Selector.

The Transposition Map works the same for every octave:
It transposes notes to new values. the original values are on the horizontal row, destination notes are on vertical.

The values are counted upwards from the “Root” value. So for a root of C, this:

Would only allow notes C, D# and G through.

That’s a C minor chord of course.

Name this layer Cm, and duplicate it.

Create some other chord in the second layer and rename it accordingly.

I made a G minor seventh (G, Bb, D, F):

I created in the same routine two more chords for a very typical harmonic movement.

Now create a modulator for the Note FX Selector, and modulate the index of the Note FX Selector with a value of 3.0, ie. max you can use with four layers:

Make sure that you have the first layer of the selector selected (the yellow dot indicates this), since the modulation is relative to the selection.

This sounds remotely interesting already.

Remember that the Transposition Map deals inside octaves, so you can’t really control accurately which one will be your root, so you will get inversions (where the root of the chord is not the lowest note) of the intended chords too.

If you just want to in general limit the output to a scale with all it’s notes, you can simply use the Diatonic Transposer instead.

Next, lets’ work a bit with that descending pattern. We’ll insert a Steps device that modulates the “Key” value of the Note Replacer in addition to the LFO:

Notice the length of seven steps, this will create already a more organic pattern since this uneven value will play against the gate 8-step gate (gate is a term used in modular synthesis to basically call any pulse wave pattern, typically used to trigger envelopes, etc, in this case we are using it to fire the Replacer) pattern. I modulated the “key” parameter with a value of +7.0 to avoid too sudden jumps.

The pattern is still static and kind of boring. The reason is, we’re just playing a slow arpeggio pattern here.

So from here on, we start to have a ton of options. Let’s add a modulation that allows the full scale of C minor to be used instead of the chords for the last beat of the measure. This creates a bit more complexity.

Create another Note FX Selector layer, and place the first one inside it, then create a Diatonic Transposer in the layer, and automate the index, so the “Full Scale” layer is active only 25% of time:

I also added one more slow LFO (rate 0.05) to modulate the Replacer key value at +7.0. So now the whole pattern we created earlier will travel up and down.

Now to create some polyphony and groove, place a Note Echo thus before the Note FX Selector in the chain:

Now there’s already a nice movement going.

By modulating the LFO shape, we can create a more natural movement of the melody:

There’s a few funny notes here and there, but then again: the trees don’t grow in a line in the forest either.

Let’s make next a harmonic pad backing.

Duplidate the previous track and mute the original one.

Slow down the gate pattern to 8ths and place one long step in the beginning with no breaks so there is some sustain:

Edit the sound to a pad, string or something else with sustain.

Remove the Note Echo from this track.

Place a Multi Note before of the Note FX Selector:

In addition to the fundamental we have an octave there, along with a fifth and a compound (spanning over an octave) minor third.

The harmonic filter we created will keep things in check. You can disable it if you want, but you will probably get non-diatonic chords then.

(At this point I edited the arp sound for some stereo image with the Voice Stack modulator, using 2 voices per note.)

There. A wealth of options are available to modify the setup further. Add more arp voices and make polyrhythms by setting the speed value of the gate pattern to something like 1,25, 1,5, 2,25 or whatever sounds good. Make drum patterns. Construct the whole thing in a different way and place all chains inside one parallel Instrument Layer, so you can have common macro controls at the main level to control all of the instruments at once (if you don’t do this, editing a song based on patterns like this becomes a chore since you need to edit a lot of automation points that all have basically the same values on different tracks).

V3 will make things more interesting, but nothing in here should get old either, and probably even with the Grid the macro level might be best built on layers and selectors. We will see.

Download the project here.