Tags: posts polarity-music Bitwig Tutorial Bitwig Grid

Bitwig Grid Probabilities for Weighted Random Modulation

Tutorial | Aug 07, 2026

Learn how to use Bitwig Studio Grid with the Probabilities module and Sample and Hold to create weighted random modulation and note sequencing.

Quick Answer

Short Overview

Controlled randomness in Bitwig Studio with Polymer and The Grid allows modulation and note generation to follow weighted probability instead of uniform random distribution. This matters when certain values should occur more often than others, such as favoring specific wavetable positions, excluding unwanted timbres, or prioritizing musically useful notes in a scale.

A practical setup uses a Step mod or Pitches module, a Probabilities module, and Sample and Hold to create a probability-driven control signal. That signal can then be routed through Modulator Out or MIDI CC to modulate Polymer parameters like wavetable index or cutoff, giving precise control over which random outcomes are likely, rare, or impossible.

Key Takeaways

Controlled Randomness in Bitwig: Weighted Probabilities for Modulation and Note Generation

Bitwig’s built-in Random modulator is excellent for assigning values within a range. It can define a starting point, an endpoint, and how quickly the value changes. What it cannot do directly is control which values inside that range are more likely to occur.

That missing piece matters whenever random should be guided rather than uniform.

A practical example is wavetable scanning in Polymer. If a wavetable contains four waveforms, sine, triangle, pulse, and saw, it may be useful to randomize the wavetable index while making saw occur most often, sine and triangle occasionally, and pulse never. Standard random modulation does not offer that kind of weighted distribution. The Grid does.

What It Does

This technique creates weighted randomness: a signal where some values are more likely than others.

Instead of letting random values land anywhere with equal probability, the patch defines:

This can be used for:

Why the Standard Random Modulator Is Not Enough

A normal random modulator in Bitwig can already control:

But it distributes values evenly across the range. Every point is equally likely.

That is often fine for generic motion. It is not enough when certain states should dominate and others should be rare or excluded entirely.

How It Works

The core idea is to separate value selection from probability selection.

One Grid module provides the possible values. Another provides the probability gates. A shared phase source keeps them aligned. A Sample and Hold module then outputs only the values allowed by the probability pattern.

The important modules are:

Workflow

1. Define the possible values

Use a Step Mod with one step per target value.

For a four-waveform Polymer wavetable, set the Step Mod to four steps so each step corresponds to one waveform position:

The exact step values should match the wavetable index positions needed by Polymer.

This module acts as a lookup table of allowed values.

2. Drive the step position with phase

Use Transport to generate a phase signal, then disable pre-cord on the Step Mod and feed the phase into it.

This makes the Step Mod scan through its steps in sync with musical time rather than free-running internally.

Rate can be set musically, such as:

3. Create matching probability weights

Add a Probabilities module and set it to the same number of steps as the Step Mod.

For the four-waveform example:

Then disable pre-cord on the Probabilities module and feed it the same phase signal used by the Step Mod.

Now both modules are perfectly aligned: each step in the value list has a corresponding probability weight.

4. Use Sample and Hold to output only selected values

Add Sample and Hold.

The probability module determines when a value is accepted. When a gate occurs, Sample and Hold captures the current value from the Step Mod.

This is the key operation. Without it, the patch would simply scan all values in sequence. With Sample and Hold, only the probability-approved values become output.

5. Send the result to a modulation target

To use the signal as modulation, send it through Modulator Out.

That output can then modulate parameters such as:

In the wavetable case, the index moves among the selected waveform positions, but values assigned zero probability never occur.

Smoothing the transitions

Stepped values can sound abrupt, especially when modulating timbral parameters such as wavetable position.

To soften this, insert a smoothing module before Modulator Out, such as:

This creates glides or eased transitions between selected values.

The result is similar to increasing smoothness on a Random modulator, but now the distribution is weighted rather than uniform.

Alternative routing: Node Grid inside Polymer

Instead of placing Polymer inside an FX Grid, the setup can be moved into a Note Grid or Grid module inside Polymer’s Note FX slot.

In that arrangement:

