Max & M4L

Sections on this page: Programming Max, Max for Live

Max / MSP / Jitter

Max is a programming language which was developed around 1980. Its development shifted back and forth and around 1990 it became the property of the person who later founded the Cycling ’74 company in 1997. The original writer of Max also released an open source version which is called Pure Data. Although very different than Max, Pure Data still exists today and is available on several operating systems (Windows and Linux being amongst those) and in a way could be seen as the “free” counterpart of Max (though they really have very little in common these days).

In its beginning Max was basically an environment which could be used to access (hardware) synthesizers through the means of midi and basically could be used to automate certain aspects of said synthesizers (of course it could do a lot more than that as well).

Over time several enhancements were added to Max, amongst which the MSP module which provides a way for real-time manipulation of digital audio signals (MSP stands for “Max Signal Processing“). During these times Cycling ’74 also started to work more actively on Max itself and around 2003 the latest enhancement was released: Jitter. Jitter provides Max with real-time video capabilities, 2D/3D graphics and matrix processing.

Max 6

And finally around the end of 2011 the latest version got released: Max 6. It includes many changes in the user interface, an enhanced sound engine which provided better support for 64bit and a new extension has been added: Gen. This extension allows people to build modules using the regular Max interface after which the code that module gets compiled instantly.

Another interesting change is that Max 6 is no longer sold without the audio and video extensions (MSP / Jitter); these have become part of the Max 6 package. The only optional extension is Gen.

Max 6 vs Max 5 vs ‘Max for Live’

Keep in mind that this tribute page is focussed around Max 5 and the current version of Max for Live. Although I had some concerns when it comes to the new Max 6 interface (I liked the “no nonsense” interface of Max 5) there is no denying that Cycling ’74 have made some very interesting developments and enhancement in these parts.

And the best part is that Max 5 and 6 can easily co-exist. As such on my computer I keep Max 5 around to be used stand alone and as Max for Live in Live 8. Whereas Max 6 is used within Live to power the latest Max for Live 6.

What can you do with Max? (Max 5 shown)

Now, this is a very loaded question because since Max is a programming language there’s basically very little which you can’t do.  But because I can imagine that a programming language maybe a strange sight on a website devoted to synthesizers I figured I’d start with this question.

As can be expected Max’ key strength lies in multimedia. However, its capabilities way exceed this specific section. Max provides a relatively easy way to create programs which you can use to process audio or video, control external devices (for example through the use of midi) right to setting up connections to other (Max) devices (over a network if you’d want to).

And if you do come across a situation where Max alone isn’t able to cope with the things you want it to do there is no reason to despair; having native support for expansions written in either Javascript or Java the sky basically is the limit when it comes to working with Max.

Please keep well in mind that Max isn’t limited in any way to the features I’m describing here. All I’m trying to do is mentioning some of them which spring to mind, but there is a lot more to Max than this.

Programming with Max

Programming in Max basically consists of filling your programming window (called a ‘Patcher’) with objects. These objects can be anything; from buttons and sliders which can be used to setup a user interface right to objects which can be used to perform specific functions. For example; the object in the screenshot called “rewire~” is used to control other Rewire devices.

Objects can also interact with each other. To keep it a bit simple I kept the patch in the picture “locked”, but all objects have so called inlets and outlets. Inlets, located at the top, are connectors where an object can process incoming data.

Outlets, the name basically says as much, are connectors which send out output from the object. These output signals can range from simple data like numbers or words right to audio signals, as can be seen in the picture; the black/yellow cords indicate that an audio signal passes there (actually it goes a little deeper than that, but for the sake of clarity lets call it audio for now).

Next thing to keep in mind is the workflow. Max works from top to bottom and right to left.

Meaning: if an object’s outlet is connected to the inlets of 2 other objects (an example can be seen at the upper left of the picture) then the signal which will be send out first is located to the right. So, in this case: the right striped slider will receive any produced signals before the left slider.

It takes getting used to, but once you got the hang of it it actually starts making some logical sense as well.

A Max user interface

Now, this picture really isn’t the best example of what a Max patch could look like, but at least it’ll give you a rough idea.

Every Max patch has 2 modes: Patching mode and Presentation mode. The patching mode is what you’ve seen above; the objects which make up the program are visible as well as all their internal connections. Basically it shows you the program internals, as well as the programming logic so to speak.

Presentation mode on the other hand (usually) hides all the underlying logic and only presents the objects which are useful to the end user. Of course this is all entirely optional and fully to the discretion of the programmer.

But in this example you see that some of the objects in the picture above are still visible (the ‘rewire’ logo for example) whereas others have drastically changed (the large slider at the bottom).

And most importantly for this example: some objects are no longer visible. For example the “rewire~” and “loadbang” objects are fully gone from the screenshot to the left. All which is left are the objects which can be used to control the program.

And for those of you who are curious as to what this specific program does..   I made this at a time where I didn’t have a Max license but had only a “Max for Live” license (see below). Because Max provides a freely usable runtime I was basically capable to create “Max patches” by using “Max for Live” and then use these on their own using the runtime. But because the runtime has limitations (you obviously cannot edit a patch, but you also can’t access options like Max’ DSP status window (which shows you the currently available audio input and output channels)) I decided to write a patch which I could use to overcome some of those limitations.

