Percussa micro super signal processor

monomeblur

As electronic musical instruments have evolved, it’s been surprisingly easy to point to specific designs that lead others. Creators do often reach the same cluster of ideas at about the same time. But the specifics of how those ideas catch on have very often coalesced around one iconic instrument.

Bill Hemsath’s layout, with Bob Moog, for the Minimoog became the standard for monosynth keyboards with knobs. Roger Linn’s design for velocity-sensitive pads, and eventually the MPC 4×4 grid, became the standard for drum machines.

And Brian Crabtree and Kelli Cain I think deserve credit for making the 8×8 grid the dominant interface for sampling and sequencing with computers, with the monome. This isn’t just aesthetic, but functional, too. The marching, light-up step sequencer, the use of grids to play different sample slices, the division of the grid into multi-functional triggers for different software features, all come from the monome or the monome community. And, accordingly, in both layout and software function, hardware from Novation, Akai, Ableton, and others all follow the monome template.

In the face of that competition, the monome design itself hasn’t changed much. It’s still monochromatic, still an unadorned array of triggers – no additional buttons or encoders on the side. There’s still no velocity sensitivity. What has changed is that the monome project has distilled a kind of manifesto about what they’re doing.

Much of this centers on a focus on “minimalistic” design:

we seek less complex, more versatile tools: accessible yet fundamentally adaptable. we believe these parameters are most directly achieved through minimalistic design, enabling users to more quickly discover new ways to work, play, and connect. we see flexibility not as a feature but as a foundation.

Minimalism for its own sake is fairly unconvincing. What the monome project and its community have managed to do, however, is make a compelling musical case for those decisions. It’s the musical output that remains monome’s best marketing. What seems to be just a set of buttons, what seems indeed very much unlike an instrument, is able to produce astonishing musical variety. The music can say less is more. A new compilation video shows these in brief:

pieces of monome from tehn on Vimeo.

But let’s take a look at each of these individually.

“meadowphysics” is perhaps the most interesting of these. Here, the human operator triggers a set of generative rules; the limited interface (the buttons) can produce more musical results by way of algorithmic chains of events.

meadowphysics from tehn on Vimeo.

meadowphysics is a tangled cascade counter with rapid tactile rule changing.
monome.org/docs/app:meadowphysics
each row counts down, triggering an event when it hits zero on the left. this can be a drum hit, a parameter change, a synth note, etc.
upon hitting zero each row can be instructed to tell other rows to count down by one. which rows are set by pushing the leftmost column. in this way each row can cross-influence one another in simple or complex ways.
only the top row is triggered internally, as a sort of master clock. in the simplest arrangement, the master clock can simply trigger every row, and you get a relatively normal cascading counter, or polyrhythm generator such a flin.
small grid attached to aleph soundcomputer running a drum synthesis module. large grid attached to computer running monome-sum synth via teletype.
performed live.

I think it’s worth, then, realizing that the monome is not only the product of years of grids in the Roger Linn / MPC vein, but also the work of people like Toshio Iwai. Iwai’s Tenori-On with Yamaha may not have caught on, but Iwai’s work on music as interactive compositional game dates even earlier, to work in the 90s, as part of a scene of this kind of music. The reason monome can appeal more than Tenori-On is perhaps the ease of changing the software on the computer – Tenori-On’s limited repertoire of musical games, in other words, didn’t ultimately stick with musicians.

Galagoose (Trent Gill) has been personally involved in that software evolution. Even as the hardware has remained the same, he has continuously iterated on software.

It’s also evident how the monome can be a performance instrument, in the hands of Trent or artists like early-adopter (first adopter, even) Daedelus. The relationship is transparent to the audience in the way most live sets still aren’t, not so much because of the presence or absence of a computer, but because the actual rhythms are directly connected to the gesture of the player. It’s I think the rhythmic disconnect that makes computer performances so opaque. (I’m a pro, and half the time I can’t tell what’s going on.) Here, it’s all about rhythm.

galapagoose (trent gill) performing “ssensse” using monome grids and the software mlrv and mesh.
monome.org
monome.org/docs/app:mlrv
monome.org/docs/app:mesh

ssensse from tehn on Vimeo.

sum is, appropriately, a combination of these two approaches. Here, you see the essence of rhythmic access, combined with the sense of the grid as a window into a collection of apps – ultra-simple, generative machines.

monome sum, in part from tehn on Vimeo.

a little musical demonstration using an application called monome sum, a collection of grid instruments including flin, step, gome, corners, mlr and beams. all sounds are generated with the use of the built in synth, effects, presets and included samples. you can download the open source program here: monome.org/docs/app:sum

In aleph breakfast, we see the monome grid at home next to aleph, the ultra-limited standalone DSP computer from the same makers, and modular instruments.

aleph breakfast from tehn on Vimeo.

no laptops involved.
aleph and grid. dual step sequencer running within bees, driving euro modular synth via cv, continuous and gates. audio from modular synth fed back into the aleph and processed by the lines delay module with filters and feedback.
the sequencer shows two timelines which can have their position and loop lengths cut dynamically, a sort of performance step sequencer. these are the top four rows, showing the playback position and loop length per timeline.
the bottom four rows are the data bits, or notes. some rows are mapped to triggers attached to the envelope generators via cv output.
aleph knobs are mapped to feedback, delay time, filter cutoff.
i see infinity in this tiny white box.

