Summary


The Integrated Development Environment (IDE)

MoselleIDE is a stand-alone program; nothing else to install or configure (other than hooking up a MIDI keyboard).

The fully-functional IDE is free to download.

Dashboard Window Editor Window Browser Window
the Dashboard window shows you performance information and messages about the status of your patch, MIDI, the sound output etc. the Editor lets you view and modify patches and write them from scratch; supports syntax- and error-highlighting the Patch Browser lets you browse quickly through the 600+ factory patches, and the patches you'll write yourself
  Oscilloscope Window Spectrum Window  
  the Oscilloscope window can show single waveforms or entire notes, with up to eight simultaneous traces the Spectrum Analyzer shows you the harmonic spectrum with a DFT (Discrete Fourier Transform)  

Moselle for Digital Audio Workstations (DAWs)

MoselleAU and MoselleVST will be announced in 2017, to allow you to easily use the power of Moselle in your DAW.


Currently "Alpha" Release

Moselle isn't quite finished yet, so why would anyone try it now?

Here's a summary of the current temporary limitations:


How to Start Using It

  1. download a file, un-zip it, and run it
  2. hook up a MIDI keyboard to the computer with a MIDI-to-USB cable
  3. play the keyboard, and sound comes out the speakers
  4. 260+ "tutorial" patches walk you through all features of Moselle
  5. then start modifying the 700+ demo and general-purpose patches, or write your own from scratch

The Factory Patches


How Can You Patch a Synthesizer with a Computer Language?

To create a module, write the module name in square brackets. To set an input, simply write the name of the input, equals sign, and what you're setting it to. Let's create an Oscillator whose waveform is a sawtooth:


[Oscillator]

Waveform = Sawtooth

Any knob on physical synthesizer is probably an input variable in Moselle, as seen above with Waveform.

If you don't specifically say what a given input variable is set to, you get a standard default value. For instance if you don't mention Waveform, you get a sawtooth by default.

Any input jack on a modular synth is also an input variable. For instance, Moselle's Oscillator has an input called Frequency. A modular synth would have an input jack to control this, in addition to, probably, a built-in knob.

Any output jack on a modular synth is an output variable in Moselle. The output variables can be referred to when setting an input of another module. Let's create a filter, and set its input (called Input) to the oscillator's output (which is called Output):


[Filter]

Input = Oscillator:Output

That equation, Input = Oscillator:Output, is exactly like a patch cord from the oscillator's output to the filter's input.

What if we want two oscillators? Moselle lets us name modules however we want. We can call oscillators A and B, Carrier and Modulator, anything we want. Let's call them Oscillator1 and Oscillator2. Let's set the second oscillator's frequency to be the same as the first, plus two cents. (Cent is a musical term for 1/100 of a semitone.) Then let's send both their outputs into the filter.


[Oscillator1]

Waveform  = Sawtooth

[Oscillator2]

Waveform  = Sawtooth
Frequency = Oscillator1:Frequency + 2 cents

[Filter]

Input     = Oscillator1:Output + Oscillator2:Output

Now what if we wanted oscillator 2 to be inaudible at low velocity, but full volume at high velocity? Each Voice played has a Velocity that, mathematically, goes from 0 to 1 (not the 1 to 127 seen in MIDI). The simplest and most obvious way to accomplish our goal would be to simply multiply the oscillator's output with the velocity.


[Filter]

Input = Oscillator1:Output + Oscillator2:Output * Voice:Velocity

The above examples may not look too complex, but that is about the complexity it'd take to duplicate most physical synthesizers. You could write a lot of innovative patches without writing any more complicated formulas than that.

However, Moselle can easily handle much more complicated formulas if you need them. The following formula is just a part of the emulation of the Casio CZ Synthesizer, which Moselle ships with.


