As virtual synthesis has gained enormous popularity over the past decade, many of us have turned into soft-gear junkies. An exciting side effect of this

As virtual synthesis has gained enormous popularity over the past decade, many of us have turned into soft-gear junkies. An exciting side effect of this explosion is that loads of musicians and studio heads now create their own custom plug-ins and give them away for free on Websites and online user forums. Still, even with all that is available, it's cool, fun and not terribly difficult to design your own quirky instrument or signal processor from the ground up.

A more complex structure page and GUI screen have a stereo level meter and master volume control along the right-hand side. Next steps could be adding an LFO or full-blown modulation matrix, changing oscillator variety or adding levels for the oscillators, pan controls and filters.

There are dozens of programming platforms for constructing your own synthesis engines in modular form, including Applied Acoustics Systems Tassman, Dr. Barry Vercoe's open-source CSound, SynthEdit's shareware SynthEdit, CreativeSynth/Cycling '74 Max/MSP and Symbolic Sound Kyma. But perhaps the most commercially successful is Native Instruments Reaktor for Mac and Windows platforms, which I used for the construction environment for this article. Although some of the terminology and workflow herein is specific to Reaktor, the concepts generally apply to the other systems. Most of these applications are capable of producing not only conventional analog-style synthesizers, but also digital effects and signal processors, step-based sequencer modules and beatbox programmers, atmospheric noise-based rendering and harmonic sound generators, sample-playback and looping modules, physical modeling and Fast Fourier Transform (FFT) modules and more. This article focuses on traditional, virtual-analog synthesizer design. These basic construction concepts and ideologies should inspire you to create any kind of module you desire.


Most early analog-synth designs follow the same basic subtractive structure of one or more voltage controlled oscillators (VCOs) being fed through a voltage controlled filter (VCF) — which may be used to cut out some high-frequency harmonics — and then through to a voltage controlled amplifier (VCA). Usually, there are a couple of envelope generators (EGs) along the way — one each for determining the volume and filtering of every note played over time. These envelope generators were typically of the ADSR (attack, decay, sustain, release) variety. On top of that are several modulation- and performance-control functions such as LFO, vibrato, portamento/glide, pitch bend and mod wheel.

Reaktor 5 comes loaded with dozens of varieties of these components preassembled into what it calls primary macros. Primary macros can be thought of as basic building blocks that you use to construct instruments, effects processors, analysis utilities and more. If there isn't a primary macro that suits your needs, you can always tweak or construct one from scratch at the core macro level (see the section “Going Deep”).

Acting much like folders, macros typically contain many smaller components — called modules — in Reaktor. Think of those as the resistors, transistors and capacitors that made up analog circuit boards back in the day. Having all these nuts and bolts ensconced within macros is intended to make the construction of potentially complex structures easy and, most importantly, clearly laid out.


To begin building a synth, first select an oscillator component. Into the instrument's blank Structure window, insert a simple 3-wave oscillator by choosing the “Osc (pls, saw, tri)” macro from the Macro > Building Blocks >Oscillators menu. To define the oscillator's amplitude over time, connect a simple ADSR envelope (Macro > Building Blocks > Envelopes) to the amplitude control port of the oscillator. In order to contour the oscillator's frequencies, slap in a juicy resonant filter by selecting “4 Pole Filter (BP, BLP, LP)” from the building blocks macros and connect the oscillator's output port to the input port of the filter. Similar to the amp envelope above, you should add and connect another ADSR macro to control the filter to make it sound richer and more dynamic. Your new, albeit simple, synthesizer structure is now taking shape.

Before you can actually play it, however, you must connect an external MIDI input device (controller keyboard, etc.) to the synth structure. You accomplish that by using either two MIDI input modules (Built-In Modules > MIDI IN) to handle the MIDI note trigger and note pitch events of a played note or the combined Pitch + Gate macro. Select the pitch terminal of this macro and connect it to the P (pitch) inputs of the oscillator macro, both ADSR envelopes and the filter macro. Then select the gate terminal and connect it likewise to the G (gate) inputs of the ADSR envelopes. The structure window now should clearly show the chain of events that takes place.

You can audition everything at this point by connecting the filter output to the input of the default Audio Voice Combiner module, which serves to convert all polyphonically played voices into a monophonic signal that can be heard through the audio output port. Playing the MIDI keyboard, you should hear sound. Not exactly flattering yet, is it?

Since two oscillators are much nicer sounding than one, you need to duplicate the first oscillator. So that both oscillators can stream to the filter, first add a basic mixer (Built-In Modules > Signal Path > Amp/Mixer) to receive both oscillators and run its summed output to the Audio Voice Combiner. Guess what? You've just built your first 2-oscillator subtractive soft synth.


Take a look at Reaktor's instrument panel, where structures are represented in graphical user interface (GUI) fashion. A bunch of knobs are wrapped up within frames. Reaktor automatically generates those during construction, with each frame corresponding to one of the macros you inserted. The appearance may be congested and illogical at first, requiring you to reposition and rename your components for easier identification and control. Likewise, the default colors and controller icons may not be to your liking, functionally or visually.

