VCV Rack and Bitwig Studio: Synchronizing Modular Synthesis with DAWs

Tutorial | Fri Dec 03 2021 00:00:00 GMT+0000 (Coordinated Universal Time)

In this video, I discussed how to connect VCV reg and Bitwig Studio together and how to get started with VCV reg. I showed how to connect modules, what modules to choose, how to get something going and how to get information from Bitwig into VCV reg and out of VCV reg back into Bitwig Studio. I explained how to synchronize everything, quantize notes, and more. I demonstrated how to create a simple wave table synthesizer monophonic with just two simple signals coming from Bitwig studio and how to modulate it with a random modulator from inside of Bitwig studio in VZV rack. I also showed how to use a quantizer, sample and hold, and trigger buffer to synchronize signals and create interesting rhythms. Finally, I demonstrated how to use a low pass filter and sequencer to create melodies.

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

Questions & Answers #

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

How do you connect VCV-Rack and Bitwig Studio together? #

To connect VCV-Rack and Bitwig Studio together, use the ‘meets2cb’ device in VCV-Rack and create a note clip in Bitwig Studio. Connect the note clip’s pitch and gate outputs to the respective inputs in VCV-Rack. This will allow you to sync the two environments, as well as send audio signals between them.

What modules should I use to get started with VCV-Rack? #

When getting started with VCV-Rack, it is best to start with the modules included in the base module pack. This includes the oscilloscope, voltage per octave, VCO, VCA, and ADSR modules. These modules are all you need to create simple patches and experiment with sound.

How can I modulate things in VCV-Rack from Bitwig Studio? #

