Tags: posts polarity-music Bitwig Instrument Preset Tutorial Sampling

Drum Auto Slicer in Bitwig

Tutorial | Nov 07, 2023

In this video, I discuss the limitations of the sampling mode in Bitwig Studio, particularly the lack of a slicing feature. To overcome this, I demonstrate how I created a custom slicer within the Bitwig Grid, allowing for easy mapping of slices onto the MIDI keyboard. I provide an overview of the patch and explain the functions of the transient detector, slice mapping, and play triggers.

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

In my latest video, I talked about how Bitwig Studio's sampler lacks a slicing mode—a feature I believe is essential for such a dynamic instrument. Here are the key moments from the video:

Thanks to everyone who watched, and I reminded viewers to subscribe to the channel for future updates. The link for the patch download is in the video description on on my patreon page.

Questions & Answers

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

What is the issue with the sampler in Bitwig Studio?

The sampler in Bitwig Studio does not have a slicing mode, which allows users to drag in drum or percussion loops, detect transients, and create slices to map onto a MIDI keyboard. This is a limitation that I find puzzling, considering Bitwig's dynamic nature and the fact that the sampler was revamped a few years ago.

How did I address this issue?

I came up with the idea to create a slicing feature within the Bitwig Studio grid. I built a module that detects transients, stores their positions in an array, and allows users to map these slices onto a MIDI keyboard. While I can't show the entire process in the video, I provide a detailed explanation and demonstration of how it works.

How does the created slicing feature work?

The slicing feature I built within the grid uses a transient detector to detect transients in a drum loop. The detected positions are stored in an array and can be recalled and mapped onto a MIDI keyboard. Users can trigger and play these slices using the keyboard or through the sample slice knob. The feature also allows for pitch changes and looping.

Is the created slicing feature efficient and user-friendly?

