Creating Music in Bitwig Studio: Using Global Modulators and Unique Triggering Techniques

Tutorial | Jul 31, 2023

In the video, I showed how to make music in Bitwig Studio using global modulators. I used two step modulators, one for values and one for melody. I connected them to a polymer synthesizer and routed them through a node grid. I used the values from the step modulator to modulate various parameters in the synthesizer, such as decay time, amplitude envelope, and mix levels. I also used the melody step modulator to generate notes and trigger them using clock and XOR modules. I demonstrated how changing values in the step modulators can instantly modify the sound and trigger different sequences. Overall, it was a fun and nerdy way to create music in Bitwig Studio.

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

Questions & Answers #

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

What is the purpose of this video? #

The purpose of this video is to demonstrate how to create music in a unique and nerdy way using Bitwig Studio. The focus is on utilizing global modulators, touching signals, and routing within Bitwig to create interesting and dynamic tracks. While this approach may not be practical for everyday use, it serves as a fun exercise and a way to learn more about Bitwig's capabilities.

How are the global modulators utilized in the video? #

The video showcases the use of global modulators in Bitwig Studio. Firstly, a step modulator with 64 steps is added to the global project pane. This step modulator is then randomized to provide a variety of different values. Additionally, a second step modulator is used for the melody, with negative values enabled and the root node set as zero for the grid. The values from the step modulators are received in the node grid using a value knob, which is then connected to various parameters in different devices and effects.

How is the modulation of the values accomplished? #

The modulation of the values is achieved through a series of devices and modules in Bitwig Studio. Firstly, a phase signal is created that matches the length of the phase signal in the node grid, which is set to one bar in this example. This phase signal is then synchronized with the step modulator using a split module and a sample and hold device. The split module steps through the values of the step modulator, which are then held using the sample and hold device. These static values are then mapped to different parameters in various devices using MIDI CC devices and modulation.

What other techniques and devices are used in the video? #

