Tags: posts Bitwig

Creating a Step Sequencer with Bitwig Studio: A Step-by-Step Tutorial

Tutorial | Aug 11, 2022

In this video, I discussed my approach to learning the Note Grid in Bitwig Studio. I explained that it is best to take a handful of small modules you know and then build from that every day, adding a new module and learning what you can do with it. I showed how to build a step sequencer with the grid, and gave tips for how to avoid micro-tuning issues, such as using a bias instead of a transpose, and using a range map to switch between different mappings.

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

Questions & Answers

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

How can I learn to use the Bitwig Grid?

The best approach to learning to use the Bitwig Grid is to start with a small set of modules that you understand and build from there. Experiment with different combinations and create a patch every day. This will help you build experience over time and you'll start to recognize certain modules that work well in different contexts.

How can I create a step sequencer in Bitwig Studio?

To create a step sequencer in Bitwig Studio, you'll need to start with a Note Grid and Polysense. Start by using the Step Mode mode to create gates and velocity information. Then use value knobs to receive values and a delay to recognize changes between velocity settings as a gate signal. You can also use a transpose or bias module to create pitch information, as well as a sample and hold and key filter for more advanced settings.

What can I do to avoid micro tunings in step sequencers?

To avoid micro tunings in step sequencers, use a bias module instead of a transpose module, set it to bipolar mode, and modulate it with a pitch module. This should help


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.000] Hey folks, welcome back to another video.
[00:03.480] Before we start and create a step sequencer inside Bitwig Studio, I want to give out some
[00:07.960] rough ideas about how to approach learning the grid.
[00:11.400] In my opinion, you don't learn how to use the grid by learning what each individual
[00:16.160] module does.
[00:18.080] And you also don't learn how to drive a car by learning what each individual car part
[00:23.400] does.
[00:24.400] So that's not how it works.
[00:26.840] You learn how to drive a car by sitting in the car, having a rough idea how everything
[00:31.040] works and then you experiment and start to drive and then you build experience over time.
[00:37.360] Make some failures here and there maybe and then you learn from that.
[00:42.920] And yeah, that's how it works.
[00:45.040] It's also how you learn to program or how to learn a new programming language.
[00:50.520] It doesn't learn the language when you just read or know what each feature does.
[00:57.240] You need to get to certain points while programming to get some ideas why you need certain features
[01:06.520] or you maybe had a problem before and then you see why this feature is helpful.
[01:11.800] But you need to have this experience before you discover why you need something.
[01:17.520] So it's the same also with the grid.
[01:21.640] If you explain to you what each individual module does, you don't know how to use the
[01:26.000] grid.
[01:27.000] You can't use it.
[01:28.000] It's just impossible.
[01:30.920] You start with a handful of small modules you know and then you build from that and
[01:36.800] you add maybe every day a new module to it and you learn what you can do with this module
[01:42.120] with your small set of knowledge you already own.
[01:45.800] And then you progress from that and you build up new experiences and you remember certain
[01:51.600] combinations that work well.
[01:54.280] Because a lot of modules are pretty great in certain contexts they are not really made
[02:00.120] for and that's not what a manual gives you as information on.
[02:06.160] It's also not something that most tutorials give you.
[02:10.160] You learn how to use the grid exactly like I said.
[02:13.280] You need to make a patch every day with your small little knowledge you already have and
[02:19.440] then you build up from that every day.
[02:22.640] And that's also a fun way of learning because you always have kind of success because you
[02:28.200] already know certain patchings that work and then you create something from that and you
[02:33.120] learn something new and then you see oh well this is actually great in this kind of context.
[02:39.160] And then you see these contexts in all kinds of places and you try to combine them and
[02:43.720] then you have you know create a much much bigger knowledge base over time and this is
[02:48.760] how you learn it.
[02:50.240] So my opinion take your smaller knowledge go into the grid and try to create something
[02:56.720] and maybe take one or two new modules you never used before and try to use them.
[03:06.120] So let's build some step sequences with the Note Grid and we need of course a Note Grid
[03:15.480] and we need a polysense just to make sure we are also outputting some nodes.
[03:21.880] So just as a test device nothing fancy and we don't inside the Note Grid we don't need
[03:30.920] here actually the node inputs we can remove that and as a step sequencer I really love
[03:38.280] to use the step mode with big studio because it has a nice interface you can access from
[03:45.160] the device itself and you can randomize here each step and it's handy to use you can also
[03:52.720] increase or decrease the steps here you can change speed settings and so on so it's a
[03:57.960] nice little interface we can already use.
[04:01.720] So how do we create actually step sequences for pitches and gates.
[04:07.520] In my opinion interesting approach is to use one step mode here for gates and velocity
[04:18.360] different step modes for the pitches, pitch informations and we also utilize here each
[04:30.680] step value as a velocity setting and you can turn this around and approach this differently
[04:36.880] if you want to you can maybe use here each step value for pitch signal and then use velocities
[04:44.000] in a separate step mode or you do it like I do here but by using a bar for velocity
[04:50.720] and so I'm using gates and velocity and we use value knobs inside the grid to actually
[04:58.000] receive these values so maybe this one here is the velocity and this one is gates and
[05:08.760] we also need pitches.
[05:13.680] So for velocity it's simple we just modulate here the snob all the way through so if a
[05:19.080] bar is all the way at the bottom we have velocity 0 and all the way up is velocity 1 to 27.
[05:25.440] We can straight up connect this output here to the velocity output of the Note Grid super
[05:32.280] simple but the gates it's not so simple because first when we modulate this here all the way
[05:40.600] through we know or I told you in some of my recent videos that you need at least the value
[05:48.440] of 0.5 or something above to be recognized as a gate signal inside the grid and if we
[05:57.760] connect these two here we have no gate triggering at all below 0.5 here only when you reach
[06:06.320] this line so what we want to do is we actually want to have a trigger already when we just
[06:14.320] move your slightly above 0 line and then everything else is basically velocity and if you have
[06:22.760] this at 0 then we have no trigger at all so what we're going to do is we offset here the
[06:29.840] gate a value to 0.9 maybe so we already at the gates of getting a gate so now when we
[06:47.480] move up here we have already gates just by slightly having a value above 0 right so that's
[06:57.320] the solution for that in my opinion the second problem now is maybe put this down a bit the
[07:07.280] second problem is that when we have multiple steps here this kind of works because we have
[07:13.200] in between some empty steps but when you draw in here all steps we have one single continuously
[07:26.320] playing note and that's not what we want we want to have single triggers here for each
[07:31.440] step and my solution to that is we just utilize the velocity settings so you can see here
[07:38.400] each step has a slightly different value and we can sniff that or we can recognize that
[07:45.240] inside the grid by just comparing each step to the next step and looking if the velocity
[07:52.960] value changed and when the velocity value changed we probably switch to another step
[07:58.320] so make a cut into the gate and have a note off and I do this here by using a delay of
[08:07.920] course and we compare basically the current value of the velocity to the value of 0.02
[08:16.960] milliseconds earlier at some point there is a change here between the velocity settings
[08:23.120] and we want to recognize this as a gate so bring this in then we need a comparison here
[08:29.840] I don't know what the name is it's probably uneven here yes okay this and this so every
[08:38.040] time we have now here a difference between the velocity velocity settings we get a gate
[08:42.120] signal as you can see here maybe there's an oscilloscope for that so we have now here
[08:51.040] each step and sometimes when the steps are have exactly the same value like here 41
[08:58.320] then this one is glued together it's one step it's kind of an hold or I don't know
[09:02.080] how it's called on a step sequencer rest or yeah that you basically glue multiple steps
[09:08.320] together so we can also utilize this here as a as a hold feature so now that we have
[09:16.640] this we just take here a multiply a multiply basically doesn't transmit anything so we use
[09:25.680] it here for the gates so basically when we play here gates nothing happens because this
[09:32.160] signal doesn't pass through so we have to input your constant of one to actually pass
[09:42.760] the signal and if you if the signal is at zero and see nothing passes so it's also nice
[09:50.360] that we get your gate signal and the gate signal is exactly one one or zero so it's
[09:57.920] exactly what we need and we don't want to actually connect this here because now we
[10:03.520] only get the gate on or pass here pass through by when something changes which is pretty
[10:09.480] short in fact we want to have an not module which basically inverts the signal here so
[10:17.640] now we pass the signal all the time but only when something changes in the velocity settings
[10:26.440] we don't so we cut off basically on each step as you can hear here we have a nice gate trigger
[10:33.880] all the time but only when you have here the same values then you have a hold or continuously
[10:44.720] holding note so now we can also have the velocity here passing out so we can use the velocity
[10:50.760] setting here on the synthesizer makes use of it so now we can go on to the pitch signals
[11:10.080] here and this one is a bit yeah it's a bit strange because I don't use here well value
[11:15.880] slider let's see here we have the pitches and we switch this to bipolar mode because
[11:22.320] we want to have a root note which is zero and then we just want to transpose away from
[11:27.840] zero in pitches down and up right so we could use we could use here maybe pitch in or not
[11:38.960] the pitch in a pitch module so we can define a root root note in this case here at C3 and
[11:48.520] then we use a transpose and modulate that with the pitch module and then go out something
[11:57.120] like this and then you probably also want to use a sample and hold here to hold the
[12:03.200] current pitch or the grant gate because sometimes you want to have the pitch step sequence are
[12:09.920] playing at a different speed than the gates step sequencer and when you have different
[12:15.440] speeds then you probably change the pitch while you have a gate active and then you
[12:20.040] have create some kind of bands between notes but again show you this in a minute so maybe
[12:26.840] just modulate this here by 12 semitones should be fine okay and then we use the gate out
[12:36.280] here from this we maybe call out the yellows we can see it's a gate so maybe make a test
[12:58.320] here and use a different instrument track and get in the notes from the note grid record
[13:07.320] this here and look at how it looks like you can see here we have some problems already
[13:16.840] the year we introduce kind of notes the right notes but we also introduce you some micro
[13:25.000] tunings as you can see it's off by 0.26 it's by minus so we have some bands in there some
[13:32.760] micro tunings which we don't want we have to want to have straight notes and I haven't
[13:39.240] figured out why that why this is but I think the problem lies here in the transpose module
[13:46.760] I kind of can use here and quantize something like this which doesn't help so I want to
[13:56.400] use here the quantize right to quantize all notes to a current pitch this doesn't also
[14:02.160] doesn't work yeah kind of okay I guess it works but in my test it hasn't worked I still
[14:17.720] got some bands in there some pitch bands but yeah it kind of works now okay so with this
[14:25.280] transpose here you can also replace this here with the bias I had more luck with using a
[14:30.560] bias and switching this to bipolar mode and modulating this instead of using a transpose
[14:36.720] for some reason for some reason now it works but maybe later on it doesn't so keep this
[14:42.440] in mind so maybe modulate again so now we have to see on the perfect nice chromatic
[15:00.160] scale and if you want to have a scale you probably want to use a key filter here it's
[15:06.200] better than implementing this in the grid itself because you want to have you want to
[15:10.800] stay modular sometimes people just want to have chromatic scales sometimes they want
[15:15.080] to die in certain scales you can also replace this here with a that's both map for instance
[15:21.560] and you know use more exotic scales or something but here we can just use finder the key filter
[15:44.920] make a test again here maybe record this yeah it's still off as you can see here 0-0.5 that's
[15:56.120] not what we want we want to have straight straight pitches in my opinion we can see we already
[16:03.200] use here a sample node and we use a pitch quantizer this transpose doesn't care you're
[16:08.120] still trans transpose within a gate on for some reason so I'm replacing this here for
[16:16.360] bias I also tried different tricks here trust me I tried different tricks just to keep a
[16:26.520] state steady pitch also you just use some multipliers for getting the pitch but these
[16:33.480] bands are so persistent I don't know why maybe modulators as is a different range to record
[16:49.920] this again here now we have straight pitchers can see at the line micro expression line
[16:58.880] is perfectly in the middle there are no offsets it's much better my tip use the bias it's
[17:09.680] basically the same it has just a different range okay so now that we have this let's
[17:18.840] see if we can arrange this here a bit more so we have the gates here we have the pitch
[17:25.400] sample and hold you could put this here after the sample and hold and remove this
[17:41.720] and you can maybe also introduce your new step mod for number this and pressure and
[18:00.520] also duplicate this and use it for panning it's also nice and the pan you probably want
[18:07.040] to have here also bipolar signal so let's use value here again in bipolar mode or panning
[18:16.560] oh we have to unfold this panning modulate all the way and we want to have here value
[18:28.800] for pressure and timbre bam pressure is this timbre is this panning is already modulated
[18:51.080] maybe you can use a name here and so now we have a nice little interface here for a step
[19:01.000] sequencer don't need actually some note inputs for anything or note clips here to paint in
[19:09.040] we just bring in this sequencer and then we can play some notes or some gate sequence
[19:14.760] or hit randomize here we get random sequences sometimes it's better yet to use a broad range
[19:34.280] three steps maybe bring in your more of the root note
[19:50.840] and you can now use your timbre for maybe the setting and maybe the pressure here to
[19:59.480] mix in the second oscillator so we can also paint this in
[20:19.880] we can change the panning
[20:33.000] and it's persistent so when you save this with your project it still stays the same
[20:37.200] maybe the panning is too much here and you can use the mount knob here to actually scale
[20:51.000] the whole modulation
[21:20.480] nice
[21:35.080] so now off to the next idea maybe you don't want to trigger actually a polysand you want
[21:40.880] to trigger a drum sequencer for instance maybe remove this here maybe you have the xo the
[21:51.440] xo has a different mapping maybe I choose here some random kit
[22:05.720] or something like this and you want to trigger here these notes right but here you started
[22:10.680] C1 C1 C sharp 1 D1 and so on so I seven yeah basically seven semitones up so we can implement
[22:21.840] this here and use a button and call this button drums maybe so for drum drum mapping
[22:33.680] if we pull this out we use here and merge or maybe you select this enough and just dial
[22:48.240] in here maybe a second note I mean you could just use transpose or something like this
[22:56.240] would also work I'm going here for C1 so I'm connecting this here with the button calling
[23:06.680] this button drums and when you press the button then you get C1 if you release the button
[23:15.280] you get C3 and then we can modulate these two switch here the second input so now we
[23:26.200] started C1 as a root note and everything that you dial in here selects a different different
[23:33.480] drum kit so we can try this so you have to stay basically here in the range of these
[23:56.920] seven semitones here we are probably 24 semitones or something like this so we probably have
[24:05.920] to change here also the range of this maybe we use here a merge to select between different
[24:18.000] modulation amounts so this is here the range of melodies melodies and this is the range
[24:30.920] of plus seven maybe so we can also switch this here the bipolar mode off and just modulate
[24:40.400] into the positive range but not that much maybe just seven I don't know how many it's
[24:49.400] not it's not transpose right so maybe switches here to transpose instead let's see it shouldn't
[24:55.640] be a problem for pitch flights here now we just modulate by seven semitones seven and
[25:13.720] to use a value here and to use this to interpolation nearest so again we switch between these two
[25:23.640] and we call this range map or something we use a macro here to switch between the mappings
[25:35.280] map 12 7 something like this so when we turn this up it's perfectly nice for XO if it turns
[25:47.040] down then it's perfect for melodies or drum sequences that have more than seven semitone
[25:54.520] steps so when we turn this up here to seven and have drums enabled then we probably play
[26:02.160] in the the sequencer here with this value the top step here let's see not really maybe
[26:17.600] maybe I'm wrong okay we need to modulate by 12 we need more than 12 yeah so now we can
[26:37.800] randomize and this should be the kick drum here yes the kick drum so modulating nothing
[26:45.400] as the kick drum different loop length here
[27:12.680] it's already a nice groove so yeah then you have here the right mapping for the XO or
[27:40.400] you can switch us here to a different range then you probably exceed here the number right
[27:46.360] so sometimes you have instead of XO you have maybe something like addictive drums and there
[27:55.560] you have multiple octaves of mappings for for drum kits here so these seven steps are
[28:03.520] not enough but also here the XO value is basically the kick drum
[28:30.920] but here the interesting thing is when you choose a different length for the gates and
[28:35.560] velocity settings and the pitches you can when you have your even number for steps like
[28:42.800] 16 steps here you can dial in at the same position the snare drum for the pitch right
[28:49.760] so dial in here the pitch for the snare drum at the same position but the gates actually
[28:54.040] doesn't trigger the snare every time it passes through here because you have odd numbers and
[28:59.320] it leads to all kinds of interesting rhythms sometimes which is really nice to play around
[29:06.240] with
[29:17.240] kind of like the screw but now we can put this here to a second track push the strums
[29:24.960] off and we can use maybe a Polysend again and try to find here
[29:47.920] and some melodies here in the pitch
[30:14.560] and
[30:30.960] And it's a really nice odd groove you can create with this.
[30:52.960] Maybe we can also add some more whistles and bells to this.
[30:56.640] So why not introduce some rolls or some glitch stuff in there.
[31:03.520] So maybe we can take here the gate signal of our drum note grid and maybe use here the
[31:15.840] gate select and in here create repeats and then we switch basically to a gate repeater.
[31:35.960] Let me see the value, oh let's use the button, this is the hi-hat obviously.
[31:52.440] And maybe we switch also off here playback select.
[32:22.360] So every time we hit the stop on the transport we don't want to have a gate signal playing.
[32:28.800] Or when we hit play.
[32:45.680] So we create here another step sequencer, step mod and call this maybe rolls or something
[32:54.360] like this and we do the same thing, we use a value and replace this with a button and
[33:05.280] go to 49.9 and then we can modulate this here all the way up and then the value actually
[33:24.080] changes here, the gate repeats, maybe we start at the smaller value here, let's see.
[33:41.840] And here again if you use odd numbers you don't repeat on each two bars at the same position
[34:09.080] the same rolls, so when you have to see at different odd lengths then kind of create
[34:14.760] a polyrhythmic pattern or sequence and you have rolls at different points in your sequence
[34:22.080] which is much more interesting in my opinion.
[34:25.440] Also you have to see when you have your short loop length and this one is longer than this
[34:31.320] playhead switches back to the initial position so you have to make this here a bit longer
[34:35.840] so actually fit all the sequences in, it's right if you have this here at one and see
[34:43.840] it switches back to one before it's ending here.
[34:53.000] Because we have synchronized this here to transport which is nice or we can also use
[34:58.680] here with groove of course later on, nice, yeah make this a bit longer.
[35:05.680] And make this slower, maybe this is also here too much.
[35:27.640] If you don't like to have these rolls so in pretty off timings you can also sneak in here
[35:47.840] in between a clock quantizer and quantize these steps here to maybe let's say 32 beats,
[36:02.240] make them more of a synchronized flair, or 64, nice, yeah, yeah, yeah, yeah, yeah, yeah,
[36:28.240] yeah, nice.
[36:38.240] We have to make this a bit wider.
[36:51.080] So yeah cool stuff, maybe a peak limiter here, maybe also create your bassline, let's see
[37:09.520] if this works.
[37:18.520] Now transpose we want to have this a bit lower here so you can see because of the modularity
[37:23.480] of Bitwig Studio we don't actually need to implement every feature we just can use here
[37:29.800] NodeFX to treat the signal to our likings.
[37:49.360] Oh there's some rolls in there, they don't need that, maybe the pitch sequence should
[37:58.840] be more simple.
[38:09.640] Maybe we can use your fresh art tamer, oh yeah we also need to remove the panning.
[38:35.640] Bring it up a bit more right here, very bit slower.
[39:01.640] Too slow, you don't like the velocity steps in there, you can also dial this down here.
[39:27.640] Oh yeah, we need of course also here to keep it down.
[39:46.200] Same with the friend kit.
[40:11.400] Yeah if you want to record all this stuff then you can as always use an instrument track,
[40:18.080] select as an input here, below tracks, you can even select here the note grid, maybe
[40:26.960] you can also rename this here to step sequencer, yeah.
[40:35.080] Step sequencer, there it is, just hit record, then you get the pattern here, now look at
[40:47.360] all these pitch glides here, this is actually the glitches coming from the transpose and
[40:57.480] it's much better to use like I said in the beginning here to use the bias, for some reason
[41:03.000] all these pitch bends make it through all these sample holds and pitch quantizers, I
[41:09.480] don't know why, it's probably because of how the note system inside the Bix2D works, but
[41:16.960] yeah there it is, you can record it, easy peasy.
[41:20.600] That's it for this tutorial, you can also download this patch of course on my patreon
[41:25.240] page, the link is in the description below, leave a like if you liked the video, dislike
[41:29.760] if you don't like the video and leave me a comment if you have some questions, thanks
[41:35.040] for subscribing, thanks for watching and see you in the next video, bye.