Moog Labyrinth Semi-Modular Synthesizer Overview

So What IS a Parallel Generative Analog Synthesizer, Anyway?

Ryan Gaston · 07/11/24

Moog is back with what may be their strangest instrument to date: Labyrinth, another entry in their popular line of desktop semi-modular synthesizers. Described by Moog as a "parallel generative analog synthesizer," Labyrinth leverages so-called "West Coast" sound manipulation techniques and highly random, probabilistic sequencing to create sounds and sequences that take you by surprise—gradually evolving and reorganizing themselves over time.

Of course, Labyrinth isn't exactly a new development—it was leaked by several retailers earlier this year, but quickly pulled down...leading to more-or-less constant speculation since about when it would be ready. In a surprise announcement last week, Moog provided the public with the release date: and today, we're happy to say that Labyrinth is available for orders.

All of the Moog instruments in this desktop semi-modular format prior to Spectravox were effectively "self-contained" or "self-sufficient" devices. Each offered its own unique proposition about music-making: they each contain a unique synthesis structure and sequencing structure tailor made for one another. So, each of these instruments can be used fully standalone, without the need for any other external sound generation or sequencing/controllers. The recent Spectravox is the exception: it is primarily an audio processor, which benefits significantly from external audio and control sources. Labyrinth in some senses represents a return to form: it works perfectly fine all by itself, and we suspect that it will prove to be a compelling way for curious musicians to start their explorations with modular synthesis altogether.

In other ways, though, Labyrinth does still represent a conceptual departure from the approaches taken in prior instruments. Rather than relying on Moog's bread and butter synthesis techniques, it instead leverages techniques from what some call "West Coast" synthesis—taking broad inspiration from instruments developed by Donald Buchla, such as the cult classic Music Easel. Of course, it has plenty more tricks up its sleeve as well—so let's dive in and discuss Labyrinth's audio and control structures in detail.

Moog Labyrinth Audio Structure

Labyrinth features a complex and knotted sound generation structure quite unlike that found in most Moog instruments. Let's walk through it step-by-step.

Sound in Labyrinth typically originates from its two oscillators and noise source. The primary oscillator produces only sine waves; the second oscillator produces only triangle waves. The noise source offers a continuously variable color control. This collection of sound-generation might seem odd to most Moog enthusiasts...where are the saw waves and pulse waves? Well, you're not going to find them here: Labyrinth isn't that kind of synthesizer. Instead, you'll need to turn to different tricks in order to generate sounds with harmonic complexity...luckily, Labyrinth has many such tricks.

The first notable tricks hinge around inter-oscillator modulation. Though both oscillators can be used to generate sound, it in many situations is more gratifying to thing of the top oscillator as your primary sound sources, and to think of the second oscillator as a tool for modulating the first. Between the two oscillators on the panel, you'll find a control for FM depth from the modulation oscillator to the primary oscillator: this enables thru-zero frequency modulation, adding timbral complexity while minimizing the detuning effects that plague typical analog exponential FM or more conventional linear FM. Don't worry—with the right frequency ratios and modulation depths, the FM can still be wrenched into truly clangorous, inharmonic territory...but it also allows for much more stable, predictable results than with more "old school" analog FM techniques. One should also note that the mixer contains a dedicated level control for Ring Modulation; this is the ring modulated product of both oscillators, allowing a different style of timbre to emerge. Of course, since the modulation oscillator can go down into fairly low frequency ranges, these types of modulation can also be tamed for use as vibrato (FM) and tremolo (ring mod), allowing for subtle and expressive alterations to the main sound source.

The modulation oscillator also features a sync input on the patch bay, adding quite significantly to Labyrinth's sonic palette.

In Labyrinth, sonic interest can also emerge from unlikely places. The mixer, for instance, passes each input signal at unity gain at 12:00—turning the level knobs clockwise from this position starts to introduce saturation/distortion, which can turn even the delicate sine and triangle waves into wooly, round tones. The mixer adds a ton of color and character, and is well worth careful attention.

From there, things get more interesting. After the mixer, the signal path bifurcates and passes along to two analog signal processing tools, both new for Moog: a voltage-controllable wavefolder and a state-variable filter. These processors may be used in parallel or in series, with either the wavefolder or filter first in the signal chain. Each of these passes into a dedicated VCA, and the two sources may be continually blended between using the Blend control and CV input, regardless which processing order you've selected.

The wavefolder is a powerful tool for adding harmonics to incoming sounds. By forcing the top and bottom edges of waveforms to "fold over" on themselves, it creates complex audio spectra previously unheard in Moog instruments. The wavefolding depth is voltage-controllable, and additionally, the Bias control allows you to add a voltage offset to the signal prior to the folding stage, great for creating asymmetrical waveforms. While the Fold parameter is voltage-controllable (and can be modulated via the first envelope and the sequencer without the need for patching), the Bias parameter features no apparent modulation inputs. However, similar effects can be created by, for instance, setting the modulation oscillator to a low frequency and turning its level up (along with the main oscillator) in the mixer section...yielding somewhat PWM-like wavefolding effects. The wavefolder also features a dedicated audio input on the patch bay, allowing you to wavefold whatever signals you like—internal or external.