It’s an expensive combination, but the ultra-high-res encoders of arc really do extend monome nicely, by allowing you to reach beyond the limitations of the grid.

de route – søren andreasen from tehn on Vimeo.

improvisation by søren andreasen using monome arc four and one twenty eight using tailored software.
soundcloud.com/sorenandreasen
monome.org
monome.org/docs/app:returns

As design projects, I have to say, I admire the ingenuity of the software here.

Limitations – the absence of parameter control on the grid of on/off buttons with on/off lights – can be a platform for creativity. I had a composition teacher once talk about putting yourself in a cage, then rattling the bars of the cage. Others talked in slightly less violent terms, but it’s clear that restrictions and rules can be a way of focusing compositional ideas. And that’s the genius of monome: its minimalism makes it a compositional frame. The music that comes out can be more than that grid; what you do with the grid becomes even greater in importance.

Less, but more?

That said, maybe it’s time to start criticizing the monome itself. (I’ll say this: it’s worth criticizing. Not everything is. This is hardware with a point of view.)

It’s absolutely beautiful that the monome lacks labels and icons, extra buttons, displays. It remains distinct from other hardware like Ableton Push in that those devices have become increasingly tied to software. They become nonsensical without the computer applications. You could go as far as saying they’re extensions of software marketing, but I don’t think that’s fair. Rather, they’re physical manifestations of a set of computer software behaviors. The problem is, what makes them work so clearly with the software also makes them poorer at adapting to anything else. And unlike the hardware of the past, that functionality is always somewhere else.

The clever trick of monome, then, is the way it deals with the disconnect between software and hardware. It is as generic as possible, so that it can adapt to any software. And that aspect is wonderful.

But…

I recall my first complaint about the monome, which was its lack of velocity sensitivity. For a time, watching the trajectory of the monome community and the music around it, I began to regret that comment. It was clear, at least, that it didn’t matter to everyone, and that in itself was (and is) interesting.

The problem is, it still matters to me, quite a lot. Listen to the examples above. The aesthetic of the music is essentially flat; you may find dynamic variations in the content of the samples, but because you can’t control any degree of expression in parameters directly, there’s a great deal of repetition of samples at the same volume level.

The musician is given the ability to control which button is triggered, and you can do a whole lot with expression simply using the aspect of time. But the problem is, you’re still playing an on/off instrument. Nothing about the physical gesture you make apart from time is reflected in the sound.

Amplitude is to me an essential element; it’s no accident that the Theremin, given only two parameters, chose the axes of pitch and amplitude. And consider the above examples. The monome took the 4×4 grid Roger Linn introduced on the MPC (or the 6×3 matrix of the Linn 9000) and expanded it as a matrix with independent light. But by removing velocity and pressure, monome’s pads represent a regression.

Oddly, building such a parameter into the sensor below the trigger itself ought to keep with monome’s minimalistic philosophy, because it adds expression to the same interface without requiring any additional controls. In fact, both the velocity of striking the trigger and ongoing pressure then become usable. (Tilt has been added experimentally to monomes, but that’s it.)

There is a certain cult of expression in digital interfaces, one that believes that they should behave more like conventional acoustic instruments. This phenomenon usually results in the idea that you need more data – audio streams to reproduce expression. To me, while it can be an admirable course, this doesn’t entirely reflect either the beauty of having an instrument with acoustic properties, or the inherent flexibility of a digital interface. Digital instruments are compositional as much as they are about physical performance; they embody structures, rules, and decisions, not only the connection of movement to sound. And so you can have a digital instrument like the monome that removes input and still produce something musical – just musical in a different way than, say, a violin.

monome is an elegant demonstration that you can take away input data and still create something expressive. In an age of high-resolution displays, it has pixel counts you can count on your fingers. And it shows that less can be more musically, too.

But all that might still not erase the desire to use the sensor to measure more than on/off.

While monome has produced physical variations and grids of different sizes, most of the recent developments on the hardware side have been side excursions. We’ve gotten the arc, a set of encoders. We’ve gotten aleph, a self-contained computer. What we haven’t seen is any significant revision to the monome itself.

I remain for that reason optimistic about Roger Linn’s own forthcoming addition to the field:
Roger Linn’s Linnstrument Could Finally Make Grids Expressive for Music [Hands On]

In the meantime, other options: you can certainly use a Maschine (in MIDI mode), a Push (always sends and receives via MIDI), something like the Livid Base (recently updated, in fact, as Base II), or – ideal as it supports MIDI and OSC and lots of expression – the Keith McMillen QuNeo.

“Keep it simple and it’ll last forever,” as Massimo Vignelli said. And the monome certainly appears to do that. But sometimes, great design deserves a sequel.

The design of monome remains so fresh, so inspiring, once paired with software, that to me it’s worth asking: what if a design could be just as minimal, but deeper? I hope someone takes on that challenge.

I think it’s worth challenging ourselves with these ideas, too – as builders, as patchers, as artists. We can always work harder to create Weniger, aber besser (less, but better).