7up 2.0 – Introduction from makingthenoise on Vimeo.

What if the world of musical performance suddenly started moving a whole lot faster? That’s certainly the case among a handful of monome- and grid-wielding electronic artists.

In an evolutionary breakthrough, what previously had appeared in a period of months is showing up in a period of days, as long-simmering ideas come to the fore. Spurred by the blank-slate, minimal grid of the monome (and its design as mirrored in similar controllers from Livid, Novation, and Akai), musicians are re-imagining the step sequencer in new permutations. Many of these creations in recent days have been coming to Max for Live (site | cdmu tag), taking advantage of the potent combination of Live as a host, third-party plug-in instruments as sound sources, and Max’s own capabilities with sequencing and sound. But it would be a mistake to see this as a phenomenon limited to Max for Live. Other development efforts, built in free tools, work from the ground up instead of the top down, and may use code in place of patches. These efforts are running in parallel, taking ideas from one another, responding to each other as a challenge. And that could make the coming months very interesting, indeed.

What’s exciting to me is that a set of ideas is emerging that may go beyond any one tool. Even past the grid, what we see is people beginning to refine the idea of live electronic performance into reusable, modular components. There is a greater sense than ever that what computer performance is treads a line between composition and live playing. At the heart of that concept is embodying both in an “application,” and making that application work on the grid.

7up 2.0 Arrives, in Max for Live

The biggest news is that 7up, the popular multi-page, multi-module performance app for the monome, is reaching a big new release. 7up 2.0 builds upon an earlier version written as a standalone application in Java.

7up takes the grid and builds a single performance tool that has multiple functions. One strength of this approach is that, even with 7up’s various capabilities, controller assignments are fixed. You can learn 7up and build muscle memory with it. Equally significant, you get a set of predictable modules for various tasks, as pictured. stretta’s work, also using Max for Live, goes another direction, making the monome a generic controller for any number of performance “applications.”

For people working with Live, 7up is more functional in Max for Live than it was as a Java standalone. Among other things, creator Adam Ribaudo (makingthenoise) notes:

  • 7up components install into your normal device library
  • Drag and drop components to start using them
  • Extensible components mean community members can build their own in Max
  • Virtual MIDI no longer required

SevenUp site, with documentation + more
monome message thread


stretta, Live, and the Musical “Application”

maxforlive: monome integration from stretta on Vimeo.

Matthew Davidson, aka stretta, has long been both a virtuoso performer and master developer for the monome. Now, he’s going one step further, to try to make the undifferentiated grid of the monome work as a fully-functioning control surface, integrating multiple applications without ever having to leave the monome’s buttons.

It is one thing to adapt max patches for maxforlive but it is another thing entirely to construct them so they can handle multiple instances without stepping all over each other by accessing the same data. Then there is the issue of telling monomeserial which instance has control of the monome hardware.

I wanted to make it elegant to use. For example, if you click on a track in live that has a monome application running, that monome application is in focus on the hardware. It is this level of integration that makes maxforlive so appealing. So, now you can run as many obos, polygomes, stepfilters, or automatorgators as you like, and the monome switches between them effortlessly.

“Applications” and “musical compositions” take on interchangeable meanings. When stretta uses his “polygome” creation, it is an instrument, a composition of sorts, and – in the context of Live – a device. We’ve long lived with the ability to introduce new sounds and instruments into a studio simply by connecting them. With Max patches operating as modular compositions, you can drag and drop interactive musical ideas. (Okay, granted, such things appeal to the small portion of the population who can express their ideas in Max patches, but if you do count yourself among those numbers – or if you’re just lucky enough to be stretta – it’s all pretty amazing.)

Watch what happens as stretta drops polygome into a Live set:

maxforlive: polygome from stretta on Vimeo.

This certainly illustrates the advantage of Max for Live, for those who want a host for Max patches. As stretta puts it:

maxforlive simplifies monome workflow. For example, if you want to use polygomé with a DAW, you must open your DAW software, open polygomé, set up sync in polygomé, set up sync in your host app, set up MIDI output routings from polygomé, set up MIDI routings in your DAW. There is a lot of overhead. With maxforlive, you simply drag polygomé into your track as a MIDI effect. Then you can start playing immediately. There is no setup. Everything is in sync.

stretta hasn’t yet released this new version; that will come soon, so stay tuned.

…and Parallel, Free Software Solutions

Here’s an illustration of how the Max inside Live world might intersect with people working in very different ways. Inspired by the same problems stretta is trying to solve, there’s an effort to build tools well beyond Max or Live.

Brian Crabtree (tehn) has raised discussion of potential for a new monomeserial that would use OSC in a standard way to talk to multiple “applications,” across ports. That could be a number of Max patches running in Live, or a Max patch and a Processing sketch, or anything else. And it could ultimately have implications for hardware other than just the monome.

monomeserial next revision

See also this application, which handles OSC routing:
MonoRoute Software Release

Ohm + Max for Live

LividStep: step sequencer made in Max For Live from Livid Instruments on Vimeo.

For another view of how you might make a grid work with Ableton Live, here’s a glimpse of Livid’s Ohm64/block hardware in action with Max for Live. In this case, the grid itself replaces the mouse for what you might have done previously onscreen, arranging a sequence. Livid Instruments writes:

This details the major functions of Livid’s Max For Live device, LividStep, including playback, how to: add and change sequences, control timing, navigate Live, and control instruments, all from the Livid controller.
The device works in Ableton Live with Livid ohm64 and block MIDI controllers. The device creates an eight step sequencer on one row of the 64 button grid. Fill eight live tracks with eight devices to fill the grid. Each sequence has independent time control for a huge variety of rhythmic possibility.

And, if you make it to the end, yes, the irritation at those who don’t use a Livid controller is real and palpable 🙂

Livid’s patches are open, so this approach doesn’t have to be limited to Livid hardware.

Little Scale’s Standalone Sonic Creations

Little Scale’s efforts for the Novation Launchpad are aggressively simple, and beautifully so. Sebastian Tomczak is known primarily in the chip music scene, so the minimalist aesthetic is definitely part of his work. (Not to be confused – as I did initially – with Ripple, a framework of musical tools built by Morgan Packard in SuperCollider.) It illustrates that there doesn’t really have to be a UI; the Launchpad sequencer can run purely on the monome. (Add embedded hardware into a monome case, and you could have your own DIY musical instrument, standalone, without a computer as such. But that could come later.)

Sebastian is doing interesting like this “waveform editor”. It could certainly also be a prime candidate for a SuperCollider version.

Both of these projects were built with Max 5 standalone, though they could work nicely in Max for Live or other environments.


There’s just a handful of people involved, scattered geographically around the globe, but something is definitely happening – even as these artists work in relative isolation.

I think you can thank, in part, the limitations of the monome grid. Deciding to restrict the interface, and building something from scratch – whatever the development tool you use – is causing people to really focus on the musical idea they wish to express.

Of course, that means you don’t need a monome or Max for Live or anything else. The real power here is focusing on what you’re controlling live, and using restrictions in one place to breed creativity elsewhere. (Translation: what can you do with an 8×8 grid with no velocity sensitivity? Be creative.)