The filter is also a new design for Moog; rather than their typical 24dB/oct ladder filter, it instead features a 12dB/oct state variable filter, giving you access to a continuous blend between lowpass and bandpass filter responses. You get hardwired CV control of the filter cutoff from the first envelope generator and from the sequencer; of course, the filter offers a dedicated modulation input on the patch bay as well, as well as a direct audio input for filtering external signals or other signals from within Labyrinth.

The patch bay, of course, offers ample opportunity for reconfiguring the behavior of this basic audio path. And, we suspect that you'll find the patch bay in many ways more open-ended than in any prior Moog desktop semi-modular instrument: it offers plenty of patch points for everything from convenient signal utilities to the exploration of all-out sonic mayhem.

Corrupt: Sequencing in Labyrinth

The novel sound structure is only part of what makes Labyrinth tick. Its onboard sequencers are the key to many of its generative possibilities: taking it outside the realm of purely predictable, programmable sequences and into turf that rewards careful listening and an embrace of uncertainty.

Labyrinth contains two probabilistic sequencers, each of which offers an eight-LED display on the front panel—showing you which steps are active, as well as displaying the current step. The sequencers are each connected to the same clock source by default, however they do feature independent advance trigger inputs on the patch bay. Likewise, they have a number of normalled connections on the panel (to the oscillators, wavefolder, and filter) as well as direct CV outputs on the patch bay, great for experimenting with novel control structures.

You might be wondering...how the heck do you program these sequencers? Excellent question.

The small buttons to the left of the sequencing section are the most reliable means of programming the sequencers. You simply advance the "write head" using the "advance button"—which moves sequentially through each of the stages—and then use the "bit flip" button to flip the status of each step on or off, as desired. When you do this, a random CV value is assigned to each active step. The CV outputs are updated and gates are produced only on active stages. So, you can't program specific voltage sequences—but you can program specific gate sequences. The CV values are simply left up to chance. Happily, there are sixteen quantization options, so if you're aiming to keep things melodic, it's quite straightforward. The Bit Flip inputs on the panel can be used to define sequences, as well, mimicking the action of the Bit Flip buttons.

Of course, there's also the colorfully-named Corrupt parameter for each sequence. Corrupt is a multi-functional parameter that impacts each sequence individually. When Corrupt is fully counterclockwise, the sequence in question will repeat exactly each time through. As you turn Corrupt up toward noon, however, you introduce increasing likelihood that the CV value associated with any given step will update randomly once it is reached. In this way, it's possible to create sequences with stable rhythms, where notes occasionally change from repetition to repetition. As you turn the knob beyond 12:00, you begin to introduce probability that any given stage will flip between on and off states—gradually changing the sequence's apparent rhythm. With Corrupt fully clockwise, each repetition will be entirely unpredictable, acting as a sort of random voltage/rhythm generator.

Of course, there's much more to the sequencer: the two sequences can be set to any number of stages eight or lower; the sequences can be chained; the playhead for each output can be offset from one another (especially useful when chaining sequences); a single "buffer" can be stored in volatile memory, allowing you to get back to a known state after Corrupting the living daylights out of your sequence. Moreover, Labyrinth also features MIDI input, allowing it to be used as a more conventional synthesizer when combined with external controllers.

Embracing Uncertainty

Labyrinth is a deep instrument—much deeper than we can possibly address here. It can be used as two synth voices; it can create percussive sounds; it can create beautiful, slowly-evolving sequences; and it can create all-out explosive blasts of chaotic noise (if you want!). Of all of Moog's semi-modular instruments, I dare say that it feels like the best marriage of flexibility and ease of use—despite its seemingly complex methods of sound production and sequencing, it's actually very easy to get up and running, and surprisingly simple to discover all sorts of unexpected sounds.

I personally appreciate that Labyrinth leaves many important details of its use up to chance—forcing the player to listen carefully, and to occasionally turn their attention to sonic details other than explicitly-defined rhythms and pitches. If an instrument provides a way to program precise rhythms and pitches, it becomes all too easy to fall into familiar musical habits. It's my feeling that this occasionally can lead musicians to miss out on some of an instrument's most exciting or unique potential. With Labyrinth, though, it's easy to get into the weeds by foregoing the typical decision-making processes associated with these parameters—ultimately leading to idiosyncratic means of approach sound and musical organization altogether.

If you're looking for a solid step into the world of modular synthesizers, or if you're looking for a unique, fun, and intuitive addition to an existing setup, Labyrinth is a solid contender. And of course, for all you Moog completists out there, it provides opportunities that no prior Moog instrument has, altogether—and ultimately, it pairs excellently with all of its semi-modular siblings.