Tags: posts polarity-music Bitwig Tutorial

Creating Polymetric Beats with Triaz: A Grid Tutorial

Tutorial | May 30, 2024

In this video, I focus on the sequencer part of the Triaz plugin by Wave Alchemy. By using the note grid in Bitwig, I demonstrate how to create polymetric drum sequences with individual lanes and adjustable loop lengths. I also showcase techniques like changing the gate length, velocity, and implementing retrigger features using modules like Trigger, Latch, and Shift.

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


I received a request from Tamara to create a plugin remake video for Triaz by Wave Alchemy, focusing on the polymetric features of its sequencer. This tutorial only covers the sequencer part of Triaz, as the sound tab functions like a normal drum sampler. I demonstrated how to utilize Bitwig's Note Grid in monophonic mode to create self-running patches and implement polymetric sequences.

Key Points

If you need more details on specific sections or functions, let me know!

Questions & Answers

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

1. What is the focus of the tutorial on Triaz by Wave Alchemy?

I am focusing on the sequencer part of Triaz in this tutorial. The sound tab is just a normal drum sampler, so I won't be covering that. The individual lanes and their ability to change playback speed and loop length are the important features I will be discussing.

2. How is the sequencer part set up in Bitwig?

In Bitwig, the sequencer part is set up using a note grid in monophonic mode. The step count is increased to 16, and the triggering mode is changed from gate to trigger. The pre-chord is disabled, and a trigger module is used to divide one bar into 16 equal steps.

3. How can the loop length and velocity be manipulated in the sequencer?

To manipulate the loop length, you can use a modulator to change the step count negatively from 16 to -14, allowing you to loop a specific number of steps. The velocity can also be manipulated by using another step module synchronized with the gate length, allowing for independent changes in loop length and velocity.

4. How can the retrigger feature of Triaz be implemented in the sequencer?

