Step Recorder in Bitwig

Tutorial | Jan 03, 2025

In this video, I demonstrate how to create a step recorder within Bitwig Studio using the Note Grid by replicating the functionality of a hardware step sequencer. The process involves using arrays to store pitch information for each step, counters to manage step progression, and some additional logic for recording and playback. I've saved the step recorder as a preset, which you can download and customize further, allowing you to build sequences on the fly more fluidly.

You can watch the Video on Youtube

• support me on Patreon
• Download the Preset

Summary #

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

In this video, I'm going to guide you through the process of creating a step recorder within the Note Grid of Bitwig Studio. I'll try to keep things as straightforward and simple as possible so that everyone can follow along. But first, we need to address the question: what exactly is step recording?

To illustrate, I'm using my Arturia KeyStep, which has an integrated step sequencer. But not everyone has access to a KeyStep Pro, so the goal here is to recreate this functionality within Bitwig's Grid environment. On a step sequencer, with the transport stopped, pressing record will make the first step flash, indicating it's ready to accept notes. You can play notes one by one – each keypress advances the sequence by a step until you reach the end. You can choose to overwrite the sequence or simply let it play, and you can adjust the playback speed as well.

The aim here is to create a similar step recording experience within Bitwig's Note Grid. In the Note Grid, we'll utilize a buffer or array to store pitch information for each step. Accessing each step is done using a counter. For this demonstration, we’ll use an 8-step sequence, but you can expand this to 16 or more steps if desired.

To set this up, I'll first create a counter to change our position within the sequence and establish a place (write phase) to store pitch information from the MIDI keyboard. Next, a gate input is necessary for saving values to each position, which constitutes a write operation. We also need the counter to advance every time we press a key.

Once pitches are recorded into the array, we utilize another counter for playback purposes. This involves setting a playback speed and having a module trigger the sequence playback. The counter moves through the array to recall the stored pitches, which are then sent to a pitch output for playback. This simple setup allows for on-the-fly step recording, and it's sufficient for my needs.

For some added functionality, I'll show you how to implement buttons for play and record. The playback button is straightforward: a simple toggle switches between play and stop. The recording logic, however, is a bit more involved. We use a latch to toggle between recording states (record on/off) and a select module to determine actions when recording is turned on. The recording stops automatically once the sequence loop is completed.

Additionally, during recording, it’s important to hear the actual notes you play, not the pre-recorded sequence. For this, select modules are used to switch between the original gate/pitch information when recording, and the playback sequence when not recording.

To demonstrate velocity recording, I duplicate the modules and make the necessary connections and adjustments for recording velocity data alongside pitch. This setup allows for seamless real-time sequence variations and creation during performances or live streams.

I find my initial simple version to be more fluent than the more feature-rich iteration, though each has its place depending on the specific requirements of a user. The first version doesn’t require toggling a record button and fits well in spontaneous creation contexts.

Finally, I highlight how you can save your step recordings as presets, adjust sequence length, or alter playback speed with the grid to customize your experience further. If desired, you can also synchronize playback with the transport control of Bitwig for additional flexibility.

The video ends with me encouraging viewers to try out the preset themselves, explaining how easy it is to build upon the foundational patch I've shared. I hope this video helps you understand and utilize Bitwig's Note Grid effectively. Don't forget to like the video, subscribe to the channel, and leave any questions you might have in the comments. Thanks for watching, and I'll see you in the next one!

How to add a "Rest" Step? Is this possible? #

You can’t add a "no pitch" step to the array, but you can send a special note that's very low, like C-1 or C0. Filter this note out before sending it from the grid and use it as a trigger to "remove" a gate trigger. So when C0 or C-1 plays, it won’t trigger or send the pitch. That’s a very simple solution to the problem. It could look like this patch here:

Another solution could be to record "rest" steps in a separate array, but we’d still need to trigger them with something like a key press or button press. So I think the first solution is sufficient.

Are there any ways to manipulate the read phase to get variations of the pattern? #

