Tags: posts polarity-music Ambient Bitwig Generative Shift-Register Tutorial Note-Grid

Shift Register - Generative Melodies

Tutorial | Jun 24, 2024

In this video, I demonstrate how to create a random note generator using the Polymer synthesizer in Bitwig Studio. I use the Node Grid and the Dice module to generate random nodes, and the Triggers module to create eight equally spaced triggers within one bar. I then use the Shift register to record and modify the generated sequence, allowing for variations and alterations in the playback.

You can watch the Video on Youtube - support me on Patreon

In this video, I walk through using Bitwig's Node Grid to create random notes for the Polymer synthesizer without using a MIDI keyboard. Instead, I use various modules within the Grid to generate, scale, and quantize these notes, ultimately producing a more musical and controlled sequence.

Key Points:

This setup demonstrates a flexible way to create a recordable, random note generator within Bitwig's Grid, allowing for dynamic and controlled musical outputs.

Questions & Answers

Maybe you dont watch the video, here are some important takeaways:

How can I generate random nodes in the Polymer synthesizer using the Node Grid?

You can generate random nodes by removing the node input and using the Dice module to generate random values. Additionally, use the Triggers module to generate eight equally spaced triggers within one bar to drive the Polymer synthesizer.

How can I scale down the random nodes to fit within a certain range?

You can use the Attenuate module to scale down the random nodes. Adjust the attenuation level to reduce the range of the nodes and ensure they are within a desired octave range.

How can I make the random nodes adhere to a specific scale?

To make the random nodes adhere to a specific scale, use the Quantizer module to quantize the nodes to a particular scale. For example, you can quantize the nodes to the C major scale to ensure they fit within the desired tonality.

How can I record and modify the random note sequence?

In version 5.2, you can use the Shift Register module to record and modify the random note sequence. Connect the trigger module to the Shift Register to sample values. Use a select module and button to control the recording process. To playback the recorded sequence, use a merge module and a counter to step through the sequence. Additionally, you can modify the playback direction using other modules like reverse or curve.


This is what im talking about in this video. The text is transcribed by AI, so it might not be perfect. If you find any mistakes, please let me know.
You can also click on the timestamps to jump to the right part of the video, which should be helpful.

