Cycling ’74 Max 9

Max 9 introduces Ableton devices and brings a host of welcome updates and improvements.

It’s a half‑decade since the last major release of Cycling ’74’s Max media programming environment, a period which saw a pandemic (giving many of us much more time in our home studios) and Apple’s shift to their own ARM‑based silicon for the Macintosh. The previous release of Max (version 8) came shortly after Cycling ’74’s acquisition by Ableton, so we’ve also had five more years for that partnership to deepen, with ever more technological crossover between Max and Ableton Live. So, how does the Max landscape look with the release of version 9?

Ableton Devices

For a software platform aimed at building audio processing systems, one could argue that Max actually doesn’t make the process that easy, at least from the perspective of the jobbing electronic musician! Recording and manipulating audio buffers is relatively straightforward, but if you want to dive into the construction of non‑trivial oscillator and filter systems or effects processing, perhaps adding control parameters and modulation on the way, things get complicated, and creating a good‑sounding synthesizer voice or effects system is not a small amount of work.

Way back in the days of Max 7, Matthew Davidson developed a library called BEAP for teaching electroacoustic composition at Berklee, with graphical control panels allowing simple modular synthesizers to be constructed easily. In Max 9 we now have a more sophisticated library of native objects, under the generic name of ABL, which have been ported more or less directly from Ableton Live, including some freshly minted offerings from Live 12. Unlike BEAP, these objects don’t have graphical user interfaces — you’ll need to build those yourself (and there is some new UI machinery to help with that, as we’ll see). What ABL offers instead is high‑quality audio generation and processing at the level of fidelity and detail you’d find in any modern DAW.

The ABL objects fall into two categories: a set of 55 (so far) low‑level ‘DSP’ objects with names prefixed by ‘abl.dsp’, and 12 high‑level ‘device’ objects prefixed by ‘abl.device’. The selection of DSP devices includes traditional audio functions (oscillators, filters, phaser, flanger, ring modulator, some simple reverbs). Some of these operate in mono, some are stereo. All are accompanied by comprehensive help patchers which explain their parameters and demonstrate their features.

The DSP objects are drawn from library components developed for devices in Ableton Live: for example, darkhall, quartz, shimmer, tides and prism are the five algorithms from Live’s new Hybrid Reverb device, whilst all two dozen or so oscillator types from Live’s Meld instrument are present as discrete objects. Meld in particular has been well received by Live users as an appealing and versatile sound source, so having access to its oscillators within Max really expands the kinds of synthesis that are possible without all the hard work.

Quite apart from the audio generating and processing objects, there are various LFOs, modulators, envelope followers and other components to allow you to build out sophisticated processing units, although something of the complexity of Live’s Meld or Roar would still be quite an undertaking. I was pleased to find that the DSP objects are ‘MC‑aware’, which means that a multi‑channel audio feed can be split across an array of such objects running in parallel, with a spread of parameter settings. So, if a granular oscillator like Swarm isn’t rich enough, mc.abl.swarm~ will deliver an entire swarm of swarms, while an MC instance of a simple FM oscillator offers the potential of some rich, multi‑tonal additive and FM layering.

The Ableton Drift synthesizer driving a guitar pedal distortion effect.

The abl.dsp objects are powerful additions to Max’s audio processing arsenal, but with the possible exception of the obvious ‘effects’ objects they aren’t really full devices in the Ableton Live sense: apart from anything else, the oscillator objects are not polyphonic. However, ABL also brings us a handful of ‘full’ devices, including a complete version of Live 12’s Roar saturation/distortion effect. Instruments are, sadly, a little thin on the ground: we have abl.device.drift~, the analogue‑style synth that arrived with Live 11. Drift in Live has a simple modulation system: three source/amount/destination slots rather than a complete matrix. This is reproduced in Max. As an instrument, Drift is fully polyphonic internally (though it will also operate monophonically or in unison mode), which means that it needs to be fed actual MIDI messages (a sequence of byte values) rather than frequency values like the ABL oscillators. In that respect, Drift behaves similarly to embedded VST instruments. Sadly, we don’t get a complete port of Meld, perhaps thankfully as it is pretty complex, and the modulation matrix alone would be a challenge to manipulate in Max. I can imagine there’s also demand for Live’s venerable Operator FM synth, but this wasn’t built with Ableton’s latest libraries, making porting across to Max infeasible.

Patching

The sophistication and capabilities of Max objects have increased immensely since the early 1990s when MIDI message processing was the only game in town. The arrival of the Jitter visual system, with its suite of complex 3D graphics and video processing objects, required the introduction of named object attributes, which in turn led to dedicated attrui (attribute interface) objects. The original preset object, used to store and retrieve object values, was superseded by the pattr system. Complex data values led to dictionary processing and messages. And this is all before the additional complexity caused by Max For Live controls and automation. The arrival of the ABL objects, with their large numbers of parameters and complete lack of visual interface, has led to another kind of data linkage: parameter connection. This new feature allows knob‑based control panels to be built around ABL objects without the traditional plumbing of patch cords, ‘set’ messages to avoid data loops, and so on.

User interface objects (dials, sliders, toggle buttons) can be invisibly attached to ABL device parameters, and once attached will automatically track changes. In this respect, the UI control behaves very similarly to an attached attrui object, except that it looks and behaves like an actual control. Unlike attrui (but rather like the original preset object), there’s no patch cord between control and ABL object, making the connection process a little fiddly: you have to choose from a potentially enormous menu of target devices and parameters. And the connection is not very discoverable: you have to Option‑hover the mouse pointer over a control to see what it might be mapped to.

