Exploring the New Note Grid in Bitwig 4.2: Tips and Tricks

Tutorial | Feb 16, 2022

In this video, I discuss the new Note Grid device in Bitwig Studio 4.2 and how it can be used to create interesting patterns and chord progressions. I explain how the Note Grid is similar to the Poly Grid and FX Grid devices, but is specifically dedicated to node functions. I demonstrate how to use the Note Grid to create polyphonic and monophonic sounds as well as how to use it to harmonize with a chord track. Finally, I demonstrate how to use the Note Grid to target individual notes and transpose them.

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 new Note Grid in Bitwig 4.2? #

The new Note Grid in Bitwig 4.2 is a dedicated device container specifically designed to create and manipulate nodes. It is different from the Poly-Grid and the FX Grid because it only outputs nodes and is context aware, meaning it will only show node devices in the browser when a node effect is being added.

What are the two new modules in 4.2? #

The two new modules in 4.2 are the Node In and Node Out modules. The Node In module captures MIDI signals and outputs gate and pitch signals, as well as velocity and channel information. The Node Out module outputs the nodes from the device.

How can the Note Grid be used to create chord progressions? #

The Note Grid can be used to create chord progressions by using the Pitch Quantizer module. This module takes MIDI notes as an input and quantizes them to a constrained range of notes, so by setting a chord progression as the input, it will quantize the incoming MIDI notes to match that chord progression. Additionally, by using the Polytumono module, the sum of two notes can be outputted as a third

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.000] Welcome back to another video guys today. It's all about 4.2 and a new Note Grid and some tips and tricks
[00:06.440] I discovered since the release of 4.2 yesterday
[00:10.440] So this video is also nicely tacked so you can jump to the specific time mark if you want to so let's have some fun
[00:19.280] So the newest edition is basically the Note Grid and you can call the Note Grid here in physics studio by
[00:26.280] typing in Note Grid then it's here and it's just a normal grid device. It's
[00:34.440] only special in that sense that it's dedicated to the controls or that container function to
[00:40.840] the node functionality so we don't have here
[00:44.440] here call here
[00:46.600] a Poly-Grid for instance. You don't have to out volume control here
[00:51.800] because it makes no sense. It's just outputs nodes
[00:56.760] you have pre-fx positive x and that's it
[01:00.680] But you can also just use what what you do inside here of the Note Grid. You can also do inside the Poly-Grid or the fx grid
[01:11.480] and
[01:13.480] The reason why we have special containers is
[01:16.280] basically because of these controls. So for x out of x you have a mix knob because you want to mix in your audio effect
[01:26.920] and for the Poly-Grid you have an out volume knob because it's basically a synthesizer or a sampler or whatever you do inside here
[01:34.840] It's an instrument an instrument needs an out volume
[01:39.240] a knob of course and a mix knob wouldn't make sense here, right? So what do you want to mix into?
[01:47.880] There's nothing there on the track there. So first instrument it's basically the device that creates the sound
[01:55.800] and in the Note Grid here
[01:59.080] um you have no out or a mix knob or anything because it just outputs the nodes
[02:05.320] and as you can see in this order here we have now all the device
[02:12.600] categories available as a grid device. So we have the node generation
[02:17.880] we have the sound generation and we have audio effects altering the sounds of the instrument
[02:25.080] The second reason why we have different device containers of what the grid is
[02:30.200] is that bitwig is with the browser context aware. So let's imagine you have an instrument here
[02:38.840] and an audio effect after the instrument and you want to insert here some node effects
[02:44.680] and of course when you hit the plus button here the browser automatically shows you only the node fx devices
[02:53.960] instead of instruments or audio effects because we want to insert something in front of the instrument
[02:59.240] so the browser now is aware that we want to insert probably some node effects or some
[03:07.160] node altering devices, right? So and here is the Note Grid available the same goes for the presets
[03:13.720] when we switch here to presets we only see here presets that are available for node fx devices
[03:21.960] that make sense in front of an instrument and also of course when we switch here to let's see
[03:30.840] Note Grid you can see all the Note Grid presets in here and it makes sense that you only see
[03:39.640] these presets because we want to insert something in front of the instrument. So this is also
[03:44.760] reason why we have different instruments or different devices for the grid. So when we look here
[03:52.840] or when we create a new node effects device or Note Grid device inside here there's nothing
[04:00.840] different than in the polygrid or the fx grid it's the same thing. The only difference is that we
[04:08.120] have now in 4.2 these two devices here or modules and you can also expand these here.
[04:19.560] Which basically gets you the information of the gate signals when you press on a MIDI keyboard
[04:25.560] key then you get the gate and the pitch and also the velocity and you're also some channel
[04:30.440] informations if you use an MPE controller you get a tumbler and pressure and so on and you can just
[04:38.520] input to the output and in between you can hook up some math or logic modules and can alter
[04:47.320] pitch or the gate information and so on. So these two modules are basically new in 4.2
[04:55.720] and you can also use them inside your polygrid if you want to. So for ends we get the node in
[05:03.320] here and you can use them here and can also output after the polygrid the nodes out here.
[05:15.720] And you can see we have here some settings which are basically the default settings so when
[05:23.560] there's no signal going into this jack here this one outputs this node and this velocity setting
[05:32.040] on this channel you can set some default settings when there's no signal available.
[05:39.240] So there's no really not really a difference between these devices. Now that's what I want to
[05:49.560] make clear because a lot of people thought oh the Note Grid is something completely new it's not
[05:54.440] it's just a grid. So let's actually build something in this constellation. I have now here a polygrid
[06:00.440] which kind of imitates a synthesizer on instrument or it's a simple instrument here we can play
[06:08.040] something on the keyboard and we have an fx grid device where there's a phasor plus in there
[06:15.640] to simulate some kind of audio effect we have a mix now we can dial in here
[06:21.800] audio effect slightly and then we have in front here the monochrome Note Grid and the Note Grid
[06:28.120] just takes the nodes with the gate and the pitch and the velocity and the channel settings and outputs
[06:35.240] it straight here to the back of the Note Grid and delivers it to the instrument right so we get
[06:41.800] here from here we come from the MIDI keyboard MIDI keyboard goes into the Note Grid Note Grid changes
[06:47.960] the nodes outputs the nodes into the polygrid in the synthesizer the synthesizer outputs audio
[06:55.000] into the fx grid here and fx grid mix it together with a try and a bad signal. So we have a pretty
[07:03.320] standard instrument chain setup so what we do now is we try and change and alter the pitch
[07:13.320] informations or maybe also the gate informations that we get from the MIDI keyboard so at this point
[07:20.120] here when you select the device itself you can see the Note Grid can operate in polyphonic mode
[07:26.600] or in monophonic mode which means it only accepts one node after the other if you press multiple
[07:32.120] keys it just takes the last node to press right so you have to be aware of that if you use your
[07:44.280] polyphonic mode then every time you press multiple keys on the keyboard this patch gets
[07:52.600] duplicated virtually to how many keys you press if you press five keys you duplicate this virtually five times
[08:01.880] and on every voice you do basically the same operation so let's take here for instance a quantizer
[08:12.200] we have this quantizer here you get the MIDI or the pitch information from our keyboard
[08:17.560] and get into the quantizer to the output here and when we press now keys
[08:26.600] doesn't matter which keys we are pressing on the keyboard we only get these nodes here that are
[08:31.800] highlighted out of the device itself okay so it's basically a diatonic transposer or a transposition
[08:39.720] map or however you want to call it it's a quantizer a pitch quantizer it quantizes the pitch
[08:45.480] information to a constrained range of nodes or nodes you select here but you can also switch this
[08:56.440] here to a different mode with this button and in this mode it accepts the MIDI input so when we
[09:03.720] press your multiple keys on the keyboard I can see we're pressing this node this node and this
[09:08.520] node and now the switch quantizer here only allows these nodes that are highlighted to pass through
[09:16.120] or where the signal is corrected to so we can deselect us here and maybe use for instance let's
[09:29.480] use a transpose here in front and use an LFO it's this one and now we just modulate us here let's go
[09:43.240] for 12 semi-tones maybe just you know modulate up or down so when we press now multiple keys
[09:54.920] you can hear something happens the problem now is that we only get here some signals because we
[10:12.440] are triggering the MIDI keyboard and we get the gate information from the keyboard what we need for
[10:18.600] every pitch or every voice we need to separate trigger so we can do this by using
[10:29.320] trigger module here which just outputs a static pulse so let's do this maybe go to six and then
[10:36.920] we press now multiple keys we get kind of this sound I'm holding the keys on my keyboard here
[10:54.440] and the LFO modulates the transpose which autoes all the features that are going into the
[11:00.680] transpose and remember it's for every single node you are pressing it's for every voice separate
[11:07.960] and then we go to the pitch quantizer here which quantizes the pitches to the nodes we are
[11:14.040] pressing on the keyboard and the triggers fix basically some nodes some gate information so we
[11:22.040] trigger each voice differently with this thing here right the problem now is that the LFO changes
[11:34.280] the pitch here from the transpose in between the triggers so we need the sample and hold
[11:40.520] to get rid of this glitchy feel and do something like this so every time a trigger happens we
[11:48.520] sample the current pitch information and hold the pitch information until the trigger releases
[11:56.200] so this should be sound cleaner
[12:11.400] so now we have the problem that for every voice we are using five or four pulses here
[12:17.640] and maybe we want to change this for every voice differently and we can do this by maybe separating
[12:26.600] this here with the pitch so we get to the pitch information user module later
[12:33.480] get the pitch and of course every node has a different value or a different signal strength
[12:41.800] so for instance if I press c3 it's 0 if I press c4 it's probably 0.5 or something
[12:51.400] um we can modulate here this in this direction so every node the higher the node the node is I'm
[13:02.840] inputting into the Note Grid the more triggers I generate here right so when I press now
[13:15.880] with the book piece I should have different speeds or different pulses for each node
[13:33.000] okay so because we don't know which pulse or how many pulses we play for each voice we can kind
[13:39.960] of correct this by using a clock one ties here so we go with the triggers into the clock one ties
[13:49.800] and we want to have a second trigger module here and this trigger module
[13:57.480] kind of quantize everything to 16th Note Grid the should sound a bit better or maybe a bit more
[14:06.280] groovy let's try it so I press multiple keys again
[14:27.160] okay so you can create kind of interesting patterns or
[14:32.680] appriciators with this without using the appriciator
[14:49.320] that's pretty nice it's a re-bub here maybe a delay
[14:53.320] let's turn this a bit down here
[15:01.160] we can create with multiple keys on the keyboard you can create a pretty strange appriciator that
[15:24.120] sounds a bit different than your usual appriciator right another interesting concept is to
[15:32.120] use the pitch quantize to create some kind of chord tracks so imagine you have one track
[15:40.920] instrument track let's use what you know here and you call this chord track
[15:49.800] inside this chord track you generate multiple notes for instance here I'm just some minor
[15:59.880] chords and you use a diatonic transposer D sharp minor and you create some chords you can also just
[16:08.280] paint and hear some chords that's a matter really with something like this here
[16:25.160] or you can put it also on the clip launcher and just loop this over and over
[16:30.440] and when you put in here a Polysen to get the notes you can also use scalar 2 if you want to
[16:46.840] or any chord progression generator it doesn't matter the only thing you need to know is if it outputs
[16:55.560] media notes you can use it inside here we can now use the quantizer the pitch quantize
[17:05.960] go in here go out switch this to this mode and then on the left side you can use a different
[17:13.560] track here for instance the chord tracking we want to get the notes after the kill filter
[17:18.440] so now this pitch quantizer basically gets notes from this track or from this chord track here
[17:30.120] and quantizes everything to the current state of this chord progression
[17:35.160] so what we can do now is we can hit here arm and play on the keyboard and everything gets
[17:41.880] corrected to these three notes
[17:57.320] and maybe add here maybe the sound from this Polysen so you can hear it
[18:18.840] so what this means is you basically can create chord track and with a note grid device here
[18:25.000] and this method you can kind of harmonize with your keyboard to the current chord position
[18:34.440] so you can create very very weird chord progressions and then use it as a guide for the pitch quantizer
[18:43.720] and if you don't like that the pitch changes for some of the transitions because when you hold the
[18:50.840] pitch can I do this here maybe using a DSR
[19:05.880] you can hear it just hold basically the note and when the chord progression changes it also changes
[19:14.440] here this one if you don't want to have this then you need also a sample and hold here
[19:22.920] you need to hold the current note without changing the value
[19:34.920] so the moment you press basically a note that's in here doesn't get changed
[19:39.800] when the chord progression changes to a different chord okay so this is something you need to be
[19:45.320] aware of so this is an easy trick to change pitch quantizer on the fly with the chord track
[19:52.120] super handy so let's take a note clip here inside this note clip we paint only two notes for
[19:59.640] instance we choose here the D 1 2 3 4 5 6 7 and the fifth of D so two notes and we go straight into
[20:11.400] the note clip here inside the note clip we use the new polytumono module looks like this
[20:19.720] and we get some pitch information in here and a pull down here you can choose what you want to
[20:25.400] output so you can say the remember the notes that are going into the note grid or
[20:33.160] integrate in general are converted to signals and signals mean it's just a value so C3 is basically
[20:41.320] the value of 0 you can see this all the time when you use an oscilloscope here in the middle line
[20:47.880] of the oscilloscope is 0 and when you input C3 then you get the line of 0 or a signal of 0
[20:58.360] you go to here this is I think C4 or C5 you know the value gets higher you can also use a readout
[21:09.240] for that which gives you just the number more or less you can see it raises basically and the
[21:19.160] highest note is I think C7 which is basically 1 so C3 is 0 C7 is 1 and C-2 I think is minus 1
[21:32.440] okay so all the notes get converted to just signals that have a value number so that's important
[21:42.760] to know because when we now input multiple notes we can say I want to want to have the sum of
[21:52.360] of these notes here which are d4 a4 and each of these notes has a value and you can add these
[22:04.040] values together right you can say give me the sum of that and the interesting part now is we can
[22:12.120] play a third note which is the sum of these two notes right so we add the number the value of this
[22:21.160] to the value of this to get a third result or a third note which is the sum of these two notes
[22:29.080] I hope this is clear what I wanted to say we can do this by just outputting regular here the
[22:37.240] notes that are going in which which are our two notes and then we are using a second
[22:42.680] a second output here and this one takes the pitch of the sum so now we have three notes
[22:54.040] playing you can hear it right and the more these notes are apart or yeah basically away from C3
[23:06.360] which is 0 and the higher the third note becomes now maybe I use here the
[23:21.800] um this MIDI chord analyzer you can see it then on the keyboard you can see we have now three notes here
[23:40.360] you can see it it jumps way up here it's basically a combination or the sum of these two notes
[23:53.560] create a third note it can be interesting to use this for chord progressions or yeah in general just
[24:18.440] interesting fact you also can switch it to average which can lead to interesting results maybe
[24:38.280] let's say you want to target multiple or individual notes and we have still here two notes playing
[24:44.200] and when we use your note grid completely empty close this here we want to let's say we want to
[24:56.040] change the upper note and we also want to change the lower note but differently so we can use here
[25:03.000] the Poly the mono thing module again can say max which is the highest signal which is the
[25:10.040] upper note or minimum which is the lowest signal which is of course the lowest note so let's say
[25:16.520] we go here for the upper note and use or let's say we use the drastic transpose we want to
[25:24.680] transpose the upper note up like seven semitones you can also use a quantizer of course or whatever you
[25:32.280] want and then we duplicate this and say we want to target here the minimal the lowest note
[25:39.080] and we want to turn by five semitones we just do that the problem now is when you input just one
[25:50.600] note this one note goes into this chain and also into this chain which produces again two notes
[26:05.400] because we just duplicate the note here or multiply the note and then we add just some
[26:12.680] alterations to each of these notes so this is a problem but what we can do is we can
[26:19.080] multiply this here again remove this and now we have to disable basically this
[26:26.440] these two patches here when we just press one key and we can do this by using the keys held
[26:35.560] thing here it shows us how many keys we are pressing so when I press one key it shows one
[26:41.000] when I press three keys or two shows two or three so it gives us the information of how many keys
[26:50.120] are impressed and you can use a constant here and say two and we make a logical comparison here by
[27:02.280] using here the comparator this equals this so when we have two here the sends the logic signal out
[27:12.120] so one is nothing two keys gives us a yes or a gate or a high signal and then we need maybe a
[27:23.000] select here which yeah you select everything when we press or only switches on when we have multiple
[27:32.600] keys let's do this go in here of course every time I press one key it goes through that line
[27:52.600] and we need to have of course also a select in here maybe not
[28:04.760] I'm gonna press two keys only this is active when I press one key only this is active
[28:23.960] okay so every time I input two notes these two chains are active and
[28:32.680] altering the upper node and the lower node when I only input one node only this becomes active
[28:39.080] and just outputs the node so we can distinct all the difference differentiate between
[28:48.680] multiple node inputs right we can create interesting devices just with this
[28:54.440] let's say you have three nodes right the E3 G3 C4 and you want to target this node so how do we
[29:05.400] get this because we know the lowest value of the of the D3 we know the max value which is C4
[29:13.400] and we also know the sum of all these nodes together can just calculate the middle node
[29:20.280] we can do this by using monopoly and we get the sum of all three nodes together and we subtract
[29:36.040] the highest node max highest node so all three nodes together subtracted by the highest node
[29:44.680] and then subtract again here by the lowest node okay and then we get get the readout here
[30:01.000] we get G3 and I hit play and we have here G3 so when I switch this to A3 let's see we have A3
[30:12.600] right this is how we get to the middle node and you can target then this node or you get
[30:20.200] pitch more or less of the middle node and you can alter this and can output the node separately
[30:26.440] and yeah have some fun with it another interesting way of using the Note Grid is by
[30:34.440] making it basically a drum machine so using xO here as a VST so you can see it also works with
[30:46.840] a VST plug-ins of course because Note Grid just outputs random nodes let's go here with some
[30:57.480] preset I have no idea how it sounds that's fine I think this one is C1 so create a Note Grid
[31:14.520] and then you can utilize basically the default settings we can say I want to trigger the kick
[31:21.880] drum here C1 let's able this and choose trigger this one and switch it to monophonic mode so it
[31:37.160] plays for itself we don't need the inputs here duplicate this and say this is snare
[31:53.080] oh we can use here the gates module
[32:04.600] so we can basically create some kind of steps sequences with this
[32:34.920] now so you see maybe a step smooth change the velocity
[32:49.880] okay you can also turn on here of course the global shuffle what the grid
[32:55.640] and add here some groove and bring in some probabilities
[33:09.320] clap here so you can use everything you have in the grid
[33:39.800] just to play around with some beats and also of course use
[33:49.960] maybe the clock quantizer some triggers
[33:56.120] 16th grid you know make some more movie things
[34:16.520] so just by using here the grid as a monogrid monophonic grid and the outputs here with some triggers
[34:32.520] and some gate things or maybe also your features module so yeah you can create basically
[34:41.320] nice step sequences for your drum machines just for fun here I used basically my
[34:50.920] pitch quantized trick from earlier with a sample hold the grid is on mono and I also used
[34:57.560] the new quantized device here to make all my inputs quantized to the grid so on this
[35:04.680] track here I am having a EDM chord progression some random thing and all the pitch quantizes here
[35:13.320] basically connected to the chord track here above and all I can do now is I can play here a melody
[35:20.120] that only uses notes from this chord progression so it plays very well along without me actually
[35:29.720] so I'm not able to play the piano but with this I can
[35:39.720] sometimes this is great when you use some complicated jazz chords and you want to
[35:59.800] find the melody that also is you know harmonizing over the chord progression then this is a neat trick
[36:09.800] and that's it for this video thanks for watching guys if you have some additional tricks and tips
[36:15.240] maybe for the note grid then please let me know in the comments below subscribe to the channel
[36:20.600] leave a like if you liked the video and I'll see you in the next video thanks for watching and