Creating a Polyphonic Synthesizer VST3 with Max - Tutorial

Tutorial | Nov 03, 2022

In this video, I created a polyphonic synthesizer in Max with a new rainbow patcher. I started by creating an audio output module and then created a rainbow sub-patcher with an oscillator and connected it to the audio output. I then added MIDI inputs and connected them to the oscillator so I could change the frequency with my keyboard. I also added an ADSR filter to give the oscillator an attack, decay, sustain, and release phase. Finally, I exported the patch as a VST3 and tested it in BitwigStudio.

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 Max and what is the Rainbow Patcher? #

Max is a graphical programming language designed to create interactive digital audio, audio effects, and multimedia applications. The Rainbow Patcher is a visual programming environment within Max that allows users to create their own patches, which are a combination of objects, connections, and messages that can be used to process audio, control devices, and create interesting sounds.

How does one create an audio output in Max? #

Creating an audio output in Max is as easy as creating an object. To create an audio output, double click in an empty space in the Max patcher. Type in the "AC~" object and hit enter. This will create an audio output with two channels: left and right.

What is the purpose of an MTOF object in Max? #

The MTOF object in Max stands for MIDI to Frequency converter. It is used to convert a MIDI number into a frequency. This is useful when creating a synthesizer in Max as it allows one to map a key on a MIDI keyboard to a frequency that can then be used to control the oscillator.

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 folks, welcome back, and today we're gonna try to create some kind of polyphonic synthesizer
[00:08.280] as a VST3 inside of Max with a new rainbow patcher.
[00:13.160] So let's see how easy and fast this is.
[00:16.440] And I opened already here Max.
[00:19.880] And for me, I disabled everything, I just want to have the Max console here.
[00:23.920] And this usually just output some debugging messages.
[00:27.760] And because we are real programmers, we completely ignore everything that happens in this debugging
[00:33.320] console, right?
[00:35.040] But we need this here to open up a new patcher.
[00:38.840] And this looks like this.
[00:39.840] This is a regular Max patch here, and we create objects in here.
[00:45.080] So at first, I want to zoom in a bit here, or maybe twice.
[00:50.160] So you can see what's going on.
[00:52.560] So at first, we need, of course, an output, an audio output, so we can output signals
[00:58.480] to our sound driver or sound card, and we do this by creating an object here.
[01:04.360] And we create objects by just double clicking or using these buttons here on top.
[01:10.880] And I just use here the double click.
[01:13.080] And this opens up here an empty object, and we can type in something.
[01:16.640] It's exactly like the Black Data tutorial I made in the last video.
[01:22.960] It's basically the same concept, because Max forked pure data at some point in the past,
[01:30.960] and they added stuff on top.
[01:32.400] But it's usually the main base or how it works is the same.
[01:37.080] So we have here an empty object, and you can see the cursor is flashing, so we can type
[01:41.120] in what we want to add as an object.
[01:43.560] We type in the AC tilde, and the AC stands for digital audio conversion, I think.
[01:50.320] And the tilde basically tells that this object wants to or processes signals at audio rate
[02:00.040] or audio signals.
[02:01.800] So just hit return here.
[02:03.080] So I have a new audio output, and we have a left output and a right output, so two channels,
[02:09.240] so stereo output, right?
[02:12.320] And then we want to create a new object here, and this is our rainbow sub-patch.
[02:18.160] So we create an object here called RNVO tilde, because it processes audio signals.
[02:24.640] And when we hit return, you can see we open up here a new patching window.
[02:30.800] And everything in here is basically in here, or everything we do in here is this object,
[02:37.920] right?
[02:38.920] And you can see we have only one output, which is the port message outlet and default inlet.
[02:47.000] That's not what we need.
[02:48.000] We need two audio outputs in here, or add this object.
[02:52.560] So we create your new object by double clicking in this patcher, and call this out tilde,
[03:00.040] because it processes audio outputs or audio signals, then empty space and one, that's
[03:06.040] the first output.
[03:07.760] And maybe we zoom in also here, yes, output one.
[03:14.680] And you can see we already created your new outlet, the signal outlet one, right?
[03:20.160] This is the left channel.
[03:22.720] And then we want to create a second output, which is the right channel, so out two.
[03:30.640] And you probably can guess that you can create more outputs if you want to, but we only need
[03:36.160] stereo outputs.
[03:37.160] So we have two outlets here.
[03:39.320] And we also connect here the second output to the input of the DAC, so we can hear something
[03:46.240] when we do something.
[03:48.840] So in this rainbow patcher now here, we can create stuff to synthesize sounds.
[03:59.800] So the easiest way to do this would be to create some kind of oscillator, and we can
[04:04.000] do this by double clicking and creating a new object, and there are multiple oscillators
[04:08.080] inside of Max or this rainbow environment, of course.
[04:12.920] And you can, for instance, use your saw, sawtooth wave form or wave oscillator, but we want
[04:20.040] to use here, let's use cycle, which is the sine oscillator, and also tilde, because it
[04:27.760] outputs audio signals.
[04:30.080] Let's hit return.
[04:32.480] And now we could easily just connect here the output of the cycle oscillator with the
[04:37.640] outlets here, but we need to do something first.
[04:41.200] And this is, we need to specify a frequency of this oscillator.
[04:46.800] We have here an frequency input, and we need some kind of number, and we can create a number
[04:51.800] by using here at the top numbers button, and then we can choose between a floating point
[04:59.600] number or adjust an integer, which is no floating points.
[05:05.200] And that's what we need.
[05:06.200] We just want to specify basically a frequency, maybe let's say 500 hertz, around 500 hertz.
[05:15.640] So we can connect to the output of this with the cycle input.
[05:20.040] And the first input check here shows you the help, the online help basically shows you
[05:24.480] the cycle frequency, frequency of phase, so it accepts basically a value.
[05:29.960] That's exactly what we're doing here.
[05:32.160] We're giving the sine oscillator a frequency, so 500 hertz, maybe switch this on here.
[05:39.200] So the audio is active, or this whole patcher is active.
[05:45.440] And then we can connect, or maybe pull this down here a bit, we can connect the output
[05:49.800] of the oscillator here with output one, and all the two, and you can already hear.
[06:05.440] We have basically a sine wave playing to our speakers, and we can change the frequency.
[06:13.400] So that's basically half the synth already, right?
[06:16.960] So what we need to do now is we need to create some kind of MIDI inputs.
[06:22.440] We can use our MIDI keyboard to play, actually, I have to switch it on here, so we can play
[06:30.080] something on the keyboard and change the frequency.
[06:33.040] Now already did this, I think, in the plug data tutorial last time, but yeah, I want
[06:39.440] to do it again, of course.
[06:40.800] So we create a new object, use node in, node tilde, because it just outputs regular signals.
[06:50.880] And we need to convert this node data, because we're getting basically the node number of
[06:57.040] the key we are pressing on the keyboard, so if I press, I think, C3, we get a number of
[07:03.360] 60.
[07:05.200] If I press C sharp, then we get 61, and so on.
[07:10.400] So it's just a number, a MIDI number, and we need to convert this into frequencies.
[07:14.800] So C3 needs to be, instead of 60, it needs to be 262, I think a bit, we get 262 for
[07:23.800] C3.
[07:24.800] So we need the frequency number, right?
[07:26.320] So you can do this by creating a new object and using an MTOF, which stands for MIDI to
[07:36.080] frequency converter, and we connected the MIDI number or the node number output with
[07:42.960] the input of this, and this output is now here a frequency, and you can use this frequency
[07:49.360] to connect this here, maybe also to our slider or to our number box, so we can see what's
[07:54.320] changing.
[07:55.320] We connect this here a bit more.
[07:58.560] Let's see if it's actually working, so no, it's not working, because we don't get nodes
[08:05.520] in here.
[08:08.400] Let's right click this and open node help.
[08:11.320] Let's see how this looks like here.
[08:16.000] We probably need MIDI in.
[08:22.000] Yes, you can see here is a rainbow object, and we need load mass, MIDI info, and then
[08:30.240] we can change here what kind of MIDI input we want, and we get this MIDI in thing, and
[08:37.280] then we can connect here with the R and B O patch up.
[08:41.080] So we just do this and disable here the locking thing, just select everything, control and
[08:48.840] C, control and V, so we input this here, and we just connect these two, right?
[08:57.600] And we select here the right MIDI input, I use my key set pro, and we can close here
[09:03.960] this helping, helping patcher again, and maybe switch this on.
[09:13.480] And now I can play something on the keyboard, perfect.
[09:25.080] So we can change the frequency actually with our MIDI keyboard, and it's the right key,
[09:29.920] and we get the right frequency for our sine oscillator.
[09:34.480] The next step would be to change the volume of this oscillator output here.
[09:40.480] And we do this by just the math operations we use here, the multiplication and the tilde,
[09:45.520] of course, because it wants to process audio signals to just hit return.
[09:52.440] We can grab this here, hold shift, and just look at or plug it in between here.
[09:59.480] And also this one goes into there, so it's just one output here and two outputs there.
[10:08.640] So it's a mono signal, right?
[10:10.600] So the left channel and the right channel are basically the same because our sine oscillator
[10:14.760] is just a mono signal.
[10:17.320] And here we have a multiplication, and the second input jack is empty.
[10:21.440] So here we can input also a number.
[10:24.240] So maybe use here this time floating point number because we want to have numbers, let's
[10:32.240] open up here, this one, we want to have numbers between zero and one.
[10:38.480] So one is the loudest volume and zero is, yeah, no volume at all.
[10:42.960] You can input here the values minimum, maximum for this box because this box is currently
[10:48.440] selected.
[10:49.680] So we input here zero, which is the minimum number, the maximum number is one and everything
[10:55.360] in between.
[10:56.360] Because this is a floating point, we have here now zero dot one, two, three, four, five,
[11:03.960] six, seven, so floating point steps until we hit one.
[11:08.640] So we can pull this down and we can use this number here to input this into the multiplication.
[11:14.560] And this is basically just a volume or a mixer or, yeah, an operation that changes the volume
[11:22.040] of something.
[11:23.040] So we can switch this on and we can change the volume here.
[11:32.600] And we can change the frequencies with the keyboard.
[11:37.880] Okay, so now we want to change, actually, this you're not with this number box, you want
[11:43.360] to change this maybe with an envelope, right?
[11:48.560] So when you press a key, you want to have an attack and then you want to have a sustained
[11:52.640] phase and the release phase when you actually release the key on the keyboard.
[11:57.800] So we can do this by using an ADSR filter object here.
[12:05.400] And this outputs basically a number between zero and one.
[12:10.200] It's exactly what we want.
[12:12.440] And we also have here some inputs for the attack.
[12:15.140] We have here ADSR trigger.
[12:19.520] And we have decay.
[12:22.040] We also have sustain and release.
[12:25.160] And if we open up here the help menu for this, right click or you just hold alt and click
[12:30.240] it.
[12:33.240] We can see here, these two here are basically in milliseconds.
[12:38.160] We can define a number that defines the milliseconds, so that attack phase in milliseconds, decay
[12:43.080] phase in milliseconds, then we have the sustain level, which is between zero and one.
[12:48.680] So zero is quiet and one is the loudest part.
[12:53.920] And then we have release here again in milliseconds.
[12:56.440] So the sustain level here is basically a bit differently.
[13:01.160] And one starts the envelope and the message of zero releases the key, right?
[13:08.140] So one is start the envelope or everything that's not zero is basically the explanation.
[13:15.280] A non-zero number gives the maximum level of the envelope.
[13:21.000] So we can utilize here to trigger this.
[13:24.440] We can utilize here the velocity like I did in the other tutorial too.
[13:30.080] And we also need to convert this number because the velocity is always between zero and 127.
[13:37.480] It's the maximum velocity number in the media standard.
[13:42.120] And this one here has the maximum number of one and the minimum value of zero.
[13:47.920] So we have to convert this by using an object and dividing everything by 127.
[13:56.040] So the maximum velocity number or value of 127 becomes one and everything in between
[14:04.040] is scaled down accordingly.
[14:06.680] So we can take this and put this into here the trigger of the ADSR.
[14:13.560] And basically what we are doing is when we pressing a key here and the velocity is probably
[14:18.920] when we press something on the keyboard is probably above zero.
[14:22.920] So maybe 60 or something like this gets divided by 127.
[14:28.400] Then it's a non-zero value which triggers the ADSR and also sets the sustain phase to
[14:35.160] the correct number.
[14:37.680] And we can change the attack, decay and release phase.
[14:41.600] And we can change this by using also numbers.
[14:45.520] So maybe delete this.
[14:48.920] So use here a number box and we want to use also your integer.
[14:53.560] So no floating points basically.
[14:58.160] So this is the attack, maybe duplicate this.
[15:08.160] This is a decay, duplicate this, this is sustain.
[15:18.280] And here we need to set this also minimum zero, maximum one.
[15:25.360] Of course this is not milliseconds, it's a different unit.
[15:29.960] And we also want to have release here at the end.
[15:34.680] So we can dial in milliseconds for the attack, for the decay, for the release and we want
[15:40.280] to have something, actually this needs to be here a floating point because we want to
[15:50.560] have something between zero and one, like these two, and here minimum zero, maximum
[15:59.080] one.
[16:00.080] Okay, so now we can dial something in between.
[16:03.840] So now let's try it out if it works, or we have to actually connect these two here.
[16:10.720] Maybe make a sharp attack, longer release.
[16:30.720] So it basically works nice, we can maybe also set this to minimum zero because we don't
[16:36.120] want to have values below zero.
[16:39.800] So it's safe to use.
[16:41.440] Okay, so now that we have this, we maybe can already try and export this as VST and try
[16:50.280] it out in BitwigStudio, right?
[16:52.440] So maybe we just save this here.
[16:56.120] Save as and maybe call it only since why.
[17:03.720] Just save this and maybe use the export button and choose audio plug in export.
[17:17.920] Format and platform is VST three windows, we are on windows currently, and we call this
[17:23.200] maybe Poly, Polysynth, or maybe synth tutorial, so you can see how it's called.
[17:43.280] Company is polarity, of course.
[17:47.200] It's an instrument.
[17:48.640] Export directory is already set here to my VST directory.
[17:54.760] It's programs, common files, VST three, that's correct.
[18:00.400] Then we have include presets, blah, blah, blah, open export directory.
[18:05.120] It's not what we want.
[18:07.000] And we can just hit here export to selected target.
[18:11.040] And you can see here there's some debugging messages and also the compiling is not done
[18:17.040] locally.
[18:18.360] Just upload it, you basically upload this patch into the cloud, upload generated code
[18:24.000] and start cloud build.
[18:25.600] So it's compiled basically on their servers.
[18:28.800] I don't know why they did this, but I'm sure there's a really good reason for that.
[18:35.480] And we are waiting here basically for the cloud build to come back.
[18:40.680] And then the VST three is put into our VST three directory.
[18:47.780] So we can see finishing successfully exported to target.
[18:51.440] So we can open up here our VST three plug in.
[18:58.400] And it's already in the wrong directory, which is really nice.
[19:04.480] So maybe copy this here and go back to our VST three directory, put this in there.
[19:12.320] Just pass it in there.
[19:14.960] And it should be here, send tutorial, nice.
[19:18.200] So now we open up a Bitvek studio here.
[19:20.840] And maybe this should be already in there, send tutorial devices, and we have this here.
[19:28.840] So open this up, you can see the interface is pretty minimal, but it's not important.
[19:39.320] So just activate here the input and maybe in the patch I have in here, we want to maybe
[19:47.480] disable this.
[19:51.160] And now we can see it kind of works.
[19:53.360] We have this clicking happening, but there's actually no controls for attack, decay and
[20:01.320] anything like that.
[20:02.480] We need to implement that.
[20:05.000] So just delete this here.
[20:06.400] But we can see the VST actually loads and it kind of works.
[20:10.560] We have at least something happening.
[20:13.960] And go back to our thing here, to our max patcher, maybe close this down.
[20:23.800] And we want to implement basically your controls.
[20:26.360] Instead of having these numbers, we want to have parameters we can change at the send
[20:32.600] in Bitvek, so we can change the attack, decay and sustain and so on.
[20:38.200] And we can do this by using an object here in the rainbow patcher called param.
[20:45.160] And it wants to complete the final parameter that can control RBNO or rainbow externally.
[20:51.840] So this is what we want.
[20:53.880] And we can give this a name.
[20:55.760] And the name is attack, probably, and we can define here a minimum, or let's go for the
[21:07.720] shorthand here min.
[21:09.920] And the minimum number is, of course, zero, zero milliseconds.
[21:17.000] And instead of this number here, we use this, or the attack.
[21:22.240] Then we do the same for decay.
[21:30.760] Connect this here to the second input, so we can delete this.
[21:34.040] Then we do this, of course, for sustain, which we turn, connect this, and here the minimum
[21:43.880] is also zero, but the maximum, maximum number is one.
[21:50.960] So let's use one here, maybe pull this down, we can delete this here.
[22:05.480] And then we need this one here.
[22:11.840] And this is release, it's return, connect this here to the last input jack, and just
[22:19.640] delete this.
[22:20.640] So now we define basically all these parameters, and they should show up in the BST3 implementation,
[22:28.760] basically.
[22:29.760] Also, we have here some error messages because I haven't renamed in time, but it's corrected
[22:39.640] now.
[22:40.640] So we have all unique names, attack, decay, sustain, release, and we have also defined
[22:47.000] here the minimum value, and here the maximum value of one for the sustain phase.
[22:52.840] And this should be good.
[22:54.160] So let's save this here.
[23:00.200] Maybe also here export and use export again.
[23:04.480] Maybe let's see if I can go back here to the, okay, let's use this, export, and we want
[23:15.520] to override, so you can see your program files, command files, BST3, override, yes, we want
[23:20.800] to do that.
[23:21.880] And you have to make sure that you actually unloaded here the BST3, otherwise you get
[23:26.720] an error, or you already have the BST running.
[23:31.560] So you need to make sure that the BST is closed or unloaded.
[23:38.280] Hit okay.
[23:40.080] And again, everything is uploaded to the cloud, and they compile everything on their servers,
[23:46.040] and we hopefully get a nice build back.
[23:50.520] So to build this finished, successfully exported to target, so maybe open up here the window
[23:57.760] again, and now we are on the correct folder here, programs, command files, BST3, and we
[24:04.200] have here the newest version, yeah, it's the same time.
[24:09.080] So it's a new file, and we can go back here to Bitwig Studio and try to load this up.
[24:16.520] So send tutorial, BST3, and look at that, we have now release, sustain, decay, attack,
[24:26.040] as parameters.
[24:27.040] So let's try it out.
[24:28.800] Maybe I have to go back here first to this one, and after this, oh, it's actually disabled.
[24:33.920] So if I don't disable this, I basically play in the background with my MIDI keyboard, Max,
[24:41.000] and Bitwig at the same time, which is not what I want.
[24:43.400] I want to play actually only this instance.
[24:47.920] So we have this click again, we can input here, sustain, decay, attack, and release.
[24:59.200] Oh, we can see here, the numbers are actually not right.
[25:14.120] We have here something between zero and one, for the release, that's not what we want.
[25:21.560] We want to have much, much higher numbers because this is milliseconds.
[25:25.760] We have to check something.
[25:27.040] What we can see, we have here parameters exposed to the BST3 interface, and we can use it,
[25:35.160] we can change it, and it does something.
[25:40.720] At least we have some sound running.
[25:43.080] Close this down, unload it, and we go back to the patcher, and we want to see here what
[25:49.800] we can do.
[25:52.680] So maybe we input here first, instead of min zero, we also add here max, a max value of,
[26:00.920] maybe let's go for 200 milliseconds, also your decay is maximum of 200, and maybe the
[26:12.200] release base here gets a lot of maximum value of 500 milliseconds.
[26:20.720] So now that we have this, this should be good, actually, this should be working, and we want
[26:26.680] to implement a bit more because the problem is we have only a monophonic synthesizer,
[26:32.000] so we can only play one note at a time.
[26:36.840] And we want to have a polyphonic synthesizer, we want to play chords, we want to play multiple
[26:41.240] notes at the same time, and we can do this pretty easily, it's actually much more easier
[26:46.880] than before with the rainbow here, with the rainbow patcher, we can just add here a new
[26:52.760] parameter to the global rainbow patcher and call it polyphony, and add a number, for instance
[27:00.600] eight or four, which is the maximum number of voices we want to use in parallel.
[27:07.360] So let's go for eight or maybe 16 notes here, and yeah, we should be good.
[27:14.400] So let's save this, save this up, and maybe compile it again.
[27:21.840] So export again, overwrite, yes, that's what we want to do.
[27:27.160] And here we go.
[27:29.600] So and we have our compiled VST3 back from the cloud, so we can try it out in Bitwig.
[27:38.280] So let's go back, synth tutorial, and let's see, oh yeah, we have much, much higher numbers
[27:46.240] now, you can see here we can go up to 500 for the release, sustain, decay, tag, and
[27:55.120] let's try it out.
[28:05.920] And let's play multiple notes.
[28:10.680] Wow, so it's actually not that hard to create a synthesizer in this rainbow thing.
[28:25.240] And maybe we can do some more because it's that easy.
[28:28.720] So back in Max here, we probably want to create some kind of FM modulator.
[28:36.320] So we need a second oscillator to modulate the first oscillators.
[28:41.560] We have our sine oscillator here, and we have a frequency input.
[28:46.040] And we want to combine this with the second oscillator that modulates actually the frequency
[28:50.520] while maintaining the grand pitch of our key.
[28:57.840] So before we start to do this, I want to show you how you can tweak this patch here because
[29:03.280] we use now here these parameters.
[29:05.480] And when you switch on here this project and you play something on the keyboard, you actually
[29:12.680] hear nothing besides the small click because you can't change these parameters.
[29:17.800] So you can do this by just using here this general or this parent object as an VST plug-in
[29:27.800] and just input these parameters here.
[29:30.920] And you can do this by using this object here, Attribute UI, and you get basically a pull
[29:39.440] down here and the number box.
[29:42.480] And we can just put this over here and connect this with the input of the rainbow patcher.
[29:49.080] And now this pull down is filled with all the parameters we can change.
[29:55.240] So for instance here, we have the sustain, right?
[29:57.640] This is our sustain knob, and we can change this from the outside.
[30:01.240] So now at least we can hear something and also duplicate this here with Ctrl and D.
[30:11.320] Create this also with the input.
[30:13.440] And now we can change here the release, maybe a bit more.
[30:25.520] So we can tweak it a bit better and see if everything is right or we actually compile
[30:33.520] the VST.
[30:35.480] So in here, we don't need this because we change the volume of the sine oscillator
[30:42.360] with the 80s.
[30:43.360] Anyway, this is just here from the beginning, so we can just hit Delete on that.
[30:48.360] And we need, oh, also this here, this is not needed really, you can delete this.
[30:54.080] You can also see here in the top, we have an error message number, UI objects, which
[30:59.200] are these, these number boxes here are not supported in polyphonic patcher.
[31:05.800] So we can't use them anyway.
[31:08.860] So let's delete that, connect these two here, and we are good to go.
[31:13.360] So here we have the 80sR, maybe we put this a bit to the side, put it here, maybe put
[31:19.640] this over there, and make us a bit more room for the new patch.
[31:28.600] So now we need a second oscillator.
[31:30.880] That's for sure.
[31:31.880] This is our modulator, oscillator that modulates basically this first one.
[31:38.440] So the sine oscillator itself not only accepts here an signal, it also accepts audio signals.
[31:48.240] So we can convert this number signal into an audio signal by using a signal tilde object.
[31:58.160] And just took this here in between the shift.
[32:01.040] You can see now we have here audio signals, right?
[32:03.800] So now that we have this audio signal, and it works exactly like before, I think.
[32:09.160] Yeah, it's the same as before.
[32:12.560] So now we can mix this here with the audio output of this sine oscillator by using an
[32:20.040] plus operation tilde, because it's audio signals, look this in between.
[32:27.480] And then we connect this oscillator with this one, or with this path.
[32:32.480] So now we are getting here the frequency of our MIDI keyboard, and we mix this with the
[32:37.400] second oscillator.
[32:39.080] So we keep basically the main fundamental frequency, but we want to add frequency modulation
[32:47.920] from a second oscillator, and we want to keep the tonality and the ratios and so on.
[32:55.440] So this one here also gets, of course, the frequency from here.
[33:03.280] So we get this number, which is because we want to have, we want to change the frequency
[33:11.720] of both oscillators at the same time, we want to pitch it up or down.
[33:17.640] But this one here, we want to offset to have a different ratio, and then modulated the
[33:24.000] first oscillator.
[33:26.480] So we can change the ratio here by adding a plus operation, just without tilde.
[33:34.480] And we also hit shift here and hook this up in between.
[33:38.280] Yeah, something like this.
[33:44.120] And then we need the parameter here.
[33:46.880] And we call this parameter, it's called name, we call this ratio, something like this.
[33:58.200] Minimum is zero, and maximum is maybe 10,000 or something like this, and put this here.
[34:09.120] So we can offset the MIDI frequency.
[34:12.640] So we hit C3, and then we want to change the frequency up from C3 or down from C3.
[34:19.920] So we want to change the ratio.
[34:22.680] So we have this, and we maybe also use here a new interface element, so we can try it
[34:28.280] out, hook this up, and use here ratio.
[34:34.720] And then we want to change the amount, the modulation amount, right, how much we want
[34:39.400] to influence the original oscillator, make it do this here, of course, again, by such
[34:47.600] a multiplication operation, so we just duplicate this here, and connect this here.
[34:56.160] And we have a second parameter, and this one is called amount.
[35:04.200] And maybe the amount is also 10,000, maybe, let's use it like this.
[35:12.320] Okay, so here we have the ratio, duplicate this, we connect these two, and we can change
[35:19.560] this here to amount, here, and yeah, let's give it a go.
[35:32.160] So ratio amount.
[35:49.360] So it sounds like it works.
[35:51.160] We can modulate the first oscillator, and also the second oscillator is changing accordingly
[36:00.080] with the keyboard, and we can also apply some offset.
[36:03.800] So let's save this, save this here, and export it again.
[36:12.760] And of course, override.
[36:15.280] Okay, so the build is done.
[36:19.800] It's already in the VSC3 directory, and we can just, oh, maybe, always forget that.
[36:25.840] Disable this here, audio off, and we go back here to this, and load our synth tutorial
[36:32.840] plugin.
[36:35.840] Maybe we also use here model delay, so it sounds a bit better.
[36:42.160] Let's go for reverb, dial it back.
[36:47.520] A bit of release, sustain, delay, attack, maybe ratio, yeah, nice.
[37:16.920] And because this is a bit big, we can, of course, attach here some expression modulators.
[37:23.000] We can use the expression and change the amount with the velocity, so the amount of the FM
[37:28.440] modulation.
[37:53.720] So it's a pure raw FM synth, VSC3 synth, and you can, of course, imagine that you can implement
[38:13.680] a lot of different additional things like the way you want it.
[38:19.000] But I want to show you how easy it is, actually, to start from scratch in Rainbow, to create
[38:25.520] a synthesizer in Rainbow, and also export it as a VSC3, and tweak it to your likings.
[38:32.400] So yeah, I think that's it for the first tutorial.
[38:36.000] Leave me a like if you liked the video, and keep hitting me with the questions in the comments,
[38:41.320] and maybe give me some feedback if you want to see more tutorials about Rainbow or Plug
[38:45.960] Data.
[38:47.720] And yeah, more soon.
[38:49.560] Thanks for watching, and see you in the next video, guys.
[38:51.880] Bye.