Invisible linkage between control knobs and an ABL DSP object.

V8 & Code Boxes

Max supports JavaScript coding in two ways: the node.script object for hosting a Node.js server (for networking, database access and more) as well as the js object for scripting inside Max itself. While Node.js uses a modern, sleek JavaScript variant, js is tied to an old version of the language with a rather archaic syntax, unable to run modern code. Rather than an updated js, which might break legacy code, Max 9 provides a brand new object called V8, named for the V8 JavaScript engine it uses (the same as the Chrome browser and Node.js). V8 JavaScript is vastly more efficient than the legacy engine (a quoted speed‑up figure is a factor of 25 times). The v8ui object supports graphics and interaction, the equivalent of the legacy jsui object. v8ui comes with support for PointerEvents, a standard API supporting digitiser tablets (including pressure and tilt) and multi‑finger touch. For years, Max users have been making the most of experimental and unreliable objects for multi‑touch, so proper support is welcome. Unfortunately it’s still a work in progress, and there’s no multi‑touch support yet for us MacBook users with our large, responsive trackpads. One point to note about V8: just like the legacy js object, it runs in Max’s user interface thread, not the high‑priority scheduler thread, so it’s not ideal for anything requiring really accurate timing, and if embedded in a patcher that runs at high priority, there’s a risk of messages being transmitted in a different order than would happen in ‘pure’ Max code. This isn’t a showstopper, but requires care when patching.

Some sine and cosine list generation in a JavaScript code box.

The arrival of a modern JavaScript engine is accompanied by user interface enhancements to improve code editing across the board. Code boxes are blocks of scripting text embedded directly inside Max patchers, useful for one‑liners or very short segments of code. Max 8 featured code boxes in gen and RNBO, two embedded toolchains for working with lower‑level DSP code. In Max 9, code boxes have spread to Max more generally: they can contain JavaScript (both for V8 and for Node.js), dictionaries, colls (indexed tables of values) and OSC messages, as well as code related to graphics rendering. The Node.js case is complicated slightly by its reliance on a separate Node process, which still needs to be started (and potentially stopped), and Node also reads its scripts from the file system, so there’s a bit of machinery behind the scenes to save the code box content somewhere Node can find it.

A JavaScript one‑liner to populate the first 20 cubic numbers.

REPL

Max has always been a graphical environment, which appeals to non‑programmers who often find text‑based systems too challenging or difficult to learn. The JavaScript objects allow Max coders to drop into a textual language for calculations which might be complicated or inconvenient to code up in a graphical system, but there’s now an additional text‑based interface sitting snugly underneath the Max console. This provides access to a REPL — a read‑eval‑print loop — which is a line‑by‑line interface to Max objects, patchers, help information and an additional dedicated JavaScript engine. This seems to be a nod to the Live Coding movement, where musicians improvise on stage by writing code live (and showing it to the audience as they go). The Max REPL is a bit of a polymath: it can send messages to Max objects just as if they came in via message boxes, it can interrogate V8 JavaScript instances, and can evaluate one‑line JavaScript expressions. One of its coolest tricks is to redirect the result of one segment of code into another, so if you want to (say) calculate something in JavaScript (a random number, say, or the number of milliseconds since the start of the year 1970) and send that to a named Max object in a patcher, it’s easy to do.

The state of the art in text‑based coding environments has advanced considerably in the last few years, with editors like the popular Visual Studio Code offering syntax highlighting and ‘IntelliSense’, a posh name for autocompletion of names, plus pop‑up hints of function arguments, and so on. Judged against this standard, Max’s REPL feels spartan: without autocomplete you have to type the full name of any object you want to talk to (although there is also a pop‑up menu which lists them) and the name of any parameter you might want to alter. Some text colouring would make it easier to read lines of code which mix JavaScript and Max elements. But if you’re writing your own patchers and V8 objects, and want a focal point to create messages and exercise or debug your code, REPL might well help. One day soon we might even see a brave live coder play a gig purely by typing lines into the REPL text area.

The Best Of The Rest

I’ll round off this brief overview of Max 9 by mentioning some of the general interface improvements. There’s a ‘patcher list view’ pane, which lists all objects in a patcher, showing their arguments and scripting names in one place (useful as a reference when using the REPL). Text objects now have syntax colouring to distinguish object name, arguments and attributes (though integer and floating‑point arguments are the same colour, and it would be good to get an indication that an argument has been changed by an incoming message — these are the top two issues which confuse novice Max users). There’s a debugging ‘illustration mode’ that animates a patcher’s message flow in cartoon‑like slow motion. Graphical display objects like multisliders and function generators can now be shown with tasteful alpha‑blended gradients.

Having been through Max upgrades from version 2 all the way to the new Max 9, this new release feels like something of a solidification...

Conclusion

Having been through Max upgrades from version 2 all the way to the new Max 9, this new release feels like something of a solidification: Ableton’s DSP and device suite adds considerable heft to Max’s mainstream audio processing, while the code box objects blur the sometimes awkward division between patching and text‑based coding, and add more visibility to storage objects like colls and dictionaries. The new REPL is a more esoteric feature, and still in need of some refinement, but looks as if it could steer the whole patch development process in new directions. Overall, as the cliché goes, a no‑brainer of an upgrade.