Output = IF( AND( Interface:Double, OscDoubler:PhaseOut >= .5 ),
           Select( Waveform2,
             OscCarrier:Control,
             IF( OscTimer:PhaseOut < .5, -1, OscCarrier:Control),
             IF( OscTimer:PhaseOut < Cutoff2 / 2, -1,
                 OscTimer:PhaseOut < .5, OscCarrier:Control,
                 OscTimer:PhaseOut < Cutoff2 / 2 + .5, 1, OscCarrier:Control ),
             IF( OscTimer:PhaseOut < Cutoff2, -1, OscCarrier:Control ),
             OscCarrier:Control,
             ( OscCarrier:Control + 1 ) * OscAM:Positive                                   + (Resonance2+Cutoff2[0,-42]) dB - 1,
             ( OscCarrier:Control + 1 ) * OscAM:Control                                    + (Resonance2+Cutoff2[0,-42]) dB - 1,
             ( OscCarrier:Control + 1 ) * IF( OscAM:Positive > .5, 1, OscAM:Positive * 2 ) + (Resonance2+Cutoff2[0,-42]) dB - 1
           ),
           Select( Waveform1,
             OscCarrier:Control,
             IF( OscTimer:PhaseOut < .5, -1, OscCarrier:Control),
             IF( OscTimer:PhaseOut < Cutoff1 / 2, -1,
                 OscTimer:PhaseOut < .5, OscCarrier:Control,
                 OscTimer:PhaseOut < Cutoff1 / 2 + .5, 1, OscCarrier:Control ),
             IF( OscTimer:PhaseOut < Cutoff1, -1, OscCarrier:Control ),
             OscCarrier:Control,
             ( OscCarrier:Control + 1 ) * OscAM:Positive                                   + (Resonance1+Cutoff1[0,-42]) dB - 1,
             ( OscCarrier:Control + 1 ) * OscAM:Control                                    + (Resonance1+Cutoff1[0,-42]) dB - 1,
             ( OscCarrier:Control + 1 ) * IF( OscAM:Positive > .5, 1, OscAM:Positive * 2 ) + (Resonance1+Cutoff1[0,-42]) dB - 1
           )
         )


Standard Modules

Moselle currently has about 30 built-in module types, as listed below. More module types will be added in the future. (Moselle also lets you build new module types, called Packages, out of existing modules and math. These are covered later, not here.)

In addition to the above modules that create and process audio and control signals, there is a second family of modules that convey information and other settings between the software, the user, and the patch:

illustration of the traditional-style envelope illustration of the Delay module
The Envelope lets you only specify the parameters you need. For an LFO fade in, for instance, you might only need Wait and Attack. For standard synthesizer patches' volume, you'll use Attack Decay Sustain Release. But you can use all eight of these "standard" parameters if you need. If that is still not enough, switch to the "Systematic" notation, which has no limit to the number of segments. The Delay module lets you do everything from echoes to reverb, reverse reverb, chorusing and flanging. It's multi-tap, so you can do a quadruple chorus with an echo, all with just one Delay, if you want. If you want more Delays, though, help yourself. There is no fixed maximum number of Delays, or any other module type, available.

Module Comparison

Some other software modular synthesizers seem to have huge numbers of modules. Just as one example, the Nord Modular G2 claims 160 module types. Moselle currently has less than two dozen. The raw count doesn't tell you much about power, though.

Group Nord G2 Moselle Comparison
Oscillator17 kinds6 kindsOf the G2's 17, only 2 do a job that can't currently be done by Moselle's five main Oscillator types, the Noise module, or the Delay module.
Envelope9 kinds1 kindMoselle's envelope can do far more.
Shaper7 kindsnot neededMoselle's math lets you do any of these without needing a module at all. (Moselle's Map module could also be used in some cases.)
LFO4 kinds2 kindsMoselle's LFO does everything the G2's four do. Then the LFSWO does yet more.
Mixer16 kindsnot neededMoselle can duplicate any Nord "mixer" module with a short math formula. (However, Moselle's math can also do infinitely more than the Nord's "mixers.")
Switch18 kinds1 kindMoselle's Hold module does what two of the G2's "switches" do. The other 16 "switches" can be duplicated in Moselle with a trivial math formula. (However, Moselle's math can also do infinitely more than the Nord's "switches.")
Level13 kindsnot neededThree of the G2's modules are used for processing external signals, and Moselle will have similar modules once it too has signal processing. The remaining 10 kinds of "level" modules can be duplicated precisely by simple math in Moselle.

Or to take another example: the Sonic Core Scope Modular IV claims "around 300 module (types)." Among those are "7 CZ oscillators in the style of the well known CZ synthesizer series." Moselle can accurately emulate a CZ too, but doesn't need dedicated modules to do it. Instead, the basic modules, combined with a bit of math, are powerful enough to emulate the CZ by themselves. It is not actually to Modular IV's credit that it needs additional built-in module types for this.

Also, please note that many of Moselle's modules can act like other types of modules. For instance, you can use Noise plus Delay to make a different kind of oscillator. Or a self-resonating Filter. Or set an Envelope to loop at audio frequency. You can build a complex waveform harmonic by harmonic with the Stored-Waveform Oscillator, but then use it as an LFO, and so on. So the smaller number of modules needn't be limiting.