This can be cleaner structurally because the Grid lives inside Polymer’s modulation path rather than wrapping the whole instrument. The tradeoff is additional MIDI-based routing.

Practical Uses

Weighted wavetable selection

This is one of the clearest examples.

A wavetable might contain four regions, but not all are equally useful in a patch. Weighted probabilities allow:

That yields movement without losing character.

Weighted filter motion

Filter cutoff can also benefit from weighted randomness.

Instead of a uniform spread between low and high values, the patch can favor:

This is useful when random modulation should stay musically centered.

Probability-based note generation

The same method works for pitch.

Replace the step-value source with a Pitches module containing notes from a scale, for example A minor using white keys. Then:

Sample and Hold again captures only the approved pitches.

A Quantizer can be added if needed, and a second Sample and Hold can be used to trigger pitch changes at a more musical rhythm than the fast scanning clock.

This effectively creates a probability sequencer: note choices are random, but their likelihood is controlled.

Building more musical rhythm into note changes

For note generation, it can help to separate:

For example:

This keeps selection varied while making the musical phrasing more coherent.

Relation to Markov-style sequencing

This weighted-value method controls how likely each value is in general.

A more advanced system, such as a Markov sequencer, goes further by controlling what value is likely to come next depending on the current value.

That means not only saying:

but also:

The probability patch described here is simpler, but it forms a useful foundation for those more advanced generative systems.

Limits

This approach is powerful, but it has tradeoffs.

For simple random motion, Bitwig’s normal modulation tools remain faster. This Grid-based method is most useful when the randomness itself needs structure.

Summary

Controlled randomness in Bitwig can be built by combining:

The result is a reusable pattern for generating modulation or notes where some outcomes are common, some are rare, and some never happen at all.

That makes random behavior much more musical when equal distribution is too blunt.

Transcript

This is the transcript of the video. The text was generated automatically and may contain small mistakes. The timestamps jump to the matching part of the video.

Click to expand transcript

