Monome Norns

Monome's enigmatic Norns can be anything you want it to be — if you're prepared to put the work in...

The year 1967 saw the publication of a short science fiction story by Larry Niven entitled The Soft Weapon, which featured a small, mysterious, technologically advanced hand-held device capable of completely changing shape and function according to the position of a sliding control. The characters in the story attempt, with limited success, to determine what the various 'modes' of the weapon are and how they are activated and controlled.

The story came to mind whilst I was exploring Norns, a stand-alone synthesis, effects and control unit from Monome, the small New York-based company better known for their illuminated grid control surfaces. The Norns (I'll treat the word as a singular, although technically it is a plural) is a neatly finished metal box a little smaller than a paperback book, with some knobs, buttons and a small screen on top, and audio jacks and USB sockets on the back. There is no text or iconography anywhere on the unit — nothing is labelled — and it's not immediately clear what the box does, or how it does it. Unlike Niven's fictional weapon, the Norns is not dangerous (so long as you keep the headphone volume under control), but it is very much a 'soft' device: immediately reconfigurable into one of a potentially unlimited number of operational functions with the twist of a knob and the click of a button.

Background

We'll look at the hardware and system shortly, but it's illuminating to trace some of the history behind the Norns. Following on from the early editions of their controllers (the push-button grids and later the rotary encoder-based arcs), Monome got into the Eurorack module business, shipping a variety of digital control and sequencing modules, many of which are capable of driving a Monome grid as a programming or performance interface. Since Monome as a company have always embraced open source as a philosophy, and released the software sources for all their products, it wasn't long before technically minded users were modifying, or even replacing, the firmware for these modules with enhancements and features of their own, and releasing these new varieties back into the community.

One of the modules to benefit from this communal development was the Teletype, a dynamic algorithmic triggering unit with a small text screen and a simple built-in scripting language. Plug in a QWERTY keyboard and you could program or improvise on your modular by entering lines of text, a process that would have seemed utterly ludicrous to any observer before the emergence of the whole live-coding and algorave performance scene.

So what of the Norns? It has a screen just like Teletype, some 'front panel' controls, can be connected to USB controllers, is networkable over Wi-Fi, runs synthesis and audio processing software, and is basically self-contained. (It even runs off a built-in rechargeable battery for true off-the-grid operation, if you'll pardon the pun.) Think of it as a music computer, with the versatility and flexibility which that implies, but without the distractions, interruptions and unreliability of a general-purpose multitasking laptop or desktop machine. The Norns is about options and possibilities, but also about creative focus; traditional computer systems tend not to do very well at the latter.

The Norns is very much a community-based product: prototype hardware was released to willing developers at an early stage, and the ongoing development of the platform is driven by community effort, in what might be viewed as a more formalised version of the process driving third-party modifications of the Eurorack devices. Its openness makes the Norns as much a development platform as a final product, and to get the most out of it you will have to start digging into the software environment, although it's certainly usable to an extent as a stand-alone audio device, depending on the software modules ('scripts') loaded into it.

Internally, the Norns is based around a Raspberry Pi Compute Module board, and as I write this Monome are working on a kit to add screen, controls and audio interfacing to a standard Raspberry Pi, should you wish to go the DIY route.

The Basics

Let's look at the device itself. The case measures roughly 16 x 10 x 2 cm, and is finely finished in milled and anodized aluminium. The top panel features a flush-mounted grey-scale OLED display, which is relatively low-resolution (128 x 64 pixels) but is capable of 16 levels of brightness (and so graphics can be anti-aliased to an extent). Three rotary encoders and three buttons complete the interface. Each encoder is visually paired with a button, but there's no enforced link between them. There's also no obvious alignment between the encoders/buttons and the screen, rather ruling out any interface design that might make use of soft keys or menus as you often find on mainstream digital instruments.

Monome Norns (front) connected to the illuminated button-festooned Monome Grid controller.

The rear of the device features five quarter-inch jacks: stereo in, stereo out and headphone out, all unlabelled, although their functions are fixed. (I should also say that the Norns cannot itself do CV output for modular synths: for that, you could add Monome's own 'Crow' USB-to-CV interface, which Norns supports.)

There are four USB-A sockets, and a mini-USB socket intended primarily for power, although it also doubles as a serial connection into the device. A 2-amp USB power supply is included (with American plug — a UK replacement supply works just fine) and there's a separate small Wi-Fi dongle for networking: the Norns does not support Wi-Fi natively, so you'll need to use this (and lose access to one of the four USB ports) if you need the device to be networked.

Turn the device on by holding down the leftmost button, and after a few seconds of booting up you'll initially be presented with a simple selection menu and the name of the currently loaded script. The Norns runs one script at once; to change script you navigate back to this screen and make a new selection. The definition of 'script' is pretty broad: since everything in the Norns is defined in software, a script could be anything that processes incoming audio, or generates outgoing audio, performs synthesis, manipulates samples, communicates with USB devices, talks to a wireless network, responds to its onboard encoders and buttons, or draws text or graphics to the screen. One script might be something akin to a guitar effects processor, while the next might be a step sequencer which you configure on a Monome grid and which drives an external synth (with the Norns doing no audio at all).

A simple selection interface to load a Norns script.One of the few fixed features of the Norns top panel is the function of the leftmost button, which toggles between two modes referred to as PLAY and OTHER. PLAY is the main interface to whatever script is currently running, while OTHER is a common system interface for configuring the device (including Wi-Fi and MIDI settings), setting overall input and output levels, and monitoring.

A script may declare a group of parameters for editing, in which case these appear on a page in the OTHER mode, in addition to what the script might present on screen in PLAY mode. These parameter sets can be saved and restored as numbered presets, though a script will not necessarily make its entire state visible through parameters. (You may be able to save and restore synth parameters, for example, but perhaps not step sequence data.)

A script is free to use the encoders, buttons and display for pretty much anything it chooses: the display supports text and graphics, and scripts can use the physical controls to navigate between different parameter pages or change parameter values, much as on a conventional digital instrument. The abstract layout of the controls is both a strength and a weakness: since scripts can use the controls however they want, different scripts use them differently. One moment you're navigating between pages using two buttons, the next it's via one of the encoders. There are some conventions for navigating between display pages and parameters, but not all scripts cleanly adhere to them.

System Architecture

A running Norns setup is a configuration of a number of software components which form an overall audio routing system. The 'engine' is a process running SuperCollider, a special-purpose programming language designed for real-time audio synthesis and algorithmic composition: this constitutes the Norns' built-in synthesizer. 'Softcut' is a custom-designed six-voice sample manipulation library which can load files or capture audio into buffers and manipulate it in various ways: variable speed playback, looping, filtering, and writing back to file. In addition to these two audio systems, there's a reverb, a compressor, level controls, and a small utility called 'Tape' that can capture, save and replay whatever audio is sent to the main outputs. Not all the audio components need to be used by every program: a looper might just configure Softcut, while a polyphonic synthesizer would use the engine.

The Norns audio routing system.

While Tape and the mixing system have a user interface (they can be controlled in OTHER mode via encoders, buttons and the screen), as do the compressor and reverb, the engine and Softcut are totally hidden from view: to configure and control them, you'll need to engage with the Norns scripting system, unless the current script chooses to provide on-screen access to synthesis or sampling parameters.

A lot of audio manipulation power is available in the software, but three encoders and three buttons is hardly an extensive control interface to make the most use of it. Accordingly, the Norns is designed to be extensible: the rear USB sockets support Monome Grids and Arcs, MIDI controllers and HID devices (everything from QWERTY keyboards and mice to gaming joysticks), and OSC networking provides additional links to the outside world. USB and OSC interfacing is all controlled by the built-in scripting system, which is also used to set up and control the audio system, and draw to the screen. To make the most of the Norns, you need to be willing to do some scripting.

Scripting

Everything within the Norns is held together by scripts: the scripting layer configures and controls the engine and Softcut, provides programmatic access to Tape and the mixer, reads the encoders and knobs, draws text and graphics on the OLED screen, and drives any devices connected via USB (including MIDI I/O). When loaded, a script initialises whichever parts of the audio system are needed, and then gets to work mediating controllers, screen and audio in real time.

The Norns web-based scripting environment.

The scripting is done in Lua, a lightweight language originally developed by a team in Rio de Janeiro — think of the language as a simplified but capable cousin of JavaScript or Python. A Lua tutorial is rather beyond the scope of this review, but Monome have provided online tutorials for developing Norns applications step by step. There are Lua language interfaces to the audio system, display, and any grid, arc or MIDI devices attached to the Norns, as well as OSC networking and the internal file system.

If your primary area of interest is sample manipulation, then you'll need to work with Lua and the interface to Softcut. The Norns application 'mlr', the sample-slicing app originally developed in MaxMSP, works this way, connecting Softcut to an animated Monome grid. If you are more interested in synthesis, then you can activate the SuperCollider engine. The Norns comes with a small number of SuperCollider engine programs including a 16-voice subtractive polysynth and a Karplus-Strong plucked string model, all with scriptable parameters. If you want to explore synthesis more fully, then things get more complicated: you'll have to start coding in the SuperCollider language itself, which is not trivial. (The definitive SuperCollider book published by MIT Press runs to a little under 700 pages.) But you can get a long way working purely in Lua, linking in one of the off-the-shelf engine programs: a few of the third-party Norns scripts have custom engine setups which can be repurposed without too much intricate coding.

To develop and test scripts for a Norns, you'll have to network it. Plug in the provided Wi-Fi dongle and the Norns can connect to an existing Wi-Fi network, at least in theory: in practice, the device seemed to like some networks better than others, without giving much indication of why some networks didn't work. (My Norns review unit had no problem with my Google Wi‑Fi router but didn't seem to like the Fritz!Boxes that are ubiquitous in Berlin.) On a few occasions I resorted to using my iPhone's personal hotspot, which was perfectly functional. In any case, the Norns can itself act as a dedicated hotspot if you don't mind losing Internet connectivity whilst using it.

Once networked, the Norns runs a web server that provides a development environment for script writing. The device's file system is presented on the left, while the right-hand window allows editing of Lua scripts or, for the brave, SuperCollider code. Updated code can be loaded and run by clicking an icon or typing a keyboard shortcut. At the bottom right is a text entry field for evaluating lines written in Lua — useful for debugging or experimenting with the active script.

Whilst the web server shows the Norns' file system, it doesn't provide total access to it. There's a built-in web-based package manager for installing and updating third-party scripts, while you can use FTP to transfer files. Additionally, WebDAV support allows the Norns file system to be mounted on your Mac or PC for drag and drop.

If you are willing to get your hands dirty, the Norns web interface is eminently usable: importantly, the turnaround from editing code to seeing or hearing the results is very fast, and the interface highlights programming errors reasonably clearly. This was my first real contact with the Lua language, but it is simple and elegant, so I was able to start creating interactive lighting patterns for a Monome grid within a few minutes. There are no real 'sharp edges' to the language or the Norns environment — everything is pretty obvious — but you will have to hunt around online for documentation. The Norns' internal web server itself comes with pages describing the Lua interface to everything from controlling audio to drawing icons on the screen, but you will have to hunt around monome.org, llllllll.co (the Monome community site), or GitHub for overviews, tutorials and example code. There's plenty of online help for the SuperCollider language as well, but that's a much deeper and more involved process, so it's probably best to explore the existing engines (as well as Softcut) before diving into full-on DSP coding. Monome have hinted that they want to support built-in languages other than SuperCollider in future, so this part of the system might become more accessible.

The Norns isn't just a product, it's a combination of instrument and platform, and rewards investment.

Playing

In order to get a sense of the breadth of scripts available for the Norns at the moment, I set about auditioning some of those that came installed on the device, as well as some listed in the package manager.

Awake is the initial default program, a simple step sequencer with a visual row for pitches and a second one for transposition: the rows can be different lengths to introduce phasing patterns. A Monome grid can be plugged in for easy programming, though the script can be controlled purely by the Norns' encoders and buttons. It uses the PolyPerc synth engine, providing some basic synth parameters (pulse width, release, cutoff), and there's a delay line leading into a reverb.

Meadowphysics is a sophisticated polyrhythmic counter-based step sequencer, based on the Eurorack unit of the same name. It requires a Monome 128 grid for programming or playing. I didn't get deeply into the programming over and above changing some of the tunings and loop lengths, but the various abstract displays on the grid matched those in the user manual for the hardware version. As well as the internal Norns sound engine (it uses an engine called PolyPerc), Meadowphysics transmits MIDI and supports MIDI clock. This temporarily stumped me as I didn't have any USB MIDI sound generators to hand for testing, but my iConnectMIDI2+ interface let me connect the Norns to my MacBook and route MIDI messages between them. Some experimentation in Bitwig Studio and Max proved that notes and clock data were passing back and forth, though I didn't manage to get DAW sync to work, probably due to some issue with clock stop and start messages, an issue which feels fixable.

Loom, another grid-128 program, is best described as a kind of two-dimensional pattern generator, inspired by textile weaving, with notes travelling horizontally and triggers vertically. It makes use of a custom synthesis engine called Molly the Polly (from another third-party script), which provides some LFO control and a noise source.

The above-mentioned mlr seemed to work as advertised: I recorded a simple drum loop into the box and spent a happy hour varying sample selection and speed on multiple tracks via the 128 grid. To use it seriously (unlike me) you'd have to properly sync the sample length to mlr's tempo.

Rolling the dice in the PassersBy synth.Back in more conventional territory, PassersBy bills itself as a "West Coast–style mono synth", so I duly plugged in a MIDI keyboard and discovered all sorts of FM, wave-shaping and overdrive goodness. MIDI pitch and pitch-bend controller were faithfully tracked, right up until I started hitting the randomise function (portrayed on screen as a the roll of a pair of animated dice). The custom synthesis engine can be loaded into other programs, so if you want to try some scripting but not dive deeply into DSP design, this would seem to be a valuable resource.

Box Of Delights

The Norns is an intriguing prospect: an attempt to harness the power of the computer into a neat and focused multi-purpose musical device with lots of scope for attaching control surfaces. It is clearly not for everyone: if you're not up for rolling your sleeves up and doing some coding, then you'll have to stick with using whatever scripts are already available, saving preset states as you go. The encoders and buttons form a pretty sparse performance interface, so you'll also need to think about what control surface(s) to attach, and what scripts support them.

If you are a coder, or are willing to learn, the Norns' appeal is clearer. For the $800 it costs, you could source a cheap laptop and run SuperCollider, but you wouldn't get the minimal, focused design where all the hard work of audio and device interfacing has been done for you. The Norns isn't just a product, it's a combination of instrument and platform, and rewards investment.