The array uses a "phase" signal to access the correct cells. Yes, you can modify the signal using modules from the "Phase" category (and others), like the "Reverse" module shown in the image to play the sequence backward.

Another idea is to use the "Mirror" module for sped-up back-and-forth playback of the pattern, the "Shift" module to offset the playback position, or "Bend," "Pinch," or "Sine Mod" for more randomized playback patterns!

Disclaimer: I’m not sure how the array works internally, but I assume the array size (set in the inspector) is crucial for reading the correct cells. For example, if the array size is 160 and you want to save a 16-step pattern with a ramp phase signal, you’d likely save a step in every 10th cell. However, altering the phase signal could cause the quantization to access cells with no saved values.

To avoid this, ensure the array size matches your desired step pattern length (e.g., 16 steps = array size 16) to prevent empty cells.

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] Hey, folks, welcome back to another video.
[00:00:02] So today we are gonna create some kind of step recorder
[00:00:05] inside of the Note-Grid of Bitwig Studio.
[00:00:09] And I try to keep it as simple and easy as possible
[00:00:13] for everyone to follow along.
[00:00:15] But first we have to answer the question,
[00:00:17] what actually is step recording?
[00:00:19] And I think the best way to show it to you
[00:00:21] is on my Arturia key step here.
[00:00:24] It's not German enough.
[00:00:29] So here we have a step integrated step sequencer
[00:00:32] that we can use but not everyone has a key step pro, right?
[00:00:36] So that's why we want to recreate it in the Bitwig grid.
[00:00:40] But here there's a step sequencer on there
[00:00:43] and you can see at the moment the transport is stopped
[00:00:46] and we can hit record.
[00:00:48] And the first step is flashing.
[00:00:52] So it's ready to take some notes, right?
[00:00:55] So we can play some notes here.
[00:00:58] And on every key press,
[00:01:00] we advance inside of the sequence step by step.
[00:01:03] Until we hit the end of the sequence, of course,
[00:01:16] and then we can override the whole sequence again
[00:01:18] if you want to, or we can just let it play.
[00:01:27] And it's sometimes really nice to create some sequences
[00:01:30] like this on the fly.
[00:01:32] You can also change the playback speed, of course.
[00:01:36] So a bit slower.
[00:01:42] So that's step recording.
[00:01:48] So it's very nice if you just want to create some melodies
[00:01:53] on the fly.
[00:01:54] I use this all the time here with the Poly-D.
[00:01:56] There's also an integrated step sequencer
[00:01:59] or step recording sequencer.
[00:02:01] Very, very nice.
[00:02:03] So, but some people don't have it, right?
[00:02:06] They don't have a step sequencer at hand.
[00:02:08] And we can use here the note grid for that.
[00:02:12] So inside of the note grid, we can utilize as a buffer.
[00:02:15] We can utilize, what's the name, array.
[00:02:18] So here we want to store all the pitch informations
[00:02:22] for each step.
[00:02:24] And to access each step, we use a counter.
[00:02:27] So here with the counter, we can decide how many steps
[00:02:30] we want to have.
[00:02:31] At the moment, it's eight.
[00:02:32] We can also use here 16.
[00:02:34] I just use eight for this experiment.
[00:02:36] So we can use this to change the position in our sequence
[00:02:40] and we go here to the right face.
[00:02:43] So this is the position where we want to write
[00:02:46] a pitch information.
[00:02:48] So at the moment, it's a beginning here, it's zero.
[00:02:51] So then we need the pitch information
[00:02:53] that's coming here from the MIDI keyboard, of course.
[00:02:57] And then we need here a gate input to actually save.
[00:03:01] So take this value here and save it at this position.
[00:03:04] That's a write operation.
[00:03:07] You can call it like this, a write operation.
[00:03:09] And then we want to also advance here the counter
[00:03:14] every time we hit the gate or we hit a note on the keyboard.
[00:03:19] So we can already write some informations here.
[00:03:24] (drums playing)
[00:03:26] Into the array.
[00:03:28] So we already recorded the sequence.
[00:03:31] To play this back, all we need to do is to use
[00:03:34] a second counter here, maybe call this playback
[00:03:39] and go into the read phase and then use a pulse
[00:03:45] or a trigger module here.
[00:03:47] We want to play this back here with eight notes speed.
[00:03:52] And then this one here goes through the array
[00:03:55] and recalls all the pitch informations we just stored.
[00:04:00] So this gets also different color here for some reason.
[00:04:03] And then we go out to the pitch output here.
[00:04:06] And then we can use this as a trigger.
[00:04:08] So it plays back exactly what we just played on the keyboard.
[00:04:13] So that's basically all you need to create
[00:04:19] step recordings on the fly.
[00:04:21] In my opinion, this is completely fine, just enough.
[00:04:26] It's, you don't need anything more
[00:04:28] because you can also on top of this record something new.
[00:04:33] So we play now something different on the keyboard.
[00:04:36] Can show you this here.
[00:04:38] (drums playing)
[00:04:41] (upbeat music)
[00:04:44] (upbeat music)
[00:05:13] In my opinion, this is all I need, right?
[00:05:17] But it's a bit basic if you want to, you know,
[00:05:19] give this someone else as a patch.
[00:05:22] It's probably not that easy, but in my opinion,
[00:05:24] it's completely fine for me.
[00:05:26] That's all I need.
[00:05:28] So we can implement a bit of playback and recording logic.
[00:05:31] There's also velocity here.
[00:05:39] So yeah, that's something I show you later on here
[00:05:42] with the velocity.
[00:05:43] We can also record velocity, of course, here for each step.
[00:05:45] So let's first implement here a playback button.
[00:05:52] So I use a toggle, this one.
[00:05:56] So we can stop the playback.
[00:06:00] Playback, nice.
[00:06:05] So the playback logic is very easy here.
[00:06:10] Just hit this to play and hit this to stop.
[00:06:13] So we can use this here maybe also as a remote playback.
[00:06:18] Nice.
[00:06:20] So the recording logic is a bit more complicated.
[00:06:24] So we use a button here.
[00:06:25] Maybe move this a bit out of the way here.
[00:06:29] Use a button and call this record.
[00:06:33] And then we use a latch.
[00:06:35] And the latch just changes the value between zero and one.
[00:06:39] And we can decide when we want to do it.
[00:06:41] So when we hit record, of course,
[00:06:42] we want to switch to one.
[00:06:44] So recording question mark, is it true?
[00:06:49] Is it true that we are recording?
[00:06:51] If we get a one, then yes.
[00:06:52] If you get a zero, then no, not so much.
[00:06:55] So we use a select then.
[00:07:00] And the select then decides what to do when it gets a one.
[00:07:06] So when we hit record here, we have here one.
[00:07:11] So this switches then to the second input.
[00:07:14] So every time when we record,
[00:07:16] we want to have a gate to advance the counter here
[00:07:21] of the recording process.
[00:07:24] And every time we don't record or when the record is stopped,
[00:07:31] then we don't want to advance this.
[00:07:34] So when do we want to stop recording?
[00:07:37] Of course, every time when the sequence is finished,
[00:07:40] so when we finish to record a sequence.
[00:07:43] So we can do this here with a bit of logic,
[00:07:46] very easily this one.
[00:07:50] So when this signal here goes back to zero,
[00:07:53] when we are back at the beginning of the sequence,
[00:07:56] then send out here a gate signal to switch this back to zero.
[00:08:01] But you can see here, it's not working
[00:08:03] because we are kind of create some feedback loop.
[00:08:08] So inside of the grid, we need to use here a long delay
[00:08:11] to introduce a bit of delay or delay buffer for the feedback.
[00:08:18] It's not 0.02 milliseconds here, don't be fooled.
[00:08:22] It's actually the minimum is the sample rate
[00:08:26] of your audio setup here.
[00:08:28] For me, it's 10 milliseconds, right?
[00:08:32] So this is now here at 10 milliseconds delay.
[00:08:36] Go back in here.
[00:08:39] It's also yellow.
[00:08:41] And yeah, so when the sequence is finished,
[00:08:46] we switch off the recording.
[00:08:47] So recording on, record, back to zero, right?
[00:08:54] We switch it off because we just finished recording here.
[00:08:58] Yeah, the sequence, that's all you need.
[00:09:01] Recording on, record all the steps until we hit eight,
[00:09:07] back to playback, right?
[00:09:09] So now we want to have also something different here.
[00:09:18] At the moment, we get pitch information here from the array
[00:09:22] and we get the trigger here from this trigger module.
[00:09:27] So when we record, we want to actually hear what we play
[00:09:32] on the keyboard.
[00:09:33] We don't want to hear what's coming from the array
[00:09:36] and what's coming from this trigger module.
[00:09:38] We want to hear what we play.
[00:09:40] So we have to switch this here on and off when we record.
[00:09:44] So we use here another select, maybe call this here,
[00:09:50] advance inside of the sequence.
[00:09:53] Maybe use this here.
[00:09:56] So this is gates.
[00:09:57] So every time we record, we have here one.
[00:10:04] So the switch is down to this input.
[00:10:08] So every time we record, we want to hear the original gate
[00:10:13] informations and we also want to hear the original pitch
[00:10:19] informations.
[00:10:23] Yeah, let's call this pitches here.
[00:10:27] And when we don't record, we have this input check here.
[00:10:29] So we want to hear the pitch coming from the array
[00:10:32] and we want to hear the triggers coming from the playback.
[00:10:38] That's the idea.
[00:10:39] So we have a bit of recording and playback logic here now.
[00:10:43] So you can see the playback logic and the recording logic
[00:10:45] is more complicated than the step recorder itself.
[00:10:51] But that's always the case with applications
[00:10:53] or when you are the developer, right?
[00:10:55] The user interface is always the most complicated thing
[00:10:59] in the whole application.
[00:11:00] And the logic to make actually the function
[00:11:04] or the business logic or how we want to call it
[00:11:07] is not that big because that's where the computer hits reality
[00:11:13] or the patch hits reality, right?
[00:11:15] The interface, the connection with the user.
[00:11:19] Anyway, doesn't matter.
[00:11:23] So recording is in there.
[00:11:26] We can use this here.
[00:11:27] So we can hit record and hit playback.
[00:11:32] Maybe call this recording, recording.
[00:11:37] And we can also influence the playback speed
[00:11:40] with the steps or the triggers module here.
[00:11:45] Triggers for each bar, so eight triggers at the moment here.
[00:11:52] And this should work.
[00:11:53] Let me let me try this out here for a moment.
[00:11:56] Recording and then we play the notes.
[00:11:59] We can hear what we play on the keyboard.
[00:12:01] And then it stops recording.
[00:12:08] So we can't hear what we play on the keyboard anymore.
[00:12:11] So it's just stopping, which is very nice.
[00:12:14] We can just leave this on.
[00:12:16] You can leave it recording on if you want to.
[00:12:19] And then hit playback.
[00:12:20] So let's duplicate this here also for velocity.
[00:12:41] Velocity, and this is pitch.
[00:12:46] Pitches.
[00:12:49] So we go in here with the velocity information.
[00:12:53] We give this a different color.
[00:12:56] We also need here this one for the--
[00:13:02] give this also a different color.
[00:13:07] So we use here this then.
[00:13:10] And here we use that.
[00:13:14] You can put this on a different place.
[00:13:16] I don't know what's better here.
[00:13:20] Something like this.
[00:13:22] OK, let's try this out again.
[00:13:25] Recording, so we start with zero here.
[00:13:28] So I used there a bit more velocity.
[00:13:36] So you can see that we are recording this.
[00:13:38] [MUSIC PLAYING]
[00:13:41] Bam, step recording.
[00:13:48] So then when we have this, we, of course,
[00:14:02] can just duplicate this here to another track
[00:14:06] and use maybe another Polymer.
[00:14:10] Stop playback and use maybe four triggers only.
[00:14:14] Just record this here octave lower.
[00:14:16] Oh, we have to.
[00:14:22] [MUSIC PLAYING]
[00:14:26] But in my opinion, my first iteration,
[00:14:47] without all the logic, was much, much better.
[00:14:49] It was more fluent, in my opinion.
[00:14:52] But you can see you can easily here create stuff like this.
[00:14:57] And if you do live streams or live events
[00:15:00] and you just want to record some sequences on the fly,
[00:15:05] this is super neat because you just need to hit record.
[00:15:08] Or like you saw in my first iteration,
[00:15:11] you don't even need to hit record.
[00:15:13] You just play something different on the keyboard.
[00:15:15] Maybe I'll arm here the track and record something new.
[00:15:18] And then you have a new sequence.
[00:15:19] Without using the clip launcher, without recording
[00:15:22] into a note clip or anything like that.
[00:15:25] It's super neat, in my opinion.
[00:15:27] And I saved this here as a preset
[00:15:29] and put this in the description below so you
[00:15:32] can download it if you want to.
[00:15:36] You can advance this in all kinds of directions.
[00:15:38] You can increase here the step size.
[00:15:41] You can say we want to have 16 steps, 16 notes to record,
[00:15:47] or even more, you can go up to 64 here.
[00:15:51] So you can make the sequence longer.
[00:15:52] You can change the playback here with the triggers.
[00:15:55] You can make it slower.
[00:15:57] You can make it faster, so 16 notes here.
[00:16:00] You can use odd numbers and then put this
[00:16:03] into what's the name, a clock quantizer here.
[00:16:09] Something like this.
[00:16:10] And then synchronize this to 16 notes.
[00:16:13] Then you have more like a more rhythmical.
[00:16:16] Maybe you like this.
[00:16:29] We can also create another instrument track.
[00:16:31] And I show this all the time because people keep asking me
[00:16:34] this every time I make something here with the note grid.
[00:16:37] They want to know how to record this.
[00:16:41] So we can just record the note grid into another instrument.
[00:16:50] So this is coming from the note grid, of course.
[00:16:54] So you can save it then in a note clip if you want to.
[00:17:00] You can also bind the playback here to the playback
[00:17:05] or the transport of the sequencer.
[00:17:09] So we can say, what's the name?
[00:17:11] Playback, transport playing, something like this.
[00:17:16] So maybe use your modulator out for this
[00:17:20] and then activate playback.
[00:17:24] So every time we play on the transport,
[00:17:26] we activate the playback and play it back.
[00:17:32] The sequence here starts where you stopped the playback.
[00:17:36] So you can also say, every time I hit the transport here,
[00:17:40] I reset playback and start from the beginning of the sequence.
[00:17:47] Or you can use a transport and bind it
[00:17:51] to the position of the transport.
[00:17:55] So every two bars, we get here a trigger signal
[00:17:58] and we reset every two bars the playback.
[00:18:06] So that's also possible.
[00:18:07] So all kinds of different tweaks you can do to this patch.
[00:18:12] But I still like my first iteration, the very simple one
[00:18:16] the most because it's so fluent to work with.
[00:18:19] Maybe call this here step recorder, something like this.
[00:18:26] Save preset, step recorder.
[00:18:30] That's note, a little rhythmic probably here.
[00:18:37] Record step note input or something like this.
[00:18:44] So yeah, so I put this in the description below.
[00:18:47] So you can use it if you want to.
[00:18:49] I hope you learned something about the note grid.
[00:18:51] Keep asking questions, like the video,
[00:18:54] subscribe to the channel, whatever you want to do.
[00:18:58] Thanks for watching.
[00:18:59] See you in the next video, and bye.
[00:19:01] [BLANK_AUDIO]