[00:00:00] Okay, so in this video, I'll try to explain to you how to implement controlled randomness
[00:00:06] or I don't know how to call it or probability values.
[00:00:11] And the hardest part is probably to explain what I actually mean by that and why you want
[00:00:17] to need it or why you need it, because this is something you don't need all the time.
[00:00:24] But when you need it, it's not straightforward to implement.
[00:00:28] So let's say you have a synthesizer here.
[00:00:30] So we have polymer here in Bitwig Studio, and you want to randomize the cutoff knob position,
[00:00:36] which is very easy to do because you just use a random modulator here and we use it
[00:00:42] in a monophonic way.
[00:00:44] And we increase here the smoothness and we modulate the cutoff knob.
[00:00:50] So with this, we can already define a lot of things.
[00:00:54] We can define where we start, which is the initial position of the cutoff knob, which
[00:00:58] is here at 262 Hertz.
[00:01:02] And we can define the endpoint of the modulation, which is this position here.
[00:01:06] And we now know that there are random values happening between the start point and the
[00:01:12] end point of this kind of defined range here.
[00:01:17] We can also change the speed of the modulation or the automation, and that's basically it.
[00:01:26] But what we can't define is which values between these two points, the end points and the start
[00:01:33] point and the endpoint, are more likely to happen.
[00:01:38] So you can see here the randomness is equally distributed between the two points.
[00:01:43] So all kinds of different positions in between can happen.
[00:01:47] And sometimes you want to define that.
[00:01:50] You want to define what kind of values are more likely than others.
[00:01:57] I hope this makes sense.
[00:01:59] Maybe a better example would be if you use the random modulator here on the wave table,
[00:02:05] where we modulate the index of the wave table.
[00:02:08] And we have here four different waveforms in the wave table.
[00:02:11] We have the sine, the triangle, pools, and saw.
[00:02:17] And sometimes you want to define, you want to say, I want to have a random waveform, but
[00:02:23] I don't want to have the pools waveform not happening at all.
[00:02:29] Most of the times I want to have the saw, sometimes I want to have the sine, and maybe
[00:02:35] sometimes the triangle, but the pools not at all.
[00:02:39] And I want to have a randomized.
[00:02:41] So now we have a problem that this random modulator here is equally distributed.
[00:02:46] So all kind of values can happen all the time.
[00:02:49] You have no influence of which values are more likely than others.
[00:02:54] I hope this makes more sense.
[00:02:56] So this would be a practical example for that.
[00:03:00] So how do we implement this?
[00:03:01] This is not straightforward.
[00:03:03] And sometimes you want this, and this is what I show you.
[00:03:07] So you can't do this inside of the modulation matrix here of Bittrick Studio.
[00:03:13] Maybe you can with a lot of modulators and a lot of complexity, but in my opinion, it's
[00:03:17] much easier when you use the grid for that and combine it with the modulation system.
[00:03:24] So we can do this by using an FX grid here.
[00:03:28] You can use whatever you want to use, but I start with an FX grid.
[00:03:33] And we first prepare a signal that we then later on use to modulate something.
[00:03:40] So we can start by, let's say, use a step modulator steps like that.
[00:03:49] And we know that inside of the polymers synthesizer here, we have four waveforms.
[00:03:55] So the sine, tri, pools, and so on, right?
[00:03:59] And we can say, we just use four different steps.
[00:04:04] And we want to have the sine in there.
[00:04:08] We want to have the triangle in there.
[00:04:10] Maybe I can create here just an saw.
[00:04:14] No, that's not going to work.
[00:04:17] Something like that, right?
[00:04:19] So we have the sine.
[00:04:21] We have the triangle, pools, and sine of saw.
[00:04:26] And then we can put here the whole polymers synthesizer into the post FX like that.
[00:04:32] So now we can use here this output and modulate the index.
[00:04:37] You can tweak this a little bit here.
[00:04:41] Maybe like this.
[00:04:42] This should be 75 probably.
[00:04:47] Yeah, OK.
[00:04:51] OK, so this is not what we want.
[00:04:52] So we want to use now, let's say, a transport, which gives us here this kind of phase signal.
[00:05:04] And this phase signal should happen across quarter nodes, one quarter node maybe or two
[00:05:10] quarter nodes, which is in half, half step here, half node, anyway.
[00:05:17] So we then disable here the pre-code of this step sequencer or step mode.
[00:05:23] And we use the output here of this and drive this step mode here with the transport output.
[00:05:29] So the phase signal of the transport drives the position of the step mode.
[00:05:35] Very easy.
[00:05:37] Now use a probabilities module looks like this.
[00:05:43] And we can define also here now the probabilities of each step.
[00:05:46] So we go to the left side here in the inspector and pull this down to four.
[00:05:51] So we have four possible faders for four steps.
[00:05:56] And we want to say the saw should happen most of the time.
[00:06:02] The pull is not at all, so it's zero.
[00:06:06] Then maybe to try and the sign is also cool.
[00:06:11] So also here with disable the pre-code, we use the same phase signal from the transport.
[00:06:16] So now it's synchronized.
[00:06:18] So each step of the step mode equals to each step of the probability sequencer or the probabilities
[00:06:27] module.
[00:06:28] So all we have to do now is to use here maybe an oscilloscope to check the output.
[00:06:38] So here we have all values happening all the time, all over the place, one after the other
[00:06:45] because the step sequencer just runs.
[00:06:48] And then we use here at the bottom input, we use sample and hold.
[00:06:55] And also the signal from the step mode goes into the sample and hold.
[00:06:58] And also the output of the probabilities module goes into the sample and hold to actually
[00:07:04] trigger when we want to sample the data from the step mode.
[00:07:13] So you can see now here that we have the pulls not at all happening.
[00:07:19] So this value is not coming through at all.
[00:07:22] But most of the times we get the saw and sometimes the sign which is down here.
[00:07:27] And very rarely we get the triangle in the middle.
[00:07:31] So now this is very slowly happening or modulating here.
[00:07:37] So all we have to do now is use a modulator out module which gives us kind of a wireless
[00:07:48] ability to modulate here the cutoff or here this kind of thing.
[00:07:53] So let's modulate the index here of the wave table.
[00:07:58] Now we can see we move through the wave table but we never end up on the pulls.
[00:08:05] Does it make sense, I hope so.
[00:08:07] So we can now change the speed of this modulation exactly like we could here do this in the
[00:08:14] random modulator itself.
[00:08:16] So we have here Hertz, then we go to eight note, right?
[00:08:20] Then we have a much faster randomization.
[00:08:24] So we go to eight note, one eight note.
[00:08:27] And you can see we step through each wave from here pretty fast.
[00:08:33] So what we can do about this is also we can make some smoothing happening.
[00:08:40] So we can use maybe an average or maybe a lag module before we go into the modulator
[00:08:50] out and we can change how the transitioning here happens, right, it looks like this.
[00:09:05] Maybe it's a bit too fast, maybe I go to quarter notes here.
[00:09:13] So now with this we can create some kind of values that are more likely than other values
[00:09:21] and you don't need this all the time but sometimes you want exactly that.
[00:09:26] So we don't need a oscilloscope here, that's all we need, these two or these modules here
[00:09:32] in combination.
[00:09:34] You can do this in all kinds of different ways.
[00:09:36] If you want we can just use here this phase signal for the modulation signals, you can
[00:09:43] go straight into that.
[00:09:45] But here you have a bit more control if you use a step mod in between because you can
[00:09:51] decide what kind of step gets which kind of value, right?
[00:09:56] Also a downside is this is not polyphonic, you can do it probably polyphonic by just
[00:10:05] switching here voices on and then you have for each voice multiple modulations.
[00:10:14] But yeah, it's not as straightforward as using just a modulator here.
[00:10:19] Another thing is if you don't like to have this polymer inside of the FX grid, so it's
[00:10:25] like a nested, we can also do something different which looks a bit better but also has a downside
[00:10:32] of course, we can say we use the polymer outside of the FX grid and then we change the FX grid
[00:10:38] to maybe a node grid, something like that and then we put this into the node FX box
[00:10:47] here of the polymer itself.
[00:10:49] So now the node FX or the node grid is inside of the node FX box of the polymer so it wraps
[00:10:57] a bit better or it's more logical in a way.
[00:11:00] We also have here a node through active, we can also instead of using now here this modulator
[00:11:08] out use just a CC out something like this and we send this data the same signal we send
[00:11:16] out as MIDI CC 1 on channel 1, okay?
[00:11:22] And you can then load here a MIDI modulator, looks like this, and we receive the data from
[00:11:33] this output here basically in here, oh we have no signal, sorry, and then we modulate
[00:11:48] of course here the index of the wave table.
[00:12:12] So you have a bit of control over the randomness what's happening.
[00:12:17] I showed something like this in a video a few years ago where I use this for generating
[00:12:23] nodes because this is also possible, so instead of doing that we can say we have a node grid
[00:12:32] in here and we use maybe pitches module like that, I can say I want to have all kinds of
[00:12:42] different nodes in a scale maybe or maybe use your A minor, it's a bit easier.
[00:12:54] So we select here all the white keys, something like that, we maybe don't need eight, we need
[00:13:02] seven maybe so we end up on A again.
[00:13:05] We do the same trick here, right, so we disable the pre chord of the pitches module, we use,
[00:13:14] what can we use, use a probability, probabilities module, we also use here seven steps, we disable
[00:13:22] this, and we scan through that maybe with a clock like that, pretty fast, 32 hertz which
[00:13:32] is a ramp signal then, scanning through the nodes and also scanning through the probabilities
[00:13:39] and then we use here a sample and hold for that and we can now decide oh this node which
[00:13:47] is the root node should happen all the time and maybe where's G this one here, this is
[00:13:53] G actually, yeah this is G, so G the dominant we also want to happen all the time and then
[00:14:01] we get a different node here at the end, use a quantizer, let's see how this looks like.
[00:14:14] So we have A and G, oh it's probably E is the dominant right, not G, G is the dominant
[00:14:23] of C, sorry, maybe something like this, so we get only these two nodes and you can decide
[00:14:35] which nodes are more interesting to you than others in the scale and then you end up with
[00:14:41] the stuff, so then we have here the pretty fast pitch changes, right, so we use another
[00:14:46] sample and hold, yeah and we trigger this with more like, more musical rhythm, let's
[00:14:57] say every quarter note here, every quarter note and then we go from that or maybe from
[00:15:05] that trigger, so you can build more or less a probability sequencer because you can decide
[00:15:35] which nodes you like more than others from a scale and how often they should occur in
[00:15:41] a sequence, right, so it's very easy to do actually in Bitwig if you know the patch,
[00:15:46] so yeah, this is basically a modification of this what we did earlier with the modulations,
[00:15:53] it's all like, you know, it's just a signal and you can decide which kind of values you
[00:15:59] want to have more inside of the signal and then you use the signal for pitch generation
[00:16:03] modulation or I don't know sound design or whatever, so yeah, this is how you do it,
[00:16:11] the probabilities module here is very nice for that and then you need another module that
[00:16:16] spits out the values and then you sync basically the position of the probabilities module to
[00:16:23] the data module and then you use the sample and hold and the gates from the probabilities
[00:16:30] module then hold the right values when here a gate happens, yeah, I hope I explained this
[00:16:38] actually well and you understand what I mean by that, I don't know if you could follow this
[00:16:44] at all, I tried to make it as easy as possible, I hope we get something like this here as a
[00:16:52] modulator at some point where you have like a matrix of values and then you can decide you
[00:17:01] know which values you want to have more than others or maybe something like Markov chains,
[00:17:06] I showed you also at some point I have here a Markov sequencer, I made this a few years ago,
[00:17:14] looks like this here also a lot of values and then here a lot of probabilities modules,
[00:17:20] so here the difference is it's not only deciding which values you want to have more inside of
[00:17:27] the signal, you can also decide where you go next, right, so if you are on the first scale note,
[00:17:35] it's more likely that you go to, I don't know, the dominant note right after that and if you
[00:17:47] are on the dominant it's more likely that you go back to the first note, right, so with this you
[00:17:54] can generate a lot of nice melodies or note sequences, so yeah this is basically how you use
[00:18:02] it to generate modulations, I want to show you this because I just did this yesterday and I thought
[00:18:09] it's maybe a good idea to explain this in a video, yeah maybe I put this here on my on my
[00:18:18] github so you can just download this, anyway, if you have some questions let me know in the
[00:18:22] comments down below, leave a like if you liked the video and just ask if this is too complicated or
[00:18:29] you don't know how to use it and what I actually just explained, just let me know in the comments,
[00:18:34] I maybe make another video or maybe write a blog post that goes more into detail, I don't know,
[00:18:41] anyway leave a like, see you in the next video, thanks for watching and bye.