Although I admit that the process of building and tweaking the feature took time and effort, the end result is a simple and efficient solution to the lack of a slicing mode in Bitwig Studio's sampler. I provide a downloadable version of the patch on my Patreon page for users to experiment with and customize. I also express hope that Bitwig Studio will include a similar feature natively in their sampler to enhance user experience.


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] The sampler of Bitwig Studio unfortunately doesn't feature a slicing mode, you know,
[00:00:07] where you can drag in a drum loop or a percussion loop, detect all the transients, create slices
[00:00:13] from that and then map out these slices onto the MIDI keyboard.
[00:00:18] So that's not part of the sampler and I don't know why they included one yet when they revamped
[00:00:25] the sampler a few years back. They haven't actually included a slicer into the sampler.
[00:00:30] I don't know why. In my opinion, Bitwig is a highly dynamic instrument so it needs to
[00:00:35] feature at least a slicer where you can drag in samples on the fly and map it onto the
[00:00:42] keyboard pretty easily and fast.
[00:00:45] So I had this idea, maybe let's create one actually inside of the grid and that's exactly
[00:00:53] what I did and it looks like this, what you can see on the background and unfortunately
[00:00:58] I can't show you how to build this from scratch in a video.
[00:01:03] It would take too long and not like building all these things here, these building blocks
[00:01:10] but more like tweaking everything so it works nicely. It's more like finding the right sweet
[00:01:17] spots, debugging stuff and so on.
[00:01:20] So this is how it looks like. We have here in the middle the sampler as a module inside
[00:01:26] of the grid and there's a drum loop in there. It sounds like this.
[00:01:32] Right so just a normal drum loop with kick, snare, hi-hats and so on and a bit of percussion.
[00:01:38] So we want to map this now onto the MIDI keyboard. So I have here created a transient detector
[00:01:45] where we detect all the transients and create position signals from that, store that into
[00:01:53] an array and then we can recall these settings from the array and map this onto the keyboard.
[00:02:02] So what you do usually here is you load in a sample a drum loop like this and then you
[00:02:07] hit the scan button here, right? And then I scan through the sample and you can see
[00:02:13] here down here we detect basically all the transients with the transient detector and
[00:02:18] every time we detect one transient we trigger basically here the transient store and store
[00:02:24] the position of the playback, playhead in the sampler here.
[00:02:31] And now what I have if I use this button I switch to keys and now I can play on my keyboard.
[00:02:38] See let me show you my keyboard down here. So we have C3, right? That's the first sample
[00:02:47] or the first slice and D# or C# is the second one.
[00:03:02] So we can play basically all these detected slices in the sampler just with the keyboard.
[00:03:08] You can also trigger this here or you can switch the keys off. So now you basically use the
[00:03:16] sample knob here or the sample slice knob so we can scan through all the detected slices
[00:03:23] here, right? What you also can do is you can change the pitch of course from everything
[00:03:35] and I use the loop mode so we can also just loop this.
[00:03:47] Right you can do stuff like this. So it works like you would use a slicing feature in any
[00:03:53] other slicing sampler ever. So I try to do this. I also try to explain everything here
[00:04:01] with a lot of text how this stuff works. It's not actually that complicated in theory but
[00:04:09] I needed to make a lot of conversions sometimes. It's probably or you can make this patch maybe
[00:04:16] even simpler because I'm using here not the normalizing feature of the array. I switched
[00:04:24] this off because I wanted to have integers for the index. So basically the first slice
[00:04:31] has the index one, the second slice has index two and so on. So I need to make some conversions
[00:04:37] here for the key mapping. So here if you use the keys or the pitch input from the keyboard,
[00:04:44] C3 is zero and C# is 0.013 or something like that. So I needed here to multiply this.
[00:04:54] These values to get an integer. So C is zero and C# is one, D is two and then I use these
[00:05:03] numbers basically to recall here the positions from these arrays. It's maybe interesting also
[00:05:10] to look at the transit detector how I try to solve this problem here. I basically just
[00:05:15] use an envelope follower which is rectified and lacked amplitude here from an audio signal
[00:05:25] and then I delay the signal and then I subtract the delayed signal from the original signal
[00:05:30] and it gives you as you can see here pretty nice indications where a transient occurs
[00:05:38] where you basically have a drastic volume change where the volume ramps up pretty fast.
[00:05:45] So with this you get this pretty easy. You can also try to play around with the false
[00:05:49] setting and the delay setting to see how it influences the transit detection because if
[00:05:54] you go down here with these values you detect more things inside of the sampler. You can
[00:06:03] also try to include here maybe filters. So let's say bandpass filters if you want to
[00:06:09] exclude for instance hi-hat sounds or noise clicks and stuff like this. So you can filter
[00:06:16] the sound before you go into the follower here and then try to use that for the sample
[00:06:22] detection or for the transient detection. Then there's also something like the transient
[00:06:28] store. I'm storing basically the position here of the play hat. I go or scan through
[00:06:36] the sample and every time I detect something here I just push the position of this into
[00:06:42] the array. So we find something here that detector says hey there's a transient so I'm
[00:06:50] pushing basically this position into the array and I push this not only in this array also
[00:06:57] in this one here but then for the index I just add one and that's basically my simple
[00:07:06] solution to find the start and end point because now when I recall a position basically with
[00:07:13] the index let's say I want to recall slice two which is here. I basically take the integer
[00:07:19] of two so I get the position from this array for this position here. But I also get a position
[00:07:27] that the next slice the beginning of the next slice which is this one and this I get from
[00:07:33] this second array here because I just add a constant or the index to the just add one
[00:07:40] to the index right. So I always get the first position here of that and the position of
[00:07:45] the second array at the same time. So I use this basically as a starting point here of
[00:07:50] the start play play hat and this at the end position which is the beginning of the next
[00:07:54] slide. But then inside of the sample you don't have a start position and the end position
[00:08:02] you have a start position and then you have the length of the loop. So this was kind of
[00:08:08] a problem so I needed to calculate here the loop length in percentage. So you can do this
[00:08:15] here by just subtracting basically the start point from the end point and it gives you
[00:08:20] basically the loop length and yeah percentage and you can see it works quite well here.
[00:08:27] Certain things here the loop length basically changes to the next slice right. So this was
[00:08:36] kind of a problem you don't have like I said you don't have a starting point and end point
[00:08:40] you have a start point and the loop length which is here. I tried to solve this here with
[00:08:44] this kind of patching and it works quite well. And then start point end point is here solved
[00:08:52] by just using the same inputs just adding here one to the index so I have basically for
[00:09:01] the same index to start point and then end point. Actually a simple solution just offsetting
[00:09:06] the index. The scan process itself is just here an envelope that I trigger and then it
[00:09:14] creates a ramp signal and I use this ramp signal here as you can see the modulation to use
[00:09:21] it for the playhead and then scan through the whole sample and then use the audio output
[00:09:26] of that going to detect or here detect everything and so on. So if you don't want to use an
[00:09:32] ad you can exchange this for maybe an LFO or a clock or you can try to make it faster
[00:09:39] or slower. If you make it faster you probably have to tweak your transient detector a bit
[00:09:46] with the fall setting and delay setting because the timing changes. I made it a bit slower
[00:09:52] so you get what's happening but you can probably optimize this to do the scan process much
[00:09:58] faster. Yeah so that's that. Yeah and the rest is basically not that hard to get here
[00:10:07] just basically the slice play trigger where you use the keyboard to trigger the slices
[00:10:13] or you can just click this button here to trigger the current slice. You can change the slice
[00:10:17] here or you switch the keys mode on and then you can use the keyboard. And it also works
[00:10:32] pretty fast actually. So it's not like you have to play slow or something like that.
[00:10:40] I needed to insert here kind of a delay of 30 milliseconds. You can also play around
[00:10:45] with slower settings but the the sampler kind of needs a bit of time to switch to the right
[00:10:55] positions inside of the sampler. If you put this down to zero sometimes you know you don't
[00:11:01] trigger the right sample. So you have to have some kind of trigger delay here to yeah basically
[00:11:11] have more time to select the right slice. So that's that. As I said you can download this
[00:11:16] on my Patreon page and go into that and play around with this and have some experimentation
[00:11:23] into that. In my opinion it works really great actually for just being a simple grid patch.
[00:11:34] So I hope Bitwig includes something like that into the sampler natively just so we can push
[00:11:42] a button, detect the slices or the onsets or whatever. I mean they have the technology
[00:11:47] already in place on the audio track so why not include it into the sampler and just map
[00:11:52] everything out onto the keyboard so people can just trigger these samples on the fly.
[00:11:58] Okay that's it for this video. Thanks for watching. Link is in the description below.
[00:12:04] Leave a like if you liked the video. Of course subscribe to the channel. Super important.
[00:12:08] Thanks for watching and see you in the next video. Bye.
[00:12:13] [BLANK_AUDIO]