Bitwig

Currently Bitwig is my DAW of choice. It runs on Linux, the stock synths and devices are of high quality and it has a truly innovative design, with its concept of modulators everywhere, becoming a true modular playground in DAW form.

The Grid

One of the most powerful devices in Bitwig is “the grid”. Using the grid we can tap into a modular playground akin to using VCV rack, MAX/MSP or Pure Data, but with a much more intuitive design (In my opinion). It allow us to design our own synths and FX from several modules and it’s great for quickly making generative music.

Here you will find a collection of useful constructs that I’ve found when learning the grid. Additionally if you are interested to see these put into action you can check out these videos of some generative patches that I made in my explorations:

• Bad Diode // Bitwig generative patch 001
• Bad Diode // Bitwig generative patch 002
• Bad Diode // Bitwig generative patch 003

Patreon and kofi subscribers get access to an exclusive preset file with all these reference patterns so that you can try them at your convenience.

Euclidean Rhythms

Euclidian Rhythms are easy to set up in the grid, although rotation can be a bit more involved. Here are several versions of Euclidean generators of different complexities.

All it takes is a base clock trigger (for example 16) and another trigger for the subdivisions. For example a 7:16 or 3:8 Euclidean rhythm (division:base).

We can use a gate device in trigger mode to remove certain notes we don’t want to play. Additionally we can set a 16:16 rhythm and use this gate as a pseudo-sequencer.

Using the transport LFO we can control the slowdown/speedup of our signal. For example we can have a pattern that plays over 2 bars (2/bar) or every 4 bars (4/bar) or twice every bar (1/2nd) or any number of combinations.

To perform rotations we need to use a phase shifter node. A phase is exactly N = Base steps. In this case Base = 16 so we quantize a value knob to rotate in the right increments. If we change the base the constant has to be updated accordingly.

Array recording

The array device is conceptually simple but a bit confusing when initially looking at it.

Using a phase counter and making sure we set up the same number for the counter number and array size, we can use the array for recording N random notes and then repeat them constantly.

In essence, when recording we are also passing through the same signal and when if there is not a trigger at that time a note will be read from memory instead.

The second method shown on the right allow us to automatically record a new melody each N bars (Or whenever we want using the combination of gate triggers and transport).

Source: How To Make a Turing Machine in Bitwig Grid (Dash Glitch)

Bernoulli gates

The concept of Bernoulli gates consists on splitting a signal into two path depending on some probability amount. We can bias the signal towards one or the other path by adjusting the chance probability.

In their simplest form these can be implemented with a split and a chance module (Left). We can also combine multiple Bernoulli gates in a multitude of ways, for example cascading them or making them have a probability for the same signal being chosen more than once (Right).

A practical use for this is to create interesting Closed/Open hi-hat patterns.

Source: Bitwig Grid 101: Bernoulli Gates (Tâches Teaches)

Probabilistic gate merger

This construct allow us to combine different trigger probabilities. For this example, the top pattern will play 90% of the time, the middle one 70% of the time and the bottom one 25%, but note that the probabilities are calculated each N bars by using the Transport (LFO) configured as N / bar.

This shows a gate trigger that could be connected to a kick, for example. With three gates we have a total of seven different patterns we can generate. With 4, we would have 16 possible patterns (Think binary!)

Source: Generative Pattern Combining in the Bitwig Studio Grid (Polarity)

Melody generation

Simple approach

Probably the simplest random pitch generator uses some sort of trigger or gate, a dice module and a pitch scaler + quantizer.

To avoid repeating the same note more than once we can use a delay and some logic to obtain a new trigger. This can create some interesting rhythmic responses.

Using S/H LFO

If we don’t care about repeating the same melody multiple times or having a higher probability for certain notes than others, we can use a simple random LFO and the usual combo of pitch scaler + quantizer.

This by itself may be a bit jarring sometimes, but we can also use these random notes to add variation to an existing fixed pattern some of the time as seen below.

A fixed note method

This approach to generate melodies allow us to select a fixed number of notes (in this case 6) and generate a different pitch for each of them, constrained within the given range by the pitch scaler and the selected notes on the quantizer.

The notes can be manually changed with a trigger or, like shown here they can change any N bars by using a phase scaler with a 1:N ratio or a Transport (LFO) setup as (N / bar). When the phase reaches the apex (1.0) we trigger the new pattern.

Using sinemod phase modulation

Another easy way of generating random repeating melodies is to use the sinemod phase device with a sample and hold to retain the value and use the combination of pitch scale/quantizer to adjust note range and scale.

Using the gates device as triggers we can play sequences that contain silences and not just streams of notes. The triggers can be changed to taste, for example to use Euclidean rhythms for polyrhythms.

Modulating the sinemod amount we can create different patterns but all of them will start with the same note. If we add and modulate a phase shift device we can then completely generate new melodies easily.

The idea can be extended to also using the sinemod for rhythm generation provided we have some form of clock quantization. This is usually my preferred method.

Using a delay chain

Here is another example of a probabilistic melody machine which progressively reduces the chances of a note being played through the delay chain.

In this case we have a fixed Cmaj9 chord spelled out, but you can, of course, set up your own notes or even use a random pattern within a key.

Source: Bitwig Grid 101: Yet Another Probability Based Melody Machine (Tâches Teaches)

With probabilistic sampling

We can select a random note from the scale with different probability values with this system.

The output of the sample and hold can be used with an addition S/H triggered by a N=16 clock quantizer or another clock division (e.g. euclidean rhythms).

The method displayed on the right combines the probabilistic sampling with a recorder to allow us repeating the same melody for N bars.

Source: Try these 2 ways of creating melody & rhythm - Bitwig Grid (Polarity)

Creating a chaos machine

This chaos machine uses two random LFOs to modulate the X/Y position of the pad. On a zero crossing from any direction a note will be triggered.

This could be extended for different positions or modulating some parameters/changing the range/changing the scale depending on where in the X or Y axis are we.

Source: Bitwig Grid 101: The XY Pad Can Do Something Pretty Cool (Tâches Teaches)

Sound design

Pitch delay chain

FX like delay are not limited to audio signals, they can be used for anything, including pitch signals like shown here. We are using cascading delays to create a sort of analog shift register.

This can be used in creative ways and with modulations and adding randomness they can be used for example for haunting random melodies.

This method also allows us to further manipulate the signal, for example by controlling the output of the delayed notes with gates. Not possible with a regular delay FX!

Source: Bitwig Grid 101: A Simple Analog Shift Register (Tâches Teaches)

Chaining/repeating envelopes

We can create an envelope that is constantly triggering after it reaches zero while a gate is being held by using a long delay (to enable feedback) and a bit of logic.

In this case its shown with the gates device but we can also use a gate-in for building a playable instrument.

We can extend this concept chaining multiple envelopes, creating a repeating multi stage envelope, as seen below.

Source: Modular Concepts: Musical Maths

Morphing/blending wavetable synths

Here is an interesting way of blending between four different sounds using the XY pad. By modulating the X-Y positions we can get interesting sounds, specially when we also play with the modulation within each synth or sound.

In these example we are blending four wavetable synths, but this technique could be used with any sound.

Source: Bitwig Grid 101: Basic Vector Synthesis With The XY Pad (Tâches Teaches)