Summary

• Moselle is a software synthesizer for making music
• connect a MIDI keyboard to your computer, design sounds, and play them
• Moselle uses the modular synthesizer paradigm of connecting modules any way you want
• unlike hardware modular synthesizers, Moselle is polyphonic and lets you load and save patches
• program it not with graphics but with a simple programming language
• the fully-functional, stand-alone "alpha" version can be downloaded for free

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.

the Dashboard window shows you performance information and messages about the status of your patch, MIDI, the sound output etc.	the Patch 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
the Wavetable Editor window lets you design a set of waveforms, that your application can morph between... can be used for Wavetable Synthesis, Wave Sequencing, Multisampling, and Vector Synthesis	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)

MoselleVST will be announced hopefully in the next year, 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?

• to get a taste of a totally new style of synthesizer
• to see your feedback influence the final version
• despite the caveats, it should work fine and you can record or perform with it today
• and it's free, so why not?

Here's a summary of the current temporary limitations:

• there is NO DAW Support yet, though this will be available hopefully in the next year as a commercial product
• performance hasn't been optimized yet; you are limited to playing fewer simultaneous notes (less polyphony) than the final version will support
• currently Windows-Only though production versions for Mac are planned
• some features will change; patches you write with this version may not work with future releases without some changes

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. 280+ "tutorial" patches walk you through all features of Moselle
5. then start modifying the 500+ demo and general-purpose patches, or write your own from scratch

The Factory Patches

• over 280 "tutorial" patches serve as a textbook and reference manual, showing you—and letting you hear—every feature of Moselle
• dozens of "demo" patches highlight Moselle's unusual capabilities
• 500 general purpose patches are also included, ranging from string pads and electric pianos to the tackiest special effects
• but Moselle's not really about factory patches, it's about patches you write

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.)

• Geometric Oscillator. The usual Sawtooth, Triangle, Square, Sine waves. Also can morph (not just fade!) between seven pairs of waveforms (see diagram). SawPulse and Sine have pulse width in addition to the usual Square Wave. Full sync-in/out. Capable of FM. Calculates phase with floating point accuracy for massively reduced aliasing.



• Stored Waveform Oscillator. Bandwidth-limited for very clean sound. Can be programmed individually harmonic by harmonic and note by note, either from scratch, or by tweaking a basic Sawtooth, Triangle or Square wave. Does Sawtooth to Triangle morphs. Square wave has pulse width. Full sync-in/out. Capable of FM. Aliasing-free.
• Swarm. Generates thousands of detuned waves.
• Wavetable Oscillator. Supports Wavetable Synthesis like PPG and Ensoniq keyboards are famous for. Also allows Wave Sequencing, Grooves, Multisampling, and Vector Synthesis. Aliasing-free.
• Adder. Specialized for additive synthesis.
• FMAlgo. Specialized for FM synthesis. No limit to number of operators, operators with feedback, and design any algorithm you want.
• LFO and LFSWO. Similar features to the Geometric Oscillator and SWO, for low-frequency modulation.
• Filters, filters, filters: Butterworth, simulations of Moog, etc. support cutoff, resonance, variable pole count, and in some types, variable drive and/or self-oscillation. Low-pass, high-pass, band-pass and band-reject.
• Multi-filter: a box to be filled with any of dozens of filter types, to build graphic EQ, parametric EQ, simple tone controls, and phasers. Tutorial patches show you how.
• ADSR Envelope. Has additional wait, impact, break and slope parameters for WAIDBPSR if you want them, but can make sense of any subset too. (e.g.: for a vibrato that fades in, use an envelope with just wait and attack segments.) Outputs for linear, exponential, audio, and custom curves.
• Systematic Envelope. Supports an arbitrary number of level/time pairs with customizable curves. Each point has wait, start, goto conditions. Works fine in audio-domain as an oscillator, and can be used as an LFO or sequencer.
• Noise. White and pink.
• Delay Line. Supports multiple time-variable taps. Can be used for delay, echo, reverb, reverse reverb, chorusing, flanging, etc.
• Tuning tables. Supports Equal Temperament, Just Intonation, any historical tuning or experimental tuning, quarter-tones, backwards keyboards. Have multiple per patch if you want (for instance to modulate between keys while using just intonation).
• Maps. These can be used at audio frequencies for waveshaping of oscillators and LFOs. Also can be used for modifying response curve of MIDI controls, etc.
• Sample-and-Hold. Works fine for modulation signals (such as 80's burbling filters). Can also be used at audio frequencies. Besides the hold output itself, it also outputs its internal phase and a signal that it's just re-sampled the input.
• Portamento. Wired in place by default, just turn it on.
• Slew. Like Portamento but for anything else, from smoothing modulation signals to audio frequency.

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:

• Global. This holds master tuning, sampling frequency and so on.
• Patch. This sets overall controls for the patch, such as number of voices.
• Channel. This provides access to pitch wheel, channel pressure, and every other MIDI controller.
• Note. This provides all the data for the given note: which note played, velocity, release and release velocity, and so on.
• Pitch. This conveniently packages coordination of tuning tables and portamento; pitch bend; vibrato; octave, transpose, detune; unison detune.
• Voice. The ultimate destination for your output waveforms.
• Oscilloscope. This takes input variables describing what signals to graph and when to start collecting data and when to graph it. Can show you Real-Time Spectrum Analysis of your patch as you play.

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.

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.

• Reverb, built out of the Delay module plus several Filters
• ReverseReverb, again containing a Delay and Filters
• LeslieSimulator simulator, with separately-rotating high and low frequency speakers with separate fast and slow rotation speeds and configurable rise/fall times; internally it contains Delays, Filters, LFOs, Slews, etc.
• Tube Distortion simulator, that just contains complicated math, no actual modules
• Casio CZ Oscillator simulator, emulating the way Casio brilliantly recreated the sounds of sawtooths, square waves, filter cutoff, and resonance using phase distortion of sine waves; internally uses several oscillators and a solid wall of math
• Roland Supersaw simulator, closely mirroring Roland's detune and level parameters; unlike Roland this package also supports super-triangle, super-square, and morphs between all three waveforms as well as supporting PW and PWM
• Alternate Tunings such as Just Intonation

Sub-Patches

• make a new patch that is just an old patch but with different effects
• ... or different portamento or tuning
• ... or change its internal settings
• ... or access its internal signal variables for further processing
• ... or spoof its MIDI inputs (so it thinks a foot pedal is pitch bend; transpose keys; etc.)
• ... or combine multiple patches into layers or splits or velocity-fades etc.
• ... or more complicated combinations like time-fades, ring modulation
• ... or all the above at once

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.

• "Alpha" Release: reverb, samples

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

• "Alpha" Release: further performance improvements
• "Alpha" Release: handle sound inputs, allowing Moselle to act as an effect processor. This release will also have Pitch Detection, Envelope Follower, and the like.
• "Beta" Release: integrate into DAWs
• Production Release
• Mac Version
• DSP Hardware: This would have polyphony of 100s of complicated voices, and lower latency that computers are capable of. (If there is sufficient interest...)

Why Moselle?

Moselle's goals are to:

• give as much power to create patches as any other synthesizer
• while also making it the easiest of the full-power synthesizers for writing, studying, and modifying patches of medium and higher complexity.

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

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.

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.