The retrigger feature can be implemented by using a ledge module that switches between 1 and 0 when triggering a kick drum. A select module is used to switch the ledge output, and a trigger module with a 16-node sequence is used to retrigger the kick drum. This creates a glitch-like effect that can be adjusted to different speeds.


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] So I got a message by Tamara a few weeks ago.
[00:00:03] "Hi, can you please do one of your plug-in remake videos for Triaz by Wave Alchemy?
[00:00:09] I've been trying to think about how I can remake it, but my brain is breaking, because
[00:00:13] you know how each drum sound has its individual lane, so that allows for a lot of polymetric
[00:00:19] stuff."
[00:00:20] So I think this is pretty important for Tamara here, this polymetric stuff.
[00:00:24] So I'm focusing here, that's a tutorial about Triaz.
[00:00:29] I'm focusing only here on the sequencer part, right?
[00:00:33] The sound tab, it's just a normal drum sampler.
[00:00:37] So a sampler would start endpoint envelopes and so on, just normal stuff.
[00:00:43] And we only focus here on the sequencer part, because we have these individual lanes here
[00:00:49] and you can change the playback speed here and you can also change the loop length of
[00:00:53] each of these lanes.
[00:00:55] So that's the important part.
[00:00:58] Right of Bitwig here, I have just a drum machine with a default acoustic drum kit, right?
[00:01:03] It's Bitwig default.
[00:01:10] Just some drum sounds.
[00:01:12] And in front of that, we create here a note grid.
[00:01:16] And the note grid is in monophonic mode.
[00:01:18] You can see this here on the left side, voice is mono.
[00:01:21] That's pretty important, so it's a self-running patch.
[00:01:23] In monophonic mode, it's a self-running patch.
[00:01:26] That's important.
[00:01:28] Inside of the grid here, we just delete the note input because we want to generate the
[00:01:31] notes inside of the grid and then send it out.
[00:01:36] So we start by using a gate or a gate module here.
[00:01:43] And we increase the step count to 16.
[00:01:47] That's important.
[00:01:48] Make this a bit longer.
[00:01:51] And we change triggering mode here from gate to trigger.
[00:01:54] So it's a pretty short trigger.
[00:01:57] And we also disable here the pre-chord.
[00:02:01] So this one here is basically not fed by a phase signal because we want to implement
[00:02:07] this phase signal first.
[00:02:09] And for that, we use a trigger, trigger module.
[00:02:12] And we want to divide one bar into 16 equal steps.
[00:02:18] And we trigger on each step here, so this is basically just 16 notes.
[00:02:22] And then we trigger a counter.
[00:02:26] And the counter goes up to 16 also because we have 16 notes.
[00:02:31] And you want to increase the phase signal on each step until we reach basically the end
[00:02:36] here.
[00:02:37] So now we have basically the same result as before.
[00:02:42] Just implement it differently here with this setup.
[00:02:46] Okay.
[00:02:47] So my idea now is to change the loop length here was to actually use a value and to use
[00:02:58] a modulator.
[00:02:59] Okay.
[00:03:02] So first I show you here an idea.
[00:03:05] When you change the step count of the skates module, you can see it's represented here by
[00:03:10] the visuals, right?
[00:03:11] You can see how these steps basically are decreased.
[00:03:16] You can see this.
[00:03:17] But if you go down to two and then modulate here, this step count, right?
[00:03:23] And then you turn the snob.
[00:03:25] It doesn't change.
[00:03:26] It doesn't update the visuals.
[00:03:28] It stays basically here by on these two steps, which is, yeah, not good.
[00:03:37] So my idea was instead of starting with two, we go here up to 16 again.
[00:03:44] Start this in 16 and then modulate us here negatively down to minus 14.
[00:03:54] Something like this.
[00:03:55] And also here, this one down to minus 14.
[00:04:02] So now if you have this at 100%, you basically loop the first two steps, right?
[00:04:10] The visuals doesn't update.
[00:04:11] We modulate basically here the step count, but the visuals stay on 16 nodes because this
[00:04:16] is what we dialed in here.
[00:04:19] But you can see it's looping basically here these two steps.
[00:04:22] So we can reduce here the steps with this.
[00:04:25] And if you pull this down to zero, we have basically back our 16 steps as before.
[00:04:30] So we can change here the loop length with this.
[00:04:33] We can call this here.
[00:04:35] Gate length.
[00:04:38] Or actually gate loop.
[00:04:40] Yeah, gate loop.
[00:04:42] Let's call it this way.
[00:04:43] Or let's call it loop length.
[00:04:49] Something like this.
[00:04:51] Nice.
[00:04:52] So we can already trigger here the kick drum by pulling this down to, let's say, C1.
[00:04:58] That's the kick drum.
[00:04:59] Then sending out the trigger.
[00:05:09] So then we put this device here into or disable here this free run when stopped.
[00:05:16] So now it stops.
[00:05:18] And when you hit play, it starts again.
[00:05:24] What we also want to do is probably to use here play transport playing.
[00:05:29] So every time we hit play, we reset here the count of the zeros.
[00:05:34] We start at the beginning of the phase, right?
[00:05:36] So we can synchronize basically here to our start or push.
[00:05:41] It's actually not precise because if you just start here with the play at something here,
[00:05:48] right?
[00:05:49] It's not.
[00:05:50] It's it also starts at the beginning.
[00:05:52] So this is not intelligent.
[00:05:54] You have to always start here with the with the play head at the beginning of a bar to
[00:06:00] make the synchronized.
[00:06:01] You can also do something like a transport and say bar and eight bars and you send basically
[00:06:11] out here a gate signal every eight bars.
[00:06:15] And you can then use this to synchronize this.
[00:06:19] That's also possible.
[00:06:22] Yeah.
[00:06:24] So this you can do it how you want to do.
[00:06:27] But you need to reset this counter at some point.
[00:06:31] But you also don't want to reset it on every bar because you want to have here poly meters
[00:06:37] and poly meters never actually loop exactly at every bar.
[00:06:45] That's the point of having these poly meters.
[00:06:46] So it's probably better to go here for a transport something like this.
[00:06:53] Yeah.
[00:06:56] It would be probably the best way of doing it.
[00:06:59] Okay.
[00:07:00] So now that you reset or can reset this, it's kind of is completely.
[00:07:06] You put a drum here and kick from there.
[00:07:15] Something like this.
[00:07:16] Okay.
[00:07:17] So another idea would be to change actually the velocity.
[00:07:22] We can do this here also with the step or the steps module.
[00:07:28] We also increase this year to 16 steps.
[00:07:33] And with this one, my idea was to actually change also here to loop length independently
[00:07:40] from the gate length.
[00:07:41] This could be interesting sometimes for hi-hats.
[00:07:44] This is really nice.
[00:07:46] So I'm doing here.
[00:07:48] I'm duplicating this, putting this in there, disabling here also the prequad.
[00:07:52] Then duplicating this and then velocity length.
[00:07:59] And this one here doesn't change this.
[00:08:01] So we delete this and we also want to just modulate here with this down to minus 14.
[00:08:13] And also this one.
[00:08:16] Okay.
[00:08:18] Yeah.
[00:08:20] So this should, yeah, this should work.
[00:08:29] I think let me see.
[00:08:30] Push this up.
[00:08:32] Play.
[00:08:33] So now it loops basically here with this one, just the first two steps.
[00:08:41] And you can change the loop length individually from the gate length.
[00:08:45] And we have already polymeters with a velocity setting here and the gate setting.
[00:08:51] And then we just put this out here to the gate.
[00:08:56] Nice.
[00:09:01] Another idea was to implement actually the retrigger feature of Triaz.
[00:09:06] And we can do this by, or my idea for this was to use, what's the name?
[00:09:13] Ledge.
[00:09:15] Ledge here.
[00:09:16] So we switch every time we want to trigger a kick drum, we switch the ledge to one.
[00:09:22] Okay.
[00:09:23] And the rest of the times when we don't trigger the ledge to one, we want to retrigger this
[00:09:30] to back to zero.
[00:09:34] So these triggers, the kick drum triggers basically switch this to one.
[00:09:39] And these three spaces here trigger it back to zero.
[00:09:45] We can then use here a select in and say, we want to switch this down here to the second
[00:09:54] input, right?
[00:09:55] So it looks like this.
[00:09:57] So every time we trigger here kick drum, you can see it switches down to the second input,
[00:10:02] right?
[00:10:03] So the second input then uses a trigger module here, also 16 nodes.
[00:10:11] So now it's more or less like before.
[00:10:28] Let's actually use more velocity here.
[00:10:32] But with this set up, we can now do some funky things.
[00:10:36] We can use another steps module.
[00:10:42] If this may be a different color, yeah.
[00:10:47] Also switch this to 16, 16 modes here.
[00:10:51] And we synchronize this here with the first, with the gate length, right?
[00:10:56] So the gate length.
[00:10:57] So this sequence here and this sequence is always the same.
[00:11:03] So now we can use here the data input or these bars to actually modulate here the trigger
[00:11:09] speed.
[00:11:10] So maybe go up to 63 here.
[00:11:12] So we can say we want to trigger this here multiple times.
[00:11:17] Like this.
[00:11:33] You can go a bit fancy over this and you can maybe implement your multiple triggers with
[00:11:37] 16, 32, 64 and then only switch between these three if you want to.
[00:11:44] But here with this, you have more freedom, right?
[00:11:45] You can have all the triggers in between 16 and 60 or 99.
[00:11:50] I think the highest is 64, right?
[00:11:55] Or you can also, if you want to just use repeats here, that's also possible.
[00:12:03] Repeats are just a millisecond.
[00:12:05] So they are completely off the grid if you like to have this.
[00:12:09] So instead of a latch and select, you just implement your gate repeat and put this to
[00:12:13] maybe 10 seconds.
[00:12:15] I think this should work.
[00:12:16] And then you go down here with this value for this and then you trigger very, very fast.
[00:12:24] Maybe I can implement this here for a second.
[00:12:28] I'll show you this.
[00:12:31] So you do something like this.
[00:12:33] Go up and then you modulate your basically down.
[00:12:37] Let's see how this sounds.
[00:12:47] So it's more like a glitch.
[00:13:00] It's actually better.
[00:13:01] Let's use this one.
[00:13:02] It's also simpler.
[00:13:03] I like simple patches.
[00:13:05] So the less modules here have the better, in my opinion.
[00:13:13] Okay, so let's stick with this.
[00:13:16] What else can we do?
[00:13:19] We can now also just duplicate this for the rest of the lanes.
[00:13:24] So we have basically only the kick drum.
[00:13:27] Maybe make this a bit, bring this closer together.
[00:13:33] And let's use your display.
[00:13:42] Pick drum C1, something like this.
[00:13:48] So that's the first lane.
[00:13:49] Maybe we can put this here.
[00:13:51] Yeah, it's a bit better.
[00:13:55] Second one here.
[00:13:56] This is the snare.
[00:13:57] The snare drum C#1.
[00:14:26] Okay let's leave the kick drum here, velocity all the way up.
[00:14:33] Also the snare drum.
[00:14:44] So that's a problem here now.
[00:15:02] Let me see.
[00:15:03] Something is off here.
[00:15:05] It's not synchronized.
[00:15:13] Oh yeah, completely forgot.
[00:15:18] We can also implement your shift with the shift module.
[00:15:23] We can shift this whole sequence around if we want to.
[00:15:34] Let's use this.
[00:15:37] Also here.
[00:15:42] It's hard to grab sometimes here.
[00:15:51] So yeah.
[00:15:52] We can offset your kick drum to a different point.
[00:15:57] Maybe 50%.
[00:16:10] So you can notch the kick drum or the snare drum to a different point in time if you want
[00:16:15] to.
[00:16:16] So shift also easy to implement here.
[00:16:22] Okay so that's the snare drum.
[00:16:25] Let's go to the hi-hats here.
[00:16:28] I think it's D, right?
[00:16:34] Closed.
[00:16:35] You want to trigger this probably all the time and you want to have just three steps
[00:16:43] going down.
[00:17:01] Okay, that's cool.
[00:17:18] That's a cool beat.
[00:17:27] We can also implement something for the percussion.
[00:17:31] Let me see here.
[00:17:35] Something like this.
[00:17:40] So we go here just with one trigger and there we change the loop length here.
[00:17:48] Oh I see, I also made a mistake here with the loop length here.
[00:17:58] I need to change the loop length also for the retriggers.
[00:18:01] Minus 14.
[00:18:06] Let's go to that and also here.
[00:18:10] It's always something you forget to modulate.
[00:18:15] Oh I see also your the gate repeats probably make some problems.
[00:18:23] Minus 14.
[00:18:30] Minus 14.
[00:18:41] Minus 14.
[00:18:57] Yeah, the end of phase is not the best.
[00:19:27] You can see here the gate repeats basically retriggers the snare because it keeps staying
[00:19:34] on this step here.
[00:19:37] That's a problem.
[00:19:40] So you probably have to also implement here something like this and then you see the play
[00:19:51] thing.
[00:19:52] So you have to circumvent some problems here and there.
[00:20:09] Yeah I put this preset down in the description so you can download it if you want to and
[00:20:16] can play around with this.
[00:20:19] It's actually not super hard to set up.
[00:20:24] It's also a nice exercise to learn the grid.
[00:20:30] Something like this.
[00:20:31] Yeah nice.
[00:20:37] And here also again it's a problem with the interface right.
[00:20:42] This would be so much nicer if you can design your own interface and abstract all the stuff
[00:20:48] here you need to implement away and just boil it down to the important elements.
[00:20:56] What it kind of works it's not super bad.
[00:20:58] I mean at least you can do it.
[00:21:00] You can create something like this easily.
[00:21:04] Just really really nice.
[00:21:06] Okay, play.
[00:21:11] Let's change the snare drum.
[00:21:27] Yeah and you can create basically your Euclidean rhythms with this pretty easily.
[00:21:45] So like I said I put this in the description below.
[00:21:48] I hope you learned something how to create something like this in the grid.
[00:21:53] It's kind of similar to the Harmony Bloom video I did a few months ago but it's also
[00:22:01] a bit different.
[00:22:02] So yeah I hope you learned something.
[00:22:04] Preset this down in the description.
[00:22:06] You can download it.
[00:22:07] Have some fun.
[00:22:08] Leave a like.
[00:22:09] Subscribe to the channel and I'll see you in the next one.
[00:22:10] Bye.
[00:22:10] Bye.