In addition to the global modulators and the node grid, the video also highlights the use of devices such as the polymer synthesizer, the convolution device, and various delay and reverb devices. MIDI CC devices are used to receive the values from the global modulators and modulate different parameters. The video also showcases the use of triggers, clocks, quantizers, and mirrors to generate notes and control

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] Okay, this is probably the 20th take of recording this video for some reason.
[00:00:06] Every time I made some mistake, I have no idea why.
[00:00:11] So this is the 20th take for today.
[00:00:14] So it's a perfect Monday.
[00:00:18] And in this video, I want to make music in the most nerdiest way imaginable inside of
[00:00:26] Bitwig Studio.
[00:00:28] I want to utilize the global modulators.
[00:00:31] I want to touch signals, route stuff around inside of Bitwig.
[00:00:36] And when you press one button, you change the whole track.
[00:00:40] So this is the idea.
[00:00:41] It's probably also not something really practical, which you want to use in a daily usage, but
[00:00:48] it's a fun exercise and you probably can learn a lot.
[00:00:53] And it's also fun to do.
[00:00:56] And sometimes I need a challenge, right?
[00:00:57] So this was the idea for today's video.
[00:01:02] So I want to switch to Bitwig.
[00:01:04] As you can see, some projects are already made today.
[00:01:14] So again, let's imagine you have an empty project inside of Bitwig Studio.
[00:01:20] And what we want to do is we want to use the global project pane here.
[00:01:28] And I want to add here a step mod.
[00:01:33] And this step mod, we want to utilize 64 steps, of course, to have a lot of different values.
[00:01:38] You click here this randomize button or dice button.
[00:01:42] You get a lot of different values, which is nice.
[00:01:45] We also go here with the BPM setting, maybe do 85, which I like to do, and use the loop
[00:01:52] mode here and switch to play.
[00:01:55] So now we step here through the settings and we don't change here the speed settings.
[00:02:03] We do this later on.
[00:02:04] I think this is better.
[00:02:06] And then we use a second step mod here.
[00:02:09] And this one we call melody or something.
[00:02:13] Yeah, melody, the first one we call values.
[00:02:19] So the melody step mod here and switch to bipolar modes.
[00:02:23] We also get negative values.
[00:02:26] You also want to delete here the first nodes to have a zero value in here.
[00:02:30] And the zero value converts to C3 or to the root node inside of the grid.
[00:02:37] We are using this later on then.
[00:02:39] But here I want to switch to zero, maybe also here, delete some keys there, just to have
[00:02:45] the root node in here more than all the other nodes.
[00:02:52] Then we want to switch also to 16 node grid probably.
[00:02:57] And that's fine for now.
[00:02:59] So this is the global modulator pane here.
[00:03:02] We can use this on all kinds of different tracks.
[00:03:04] So when we use the second instrument track, you can see we can access these modulators
[00:03:09] on each track.
[00:03:10] So in the first track here, we want to create maybe a polymer synthesizer.
[00:03:17] And we want to remove this here.
[00:03:19] We don't need this and the expressions we need later on.
[00:03:21] So this one is a perfect, super simple synthesizer.
[00:03:26] It also reacts to my keyboard, MIDI keyboard input.
[00:03:29] Yeah, that's all we need for now.
[00:03:34] We can also use a VST device if you want to, VSC instruments, or some other grid patch
[00:03:41] or other bitwig device, whatever you want to use.
[00:03:46] In front of that, we use a node grid.
[00:03:50] And this node grid is important because this is our receiver and we call this net receiver.
[00:03:57] Yes.
[00:03:58] Inside the node grid, we don't use the node inputs, but therefore we select the grid itself
[00:04:06] and select your node through.
[00:04:08] So we just pass all the input nodes from the MIDI keyboard or from the piano wall through
[00:04:14] this device to the polymers.
[00:04:16] We can still play on the MIDI keyboard, right?
[00:04:19] Even though we have no node input and no node output here at the moment.
[00:04:24] So that's important.
[00:04:25] So what we want to do is we firstly want to receive the values here from the values global
[00:04:33] modulator.
[00:04:34] And we do this by using a value knob and just modulating this value knob with a step mod
[00:04:40] here, right?
[00:04:41] You can see we receive here all the nodes, all the values.
[00:04:45] And it's also important that you have the node grid itself in monophonic mode.
[00:04:50] I need to say this every time.
[00:04:54] It's very important.
[00:04:55] So we have only one voice active and it's always active.
[00:04:59] So keep in mind, you have to switch the node grid here to mono mode.
[00:05:04] So back to the values we call this here, values, and maybe give a different color just so it
[00:05:13] looks a bit different.
[00:05:15] So we need to access here all these values from the step mod in the grid, right?
[00:05:20] And you want to make static values out of this.
[00:05:23] We can do this by firstly using a phase signal, phase in.
[00:05:31] And this phase signal here is exactly in our case here, in our example, it's exactly one
[00:05:36] bar long.
[00:05:37] Why?
[00:05:38] If you switch to the node grid, look at the device phase here.
[00:05:44] It's one bar long.
[00:05:46] Again, it switches two bars, then the signal here becomes more stretched out, right?
[00:05:53] So we want to use one bar here in this example.
[00:05:58] So all we have to do now is to match or to synchronize this phase signal with this step
[00:06:04] mod.
[00:06:05] So we want to have at zero here, when we are at zero, we want to be at the start of the
[00:06:11] step mod.
[00:06:12] And when we are at one, we want to be at the end of this.
[00:06:16] And I already know how to achieve this.
[00:06:18] We have to switch to 32 nodes here and we have to switch this to 0.5.
[00:06:24] And it's the same speed setting than this phase signal.
[00:06:29] And because it's here time-based, so it's perfectly in sync, right?
[00:06:36] Which means we map basically each of these values of the step mod here to position on
[00:06:42] this phase signal.
[00:06:44] So every time we cross or we are on this phase signal at a certain position, we get the same
[00:06:51] value.
[00:06:52] So this is the important part and it's very important.
[00:06:55] So we delete this and use a split module here.
[00:07:01] And this gets the value input and we step through this here with a split device.
[00:07:10] And we switch the split device here also to interpolation to nearest.
[00:07:13] So we step through it instead of gliding through it.
[00:07:18] And we want to use eight outputs on the left side here, right?
[00:07:23] That's the maximum number for some reason.
[00:07:26] And you can see we step through here the stuff.
[00:07:30] We probably don't hit here each of these 64 bars, but we hit some of these bars, right?
[00:07:36] What's important about this because we synchronize this, it's each time the same bar.
[00:07:40] So we use a sample and hold here, duplicate this and connect these two.
[00:07:48] Bam, bam, bam, bam, bam, bam.
[00:07:54] And we need here a gate input and we do this with the logic module bigger than this one
[00:08:00] here.
[00:08:01] We use the value output here.
[00:08:03] Every time the value here becomes bigger than zero because the second input is empty, we
[00:08:10] get the gate output here, right?
[00:08:11] And we use this to try for the second input to hold the value.
[00:08:16] That's the idea.
[00:08:18] But it's duplicate this here again, make an input.
[00:08:29] And then we use the gate output to hold the signal, to hold the value.
[00:08:36] So to check this, we use a readout, actually two or maybe three.
[00:08:46] And you can see here we have a static value, right?
[00:08:49] It doesn't change.
[00:08:51] When we hit the dice symbol here or dice icon button, we update then these values and we
[00:08:58] get different values.
[00:09:02] Okay.
[00:09:04] But this output then is used later on as static values where we modulate something on a synthesizer.
[00:09:14] So because we only have eight outputs here, we probably need more later on.
[00:09:20] So I can also show you this.
[00:09:21] We just duplicate this here.
[00:09:25] So instead of using the same phase input here, we use a split phase and use this as an input.
[00:09:35] And then you look here on the left side on the inspector, you can see the input phase
[00:09:39] input, this one here is the same as the phase out one output.
[00:09:44] So this one here, but the second one is slightly offset.
[00:09:50] It's exactly offset by, I think 90 degrees, right?
[00:09:55] Which means we can use this one here for that input and this one for the second one.
[00:10:00] So you can also see here at the yellow dots, we are slightly offset or behind, right?
[00:10:07] So we hit the different bar.
[00:10:09] Yeah, we hit a different bar basically at the same position of this phase signal, which
[00:10:15] should lead to different values.
[00:10:21] Let's move here.
[00:10:39] Let me see if it's actually here just offset also the values 895, which is this one here,
[00:10:52] which is not good.
[00:10:53] We kind of need to use here maybe a different idea.
[00:11:02] Maybe I use the offset, it's there your face offset.
[00:11:08] I haven't done this before actually.
[00:11:10] It's maybe a leg, maybe shift, maybe use a shift instead.
[00:11:17] So we delete this here and use a slight shift.
[00:11:24] So you make different, we step at different times.
[00:11:33] Yeah, I think this is better.
[00:11:36] Yeah, so we have different values here.
[00:11:41] So we don't need to read out actually here because we want to use the values.
[00:11:45] So let's use here CC out here.
[00:11:49] And instead of channel one, we want to use channel two just to keep channel one free
[00:11:53] for maybe media input or media keyboard input or whatever.
[00:11:57] CC one, second one goes to CC two, two, three, four.
[00:12:09] You get the idea just to have your multiple different outputs, five, six, seven, eight.
[00:12:18] Nice.
[00:12:19] So we continue with nine, nine, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
[00:12:45] 14, 14, 15 and 16.
[00:12:52] Okay.
[00:12:54] So now we can access these values of course here with a media CC modulator.
[00:13:01] We switch all of voices off and go to channel two and you can use here CC one for maybe
[00:13:09] position in the wave table.
[00:13:10] You can change the wave table here.
[00:13:12] Would be nice if you could actually modulate here the exchange the wave table with the
[00:13:18] modulation, but it's not possible at the moment.
[00:13:22] Probably also not easy to solve the load loading times.
[00:13:25] You need to have some kind of latency there.
[00:13:29] So we modulate this here.
[00:13:31] And when we hit randomize here on this global step mod, we should now change to a different
[00:13:38] value here.
[00:13:43] BAM there it is.
[00:13:44] And you can see the modulation is applied instantaneously.
[00:13:48] So there's a big switch or instantaneous switch.
[00:13:53] So we can change this to a slow morph by using a lag using this one here and using a global
[00:14:06] macro modulator, select and call it lag.
[00:14:14] Yeah, it's the same.
[00:14:21] So we have to again here make all the patching right.
[00:14:31] But then when we have this in place and basically drive up here the lag, then we, if you want
[00:14:36] to watch this here, we slowly move then from one value to the end result value.
[00:14:46] So it's a slow morph, right?
[00:14:48] Every time you change this later on, when you basically change everything on a track,
[00:14:52] it's not like that every parameter just switches in.
[00:14:57] You have a slow morph, which is more, which is better in my opinion.
[00:15:05] Let's copy this over here.
[00:15:09] Duplicate this.
[00:15:14] Yeah, nice.
[00:15:25] I think we have everything patched right.
[00:15:28] Yeah, looks nice.
[00:15:30] So let's give this here all a nice color, maybe greenish so we know its static values.
[00:15:39] Can also use a display here.
[00:15:45] Static values.
[00:15:47] Bam.
[00:15:48] It brings over here.
[00:15:53] Looks better.
[00:15:54] Okay.
[00:15:55] So static values, we can receive them here with all these midi CC devices.
[00:16:01] It's probably here with decay time.
[00:16:07] Maybe also use the amplitude envelope.
[00:16:13] We go to low pass eight.
[00:16:20] What else?
[00:16:23] Maybe use a CC3 here with this modulation.
[00:16:28] We go to zero here and use CC4 to bring this in.
[00:16:36] Maybe use CC5 for the tag time.
[00:16:41] So with a different sound.
[00:16:44] And in the FX box here, we want to use maybe convolution device to have some reverb and
[00:16:55] delay two and maybe a delay reverb.
[00:17:05] And here then we can also use all these CC devices.
[00:17:15] CC5, CC6 for the mix.
[00:17:20] CC6 for the mix.
[00:17:22] Okay.
[00:17:23] That's great.
[00:17:24] Seven is feedback.
[00:17:33] And eight is the diffusion algorithm.
[00:17:42] And delay, we just keep it there.
[00:17:48] Maybe go down here to CC2 so it's a bit more muted.
[00:17:53] Okay.
[00:17:54] So now that we have this, we probably also want to generate some nodes.
[00:17:58] So we need to randomize.
[00:18:00] You can see all these settings now change here, which is nice.
[00:18:12] Also slowly.
[00:18:13] Yes.
[00:18:14] So when I use my MIDI keyboard, we need to modulate this here even more.
[00:18:35] Let's go to zero here.
[00:18:36] Right click.
[00:18:37] Oh, there's no modulation here.
[00:18:39] Dammit.
[00:18:40] We use here, what's the last one we used?
[00:18:44] Eight.
[00:18:45] Let's use nine here.
[00:18:48] This kind of setting.
[00:18:53] Oh, we need, is there no CC9?
[00:19:04] Eight.
[00:19:05] Oh, I missed that here.
[00:19:08] Okay.
[00:19:09] Eight, nine, ten.
[00:19:10] Maybe reduce your MIDI five.
[00:19:30] That's probably the hardest part to find all the sweet spots, how much you modulate everything,
[00:19:35] you know, how to dial in everything and so on.
[00:19:37] So this is the biggest part then to find all the minimum and maximum values to write amounts.
[00:19:44] This is probably way too short.
[00:19:57] Okay.
[00:20:01] So we want to generate some notes.
[00:20:10] Okay.
[00:20:11] Let's do this first.
[00:20:12] So for the notes, we use also a value here.
[00:20:16] We call this melody.
[00:20:21] And you modulate this here with the, first we switch this to bipolar mode.
[00:20:25] So this up here needs to be bipolar mode, right?
[00:20:28] So we have here minus and positive values.
[00:20:32] So modulate this maybe by 10% or maybe 12%.
[00:20:35] We don't want to modulate this too much because we want to stay in the same octave with the
[00:20:41] melody.
[00:20:42] We change the octaves later on with an octave switch, but here we want to stay within one
[00:20:47] octave.
[00:20:48] So we have some values there and we probably also want to increase the transpose by three
[00:20:56] because we use my beloved scale D# minor and D# is exactly three semitones above C3 and
[00:21:07] zero in the grid is C3.
[00:21:10] So we switch the zero up to three semitones, which is D#.
[00:21:13] I hope this is clear.
[00:21:15] So then we output here the notes there and we probably want to use a sample note.
[00:21:23] Maybe use this in front of the pitch quantize so we can see what's going on.
[00:21:27] This is the last module in the chain here.
[00:21:31] So now we need to something to trigger.
[00:21:34] So we also implement some kind of genius trigger triggering stuff.
[00:21:41] So we use one trigger here.
[00:21:43] This is the clock.
[00:21:47] The clock is always 60 and 60 notes.
[00:21:50] We use the clock quantize.
[00:21:54] So we synchronize here this one to the 60 notes and we modulate this here of course.
[00:22:01] We start at two.
[00:22:03] Second one, we need also second one and this one starts at three and we use a different
[00:22:11] you know remember all that stuff here.
[00:22:14] We use here a mirror.
[00:22:18] So it's very important that this one here plays always a bit different than this one.
[00:22:22] We don't want to have this value match this value at any time.
[00:22:27] But because it's random sometimes it is.
[00:22:30] But with this mirror here we play at least this one backwards sometimes.
[00:22:34] So it's always kind of different than this one.
[00:22:39] Because we want to use a XOR and we want to XOR this one with this one.
[00:22:45] So it only outputs here basically a trigger signal when either this one or this one is
[00:22:51] true.
[00:22:52] If both of them are true then this one is a zero or if both of them are zero this is
[00:22:56] a zero.
[00:22:57] You can see this here in the help.
[00:22:59] Right?
[00:23:00] Zero zero is zero.
[00:23:01] Zero one is one and one zero is one but one one is also zero.
[00:23:05] So only one input needs to be true.
[00:23:11] So basically this gives us some triggering possibilities.
[00:23:16] So we have now three outputs.
[00:23:18] We can use this as triggering.
[00:23:20] We can use this for triggering and we can use this for triggering.
[00:23:23] And we also do this.
[00:23:25] So we do this by using again a split.
[00:23:32] Or not a split.
[00:23:33] We use a merge.
[00:23:34] Sorry.
[00:23:35] Merge.
[00:23:36] So this is an input.
[00:23:39] This is an input.
[00:23:40] We increase this to three and this is an input.
[00:23:44] This one is switched to nearest and we can use a value here.
[00:23:50] Change between all of these three outputs.
[00:23:53] Okay?
[00:23:54] We call this triggering mode or something.
[00:23:58] Trigger mode.
[00:24:00] And we use this output to either sample note here the melody and also output this here
[00:24:05] as trigger for the notes.
[00:24:09] So we have already three different groups here.
[00:24:26] And we want to change this even more by again duplicating this here.
[00:24:34] But here we use again a slight shift.
[00:24:47] And here we don't want to use the CC outputs.
[00:24:51] We want to use this for some internal stuff.
[00:24:53] We use modulator output here.
[00:24:57] So this one is modulating basically the second clock here.
[00:25:08] Made equal to seven here.
[00:25:14] And this one is changing this one here.
[00:25:26] And the third one here, of course, is changing the triggering mode.
[00:25:33] So when we hit basically randomize here on the step mode, we change the trigger settings
[00:25:38] here, here, and which mode we are choosing.
[00:25:41] So there's a lot of variety that can happen.
[00:25:44] But we know what we dialed in here.
[00:25:46] Everything that can happen is kind of nice.
[00:25:49] So we limit the possibilities basically a bit.
[00:25:55] So yeah, with this randomize setting, it basically chooses here the second input, which uses
[00:25:59] then here, I don't know what kind of...
[00:26:02] Let me see.
[00:26:04] It uses five here.
[00:26:07] Five which is then synchronized to 16.
[00:26:13] But it's a bit muted here for some reason.
[00:26:17] Because output six is not... let me go to 12 here.
[00:26:32] But that's what I mean with finding the right sweet spots for everything.
[00:26:40] Okay.
[00:26:44] So this is the very high complex triggering mode here.
[00:26:55] But I think it's not complex enough for some reason.
[00:26:59] I don't know why.
[00:27:02] So we use another bunch of triggers here.
[00:27:07] Also, we can utilize 16 from here.
[00:27:12] We can call quantize 16 nodes.
[00:27:19] And then we switch with the select from this to this.
[00:27:28] So with the button, which is called local, we switch basically the second input.
[00:27:39] And we use this here on a page.
[00:27:42] We use this here, local.
[00:27:44] So we can basically switch from a global driven standpoint.
[00:27:48] So we get the triggers from this, right?
[00:27:51] Because this automates all that stuff here.
[00:27:54] We switch the local, which is basically just this triggers mode here or this triggers module,
[00:28:00] which is not modulated by anything that's modulated by this step mode.
[00:28:05] So here, we use this here so we can change this locally.
[00:28:11] That's why it's called local.
[00:28:18] But then there's another problem.
[00:28:20] Sometimes we don't want to create these kind of plug sounds.
[00:28:23] We want to have sustained sounds, something that's, you know, drive up here.
[00:28:29] You can hear it's not long, right?
[00:28:32] It's just a short note.
[00:28:34] The problem with this is that these triggers here are pretty short, right?
[00:28:39] This is basically how long a note is held, which is in the log.
[00:28:44] So to solve this problem, we make it even shorter.
[00:28:49] It's like 0.12 milliseconds long.
[00:28:54] You can see it's a very, very short burst.
[00:29:09] Should be fine.
[00:29:12] Default value.
[00:29:13] And then we use a note.
[00:29:18] Here and again, another select and we just reverse this, right?
[00:29:29] I'll show you in a minute what I mean.
[00:29:31] We call this here sustain and we also use this in here.
[00:29:39] So now when we push this button, we basically use the same signal we have here just inverted.
[00:29:45] So the short bursts of gate become gaps and the space in between becomes sustained, right?
[00:29:55] Completely opposite.
[00:29:56] So now we can utilize here the...
[00:30:03] So basically hold the note and retrigger only when this gap happens.
[00:30:08] I hope this makes sense.
[00:30:15] So I'll use this down here probably, the stand also here.
[00:30:22] So we want to map here also the values so we can see here values happening.
[00:30:28] And we want to use the melody here.
[00:30:31] So we can see we modulate the melody here.
[00:30:34] We can also change maybe melody slightly if we want to.
[00:30:42] We don't need this.
[00:30:49] A bit of detritus here.
[00:30:51] Yeah, that's okay.
[00:30:55] So we have at least some kind of notes running and you can change the sound.
[00:31:08] It's very muted.
[00:31:20] We'll stay at C3.
[00:31:29] So we have notes.
[00:31:31] We have gates or pitches.
[00:31:43] Gate heaven.
[00:31:49] Yeah, yeah, yeah.
[00:31:52] This one is probably this is yellow.
[00:32:03] Let me move.
[00:32:06] Yeah.
[00:32:08] So and now we also want to output here of course velocity and velocity and pressure
[00:32:18] and number.
[00:32:20] So we need moving values.
[00:32:26] Let me see, how can we do this?
[00:32:34] So we can use maybe a sign mod.
[00:32:40] Get the values here from the value.
[00:32:45] Make it a bit more complex with a very randomized setting here.
[00:32:52] And output this with the CC device.
[00:32:58] Channel two and the last one here is CC 16.
[00:33:01] So let's start with CC 20.
[00:33:05] CC 20.
[00:33:08] So everything above CC 20 is basically changing our time.
[00:33:19] 21, 22, 23, 24, 25.
[00:33:32] Okay let's change some settings.
[00:33:40] So for each one I want to have a different setting.
[00:33:43] Just have a different value and time.
[00:33:46] Let's use an oscilloscope here.
[00:33:58] Can't change that.
[00:34:09] You can see in the background we have a lot of different values because we multiply this
[00:34:16] here with a sign mod, which is what we want.
[00:34:23] But the important part is it's always the same. Every time we load up the patch it's
[00:34:28] the same pattern.
[00:34:30] But slightly different.
[00:34:38] And maybe also introduce some kind of lag to that.
[00:34:57] It's a bit smoothed out.
[00:35:02] Or actually, no.
[00:35:07] Use a sample note.
[00:35:08] You want to have a stepped output there.
[00:35:21] And you want to generate this each time we trigger.
[00:35:28] So every time we get a new note, we get a different CC setting here.
[00:35:35] Everything above 20, CC 20.
[00:35:39] And we also want to generate here, instead of CC 26, we want to generate here velocity,
[00:35:48] number and pressure.
[00:35:59] Nice.
[00:36:00] So here we also have to use different settings, of course.
[00:36:09] And we can then use here expressions.
[00:36:17] Use the velocity sensitivity and use tumbler here.
[00:36:23] Use pressure here.
[00:36:29] And maybe also velocity for the filter.
[00:36:38] And everything that's above 20 is stepped, but modulated.
[00:36:51] Okay.
[00:36:54] I hope this makes sense so far.
[00:37:07] So we have a nice little receiver module here, which receives values from the global step
[00:37:13] mod.
[00:37:14] Also the melody and the lag input.
[00:37:17] And then output notes, static values we can use with the CCs here to change the parameters.
[00:37:25] And also modulations here with everything above CC 20 to modulate something over time.
[00:37:36] Now sometimes we generate pretty muted sounds, which I don't like.
[00:38:02] I guess the default should be 24 maybe.
[00:38:23] So the melody is always the same because we don't change this here, right?
[00:38:27] All we change is the triggering, the gate triggering and the sound and the modulations.
[00:38:36] Okay.
[00:38:38] So what else?
[00:38:39] Maybe we should implement something like an octave switcher.
[00:38:44] Let me put this over here.
[00:38:47] Back to zero.
[00:38:49] You also want to have this in here so we can limit basically or change this when we, when
[00:38:54] we duplicate this to different tracks, we then probably want to play on the bass, right?
[00:39:01] Or something here so we can limit something or switch or offset something to a different
[00:39:06] octave.
[00:39:07] So here we stay at zero for this.
[00:39:33] Check here if I actually do the right thing.
[00:39:53] I guess I'll get started to one here.
[00:40:22] We generate those notes, but it's always the same add-on.
[00:40:41] Sounds almost like it.
[00:40:44] Oh yeah, because I have clog on.
[00:40:50] Okay, I see.
[00:40:51] Damn it, I fooled myself.
[00:41:11] But yeah, we want to implement just some kind of octave switcher.
[00:41:14] So here's another step mod.
[00:41:19] This one is slightly shorter.
[00:41:21] It's not 16 notes.
[00:41:22] It's only 15 steps long.
[00:41:28] Also bipolar.
[00:41:30] And you only want to shift the octave here at certain points.
[00:41:34] And because it's a different step length or yeah, we don't actually have the same octave
[00:41:40] switch at the same position in the melodies sequence here.
[00:41:47] So we modulate probably this here by one.
[00:42:02] Or we use a select.
[00:42:19] So in here and then there and we modulate only this.
[00:42:42] So we can say when we enable this, we shift the octave with this one here.
[00:42:57] And I only shift here by one up and one down maximum.
[00:43:14] Okay, did I miss something?
[00:43:30] Looks good so far.
[00:43:31] So we have expressions.
[00:43:32] We have some CCs above 20 for modulations.
[00:43:33] We have a lot of different triggering stuff here and we generate static values.
[00:43:40] We have some something left here we can use for certain things here.
[00:43:46] Can maybe use here some of these outputs here for the sign mods right to change even more
[00:43:52] stuff.
[00:43:56] I have some kind of preset here I made a while ago.
[00:44:13] What it's called, Robot glitch.
[00:44:15] I made this for essentials here.
[00:44:27] Yeah let's use here CC.
[00:44:33] What's the CC 10 maybe?
[00:44:36] Change the mix.
[00:45:00] Okay there's one thing we have to do and that's that we have to create some kind of local
[00:45:08] seed for this device.
[00:45:11] Because when we duplicate now this thing here to another track, we probably want to have
[00:45:18] at certain points different values.
[00:45:22] We can create here local seed by using sign mod in front of that.
[00:45:32] I'm not sure why it's changing this to purple but whatever.
[00:45:39] So we create here a macro, changes maybe this slightly.
[00:45:52] So we warp basically the values here.
[00:45:58] We call this seed.
[00:46:03] So this is a local seed here.
[00:46:04] We have to change this for every device we use on different tracks to get different values
[00:46:09] different positions of this these gate signals.
[00:46:15] Looks good so far.
[00:46:25] So now we can duplicate this here.
[00:46:38] So it plays kind of the same melody as you can see here.
[00:46:41] So we have to change the seed.
[00:46:55] And we probably want to change the octave.
[00:47:02] And maybe a different wavetable.
[00:47:18] And we can duplicate this again.
[00:47:24] The floor or maybe three or base.
[00:47:29] Change this to local.
[00:47:50] So we create a base with this.
[00:48:04] For the base we probably don't want to have here all the reverbs.
[00:48:13] And we also probably want to have zero voices, mono voices.
[00:48:17] And in the Notif Xbox here we can implement some kind of tricks.
[00:48:21] So for instance we can use a band.
[00:48:24] And we don't want to have unison of course.
[00:48:34] So here the band basically implements some kind of pitch band.
[00:48:44] But we don't want to have the pitch band all the time.
[00:48:46] So we group this into a Notif X layer.
[00:48:50] Right click this Notif X layer and convert to Notif X selector.
[00:48:53] So now we have only one layer active.
[00:48:56] We duplicate the first one.
[00:48:58] The second one gets 24.
[00:49:02] The third one gets 12.
[00:49:09] But minus five up.
[00:49:15] Maybe this one is no modulation at all.
[00:49:24] This one.
[00:49:43] Minus 12.
[00:49:49] Actually just.
[00:49:54] Minus 12 why not.
[00:50:02] Maybe milliseconds.
[00:50:07] And maybe another empty one down here.
[00:50:12] Hold.
[00:50:14] Yeah.
[00:50:17] Then we switch the first one and we use here CC what's that CC9.
[00:50:28] And we use here CC10 to switch the index.
[00:50:35] And then we use a note delay here.
[00:50:41] Just delay the notes.
[00:50:44] Maybe here.
[00:50:46] By two.
[00:50:48] Put into a layer.
[00:50:50] Switch this to a F selector.
[00:50:53] First one is delayed by two.
[00:50:55] Second one is delayed by three.
[00:50:58] Plus a quantizer.
[00:51:01] With the groove on.
[00:51:02] The third one is four.
[00:51:06] This one is no delay at all.
[00:51:10] Maybe just one.
[00:51:16] Back to this.
[00:51:17] That one here.
[00:51:20] This is CC11 index modulated.
[00:51:23] Nice.
[00:51:25] Let's see how this sounds.
[00:51:36] So here it's selected basically this note delay.
[00:51:58] And this band layer.
[00:51:59] So we have pitch band.
[00:52:01] You know different pitch bands.
[00:52:03] The delays for the bass sequence.
[00:52:06] Brings in a bit of variety here.
[00:52:18] And then we use this.
[00:52:44] And of course you can go crazy with all kinds of audio effects and modulating them right.
[00:52:57] But for me I want to keep it kind of simple in this tutorial.
[00:53:02] Just to show you how the setup is.
[00:53:08] Let's create some kind of different melody here.
[00:53:25] This is much better.
[00:53:41] I
[00:54:06] think this sounds cool.
[00:54:12] Of course it could be interesting to create some kind of custom patch for drums.
[00:54:17] And then modulating these drums and patterns and so on.
[00:54:21] But I don't want to make this too complicated.
[00:54:24] I'm already at the 54 minute mark here for this tutorial.
[00:54:29] So maybe I leave it at that.
[00:54:35] So I think that's it for this tutorial.
[00:54:38] I hope I showed you some interesting ideas for creating patterns and sound design with
[00:54:46] just one step mod with the global modulator step modulator.
[00:54:51] Global step modulator.
[00:54:53] And how you can receive all these or extract all these different values from the step mod
[00:54:58] and utilize it for all these kinds of different signals.
[00:55:03] It's an interesting method.
[00:55:05] I try to make a track with this and tell you what kind of problems I encounter.
[00:55:13] Maybe I make another tutorial.
[00:55:15] Maybe I share something on my Patreon.
[00:55:16] I have no idea.
[00:55:17] But I think it's a nice idea to make tracks.
[00:55:21] It's super nerdy actually.
[00:55:23] It's probably not practical.
[00:55:26] But when you do it in the right way it's kind of interesting to just hit one button and
[00:55:31] see how everything changes and how everything evolves and discover something new out of
[00:55:37] thin air.
[00:55:38] So if you liked the video, subscribe of course, leave a thumbs up, comment some kind of smiley
[00:55:46] in the comments, everything helps.
[00:55:50] And thanks for watching and I see you in the next video.
[00:55:53] Bye.
[00:55:53] Bye.