Probability based melodies in the Bitwig Grid

Tutorial | May 30, 2025

In this video, I walk you through a simple and straightforward Bitwig Grid setup for generating probabilistic melodies by storing scale notes and assigning individual probabilities to each. I show how to record and synchronize these generative sequences so you can capture stable, repeating patterns with easy logic for playback and triggering new sequences. This patch is perfect for creating evolving melodies, and you can download it on my Patreon if you don't want to build it yourself.

You can watch the Video on Youtube

• support me on Patreon
• Download the Grid Patch

Summary #

Maybe you don't watch the video, here are some important takeaways:

Hey everyone, welcome back! In today’s video, I’m going to walk you through a simple and powerful Grid setup in Bitwig Studio, a generative note/pitch array with probability control and synchronized recording/playback. I’ve covered something like this before a few years ago, but this method is more stripped down and easy to follow, so even if you’re new to the Grid or you just want a faster workflow, you’ll find this useful.

First, I start by creating a new track with the Poly Grid device. The basic sound engine uses just the sine oscillator connected to the amplitude envelope; nice and simple. What I really want to show you is how to create and then control a bank of musical notes, let’s take D# minor as the example scale. I use the ‘Pitches’ module, which is something I end up using constantly because of how versatile it is. But in this case, I’m not using it as a sequencer, but rather as a storage array: it “holds” the seven notes that make up the D# minor scale, one per step.

I’m deliberately not connecting anything to the phase input on Pitches because I don’t want it to behave like a stepped sequencer here. Instead, I want to scan through these notes under probabilistic control. To drive the scanning, I use a clock signal, outputting a phase signal (from 0 to 1), and ramp the rate up to, say, 32 Hz, so it zips through all seven notes rapidly. This goes to both the note array (Pitches) and, importantly, a Probability Data Sequencer that matches the number of notes (seven steps, one for each pitch).

The Probability Data Sequencer lets me set the likelihood of each scale degree being selected. For instance, I can set a high value for the root, maybe lower ones for the fourth or seventh, and so on, so I can musically bias the result. Both the notes and their associated probabilities are scanned at the same rate, always paired up.

The next challenge is to decide, at each scanned step, whether the note is played, sample and hold (S&H) modules are the key here. The probability signal triggers the S&H to either pass the pitch value forward or not. I usually have another S&H (downstream) to “freeze” the chosen pitch, so it holds until the next trigger (like a gate). When you dial up the clock speed, the system zips through notes, but the output is meaningful, because every note’s probability gate is respected.

To make things more musical, I tweak clock speeds, try saw waves for rhythmic variety, drop in a low-pass filter for subtle animation, and add effects such as reverb or delay. This already makes for interesting generative melodies or melodic textures, similar to my older “Melody Maker” script, with playability and repeatability right in the Grid.

However, purely generative patterns, while great for inspiration, aren’t always ideal for musical structure. You want repeatable, loopable sequences. To solve this, I use a Recorder module inside the Grid, not to capture audio, but to record the live sequence of pitches being generated. Triggers are used to control when recording starts and stops, and I use a Latch module to manage the state: push a trigger to start on the downbeat, stop exactly on the bar. This is achieved by comparing the bar phase to a constant, so the loop always starts and ends in the right place for seamless looping.

To prevent recording from starting mid-bar (which would break the loop), I use a “clock one ties” trick: this module holds the trigger until the next bar begins, ensuring clock-tight loop capture every time, no matter when I hit Record. I admit this could probably be implemented more simply, but it works and it’s reliable.

For playback, I just need to loop the Recorder output (instead of the live generative signal), using another trigger synchronized per bar, this is done with a NOT gate for a clean one-bar trigger signal.

At this stage, I have a loopable, repeatable melodic pattern that I can re-record anytime for new variations. For more excitement, I add optional octave shifts via a Chance module: with a certain probability, the loop plays in a higher register. This adds even more variety but with the consistency of looping.

To automate things for live performance or generative pieces, I use Bitwig’s Transport and bar triggers: every 32 bars, for example, the patch can auto-record a fresh sequence, keeping things evolving in long jams. The user just needs to tweak the probability sliders, scale notes, or clock speed, amazing for inspiration and live settings.

I finish by noting that this patch, particularly the probability array and sample-and-hold setup, forms a reusable core you can drop into any Grid patch that needs complex random-but-controlled melody. The recording and playback section is a bit more technical, but still logical once you see how the components fit together.

That’s pretty much it for this video! You can grab this patch from my Patreon if you want to skip the manual setup, but I encourage you to build it yourself, as that’s the best way to learn the possibilities in the Bitwig Grid. Thanks for watching, hit Like and Subscribe if you found this helpful, and I’ll see you in the next video!