To modulate things in VCV-Rack from Bitwig Studio, use the voltage per octave output from Bitwig Studio to modulate the parameters of the VCA. You can also use the random modulator from inside Bitwig Studio to modulate the wavetable position.

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] Hey guys, welcome back to another video.
[00:08.680] Today it's about VCV reg and Bitwig Studio, how you connect these two together, some
[00:14.000] inspirational tips, how you get started with VCV reg, some fundamentals, how you connect
[00:20.280] modules, what modules to choose, how to get something going, get information from Bitwig
[00:27.520] into VCV reg and out of VCV reg back into Bitwig Studio, how to synchronize everything,
[00:34.040] quantize notes and so on, so pretty basic stuff to get you up to speed and maybe encourage
[00:40.120] you to try it out for yourself and get the first step into modular environment, okay,
[00:50.240] so let's start.
[00:53.240] I already loaded to VCV reg 2 in Bitwig Studio on an instrument track, as you can see, it's
[00:58.680] just a plug-in and then you load up VCV reg for the first time, you probably have a lot
[01:05.440] of modules in here which you can delete.
[01:08.960] We only need the meet2cb device on module and also here the audio out modules all we need,
[01:15.960] so we get the meet information gate information from Bitwig into VCV reg and we get audio information
[01:21.680] out to Bitwig again here at the end and what I usually do when I start up, I create
[01:29.400] here some note clip inside Bitwig Studio to synchronize basically these two environments
[01:37.480] and I double click here the note clip and I go for a note and make this pretty short
[01:47.520] and also leave some empty space because we want to generate the gate signal which has
[01:52.880] a 1 and a 0 in there, right, so something and nothing and then I can just hit play here
[02:00.400] and this loops over and over and sends out a signal into the VST and we get this then
[02:05.880] here as a gate input.
[02:07.880] So when I use your scope, maybe stick to the VCV category here first, so when you right
[02:15.200] click on empty space you get this browser and you here are presented with a lot of modules
[02:21.160] and many downloaded some additional modules you are probably overwhelmed with the quantity
[02:26.520] of modules that are available and I highly recommend you to stick to the VCV brand first
[02:32.840] and it's probably all you need to create nice sounding patches.
[02:38.360] So this is basically the fundamental pack that comes with the base pack, base module
[02:46.640] packs, so to speak and we're going to start here with what we're going to use the other
[02:55.200] scope, it's basically an oscilloscope here and we can hook up here the gate output to
[03:01.400] the input of the scope and you can see here, this is basically our notes triggering or
[03:06.720] getting the note information, when we make this note here a bit longer, we can see that
[03:13.800] we generate different signals, right, we have a zero in here, we have one in here, which
[03:18.680] is also a gate signal, it's perfectly fine, but I'll just stick to this one here, okay.
[03:25.760] So the second information we need is to pitch and we get this here with the voltage per
[03:30.000] octave jack and we can hook this up here to input 2 and you can see it's a straight line
[03:36.440] and when we change the pitch of the note, I can see that also here this line goes up,
[03:43.960] right, so this voltage represents basically the pitch inside the VCV record, and this
[03:50.800] gate information is used to synchronize basically the transport speed or synchronize things
[03:57.600] inside VCV record here with the signal.
[04:03.000] With these two signals now we create some sound inside VCV record and I just put this
[04:08.800] here down, we don't need that and we gonna use here an oscillator and there are a lot
[04:14.560] of oscillators available in the library, with the fundamental library we have here the
[04:20.800] VCO, this one here which has a sign output, a triangle, a saw, square, but you can also
[04:27.760] use here the VCO, the wave table VCO which is just a wave table oscillator, you can also
[04:35.560] load up signal wave tables here, your own wave tables, and there's also a wave table LFO,
[04:44.760] right, so this is basically the same thing just with lower frequencies, maybe we can
[04:51.840] just use this one here because it looks nice, and this one has a voltage per octave input
[04:59.000] here and we have also a voltage per octave coming from Bitwig so we can connect these two,
[05:04.200] we can see I can use basically double output checks, so to do this you have to hold control
[05:12.080] on the keyboard and then click and drag, so now we change the pitch here of the VCO with
[05:21.360] the pitch coming from Bitwig Studio which is D3, D3, and when we output here the audio
[05:28.640] signal onto the mixer we can hear now some sound, but it's a static signal, right, so we
[05:37.760] have to implement here an ADSR on envelope that changes an amplifier, we need an amplifier
[05:46.480] first, and in this VREG here we can use VCA which stands for voltage control amplifier,
[05:54.400] we can also use here a mixer if you want to which has four lines, so we can use this
[06:03.560] or we just use here this one because it looks nice like this, and we go with the output
[06:13.080] of this one, of the oscillator into the input of the amplifier and the amplifier goes
[06:18.720] you guessed it with output, so all we have to do now is to change here basically this
[06:29.200] slider with the envelope, so we insert your envelope which is called ADSR and this creates
[06:38.600] basically a shape and output this shape as a voltage signal, so we have to trigger this
[06:45.600] and we trigger this of course with our gate signal here which is the static pulse, we
[06:51.600] drag this over here and drag this to the gate input, so every time we have this gate signal
[06:59.440] this envelope gets triggered and then we can use this signal which is basically this
[07:06.240] shape here and input this here into the VCA, and now we can't hear anything because
[07:12.920] we have to raise here the maximum volume, but you can see it, it triggers this ADSR,
[07:21.400] the ADSR changes to VCA and the VCA then changes the volume of the oscillator which goes
[07:27.920] to the audio output and we have some kind of synthesizer running, monophonic synthesizer
[07:34.120] can also change here the pitch or add some additional notes and you can see the pitch
[07:40.080] is changed and it's perfectly fine, so we create basically our first simple wave
[07:48.200] table synthesizer monophonic, wave table synthesizer just two simple signals coming from
[07:56.600] Bitwig studio, so this gets a bit boring all the time so we can modulate here stuff inside
[08:06.640] of VCA actually from Bitwig itself, so when you for instance change it a wave table position
[08:14.520] you can see that it changes down here also, so we can modulate here this not basically
[08:22.880] with a random modulator, from inside of Bitwig studio in in VZV rack, which is pretty
[08:34.960] nice, another thing is we can also modulate this of course from inside VZV rack so we
[08:54.800] can use here on LFO, which just outputs static signals, so for instance here we have here
[09:07.760] a sign output, we can hook this up to the oscilloscope you can see there's a we have a
[09:13.840] Sine-Wave here and we can also change the frequency of it right and we can hook up the
[09:19.160] sign to maybe the frequency modulation here of the oscillator and it can change the
[09:30.520] amount modulation amount, so this is something you can do, you can also change here the VCA
[09:40.120] setting or the attack setting of the ADSR for instance, so we okay this is two up and
[09:47.400] then you can change the amount and you can change the ADSR with this LFO, what we also
[10:02.880] can do is we can use here something like a mixer, VCA mix for instance and we take the
[10:16.600] pitch output here from our from Bitwig studio and go into the mixer here and then we use
[10:23.760] the output of the mixer and go back to the oscillator, so it's the same as before but
[10:31.600] we can mix in here maybe the second LFO with the mixer, you can mix these signals together
[10:39.400] so when we go into the oscilloscope we have the pitch as before but you can now bring
[10:47.200] here the LFO basically mixed into the first signal and we get now here a change up in pitch
[10:58.240] which sounds like this and the more we bring it in the more the sound changes
[11:22.520] the more the pitch changes, so it's like completely wired, so what we can do now is instead
[11:29.520] of going here into the oscillator we go before we go into the oscillator we go into a quantizer
[11:39.120] like this one here and we can say we only want this node scale, so we go into here and
[11:51.480] then we go into the oscillator and then bring it, so now we change the pitch in a scale
[12:03.040] right, but now it sounds like the pitch changes within one gate trigger so we need to have
[12:11.640] some kind of sample and hold and that's also available in VCV rack of course we bring
[12:21.760] in here, there's no sample and hold here, so we need to go all brands, so we can use this
[12:33.840] sample and hold for instance, oh we can use this one here, this is what I like because
[12:47.000] we have multiple triggers here, so we take the pitch and instead of going from the quantizer
[12:53.440] into the oscillator we go here into the noise input of the sample and hold and then we
[12:59.280] trigger the sample and hold here with the gate signal, let me see this one here and every
[13:06.880] time we trigger this we get the current signal from the noise input and we go then into
[13:11.920] the oscillator and every time we trigger a node the pitch is basically hold until the
[13:19.760] triggers over, okay so triggers are bit boring because we trigger here every time we can
[13:33.680] change of course here the node clip to something different of course but we want to do this
[13:40.960] inside the VCV rack, so we're going to use here a second LFO maybe and we can use this
[13:57.320] square output to trigger the ADSR instead of the gate output from the grid or from the
[14:04.400] bit from physics studio, so we go into the gate and we can change the speed, but this is
[14:17.960] now not synchronized to our project speed, right?
[14:29.600] So we can synchronize this with the trigger buffer which was the tip by OmriCoin which
[14:38.800] is a VCV rack basically legend, I link to this channel in my description below, I can find
[14:48.440] some nice interesting tutorials on this channel, so he recommended me to use this tool or
[15:01.000] what you call trigger buffer here, looks like this and then we can go here with the square
[15:12.080] wave into the ARM input and then we can buffer basically this trigger until something happens
[15:23.040] in the second input here which is our gate signal, so we can synchronize these two signals
[15:31.200] and then we go out here to this one, maybe do this here a bit quicker, something like
[15:54.320] this and of course we need to trigger this one not with the gate inputs but instead with
[16:08.240] this output here and now we have basically a trigger signal generated by the LFO going
[16:23.600] into the trigger buffer delayed until something happens from the gate input from our bitvig
[16:28.720] studios, so we synchronize these two signals which is basically just a clock one PICE
[16:36.880] and two as you can hear it's perfectly in sync, maybe find here a nice sweet spot in between
[16:46.880] we get also some interesting rhythms, so it's now quantized to a scale here, we have
[17:04.040] a sample and hold implemented so the pitch is hold until the gate is over the gate
[17:10.600] event is done and then we have a trigger buffer here which synchronizes our gate signals
[17:17.400] coming from this LFO to the gate signal of bitvig studio, so it's perfectly in sync, so
[17:33.800] maybe we implement here also a small little filter before we go out here into the audio
[17:40.800] output, let's go back to our vcb rack thing, let's see if we find the vcf, so we take
[17:58.600] the output here from this one go into the filter and then we can choose it between low pass
[18:07.840] filter and high pass filter, so we take the low pass filter and of course we can use
[18:17.960] it the same ADSR for this to open up the filter, or maybe we can also use a separate ADSR
[18:35.880] port, I think that's pretty okay, now we can apply here some effects, maybe it's super
[18:55.640] massive, you can also use them maybe if you want to, you can use a sequencer,
[19:25.080] there's a fundamental sequencer here, a really easy one, and this one gets, or at least
[19:34.720] needs a clock input here, as you can see this one, so we can use our generated trigger
[19:42.480] buffer delay and every time we have here an input, we step to the next or we step through
[19:49.760] all steps, right, so we can dial in here the first sequence which is just random knobs
[19:59.280] that gives us some control voltage signals, and we can use these here as an output and
[20:07.320] maybe use it for the VCO here, we can remove here this external modulation, so we can use
[20:21.600] this here to change the position of the wave table, so every time the first step here
[20:32.480] plays, we open up the wave table position all the time, we can use here the second row
[20:41.840] maybe for the filter position, so we take this off, and maybe go in here,
[21:02.440] so we can create a nice rule, you're seeing melodies,
[21:28.040] maybe you can also change here the slider here, which changes basically the note range,
[21:50.960] so when we have the Z0, we just have the initial pitch here which is B3, and when we bring
[21:57.280] in the LFO, we have more note ranges up and down, so we can use the third output for changing
[22:07.840] the slider.
[22:37.800] So we can create and shape nice little things just with the fundamental modules of VCV
[22:49.720] reg, just with the help of the sample and hold, which is not part of the fundamentals
[22:56.000] and also the trigger buffer which I really like, but the rest is just simple fundamental
[23:02.040] modules of VCV reg, so maybe add here polymer,
[23:24.360] so we can add here, maybe add sound,
[23:55.360] that's it for this video, thanks for watching guys, if you have some questions then please
[24:00.240] leave it in the comments below, if you liked the video then please leave a thumbs up, subscribe
[24:04.920] to the channel and I'll see you in the next video, thanks for watching and bye.