Related reading

Bitwig Studio Poly Grid Bass Generator for Random Wavetables Tutorial

Bitwig Studio Poly Grid Bass Generator for Random Wavetables

Learn Bitwig Studio Poly Grid bass sound design with a random wavetable and PM generator, then render stable bass patches for drums and basslines.

 Bitwig Poly Grid Percussion Generator: Fast Random Drum Design Tutorial

Bitwig Poly Grid Percussion Generator: Fast Random Drum Design

Learn how to build a random percussion generator in Bitwig Studio using Poly Grid, dice modules, envelopes, noise, and simple modulation techniques.

 Probability based melodies in the Bitwig Grid Tutorial

Probability based melodies in the Bitwig Grid

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.

 Bitwig Random-LFO Modulator - Random Modulation Signals Bitwig Guide

Bitwig Random-LFO Modulator - Random Modulation Signals

The Random LFO modulator in Bitwig Studio is a versatile tool that can generate unique, polyphonic or monophonic random modulations for parameters like cutoff, panning, and pitch, enabling each note or voice to have its own character. Its flexible controls allow you to adjust speed, smoothness, feedback, and trigger modes, letting you create anything from subtle variations to drastic, evolving changes over time. By fine-tuning its settings, you can easily add movement, analog feel, or rich unpredictability to your patches, transforming static sounds into dynamic, expressive ones.

 Bitwig Grid Generative Ambient Patching Workflow Tutorial

Bitwig Grid Generative Ambient Patching Workflow

A long Bitwig Grid build of an ambient generative patch with noise-driven note sequencing, all-pass reverb, and layered modulation techniques.

 Shift Register - Generative Melodies Tutorial

Shift Register - Generative Melodies

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.