Transcription #

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] Yo folks, welcome back. It's time for another nice, easy, simple, straightforward Bitwig
[00:00:05] grid setup. And it's something I showed a few years ago, but today I want to show it
[00:00:11] in a more simplified way. Like I said, it's very simple to set up. So in Bitwig, we create
[00:00:18] another track here and just use a polygrid. And in here, we could just keep this the sign
[00:00:26] oscillator on the amplitude envelope, and we want to create some notes first. So I'm
[00:00:31] going here again for pitches. I just realized I basically made a bunch of tutorials just
[00:00:39] about the pitches module here, because you can use this in so many different ways. So
[00:00:45] in this case here, we don't want to use this pitches module as a sequencer. We just use
[00:00:50] it as a kind of a storage for notes. So I'm using here all the notes of, let's say, the
[00:00:57] D sharp minor scale. So we use here just seven steps because we have seven notes inside
[00:01:04] of a scale. We have the root note, right? This is here the second, the third, the fourth,
[00:01:10] the fifth, and the sixth and the seventh and so on. So a bunch of notes in here. And we
[00:01:16] don't need to use here the phase input, because we want to use this as a storage, like an
[00:01:21] array or just a note storage. So the next thing you want to do is we want to go through
[00:01:28] this whole array here in a kind of a different way. We use a clock signal here, which outputs
[00:01:38] also here a phase signal going zero to one, which basically the same as before. But we
[00:01:43] can increase this here to 32 Hertz. We can scan through the whole thing pretty fast.
[00:01:51] Let's move this to the left side. And now we want to introduce probabilities for each
[00:01:55] note. And we can use here the probability thing, probabilities data sequencer. And we
[00:02:05] also select this here and go to the left side and say seven steps because we have only seven
[00:02:10] notes in here. And also we disable the prequote here and use the same clock signal here to
[00:02:16] scan through the notes. We also scan you through the probabilities. And when we make this here
[00:02:22] a bit slower, you can see one note exactly matches one probability slider. So the idea
[00:02:29] now is that we can scan through this pretty fast. And use a sample and hold here to actually
[00:02:39] remember all the notes or trigger the notes that have a certain probability. So let's
[00:02:45] say we want to have in our sequence the root note. It's a pretty high chance of having the
[00:02:52] root note in there. And also maybe here the fifth, right? And the fourth, maybe not so
[00:02:59] much, maybe the second and maybe the leading tone here. So different probabilities, right?
[00:03:07] So the probability of having the root note in there is pretty high. And we can select
[00:03:12] this here pretty fast. And this is probably not something you want to use to play. But
[00:03:17] we can now use here a trigger, trigger small tool to trigger actually here the amplitude
[00:03:24] envelope. It sounds like this because we are selecting many, many notes. So what we want
[00:03:33] to do now is use again another sample and hold to actually hold the current pitch.
[00:03:39] Let's go to 16 notes here. And maybe use here a saw. And maybe use a low pass. Sounds a bit
[00:03:56] different. And maybe want to use here also a reverb delay. Nice. Okay, so here we kind
[00:04:15] of do the whole probability thing. We scan through the notes and we just use the probabilities
[00:04:20] module here to trigger the sample and hold and use the current note and the chance of
[00:04:25] selecting the right note here is pretty high because we scan through the whole thing because
[00:04:31] we want to have for each trigger, we want to have all the notes scanned through and kind
[00:04:37] of analyzed for the probability. And then we use another sample and hold to take to hold
[00:04:42] this note or this pitch for the current gate time or as long as the current time is on,
[00:04:49] we want to hold this note. And this works pretty well in my opinion. So when we pull
[00:04:56] this down here, you can see we have only the root note in there. Right, it's only the root
[00:05:03] note. Then we have here the fifth and the fourth in there. So you can dial in your own
[00:05:17] kind of chance of selecting the right note and you can create interesting melodies with
[00:05:23] this. It's kind of the same thing as I did here with the melody maker with my melody
[00:05:28] maker script, where I have the different probabilities for each different or for each note of the
[00:05:33] scale. The tonic has 30% chance and the fifth has a 20% chance and so on. So we can dial
[00:05:41] this in here also and get the same results more or less. Okay, so the problem now is
[00:05:49] that we have a melody that changes all the time. So it's kind of, you know, kind of random
[00:05:57] in a way. And for music, you need to have repeating patterns and we can do this here.
[00:06:04] Okay, so what we need to do is we need to use a recorder. But instead of recording the
[00:06:11] audio output, we are recording the notes being played. So let's say we record here. So this
[00:06:23] gives us basically nothing. So we can just pull this down. So we want to record with
[00:06:29] the trigger. So we use a trigger here. We want to push this button and then it should
[00:06:34] start recording and then it should stop recording. And it also should start recording exactly
[00:06:41] on the first bar and it should stop recording on the last bar or at the end of the bar.
[00:06:47] And we do this here with a latch module. So here we say when I push the trigger, I want
[00:06:55] to switch to one. So one, the output of one, then triggers the recorder and starts recording.
[00:07:04] So this kind of works, but we also need to stop recording. So we use a face signal here
[00:07:10] again for the positioning, which is just a RAM signal going from zero to 1.99. And then
[00:07:20] we compare this now to a constant of let's say 0.99. So every time the face signal goes
[00:07:35] to the end of the bar, right? So zero here of the face signal is the start of the bar
[00:07:39] and 0.99 is the end of the bar. So every time we reach the end of the bar and then give
[00:07:48] out here a one. So the one then triggers the latch back to zero. So when we hit now here
[00:07:56] the trigger button, we switch this to one and then when the end of the bars reached,
[00:08:01] we go back to zero. You can see this here is recording and then it stops here because
[00:08:06] it's the end of the bar. So now we have a different problem because we can start the
[00:08:12] recording everywhere, maybe shortly in front of the end of the bar or exactly after the
[00:08:21] start of the bar. So right so you can push your record and then it stops somewhere because
[00:08:26] we are starting starting the recording at some point in within the bar. So that's that's
[00:08:32] so we need to kind of synchronize the starting. So I do this sometimes with their multiple
[00:08:40] ways. It's probably not the easiest way to do this, but I do it most of the time with
[00:08:46] clock one ties, not divide clock one ties. So the clock one ties holds a trigger until
[00:08:58] something happens on the second input. So we can do this. We can do the same trick here.
[00:09:06] Just copy this here. So now we go to 0.1, which is the beginning of the bar, right? So every
[00:09:13] time we are at the beginning of the bar send out one trigger and use this here for the
[00:09:18] clock one ties. So now when I press start, it holds the recording until yeah, the bar
[00:09:28] starts the timing is right, right? And then it starts recording and then we go back to
[00:09:34] zero when the end of the bars reached. So we synchronize basically the recording or the
[00:09:40] start and the end of the recording here with this kind of logic. So there are probably
[00:09:47] better ways to do this. I have no idea. It works for me. Okay. So start record, it records.
[00:09:55] And it stops. Okay, let's rename this here maybe record. Okay, let's see how this sounds.
[00:10:07] Oh, we need also the playback here. So we need the playback logic also. And that's pretty
[00:10:12] easy more or less. So we can do just one trigger here. And we do one trigger for each bar for
[00:10:22] one. You can see your weapon go to one and then go to zero within one bar. And what I
[00:10:29] do mostly is then it's probably also not the best way make the length zero and then use
[00:10:36] a knot, which gives you basically one big trigger for one bar. It's exactly what we need
[00:10:45] for the playback. Nice. So this is the playback logic here. And then you can hear you have
[00:11:07] always the same sequence. So it's not using the output of this anymore. It's just using
[00:11:12] the output of the recorder. And every time we want to have a new sequence, we press this
[00:11:16] button. I think we can also introduce here an octave shift. So we want to push the sequence
[00:11:39] sometimes one octifier just to have a bit more variety. It's the same note. It's just
[00:11:44] one one octifier basically. And we do this maybe with a chance. Let's use a chance here.
[00:11:58] And then we can maybe can we use this? Yeah. What you later out. So the chance of getting
[00:12:07] a one out of this here is 33%. And then we push this one octifier. Let's record again
[00:12:18] here. Okay, so now we can use a button and call this generate.
[00:12:48] Or something instead of this, you use a button because there is no one one push button in
[00:12:56] bitwig. So we have to use here the on off switch.
[00:13:26] We could maybe also use a secondary quarter for the modulation or something like this.
[00:13:46] Push this down and then use noise, white noise, maybe as an input, then record. And then we
[00:14:04] also need the sample on hold here for the noise output. Then we get different values
[00:14:10] here from the sample. And then we can use this to modulate. I don't know this one here.
[00:14:22] Oh, this is bipolar. So we use here, B to uni. It's the only positive values, right?
[00:14:46] You have a nice little sequence out that creates for you nice sequences. And you can combine
[00:15:02] it with something else.
[00:15:29] Okay. So we have to use this here. So we have to use this here. So we have to use this here.
[00:15:59] I would say it's not very complicated. At least this this part here is maybe this is just a
[00:16:13] playback and recording logic. But the rest of it here, this part is probably pretty simple,
[00:16:18] I would say. And you can easily set this up every time you want to create a sequence inside
[00:16:24] of the grid. This this part is maybe not that straightforward. But I think it's also kind
[00:16:30] of logical. So yeah, this is something I do sometimes for generative grid patches. And
[00:16:40] then you can do inside of this here, right? We can say we want to press this, I don't
[00:16:45] know, every 32 bars. Also, because you can use a transport here. And say we go to bar
[00:16:54] and then you say 32 bars. And then every 32 bars, you get the trigger here. We make this
[00:17:01] trigger a bit shorter.
[00:17:11] Later out. Then you can modulate to the recording thing. Probably after the stable here.
[00:17:23] No, that's fine.
[00:17:30] Takes a while. But then after 32 bars, you trigger the three quarter new sequence, you
[00:17:35] get a new sequence and so on. So it evolves and generates new sequences. And all you have
[00:17:40] to do is maybe in your live act or your live event, just to fumble around with the sliders
[00:17:47] here to get different outcomes. Okay, that's it. I think I also put this on my Patreon
[00:17:55] as download. If you want to just download this, if you don't want to recreate it, but
[00:17:59] I think it's a great practice if you just want to learn the grid. Okay, so that's it
[00:18:07] for this video. Thanks for watching. Leave a like if you liked the video. Leave a subscription.
[00:18:11] Thanks for watching and I'll see you in the next video. Bye.
[00:18:13] (upbeat music)