Bitwig Recorder Module - Short Sampler, Looping, and Glitch Techniques

[00:00:00] Hey, welcome back to another video. Today is about the Recorder module of Bitwig Studio. It's a grid
[00:00:06] module, it's fairly simple module, it's easy to explain, but there's a lot of stuff you can do
[00:00:13] and I want to show you some examples of course and some inspirations you can do for yourself
[00:00:17] with the video or maybe after the video. So let's dive into Bitwig Studio and I'll show you how
[00:00:24] this works. So we have here an audio track, there's an instrument track here I can delete,
[00:00:30] it's not important, so we have here just a normal funky soul break.
[00:00:34] So super simple drum loop and this is what I want to use to explain how the Recorder works.
[00:00:46] So what we need now is an FX grid module and you can use the Recorder module of course also
[00:00:53] inside the pulley grid which is the instrument version of the grid. This is the audio FX version
[00:00:59] of the grid. Works exactly the same as the pulley grid, the only difference is that you have here
[00:01:04] a mix knob and you have a pre FX and a post FX and it's wired up as an audio FX audio effect device
[00:01:13] where you have an audio input here and audio output and you can hook up modules in between
[00:01:17] to auto a signal and you can also use the mix knob here to bring in the try signal and mix it in with
[00:01:22] your effect signal and besides that it's completely it's the same thing. So how do we start? We start
[00:01:35] with the Recorder module here bringing it in. So this is how the Recorder module looks like.
[00:01:40] We have an audio input, we have an audio output, simple, we have a trigger for the recording and
[00:01:48] we have a trigger input for the playback. So you can record something and you can playback audio,
[00:01:52] simple. So now we open up here the help menu and it says we have record control like I said,
[00:02:00] note this input is mono. So we have a signal input and play control sets whether the playback is
[00:02:11] occurring, sets whether recording is occurring. So we can record something with trigger signals
[00:02:20] or with gate signals and it's also saying your recorder and delay. It's basically just a temporary
[00:02:28] delay buffer. So every time you record something and you save it as a preset and reload the preset,
[00:02:40] it's gone. It's just for the moment and it doesn't survive reloads or project saving. So it's
[00:02:47] a simple device. It's just an in-memory recording buffer basically. So what we do now is we
[00:02:58] let's playback actually here what it does. So the audio goes in, the audio goes out,
[00:03:03] so we hear something. So now we go into the Recorder module and we go out of the Recorder module.
[00:03:09] When we play back now, there's nothing because the Recorder module is actually doing nothing. It's
[00:03:16] just staying there and being lazy. And what we use now is a button module here and we call this
[00:03:26] playback and we hook this up here with the play input and also use the button here for the recording.
[00:03:36] Call this Recording and now we start the playback here and then we can record something. So we hit
[00:03:46] Just Record and when I disable this, it stops recording. So only when the trigger signal
[00:03:54] or the input signal of this gate input here is high or has a value of one, this one is recording
[00:04:00] until the signal is back to zero again. Also the same for the playback, it's the same. So when we
[00:04:07] play back here, it plays and when we disable this button, it stops exactly at this position.
[00:04:14] There's sadly no way to continue the playback from this position on here. When you hit Playback
[00:04:22] here again, it starts from the beginning. Also for the recording, if you hit Stop and record again,
[00:04:30] it starts from the beginning again. So there's also no possibility to change the offset of this
[00:04:35] playback or recording head and there's also no way of changing the playback speed or recording
[00:04:41] speed or whatsoever. It's a fairly simple device like I said in the beginning. So now we bring in
[00:04:47] here the original try signal. You can see it's completely messed up. So there's no sync at all
[00:05:03] and the reason for that is we started recording and playback somewhere on the grid somewhere in
[00:05:09] between the drum loop. So there's no synchronization at all happening and I initially thought maybe
[00:05:17] I give you some ideas of the clock quantizer and so on, but it gets too complicated at first.
[00:05:22] I maybe show you this later. So we switch out here the playback and the recording for gate
[00:05:31] modules, which is easier to do in the beginning. Maybe do this here to the side and put this down.
[00:05:38] So now we can use two gate modules to trigger recording in a kind of beat grid way. It's
[00:05:49] synchronized to the project tempo and you can also switch here some gates off and on if you want
[00:06:00] and you can repeat it in a different way. So now we switch here to gate mode and we maybe record
[00:06:08] from the second snare drum on until the end of the breakbeat. So you can see we basically want
[00:06:16] to start recording here and we want to record everything until the end from here. So we want
[00:06:22] to leave this out. So we want to have the snare drum at the one because we want to
[00:06:28] re-trigger the snare drum all the time. So I do this here by just leaving these two
[00:06:36] gate slots free. Start with the snare here and switch this to gates mode. And gates mode is
[00:06:44] basically there's not actually an important difference. So we may go here to the oscilloscope,
[00:06:51] switch to slow. You can see the first part here is basically the lower state and then we switch
[00:06:58] the high state and we stay on the high state until we are back here at the first empty slot.
[00:07:05] When I switch this to the trigger triggering mode, it's quite different. For each slot here
[00:07:15] we get a different high and low state and you get a single empty slot or single no trigger
[00:07:25] area here from these two. So this is basically important part. So when we switch this to gates,
[00:07:33] we make this whole section here just one big single trigger. And this is exactly what we want
[00:07:42] for the recording. We want to have recording here from the snare drum up until the end and then we
[00:07:48] want to switch the low state and stop recording. You can see here the red part or the red dot
[00:07:55] is actually recording exactly in time over and over again. So now we can switch it to the
[00:08:02] to the playback triggers and we have to see on triggers. We have a single, we have multiple
[00:08:11] triggers for all these slots. I'll put this down here. So what we do basically is we start by
[00:08:21] sampling the snare, everything until here. And then we play back this part here over and over again.
[00:08:28] So let's basically just do this, right? This is what we do. And this is also how it sounds. So let's do it.
[00:08:43] And when we bring in the original tricycle, we can mix these two sound sources together.
[00:09:10] And now we can of course, you just disable all these and just bring in some ghost notes.
[00:09:35] So now you can create nice little devices which fill in gaps of your drum loop. You
[00:09:41] can also use your post FX maybe with some filtering if you want. So maybe use a filter here.
[00:10:01] So just some rough ideas for creating interesting drum bits.
[00:10:05] You can also change here the step count maybe to 16 and get some some clitchy flavors in here.
[00:10:30] Or maybe you can also go back here to 8, switch this to gate and just play back the whole
[00:10:39] section here from this different position basically. Let's try this.
[00:10:59] So we now have the problem here that the playback stops at this position
[00:11:03] and it shouldn't stop there. And the problem is that the recording here basically is not done
[00:11:11] when this yellow dot is at this position. So it stops playback here because the recording
[00:11:18] is not done. So what we have to do is we have to cut here the recording after some point. So
[00:11:28] maybe use a select, select here. Go to this, this and use a button. Call it recording.
[00:11:49] Now you can see
[00:12:05] it plays back basically the whole last part here,
[00:12:10] and now recording is basically done one time and then it stops recording at all. So you have to
[00:12:18] play around with a lot of logic to bring in when do you want to record, how to start recording,
[00:12:24] how to stop recording, when do you start the playback and also you have to be
[00:12:29] aware of all the differences when you recording. Sometimes the recording is not done,
[00:12:38] the playback also stops and so on. So there's a lot of things going on with the recorder you have
[00:12:44] to be aware of and like you see here with a lot of logic around the recording module you can make
[00:12:51] this work and you can make interesting effects with it. So now that we have all this stuff,
[00:12:56] this logic in place and we know how the recorder kind of works, we can go completely nuts with all
[00:13:04] the logic around it and trigger it when we want it and how we want it. So for instance,
[00:13:12] like I said in the beginning with the playback and the recording button, maybe I show you this now.
[00:13:17] Maybe just we delete this here again. So we have a recording, we have a playback
[00:13:25] and we want to start the recording exactly at the beat event or grid event. So we need the clock
[00:13:32] one ties and we also need the trigger signal. So we go for triggers here and this is our clock
[00:13:44] basically which decides how much we want to divide our beat grid and when do we want to trigger
[00:13:51] something on here and you can also use the clock one ties down here. We use also the clock signal
[00:13:57] down here, we use this for the recording. So now we have a different problem. So I'm going
[00:14:04] here for the oscilloscope to show you this. Switch this to slow, this to slow, yeah okay,
[00:14:13] like this bit longer so we can see what's going on. So here we have the delayed signal which is the
[00:14:18] synchronized signal which is synchronized to this trigger clock here and we have our initial button
[00:14:24] press or our initial event. So when we press this here as you can see at the top it's delayed
[00:14:32] as you can see in here and it's delayed because of the trigger signal of our clock one ties right.
[00:14:41] It delays the signal until the beat grid is at the right position and then it starts to pass on
[00:14:49] the event or the trigger signal. So the problem here as you can see it switches back to the
[00:14:55] zero state at some point without us switching back to zero. We are still, we still want to record
[00:15:03] here right but it switches back to zero and that's because of the trigger module trigger signal sends
[00:15:09] out a high and low state all the time which is basically the clock signal as you can see it's
[00:15:20] on off on off and this clock one does uses this as an guide as to when to pass on a certain event.
[00:15:30] So when we trigger on trigger this one here it waits until something happens and then it switches
[00:15:36] on as you can see and then it switches off here again. So this is something you don't want to have
[00:15:42] because you want to still hold the value at one until we release the button press here right.
[00:15:58] So you have to introduce a lot of more logic to make this happen and we can do this by using
[00:16:05] a latch module for instance. So what we do now is maybe I've got this all off here so it doesn't
[00:16:14] look so complicated. So what we want to do is we want to press this button then we want to delay
[00:16:22] this button press until it's quantized to the grid then we want to switch to the high state which
[00:16:28] is one okay we pass this on here and then we want to stay on the high state which this is exactly
[00:16:36] what the sledge module does it stays on one all the time until it gets a different information
[00:16:42] and you want to switch to zero again when we press or when you release the record button
[00:16:50] right and we do this by using a not logic module and go to zero. So what this does is
[00:16:59] basically when we release this or send out a zero signal zero becomes here a one and this one sends
[00:17:06] out a one to zero okay. So now we have this we have this quantized signal here which is something
[00:17:16] we did before. So we press here then it gets delayed as you can see here then it switches off
[00:17:24] but it stays on because the latch module doesn't get any different information. Now we switch this
[00:17:32] off this one becomes one and this latch then switches to zero okay. So now we have basically
[00:17:40] exactly what we want we want to delay our initial trigger until it's synchronized to the grid and
[00:17:48] then we want to stay at the high state as long as possible until we release the button here
[00:17:55] and then we switch back to zero. The problem is that the release of this button press is also
[00:18:02] off the grid so we can also clock quantize this if we want so we can do this.
[00:18:09] So now we have both the initial trigger and the release synchronized to the grid so let's try
[00:18:16] this it's delayed so now we have high state this one stays high because of the latch this one goes
[00:18:23] back to zero here because of the clock quantizer that's not what we want but we want to stay exactly
[00:18:28] at at high then we switch off it gets delayed because of the clock quantizer and it's exactly
[00:18:36] releasing on the on the grid okay. So this is basically a bit of logic you have to do
[00:18:43] but it's this is the signal exactly we want to trigger the recording and to release the recording
[00:18:52] okay so we clock quantizing the initial trigger and the release okay so let's
[00:18:58] let's try this so it's recording release and it records until the beat grid says so and it's
[00:19:10] they make this record release and done
[00:19:20] oh we have to use this one of course
[00:19:26] yeah and maybe we can use here and gate repeat
[00:19:38] gate repeat go trigger mode make this shorter
[00:19:43] maybe go here too
[00:19:49] maybe
[00:20:03] so
[00:20:27] that's maybe something we can use so now we have a gate repeat here which is completely off the
[00:20:35] grid but this also sounds interesting it's a kind of a glitch effect right
[00:20:53] so maybe we use here an ads ad and we modulate this let's try it out and we trigger this
[00:21:02] we trigger this maybe with the gates module
[00:21:09] maybe here and here I don't know
[00:21:16] so
[00:21:27] so
[00:21:38] so
[00:21:49] so
[00:22:00] so
[00:22:13] okay so we can kind of create these nice little glitch effects with this
[00:22:30] if if you think this triggering is too often here then maybe we can use a scalar
[00:22:48] and slow down near the phase signal which is the course of our speed
[00:22:59] phase phase in
[00:23:02] then slow this down maybe to this let's try it out
[00:23:14] so
[00:23:26] that's better
[00:23:38] okay so now we have this effect which sounds kind of nice
[00:23:55] maybe we stop this with the playback so we go for a
[00:23:59] transport playing and the select here
[00:24:06] let's switch this only on when the playback is playing so now we have a glitch effect okay
[00:24:13] glitch maybe duplicate this so we have two of these devices now and the first one here
[00:24:23] we modify this to maybe just a regular ghost note creator
[00:24:40] so
[00:25:08] oh maybe we also delay this here a bit nice
[00:25:15] switch this off and go for gates
[00:25:42] maybe we also use this one time
[00:25:58] select
[00:26:14] so
[00:26:24] so
[00:26:36] okay maybe use a notch here for different rhythms
[00:26:51] and then we switch between these two states here at random with the dice
[00:27:03] or with the yeah with the dice let me trigger this
[00:27:14] so
[00:27:41] i really switched this here to a probabilities thing
[00:27:45] so we don't want to trigger this every time we would just want it to have this sometimes
[00:27:52] and this is basically how you can spice up your drum loops with the fx grid and the recorder
[00:28:11] but there's a lot of stuff you can you can do with this there's also not only things for
[00:28:20] drum loops you can also use this for reverbs and i don't know just repeat certain patterns and maybe
[00:28:28] use different playback speeds maybe you can do here another one fx grid
[00:28:37] use the recorder this in here and then maybe just also go with the button first
[00:28:46] i always like to start simple and then make it complex over time so you don't lose track
[00:28:54] what you actually want to do so yeah maybe we use here and
[00:29:05] gate repeat
[00:29:06] and the gate repeat here
[00:29:29] maybe some kind of buffer buffer effect
[00:29:32] maybe a dice
[00:29:36] maybe you'll watch it later
[00:29:40] trigger
[00:29:58] or you can also bring in maybe a filter
[00:30:00] maybe you can also use the second dice
[00:30:16] so now we have switch up between the different filter positions right pretty harshly
[00:30:27] but you can also maybe use a leg
[00:30:31] so if we watch this here on the oscilloscope
[00:30:39] so we get from the dice signal from the dice module we get random values out
[00:30:46] but with the leg module we can kind of get some transitions between this
[00:30:55] maybe try out the average module
[00:30:56] yeah we get some rounded edges here
[00:31:01] so now basically we have a nice transition between the filter frequencies here
[00:31:23] maybe use the reverb on the input
[00:31:25] optimize here a bit the filter the recording and the playback
[00:31:41] so
[00:31:44] so
[00:31:47] so
[00:31:50] so
[00:31:53] so
[00:31:55] so
[00:31:58] so
[00:32:01] so
[00:32:04] so
[00:32:07] so
[00:32:09] so
[00:32:22] so
[00:32:35] so
[00:32:54] i have to interrupt this video at this point because i forgot that i actually
[00:32:57] was recording a tutorial and i was completely lost i played around with all the modules for
[00:33:05] another hour or so but i want to just give for this video a rough idea about the recording module
[00:33:11] and what kind of logic modules you need around the recording module to make it work or to make
[00:33:17] it kind of interesting and this example it was just a drum loop to make it more fancy
[00:33:22] and you can of course use it for pad sounds lead sounds bass sounds whatever bring in some artifacts
[00:33:30] record and loop back at different positions in time it's interesting it's fun and you can
[00:33:37] learn a lot so leave a like if you like the video hit me up with some questions in the
[00:33:44] comments if you want to and yeah i hope to see you soon maybe this week with the live stream
[00:33:49] on this channel so make sure you subscribe and also activate this shitty small notification bell
[00:33:56] Thanks for watching and I'll see you in the next video. Bye.