Moselle also lets us build "packages." In effect, a package is a module you create yourself. You build the internals of the package from existing modules (and other packages) with perhaps a bit of math. Then, it is all boxed up and can be used from any patch as if it were a new module type. Moselle ships with a dozen or so "factory" packages that we've written as examples for you. One actually happens to be a CZ Emulation that is capable of everything the original hardware could do, everything the Modular IV's modules can do, plus more besides. (Since we're not trying to inflate Moselle's module count, we're not going to count packages as modules, much less break one package into seven just to get our count up.)

Finally, remember that Moselle is still at the "alpha" stage. By the time it's considered "Production Quality" it will have substantially more built-in module types.


Packages

You can combine multiple modules into a reusable package. The package can then be used from patches exactly like the built-in modules.

More example packages are planned for the production release, but the current "alpha" release has the following packages. As with patches, though, the point with Moselle isn't the factory packages it ships with, but your ability to write your own.


Sub-Patches

Complicated example: We can make a "horn section" patch out of three different brass patches, that automatically play a 3-part smart harmony, with half the keyboard harmonizing in Cmaj/Amin, and half in Fmaj/Dmin.

When we wrote the original sax, trumpet, and trombone patches, we may not have pictured ever using them like this, but it doesn't matter. There's nothing special the base patches need to do to be usable in this way.


Future Directions

This list roughly corresponds to the planned "alpha" releases going forward. Along with these main topics, every release should include a few more module types and of course bug fixes.

After the above projects are done, any patch you write with Moselle should continue to work for the foreseeable future.


Why Moselle?

Moselle's goals are to:

When we measure power, we're talking specifically about building sound patches, not doing things like running light shows or doing algorithmic composing. While some competitors do some things that Moselle doesn't try to, this is actually purposeful. Moselle isn't built to be a jack of all trades, it's built to be a master of one: making patches.

When we talk about ease of use, we mean:

  1. learning how to write patches, learning all the module types, and so on
  2. actually writing patches, both simple and complex
  3. studying other people's patches to understand and learn from them
  4. reviewing your own older patches, recalling how they worked
  5. (differences specifically with hardware modular synthesizers) recording polyphonic parts, changing between patches, moving the synthesizer, and even finding room for it in the studio

Graph Comparing Power vs. Ease-of-Use

Synth Keyboards can't be beat for simplicity. Bring it in and turn it on. Hook up an amp and play. They are also the least-powerful synthesizers. A Jupiter-8 has about 40 parameters to control. A V-Synth GT maybe 200. But even the V-Synth GT is almost totally hardwired. You can't add one more oscillator no matter how much you need it. You can't define an envelope with one extra segment. You can't make pitch bend depend on note, or run an LFO through a filter.

Typical Software Synths are either copies of hardware, or meant to look and act as if they are. Despite the massive creativity of the musician, and the massive power of the computer, you're limited to the tiny range of parameters they thought to give you control over. They fail at the same kinds of features listed above that the modern keyboards can't do.

Hardware Modular Synths look like the ultimate in power, but they're not even half-way there. In theory, you can do anything you want. Need 50 oscillators? You could get them! In practice, you cannot afford 50 oscillators. You don't have room for them. By the time you've got the last in tune the first is out of tune. They also fall down for being (as a rule) monophonic, being impossible to move, and impossible to quickly change patches on.

Software Modular Synths such as Reaktor remedy the portability and program-change problems. Some may be polyphonic, and they may support endless numbers of modules if you need them. Sounds good! The drawback is that they give you a photo-realistic picture of a modular synthesizer (or some type of diagram representing the same), and the number of cables becomes impossible to follow as the sound design grows more complex. This makes debugging patches, studying them, later tweaking them, and so on, quite problematic.

Example of Illegibility of Graphic Programming
Pure Data or Max/MSP Programming. What does this do? Is it even a sound patch? (Yes it is, apparently.) Graphic programming often makes simple jobs even easier... but makes medium jobs quite difficult and hard jobs impossible. This was probably hard to write, needed a lot of editing just to be a clear as it is, and yet is also hard to read.

Pure Data (and an earlier, commercial system by the same author, Max/MSP), probably has similar recording and performance power accessible to the pop musician as CSound and Moselle. Like Moselle, and unlike CSound, it was designed to be easy to use. However... it failed at that goal. It has a fairly cryptic graphical programming paradigm which doesn't have much in common with the way musicians talk about synthesizers. The graphics explode like a nest of spiders once you have to do the equivalent of a simple mathematical formula of a dozen terms (such as a pitch calculation taking into account MIDI note played, tuning table, portamento, pitch bend and bend amount, pitch envelopes, vibrato, octave selection, detuning, special detuning for stacked voices, and the like. That's two lines in Moselle and a screenful in Pure Data.

CSound is an old-timer music framework started in the 80s at MIT. We should consider the power to be ultimate, as it's not really finished yet. If you're a software engineer, you can keep adding more features. But for a pop musician, even a very technical one, that power is out of reach. It looks like it was designed to be easy for the computer, and easy for the people writing it. It doesn't seem like it is supposed to be easy to use for the people writing patches or performing with it. To its credit, it's 100% backwards-compatible: any patch you wrote in the 1980s will still work. However, that also means that a variety of bad decisions about usability made in the 1980s have never been corrected.