Most applications let you to create custom GUIs for your instruments. In Reaktor 5, that is a somewhat-hybrid process. You can choose to work with the templates suggested by the program as you add components or customize their appearance by changing size, shape, name and location of GUI objects. You can also change the background, frame and border colors or import a background and control graphics. Reaktor imports 24-bit bitmap (.bmp) and 32-bit uncompressed Targa (.tga) images for transparencies and animated control objects.

Typically, when you start a GUI layout, you should either stay close to the general layout of the synth you're emulating or have a preconceived notion of how things should look and feel if it's an entirely novel instrument design. It's good practice to keep the panel layout organized and logical as you continue to build.


A monophonic, dual-oscillator synth may have been impressive four decades ago, but to rock today's mixes, a synth should be more ambitious. You should consider what new and more elaborate components could really make the synth shine.

As an example, I added one more oscillator, a suboscillator and a nifty noise generator. A second filter running in parallel also sounded like a good idea. While those are basic components, you can make even the most typical-sounding stock parts really stand out by hooking up everything in different ways. For instance, the dual filters originally were summed together for output using a simple signal-merge module. After adding the second filter, a powerful 8-pole notchable bandpass, it would sound much better if the two filters could be blended, so I inserted mutable trims after each filter. I implemented a master attack-release style VCA unit to further contour the results of the filter and amp envelopes. So, in addition to oscillator and filter-envelope control, I can hem the overall sound using a final stage of attack and release settings (which run successive to the ADSRs) for some very cool boxy-sounding techno effects.

Experiment with the suboscillator routing for some more fun. I created a subsection that was actually made up of two freely tunable and blendable suboscillators, but whose summed output could also be tuned in unison, much like a latch mode. The noise generator received a similar treatment with its own set of integrated filters — a highpass called Grate and a lowpass I called Scour. Together, they can clearly define noise color prior to the mixing stage along with the sub and three main oscillators.

At this point, with about 30 minutes invested, I had constructed a pretty powerful synth, but not so good that it couldn't benefit from some effects from the building-block macros folder. I slapped down a 3-band graphic EQ immediately after the master VCA, followed by a subtle distortion macro to give the sound a bit of dirt. Next, a fairly simple but lush-sounding chorus macro gives the synth a wide, Roland Juno 106 — style pseudo-stereo fatness.


Up to this point, I've used only prebuilt macros supplied with Reaktor. The custom shop opens for business when you start to explore the wild world of core macros and core modules.

In core mode, you work with low-level objects such as routing ports, controllers, Boolean logic and algebraic expressions to build one-of-a-kind components that open many new and infinitely creative doors. In the example synth, all three VCOs used the same stock 3-wave oscillator macro, which provides square/pulse, sawtooth and triangle in one tidy package. That may not be what you want. Analog oscillators, for instance, have a tendency to drift in and out of tune with one another at much finer detail than what your typical LFO is designed for. Also, true analog oscillators will rarely produce exactly the same wave shape consecutively; on an oscilloscope, each cycle will appear slightly different.

If you're brave or smart enough, you can construct macros from scratch to deal with issues such as those. To venture this far requires a good grounding in mathematical logic and a slightly nerdy approach. Unfortunately, it is beyond the scope of this article to explain in great detail.

You don't need to dig this deeply all the time to get great results. Adding one or two core modules to an existing macro is sometimes all that may be required. For instance, you need to add only a single sine-wave generator core module set at the fundamental frequency of an oscillator to effectively model the classic Yamaha CS-80 oscillator type. To simulate waveform variation, you can add simple wave-shaper core modules to roughen up overly pure wave shapes.

It is also at this core level of any modular sound-generator application where you'll end up fine-tuning the work ethics of your synthesizer. Many tiny details must be observed if your synth is to sound polished, such as correctly setting the ranges and response characteristics of sliders and controls, making sure that signal levels get limited properly along the gain structure to avoid clipping, weeding out modulation and MIDI sync problems, attacking aliasing problems and more. Getting those secondary factors right takes much skill and practice. For now, don't sweat the petty stuff. If building your own virtual synth sounds intriguing, grab a design application that best suits you, and just have fun learning. Mistakes often make the best music.


Here is a list of other popular synthesis-design/sound-generation/effects-development environments, ranging from simple to insanely complex. Some are commercial, others are free.

Bidule (Plogue) — Win XP/Mac OS X

CSound (Dr. Barry Vercoe) — Win XP

Kyma X (Symbolic Sound) — Mac OS X

Max/MSP (Cycling '74) — Win XP/Mac OS X

SonicBirth (Antoine Missout) — Mac OS X

SynthEdit (SynthEdit) — Win

Synthmaker (Outsim) — Win

Tassman 4 (Applied Acoustics Systems) — Win/Mac OS X

VOID Modular System (Psoft) — Win

VAZ Modular 3 (Software Technology) — Win