Tags: posts polarity-music Bitwig Generative Note-Grid Chords Sound-Design Drums

Create a Melody Maker Inside Bitwig Studio with the Grid

Tutorial | Dec 21, 2020

In this video, I showed how to build a melody maker in Bitwig Studio and the Grid. I demonstrated how to use a pitch module, select, max min and probability selector and combined them together to build a melody maker. I also showed how to use a sample and hold, ADSR, face input, scaler, mirror and band, and a recorder to add groove and repetition to the melody. Finally, I showed how to use a clock one ties to synchronize the melody to the beat grid.

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 a Melody Maker?

A Melody Maker is a type of software or hardware module that allows you to create melodies. It typically has several sound modules, such as pitch, select, and probability selectors, that you can use to create your melody. It also usually has an output module and a playback module that allows you to listen to your melody.

How do I use a Melody Maker?

To use a Melody Maker, you typically first choose a root node (the fundamental note of your melody) and then use the pitch and select modules to create your melody. You can also use a probabilities selector to decide which notes will be played. Finally, you can use the output and playback modules to listen to your melody.

What is the purpose of a Max Min module in a Melody Maker?

The Max Min module is used to combine two lines of melody (such as the root node and the minus second node) so that the higher pitched note will always be the one that is played when both notes are triggered at the same time. This ensures that your melody will sound consistent and not clash.

How do I record my Melody Maker pattern?

To record your Melody Maker pattern, you can


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.000] Hey, welcome back to another video.
[00:02.000] Today we are going to build some kind of melody mega inside Bitwig Studio and the grid.
[00:07.560] This is how it looks like the result and the much, much fleshed out version of this.
[00:12.160] You can download on my Patreon if you are a Patreon subscriber.
[00:15.600] All you need is a $1 subscription and you can download it then after the video.
[00:19.800] What I also show you how it works and how I build it so you can follow along step by
[00:24.800] step and build it for yourself.
[00:27.120] So let's start the video and have some fun.
[00:34.600] So okay, let's start and let's build some kind of melody maker.
[00:39.000] So for every melody you probably need, of course, root node.
[00:42.960] So we start with the root node or the fundamental node.
[00:47.720] And we're going to use, of course, a pitch module for that.
[00:54.040] Let's go with this.
[00:56.560] So we start with C3, of course.
[00:59.800] And then we need a select, I'll show you why in a minute.
[01:04.160] And we need a max min at the end here.
[01:08.880] And we also need a probabilities selector or module.
[01:14.720] Because we want to select, yeah, this node or the root node in our melody by some kind
[01:21.200] of probability value, okay?
[01:24.200] So maybe draw something in here and maybe go this, we go up to 16 steps here.
[01:30.440] Let's try this.
[01:32.880] And of course, we go out here to the select because the select decides then to play the
[01:37.400] node and we hook up here the pitch to the select to the bottom one.
[01:41.040] We can already see here, sometimes to select the switching to the node.
[01:45.680] So we want basically to switch to a node in a scale at random or at some kind of probability,
[01:54.400] right?
[01:55.400] And then we have, of course, some kind of output, maybe we choose a sample and hold.
[02:04.520] That's always nice.
[02:07.200] And we go out here to this one and we go into, oh, let's go into this.
[02:13.600] I think that's better way.
[02:15.400] And maybe you ask why we need this maximum here at this position and I'll show you why
[02:20.560] in a minute because this here is our root node, okay?
[02:30.560] So this is the first line in our melody maker and we have a few more and I'll show you
[02:39.640] how the second one looks like, exactly like the first one.
[02:43.440] And instead, we delete this pitch here on the speech module and go for a transpose.
[02:52.680] Because this one is the root node plus maybe, yeah, one step, okay?
[02:59.600] So this is our second node here and it's not the root, it's our minus second.
[03:09.280] You make this a bit longer.
[03:15.120] And we have the same concept here.
[03:16.600] We want to select basically the minus second at random and we want to select the root node
[03:21.800] at random.
[03:24.440] And because it's random, you can probably select the minus second and the root at the
[03:30.200] same time.
[03:31.200] So we have to decide which node to take and my concept here is basically to use these
[03:36.920] max min values and took these together.
[03:40.640] And every time the probability module decides to play a root node and the minus second probability
[03:49.080] module decides to play a minus second node.
[03:52.200] So both nodes are playing at the same time, then the higher pitch wins.
[03:57.400] So probably in this case here, it's the minus second because the pitch value is higher.
[04:02.480] So the max value.
[04:04.080] That's why I use here the max min modules to basically combine these two lines together
[04:11.280] and say the higher pitch wins when there is the chance of all both the same playing at
[04:18.200] the same time.
[04:19.840] So this is the concept here.
[04:21.480] And all we do now is basically just clone this multiple times here.
[04:25.400] So we go here for the minus second, this is the major second.
[04:29.200] Right, this is two semitones up.
[04:36.520] Then we have here the minus third I think.
[04:46.560] And this is three semitones up.
[04:53.080] And we have the major third, and this is semitones up so we can make major chords.
[05:08.200] And then we have above this we have the perfect fourth I think should be perfect fourth.
[05:16.800] This is five, then we have here the six, which is the diminished fifth.
[05:44.600] And we have perfect fifth that is the seven semitones and let's stop here.
[05:58.520] I mean I could go up until until the end, but you know for this example for this video
[06:03.320] I just yeah, leave it at that.
[06:05.880] So now we can hook these all together here and go always into the bottom one.
[06:10.840] So let's go this, this, this, this, this.
[06:19.000] So basically we get all the notes together in this bottom one and always the higher
[06:23.760] pitch wins when there is the chance of playing multiple notes at the same time, right?
[06:29.880] So there is some kind of randomization hidden in this kind of patching.
[06:38.280] So you can decide for yourself then to make this more complex and then decide maybe
[06:43.080] is playing these two together and these two together and then decide.
[06:47.560] So you can make this more complex if you want.
[06:50.720] But for me, this is perfectly fine here and I use it in that way in this patch because
[06:55.720] there are a thousand ways of do these melody make up patches and this is just one way.
[07:04.960] So okay, so now we have these selected, we can draw in here a lot of different probabilities
[07:11.960] and we have to go into the sample and hold and then we probably want to go into some kind
[07:19.040] of sign here, maybe ADSR at the end and we use an output just to test our, our maker.
[07:31.640] Let's go to this and we go here into the, yeah, pitch end.
[07:40.880] So all we have to do now is to trigger these notes, right?
[07:46.600] And what we can do is we can do also a probability line here and just call these, I don't know,
[07:54.200] the gates and then we go all the way up, we trigger all the time.
[08:01.880] So we have this kind of patch running here and we also need to set up and what we have
[08:13.720] to do now is basically we want to change the speed.
[08:16.880] So we need some kind of face input and some face mangling so maybe go for a face in here
[08:26.800] and maybe we use a scaler that's always nice to change the speed or the division of the
[08:32.000] face input and we're gonna need probably something where we can introduce some swing or some
[08:43.120] inaccuracies to the playback.
[08:45.440] So let's go for mirror and maybe band and yeah, maybe a pinch, let's go for the pinch
[09:07.560] end nice and we disable here all the pre-quads and you see the output of the pinch of this.
[09:31.680] You can already see your plate back and forth which is because of the mirror I am.
[09:36.520] So we can also go back here to zero so we have the normal playback speed and maybe change
[09:42.160] your different division so we get a slower playback speed, right?
[09:52.680] Maybe use your just root note maybe perfect fifth.
[10:09.520] I should be working oh I see I think I have here, I have to put this into this sorry for
[10:22.000] that.
[10:26.760] So now we basically switch between plus seven semitones to perfect fifth and the root
[10:32.960] note all the time maybe go for minor here.
[10:49.120] So now we have this patch here playing notes just in one octave and what could be nice
[10:56.560] is to actually shift sometimes here is in a different octave so octave plus one and we
[11:10.040] need here another probability selector and then we if we use an octave and this should
[11:22.080] be selection and we check the output of this one here, let's move this up and we take
[11:35.400] the output of this as an input this goes into here and maybe so sometimes we want to
[11:44.400] basically shift into one octave higher, right?
[11:49.000] So we take here this one and always play on the same octave we played before but sometimes
[11:54.920] we switch one octave higher to draw in your some probabilities and we should switch
[12:01.800] some times here an octave higher okay nice so now that we have this we have basically
[12:20.080] gates we have our note generation and we also change here the octave you can also change
[12:26.000] the playback speed of this all we have to do now is to record basically the pattern because
[12:32.080] the pattern is over over the place you always generate new notes all the time and that's
[12:37.480] not how a melody works basically a melody works with repetition you hear certain patterns
[12:43.840] over and over again and also you have a change up in speed because we have pretty pretty
[12:50.880] aesthetic you know melody rhythm to it so we have to bring in some groove and repetition
[12:59.480] so we do that by using basically a recorder and the recorder is something I never used
[13:12.200] I think in a tutorial so we do this just now and we want to record basically the output
[13:21.000] of the of the probability selectors or the pictures we just we record pitch information
[13:27.000] we don't record audio we record signal for the pitch and we want to replay the pitch
[13:35.560] signal and feedback into the sign okay so we do that now add to sample this we probably
[13:44.360] need to use use and select again so we want to select when we record something and we want
[14:00.760] to trigger the recorder only synchronize to our beat grid right and we use and yeah clock
[14:13.520] quantize module for that so clock clock divide now it's the clock quantize this one and
[14:25.520] you basically can use an clock input and the bottom input check to synchronize your event
[14:31.960] which happens happening here on the on this input check and yeah you can synchronize it
[14:37.920] to some kind of grid and then we go into the select here which then yeah gives us an
[14:47.000] input trigger which we apply in a second and we make some special special kind of patch
[14:56.000] here for how we generate basically our clock signal and how we generate our trigger signal
[15:06.200] and we use a comparison module for that math now it's logic of course this one unequal
[15:18.240] so we compare two signals and we compare our face input to nothing so every time the face
[15:26.720] signal as you can see on the left input a every time the face signal is basically zero
[15:32.040] then we get no output no no gate signal okay so we have gate signal coming out of this
[15:41.600] every time every time all the time except when this face signal is at zero which is of
[15:49.920] course exactly when our bar or our beat grid starts so we use this here to basically
[15:58.920] trigger the record or use this as an input signal for the record and we want to switch
[16:05.920] this basically in time or we use this as a synchronization signal here and every time
[16:14.920] we press this button here you can see it what it waits basically for the record start
[16:23.920] until we have a face signal of zero which is the start of the bar so we basically want
[16:29.600] to delay this button trigger until the bar starts from this face signal right so every
[16:36.400] time I press this here it doesn't start right away it waits until yeah the face signals
[16:45.800] at zero which is kind of synchronization and I always want to start the record on the
[16:52.040] first beat often pattern so every time a pattern starts I want to start the record and then
[16:57.400] yeah play it back basically so as you can see I'm pushing it and then it starts when
[17:04.320] to the synchronization signal allows it okay now we have this complicated setup out of
[17:13.080] the way and what I do now is maybe choose your labels for on off so every time I every
[17:27.600] time I have this one on I probably play back and off a sample okay so now we basically
[17:41.000] sample oh no we have to use this one so basically invert the signal so now you can use playback
[17:56.080] for this and when we have this off it samples basically the current pattern into the recorder
[18:03.000] now we have to apply some playback logic here and this should be pretty simple actually
[18:13.000] I think we can just go into here to play back the yeah every time the face starts or resets
[18:28.240] or is it zero again we restart basically to playback that's all we need and when we don't
[18:38.120] like the pattern at all which is repeating all the time here we just go for sampling and
[18:44.040] then it starts when the face starts as you can see now it records and now it repeats
[18:50.400] the pattern over and over again so what we're going to do now is we take this output here
[18:55.960] of this of this recorder and we use and select for this and the input of this bottom one
[19:07.200] of the select is our recorder and the top one is our original pitch signal because we want
[19:13.360] to switch between our randomly generated signal and the recorder setting basically and
[19:20.640] this one goes out to our to our assigned oscillator here and now we want to switch between
[19:28.160] basically the pitch signal we already got and our recorder function here so we have to
[19:35.560] basically yeah you see the button again and now we can use this button to use the recorder
[19:46.120] playback right you can see now we have playback here the switches down to the output of the
[19:51.600] recorder and when we disable this we switch back to our original yeah output of our probability
[20:02.960] patch here and at the meantime the recorder basically recorded another new header so
[20:10.840] you can switch between recorder and the repetition and the new generate melody all the time.
[20:23.080] So let's just do this what so this is this is now our playback from the probabilities
[20:32.240] patch here before and it's generating random melodies all the time and we can just switch
[20:38.880] here to repetition and you can hear the pattern basically repeats and this gives you some
[20:56.720] feel for for a melody right it sounds more like a melody than before than just having
[21:02.360] random notes all the time so if you change some settings here for the mirror a band and
[21:07.800] pinch maybe we can change the playback speed as you can see here sometimes it gets yeah
[21:15.600] it slows down or it speeds up I paint in your perfect fourth notes probability and change
[21:23.000] some of the settings and we are going to also move this one the sample and hold after
[21:29.520] this because we then also sample and hold the values we get from the recorder right so
[21:37.280] let's move this over here as the last module before we go into the Sine-Oscillator maybe
[21:44.400] move this here a bit okay it doesn't get better okay so now we have basically nice recorder
[21:56.840] that sounds like this and you have to remember we only record the pitch signal the gate
[22:07.960] signal comes straight from the skates module so when you change here some settings for
[22:12.240] the scale or the playback speed you change also basically the melody or triggering of some
[22:18.960] of the pitch pitches coming from the recorder the recorder only records the pitch signal
[22:23.680] right that's what you have to remember you can of course implement this whole patch here
[22:29.720] also for the gate signal if you want just have to clone this and then you have to feed
[22:36.040] this into the ADSR maybe we can do this I'm not sure maybe just go into here and use this
[22:45.400] there and go and we have to also use a select right here so we want to use the life triggering
[22:56.400] all the time and this one goes to here and then we have this one here and then it should
[23:09.120] record also the gate signal so now we have basically a recorder for the gates and one
[23:19.240] recorder for the pitches and we can record nice little melodies you can hear it's always
[23:40.240] the same pattern because we recorded all this right and if you don't like the pattern
[23:45.680] at all you can change the settings here press sample and it records a new pattern maybe
[24:04.240] we add just some some kind of delay let's record this
[24:34.240] so you can experiment with the settings here maybe you change all the scale setting until
[24:44.440] you find you know some kind of sweet spot where you can generate nice melodies and record
[24:52.080] these patterns into the recorders here I think you can also use here of course much much
[24:57.840] along our sequences instead of just 16 steps here like I did so it's a nice little small
[25:05.160] patch you can use to generate melodies also one trick you can use is probably if you don't
[25:13.320] if you're not happy with the with the synchronization of the of the melody steps here or the gate
[25:18.640] signals you can always bring in a clock one ties like this one here whoops just clone this
[25:27.480] over here disconnect this so you basically get the trick or signal get it into here feed it
[25:35.760] into the ADS R and then you can use any clock a signal here you want to synchronize basically
[25:42.640] to a bit bit grid of your liking so for instance maybe use the gate gate signal here and trick
[25:52.800] out this one so now when you have a trick or signal it gets delayed until some event
[26:01.000] occurs on this gate signals we can always synchronize basically you are switch this here to trick
[26:14.320] off the speed grid right maybe you increase this here to 16 steps and maybe we also should
[26:35.920] use this here for the sample note of course so we have the same same trick up behavior
[26:46.160] so no matter what you change here on the mirror and the band settings to get some events
[26:53.320] in between the beat grid this one here basically synchronizes everything maybe try this
[27:23.320] maybe you increase this here to 12 now it's samples and now we have the pattern played
[27:41.560] back and then of course you can remove this here altogether and use maybe my note grid
[27:59.000] out note grid out and yeah you can use it for your synth or your VSTs if you want to trick
[28:20.040] something yeah external with it so maybe remove this and use a modulator modulator out so
[28:31.200] we get the pitches on here and we have also modulator out here for the gates use the pitch
[28:46.880] for this volume modulated all full time and also gate and yeah there's some information
[28:56.040] is happening here and we can use a pull isn't or you can use any VST you want of course
[29:25.760] or you can record a note to a track if you want so I wanted to give you this quick tutorial
[29:33.200] how you can approach a melody maker in this kind of way there are obviously a thousand
[29:39.880] ways to do this and you may be ask yourself how did I build this so quickly and I prepared
[29:48.640] this I made this basically off stream or off video and yeah this is how it looks here
[30:00.480] and you can download this on my Patreon of course if you are Patreon I think with the
[30:07.440] lowest tier because it's Christmas so you only need to subscribe with one dollar and
[30:11.680] you can download this patch here then on my Patreon so it's the same thing basically the
[30:18.480] same concept but instead of just having here a few notes I have the complete octave here
[30:26.240] perfectionism until last 12 so every semi-tone is in there we have also here the octaver
[30:32.720] in there the gate probabilities and I also added here some modulations for the tambour
[30:38.560] version of velocities so you can change this also and you know the triggering the recorder
[30:44.320] maybe I add here the gates recorder to this because I think it's a nice addition what
[30:50.960] yeah you can use here also the button outside of the grid so you have just press this and
[30:58.480] record new melodies or new patterns there's also no sound generator inside this patch it's
[31:07.200] all going out to modulate the outs here and I use this to modulate of course my grid note out
[31:17.360] device or preset here and I use this to generate notes and drive the spulison and you can replace
[31:22.800] the spulison here inside of Xbox of course with your VST or the different synth or different
[31:28.640] preset for the synth right so it's only an melody generator there's no sound generation
[31:36.400] inside this patch happening okay and I also integrated here the gate signal like we did
[31:42.560] with the patch before so it's basically the same thing now yeah
[31:53.680] it's on repeat here basically and if you want to sample a new melody then you
[31:58.000] probably just have to release this and then press again and the synchronization does the rest
[32:03.760] and you can see the recorder already recorded here something and now we are in playback mode
[32:16.800] so all you have to do is play around with these settings for the playback maybe add some new
[32:22.160] face yeah modules here if you want to change the playback speed maybe try out your different
[32:28.480] settings for the probabilities modules and you get some new melodies out of it hook up your VSTs
[32:35.760] your presets your synth after that and you have some fun I would say that's it for this video
[32:43.040] thanks for watching if you have some questions then please leave them in the comments below I try
[32:47.360] to answer everything also leave a thumbs up if you liked the video subscribe to the channel and
[32:52.320] maybe think about subscription or one patreon because that's what keeps me alive basically and yeah
[32:59.440] that's it thanks for watching and I'll see you in the next one bye