Friends, today is an amazing gift for music lovers! On this page you will find the best virtual synthesizers online. You can play them either using a keyboard or a computer mouse.
Try at least a few of them, and you will certainly discover the talent of a composer in yourself. A pleasant pastime is also guaranteed! 
Attention! To display interactive elements in the article, you will need Adobe Flash Player installed on your system (browser).
Electronic organ
Do you want to play the organ online? This is exactly what you need. This instrument imitates the sound of an organ, which many people like so much.
Try playing this excerpt from Bach's Minuet (the keys in square brackets must be played simultaneously):
[rsfh] lq[wd]e[rf] ll [tg] ert*[fu] ll [ed] rewq[sw] ewql[#h] [fl]q[sw]l[hw] [.q]
To display key hints, click Notes - Computer Keyboard.
Well, how did it work out? If not, just copy these notes into the top window of the electronic organ and click “Play”.
Software synthesizer
And so, gentlemen, I finally decided to figure out the software synthesis of music, namely the practical part of implementing such a task. Let's see what came of it and how it was implemented...
Making waves
We all understand perfectly well that sound is a wave and that the oscillation frequency of the wave from zero level corresponds to the frequency of the sound wave, and the amplitude of this wave is responsible for its strength or, simply put, loudness, but in machine representation, sound recorded in the form of pulse code modulation is an array of data , each element of which represents the position of the wave at a specific point in time. Let's look at a simple sound wave in PCM format better, for this we first write a function that will be a model of a sine wave. It will take two values - offset and frequency. public static double Sine(int index, double frequency) { return Math.Sin(frequency * index); } Now let’s add it to the Program class and write the main function Main, which will initialize a data array of 75 elements long that will represent our sound and cyclically fill each of its cells using the sine wave model we just wrote. To calculate the value of the function for a specific displacement, we need to take into account the period of the sinusoid equal to 2 * Pi and multiply this period by the wave frequency we require. But in order to understand what resulting frequency the sound in PCM format will output, you need to know its sampling frequency. Sampling frequency is the frequency of sampling elements per unit of time, but to put it simply, this is the number of array elements per second, which means that the frequency of sound in PCM format is the frequency of the wave divided by its sampling frequency. Let's generate a sound wave with a frequency of 2 Hz and agree that the sampling frequency will be equal to 75 Hz. class Program { public static void Main(string[] args) { double[] data = new double[75]; // Initialize the array. for (int index = 1; index < 76; index++) { // Calculate data for the entire array. data[index-1] = Sine(index, Math.PI * 2 * 2.0 / 75); // Period divided by sampling rate. } Console.ReadKey(true); // Wait for any key to be pressed. } public static double Sine(int index, double frequency) { return Math.Sin(frequency * index); } } And now, to see the result of our work, let’s add a new function to the Program class that can visualize our function directly in the console (This will be the fastest), so we won’t go into its details. public static void Draw(double[] data) { Console.BufferHeight = 25; // Change the console buffer length to get rid of the slider. Console.CursorVisible = false; // disable the cursor for beauty. for (int y = 0; y < 19; y++) {// Write out the sound level indices. Console.SetCursorPosition(77, y + 5);// Set the cursor to the desired position. Console.Write(9 - y); // Write out the level index number. } for (int x = 0; x < 75; x++) { // Iterate through all elements of the array Console.SetCursorPosition(x, x % 3); //Set the cursor to the desired point. Console.Write(x + 1); // write element indexes. int point = (int)(data[x] * 9); // Calculate the level and bring it to an amplitude from -9 to 9. int step = (point > 0)? -eleven; // Find out in which direction 0. for (int y = point; y != step; y += step) {// iterate through the column Console.SetCursorPosition(x, point + 14 - y); //Set the cursor to the desired position. Console.Write("█"); // Draw a point. } } } Now we can see what our two hertz looks like in machine representation.
But this is only one type of wave, while there are many other types of waves, let's describe the functions that can simulate the main types of waves and look at what they look like.
private static double Saw(int index, double frequency) { return 2.0 * (index * frequency — Math.Floor(index * frequency )) -1.0;
} Result of the Saw function
private static double Triangle(int index, double frequency) { return 2.0 * Math.Abs (2.0 * (index * frequency - Math.Floor(index * frequency + 0.5))) - 1.0; }
Result of the Triangle function
private static double Flat(int index, double frequency) { if (Math.Sin(frequency * index ) > 0) return 1;
else return -1; } Result of the Flat function
Keep in mind that the period of the Sine and Flat functions is equal to 2 * Pi, and the period of the Saw and Triangle functions is equal to one.
Recording a Wav file
When we were able to create and even consider our sound, we would also like to hear it, so let’s record it in a .wav container and listen. True, we still don’t know how the Wave container works, we need to fix this annoying mistake! So the wave file is very simple, it consists of three parts, the first is the header block, the second is the format block, the third is the data block. All together it looks like this:
Actually, everything is very clear, the details for each of the points are described here. Since our task is extremely simple, we will always use a bit depth of 16 bits and only one track. The function that I will write now will save our PCM sound in a Wav container inside the stream, which will make the work more flexible. So this is what it looks like. public static void SaveWave(Stream stream, short[] data, int sampleRate) { BinaryWriter writer = new BinaryWriter(stream); short frameSize = (short)(16 / 8); // Number of bytes in the block (16 bits divided by 8). writer.Write(0x46464952); // Header "RIFF". writer.Write(36 + data.Length * frameSize); // File size from this point. writer.Write(0x45564157); // Header "WAVE". writer.Write(0x20746D66); // Header "frm". writer.Write(16); // Format block size. writer.Write((short)1); // Format 1 means PCM. writer.Write((short)1); // Number of tracks. writer.Write(sampleRate); // Sampling frequency. writer.Write(sampleRate * frameSize); // Byterate (Like bitrate only in bytes). writer.Write(frameSize); // Number of bytes in the block. writer.Write((short)16); // bit depth. writer.Write(0x61746164); // Header "DATA". writer.Write(data.Length * frameSize); // Data size in bytes. for (int index = 0; index < data.Length; index++) { // We start writing data from our array. foreach (byte element in BitConverter.GetBytes(data[index])) { // Break each element of our array into bytes. stream.WriteByte(element); // And write them to the stream. } } } You see how simple it is, and most importantly, now we can hear our sound, let's generate 1 second of the note A of the first octave, its frequency is 440 Hz, with this task the Main function will look like this public static void Main(string[] args) { int sampleRate = 8000; // our sampling rate. short[] data = new short[sampleRate]; // Initialize an array of 16-bit values. double frequency = Math.PI * 2 * 440.0 / sampleRate; // Calculate the required frequency. for (int index = 0; index < sampleRate; index++) { // Iterate through it. data[index] = (short)(Sine(index, frequency) * short.MaxValue); // We bring the level to an amplitude from 32767 to -32767. } Stream file = File.Create("test.wav"); // Create a new file and merge it with the stream. SaveWave(file, data, sampleRate); // Write our data to the stream. file.Close(); // Close the stream. } We launch the program and lo and behold! We now have test.wav, load it into the player, listen to the beeping until catharsis is achieved and move on. Let's look at our wave from all sides on an oscilloscope and spectrogram to make sure that we got exactly the result we were looking for.
But in life, sounds do not sound endlessly, but fade away. Let’s write a modifier that will dampen our sound over time. He will need absolute values, so we will give him the coefficient, current position, frequency, coefficient multiplier and sampling frequency, and he will calculate the absolute values himself, the coefficient must always be negative.
public static double Length(double compressor, double frequency, double position, double length, int sampleRate){ return Math.Exp(((compressor / sampleRate) * frequency * sampleRate * (position / sampleRate)) / (length / sampleRate)) ; } The line that calculates the sound level also needs to be changed. data[index] = (short)(Sine(index, frequency) * Length(-0.0015, frequency, index, 1.0, sampleRate) * short.MaxValue); Now on the oscilloscope we will see a completely different picture.
We write music
Since we managed to play the note la of the fourth octave, no one is stopping us from playing different notes. Have you ever wondered how to find out the frequencies of notes? It turns out there is a wonderful formula 440 * 2 ^ (absolute note index / 12). If you look at any piano-like instrument, you will remember that there are blocks of 7 white keys and 5 black ones, the blocks are octaves, the white keys are the basic notes (C, D, E, F, G, A, B) and the black ones their semitones, that is, only 12 sounds in an octave, this is called equal temperament. Let's look at the graph of this function.
But we will write the notes in scientific notation, so we will slightly change the formula by lowering it by 4 octaves and write it in our native form.
private static double GetNote(int key, int octave) { return 27.5 * Math.Pow(2, (key + octave * 12.0) / 12.0); } Now that we have assembled the basic functionality and debugged its operation, let's think about the architecture of the future synthesizer. The synthesizer will be a certain set of elements objects that will synthesize sound and overlay it on an empty data array in the right place, this array and elements objects will be contained in the track object. The classes that describe them will be contained in the Synthesizer namespace, let's describe the Element and Track class public class Element { int length; int start; double frequency; double compressor; public Element(double frequency, double compressor, double start, double length, int sampleRate) { this.frequency = Math.PI * 2 * frequency / sampleRate ; this.start = (int)(start * sampleRate); this.length = (int)(length * sampleRate); this.compressor = compressor/sampleRate; } public void Get(ref short[] data, int sampleRate) { double result; int position; for (int index = start; index < start + length * 2; index++) { position = index - start; result = 0.5 * Sine(position, frequency) ; result += 0.4 * Sine(position, frequency / 4); result += 0.2 * Sine(position, frequency / 2); result *= Length(compressor, frequency, position, length, sampleRate) * short.MaxValue * 0.25; result += data[index]; if (result > short.MaxValue) result = short.MaxValue; if (result < -short.MaxValue) result = -short.MaxValue; data[index] = (short)(result); } } private static double Length(double compressor, double frequency, double position, double length, int sampleRate){ return Math.Exp((compressor * frequency * sampleRate * (position / sampleRate)) / (length / sampleRate)); } private static double Sine(int index, double frequency) { return Math.Sin(frequency * index); } } public class Track { private int sampleRate; private List elements = new List(); private short[] data; private int length; private static double GetNote(int key, int octave) { return 27.5 * Math.Pow(2, (key + octave * 12.0) / 12.0); } public Track(int sampleRate) { this.sampleRate = sampleRate; } public void Add(double frequency, double compressor, double start, double length) { if (this.length < (start+ length * 2 + 1) * sampleRate) this.length = (int)(start + length * 2 +1 ) * sampleRate; elements.Add(new Element(frequency, compressor, start, length, sampleRate)); } public void Synthesize() { data = new short[length]; foreach (var element in elements) { element.Get(ref data, sampleRate); } } } Now we have come to the last function that will read a line with notes and generate our melody. To do this, we will create a Dictionary that will associate the names of notes with indices, and will also contain control keys/indices. The function itself will split the string into words and then process each word separately, dividing it into two parts - left and right, the right part always consists of one character (digit) which is written to the octave variable as a number, and the length of the first part is the length of the word - 1 (that is, the word minus the right side) further serves as the key to our dictionary which returns the index of the note, after we have parsed the word we will decide what to do, if the index is controlling then we will perform the function corresponding to the index, and if not then this means that we we have a note index and we will add to our track a new sound of the length and frequency of our note we need. public void Music (string melody, double temp = 60.0) { string[] words = melody.Split(' '); foreach (string word in words) { int note = notes[word.Substring(0, word.Length - 1)]; int octave = Convert.ToInt32(word.Substring(word.Length - 1, 1)); if (note > 2){ switch (note) { case 3: dtime = Math.Pow(0.5, octave + 1) * 8 * (60.0 / temp); break; case 4: length += (int)(Math.Pow(0.5, octave + 1) * 8 * (60.0 / temp)); position += Math.Pow(0.5, octave + 1) * 8 * (60.0 / temp); break; } } else { Add(GetNote(note, octave), -0.51, position, dtime); position += dtime; } } } From this point on, the melody can be written in the form L4 B6 S4 D7 B6 F#6 S4 B6 F#6 Where L is the command that specifies the length of the note, and S creates a pause, the remaining symbols are notes. Actually, this is where the writing of the software synthesizer is completed and we can check the result by listening to a segment of “Bach’s joke”
Binary File Source Code
Space music synthesizer
This synthesizer itself looks cosmic - a crystal cube, pressing the sides of which starts playing sounds. I won’t talk much about it - try it yourself and enjoy it
Finally, a couple more online synthesizers with the ability to play on the keyboard, which are somewhat similar to each other, but each of them has a number of its own unique features:
If you liked it, also play virtual guitars and online piano.
Virtual synthesizer – Tone2 – Gladiator 2 2.6 VSTi (x64)
Tone2 - Gladiator 2
is a powerful virtual synthesizer that deserves special attention from Tone2. This tool is perhaps the best among tools of this size. Synth Tone2 has a new type of synthesis that allows you to get a thick, wide sound. HCM, FM, and AM distortion available. There is a huge number of presets distributed by category, containing the entire range of synthesized instruments and effects. Its sound is very soft, warm and, most importantly, professional. Along with such monsters as Nexus, Atmosphere and other volumetric synthesizers, Tone2 Gladiator sounds just as juicy and serious. At the same time, in the new, latest version of the Gladiator 2 synthesizer, many visual settings are available that allow you to change the selected sound beyond recognition. Synthesis method - HCM. We recommend the version from everyone's favorite AiR. In conclusion, I would like to say that this synthesizer is the most popular on our website; this instrument is downloaded by you the largest number of times.
System requirements:
Processor:
Multicore processor in excess of 2GHz is recommended
Windows:
7/8/8.1/10
RAM:
2GB or more
DAW:
FL Studio / Cakewalk Sonar / Steinberg Cubase, etc.
Torrent Virtual synthesizer – Tone2 – Gladiator 2 2.6 VSTi (x64) in detail:
• Huge sound range: unique analogue warm transparent and fat sound. • Low CPU usage. • Semi-modular composition: flexible and expandable. • More than 1000 presets. • Full stereo and Dolby Prologic II decoding. • Up to 18 oscillators per voice. 4x stereo unison. • 110 different types of oscillators with 36865 waveforms. • 162x oversampling. • Psychoacoustic treatment. • 41 unique filters (analog, vocal, combination, Moog type, phaser, equalizer, etc.). • 20 different effects. • 7 types of distortion for warm analog sound. • Programmable arpeggiator, step LFO and trans gate. • Synchronization by tempo. • IQM for cleaner chords (intelligent microtuning).
Treatment procedure: 1. Hosts
1. Open the command line (as administrator). 2. Enter notepad C:\Windows\System32\drivers\etc\hosts and press Enter. 3. Add to the opened hosts file:
127.0.0.1 tone2.com 127.0.0.1 www.tone2.com 127.0.0.1 tone2.net 127.0.0.1 www.tone2.net 127.0.0.1 www.tone2.org
And save the changes.
2. Copy the Gladiator 2.6 x64 folder to C:\Program Files\VSTPlugins 3. Scan your DAW for new plugins.
Demo:
