Sevish Music

You are browsing the Tutorials category

Microtonal equal temperaments on a Max/MSP synth using expr

The mtof object can take a MIDI note number and output the frequency of that note in standard 12-tone equal temperament tuning (aka 12-EDO). But what if you want to get away from this musical dogma? How about we start to explore say 13-EDO, 7-EDO, 24-EDO, or 41-EDO with Max/MSP?

Equal temperament on Wikipedia
Equal temperament on the Xenharmonic Wiki

Some years ago I wrote an expression that could quickly be dropped into any Max/MSP synth and then play microtonal equal temperaments. It’s a more generalised version of mtof and I want to share that with you today. It’s an mtof-killer!

mtof and expr

First let’s take a quick look inside the mtof object and see how it works. Really, mtof just performs one simple expression.

mtof-as-an-exprThe mtof object on the left always gives the exact same result as the expr on the right. Got it?

A replacement expr for microtonal equal temperaments

Here is my mtof-killer expression in all its beasthood:

An expression to replace mtof in microtonal settings

Nasty, right?

Copy and paste this code into Max/MSP and continue along with this tutorial.


How to use it

The ‘EDO’ value sets what equal tempered tuning you want. So a setting of 5 gives you 5-EDO, a setting of 34 gives you 34-EDO.

‘Reference Frequency’ is the standard pitch for the scale. Usually in Western music A = 440 Hz. You can also use 432 Hz if you believe in crystal healing and reptilian world leaders.

‘Reference MIDI Note#’ is the MIDI note to be tuned to the reference frequency (above). This could be MIDI note 69 if you want to tune to middle A, or MIDI note 60 if you want to tune to middle C.

For starters, try 5 for the EDO value, 440 Hz for the reference frequency and 69 for the reference MIDI note number. Have a play on the keyboard. It’s a cool sounding pentatonic scale, right?

Why this works

If you played with my example patch and got it working, then you don’t need to read this section. Just start using it in your projects and have fun exploring equal temperaments.

But if you absolutely must know how this magic is done, then keep reading! (Warning: I will assume that you already understand how to make expressions with the expr object).

Let’s look back at the original mtof expression, try to understand it, and then try to generalise it.

Output frequency = 8.175797 * pow(1.0594633,$f1)

Note that pow(a,b) is just the expr object’s way of saying a^b.

8.175797 is the frequency (in Hz) for MIDI note 0.
$f1 is the MIDI note number being played.
1.0594633 is the size of the smallest step size in 12-EDO. It is the value of a semitone.

Therefore an mtof object has this general structure:

Output frequency = Frequency of MIDI note 0 * pow(step size,MIDI note number)

Let’s start by swapping the step size of 1.0594633 with the step size from any n-EDO we want. But how do we calculate the step size? For n-EDO, it’s calculated like this:

step size of n-EDO = pow(2,1.0/n)

So let’s bring that into our in-progress generalised mtof:

Output frequency = Frequency of MIDI note 0 * pow( pow(2,1.0/n),MIDI note number )

That’s great, but unless you want MIDI note 0 to always be equal to 8.175797 Hz, how will we go about tuning our scale up to some standard pitch? Well first we need to know what our standard pitch is (aka reference frequency) and we also need to know what MIDI note number to assign that reference frequency to. Once we know these, we work backwards to find the frequency at MIDI note 0.

If our reference MIDI note number is higher than 0, then the frequency at MIDI note 0 will always be lower than the frequency at the reference MIDI note number. In fact:

Frequency at MIDI note 0 = reference frequency / pow(step size,reference MIDI note number)

We can re-use the step size calculation from before and insert it into the above calculation for MIDI note 0 frequency:

Frequency at MIDI note 0 = reference frequency / pow( pow(2,1.0/n),reference MIDI note number )

Above, we’ve just found a way to calculate the frequency at MIDI note 0 for any reference frequency assigned to any MIDI note number for any EDO of size n. That’s the entire left side of the mtof-killer worked out. So let’s bring alllll of this together:

Output frequency = Frequency of MIDI note 0 * pow(step size,MIDI note number)
                 = (reference frequency / pow( pow(2,1.0/n),reference MIDI note number )) * pow( pow(2,1.0/n),MIDI note number )

And finally we replace these English-language variables with integers and floats in expr format, such that:

$i1 = MIDI note number from the keyboard
$f2 = n-EDO
$f3 = reference frequency
$f4 = reference MIDI number

($f3 / pow ( pow (2,1.0/$f2),$i4)) * pow ( pow (2,1.0/$f2),$i1)

Well done if you kept up! I hope that explains how this expression alone can allow you to play microtonal equal tempered tunings in your Max/MSP projects.

UPDATE: Homebrewed methods like my one above are often inefficient. A commenter Toby noted:

This does the same thing in a simpler way:

expr $f3 * pow(2,($f1-$f4)/$f2)

If you need more power than this, for example you wish to create scales with arbitrary and variable step sizes, or you wish to play just intonation scales, then you should read How to play microtonal scales on a Max/MSP synth.

Sevish - Rhythm and Xen (Front cover)My recent album Rhythm and Xen uses many microtonal tunings. Give it a spin and see how all of this theory can be used to make accessible music with new moods.

Thanks for listening.

Xen-Arts Microtuning Virtual Instruments Part 5

Here’s a helpful Scala tutorial for intermediate tunesmiths. Jacky Ligon ( has explained batch processing and keyboard mapping in Scala. Batch processing is great if you have 4000 Scala tuning files (.scl) and you wish to export them as, say, MIDI tuning dumps or Anamark TUN files, without saving each file manually! You’ll also get a taste for using text commands in Scala, and creating script files from those commands.

To be fair I learned a thing or two from this article myself, and I’ll be using these tricks next time I get the chance.

Learn tuning theory

John Moriarty, a member of the global xenharmonic/microtonal music movement, has been making videos to explain modern tuning theory concepts. The ideas are presented in a very visual way with narration and musical examples. I would be interested to know how tuning theory newbies get on with these vids. It’s a heavy topic, both wide and deep with details. Anyway, enjoy John’s playlist!

And I’m sure there’s more to come in the future.

Microtonal chiptune music with One-SF2 VST

UPDATE: Xen-Arts plugins are no longer available, but if you’re looking to make microtonal music with SF2/SFZ soundfont files, I’ve had a good experience with TAL-Sampler.

Sonic the HedgehogI grew up as a gamer. Luckily my aunt was into games too, so I got the chance to play oldschool systems from before my time such as the Atari 2600 and the NES. All of this cemented my interest in electronic music from a young age. (For what it’s worth, my ongoing fascination with drum & bass probably came by playing Rage Racer on the Sony Playstation).

Some years ago, fueled by the nostalgia of umpteen million nerds, the chiptune music genre took off and is still going strong today. For some, the only way to make this music happen is to record from the original hardware itself. For others, it’s good enough to cheat and use VSTs which recreate the sound. Today I want to share one method of writing microtonal chiptune music using a VST called One-SF2.

OneSF2 - SNES Secret of Mana gamelan tuned to slendroOne-SF2 is a free soundfont player VST for Windows, and it has microtuning features baked right into it. Actually, it supports the MIDI tuning standard, so it can load all of the crazy scales I’ve been collecting in my tuning packs.

  1. Download One-SF2 and extract it to your VST folder. It’s about 30MB because it comes with a bank of sounds.
  2. Download the top soundfont “Famicom” from this collection. The Famicom soundfont contains many sounds recorded from the NES. Save it to your One-SF2 folder.
  3. Load up One-SF2 in your DAW!
  4. Let’s get a nice NES synth sound first. Look for a button that says “SF2” and click it. Now you can load the Famicom soundfont downloaded earlier.
  5. This soundfont contains multiple instruments. Find “SF2 Patch Name” and click the left and right arrow icons to scroll through the available sounds. I quite like #2 “Square Wave 25%”
  6. Switch the synth to mono mode. Now when you play a melody, it will sound more like the actual hardware and less like a polysynth. To do this, find the menu labelled “Control Edit”. Select “MIDI” from the list. Now you will be able to find an option called “Mono Mode”, turn this on.
  7. Here’s the key step, let’s make it microtonal! Find the button that says “MTS”. Clicking this will let you load a scale file.
  8. Write some dope xenharmonic chiptunes.

Remember the NES only had 5 sound channels. 2 are pulse/square channels, 1 is triangle, 1 is noise, and the last was used for low-quality digital sampling. You could recreate this capability by using 4 instances of One-SF2 (each using the Famicom soundfont), plus one audio channel with a bitcrusher effect. Read the technical specifications of the Famicom/NES sound chip if you want to strive for the most realistic result.

Here’s some xen chiptune drum & bass I cooked up a few years ago, in a game boy style.

Now, if only someone would make a version of Clotho from Columns tuned to a beautiful meantone, I could die a happy man…


Where to find more video game soundfonts

Here’s a collection of soundfonts from various game systems.
And here’s a mother lode of soundfonts ripped from SNES games.


Alternative pathways to microtonal chiptune music

Plogue Chipsounds supports Scala tuning files, emulates several oldschool chips, and opens the door to microtonal chiptune on Mac OS X and Windows (32/64-bit). Costs about 95 USD (as of early 2017).

Plogue Sforzando is a free and simple soundfont player much like One-SF2, but it works with the SFZ file format instead.

Pick up a second-hand console system and do it the old fashioned way, with tracker software and a soldering iron. Some trackers support microtones natively!

One-SF2 has a big brother, XenFont. This free, 32-bit Win-only VST adds heaps of synthesis functions on top of the basic soundfont player. A plethora of options exist for creating deep sound designs, so my own work always features XenFont instead of One-SF2.

How to play microtonal scales on a Max/MSP synth

Those of you who have built synths in Max/MSP or Max 4 Live will have used the mtof (MIDI-to-frequency) object. This clever little object waits for you to send it a MIDI note number (0-127), then it spits out a frequency (Hz). Perfect if you’re working within the confines of 12-tone equal temperament—or rather limiting if you wish to use all kinds of expressive intonation systems outside of the Western common practice.

A simple sine wave generator using mtof: MIDI to frequency

There is a very simple way to get microtonal scales out of your Max/MSP synths. We simply replace the mtof object with coll.

The coll object


What is the coll object, anyway?

Coll can be used to store and edit collections of data. The data is stored in a text file. Each item of data contains an index followed by some content. For example, we could use coll to remember the release years for various killer synths.

Example of coll's use

Above, the coll object is waiting to receive an index (either YamahaDX7 or Theremin) before it spits out the data we want. I just clicked the “YamahaDX7” button, so “1983” was sent via the first outlet of coll.

To see and edit all the data inside the coll, just double-click on the coll object. It will bring up the data entry window. Here’s what’s inside the above coll object:

OndesMartenot, 1928;
RolandTB-303, 1982;
Theremin, 1920;
YamahaDX7, 1983;

Neat trick. Mind you it’s not very useful for our goal of exploring crazy scales.

Here’s how we can use coll as a replacement for mtof. First we need to understand our data structure. We send a MIDI note number (0-127) to the coll object. We want coll to spit out a frequency in Hz. So we double click coll, and we start inputting data for what frequency corresponds to what MIDI note number.

# Lines that start with a # symbol are comments.
# This is a simple scale which starts at 100 Hz on MIDI note 0.
0, 100.0;
1, 200.0;
2, 300.0;
3, 400.0;
4, 500.0;
5, 600.0;
6, 700.0;


127, 12800.0;

(Interesting note: This scale is a harmonic series with a fundamental of 100Hz. Kinda trippy if you’ve never heard this kind of scale before, so try it out).

To test this out, let’s send the number 0 to the coll. This is the lowest possible MIDI note number, and according to our data we should receive the float value 100.0 from coll’s first outlet.

Testing the coll object

A success! It’s pretty simple to get it to work, but the only problem is that the tuning data took us a looooong time to type… 128 lines in total! Luckily coll can read .txt files, and there is a much better way to generate tuning data in this format. For this tutorial, we’ll be using Scala tuning software to create .txt files that coll can read.


First create or load some tuning data into Scala. (For now we’ll just load a file from Scala’s huge database)

Loading a scala file from the huge Scala database

Then type the following command into Scala:

set synth 135

Scala will say “Synthesizer 135: Max/MSP coll data, via text file”. You’re doing just great.

Now click File → Export synth tuning as shown below.

How to export a .tun file from Scala

This will bring up a familiar save file dialog, and you can save your .txt file anywhere. Once your .txt file is saved somewhere convenient, your can load it into your coll object.

Create a message button which contains the word “read”. Connect this up to the coll object (as shown below). You can click the “read” button to bring up an open file dialog. Use this to load the file you just exported from Scala.

Load .txt file into coll but using a message box titled "read"

Once you’ve loaded the .txt file into coll, you can check that the data went in correctly by double-clicking the coll object.

# Tuning file for Max/MSP coll objects created by Scala
# Sean "Sevish" Archibald's "Trapped in a Cycle" JI scale
0, 8.1757989;
1, 8.4312926;
2, 9.1977738;
3, 9.5384321;
4, 10.2197486;
5, 10.7307361;
6, 11.2417235;
7, 12.2636984;


Congrats, you’ve just replaced the mtof object with your very own, microtunable coll! Enjoy playing microtonal scales in Max/MSP.

Big up to Manuel Op de Coul, the creator of Scala, who added support for Max/MSP coll files on my request. Much appreciation that his project is still being maintained.



  1. Recreate my sine tone generator above, using coll.
  2. Download and install Scala, then get to grips with creating your own scales.
  3. Max 4 Live users—download my device Boom. Look at the source and see how I used coll to load tuning data.
  4. Make your own simple synth and have a jam in 5-EDO.
  5. The mtof object will accept float values in its input. Find a way to abuse this feature to microtune Max/MSP without using coll at all.

How to create a .tun file in Scala

Just a quick microtuning tutorial. Are you using a synthesizer instrument which loads the TUN (.tun) tuning file format? Let’s learn how to create one of these .tun files using Scala.

Before you start, make sure you’re using a synthesiser that supports .tun files.


Step One – Create new scale, or load existing scale into Scala.

You could load a file from Scala’s huge scale database, or you could generate new pitches by typing a command into the command bar (at the bottom of the window). For example let’s create a 13 note equal scale (13-EDO):

equal 13

Tip: Type “show” to display your the tuning in the main window.



Step Two – Tell Scala what type of file to export.

Type the following into the command bar:

set synth 112

Scala will output “Synthesizer 112: TUN standard .tun format for many softsynths, via text file”. You’re doing OK.


Step Three – Export

Go to File > Export synth tuning. Or press Shift+Ctrl+T instead. Choose a new location to save the file. All done!

How to export a .tun file from Scala

This is very similar to the process of making a MIDI Tuning Standard (MTS) tuning dump. To make an MTS .mid file, use “set synth 107” instead.

Jam away!