[00:00:00] So I think we just start here again with the Polymer synthesizer because we want to make some music.
[00:00:07] And instead of using the MIDI keyboard, we use here again the Node Grid.
[00:00:11] Because we want to generate some random nodes in the grid.
[00:00:17] By the way, this is here a monophonic mode. Voices on mono, voice-circuit is off.
[00:00:22] And we want to remove here the node input.
[00:00:25] And we just want to generate random nodes with the Dice module.
[00:00:29] And this Triggers module here, we want to generate eight triggers,
[00:00:36] eight equally spaced triggers within one bar.
[00:00:40] And this one gives us here some random values.
[00:00:46] And with this we can already drive here this Polymer synthesizer.
[00:00:53] [Music]
[00:01:01] So it's pretty random. And you can also hear the nodes are way out of scale.
[00:01:06] So we have like, I don't know, five octaves higher, sometimes nodes, six octaves higher and so on.
[00:01:12] So we want to scale this down by using an Attenuate here.
[00:01:17] And when we go down to, let's say, 10%, we have only nodes one octave and minimum one octave lower.
[00:01:25] So it sounds like this.
[00:01:27] [Music]
[00:01:34] So the nodes are just, you know, within a certain range, which is nice.
[00:01:39] But now the nodes are kind of chromatic, so we use the Quantizer.
[00:01:45] So we quantize here this to the C major scale.
[00:01:48] [Music]
[00:01:54] And it doesn't sound like a melody because there is no repetition in there.
[00:01:58] So usually I used, in earlier videos, I used to record for this, to record sequences,
[00:02:04] or I used Array to record sequences, right, or maybe a long delay or a delay with feedback.
[00:02:11] So everything like this you can use.
[00:02:13] But now in 5.2 you can also use, of course, the Shift register here,
[00:02:18] which is more or less to me a sample and hold with the history.
[00:02:23] So we have the current sample and hold value always in the first slot.
[00:02:28] And the old and the last value you had in this slot is now in the next slot every time you trigger it, right?
[00:02:34] So we can extend this here to 8 slots and we can basically create an 8 step recorder here with this.
[00:02:44] So all we need to do is go with the trigger module in here.
[00:02:47] You can see we're already sampling values.
[00:02:51] Here's a readout here.
[00:02:53] [Music]
[00:02:58] You can see here we are shifting basically, every time we trigger this we get a new value here
[00:03:04] and the old value is shifted here and this old value is shifted down and this value is shifted down.
[00:03:09] So this is basically how the Shift register works.
[00:03:13] We can also see this here with the trigger module.
[00:03:19] Right, so here we have D3 and if I hit this button D3 goes here and here's a new value.
[00:03:24] And this D3 goes here and this C3 goes here.
[00:03:29] So C3DDA.
[00:03:32] This is how it works.
[00:03:35] And we want to kind of implement here some record structure.
[00:03:40] So I use a select and I use a button because I want to say this is the record button.
[00:03:50] Every time I press this button I switch it to the second input slot and this one gets here the triggers input
[00:03:56] and goes into here so I can now say record a sequence and then stop recording the sequence
[00:04:02] and then leave all the values in these slots.
[00:04:07] To read out all these slots here I usually use a merge.
[00:04:12] It has also eight values and then I just connect these outputs with the inputs here.
[00:04:19] And then I use maybe a counter here.
[00:04:26] Also eight slots or eight steps.
[00:04:29] This goes in here.
[00:04:31] This one goes to nearest interpolation and then we can just trigger this here and step through the sequence.
[00:04:37] So this counter here creates more or less a stepped ramp signal.
[00:04:44] Looks like this.
[00:04:46] It goes upright.
[00:04:48] Every time we trigger this here it goes slightly up.
[00:04:51] Then when we reach the top the highest point which is our eight here, then we go back to the zero value.
[00:04:58] And each of these points here in this step signal is basically a position here in this merge module.
[00:05:08] So this is how we get the values out.
[00:05:12] So we can trigger here this again.
[00:05:15] [Music]
[00:05:24] So it's basically the same melody over and over because it uses here this shift register and we don't record.
[00:05:32] So we can now use the record button here to actually update this melody.
[00:05:36] [Music]
[00:05:58] So this is how you can record this or make a recordable random note generator.
[00:06:05] This is an easy setup, I would say.
[00:06:08] Here's a bit of randomization.
[00:06:10] Then we scale it down.
[00:06:11] Then we quantize everything, record everything into a shift register, read it out.
[00:06:17] But now we have also the freedom here to tweak this output a little bit.
[00:06:22] So instead of just playing this here, this eight step sequence over and over, we can make some modifications to it
[00:06:31] because we can modify here this phase signal and change the playback direction.
[00:06:38] So you could use, so this is just one idea.
[00:06:42] You can do this in all kinds of different ways.
[00:06:45] You just can use here maybe a reverse thing.
[00:06:52] So this just reverse is basically the phase signal.
[00:06:56] Looks like this.
[00:06:59] This is the original signal, right?
[00:07:03] And this is the reversed signal.
[00:07:09] That's just the opposite way.
[00:07:12] Then it plays back here the sequence reversed.
[00:07:16] [Music]
[00:07:24] So we can use here, let's say, a select in.
[00:07:31] So we just use here the first input and the second input is this reversed signal.
[00:07:38] Maybe give this a different color and then go in here.
[00:07:43] And then decide by, let's say, a dice module here if we actually use the real signal or the reversed signal.
[00:07:53] Right, it switches back and forth and then we get some random playbacks.
[00:07:58] [Music]
[00:08:03] But again, this gets too random because we have this dice module here.
[00:08:07] So in my opinion, it's probably better to use something different.
[00:08:11] So my idea was to use just a curve module, a curve module.
[00:08:16] Looks like this.
[00:08:18] So this one has here already synchronized playbacks.
[00:08:22] We can type in here bar and say we want to have two bars because at the moment we have an eight step sequence that is exactly one bar long.
[00:08:31] So we can do this here, one bar, go in here, reset and just emulate or simulate this ramp signal here, go in here.
[00:08:42] It does basically the same thing as before.
[00:08:45] Let's maybe put this here.
[00:08:50] [Music]
[00:08:58] So now we can say we want to make this two bars long.
[00:09:02] So when we say this is two bars long, we basically stretch out this ramp signal here over two bars, which means this sequence is playing slower.
[00:09:13] But we can do something like this and say, okay, this is two bars and this is one bar.
[00:09:21] So we can do something like this.
[00:09:23] So now we have the same thing as before.
[00:09:26] But in the second part here, we can say we want to play maybe in reverse.
[00:09:32] So play forward, play forward.
[00:09:34] And then in the half of the sequence here, we play backward.
[00:09:38] So you can see, right?
[00:09:40] Forward, next forward, stop and back.
[00:09:44] So this is how this works.
[00:09:46] [Music]
[00:09:54] So now you can basically create a small alteration at the end of the second bar.
[00:10:00] I think we can also say this is now four bars long and say this is one, this is one bar.
[00:10:07] This is one bar.
[00:10:09] This is one bar.
[00:10:11] Let's divide this here even more.
[00:10:15] Eight.
[00:10:17] Something like this.
[00:10:19] Then we also need to re-trigger this here probably.
[00:10:27] And for this, I want to use a transport.
[00:10:29] And I dial in here, let's say one bar.
[00:10:34] And we have four bars.
[00:10:36] So I type in four bars.
[00:10:38] So we get here trigger.
[00:10:40] Every time four bars are ending or when you go back to the first bar.
[00:10:46] So we re-trigger the golf's module.
[00:10:49] And then let's see how this sounds.
[00:10:51] [Music]
[00:10:59] And we probably want to use also sample and hold.
[00:11:03] [Music]
[00:11:27] So now we can record here the sequence or record the new sequence.
[00:11:31] [Music]
[00:11:44] And we can do something different here.
[00:11:47] [Music]
[00:11:53] So all I want to do is basically to make here the last...
[00:11:57] [Music]
[00:12:00] The last sequence a bit different.
[00:12:03] [Music]
[00:12:22] So a problem with a random note generation in my opinion most of the times is that you have a problem with the scale.
[00:12:30] Let's say we randomize here the note generation.
[00:12:33] You get sometimes a lot of notes that are not the root note.
[00:12:37] As you can see here, we barely actually generate the root note.
[00:12:43] So the root note here also decides which kind of mode we are playing in the scale.
[00:12:48] So usually C major is not only...
[00:12:51] The keys of C major is actually not only C major.
[00:12:54] It's also C major.
[00:12:56] It's the Dorian, it's E Phrygian, or F lydian, or G Mixolydian, or A Minor, or B Locrian and so on.
[00:13:05] So it depends basically what note we are playing for the first or what the key sender basically is, what kind of mode we are playing.
[00:13:14] So in my opinion it's maybe best to disconnect here some of the notes and give them the real root note.
[00:13:23] So let's say we want to play C, right?
[00:13:26] So we put here the C in the first slot.
[00:13:28] So we have at least the root note in there at the beginning of the sequence.
[00:13:32] So the listener knows, oh okay, we are probably inside of the C major scale and not in Dorian or an E Phrygian.
[00:13:42] So this is something you can do.
[00:13:44] You maybe can also bring this in at a second point or something like this, right?
[00:13:50] To remove a bit of the randomness and make the listener more aware of the scale.
[00:13:55] So C major scale is also the same...
[00:14:07] or shares the same keys with A Minor so we can put in here an A
[00:14:12] and just make this more or less like an A Minor scale.
[00:14:35] It's probably also nice to have here the dominant end there so we can use a transpose.
[00:14:41] So instead of A we always play here the fifth.
[00:14:50] [Music]
[00:15:17] So with this Curve Modulator basically I'm trying to get more out of this eight note sequence.
[00:15:24] Basically we generate eight notes and then we play them back in a different kind of manner
[00:15:30] while trying to make it or keep the repetition so it sounds more musical, right?
[00:15:36] So this is the idea behind this.
[00:15:39] Okay.
[00:15:41] So at the end here I want to extend this to this note generation here also for let's say a velocity.
[00:15:54] So instead of going in here with the pitch quantizer also go in with the dice.
[00:16:01] So I use a different dice module here.
[00:16:05] Let's call this velocity.
[00:16:09] This is the same output.
[00:16:12] Can I rename this here?
[00:16:14] Yeah.
[00:16:16] Velocity.
[00:16:18] And then we do the same thing for let's say pressure or tumble.
[00:16:33] This is the same input.
[00:16:34] This is the new one.
[00:16:39] And then we just connect here velocity with velocity.
[00:16:44] And what's the pressure here?
[00:16:50] I think this is tumble, right?
[00:16:52] Okay.
[00:16:54] So now we generate here basically let's record something.
[00:17:03] So we recorded here sequence of random values for notes for velocity and for tumble and then we're sending this out here.
[00:17:13] So here we can use tumble for let's say the index maybe.
[00:17:20] And we can use velocity for the modulation amount here for the filter.
[00:17:48] I think this is a great way actually to use the shift register for note generation or for step sequences inside of the grid.
[00:17:59] Because you can just here record easily new values and then extract it with a merge module.
[00:18:06] And then try to play around here with the face signal to play these sequences back in different manners.
[00:18:14] I think that's it.
[00:18:15] If I put this patch here in the description below so you can download it and can play around with this.
[00:18:20] And yeah, try to leave a comment and leave a like, subscribe to the channel.
[00:18:25] Thanks for watching and see you in the next one.
[00:18:27] Bye.
[00:18:28] [Music]
[00:18:38] [Music]