And for the record, a runtime is an environment which can be used to execute programs which were made for that environment. The most obvious example I can come up with is Java: you need to have “Java” installed in order to use it. But what you’re basically installing is the so called Java runtime which allows you to use programs made in Java. Do keep in mind that Max isn’t limited to be used with a runtime. It is possible to create Max applications; programs which can be used without a separate runtime being available.

Because I long expired my Max demo license when I finally got more interested in the Max sound engine I simply wrote the patch above (which allows me to use Max as either a rewire Master or Slave) and started checking the entire thing out on my own. And it worked like a charm indeed!

Eventually resulting in a full Max license, but that’s a totally different story..

Max for Live

Take a program like Ableton Live. Add a programming environment like Max and what do you get?  Max for Live.

Cycling '74 loops in the Live library.I’m not sure but I don’t think that the relationship between Ableton and Cycling ’74 is something “out of the blue”. Not when you consider that Cycling ’74 has its own impact on Ableton Live; even without Max anywhere near.

As can be seen in the screenshot to the right; this is where you can find a collection of audio loops in the Ableton Live library which were provided courtesy of Cycling ’74. And the material is quite good as well (at least in my opinion).

So within that context I don’t think it should come as a surprise that both companies eventually decided to work together on a project which could easily get them a mutual benefit.

Live for Max

On one hand you have Max programmers who might be interested in using their programming expertise in an environment like Live which can provide for their needs when it comes to audio or midi processing. Although Max is perfectly capable of recording audio it takes quite an effort to set it all up. Whereas Live can basically record with the click of a mouse button. Enter Max for Live..

Max for Live

And on the other hand there are users like myself; people who are fully into Live yet have (had) no clue about the existence of something like Max. Presenting them with Max for Live might give them a whole new experience which could very well expand so far that Live itself simply won’t be enough for them anymore. Enter Max..

To me Max for Live is the best thing which could have happened to Live ever. Even though my experiences with Live were very limited when I first came into contact with Max for Live I immediately recognized the potential it provided and basically jumped onto the bandwagon with very little doubts. It was then and there where I first came into contact with Max. And I guess I’m the living proof that the strategy does seem to work considering that I started with a Max for Live license (which I even (‘ab’)used to create full blown Max patches) yet eventually ended up with a full Max license (Max/MSP/Jitter) as well.

At the time of writing Max for Live can provide Instruments, Midi and Audio effects all easily used within Live. Do note; a so called runtime which Max has is not available. In other words; in order to use a Max patch you can download the freely available runtime and use the patch.

In order to use a Max for Live patch you either need to have the Suite version of Live (this includes Max for Live out of the box) OR buy a separate Max for Live license. There is no freely usable runtime. The opinions on that matter differ, personally I don’t think that there’s an advantage of having a free runtime for either the companies nor the early adopters.

Programming with Max for Live

In general using Max for Live is not that much different from using Max.

The biggest difference as can be seen to the right is that the patcher window now has a grey background in comparison to the white background of the Max patcher window.

But apart from that this is in every aspect of the word Max embedded within Live. For example; you will notice that the icon bar at the bottom is exactly the same as that in the pictures above. Even some of the objects are a perfect match (the grey “text fields” for example).

As a side-note; in this screenshot you can now more clearly see the inlets and outlets of the several objects. A good example is the “p reset_values” object which has one inlet and up to 4 outlets.

Don’t mind the changed menubar by the way; this is “by design”. I set that up in an attempt to make sure people would notice the comment field at the bottom and read the release notes. The reason for that is that this patch, a tone generator, can easily provide very high and thus quite annoying noise.

(note that this patch can be downloaded on my M4L Patches page).

The main difference however is the inclusion of Live objects. Notice the drop-down menu in this screenshot? If you scroll back up to the ‘ReWire controller’ patch you’ll notice that the menus there look completely different.

Since Max for Live came to existence there have been several new objects added to the Max environment. Ranging from the “” you see above right to stuff like “live.dial” and “live.button”. Alas, for a rough overview see this screenshot:

Max for Live’s Live capabilities

Although having Max within Live should in itself already provide enough means to create devices to enhance Live they also made sure to provide a Live programming model which can be used to access and control several specific Live controls. Ranging from simple aspects like, for example, the track volume right to more specific elements such as arming or de-arming a track.

All in all Max for Live (‘M4L’) provides a full blown programming environment within Live which can be used to do whatever ideas you might have but which at this time aren’t natively supported by Live “out of the box”.

And there you have it…

Right now I don’t think I’d be able to get used to a Live environment anymore when it doesn’t have any M4L capabilities. Its influences can be very subtle like providing a way to quickly stop a certain action right to more complex tasks such as providing previously mentioned action but this time depending on a random factor.



I hope this gives a global impression about Max and Max for Live. But if you want to get the official wording on it all I’d like to suggest a visit to the official product pages for Max or M4L (which has two:) courtesy of Ableton and the one courtesy of Cycling ’74.