monome apps for arc and grid

Jason Wehmhoener edited this page Mar 24, 2016 · 20 revisions
Clone this wiki locally

all-in-one

back to top

monome_sum

monome_sum is a collection of essential monome applications, synchronized together, creating a flexible environment for creating music. The apps are simplified for easy exploration with enhanced visual feedback for vari-bright grids. Expanded versions are available in the monome application repository.

gome is based on the original polygome by stretta.

utilities

back to top

Arc Tester

created by: JP

It's a diagnostic and debug patch for the Arcs. It just shows stuff coming out, and allows you to put stuff in. It's basically a pretty version of a bunch of apps that Tehn and Stretta floated about for testing, I was bored so I made this.

arcmouse

created by: galapagoose

allows your arc2 to move your mouse. primarily designed to edit parameters in ableton live with a physical control. simply click on the parameter with the mouse then turn the 1st encoder to move it up or down. after you've clicked you can turn the 2nd encoder clockwise to engage the 'command' key for finer control (but remember to turn it back after you're done!).

clippyclippy

This app requires monomebridge in order to work properly with serialosc.

https://vimeo.com/44410737

keyboard shortcuts in the code are set to MAC for windows, set shortcuts to control-c & control-v

USE

highlight text press a button on the monome to copy text to button

press a button to paste text

press upper right button for delete mode press buttons you want to remove upper right button again to toggle back to normal

fivetwelve

a collection of information regarding the five twelve, a special edition produced in april of 2010.

settings

with cables oriented towards the left, the 512 is two 256's side by side. the one on the left has a serial number of m256-?-0 and the right m256-?-1 where ? is your unique id. (yes, there are only 10!)

serialosc setup

The 512 appears as a pair of 256 monome grids. serialosc applications for the 512 address each 256 grid as a separate device.

monome serial setup

you edit the left and right half by accessing the dropdown in monomeserial.

to create a mapped 32x16 grid in monomeserial set both to cable left, unit-0 to offset 0,0 and unit-1 to offset 16 columns 0 rows.

to create a mapped 16x32 grid (with cables coming out the top) set both to cable top, unit-0 offset 0,0 and unit-1 offset 0 cols 16 rows.

applications

included in this repo (click download zip):

  • mlr 31 rows
  • mlr 32 steps
  • 512life

additionally, these two stretta applications support the 512 grid:

griddle

griddle is a splitter/spanner router app for grid devices.
meme is a gtk monome emulator with arbitrary size support.

griddle acts as a proxy between serialosc and your application. it's designed
to serve two purposes: create large virtual devices from physical monomes and
split larger monomes into smaller virtual devices (sizes down to 8 x 8 are
allowed).

to split a 128/256/512 unit, create several virtual devices in the
configuration file, each with the appropriate offset and link them to a
hardware device with a zero offset.

to join several devices into a single virtual device, create a virtual device
in the configuration file with a zero offset, and specify all the linked
hardware units with the appropriate offsets.

to create a mirror effect (my favourite), use the same config as the one
for joining, replace all the offsets with zeroes and make sure all your devices
(virtual and physical) are of the same size.

all the offsets have to be multiples of 8. 

have fun!
-artfwo



this repository includes the following third-party modules:

pybonjour (MIT License):
    Copyright (c) 2007-2008 Christopher J. Stawarz

pyOSC (LPGL-2.1+ License):
    Copyright (c) Daniel Holth & Clinton McChesney.
    Copyright (c) 2008-2010, Artem Baguinski <artm@v2.nl> et al., Stock, V2_Lab, Rotterdam, Netherlands.
    Copyright (c) 2010 Uli Franke <uli.franke@weiss.ch>, Weiss Engineering, Uster, Switzerland.

gridgoggles

|| Grid Goggles 0.01
|| by Raymond Weitekamp
|| Date:  12.4.11
|| Summary: A utility for synchronous visualization of time-dependent matrices.  Like a monome.
||         In development...pre-alpha.
||
|| Details: Currently for monome only.  Receives "/key" and "/led" messages on port 3030.  
||          Use AlphaNerd's SerialOSnoopy or Griddle to easily copy your OSC messages:
||          https://github.com/TheAlphaNerd/SerialOSnoopy--Monome
||          http://docs.monome.org/doku.php?id=app:griddle
||
||
|| Instructions for adding: There are specific sections of the code for adding new visualizations.
||       These are tagged with the symbol '@@@'.  
||
|| Note: Currently developed for Processing 1.5.1, and rendered with the GLGraphics library by CodeAntiCode
|| 
|| License: GNU GPL 2.0 (http://creativecommons.org/licenses/GPL/2.0/)


altitudesickness TODOs:
  -ADD ControlP5 for OSC port
  -ADD ControlP5 for specific visualization parameters
  -README

thealphanerd TODOs:
  -breakout examples as separate sketches
  -create csv to store list of different visualizations
  -make selection list modular to adapt to any number of items
  -create input for switching visuals
  -enable full screen
  -placement on second monitor
  -fix 256 placement
  -add gui element to select monome size

WISHLIST:
  -Lots more visualizations!
  -color picker
  -transitions between visuals
  -256 testing
    -test re-sizing
  -cross-platform, streamlined fullscreen mode

SOME IDEAS FOR VISUALS TO ADAPT/ADD 
  -space invaders!
  -particles.  too intensive? see "bouncy boxes": http://www.openprocessing.org/visuals/?visualID=6535
  -flocking
  -wavy?  could be cool? http://www.openprocessing.org/visuals/?visualID=16256

libmonome

libmonome is a library for easy interaction with monome devices. It currently runs on Linux (on which it is primarily developed), OpenBSD, and Darwin/OS X.

It was developed to make monome devices easy to use with programming languages like C and Python, and adding wrappers for use in your favorite language with a suitable FFI is straightforward.

libmonome has support for 40h and series devices through a unified API, and by default includes a third backend which wraps around the OSC protocol and presents the same API as a physical device. This means that a program written using libmonome can, at runtime, decide whether to communicate with a running monomeserial instance over OSC or whether to access the physical device directly.

monome base

a collection of various max/msp patches including:

basic test patch
midi routers (multi-mode, virtual sliders, etc)
various vu audio-visualizers
prefix routing tools
osc howto patches (primer to writing your own patches)
serial howto patches (making sense of the protocol without monomeserial)

monomebridge

use with non-serialosc apps

we have created a bridge (uses max5/6/7) which makes serialosc “look” like monomeserial. if you don't know what this means, you will certainly have zero interest in using it.

monomeclass

A Chuck Class Object for the Monome

This app requires monomebridge in order to work properly with serialosc.

This object encapsulates most of the core functions for communicating between your monome and Chuck.

Created by: Raymond Weitekamp

http://vimeo.com/3426555

Example Code

Test

Monome m;
m.monomeSize("64");
"/test" => m.prefix;
m.go(); //resets the prefix

spork ~m.testPush();

while (true){
  1::second => now;
}

MidiPush128

//-----------------------------------------------------------------------------
// author: Raymond Weitekamp
// name: midiPush128.ck
// date: 8/10/08
// desc: Each button sends a unique midi noteOn when pressed and released.
//-----------------------------------------------------------------------------
Monome m;

"/midipush" => m.prefix;
m.resetOsc();//same as m.go() now.

m.monomeSize("128h");

m.midiEnable(1, 0, 0); //midiEnable(on?, device?, channel?)
//use "Chuck --probe" in terminal to see available midi devices

spork ~m.testPush();//lights up when pressed

while (true) {1::second => now;}//do stuff

Tilt

//Setup
Monome m;
m.monomeSize("64");
"/tilt" => m.prefix;
m.go();
m.clear();
//--

//variables
float xPos, yPos;
int xGrid, yGrid;

//enable accelerometer
m.accelEnable();

//invert my accel values for both axes...
[1,1] @=> m.invert;

while (true){
    //wait for the accelometer "polled" event
    m.polled => now;

    //extract the tiltmap position
    m.pos[0] => xPos;
    m.pos[1] => yPos;

    //print
    <<< xPos, yPos >>>;

    //translate to our monome size
    (xPos * (m.xWidth-1)) $ int => xGrid;
    (yPos * (m.yHeight-1)) $ int => yGrid;

    //print
    <<< xGrid, yGrid >>>;

    //clear the leds
    m.clear();

    //light up our position on the tiltmap
    spork ~m.ledSet(xGrid, yGrid, 1);

}

monome_community

created by: raja

Summary: This is a max-external, you create your own app with it.

This is for quickly setting up interfaces on your monome to detect any combination of presses(technically speaking, if you can press up to the same number of buttons your monome contains(64? 128? 256? 512? 1024?...) this object will help you detect any number of finger-combinations for that number of buttons(the object itself only detects up to a 4x4 grid(16 buttons total at once) but by setting up many of these objects, you can cover any key-press combination on your entire monome).

Detailed Description:

You give the object 2 arguments which causes it to detect a grid of 4 by 4 buttons(16 total) whose TOP-LEFT coordinate is the argument you give. example: will set up a grid whose top-left starts at column 2(index starts at 0 so it is physically the 3rd column over), row 3(index start at 0 again so it is physically the 4th row down).

You can then mash your monome buttons within that grid and the object will output a binary-based ID-number which you can use as a message identifier. Keep in mind, the object polls all buttons pressed within the 4x4 grid when pushing down, and then outputs the identifier once those buttons are released.

Further example: say you create the object as , without arguments it defaults to 0 0(top left of your entire monome(depending on your cable orientation being left)). Press the top-left button only(1 button), the object outputs '1'

Top-left button + 2nd column over(same row; 2 buttons at once), the object outputs '3'

Say you grow 16 fingers and mash all 16 at once, the object outputs '65535' and so on and so forth(to detect between two or more different objects(more than 16 buttons at once or across multiple 4x4 grids), simply match up all the identifiers appropriately).

Use the specific number as an ID for that key-press combo and route it to a function in your app. See the help-file for more details.

The object can help you setup detection of your entire monome using multiple copies. Example - for a monome64, try 4 of these objects set like so: (defaults to starting at coordinates 0 0) (starts at column 0, row 4) (starts at column 4, row 0) (starts at column 4, row 4)

Added: 16rower.mxo and 16rower.mxe which works exactly the same as monome_community but in a row of 16(rather than 4x4 grid).

old download (everything in one folder: WIN = .mxe , OSX = .mxo) :

MOST CURRENT:

(sorry, OSX only these days, but the .c files are in there and it should be easy to download the max6 sdk: http://cycling74.com/downloads/sdk/ and alter one of the MSVisualStudio projects there to swap out it's .c file with one of these and rename its elements to the new object name)

Additionally included are 2 other objects from the old app "MonoMahna" which also aid in other forms of monome-button/led management.

All these objects simply take 3-element lists(for button coordinates and press state), so they have always worked for both monomeserial and serialosc, but the helpfiles in this version have been updated to connect via serialosc(instead of the old monomeserial) easily.

monomecontrol objects

This app requires monomebridge in order to work properly with serialosc.

Created by: James Drake.

A collection of abstractions written in Max/MSP 5 used to build monome interfaces. Documentation included as .maxhelp files.

http://www.vimeo.com/4504030

matrixcontrol

A drop-in replacement for matrixctrl. Use it when you want the functionality of matrixctrl without wasting loads of space in your patch.

monomebutton

Create buttons. Various styles, including features like button press quantisation.

monomeslider

Create faders that have fine control over your patches with various options for LED feedback. Requires matrixcontrol.

monomepage

Create multi-page monome apps with minimum fuss. Requires matrixcontrol.

monomectrl

This app requires monomebridge in order to work properly with serialosc.

While working on my current application, I became frustrated with using matrixctrl. It wasn't doing everything I wanted to be able to do, like send it binary rows, or handling getting rows and columns in a convenient way for updating the display surface. So, I rebuilt all of the functionality of matrixctrl from scratch.

The end result is /monomectrl/ a patch that you can use for all of your monome management needs.

You should be able to replace any matrixctrl in any patch that you've already made with this with no problems.

It features:

  • /Support for monome 64, 128, and 256/ - Now, by sending a 'mode 64', 'mode 128', or 'mode 256' message, you can dynamically change the way gets/updates are processed. Changing modes is non-destructive (the entire grid's data remains intact no matter how many mode changes you make), it merely reduces the processing required to get column and rows and generate monome update messages. Just resize the bpatcher to hide any parts that you don't want to see.

  • /tempcell/tempcellrow/tempcellcolumn/ - These methods automatically revert the previous cell message. The row and column versions do the same thing as tempcell, except they are row/column dependent instead of unique to the entire grid.

  • /Display Updating/ - On demand display updaing of cells, rows, columns, and full frames.

  • /Getters and Setters/ - Getting and setting of cells, rows, columns, and full frames with multiple techniques.

  • /Multiple Ouputs/ - Get cell data, row/column data (with and without row/column prefix), and update messages.

Check out the included test patch to test out all of the functionality.

I've done my darndest to weed out bugs, but chances are I missed a few. Please let me know if you spot any. I've tried to make it as fast as possible, but there will probably be some optimization in the future. If you see any spots that can be cleaned up, feel free to post code and I'll add it into the official release. Also, if there's some bit of matrixctrl that I missed, please let me know, and I'll try to add that in too.

I hope you find this useful. I know it will help me in my work. I hope it helps you too!

monome home

monome home collects information about all of the serialosc devices currently connected to your computer and displays it in a simple device list.

you can click on one of the displayed devices to select it and allow editing of its serialosc settings i.e host, port, prefix, rotation, tilt.

also provided is a simple testing section to check key presses and encoder deltas, and to test grid and ring leds.

requires serialosc 1.2 or above and max 6 or above. (zeroconf/bonjour is not used, so you do not need the externals installed in max)

Monome Protocol Jumper

created by: raja

A max patch for devs to use in their apps, given connection of device to serialosc.maxpat, to route /sys/id (serial-number) to appropriate monome protocol selection: 'mext', 'series', or '40h'; allowing devs to cater their app to the capabilities of different devices.

monomer

This app requires monomebridge in order to work properly with serialosc.

A Ruby library (and sample apps) for interacting with the monome using the Ruby programming language and osc

Created by: Sam Aaron, with contributions from Ullrich Schäfer

It is most definitely work in progress, is evolving rapidly, but is already great fun to play with :-)

Download

http://github.com/samaaron/monomer/tree/master

The library is stored in a publicly available git repository. This allows for excellent collaboration and development; feel free to clone your own version and send me pull requests so I can merge your changes to the master branch.

If all this git stuff sounds too much like hard work, you can always fetch the latest tarball from this link: http://github.com/samaaron/monomer/tarball/master

Installation

  • install JRuby version 1.1.2 or greater and make sure jruby is in your PATH (http://jruby.codehaus.org/),
  • launch monomeserial,
  • download monomer (the tarball would do just fine),
  • copy the mmj .jar and .jnilib files found in lib/java/ to /Library/Java/Extensions,
  • launch audio midi setup (found in /Applications/Utilities),
  • double-click on the IAC driver icon,
  • click on the little plus button to add a new port,
  • rename the two ports to in and out,
  • click the 'device is online' toggle at the top,
  • using the terminal navigate to the apps directory inside monomer,
  • decide which app to launch,
  • launch it with ./app_name.rb e.g:
  • ./blinken_lights.rb
  • make sure you have something set up to receive the midi (garage band will do),
  • enjoy!

Instructions

In order to use this library, you must have monomeserial running. The address pattern prefix will be automatically set to /monomer, and the cable orientation will be automatically set to up. Simply navigate to the apps folder in a terminal and run one of the scripts like you would normally run a shell script:

./blinker.rb

Or to force a particular interpreter:

ruby blinker.rb

Caveats

This library has been developed and tested using a monome 128 and on OS X Leopard. If you have any issues with the 40h, 64 and 256 monomes, please contact me and I'll help as soon as I can. Monomer requires the JRuby interpreter. It's much faster (with cool stuff like JIT support) and has a decent thread implementation. Make sure you're using v1.1.2+ If things aren't working on Windows and you know how to fix them, I'll be happy to receive pull requests. Also cable orientation other than up isn't available yet, although it is planned.

monome test

currently hosted on archive.monome.org and needs a new home

test suite for monome grids and arcs

monomic

This app requires monomebridge in order to work properly with serialosc.

A library by Jesse Kriss for the programming environment processing. Last update, 01/03/2009.

Monomic is a Processing library for the monome 40h.

The 40h is a usb serial device, but it also comes with an OSC driver. Monomic builds on Processing's Serial library and Andreas Sojamo's oscP5 library, and, as a result, can use either protocol.

Monomic provides straightforward functions for receiving 40h button events and turning the leds on and off, as well as advanced functions like setting led intensity and going in and out of low power mode.

mesh

mesh records live gestures into a large number of banks, allowing instant replay of past selves layered one upon another.

created by: trent gill (galapagoose)

http://vimeo.com/94991557

mesh allows you to capture any sequence of OSC messages as a gesture, stored and recalled from a monome grid. there are 63 nodes available for gestures, plus one function button (top-left) for clearing unwanted gestures.

mesh forwards all gesture input directly to the chosen client application (any serialosc capable monome application), and acts transparently when not playing back gestures.

example gestures can simply be a sequence of presses on the monome grid (either on the same, or a second attached grid), or movements / keypresses on an arc.

quickstart

** before starting, you'll need to update to the {{:app:serialosc:serialosc.maxpat-2014-april.zip|2014-april serialosc.maxpat}} or newer. ** see :setup for installation instructions.

  • open the mesh application
  • select your monome grid in the top serialosc dropdown
  • open your 'client app' (the app you want to control)
  • select your 'client app' prefix in the mesh window (bottom left)
  • you can now play your client app as normal

modes

mesh has 3 modes which are designed for different use cases and device sizes.

switch

designed primarily for 64 key grids, this mode switches between the mesh and your client application. to switch, tap the top-right key to view the other page.

split

currently supported by 128 only, this mode provides the mesh on the left 8x8 quadrant, and the client application on the right quadrant.

dual

for use with multiple devices, the primary grid provides access to the mesh. a secondary device, attached under 'to client', communicates directly to the client application, though can be recorded into gesture nodes in mesh. the second device can be either a grid or arc device.

in use

once you have selected a mode you can record a gesture

  • arm a mesh node by pressing any key in the mesh
  • the key will dimly light to show it is ready to record
  • perform your gesture in the client application
  • the key will fully light to show recording has begun
  • press the node again to end the recording
  • press the node again to trigger (and retrigger) the recorded gesture

only a single node can be armed at a given time. if a recording is currently underway when a new node is armed, the current recording will be stopped and saved, and the new recording will begin. this allows sequential gestures to be captured into separate nodes with a minimum of presses required.

in order to remove an unwanted recording:

  • hold the top-left mesh button (the 'clear' key)
  • press a lit node you wish to clear
  • the node's led will deactivate and is now ready for a new gesture

oscRedirect

This app requires monomebridge in order to work properly with serialosc.

(Please note that while I'm referring to Windows and Linux, this should work with any OS and in any direction. However, I only tested the configuration explained below)

This script allows you to redirect incoming messages to a remote computer.

created by: blen2r (P.E. Viau)

This type of application may already exist but it was an easy fix to a problem I had. Since my desktop runs Linux only, I'm not able to use the Max/Msp patches. Since I want to use my monome with Linux and Windows at the same time, I needed a solution to share OSC messages over my LAN. The solution I found was to use my Windows laptop to run Max/Msp but the LEDs wouldn't light up using ArduinomeSerial.

Using my script, I can take the OSC output of Max and send it to a remote computer. So my arduinome is now connected to my linux pc, using serial-pyo, and communicates with Max via my network.

To set this up you need to:

  • On linux machine, run serial-pyo
  • Config a new OSC application (Serial-pyo address: (NOT 127.0.0.1/localhost) port: 8080 / Application address: port:8000). Don't forget to set a correct prefix.
  • Set your device to use this application
  • On Windows PC, launch Max/Msp with desired application
  • Edit oscRedirect.py (using notepad) to reflect your configuration (remote="")
  • Run oscRedirect.py (python oscRedirect.py)

PUMA

This app requires monomebridge in order to work properly with serialosc.

created by: weng/Gwen

PUMA (PUredata Monome Abstractions) is a collection of objects/abstractions which goal is to ease and speed up the development of monome applications inside the Puredata environment.

Overview

Initial list of objects:

  • puma.press.switch: filter press events for further processing.
  • puma.press.repeat: filter press events and detect long presses.
  • puma.press.mono: filter press events and detects single pushes.
  • puma.led.toggle: display simple on/off leds.
  • puma.led.slider: display slider-like series of leds.
  • puma.led.monot: display transitional led (aka running step).
  • puma.led.mono: display a single led on a set.
  • puma.led.blink: display blinking leds.

Underlying concepts

All the objects define operation areas on the monome and accept at least these four parameters:

  • startx
  • starty
  • width
  • height

BUT there is an exception. There is always one! ;) The slider led object whose arguments scheme is:

  • startx
  • starty
  • direction (from 1 -top to 4 -left, clockwise)
  • lenght

In addition, some objects have extra arguments. More on this in the help file.

For convenience and consistency, even if the objects are mapped across multiple rows, it will output a single number to identify the position. For example if the object is mapped as follow: "start x at 0, width 4, start y at 0, height 2" and you press the second row - second column on the monome, the position ID will be 5 (the topleft most button of the object has the ID 0, no matter what the [start x] and [start y] of this object are).

Similarly, the led objects will accept the ID 0 to operate on the topleft most led of the defined area, and soforth.

Installation/Usage

Puma is a so called "library" of objects. It means that to use it you should put the extracted archive's contained folder in one of your Puredata paths. I guess Max/msp and Puredata share this "path" concept. If you aren't familiar at all with this here is how to proceed:

Running Linux (any distro):

Copy the folder inside /usr/lib/pd/extra/ (you will need to be root or super-user to do this).

Running Mac OS:

Right-click on your Pd-extended app > show packages content. Now browse to Contents > Resources > extra and copy the folder here.

Running Windows:

Copy the folder inside C:\Program Files\Pd-extended\extra\

(please someone correct this if not accurate, as I don't have a windows box).

Any OS:

You can alway put the library anywhere else, but it's a good default, since Pd-extended keeps all its externals and libs in the extra folder.

Now, in any case, you will need to add a path pointing to this puma folder. To do so, launch Pd, go to "preferences" in the menu > "path". There you can add path to the puma folder, save your preferences and you're set :-)

Note to the application developers: You don't need to package puma with your app. That way, people can take advantage of updates or bugfixes without needing to overwrite the old versions inside every app that make usage of the puma lib.

Just make sure people install the library before running your app. It is a dependency for those familiar with the linux packaging systems.

Of course, if you make significant changes to the objects, which your app rely upon, you can alway ship it with your app.

I strongly encourage people improving the library to commit/notify their changes in the puma thread. That way we can all benefit from your work. Please share the love ;-)

Download

The download archive contains the objects, a help file, which will show you how to use the objects, and a logo which is used by the help file, along with a README file and a COPYRIGHT file.

http://gwen.coffy.name/Puredata/Puma/puma-0.1.tar.bz2|puma-0.1.tar.bz2

Pages

Pages is a monome application that allows the simultaneous execution of multiple other monome applications on any number of devices. There are many built in applications as well, including MIDI interfaces (keyboard, triggers, faders, sequencers), Ableton clip launcher interfaces, and a way to easily script your own programs.

Pages speaks both SerialOSC and MonomeSerial protocols and can be used with any grid-like device that speaks either protocol. Any combination of serialosc and monomeserial applications can be used via the External Application Page.

The new zeroconf-less discovery mechanism is not compatible with Pages' External Application Page functionality, however it's fairly easy to make it work. To use Pages with new Max/MSP applications that use the zeroconf-less serialosc (ie. mlrv 2.3):

  • Follow the setup guide as normal.
  • In step 4, replace the serialosc.maxpat with the zeroconf-serialosc.maxpat (unzip the file, find serialosc.maxpat and copy it to your Max6/patches folder)
  • Install the Max5 zeroconf externals, see this page: http://monome.org/docs/app:serialosc:zeroconf

You should now be able to use these applications via the External Application Page in Pages. Max/MSP applications will function as normal but will be using zeroconf for discovery.

Pages 1 (old and crusty): http://post.monome.org/comments.php?DiscussionID=2447&page=1s

pauk on pages 2 from Pauk on Vimeo.

pauk on pages from Pauk on Vimeo.

new groovy pages demo from phortran on Vimeo.

pages demo / groovy pages from phortran on Vimeo.

pages demo / groovy pages explanation from phortran on Vimeo.

quadrants 2

created by: galapagoose original version by: bean

a device splitter to access multiple patches simultaneously

allows the user to attach a 128 or 256 and address up to 2 or 4 applications respectively. the device is split into 8x8, 16x8 or 16x16 grids with each area communicating with one application only. this version uses serialosc and does not require the zeroconf externals or bonjour to be installed on windows machines.

at present variable brightness commands are not supported. tilt sensor is available to the 1st (orange) app only. please report bugs to the forum post below.

SerialOSnoopy

SerialOSnoopy is a mod of the serialosc abstraction by Brian Crabtree that pipes all press data out on a secondary osc port. This gives you the ability to pipe monome data into multiple application to monitor input such as processing, super collider, or even another instance of max/msp.

Utilizing the mod is fairly easy. First copy the serialosnoopy.maxpat file into any monome application folder. Open the application and modify the patcher file from serialosc.maxpat to serialoscnoopy.maxpat.

There should now be a new S button available within the serialosc subpatcher, click it to set the port

NOTE Routed osc data is sent without a prefix, this will allow you to make open ended applications that can receive the SerialOSnoopy data from any application without needing modification

This patch uses an external called OSC-route which was developed by Matt Wright at CNMAT. http://cnmat.berkeley.edu/patch/4029 It can be found in the dependencies folder and should be placed in you max externals folder. This is the osx build of the external... so if you are on a pc you will want to get it from their website... download everything for you favorite platform

http://cnmat.berkeley.edu/downloads

shado

net.loadbang.shado Build Status Dependency Status

shado is a compositing and sprite library for the monome. It is written in Java, but designed to be dynamically scripted in a language like Python and hosted in MaxMSP (or Max for Live). The common usage scenario is to install shado alongside our Java Python interpreter in a MaxMSP system, and drive it via Python scripts triggered and controlled by MaxMSP messages.

To get a sense for what's achievable in shado, take a look at this video.

The file README.MANUAL will eventually be the manual for shado; for now, it contains an explanation of the shado architecture - quite possibly, along with the examples, just about enough to start writing shado "programs".

Documentation

The JavaDocs can be generated from Maven by

mvn javadoc:javadoc

The documentation is written to target/site/apidocs.

License

Distributed under the GNU General Public License.

Copyright (C) 2013 Nick Rothwell.

SkyMonome

This app requires monomebridge in order to work properly with serialosc.

SkyMonome is for Monome owners who want to easily program their unit in Java language. Based on the JavaOSC library, the SkyMonome library is a complete and evolutive API for musical and visual applications.

http://skymonome.org

Created by PJ Skyman on may 2009

Last update v1.3 on 2010/06/19

Description

The main goal is to facilitate Monome programming by manipulating simple virtual entities like leds, buttons, analogs, groups of leds and buttons, sequencers, frames, etc... You don't need to know the OSC protocol at all.

SkyMonome can manage knobs or accelerometers soldered on the Monome board. Its API is as modular as possible. Possible applications are graphical (clocks, vu-meters, spectral analyzers,...), musical (simple or very elaborated sequencers, beat mappers, Midi controllers,...).

Tutorials

smallbatch

currently hosted on archive.monome.org and needs a new home

created by: galapagoose

smallbatch acts as a virtual client/server system that sits on top of serialosc, allowing devices to talk to multiple applications, and applications to address only specific regions of devices. application switching is accessible via a key on the grid, and apps can be dynamically spanned across all or part of a device.

audio/sampling

back to top

64fingers

created by: dovemouse

Each button represents a sample or loop which can be triggered in one of 4 ways.

Features:

  • Five pattern recorders.
  • Midi sync and quantisation.
  • Note repeat.
  • Button linking.
  • Changeable OSC ports.
  • Settings page.
  • Clear all samples button.
  • Sound device and channel menu.
  • Midi note can trigger samples.
  • Row modifiers.
  • Waveform selection.
  • Preset saving.
  • Tap tempo.
  • Midi note out.
  • Multiple outputs (up to four stereo out).
  • Pitch/speed shifting by semitones.

64step

written by Peter Segerstrom

64step is a versatile sequencer/sampler designed for tight integration with the monome 40h. it is a more complete realization of step. please write peter a t flatflat.org for bugs.

WARNING: DOES NOT WORK IN MAX 7

angles

created by: t.gill

a simple tilt to midi-CC converter

captures analog output of up to 3-dimensional tilt sensors. each sensor can be turned on/off, have it's range inverted, and route the value to a midi CC of your choice.

there are two modes:

  • 'absolute' maps the physical device orientation directly to the midi-CC value. leaving the device stationary resets all values to mid-level.
  • 'relative' uses the device orientation to shift the current output state. leaving the device stationary freezes values at their current level.

calibration is dynamically calculated so no need to wiggle your device on load. all outputs are smoothed by a variable time to avoid unwanted spikes. settings save & load is possible by the 'write' and 'read' settings at top. settings should be saved to angles.json inside the angles folder.

Axiome

This app requires monomebridge in order to work properly with serialosc.

Concept

Axiome is basically a port of app:mlr. It has few main differences with the mother app though:

  • It is for now only developed for the 40h (but a port would be quite easy).
  • Made in http://puredata.info patching environment.
  • Samples are sliced -> pitch does not affect speed.
  • Stopping track does not stop pattern.
  • It has no audio recording capabilities (maybe in the future!).
  • No "quick-looping" functionality (you can achieve this by setting an appropriate record length...)

http://gwen.coffy.name/Puredata/Axiome

bigwing

created by: dewb

automatic whole-song beat/segment slicer for hands-on remixing with grid and optional arc using the Echo Nest analyzer API

http://dewb.org

bigwing maps all the beats of a single song to all the keys of a grid controller. beats are automatically detected using the Echo Nest analyzer web service. arc encoders can be used to scroll through the song, control playback/loop speed, volume, etc.

in addition to slicing a song by beats, you can also slice it into "segments", which in Echo Nest parlance are the smallest block of analysis, a short entity uniform in timbre and harmony. this can enable some resynthesis-like fun.

notes

  • Requires Max 6 / serialosc / OS X 10.6+
  • currently requires an Echo Nest API key (free) and a network connection
  • bigwing was designed to take full advantage of a 2012 16-level varibrightness 256 and arc4. Smaller grids and arcs will work fine. If you lack varibrightness or an arc, the experience won't be as awesome, but with bigwing 0.2 all functions should be accessible.
  • a modified version of en_analyzer~ built for Max6/OSX 10.6+ is included in the patch folder. Max will load it from this location; it is recommended that you NOT copy it into the Max folder, as it's still unstable. Windows users, see note below.

setup

how to use

  • open the Max messages window.
  • load any song under 40MB (wav, mp3, m4a ok.) this will freeze Max for a while while it uploads the track and waits for analysis.
  • check the Max messages window for a successful analysis result. it's likely that the analysis will fail the first time. try loading the same song again and it should succeed quickly.
  • press any grid button to start playing the song from that position
  • hold down a button to loop that beat or segment
  • click "beat" or "segment" to change the slicing mode
  • arc encoder 0 controls speed
  • arc encoder 1 scrolls through the file (if it has more than 256 beats/segments)
  • arc encoder 2 is reserved for future use
  • arc encoder 3 controls volume
  • uncheck "keep playing on key up" for a more synth-like experience.

media

  • video coming when it's closer to 1.0

known issues & future enhancements

  • bug: glitches in current song position indicator on grid & arc LEDs
  • bug: long pauses or crashes during upload (need to make analyzer call non-blocking)
  • move from groove~ to xgroove~, add pitch lock
  • in segment mode, use loudness/timbre/pitch data to shade the background
  • external clock sync, recognize non-4/4 songs
  • add preset storage/recall so already-analyzed songs don't need to hit the web
  • for songs with a short intro bar, use section analysis and/or add a "beat offset" user control to align beat 1 on the right side of the grid
  • add sequencing features
  • use encoder 2 for swing/filter/???

running on windows/linux

  • the modified en_analyzer~ has only been built for OS X 10.6+. It should be feasible to adapt it to Windows/Linux. There is an existing Visual Studio project to build the analyzer against Max 5. Dependencies include libjson-c, libsndfile, and libcrypt. code is here: http://github.com/dewb/en_analyzer

bigwing was created for Music Hack Day Boston 2012.

inspired by Paul Lamere's MHD Boston 2011 project "Bohemian Rhapsichord":

breakme

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

A simple sample cutter app. Possibly useful for people who have problems (I have) with timing presses in other sample triggering apps. The 64 key version of this starts playing a sample loop in 8 steps. If you leave it alone it will just loop forever, but if you start playing keys some parts of the sample will be replaced by others momentarily. The idea is that you set a position to rewind as many steps as the y coordinate, and then fast forward back again when that step has passed. After that step has passed, the setting snaps back to no rewind. If you set it to load a sample that is longer then the set sequence length (default 1 second), it will play the full sample, allowing you to cut it up in 8ths of a second.

The 256 key version gives you three sequences that you can cut up in this way, along with a sample selector in the fourth quadrant, allowing you to switch between four different samples in each of the “breakers”, plus an additional five sequencers (not accessible via breakers) that each can switch between four samples. The fifth column in the sample selector stops playing the sample in a row, the sixth column rewinds the sample in that row one eighth of its sequence lenght, the seventh column fast forwards, and the eighth column resets the sequence to the where it last started its led sequence. Each line will snap back so that all samples stay in sync if you leave the keys alone.

I've included some simple drum sequence samples with the packages (one sample with the 64 key version and three - kick, snare and hihat - with the 256 version). If you want to change the samples and their sequence lengths, search for “TWEAK HERE” in the source code and you'll see where you can put wav filenames.

Please post questions in the forum or to Stefan dot Blixt at that google mail service (I sometimes miss posts in the forum).

To run, unpack one of the zip archives somewhere on the disk, open a terminal and go to where you unpacked (use 'cd xx/yy/zz' where xx/yy/zz is the path). Then run 'chuck breakme.ck' to start up. Alternaterly, you can use the MiniAudicle, and set the working directory to where you unpacked files (or if you want to use other samples, set the working directory to where those are).

chuckstep

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

a version of the old “step” max patch, written in chuck.

it works the same as the original “step”, except it only has 7 channels, and the top row gives mlr-like control of the playback position.

to play with the crappy samples included, set the “current directory” box in the “miscellaneous” tab of the chuck prefs to wherever you put the chuckstep directory, or move the chuckstep directory to wherever your already-chosen “current directory”.

to load your own samples, put them in this directory (or direct the preferences to your own), and alter each of the ””somesample.wav” ⇒ b(something).read” lines to read your samples.

app by stephen, doku entry by kevin

N.B – i used the mini-audicle version of chuck, and it has a slider for bpm. it won’t run from the command-line unless you remove the code for the slider (OS X at least), and you’ll have to alter tempo by manually changing the line line “120.0 ⇒ bpm float;”

dj64

Created by Bitbasic

Dj emulation for the 40h / 64. Using 64 buttons, the user controls 2 decks, a virtual mixer, and several effects.

The functions of a typical DJ setup have been modeled in Max/MSP, and are controllable using the monome. As well as this, several effects can be used to add more versatility and creativity to a DJ set.

http://vimeo.com/1333520

electric dharma wheels

electric dharma wheels is a FM synthesizer for the monome arc. arc4s are preferred.

created by: stretta

http://vimeo.com/21596928

flip

This app requires monomebridge in order to work properly with serialosc.

Original written by Peter Segerstrom

Current Version by Axolotl

_flip, a multi-voiced reslicer.

flip is a program that allows you to cut up sound files into rhythmic units and reorder them to be played back as a pattern. you can save pattern states and then recall them there by varying the playback of a drum sample for example. really that's what this is best for... drums.

frost

created by: dataplex

frost is an max/msp/jitter patch that's great for making harmonious soundscapes on the fly.

from the documentation

  • each first row cell will freeze a spectral window of whatever passes through, resulting in a continuous spectral representation of the original signal.

  • column buttons will pitch shift the frosty drone captured before.

  • due to cpu overload on my machine, the first and last columns are monophonic...

http://www.vimeo.com/klive

grainslide

This app requires monomebridge in order to work properly with serialosc.

multi-loop, non-quantized sampler with independent speed/pitch controls and delay

created by: jared smith -- http://jaredsmyth.info

Four groups of sample loop playback, a+b for each group

Eight sample banks total

Dynamic control over sample length through a series of draw functions within max/msp GUI: Can be used as waveform synthesis by drawing in millisecond looping, and drawing your own waveforms

Four global pitch/speed time controls

Four global REVERSE pitch/speed controls

&

Four pitch/speed controls for each (a+b) sample

Four L/R sliders in center of 64 grid for control of sample delay playback over each of the four groups of samples

and drag-n-drop functionality for folders of wav, mp3, or aiff, samples

http://vimeo.com/18332486

grainstorm

created by: stretta

grainstorm is a four voice granular synthesizer for grid and arc. grainstorm maps all functions to a 64-button size monome so any monome grid will work. Both arc2s and arc4s may be used but arc4s provide additional control over grain duration, volume and filter.

loopy

This app requires monomebridge in order to work properly with serialosc.

/loopy/ (adjective): 1) having or characterized by loops 2) crazy, bizarre

/loopy/ is a Pure Data based sample player for use with a monome combining a large sample bank and multiple trigger modes - momentary, one-shot, loop - with flexible recorders and simple mlr-like sample cutting. Each row can be defined independently to function like a multi-sample one shot player or a bank from which to choose a sample to be sliced.

created by: bongo

prefix: loopy

full documentation: http://www.bongoware.com/documentation/loopy_help.html

overview

/loopy/, written in the open source Pure Data (pd) environment, provides a bank of 56 (7 rows x 8 columns) which can be triggered in momentary, trigger once (one-shot) or loop modes, and also can be sliced in mlr-like fashion.

/loopy/ also provides 7 recorders, which can record button presses, internal audio and external audio; and once recorded, loops can be assigned to sample bank buttons.

/loopy/ features

  • Standalone pd application, requiring pd extended & your samples only

  • Monome configuration: 64 or 128H

  • 56 sample bank locations (7 rows x 8 columns)

  • 7 recorders, each of which can record button presses from all rows, button presses from a single row, audio from all rows, audio from a single row, or external audio from a number of input channels. Once audio is recorded, it can be assigned to a sample bank location or saved to an external wave file for future use.

  • Each row can be played in 'multi', 'single' or 'cue' mode

  • Each sample can be triggered in 'momentary', 'trigger' once or 'loop' modes

  • When in loop mode, 'sub-loop' capability allows a portion of a sample to be looped.

  • 'Repeat' feature allows a button press to be automatically repeated on a quantized beat, providing a stutter effect.

  • Quantization can be set globally or by row, and can be turned on/off at the individual sample level

  • Save/load of sample sets and configuration parameters

quick start

IF AT ANY TIME YOU WANT TO STOP ALL SOUND, PRESS AND HOLD FOR 3 SECONDS THE TOP LEFT BUTTON ON THE MONOME OR CLICK THE BUTTON ON THE MAIN loopy SCREEN WHERE IT SAYS 'stop all.'

  • Select Audio setting... from the pd Media menu. Set output device 1 to your active sound device.

  • Select monome layout (64 or 128) on left side of the main //loopy// screen.

  • Click to send prefix setting to monomeserial (prefix is /loopy) on the main loopy screen.

  • Click 'load' to select audio file for sample 0 in row 1 (top left) on main //loopy// screen.

  • Press and hold leftmost button on second row of monome to begin playback. Release button to stop.

  • Click row mode 'single' for row 1 on right side of main //loopy// screen. Then click sample mode 'L' (for Loop) just above this. Tap and release leftmost button on second row of monome to begin playback. On 128 led's should sequence on right hand side as sample plays. On 64 tap top left button on monome to toggle to 'right' page, and led's in second row should sequence as sample plays.

  • Tap buttons in second row to to play (cut) from different points within the sample.

  • On 64 tap top left button on monome to toggle to 'left' page. On 64 or 128 tap leftmost button in second row to stop sample play.

help

full documentation available in the file 'loopy_help.html' found in the main //loopy// directory.

lpr

loop recorder for grid and optional arc

created by: stretta

Mash 2.0

created by: sean pierce (stevieraysean)

mlr style sampler for live looping interaction

m.a.t.e.

This app requires monomebridge in order to work properly with serialosc.

mlr audio tweaker/editor

description

mate takes advantage of max/msp's built-in waveform editor to make editing sound files for mlr more immediate, and hopefully convenient.

it allows for basic sound file trimming, as well as basic monome control, allowing for slice auditioning before saving the sound file for use in mlr.

instructions

  • turn on dac with the toggle (x) switch on the bottom right
  • click "replace" to load an aif/wav or "import" to load an mp3 using quicktime conversion
  • use the mouse controls to select the desired segment of the sound file
  • use keyboard shortcuts and a monome device to audition your segment. if you're using the monome, make sure you set the beats number box to properly match the number of steps you intend for the sample to occupy in mlr.
  • use the slider on the left to set the audition volume. this gain or attenuation only affects the audition, not the sound file.
  • optionally normalize the buffer (you may want to crop first), or use the dropdown menus to set grid reference and snap-to
  • click help to display this page
  • when you are done editing/trimming your selection, click the crop button to remove all other data from the buffer.
  • click write to save the sound file.

reference

keyboard shortcuts

  • space: play from selection start point
  • s: stop playback
  • l: toggle loop on/off
  • r: read an aif or wav file (replace)
  • m: read an mp3 file (import)
  • n: normalize to value indicated in the number box
  • c: crop buffer
  • cmd+a: select entire buffer
  • cmd+z: undo last selection change

wave editor techniques

  • clicking and dragging creates a new selection
  • shift+clicking modifies the current selection
  • cmd+clicking and moving left/right moves the viewer, moving up/down zooms in/out
  • ctrl+clicking moves the selection without changing its length

monome functionality

  • top row is a control row like mlr. currently only the top left button is implemented and functions like pressing the 's' key to stop playback
  • second row functions as an unquantized mlr playback row and depends on the number of beats.
  • all other buttons do nothing.

mlr

mlr is a live sample-cutting platform.

written by tehn

sound files are mapped across each row of the hardware interface where playback position is indicated by a lit pad. pressing a pad within a row jumps playback to this position. jumps are quantized according to a specified subdivision. sample playback speed is mappable to a global tempo.

multiple “groups” of sounds can play at once, enabling the user to have certain sounds cancel each other (like mute groups in a traditional sampler).

each group has its own level, mute and meter.

pattern recording module allows for recording and playback of key sequences.

a live input module allows clips to be captured in real time and immediately mapped to a row. complete feature list and documentation included with the download.

2.8 has a different file system. check the help for instructions. shift-click assigns the selected file (on the right) to the clicked row (on the left, default marked >> for empty)

http://vimeo.com/search?q=monome+AND+mlr - videos of mlr in use

http://vimeo.com/2045547- tutorial to sync with logic

FAQ

This page will be for general FAQ's that related to MLR. Initially I'll be adding questions and answers that already exist on the forums that seem common. If anyone has any additional questions that seem obvious, please add them at the bottom and hopefully they will be answered.

Q: Why are there 16 steps (8 grey ones, 8 white ones)? Is that only for bigger than 40h monome's or?

A: 16 steps IS for larger monomes

Q: When I drop in some files recorded at a certain tempo, why do I have to drop them down two octaves to get them to play back at the same tempo?

A: loops of different lengths require the octave switch, (not fully capable of explaining why) but once they are set, it makes no difference in playback

Q: Related to 2: It's quite unclear to me what happens when I change the speed for the 7 tracks? Like, sometimes if I just type in a 1 to get the audio to play back at original speed, it plays back at a completely different speed.

A: the loops will ALL play back at the given BPM no matter what you set the row to

Q: How about recording audio? I simply cannot work that out at all. How's it done?

A: to record loops.......you need to unmute your "input" and raise the volume fader....then just press "go" under the waveform viewer....if one of your rows is set to input1 then that will play whatever you just recorded........set the waveform viewer to input2 for another loop....etc..

mlr Alternate Versions

originally written by tehn

mlr is a live sample-cutting platform.

sound files are mapped across each row of the hardware interface where playback position is indicated by a lit pad. pressing a pad within a row jumps playback to this position. jumps are quantized according to a specified subdivision. sample playback speed is mappable to a global tempo. multiple “groups” of sounds can play at once, enabling the user to have certain sounds cancel each other (like mute groups in a traditional sampler). each group has its own level, mute and meter. pattern recording module allows for recording and playback of key sequences.

a live input module allows clips to be captured in real time and immediately mapped to a row. complete feature list and documentation included with the download.

other versions

  • v2.6.2AUX - adds support for auxiliary 64 w/tilt & fx, Max 7
  • v2.51 - same as 2.56 for monomeserial
  • mlr3pre - initial view of a potential mlr3.
  • aes edit - aditional groups, pattern recorders & live recording
  • soundcyst edit for larger monomes
  • delete_file.maxpat is included to remove files from an mlr save file

MLR AES Edit

created by: aesoteric

The AES edit expands pattern recording slots and recording control with modifier keys on the top row. Blinking preroll light/button to help you record live as well.

This is an alteration of the mlr program by brian crabtree. It adds buttons in the upper right to control alternate 1st row functions. One is 4 pattern recorders and one is to control input buffer, record start, view preroll start blinking light and change presets (I think!).

jmelnyk version

i worked on this version a lot last fall before i got my 256. there's all sorts of goodies in it. it was basically set up so that i could do anything i wanted in mlr without touching the computer, or ever even looking at it really. it also makes use of the accelerometer to tweak vst's. very fun on stage.

some of the mods include:

  • two mod pages
  • volume sliders for all four channels
  • storing of "sessions" and loading with a single button press
  • quantize change mapped to monome
  • half-timing, double-timing and reversing all mapped to monome
  • one-button-press recording with auto-assignment of record buffers
  • monome navigation through presets, complete with slider to indicate position
  • chain of four vst's with cc assignment; first four assigned cc's automatically mapped to accelerometer

there's prolly a few more i'm missing. anyway, dig in. i wrote this for my 40hSE but it just occurred to me (upon playing with it for the first time in months) that 64 users will prolly have a lot of fun with it. any issues, please let me know. and windows users, you may want to try the "_mlr" txt file instead of the "_mlr.mxb" file. i've had a few reports of the latter not working on windows boxes.

note: this should work on 128's and 256's (minus the accel, of course) tho you might need to modify it slightly first

Soundcyst

for larger monomes

the main difference between mlr_cyst and standard mlr is the functionality of the control row. while the standard release of _mlr256 adds 8 rows of samples to the 8 row version, it does not add any additional functionality to the top row, leaving 8 buttons unused.

by taking advantage of these 8 buttons, mlr_cyst adds the following features:

  • 2 additional groups (6 total)
  • 2 additional pattern recorders (4 total)
  • next and previous preset
  • recall the current preset's tempo
  • tap tempo

button layout

  • buttons 0 thru 5 - standard group indication/kill
  • buttons 6 & 7 - standard shifters 1 & 2 for volume, mute, and now patterns
  • buttons 8 thru 11 - updated pattern recorders
  • button 12 - previous preset
  • button 13 - next preset
  • button 14 - recall tempo of current preset (light indicates a mismatch between actual and preset)
  • button 15 - tap tempo and tempo light

updated pattern recorders

the pattern recorders in mlr_cyst take inspiration from bonanza's repeat, which is a complete overhaul of mlr focused on beat-repeating a la Akai MPC.

the pattern recorders now record group kills and group mutes.

by making use of the shifters, you can now stop a pattern without erasing it, recall the pattern, and overdub new hits.

to more briefly document this, the following will refer to button 8 as PR0, button 6 as S0 and button 7 as S1.

pushing PR0 operates just as before, activating the pattern recorder, and starting recording as soon as the next sample is triggered.

pushing PR0 again also operates as before, stopping and erasing the pattern.

if you've pushed PR0 and have a pattern recorded, holding S0 and pushing PR0 will stop the pattern. this function is not a toggle, so after P0 is stopped, holding S0 and pushing P0 will not do anything. to re-activate the pattern, let go of S0 and push PR0 again.

if PR0 is playing a currently recorded pattern, holding S1 and pushing PR0 will enable overdub recording. overdub recording will start as soon as the next sample is triggered, similar to regular recording. this button combination will not do anything if PR0 is stopped or empty.

holding both S0 and S1 at the same time and pressing PR0 will erase the pattern even if the pattern is stopped. if the pattern is playing, this has the same functionality as simply pressing PR0.

multi-track recording

the other new feature is the option to record each group's output as a stereo aif file.

to do this, open up the options window, as you would to record standard output. you'll see that there is now a checkbox to the left of the save button.

check this box, then click save and enter a name for your files. mlr will automatically create 6 files in the location specified named "the-filename-you-entered group 1.aif" thru "the-filename-you-entered group 6.aif"

click "start" to start recording, and then "stop" when you are done, as usual.

there is a possibility that these files may be off from each other by a few milliseconds, so you may have to do some nudging once you bring them into your daw.

mlrv

mlrv is a sampling instrument for grid-based music contollers like the monome, livid ohm/block, novation launchpad, and akai apc/mpd. the software allows a sound file or live recording to be mapped across each row and assigned a triggering behavior. within this simple set of constraints and a complete MIDI + OSC remote control system, the performer of electronic music can be freed from the laptop, and at the very least appear to be doing something interesting. mlrv is an refactoring of brian crabtree's original mlr, extended by trent gill (galapagoose) and michael felix (%) of /parallelogram/

Molar VSTi

This app requires monomebridge in order to work properly with serialosc.

http://xferrecords.com/molar

created by: steve_duda

prefix: edit in config file Plug in for the monome with audio abilities. Molar is an extended version of the MonoChrome plugin. Both plugins allow you to sync to host tempo and generate MIDI sequences of notes, or use your Monome like a MIDI keyboard.

However Molar also allows you to load AudioFiles as loops or one-shot, and/or capture/manipulate a live Audio Input signal.

Unofficial Molar VSTi Functions Overview:

http://www.google.com/base/a/4740701/D3875723320633660989

Molar is donationware - paypal steve (AT) duda.org

tutorials:

http://youtube.com/watch?v=T0ioVm1sK9s

media

http://youtube.com/results?search_query=Molar+VSTi&search_type=

Monolase

created by: (Rodrigo Constanzo)[http://www.rodrigoconstanzo.com] based on Cocolase by (ciat-lonbarde)[http://www.ciat-lonbarde.net]

8-bit modulated delay/sampler based on the ciat-lonbarde Cocolase.

Features:

Two 8-bit sampler/delays being modulated by a "Sidrassi" brain, consisting of five oscillators which can be audiorate or LFO, and triangle or square. These modulation sources can be patched to different parameters (as well as each other) to create complex patterns. There are an additional three "rambrains" which are some of the oscillators sampled at the rate of other oscillators, for even more complex waveforms.

Each delay/sampler has control over input, feedback, and pitch. You can patch the modulation sources to "flip" which controls playhead direction, "skip" which controls playhead position, and "afec" which controls playback speed.

Instructions:

Top Row are modulation sources. They are variable rate oscillators that can be LFOs or audio rate and triangle or square.

They can be patched to themselves or to various parameters of each cocolase module. The parameters are "flip" (changing direction), "skip" (jumping position) and "afec" (playback speed).

You can adjust the "ip" to control how much flip/skip are effected, and "afec" to control how much the speed is effected.

  • Rows 2-7 are the parameters for modulation.
  • Row2 - flip for cocolase2
  • Row3 - flip for cocolase1
  • Row4 - skip for cocolase2
  • Row5 - skip for cocolase1
  • Row6 - afec for cocolase2
  • Row7 - afec for cocolase1

Row8 contains the playback controls. These are two identical sets of 4 buttons.

  • Button1 - cocolase engage
  • Button2 - play/stop
  • Button3 - sound/silence
  • Button4 - delay/sample

The sound and functionality are modeled after the hardware Cocolase (which I own) and it would help to read the manual linked below to get a handle on the device a bit more.

http://vimeo.com/34830353

mothership

created by: Declan Murphy

http://vimeo.com/41663708

Visual Musical Playground for 40h (64) + Arc2.

Features:

Mothership is a software instrument made for people who dig loops and enjoy improvising live.

It utilizes the mlr functionality that has become synonymous with monome-based music, chromatic keyboard function (for jamming / creating bass lines), and an FX control for loops (like SP404s + other popular samplers).

Instructions:

MAKE SURE TO CONNECT THE GRRRRIDDDD FIRST! IMPORTANT FOR THE LED BANGBANG. :)

The grid is divided up into three component parts:

The first three rows are mlr-style sequencers that buffer loops (be it melody, bass, drums, etc.).

Rows 3-6 work as a midi-keyboard ideally sent to a VST that would trigger sounds of your choosing (Ableton Live drum kits, Massive wobbled bass, etc.)

Also, three buttons on Row 4 (1 + 2 + 7) are the Group OFF buttons for the MLR groups 1, 2 + 3 respectively.

Row 7 is an FX controller, dependent on what effect you have selected from row 8, it works with button presses, but is much more smooth on the Arc's first encoder.

Row 8 has two functions - the first and last buttons (1 + 8) are octave down and octave up (respectively) for the Midi Keyboard (rows 3-6).

Arc Mapping:

Encoder 0 controls different FX when toggled with the middle 6 buttons of Row 8 on the grid.

Encoder 1 controls the Master Volume for the three MLR groups.

ALSO grab the samples!

npc

This app requires monomebridge in order to work properly with serialosc.

the mpc application for monomes!

by Peter Segerstrom -- http://flatflat.org

requires maxmsp 4.6 runtime or full version (max5 experimental) and monomeserial + any size monome

http://vimeo.com/1864382

QUICKSTART

open a recent version of monomeserial

set the address prefix in monomeserial to 'npc'

download, unzip and open npc in max 4.6 runtime or full version from cycling74.com

Make sure audio is on in the upper left hand corner of the npc window by clicking the audio button.

Drag sounds onto waveform display directly below 'VOICE'

Click 'OPTIONS' in the upper left hand corner and then click GENERATE under the heading PAD GENERATOR SLICER

Taps some pads on the lower half of your monome and start playing!

hit return to start playback. click the off button next to the click button to turn on the metronome.

hit a button on the upper half of your monome, then hit the space bar. then hit the R key.

tap out a pattern with the pads. your pattern should be recorded. IF you made a mistake hit the c key twice. replay your pattern.

unmute a different track. hit the spacebar to select that track. hit r again to go into record mode. tap out a pattern using different pads.

hit a pad that has a sound you'd like to fix. hit the V key or the enter key. the data for that voice should come up in the voice area. edit away. repeat.

NPC README

This program is a rough emulation of the software of an akai mpc. It utilizes the open source hardware developed by monome.org. Below some basic definitions are outlined along with step by step instructions for creating a piece of music with npc.

sound / sample - these are either wav or aif files that you drag and drop onto the main waveform window of npc. each sample can only be heard in npc if it is used by a voice.

voice - voices are the intermediate step between a sample and a pad on your monome. you must either hand make or generate voices via the options window, and then assign these voices to a pad. voices use one sample each and have the following parameters.

  • sample - the sample or sound assosciated with this voice
  • volume - this is the volume that you will hear the sample you have selected for this voice
  • panning - the panning of this voice
  • envelope - the 5 point adsr envelope for changing the attack and decay of this sound.
  • start point - the beginning point of playback within the sample defined by the selection in the waveform window
  • end point - the ending point of playback within the sample defined by the selection in the waveform window
  • loop toggle - this specifies whether the sound loops plays in one shot mode.
  • if loop is on, the length parameter dictates how long you will hear the voice regardless of the start and end point selection of the sample. - the envelope is consequently mapped to the the length value as well.
  • if loop is off, the sample will playback in oneshot mode, and the envelope is mapped to the length of the selection within the sample.

loop length - the length of time you will hear the sound if loop is enabled. pitch - the pitch of playback. in standard 12 note tuning fine pitch - this will interpolate between half steps by 100 cents reverse toggle - this will reverse the playback of the sound output routing - this specifies which output the sound will playback through, and consequently which group of vsts the sound will playback through. all sounds that have the same output routing are globally controllable by that channels volume.

pad - a pad refers to the pads on your monome. to hear sound from npc you must have one or more voices assigned to a pad and then press that pad. you may create several voices and then select a pad and click the 'add to pad' button to add multiple voices to one pad. to edit each voice simple hit enter or v to toggle between the various voices on the selected pad.

currently the pads you have access to are on the bottom half of your monome, while tracks are on the top half

track - a track is a recording of a playing one or more pads. to record a track, unmute it by hitting the button. it should light up, you may then hit the space bar to select that track. you will see the track number and it's row and column value updated in the npc window. hit the return key to begin playback and hit the r key or record on the screen to begin recording. tap various pads to hear them recorded. quantization is on by default but can be turned off in the prefs text file in the npc folder and of course toggled in the npc window itself. each track can have an independent length and the default length can be set in the prefs text file.

pd_mlr

This app requires monomebridge in order to work properly with serialosc.

pd_mlr is Pure Data based sample cutter based upon the original mlr (thanks Tehn).

created by: bongo

prefix: pd_mlr

overview

pd_mlr is a sample cutter based upon the original mlr (thanks Tehn), the work of Gwen (Axiome) and @ucacjbs & @smioliolio (pd and max mlr tutorials, respectively) written in the open source Pure Data (pd) environment. I undertook this project to 1) learn more about pd; and 2) to create a sample cutter for my 128 with more groups and more recorders.

pd_mlr features:

  • Monome configuration: 64, 128H, 128V, 256

  • 4 groups + 4 recorders for 64 or 128V; 8 groups + 8 recorders for 128H or 256

  • each recorder can record either button presses or audio; recorder length adjustable from 4-32 beats; recorder can toggle play/stop

  • quantization

  • "intelligent" sample load, which finds nearest multiple of standard beats

  • save/load of sample sets and configuration parameters

The implementation of some of these features is unorthodox, so read the help file (click mlr_help box) for details - especially for the pattern recorders.

help: full documentation available by clicking 'mlr_help' button on bottom left of main application screen.

plane m vi cv

scrolling monophonic diatonic step sequencer with MIDI and CV outputs

created by: stretta

plane m | vi | cv is a monophonic diatonic step sequencer. Scale degrees, not notes are presented on the monome grid, which are then passed through a diatonic transposition mechanism which can be altered and transposed in real time. If you're looking for a chromatic or polyphonic step sequencer, please see plane p.

requires a monome grid (any size) arc is optional (scrolling via mouse, keyboard or powermate is supported)

warning: plane relies exclusively on led/col messages to light the grid. monome emulators (arduinome, launchpad) may not work, or, at best, produce extremely sluggish scrolling response due to how the monome firmware is optimized to deal with this message.

Installation

move

sigmund~.mxo
sigmund~.maxhelp

to

max 5/cycling '74/max-externals

http://www.youtube.com/v/OfFyvh_BGN8

The current version of Plane is now maintained as part of Beap:

http://github.com/stretta/BEAP

plates

scrubbing playable LFO

created by: tehn

includes main version, plus 'HD version' by bar|none.

portamentos

created by: stretta

designed for the monome 64 and arc2

The grid displays several parameters (pitch, amplitude level, attack, decay, portamento time and filter cutoff) per step. Instead of using the grid to enter in data, which would be fairly coarse, the grid is used to indicate which step (vertical) and which parameter (horizontal) is in focus. The parameter value is abstracted twice, both on the grid and arc ring. Once any parameter is selected on the grid, the value for all visible steps are displayed.

http://vimeo.com/25914275

randrum

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

Randomly generated step-sequencer

Created by: Pat Cannon (Beep on the forum)

Prefix: /randrum

Button '0 0' selects page one, where you control the placement of samples 1-7. Each row has one sample assigned to it and the columns decide how many times the sample will play in 8 measures - column 0 for 0 times, column 1 for 1 time and so on up to column 7 for 7 times.

Button '0 1' selects page two, where you control the placement of samples 8-14 and this page works the same as page one.

Button '0 2' selects page three, where you control the volume output of samples 1-7. Each row has one sample assigned to it and the columns decide the amplification of playback, 0 being the quietest and 7 being the loudest.

Button '0 3' selects page four, where you control the volume output of samples 8-14 and this page works the same as page three.

Button '0 4' selects page five, where you control the pan of samples 1-7. Each row has one sample assigned to it and the columns decide the stereo position of the sample, column 0 for hard left, columns 3 & 4 for centre and column 7 for hard right.

Button '0 5' selects page six, where you control the pan of samples 8-14 and works the same as page five.

Button '0 6' selects page 7, where you control the tempo of the step sequencer; the right 4 columns will slow the tempo down by 5 ms (column 4), 10 ms (column 5), 20 ms (column 6) and 30 ms (column 7) and the left 4 columns will speed the tempo up by 5 ms (column 3), 10 ms (column 2), 20 ms (column 1) and 30 ms (column 0). Every column has the same amount of control i.e. pressing button '0 1', '0 2' and '0 3' etc. will all increase the tempo by 30ms.

Button '0 7' is an on/off button for the step sequencer (which works the same as the 'Step Sequencer' On/Off Button on the display).

repeat

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

(mlr-style) live sample cutting with note repeat

created by: dominic christie

prefix: /repeat

key features: –4 groups (as in mlr) –4 pattern recorders (that can record group 'kills' –3 assignable repeater buttons –monitor mix (click+ group mix)

quick start (slightly more comprehensive manual included):

the app has 2 modes (indicated by by the top row/far right led)

in mode 1 (led off): first 4 buttons have same purpose as in mlr (group on/off) next 3 buttons are note repeaters. if one of these is held along with a button from an audio loop, then that part of the loop is repeated (just like holding down shift+pad on an mpc). each button can be assigned a different repeat length.

in mode 2 (led on): first 4 buttons can be used to record/playback button press sequences. double tap to put a recorder into 'record ready' (flashing led). recording starts upon the first button press. pattern playback can be turned of by simply pressing pattern buttons (not too quickly though). patterns are erased when put into record. repeater buttons act the same in each mode.

rove

rove v0.2:

    what is it?
        rove is a sample-cutter in the spirit of (and blatantly imitating) mlr.
        it is written in C and designed primarily to run on the linux platform,
        though, due to similarities between the platforms, it has been compiled
        and run successfully on mac os X.

        please keep in mind that rove is alpha-quality software at best!
        there's still much to be done to make it useful even in a basic setting,
        and it's a far cry from being production-worthy.  i can't guarantee that
        it will work for you, though i've yet to have a problem.

        rove has, thus far, been tested on a 32-bit linux system, a 64-bit linux
        system, and a mac os x system.    after installing the dependencies,
        it required no modification to function correctly.

        so, basically, i can't guarantee it'll work for you.  but it probably will.
        if it doesn't, holler at me.

    how do i install it?
        the dependency list is short, but, depending on your architecture,
        installation may prove to be a bit different than what you're used to.

        regardless of the platform, you'll need:
            - libmonome
            - JACK (http://www.jackaudio.org/)
            - libsndfile

        and, optionally:
            - libsamplerate

        the libmonome code is hosted at http://github.com/monome/libmonome, and you
        should build a recent git checkout to make sure you have the OSC protocol.

        if you're on linux, you might already have the latter three installed. if not,
        use your system's package manager to install both the main packages and the
        "-dev" packages for them.

        if you're a mac user, this may be a bit trickier.  you can grab JACK from
        http://jackosx.com/ and libsndfile from http://mega-nerd.com/libsndfile/.
        read the README and INSTALL files that come along with those projects.

        you'll need libsamplerate if you want to be able to change the playback speed
        of loops.  libsamplerate can be downloaded from http://www.mega-nerd.com/SRC/.

        if you're familiar with maintaining software on os X, please get in contact
        with me!  i'd love to be able to distribute a proper package of rove,
        but i haven't the faintest idea where to start.
        additionally, i don't have any mac computers on which i can test.

    okay, i've got that stuff installed, now what?
        run the following from the top-level directory (i.e. the one you got from git):

            $ ./waf configure
            $ ./waf

        then, you can install it to your system-wide bin directory if you want:

            $ sudo ./waf install

        or just run it from where it built:

            $ ./build/src/rove

    how do i use it?
        currently, rove has no GUI of any sort.  all of the configuration is done
        through text files in a fairly standard-looking configuration file format
        that's basically a windows INI file.  a session file looks like this:

            [session]           # comments start with a pound symbol and span a line!
            bpm      = 87.68    # beats per minute
            quantize = .25      # fraction of a quarter note to quantize to
            groups   = 2        # number of groups
            pattern1 = 8        # pattern 1 length (in beats)
            pattern2 = 8        # pattern 2 length
            columns  = 12       # columns to span

            [file]
            path    = drums.wav # path to the loop relative to the session file
            rows    = 2         # number of rows to span across
            group   = 1         # group to which the file is assigned
            columns = 14        # columns to span (overrides session columns)
            speed   = 0.5       # playback speed

            [file]              # loops are mapped on the monome from top to bottom
            path    = piano.wav # in order of where they appear in the session file
            group   = 2

            [file]
            path    = piano.wav # "path" and "group" are required parameters
            group   = 2         # but "reverse" and "rows" are optional
            reverse             # and are assumed to be "false" and "1" respectively

        the row spanning lets you spread a loop out across several rows for added precision.
        after you've created your session file, run rove with "rove <sessionfile.rv>".

        there is also an additional, global configuration file.  this file looks similar to
        the session file but has different expected sections and variables.  here is an
        example file, with the variables set to their defaults.
        all variables here are optional.

            [monome]
            columns     = 8

            [osc]
            prefix      = /rove
            host-port   = 8080
            listen-port = 8000

        save your configuration file as ".rove.conf" in your home directory and rove will
        load it at startup!

    what do i press?
               +-----------+ - - - - - +-----------+-----------+-----------+-----------+
          left |   group   |  many of  | pattern 1 | pattern 2 |   prev    |   next    | right
          side |    mute   |   those   | rec / tog | rec / tog |  session  |  session  | side
               +-----------+ - - - - - +-----------+-----------+-----------+-----------+

        at the moment, it's designed to mimic mlr.  the top row is the control row, with the
        first [number of groups in session] buttons turning off their respective group.
        activate a group by pressing a button associated with one of the loops, which means
        anything below the first row starting with the second.

        the two buttons after the group controls are pattern recorders, and these act a bit
        differently.  pressing the button without anything recorded waits until you cut
        somewhere in a loop to start recording, then will record a pattern as long as you've
        specified in your config file. you can press it again any time before the end of the
        specified length to play the pattern you've created. or, if the pattern length is 0,
        it will record until you press the record button again.

        pressing that button again turns the pattern off, resuming normal playback
        immediately. turning off recorded patterns deletes them, so that you can record
        again by pressing the pattern button and playing another sequence.

        the two buttons after the pattern recorders are session controls. rove can load
        more than one session. pressing these buttons moves forward and backward through the
        loaded sessions. this is good for seamless set changes, so that you can advance from
        song to song without having to stop and restart rove.

        you can load multiple sessions from the command line:

        $ rove session1.rv session2.rv

        you can also place multiple sessions in a single session file:

        $ rove big_setlist.rv

        a multi-session file looks just like a single session, except that you can add
        several sequential blocks:

        [session]
        ...
        [file]
        ...
        [file]
        ...

        [session]
        ...
        [file]
        ...

        and so on. rove loads sessions in order, from the top down.

        when performing with multiple sessions, bpm is determined by the currently loaded
        session. you can leave a group playing from one session, advance to the next session,
        and the old session's group will still play at the old bpm. once you press the group
        mute button for that old session, then that sample ends and is cleared, making the
        group available for the current session, at the current session's bpm.

        at the moment, this is pretty much the extent of rove's functionality.
        don't worry, more is coming soon!

    how do i get in contact with you?
        my email address is wrl@illest.net, and i'd love to hear from you.  questions,
        comments, encouragement, anything.  it's a great feeling hearing from people.

        please don't mind the messiness of the code or the general lack of polish presently.
        i figure that getting software into peoples' hands is the best way to find rough edges
        that i would otherwise miss, and it's the best way to get alternate perspectives
        on how an interface feels.

        thanks so much.
        -w

tessell

created by: sleepersecond

tessell is a sampling instrument. designed to work with complete songs instead of short samples. think of it as a virtual cassette tape player with standard functions such as play. stop. and loop.

once a song is loaded. by default the app loops the first 1000ms (1 second) of the song. now it is up to you where to put that 1000ms loop length within the loaded song thus you get that jumping or "repatterning" audio effect.

there are also a two built-in reverse effects;

1second reverse function (<); reverses your audio for 1 second, then plays back to normal

reverse all patterns function (<<); reverses all the audio

http://vimeo.com/48648385

The Chocolate Grinder

created by: Rodrigo Constanzo

http://vimeo.com/36277452

Skipping/glitching CD player emulation for Arc2 or Arc2.

Features:

The Chocolate Grinder is a software emulation of a skipping/glitchy CD player. You can record (or drop a waveform) into a buffer and then define a playback/glitch window.

It uses authentic skip/glitch samples at every jump point along with weighted randomness of sample choice to emulate several makes/eras of CD players.

The seek/fastforward is also faithfully recreated.

Instructions:

Each of the four modules functions the same way. You can record audio into the buffer (or drag an audio file onto the display area) and then you can control a glitch/playback window using position/window controls.

Jitter adds some randomness to the position/window parameters relative to window size.

Glitch adds CD skipping noises on each jump.

Arc Mapping:

First press starts recording audio, with the next press stopping the recording. Once audio is in the buffer pressing starts/stops audio playback. Turning effects position (via inertia/rotation) and press+turn effects window size. Press and hold for 1second clears loop and starts the process again

The Party Van

The Party Van is a live performance patch with dozens of modules and dsp effects covering a wide range of sampling, processing, and synthesis techniques. It is primarily programmed around monome and arc controllers, but has built in MIDI learn functionality (as well as mappings for TouchOSC, Keith McMillen Softstep, and Shbobo Shnth).

tml_refactor

tehn micro looper for 64/128/256 and arc2/4

created by: tehn, refactored by: stretta and tenmen

tonemap

This app requires monomebridge in order to work properly with serialosc.

created by: Amanda Ghassaei

prefix: tone

Tone map records the frequencies and amplitudes of an incoming audio signal as you drag your finger across the monome grid. In play mode these frequencies and amplitudes are re-synthesized when the lit buttons are pressed. Requires the pitch~ object, which can be downloaded here:

http://web.media.mit.edu/~tristan/maxmsp.html

put .mxo/.mxe file in Max/Cycling_'74/msp-externals/

put .help file in Max/Cycling_'74/msp-help/

windows also requires fftw3 (http://www.fftw.org/install/windows.html), see README in the pitch~ folder

Inspired by the IPad app "singing fingers."

wolves

created by: dataplex

here is a patch that will make your sounds howl and growl. the top row triggers chimes, made from sinusoidal peaks of the input signal. the next rows will do the same but also transpose each sinusoid by a harmonic interval.

start by turning the thing on

turn up the volume

select input (sample or adc)

and start howling at your monome.

audio/midi

back to top

64 Faders

created by: sean pierce

64 separate midi faders over 8 pages for the 64 monome

basically, select a midi channel to output from. the bottom row selects which 'page' of faders is in use. go through and map these to whatever daw you are using. the midi cc outs are listed on the app and you can adjust the slide speed (need a little work). uses the awesome monome control max5 objects by jim drake.

https://www.youtube.com/watch?v=Lmhsis_j_zQ

8step

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

8 step sequencer

8track

This app requires monomebridge in order to work properly with serialosc.

http://github.com/mha/8track

Introduction

8Track is a Roland X0X-style MIDI step sequencer with 8 instruments / tracks. It is best suited for percussion, as the instruments are monophonic and send out a fixed MIDI note (works well with software like Ableton Drum Racks or Native Instruments Battery). It is built on top of the monomer library.

Each instrument has 40 patterns available with individual lengths for polyrythmic fun and a randomization function.

You can change the currently playing pattern of an instrument without changing the playing patterns of other instruments (think Ableton Live session view).

It is also possible to save all instrument patterns and load them again at a different time, a feature strangely absent from most other Monome apps I have seen.

At the moment I have only tested the application with a Monome 64 on Mac OS X 10.6.4

created by: Martin Alexander Hammer (martin.hammer gmail com)

prefix: /monomer

Interface

1st row: Instrument selection

Push one of these steps to select an instrument. This will display the patterns of the selected instrument on the next five rows.

2nd to 6th row: Pattern selection

These rows display the patterns of the currently selected instrument. A lit LED indicates a pattern with steps entered while a flashing LED indicates the currently selected pattern.

When you select a pattern, it will begin to play (if the sequencer is running), and you will be able to edit the steps.

7th row: Pattern steps

This row shows the actual steps in the selected pattern. A step can have one of three states; off (LED off), on (LED on) and accented (LED blinking).

Each step's state is toggled by pushing it once. The "on" state sends MIDI velocity 75, while an accented step sends a velocity of 100.

Hold the first step button for a moment to randomize the pattern.

8th row: Sequencer control and status

The leftmost button starts and stops playback. If held for a moment, it will save the current patterns to disk (two flashes of all buttons indicate the start and finish of the save operation).

This row also shows the "running light" indicating the currently active step in a sequence.

The default sequence length is the entire width of your Monome, but hold one of the steps in this row to set the last step in a pattern (this does not affect the length of other patterns).

accord

This app requires monomebridge in order to work properly with serialosc.

"Accordion style chord mapping with built-in chiptune style arpeggiator."

Accord is named after its similarity to the left hand bass on a accordion. The vertical axis of the monome dictates the root of the chord, and the column number specifies the "chord" played. For example, the accordion is roughly set up like:

**C** | maj | min | maj7 | min7 | aug | dim | etc |

**G** | maj | min | maj7 | min7 | aug | dim | etc |

**D** | maj | min | maj7 | min7 | aug | dim | etc |

**A** | maj | min | maj7 | min7 | aug | dim | etc |

The chords in this app aren't restricted to the set above, rather the notes of the chord are editable - you specify the intervals from the root note in semitones. There is an internal clock, or you can sync to an external source. Pressing a button either triggers:

  • a very fast arpeggio, making the app ideal for chiptune type music, i.e. with basic monophonic synths.
  • or a single chord

todo:

  • preset saving
  • pattern editor

created by: ewan hemingway

more info: http://ewanhemingway.co.uk/programming/puredata-maxmsp/accord

prefix: /accord

http://www.youtube.com/watch?v=54iY-OalJwk

arpeggiator

http://vimeo.com/24764522

created by: Amanda Ghassaei

this patch allows you to move an arpeggiated chord around a 2D MIDI keyboard (fourths). pressing a button to the left or right of the chord shifts all the notes in the chord up or down by 5 semitones. pressing a button above or below a given note will move that note up or down by one semitone. pressing one of the notes in the chord will change the direction of the arpeggio. the velocity of the three notes and the speed of the arpeggio can be changed via max controls. virtual monome is included in the patch, but I have to admit it's much more fun on a real monome...

key controls

space bar = start/stop\ d/j = shift chord left/right\ r/f = move left note up/down\ t/g = move center note up/down\ y/h = move right note up/down

arpshift

A melodic, interval based, poly-rhythmic arpeggiator.

Created by: Edward Loveall

Quick Start Tutorial

  • Open MonomeSerial
  • Open ArpShift
  • Push some buttons
  • Hit the button in the top left of the monome
  • Also fool around with the top right buttons that switch to different pages
  • Make amazing music and show the world

In Depth Explanation

monome interface

  • When you open ArpShift, you'll see 3 buttons in top left that are lit up. One of them is blinking. There is also be a button on the top right of the monome that is solid. The 3 to the left are for switching among the app's pages and the button on the right is for start and stop.

  • This is a sequencer; however, it's not like normal sequencers. Think of each row (except for the top row) as completely separate. The rows do not interact with each other, nor must they have the same values. For example, the first row can be a phrase of 7, and the second row can be a phrase of 3. The only thing that relates the rows, is the master clock.

  • Aprshift has 3 pages. A length page, a note page and a pitch page. We'll start with button 2 on the diagram (the note page) first.

  • The note page is just like any other arpeggiator. If you touch any of the bottom 7 rows, a note will appear. Hit the start button (top right) and you'll hear the notes. You can put as many notes down as you want. All notes trigger a midi note at 127 velocity. You can set which pitch to be triggered in the app it self.

  • The length page (first page, button 1 on the diagram) is for controlling each row's length, i.e., how long until the row stars over. You'll see flashing lights going by and also solid lights to the right. The flashing lights indicate where in the timeline each row is. The solid light indicates how long each row's phrase is. Try changing the length of some rows. You'll notice that the pitches and general harmonic structure of the notes stay the same, but the rhythmic structure is ever-changing. This is one of the ways ArpShift is different from many other step sequencers.

    • Nerdy Math Side Note: If this wasn't a feature in ArpShift, it would repeat at maximum every 8 notes. At its most diverse settings, ArpShift can give you a pattern that is 40,320 (8!) notes long before it ever repeats verbatim. And that's only on the 64!
  • The pitch page (third page, button 3 on the diagram) is used to change the harmonic structure of the performance. Each row starts out at its initial pitch offset all the way to the left. By pushing the buttons to the right, you change the pitch by half steps. Wouldn't it be nice to move the pitch down instead of up? Well you can actually. If you put your pitches 7 semitones (or 15 semitones if you're on a 128 or 256) lower than your intended starting pitch, you can have the pitch offset start all the way right and work down from there. You could even start it in the middle.

max interface

  • To change the tempo of ArpShift, click and drag on the tempo box to reflect a new tempo. The default is a random number between 80 and 150 (inclusive). This is so you don't feel stuck writing at 120 BPM always.

  • If your Monome receives or sends data on an alternate port, you many change these ports in the osc in/out section of ArpShift.

  • ArpShift should automatically detect the size of of your Monome. If for some reason it doesn't, or you would like to change the size of monome that ArpShift is acting on, click the size number you want.

  • ArpShift can also manage sets of preset pitches, lengths and notes. To save a preset, pick a number for the preset then click save. If you want to load a preset, pick the number you'd like to recall then hit load. If you want to delete a preset, again, select a number, hit delete. Pretty simple.

  • ArpShift may be synced to an external clock. Here are instructions for syncing to Ableton Live. To sync ArpShift to an external clock to Ableton Live, make a new midi track and set the output to a destination that ArpShift can receive. You can check for those devices in the Clock Source drop down menu. Also make sure Ableton is set to send sync data to that destination in its MIDI Sync preferences. Then in ArpShift, select the that MIDI destination from the Clock Source drop down menu and select External from the Clock Type option. Now when you hit play or stop in Ableton, it will start and stop ArpShift. You can see if ArpShift is using an external clock source by the Start/Stop button. It will flash slowly to indicate it's using an external clock as opposed to the more rapid flash for internal clock. Note that when ArpShift is using External Synchronization, it uses 16th notes for its subdivision.

  • The prefix of ArpShift is (unsurprisingly) /arpshift. If MonomeSerial is running when you start up ArpShift, it will be set automatically. If not, click the button labeled ( /sys/prefix /arpshift ). Note that you may have to close and reopen ArpShift while MonomeSerial is open for the monome to display the correct LEDs.

  • ArpShift generates MIDI note data. To send this data to an alternate source for sounds, choose a device from the MIDI Device dropdown menu. You can also change the MIDI Channel that ArpShift sends on.

Media

http://vimeo.com/6770717

http://vimeo.com/6021893

autoharp

created by: Meng Qi

4 track autoharp with physical speed/resistance system

http://vimeo.com/44917498

8 chord slots, setting chord is easy with per note / per chord / all chords transpose buttons 4 tracks, each can select a different chord, note velocity, duration, resistance, midi output and channel 4 "strum" speeds in each direction (user configureable for full version max users) preset management system that remembers everything from chords to track parameters

have a look at the video for better understanding.

thanks to member GreaterThanZero for his physical speed/resistance code "throw" http://post.monome.org/comments.php?DiscussionID=13138&page=2

for full version max users, you can edit the message objects in the subpatch "pushforce.maxpat" to get the desired acceleration amount for each button

tutorials 1 - edit the chords 2 - select midi output device and midi channel 3 - adjust midi note velocity, duration and resistance to your liking 4 - select chord for each channel with 1-4 columns and drag/push the "playhead" with 5-8 columns 5 - enjoy

Balron40h

Created by: vladspears

Long description:

Balron maps 8-tone scales across the 40h grid, turning the 40h into a very compact midi controller.

  • multiple scales in a drop-down menu, with key and transposition settings
  • four bpm synced midi delays with time from unison to 8 measures
  • cell shift transposition on each delay
  • velocity setting for original and each midi delay
  • global release time extends played notes by specified ms
  • local clock or external sync

bends

This app requires monomebridge in order to work properly with serialosc.

multiple two-dimensional tilt-interfaced controllers

Created by: tehn

Prefix: /bends

Long description:

acts as a banked tilt accumulator-- only the selected banks (specified by held keypads) are updated with the current tilt offsets.

various output scaling can be applied. cc/ch specifiable.

both 64 tilt and 40h accel via ADC are supported.

axis swap and inversion supported. calibration and centering provided.

currently only eight "banks" added. (0,0-3) and (7,0-3). (first four rows of the leftmost and rightmost columns).

this is more of an example patch that can easily be added to other applications (if you program max/msp).

blinken park

written by stretta

blinken park creates random, modally-constrained MIDI notes (and lights) The monome button grid provides two axes of interaction: birth rate (how often new notes/LED form) and persistence (note/led duration).

It wasn't really designed as musical tool, it grew out of a need to create a long photo exposure of the 256.

http://www.vimeo.com/375548/

Bloon

created by: JP (made by robot)

Unquantized time based midi sequence looper with generative deviance

http://vimeo.com/15426222

Bloon app, based on the Bloom app for the iphone and ipad by Brian Eno. Pick the length of the loop in ms, press buttons on 256, button presses will loop.

X = notes Y = velocity

X scale can be changed from standard scales without affecting the loop.

App outputs midi.

If left alone, the app will become generative, each note can change +1, -1 stay the same on the X axis each time it plays.

boiingg

written by Jules (pixelmechanic)

a bouncing midi pattern generator

A basic but fun take on Tenori-On Bounce Mode, put together as an overdue exercise in teach-yourself-monome. Requires monomeserial set to /osc. Should be good for 40h, 64s, 128s & 256s, plus has virtual interface for monome-less operation. MIDI output only, and noteouts are adjustable from 0 to 127. Loads of fun with Ableton>Impulse (syncs to external host) and plays nicely in Max Runtime.

http://www.vimeo.com/709482

corners

a grid-controlled patch which lets the user play with gravity and friction. velocities, positions, and border crossings are mapped to sound parameters and events.

this patch can be used several different ways-- i intended it mostly as a drone machine with an organic and playful method to modulate parameters.

created by: tehn

http://vimeo.com/42313896

instructions

auto-configures for all sizes of grid.

pushing a key on the grid creates an attractor. the "puck" will be drawn towards this point. push multiple keys to create several attractors-- the puck will interact with all at once. the sides of the playing area can be reflective or wrap around based on the checkboxes.

  • friction: move to the right to increase friction, which will slow the puck down more rapidly
  • gravity: move to the right to increase to power of each key's pull
  • visualized: shows the position of the puck and the velocities
  • reflections: bounce or wrap, per side
  • preset: shift-click to save, click to recall. read/write preset files.

mapping parameters:

  • x,y,dx,dy: position and velocity. first col is the CC, second is the current value. you can mouse-change the "current value" which is helpful for auto-mapping from other apps.
  • r, u, l, d: right left up down. note events generated when the puck crosses/hits a side of the field. each side has its own note. duration sets note length. "stop" is sends midi panic.
  • 1,2,3,4: notes generated according to how many keys are held down. monophonic.

each section above can be on its own output port. this way the two note sets can be sent to different instruments.

this midi tutorial may be helpful:

http://vimeo.com/28742244

cygnet

written by stetta

cygnet is a real-time eight-track performance recorder. Notes are mapped to the surface of the 256 like fourths or mabalhabla. A foot pedal from a MIDI controller is required to start and stop the loop recording. A MIDI CC controller can also be used to record velocity or additional performance data into a track.

http://www.vimeo.com/376991

Daemon

created by: Anders Ekman

Daemon is an app that combines five step sequencers with tools for advanced harmonic control. It has a simple sine wave sound engine but can also be used in MIDI mode or a combination of the two. Each sequencer features independent tempo and the ability to sync to rewire.

Daemon was created to allow greater control over more traditional harmony and to let the user switch between chords with the press of a single button.

http://www.vimeo.com/8116251

decisions

generative maze run. trigger scripts to make midi note and cc data.

created by: tehn@monome.org

http://vimeo.com/60399628

ffflux

This app requires monomebridge in order to work properly with serialosc.

written by jason r kramer for the 40h or 64

prefix: /ffflux

description:

7 note sequencer, notes travel vertically in a variety of directions and are coupled with velocity. the closer - the louder. you can set the tempo at which they notes travel independently from each other. built with max 4

instructions:

  • set prefix to /ffflux
  • assign MIDI output for all channels as desired
  • push buttons

channel columns - each of the seven left columns are channels assigned independently to any MIDI device. their notes travel up, down or up and down getting louder (in velocity) the closer it gets to you. pressing a button within a column changes that channels tempo, which can vary greatly depending on the tempo range. the closer to the top; the faster, only just slightly enough to fall in and out of rhythm as the arpeggio grows. while a button is down it momentarily pauses that channel.

control strip - each of the seven columns from left to right correspond with the right most column's buttons from top to bottom. these buttons turn the appropriate channel on and off and light up when a channel is active. the bottom right button is multifunctional depending on the number of times it's pressed within a half second. after 1 second the function is realized (number of taps is counted) and performed. if you tap it once the direction of all channels is randomized, twice the release is randomized, three times the tempo range is randomized, four times the tempo range is uniformly randomized across all channels, and five times the notes are randomized. the range of randomization can be set for release, tempo and note from the three sliders on the bottom of the patch.

flickering lights

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

Flickering Lights is a step sequencer inspired by André Michelle’s Tonematrix with a nice looking wave-map.

Features

midi sync
support for custom scales via xml
based on java, thus platform independent (no max required)
multiple layers with per-layer volume settings
multiple devices supported

flin

cyclic music box

created by: tehn

flin is a cyclic poly-rhythm MIDI music box.

http://vimeo.com/418349

HELIX

created by: ds

helix is a live midi looping app for monome, pure data and either monomeserial or monomebridge/serialosc.

features:

6 separate pages.

7 loop rows, each with a loop clear, stop, rewind and stop, mute, pitch bend mute, scale mute and record function.

midi out channel select for each loop.

loop "multiply" select. multiply any of the 7 loops by the total millesecond length of the first loop. for example: you record the second loop, but you're a few milliseconds off, just select "1" and the loop will cut to 1 x the length of the first loop.

scale select - constrain your loop to one of 8 scales set up in the app.

midi program out select for each loop.

pitch select for each loop.

save scenes for pitch, scale, midi channels, program out and loop multiply to file.

save loops to file and load 'em later.

note: the download includes certain necessary abstractions.

insanity

created by: sean pierce (stevieraysean)

8 pages of selectable midi sliders or buttons

*the 8 columns in each page can be selected as a midi slider or a group of 7 midi notes. *

slider.

press the corresponding column on the monome to move the slider.

press and hold a slider button and press and hold/tap one above or below to move the slider by the 'fine' speed one cc per set ms (millisecond) time up or down. tap moves it one cc.

decay makes the fader decay back to zero after X number of milliseconds.

buttons.

buttons can be notes or cc's this is selectable by the cc toggle. X for cc.

'off' and 'on' correspond to the messages sent when the button is lit up or off. these also correspond the the 'midi led input' messages that can turn the leds on or off when 'M' is toggled with an 'X' and your DAW sends midi back to the patch through the 'Midi led input' port.

'tog' makes the button a toggle. 1 push for 'on' and one for 'off'. with 'tog' off, 'on' messages are sent on button press and 'off' messages on release of the button.

all sliders and buttons have selectable midi channels through "chan" and "ch" values

save your preset as faderconfig to load it by default. use these to create your own interfaces for controlling synths, other apps or your daw.

Isonome 128

created by: http://www.soundcloud.com/misk

Isomorphic MIDI interface that provides all needed visual feedback on the monome.

This little guy splits a 128 in half vertically, in such a way that the left 64 buttons act as an isomorphic MIDI interface that is capable of sending MIDI note data to whatever you please.

Upon initialization and connection to a grid, you'll see pretty lights. Everything on the left is the isomorphic keyboard, and all the lit pads are the tonic note. the 8x8 grid spans a total of 5 octaves, and is designed so that no matter what 'shape' you play (e.g. a triangle) the same chord quality will be maintained within the context of that key.

on the right side you have access to 8 modes, as well as all 12 keys, thus it allows for easy modulations, both diatonically and modally. I threw in two columns to adjust velocity - and just for the hell of it, there's a 4x4 pad bank on the right side (4,8 through 11,7) that's mapped chromatically to C1 - to be used primarily with Ableton Live's drum racks.

I suggest firing up a synth or sampler and fooling around. this thing makes for writing arguably more complex modulations with ease!

I'm sure there are bugs, and though I initially created it for myself (i'm left-handed ;) if someone finds something horribly wrong with it, I'd be happy to revise it.

keys

This app requires monomebridge in order to work properly with serialosc.

Two keyboards with velocity control and an octave selector.

created by: dovemouse

prefix: /keys

The monome is split into two halves, both function in the same way. Row one is a slider which allows you to select the desired octave of the keyboard. Row two is another slider but this one determines the velocity of all the notes on the keyboard. The last two rows are layed out in a way in which i think best represents a standard keyboard.

Thanks to jimdrake for the monomecontrol objects which have helped a lot here and allowed me to throw this together real quick.

knobs

created by: MonsieurBon.

A simple arc-to-midi knob converter/doubler.

Using an arc 2 or 4, you can double the available knobs and output that data to MIDI. Turning the encoder moves an indicator on the left side. Pushing and holding and turning the encoder moves a double indicator on the right side. You can adjust the turning speed multiplier for faster knob-doodling.

I built this to use with my generative Ableton Live sets. Video to come...

Added bonus: if you send MIDI note data to whatever you have selected as "MIDI in" in knobs, the notes will flash on the encoder LEDs, scaled to velocity. MIDI channels 1-4 are mapped to knobs 0-3.

Also, knobs can have your arc display incoming MIDI data if you route CC data through MIDI in. The CC in mappings are static at this point, and correspond to the default CC values in knobs.

kradle

LiveControl

This app requires monomebridge in order to work properly with serialosc.

Monome midi remote script for ableton live. Includes the following programs:

  • ClipLauncher
  • TrackControl
  • TrackFilter
  • TrackLooper
  • Scaled Keyboard
  • DrumRack
  • Looper
  • DeviceControl
  • MIDI Faders
  • External Program
  • Multimode (like quadrants)
  • Sequencer (A step sequencer that writes data to live midi clips)

created by: ST8

prefix: /ableton

download

configuration

SVN + Documentation: http://livecontrol.q3f.org/monome/

Documentation

http://livecontrol.q3f.org/monome/documentation/

LCD Support

Via use of a customised arduinomeserial and arduinome firmware (see download section) it is possible for this script to send updates to an arduinome with a serial LCD display connected to "Analogue Pin 1"

Media

http://vimeo.com/10844915

http://www.youtube.com/v/a_w40FHXqEY

LoopForLove

This app requires monomebridge in order to work properly with serialosc.

a simple midi loopstation with switchable midi in and out

created by: mario cosentini

prefix: loop

http://sites.google.com/site/hightensionhouse/mooo

http://www.vimeo.com/8694331

meeq

This app requires monomebridge in order to work properly with serialosc.

a multi-layered, polyphonic, polyrhythmic and dynamic MIDI step sequencer written in the chuck programming language.

created by: Graham Morrison

prefix: /meeq

features: forward, backward and random play. allows for the dynamic adjustment of step sizes, timing, MIDI channels and custom scales, plus both short and sustained notes. should work on the 64, 128 and 256.

download:

v1.0: http://www.paldandy.com/meeq/v100/meeq_v1.ck

tutorials:

a PDF cheat cheat with all the controls can be found here: http://www.paldandy.com/meeq/v100/meeq_v1.pdf

QUICK SETUP INSTRUCTIONS

Get Chuck: http://chuck.cs.princeton.edu/

Only works from the command-line version of Chuck and not the miniAudicle GUI. Chuck needs to be installed and in your path.

  1. Find the MIDI device name you want to output notes to by typing: chuck --probe

  2. Open the source code in a text editor. Copy the device name within the double quotes into following line: "PLACE DEVICE NAME HERE" => string midioutstring;

  3. Define the dimensions of your monome. Maxx holds the width, while maxy hold the height eg. for monome 64 08 => int maxx; 08 => int maxy; for monome 128 16 => int maxx; 08 => int maxy;

  4. Set the global tempo for meeq by changing 120 in the following line: 120 => int bpm;

  5. Run MonomeSerial and set the prefix to /meeq

  6. Type //chuck meeq_v1.ck// on the command-line to run the sequencer.

media:

http://vimeo.com/3072632

mabalhabla

created by: stretta

A configurable tonal mapping grid. Set intervals in vertical and horizontal direction for pattern-style chords.

http://www.youtube.com/v/uQm3xbTxJRc

Mark Eats Sequencer

Mark Eats Sequencer is a MIDI step sequencer app for the monome with a focus on jamming and performing with loops as soon as you've made them.

Features

8 channels
Up to 16 patterns per channel
Adjust note length and velocity
Scale generator
Transpose
Play forward, reverse, random or slice
MLR-style looping and scrubbing

SP-1200-style swing
Tilt to MIDI
MIDI clock sync
Cut, copy and paste patterns
Automation
Save and load song files
Supports all monomes

meadowphysics

(max) complex cascading counter

UPDATE: check out version 2: http://llllllll.co/t/new-meadowphysics-two

april 2014 tehn@monome.org

requires teletype: https://github.com/monome/teletype

best experienced with a variable brightness 128.

set countdown positions. when they hit 0 (leftmost) a trigger occurs.

on trigger, a few things happen:

  1. event is generated. currently this is hard-mapped to teletype (another app).
  2. count is reset.
  3. linked rows have their positions subtracted by one.
  4. a "rule" is executed.

only the top row is constantly triggered by the metro.

to have other rows count down, you need to link them.

holding down the leftmost keys shows the output linking for each row.

so, by pushing the topleft key, you'll see the rows that will get subtracted when row 0 hits 0. by default none are selected. while holding the top-left key, push the middle of other rows to toggle them.

you can have multiple rows triggering the same row. a row cannot trigger itself. it's quite easy to create strange evolving polyrhythmic counting.

set a rule by holding down the two leftmost keys, per row. select the rule by vertically on the right side of the grid-- the icon will change. select the destination row for the rule execution in the middle of the grid.

rules: none, increment, decrement, set to max, set to min, random, random inc/dec, recall last pressed.

for example, on row 0, a rule of random with destination row 0: on each trigger, a random new starting position will be chosen.

for example, on row 1, a rule of increment destination row 0: on each trigger of row 1, row 0 will get reset to a position one greater than its previous reset position.

meadowphysics (two)

https://vimeo.com/146731772

8 counters, in rows, counting down leftwards.

when a counter hits the left edge, many things can happen:

  • a note can be triggered or toggled.
  • the counter can reset itself or others back to its count position.
  • a rule can be executed and applied to itself or another counter.

set count by pressing a key within a row.

hold leftmost key to set parameters for given row.

  • set speed by pressing keys 8-16 within the row. faster is leftwards.
  • stop (or resume) a row by pressing column 3.
  • toggle RESET for any row by pressing the fourth column.
  • set trigger output by pressing column 6.
  • set toggle output by pressing column 5. (triggers and toggles can be set for multiple outputs.)

while holding the leftmost key, press and hold the next-to-leftmost key to see rules for a given row.

  • select the destination of a rule by pressing column 6/7.
  • change the rule by pressing the right half of the grid. select vertically and a glyph is displayed.

most "rules" require a range to be defined for a counter.

  • define a range by holding a count and selecting another position. this defines the maximum and minumum.

by default the "increment" rule is selected.

  • on each execution, count will be increased. if max is hit, the next execution will be the minimum.

other rules do different things, listed from top to bottom:

  • none: do nothing.
  • increment: increase by 1. wrap if at top.
  • decrement: decrease by 1. wrap if at bottom.
  • max: go to maximum.
  • min: go to minimum.
  • random: go to random count within range.
  • pole: go to min or max, whichever is furthest away.
  • stop: stop.

monome-notes

By: myr

monome notes is an app for playing midi notes on a grid device. it turns each key on the grid into a midi note which you can trigger by pressing the key, similar to a keyboard or drum pad. the app allows you to control the way the notes are laid out and displays information about the current note layout on the leds.

it's kind of like a guitar fretboard, where you can change the tuning between strings, change the distance between frets and even snap it to play in a scale; all the while the fretboard can light up to show you whatever scale you select.

you set the interval between each column and row in semitones (or scale degrees if snapped to scale), relative to the first note in the grid. the first note in the grid is set by the offset number. you can set a scale using the drop down menu, set the root note for this scale to start on and snap to the scale eliminating all non-diatonic notes from the grid.

i've attached two images to this post, the first shows the default setup, it's kind of like a bass guitar fretboard with the interval between columns set to 1 semitone and the interval between rows set to a perfect fourth or five semitones.

the second image shows an ableton push style setup, with the scale snapped to C Ionian (Major) a semitone between columns and three semitones between rows.

here's a quick tester of what i've got so far, lots more stuff on the way and tidying up to be done in the code; chiefly presets and lighting up what notes are being played on the grid. currently designed for varibrightness monome grids, not sure if the leds will work on older models. requires max 6. hope you enjoy it.

muon

emergent feedback sequencer

created by: tehn

(initially constructed as a demo at the machine project’s most recent max/msp workshop.)

muon is a algorithmic sequencer in a sense, though better described as emergent:

wiki: http://en.wikipedia.org/wiki/Emergence

each voice is looking for a magic number. if it matches one, it will trigger it’s sound, wait a specified interval, then transmit it’s own magic number to the rest of the voices. so each voice has two numbers: that it’s looking to match (input) and that which it sends (output).

all of this is can (and should) be randomized.

what’s interesting is when the network creates feedback loops. often several at once, of different lengths, hence polyrhythms. several different delay multipliers are allowed.

furthermore, there is a “mutate” feature, which randomizes only by probability. by default this is at 15 percent, so when mutate is called, each parameter of each voice has only 15% chance of re-rolling itself.

Instructions

some other features not documented or in the vid:

  • hold down re-roll (top left 4×4) then press lower voices to mute/unmute them
  • hold down mutate (top right 4×4) then press lower voices to only mutate that voice
  • push top two big 4×4’s together to stop everything

if you don’t have a midi softsynth of choice, try simplesynth

http://vimeo.com/704818

nodes

currently hosted on archive.monome.org and needs a new home

created by: Stephen Ball

Nodes borrows heavily from Brian Crabtree's application skr, particularly the internal synth and the retriggering mechanism. Thanks to the monome folks for making everything open.

Nodes is a monophonic sequencer. It is controlled by adding nodes to the 8*8 grid, and each place on the grid represents a note. The sequencer stores the order in which nodes where created, and plays them back in that order.

There are two modes: it can either play sounds from its internal synth, or it can output midi. Choose a midi out port and channel.

Once the sequencer is running, the program uses the distance to the next node, the angle between the two nodes and the distances horizontally and vertically of a right triangle between the two nodes to adjust the speed of the sequencer, the volume of the note, the likelihood of it being retriggered (if the “repeats on/off” box is checked), and the note's length (in midi mode). These factors make it difficult to sync the app to anything.

Download includes “read_me.rtf” for more information.

pad

created by: Meng Qi

multiple xy pad midi controller for monome grid

This app is intented to be used for 128 (64 should work too) as multiple xy pads. Each 4x4 section is a pad. You can set the note, velocity, xy CC number, xy slide rate, midi ch and output port separately for each pad. Also there is a "control all" section for easy editing.

parc

parc is a probabilistic sequencer/arpeggiator.

created by: tehn

four channel, sends midi notes and cc data. sends and accepts sync.

each channel has dynamic loop lengths and timing multipliers.

similar to a normal step sequencer, except when a step contains more than one option. where normally a chord would be triggered, parc selects at random one of the choices. step data is set and selected similarly for velocity, sub (retrigger variations with re-randomizing), and line (cc output, with smoothing and range specification.)

slightly more documentation inside the patch. more to come, with screenshots, video, and proper walkthrough.

http://vimeo.com/11435470

phrasespd

WARNING BETA

MOST FEATURES ARE ONLY MINIMALLY TESTED

Feel free to play around with the PhrasesPd editor and sequencer. If you are using PhrasesPd in a mission-critical capacity, please double-check everything you want to do in advance, in order to avoid potential unforeseen bugs.



PhrasesPd

PhrasesPd is a MIDI sequencer, for arbitrarily-sized grid controllers capable of using the Monome OSC communications format. It is for composing phrases of MIDI data, which can then be saved/loaded as songs, and combined in novel ways during performance. It is very informationally dense, capable of controlling long and complex songs from a single Monome 64, and yet offers considerable options for improvisation too.

PhrasesPd allows for polyphony, polyrhythms, ADC control of note and volume parameters, and generative transference of phrase activity.

It has an integrated phrase editor, which is controlled by a combination of computer keyboard, MIDI controller, and grid controller. Song data is saved as Lua table files, in a manner that is both executable and human-readable.



Monome Wiki page:

http://monome.org/docs/app:phrasespd



Dependencies:

Puredata-extended 0.43.4



TO-DO LIST (in rough order of desired implementation):

* --- Beta Release Goes Here ---
* Refactoring: Combine preferences files, clean things up in general



Quick-Start Guide:

1. Put the following files into your /pd/extra directory:
phrases-editor-and-sequencer.pd_lua
phrases-get-prefs.pd_lua
phrases-gui-generator.pd_lua
phrases-gui-tables.lua
phrases-keychord.pd_lua
phrases-keychord-tables.lua
phrases-main-tables.lua

2. Place the following files in the same directory as one another:
default.lua
phrases-hotseats.lua
phrases-makecolor.pd
phrases-prefs.lua
phrasespd.pd
The directory itself can be wherever, but preferably somewhere convenient in your directory structure, as your savefiles will be loaded from within the same directory (or a subdirectory, if you specify so).

3. Modify the contents of "phrases-prefs.lua" to reflect your setup and directory structure.

4. Change the Puredata MIDI settings to reflect your default MIDI-IN and MIDI-OUT devices.

5. Run "phrasespd.pd" in PureData.

6. You can now begin assembling phrases of MIDI data in the PhrasesPd editor, and playing them with your Monome.

7. To save your song data: Click the "Custom Savefile" box, type in the desired filename, and hit Enter. Then, to save your data there, type Shift-?-|.

8. To change the default loadfile hotseats, edit the contents of "phrases-hotseats.lua".



Monome communications prefix:

/phrases



Editor Commands:

(Note: These are the default key-commands, and can be changed by editing phrases-keychord-tables.lua)

Choose savefile name - Type a filename in the "Custom savefile" box in the main phrasespd.pd window, and hit Enter
Save file - Shift-?-|

Choose loadfile hotseat - Shift-[number] (hotseats 1-10), Shift-BackSpace-[number] (hotseats 11-20)
Enter custom loadfile name - Type a filename in the "Custom loadfile" box in the main phrasespd.pd window, and hit Enter
Load file - Shift-Tab-Enter (WARNING: Erases any unsaved changes)

Keystroke Panic (because current keychord detection is fallible): Space

Toggle between phrases - Any Monome button (while in REC mode)
Play phrase - Any Monome button (while in PLAY mode)

Previous phrase - Left
Next phrase - Right
Previous note - Up
Next note - Down
First note - Home
Inverse note - End
Page up - PageUp
Page down - PageDown

Toggle Recording/Play modes - Esc
Toggle between input panels - Insert
Toggle between number/pitch views - Shift-M
Toggle between MIDI Catch modes - Shift-O, Shift-P

Insert MIDI command - zsxdcvgbhnjm,lq2w3er5t6y7ui9o0p
Insert blank note - Backspace
Delete note - Delete

Undo - Shift-Tab-Z
Redo - Shift-Tab-Y

Set Copy Range Top - Shift-Tab-!
Set Copy Range Bottom - Shift-Tab-@
Unset Copy Range - Shift-Tab-#
Cut - Shift-Tab-X
Copy - Shift-Tab-C
Paste - Shift-Tab-V

Shift phrase up - Shift-Tab-Up
Shift phrase down - Shift-Tab-Down
Shift phrase left - Shift-Tab-Left
Shift phrase right - Shift-Tab-Right

Increase spacing - Shift-Up
Decrease spacing - Shift-Down

Increase MIDI channel - '
Decrease MIDI channel - ;

Default MIDI velocity +1 - =
Default MIDI velocity -1 - -
Default MIDI velocity +10 - +
Default MIDI velocity -10 - _

Octave +1 - ]
Octave -1 - [

Next command type - /
Previous command type - .

Move active note back by default velocity value - Shift-Q
Move active note forward by default velocity value - Shift-W
Move all notes in active phrase back by default velocity value - Shift-E
Move all notes in active phrase forward by default velocity value - Shift-R

Shift active note-byte down by default velocity value - Shift-A
Shift active note-byte up by default velocity value - Shift-S
Shift all note-bytes in phrase down by default velocity value - Shift-D
Shift all note-bytes in phrase up by default velocity value - Shift-F

Shift active velocity byte down by default velocity value - Shift-Z
Shift active velocity byte up by default velocity value - Shift-X
Shift all velocity-bytes in phrase down by default velocity value - Shift-C
Shift all velocity-bytes in phrase up by default velocity value - Shift-V

Add note-offs to active phrase before each note - Shift-Tab-A
Add note-offs to active phrase based on spacing value - Shift-Tab-S

Plinkonome

created by: JP

Plinko midi implemention for the monome.

http://vimeo.com/11857387

http://vimeo.com/15827473

Plinko is a game from the Price is Right, where the contestant drops a ball down a column, each column has a peg in the middle after each row, so the ball can go either left or right at each level. At the bottom whereever the ball ends up is a different cash amount. The final column is pretty much randomly generated.

Plinkonome, is a variation on this theme using the excellent Java extension it treats the monome grid as a plinko game, pressing a button will cause that button to light up, after a set amount of time either the LED below that button or the one either side of that LED will light up, this pattern of down, diagonal left or diagonal right continues down the monome. At each step the new location will generate a midi note.

http://code.google.com/p/plinkonome/

polygome

by stretta

Polygomé has four modes. Play mode is default. Play mode will begin a pattern on the button you press. A new pattern can be entered if you are in record mode. Up to eight steps can be entered directly on the button surface. Velocity mode enables you to enter a velocity value for each step. The steps are represented as rising bars . Duration/step mode is a bit more complex. The bottom row represents enable/disable states for each step. The seven buttons above each enable/disable toggle operate like the rising velocity bars. The lowest amount = 1 step which is equal to 1 16th note. Higher bars = longer notes for the corresponding step.

http://vimeo.com/1381241

http://vimeo.com/1968639

The current version of Polygome is now maintained as part of Beap: http://github.com/stretta/BEAP

presscafe

written by Matthew Davidson stretta.com

A real-time rhythmic MIDI pattern performance patch.

In press cafe one axis of the monome represents discrete notes, and the other axis represents repeating sequences of that note. Press Cafe creates different pitched rhythmic patterns based on which button is pressed. The patterns are represented by animating the LEDs. Each pattern can be edited directly on the monome.

http://vimeo.com/375666

quadknobs

created by: MonsieurBon

This is a simple arc-to-midi knob converter/quadrulpler.

Using an arc 2 or 4, you can quadruple the available knobs and output that data to MIDI. Turning the encoder moves the upper right indicator. Push the encoder to move to controlling the next quadrant. The active pointer will be brighter.

Added bonus: if you send MIDI note data to whatever you have selected as “MIDI in” in quadknobs, the notes will flash on the encoder LEDs, scaled to velocity. MIDI channels 1-4 are mapped to knobs 0-3.

Also, quadknobs can have your arc display incoming MIDI data if you route CC data through MIDI in. The CC in mappings are static at this point, and correspond to the default CC values in knobs.

quantum

"beat juggling"

generative sequencer for grid and arc based on siteswap, a form of juggling notation.

http://www.siteswap.org

designed by: jay gilligan

coded by: jusu

prefix: /monome

concept

quantum maps arbitrary note values to objects in juggling patterns. higher notes correspond to higher throws by default, but any value can be assigned. additionally, the program allows for a distinction between the left and right hands. note triggers are set to the peak of each object, rather than the traditional catching or throwing position. this produces unexpected rhythmic variations, and allows for chords to exist.

getting started

quantum was built upon juggling lab, a juggling pattern animator by jack boyce- http://jugglinglab.sourceforge.net

first open the "juggling lab.jar" file included in the quantum patch folder. this should start by showing a three ball animation. next open the "quantum.maxpat" and notes should now be heard. midi destination can be set by double clicking the "noteout" button, and velocity can be set next to that. note presets can be edited by clicking the "notes bang" button. there are up to 8 presets which can be saved.

siteswaps may be manually entered into the small white box below the speed control (and above the large grey bar). to run a valid siteswap, click on this box, enter the values, and then click anywhere outside the box. the siteswap should now be animated in juggling lab and displayed prominently in the quantum patch, with the resulting melody being heard.

juggling lab also makes an excellent online siteswap generator. use this program to find valid strings of numbers to enter and see what they sound like. please note that values higher than 9 are written with letters in the final sequence: 123456789abcdefghi...

http://jugglinglab.sourceforge.net/bin/example_gen.html

grid

connect the grid by double clicking the "p monome" button on the quantum patch. this will open a new window where you may connect your grid (and arc). once connected, the siteswap animation should be displayed on the grid.

button presses will display previously entered lists of siteswaps. the default layout (with cable orientation to the left) programs the grid in a matrix- starting at the bottom, each row represents a progressively higher throw. starting from the left, each column represents a longer siteswap period (period = number of throws in each pattern). the file included with the patch starts in the lower left hand corner with the maximum throw height of 3 and longest period of 3. it stretches to the top right hand corner, ending with the highest throw of 18 (or the letter "i" in siteswap), and the longest period of 18.

without an arc to supplement functionality, only the first pattern under each button press will be accessible. however, each button has the potential to store up to 32 patterns at one time. the grid may be reprogrammed by clicking in the largest white box on the quantum patch. many siteswaps may be entered at one time, separated by a line break (press return after each complete siteswap entered). then click anywhere outside the box to save these patterns to the "patterns.json" file included with the patch. these patterns will be recalled each time you push the same button on the grid. press a new button on the grid to add patterns there. without an arc, the best layout will be to find your favorite siteswaps and enter them separately under one button each, filling the grid for fast retrieval.

the grid size and animation options can be found by double clicking on the "p animation" button in the quantum patch. once this new window opens, double click "js animationTail.js" which should open yet another window. while originally designed for a 256, other grid sizes can be entered by changing the value "16" in line 9 and 10. grids with varibrightness can opt to have a small tail or fading trail on the animated objects. replace line 5 with:

var ramp = [0, 1, 1, 2,  2, 3, 3, 3,  4, 4, 5, 6,  6, 8, 11, 15];

arc

an arc may be connected at the same time as a grid. after a button press on the grid, the first encoder will light up in segments showing how many different siteswaps are stored under that button. rotate the first encoder to change focus on different siteswaps and then press the encoder to select that siteswap.

the second encoder can be rotated clockwise to increase the tempo. pushing the second encoder will change the siteswap to "2," effectively stopping all action. at the moment only push button arcs are supported.

known issues/wish list

  • due to an error in the initial design, throw values of "g," "h," and "i" do not produce any sounds at the moment even though they are included in the programmed matrix of saved siteswaps on the 256. this can be easily fixed by adding the capacity for note values to these throws in the already existing system.

  • because of how juggling lab deals with its animation, and how this animation is mapped to note values in the quantum patch, throws "0," "1," and "2" do not yet produce any sounds. this is a conceptual error, where only "0" should represent a rest in musical notation and produce a beat of silence. hopefully future releases of this patch will add musical functionality to throws of "1" and "2".

  • if the siteswap "2" eventually triggers a note, the second encoder push button function will need to be rewritten as a "panic button" (clearing the animation on the grid and stopping all sounds) because now it defaults to "2" when pressed.

  • scrolling animation around the arc's first encoder can be a bit choppy/tricky and as well the division of segments can sometimes be unequal depending on the number of siteswaps to be displayed.

  • the tempo control of the second encoder is not mapped in any meaningful way to bpm. fundamentally this probably cannot be fixed because of the way the juggling lab animation handles time, but perhaps there could be led's pre-lit around the second encoder that correspond to certain tempos, i.e. 60 bpm, 90 bpm, etc., once those calibrations have been manually noted.

  • arcs without push button functionality could easily be implemented by eliminating the need to push the first encoder after rotating it to select the desired siteswap segment. perhaps as soon as the encoder is turned and its in the "zone" of a new segment, that siteswap could play as long as the encoder stays in that zone. as well, the second encoder could simply turn the tempo down to zero, which could also be linked to clearing the animation?

  • at the moment the quantum patch can only play the melody of asynchronous siteswaps. however, juggling lab can animate synchronous siteswaps, and the grid has no problem displaying these animations. slightly related, juggling lab animates each pattern in full 3D, allowing users to click on the animation and rotate it at will. these changes can also be seen perfectly on the grid, but with no musical effect. perhaps one day quantum can be programmed to play synchronous siteswaps and rotation of the animation can be mapped to musical consequences.

download

media/discussion

Rebound

created by: josh g. - josh (a) thoughtlost.org

A Processing-powered MIDI instrument for monome. Notes bounce across the grid, occasionally changing directions.

Rebound creates moving nodes which bounce horizontally across the grid, then occasionally change direction. MIDI notes are triggered when the node is first pressed, and then on every bounce against the outside edge. The nodes decay after a variable amount of time. The average lifespan of the nodes and the average frequency of direction-changes can be controlled via an on-screen slider or mapped to an OSC slider (via some hacking). To clear the grid, press and hold the top left button for a second and release.

The app was created and tested using an emulator, not a for reals monome, and as such might need some tweaking to get it up and running with your config. However I've tried to keep the important constants up front and at the top of the first file you see when you open the code so it shouldn't be too painful.

For anyone trying it out on the Control monome emulator, the chaosLevel and lifeLevel sliders are mapped to the emulator's two sliders.

Installation: If you don't have it yet, go download Processing 2.0 or greater and install it. This program also requires the controlp5 and midibus libraries. Download them at:

and copy them to the 'libraries' folder where your Processing sketches are saved.

Once those libraries are in place, unzip the Rebound app files somewhere and load rebound.pde in Processing. The app should run without any errors, although it may not connect right away - scroll down a little to see if you need to change the IP address or port numbers for your OSC setup.

I've mostly used this as an 8x8 grid setup, but the grid dimensions are set as constants that you can change at the start of the file too. (Although I think it'll run out of MIDI notes in the table if you run it at 16x16.)

The 'NotePlay' class contains the mapping from grid locations to MIDI notes, among other things. If you want to modify the scale being played, you can either edit the table at the start of that file to a new MIDI mapping ... or be creative and just rewrite stuff. :)

Licensed under Creative Commons Noncommercial Share Alike.

http://www.ustream.tv/recorded/23146439

Refmatrix

here's an edit of the midi version of refmatrix i've been having fun with for a bit so thought i'd share.

in short - it now has 4 grids, each assignable to seperate midi channels. playback and switching between grids for input are handled on the monome. uses serialosc. * update - now has optional random velocity, cc's and octaves available per grid*

it can be seen in action in this excellent video by nightmorph (thank you).

http://vimeo.com/26990774

residue

written by stretta

residue is an outgrowth of TR-256. It still has the drum sequencer, but there are two 'melodic' step sequencers as well for a total of three 'parts'

The top row determines which pattern(s) are playing

The second row determines which pattern you are editing. Holding down a button while editing edits all patterns of that part. So, you can enter in a kick drum pattern for all patterns at once, for example. When you switch to edit the next pattern, the kick drum is already in place.

The third row is the pattern length of the currently edited pattern.

The remaining rows contain pattern data.

http://vimeo.com/398616

returns

simple yet versatile cc output from the arc. sensitivity and lfo control. anti-aliased point indication.

created by: tehn

http://vimeo.com/63240734

added features by søren andreasen

  • basic grid support
  • clip launch
  • note out

http://vimeo.com/86750947

RGSS

Rhythm Generating Step Sequencer for Monome

created by: Astronaut

A quick and easy method for creating rhythms and melodies using the monome, sound can be generated using the internal synthesiser or using the generated midi output data.

Sequencer cycles from top to bottom at the selected BPM, with pitch increasing from left to right.

With a 'Pitch of Keys' value of zero the left hand column of the monome will represent A0 and a 'Pitch of Keys' value of 80 the right hand column of the monome will represent C8.

The internal sound is generated using a cycle~ object with a frequency generated equivalent to the tuning of a modern piano when A over middle C has the frequency of 440Hz.

Quick Start Guide

Select a Sound Source

  • Internal sound on turns on the internal synthesiser
  • Midi on shows the midi configuration menu

Program a pattern or press the Random Pattern button

Press SPACE to start Playback

ricochet

created by: bongo

derived from http://www.earslap.com/projectslab/otomata - thanks and credit to otomata author Batuhan Bozkurt.

ricochet, like otomata, is a generative sequencer employing cellular automation. Each cell can be empty, or hold a token with direction up, down, left or right. When the transport is started, on each beat each token is moved one cell in its stored direction.

If a token hits a boundary/wall, it generates a midi note. Once a wall is hit, the token either 1) flips direction; 2) flip direction and moves one cell in the new direction; or 3) loops around to the other side and maintains the direction it had when it hit the wall. Wall behavior is selectable from the on screen interface.

When N>1 tokens land on the same cell, the direction of all are rotated N-1 times clockwise. This ricochet effect can be turned on/off on screen.

A single musical scale is set for all midi notes generated, but midi channel, scale base note, note duration amd note velocity can be set for each wall. In addition, if a range of duration or velocity is set - via min & max values - ricochet will randomize duration and/or velocity within the the defined range, and this can be done independently for each wall.

In this alpha version of ricochet, tokens can only be created when the transport is stopped. Create a token by tapping a monome button - tap 1x for up, 2x for right, 3x for down, and 4x for left. Tapping a 5th time will clear the cell. The transport can be stopped and started repeatedly, with the current cellular state being maintained. Also in this alpha version, as soon as buttons are pushed while the transport is stopped, ricochet reverts to its initial state and adds tokens to this. I may at some point include the ability to add tokens to the current state while the transport is playing.

Other than setting tokens, the monome interface is quite simple in this initial version: While pushing and holding the top left button (0,0)

  • tapping button (1,0) toggles play/stop
  • tapping button (2,0) resets to the initial state
  • tapping button (3,) clear all cells

I find I have the most fun with ricochet with walls mapped to different instruments using different midi channels, and applying reverb, ping-pong or other echo effects set to BPM resonant with the ricochet BPM setting.

http://vimeo.com/22813726

sepra

This app requires monomebridge in order to work properly with serialosc.

sepra is a probability-based generative MIDI step sequencer with 4 voices.

prefix: /box

it has a unique and complex (and if we're lucky, functional) 40h interface, best described with both an image and text. there is also a tutorial video at http://www.vimeo.com/359147

here is the image:

the green and red squares in the corners are edit toggles for each of the voices. the buttons in the green square toggle edit pages for the step sequencer and the pitch class set. the red square is for editing probabilities.

the yellow square in the middle is a voice output toggle. if all of these are off, you won’t get any midi data.

the dark blue ring is a circular step sequencer, which progresses as shown by the text.

the black ring defines a pitch class set. each voice has its own pitch class set and its own rhythm, as defined by the step sequencer.

the light blue +/- buttons change which pitch class & probability structure the sequences are associated with. this is kindof like decoupling. the one on top corresponds to voice 1, right to voice 2, bottom to 3, and left to 4. increment is always up or right. the current assignment is displayed in binary offset by -1. each voice defaults to its own pitch class set.

the buttons with the white background increase or decrease the probability of a pitch class coming through as a note, depending on which orange button (the ones with arrows) is lit. pressing any of these while the right button (the one with the up arrow) is lit will increase that pitch class’ probability. with the left button lit up, they will decrease.

the grey buttons along the diagonal don’t do anything right now, but i was thinking they’d be preset scrollers or something. next and previous on the left and right.

that seems like everything. post to the forum with any questions. use your favorite synth.

shoal

created by: JP Nomeist.com @madebyrobot

Shoal is a influenceable chaotic oscillator with midi cc out.

http://vimeo.com/22529393

Shoal is a influenceable chaotic oscillator with midi cc out. Pressing buttons on the Monome 256 will create single "fish" like states, that will follow a forward yet left/right/forward route. If they hit a wall they will turn away. Each step they take they generate X,Y midi cc outs. 16 fish can be created, with a total of 32 midi channels sending out data. The rate at which the fish move can be controlled from 5ms/move through to thousands of ms/move.

If at any point you press and hold a button, it will be registered as an avoid spot. Fish within 8 buttons of this location will avoid moving closer. Letting go cancels the avoid spot.

Using this avoid spot you can "influence" but not direct the Shoal, they will continue to move chaotically, but they won't enter that area of the grid. This means if you have them applied to filters you could keep the filter from going very low, but it will still have a generative feel to it.

There is a current bug, that when creating the fish, sometimes the app will register an avoid spot as well, this can be corrected by pressing any button again after you start the fish.

Due to the avoid algorithm, it is very possible to trap fish against an edge, this is an instance where the fish can't go anywhere without going closer to the avoid zone, going closer is not allowed, so the fish will remain in one location trapped.

In the above demo, I have 3 tracks, two Ableton Simpler's an a basic bass oscillator. These 3 tracks have a total of 16 midi cc's mapped to the Shoal interface. The bass has simple filter, attack, decay assigned. The Simpler's have filter and more importantly sample start location and length. This adds to the someone chaotic, yet consistent nature of the demo.

source

Tips

  • Uncheck the "start" checkout before you try and do midi learn in your DAW, if you don't you'll be barraged by midi messages. To assign a param, just wiggle the slider associated with it up and down to register the midi.

step-o-potamus

This app requires monomebridge in order to work properly with serialosc.

Variable Length Audio/Midi Step Sequencer w/ Built In Delay v0.1-1

created by: Scott McCoid

prefix: /sop

step-o-potamus is a variable length monophonic audio/midi step sequencer built in Pure Data. It contains multiple pages to adjust octave, velocity, FX send, and key.

Please use http://puredata.info/downloads. The Open Sound Control objects and a couple others I use are included only in Pd-extended.

step-o-potamus currently has 5 different pages. To access each page you need to press and hold the correct button to access the page. It should be able to determine a page selection from a button press on that page.

  • Page 1 (0,0): - Monophonic Pitch Selection
  • Page 2 (1,0): - Octave Selection (Pick octave for each step)
  • Page 3 (2,0): - Velocity Amount (default is max velocity)
  • Page 4 (3,0): - FX Send Amount
  • Page 5 (4,0): - Key Selection

Page 4 is an FX send to the delay line. This is the amount of the signal that gets sent to the delay line for each step. For example, If you only want step 1 to repeat, go to page 4, and press one of the top row buttons. Depending on the delay time and feedback will determine the sound. This can also be use to control a midi control change value in order to change a parameter in a software synth.

Page 5 determines which key the sequence is in. You can also adjust this from the main interface by dragging the box that says "Key" upwards. The default is middle C in the Major scale.

You can also adjust the number of steps above 8. To navigate to steps 9-16 press and hold the bottom right button (7,7). To navigate back to steps 1-8 press and hold the bottom left button (0,7).

soyuz

scrolling midi step sequencer

created by: stephen ball

soyuz is a scrolling midi step sequencer. sequence length is adjustable between 1 and 64 steps. keyboard arrow keys are used to scroll left, right, up and down across the interface. the sequencer has settings for note, velocity and duration, and can sync to an external midi clock. notes are input to the grid using rows 1-7 of the monome - the top row controls the position of the playhead, a la mlr. the "about" file in the download contains detailed information on getting started.

sweep

This app requires monomebridge in order to work properly with serialosc.

sweep is a wide-range, rapid chord player; a lightweight and super-responsive live performance tool.

created by: matthew rizzuto, february 2008, montréal

prefix: /box (see description)

description:

sweep is a utility, or mini-application, for the //two fifty six// or //one twenty eight// in pd. in two words, it's a 'chord player'. in more words, it's a purposefully minimal midi controller intended as a lightweight and super-responsive live performance tool.

for my own //two fifty six// performance needs, i'm developing a collection of single-purpose and lightweight musical utilities in pd which can be run singly or combined and permutated non-exhaustively. essentially these are thought of as a family of mini-applications which can be endlessly compiled in real-time into temporary, 'full featured' applications. sweep is the first such utility, and my first large commitment in pd. i am hoping the remainder of these little works will be produced much more quickly, as my familiarity with this wonderful programming environment increases.

for the moment, the prefix is /box. eventually, i'll need to be able to manipulate and initialize these mini-apps without needing to return to the computer each time, so, as i create more of them i'm bound to begin exploring dynamic prefix switching. in the future the prefix for these utilities will be open, to be chosen by the user. /box, however, is hard-coded into version 1.

sweep occupies 6 rows total, and the complete 16 button breadth. the default placement is on row 1 so that it initializes safely on both the //two fifty six// and //one twenty eight//. the top row of sweep can be placed on 0 or 1 on the //one twenty eight//, and 0 to 10 on the //two fifty six//. this leaves the remaining 10 rows of the //two fifty six// and 2 rows of the //one twenty eight// open for other uses.

http://vimeo.com/706365

quick start:

  • open monomeserial>host 8000, listen 8080>prefix is /box
  • open pd extended 0.39.3>choose a single midi output device
  • open synth/host>choose corresponding midi input device
  • open '_sweep' in pd>ensure there are no non-initialized objects, but ignore the rest
  • click 'use defaults'.

  • consult the 'sweep controls.pdf' file

  • input a duration, velocity, midi channel, and play mode (solid/broken) on the monome 'control frame' which appears after you click 'use defaults'

  • input a bunch of notes in the 'notefield' (max is 12 before clearing)
  • press 'play+repeat', press it again.

http://vimeo.com/702112

the fly

currently hosted on archive.monome.org and needs a new home

ableton live and machinedrum performance environment

Tilty Magee

This app requires monomebridge in order to work properly with serialosc.

Update Oct 28th

Now with added max4live support. I forgo midi CC and took the code from parastepper. In this version you can control any automatable control within a tracks. Interesting about this version is that everything is being sent by a float...

About Max/msp version

Tilty Magee is an open ended tool to allow you to turn the accelerometer data of your monome into midi cc data. One of the advantages of this tool is that it remains active regardless of monome serials current prefix.

created by: TheAlphanerd

prefix: /prefix (loads on launch for calibration)

Instructions:

1) Set your port under UDP-Settings to be the same port as 'host port' in monome serial

2)Click on the tilt setup button in the "Tilt Settings" area of the patch. From there follow the on screen instructions to turn on and calibrate your accelerometer. After calibrating close window

3)In the main app window you can now set the midi CC value for your x / y axis control information, the midi channel number, and the midi device to send information to

4) Toggle on and off Sends to send data

Special Thanks go out to Tehn, Stretta, Greater Than Zero, monohusche... and of courses our viewers at home

tintinnabulome

This app requires monomebridge in order to work properly with serialosc.

a modal arpeggiator fitted to the decoupled grid of the monome

created by: Stretta

contributions by: occular

idea by: Tetramorph

prefix: tin

quick start

  • monomeserial prefix must be set to tin. Click the initialise message box to set this up.
  • make sure the internal clock is running. This is on by defailt upon opening.
  • set valid MIDI destinations with the MIDI assignment drop-down menus.
  • (optional) configure tilt setup and click checkboxes to enable tilt control of arpeggio direction and range mode, MIDI CC data or OSC message data
  • set up an arpeggio pattern using the tick boxes in the GUI (or through "edit mode," see below)
  • play using the rate columns and hold row at top

operation

MODES

There are two modes: play mode and edit mode. The modes can be toggled by pressing the top right (by default) mode button. The mode button LED is off in play mode and lighted in edit mode.

PLAY MODE

Play mode uses the monome device in the following configuration:

  • rate columns (for the defined arpeggios)
  • hold row (one hold button per rate column along top row)
    • degree column (along far right side, by default)

RATE COLUMNS

There are seven "play" or rate columns of seven buttons each, starting from the bottom going up. Each button sets a rate of arpeggiation relative to the clock. The bottom most button sets a 1/16th note rate. Each successive higher button slows down the pattern with a whole note as the slowest possible rate. Rate affects also the note duration of the sequence. The slower the rate, the longer the note duration. When a rate button is released, that arpeggio ceases to play unless a column's hold button is on.

HOLD ROW

The top row of buttons above the rate columns provides "latch" or hold buttons for each column. The rate can still be changed while a hold button is on.

DEGREE COLUMN

This is the far right (by default) column on the monome device. In play mode it controls the relative scale degree of the arpeggiations, e.g., the I, II, III, etc., chord within a given mode. (In edit mode it selects the modal scale relative to the key.)

EDIT MODE

Edit mode uses the monome device in the following configuration:

*degree column (along far right side, by default) *page row (top row selects various edit pages) *definition buttons (the rest of the buttons define a given parameter per edit page)

DEGREE COLUMN

As in play mode, this is the far right (by default) column on the monome device. In edit mode, however, it selects the modal scale relative to the key, e.g., aeolian, ionian, lydian, etc., with F, G, A, etc., defined as the tonic of the key. (This is as opposed to play mode, where it controls the relative scale degree of the arpeggiations.)

PAGE ROW

When switching to the edit mode by pressing the mode button, the hold row buttons becomes page selection buttons.The first page starts immediately top far left (by default).

DEFINITION BUTTONS

In edit mode the rest of the buttons of the monome device define parameters specific to each edit page.

EDIT PAGES

1: NOTE SET PAGE

Noteset page is the first page in edit mode. It allows note selection on each play column. These may be altered during play if (a) hold button/s were engaged in play mode.

2: ARPEGGIO / SHIFT PAGE

Arpeggio / Shift page is the second page in edit mode. This allows switching between homophonic mode, up, down and random arpeggiation. The 5th button is reserved for further modifications ( e.g., up/down, when developed). The last two buttons on the bottom allow octave shifting up and down, respectively. Again, as with note set page, above, these may be altered during play if (a) hold button/s were engaged in play mode.

3: VELOCITY PAGE

Velocity page enables alteration of velocity value for each play column. Again, as with other edit pages, velocity may be altered during play if (a) hold button/s were engaged in play mode.

4-6: BLANK PAGES

These pages are currently blank and reserved for future development.

7: PRESET PAGE

Preset page is the seventh page in edit mode. There are 49 preset slots. To save a preset to a slot, hold the preset page button continuously while pressing the desired slot button. To recall a preset, simply select the preset page and, after releasing the preset page select button, press the desired slot buton. As with other edit pages, presets may be recalled during play "on the fly" if (a) hold button/s were engaged when the preset was recorded.

graphic user interface

SETUP

HOST PORTS

Allows changes to the listen host ports. Please change to the same ports in monomeSerial, etc.

ORIENTATION

Orientation button allows for the remapping of the degree column to the right or left side of the monome device. This remaps the mode button to the top far right or left, respectively.

MODE FUNCTION

Mode function button allows for a choice between hold (default) and snap back behavior for the mode button. In hold functionality, the mode button holds on the selected mode as it switches between Play and Edit modes. In snap back functionality, the mode button only switches to edit mode while continuously depressed. When released the mode "snaps back" to play.

INITIALISE

This button sends the -tin- prefix to monomeSerial. It also returns the orientation of the degree column to its default right position and the mode function to its default hold functionality. This button is also useful as it will initialise everything in the patch, should things get messy.

VELOCITY INTERPOLATION TIME

This sets the interpolation time of the velocity slider. Default is 300.

CLOCK (SYNC)

tintinnabulome can sync to other applications. Select 'beat clock' as source and select a MIDI port that sync is being set to from the external application. To sync tintinnabulome from another Max app, send bangs to tin_pulse and turn off tintinabulome's internal clock.

MODALITY

tintinnabulome only allows for tonal harmony based upon modal scales. The modality UI allows for the selection of the tonic note of the scale ("key") and the modal scale type. It also displays the currently selected chord scale within the given mode with respect to the tonic.

TILT

Click the tilt setup button to calibrate tilt. Tilt output can be sent to any combination of arpeggio direction and mode, MIDI CC data or send OSC message data.

PRESETS

Allows all 49 presets to be saved as an XML file by selecting the write button on the UI. Upon restart the XML file can be uploaded by selecting the read button on the UI.

MATRIX

The matrix shows which page is currently selected and the monome matrix graphic indicates current LED data. The monome matrix graphic itself is for display purposes only.

For visual explantation please refer to the visual overview.pdf

CHANGELOG

CHANGES v0.94

( occular mod )

Revamped user interface Revamped monome layout to two layer-structure:

  • play mode
  • edit mode Added velocity page Added shift control on arpeggio page Added chord scale control-column Added orientation switch on the GUI Added clock options to preset system Added midi ports and channels to preset system Extended mode function button to hold/snap back on the GUI Fixed an issue with tilt listen ports Fixed note duration issue (stretta)

CHANGES v0.93

( occular mod )

Changed monome layout to page structure:

  • noteset mode
  • arp/hold mode
  • rate mode Changed scale degree to the far left Added preset system Added host ports switch Added initialise button Added page display over LED matrix Added church-artwork Added visual explantation to the doc Fixed an -out of range- issue

CHANGES v0.85

Added tilt support

CHANGES v0.84

Fixed an issue where note duration scale wouldn't update until tempo was touched Fixed an issue where chord scale wouldn't update until degree was touched Added range control and mode to arpeggiator

CHANGES v0.83

Fixed homophonic issue

CHANGES v0.801_occ_0.2

Fixed external clock sync issue

CHANGES v0.801_occ_0.1

( occular mod )

Added noteset mode Added arpeggio switch

CHANGES v0.801

Fixed stuck notes issue Fixed scale degree issue

CHANGES v0.80

Initial release

download

Current build, version 0.94 by occular {{:app:tintinnabulome_0.94.zip|}}

media

http://vimeo.com/3170703

  • vimeo "tintinnabulome" tag:

http://vimeo.com/tag:tintinnabulome

  • an example from dadek that sounds remarkeably close to Pärt's own music:

http://soundcloud.com/dadek/tin-one

background

Composer Arvo Pärt, a "sacred" minimalist, has developed a compositional technique called "tintinnabulation."

http://en.wikipedia.org/wiki/Arvo_Part

http://en.wikipedia.org/wiki/Tintinnabulation

In its strictest sense, tintinnabulation is a compositional device where one "voice" arpeggiates the tonic triad while another "voice" simply moves stepwise up (and down) the given scale or mode. In practice it can be a bit more varied. Tintinnabulome, as a modal arpeggiator, creatively pairs the compositional device of tintinnabulation with the "decoupled grid" of the monome. So (sacred) minimalist technique meets (technological) minimalist interface.

toneclock

This app requires monomebridge in order to work properly with serialosc.

A dual keyboard harmony app based on peter schat's tone clock ideas.

created by: Sean Pierce (stevieraysean)

prefix: /clk

use the two arms on either side to select the intervals from the root note you want to use from 1 semitone to 11. the left one starts at the bottom and the right one starts at the top. two 3x6 keyboards in the middle are playable to different midi outputs. there is also a tap tempo and two pattern recorders in the gap at the top and the steering buttons are in the gap at the bottom. check the info.pdf for button layouts.

media

TR-256

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

Drum sequencer emulating roland-style pattern programming.

created by Stretta

prefix tr256

description

A pattern can have up to 16 steps, but any length up to 16 steps. One pattern can be written while another is playing.

The top row determines which pattern is playing.

The second row determines which pattern you are editing. This is so you can edit one pattern while playing another - it is deigned to be played 'live'

If you hold down an edit button while entering a step, TR-256 drills this edit down to all layers. This enables you to make one master pattern, then make individual variations on that pattern live.

The third row is the pattern length of the currently edited pattern. The length of the pattern is editable. If all 16 are lit, this is a 16 step pattern.

The rest of the buttons simply edit the currently selected pattern. Each horizontal row outputs a MIDI note. Lit LEDs trigger the MIDI notes at that step location.

Although this app is primarily a 256 app, it should also mostly work on other units. If you're using a 64 or 40h, you'll see 'half' of the steps. You can set the loop length to the eighth LED and you'll get sensible results.

TR-256 evolved into residue.

trails

midi cc slash live parameter interpolation looper

created by: kramer

use your fingers to draw trails in any direction, to which the button depress is delayed a definable amount. users can have 1-8 nodes; a node is a circular, movable, resizable, 2D representation of a parameter you want to play. the closer you drag your fingers to a node's center the higher the value. changes can be recorded, looped and overdubbed, but not stored. depending on how many nodes you have enabled, their size and position - interpolation between parameters is unavoidable and typically unpredictable. as an example; you could have 1 node which could be like one knob, 2 could crossfade between your choice of parameters or you could activate a whole mess and see what happens.

version 2 adds support for arc 2 or 4 as well external MIDI controllers, presets for nodes' size and position, preset morphing and automated preset switching.

trails m4l screenshot

traknome

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

a series of Traktor Settings Information files (*.tsi) that allow communication with monome devices over a virtual midi cable (optimally used with the monome 256)

created by: John-Paul McCarthy

trigger sequencer

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

By: Stretta

trigger sequencer has eight rows of events, each can loop polyrhythmically. It can send MIDI notes, or trigger a simple release envelope via MIDI CC.

whiz

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

written by jason r kramer for the 40h/64

whiz is a simple random or manual input 28 step MIDI sequencer and an x/y lfo editor for visual control of MIDI cc messages. version 0.2 includes many improvements including sequence storage and recall, lfo smoothing, randomizer step size control and more.

requires max/msp + monomeserial with prefix set to /whiz

xor

inspired by axon (by the fine people at http://www.audiodamage.com who deserve your support!)

a mix of muon and flin in some aspects

created by: tehn

http://vimeo.com/14159606

notes

two monome-controlled modes: "values" and "links"

hit space bar to toggle between modes.

each channel (1-8) has a set value. each channel accumulates triggers from other channels. when a channel's collected triggers is more than the set value, this channel sends out its own trigger, sets a new rule, and plays a note, and resets itself to accept new triggers.

ch 1 is driven by the metronome (sync/time) box. you can midi sync this in/out. the subdivision dropdown sets the note length.

in "values" mode each key touched sets a new value, also resetting the received trigger count.

where a channel trigger is sent is controlled by the "links" matrix. for example, channel 1 could be set to send to channel 3 and 4, while channel 4 sends to channel 2, etc. each channel is a column; its destination triggers are set from top to bottom. a channel cannot trigger itself.

the "rules" dropdown gives several options which can be executed. the number next to the rule is the to-be-changed channel. for example, on channel 1, with a rule of "random 1", upon each reset a random value will be set (see video for an example of this). you can cross-map for interesting effects -- try setting ch 1 to "inc 1" and ch 2 to "min 1," having ch 1 send triggers to ch2.

lastly, midi setup is at the bottom.

  • m mute
  • n note
  • v velocity
  • d duration

video/midi

back to top

64videofingers

created by: egon77

DESCRIPTION

64 Videofingers is a live performance app designed for making music out of video clips. You can play all the video clips live or you can layer them using the four pattern recorders. Be sure to check out the manual for more detailed information.

You will also need to install the v001 shaders (designed by vade) in order to get the composite modes working. You can find the download link and install instructions here: http://001.vade.info/?page_id=6

https://vimeo.com/6255134

Incisor

This app requires monomebridge in order to work properly with serialosc.

This project uses http://troikatronix.com/isadora.html Isadora to read MIDI coming from a molar instance and control corresponding videos for real-time manipulation and performance.

created by: Momo The Monster

prefix: whatever you use for Molar

Incisor looks for MIDI notes coming from Molar and translates them into position and visibility data for movies playing within Isadora. You can fully utilize this patch using the demo version of Isadora -no watermarking or expiration. The only function you will not have is saving, meaning you will have to load up your movies each time.

tutorials

http://code.google.com/p/incisor/wiki/GettingStarted

media

http://vimeo.com/3025900

jellyfish

mix movies

by scott -- http://dinosaur.freeshell.org

for syl

http://vimeo.com/87164091

when the app starts, it randomly picks 2 video clips from the jellyfish/data folder.

they play at the same time, clip 2 atop clip 1.

kinda like jellyfish.

controls

controls run down the left and right sides.

  • a+/- : change alpha (transparency) of clip 2
  • r: red
  • g: green
  • b: blue
  • s+/-: speed up/down

press anywhere else on a clip's side to skip around the clip.

requirements

  • a 128 or 64 grid (256 may work but is untested)
  • some cool videos
  • processing
  • oscp5 library for processing
  • to know your monome's port number. the easiest way is by looking in the monome test app after "monome 128"

for cool videos, try https://archive.org/details/movies

start up

  • put a bunch of (short) movie files into jellyfish/data
  • open jellyfish.pde in Processing
  • enter your port number in the very first line of jellyfish.pde
  • enter your monome width in the second line
  • press the play button in the top left

scmodular

max for live

back to top

act

act is a loop recorder/trimmer for arc4 & m4l

created by: pewt

bounds

This app requires monomebridge in order to work properly with serialosc.

Please look at demonstration video. http://vimeo.com/18504974

This is the app ported 'boiingg' to M4L. The boiingg is a bouncing midi pattern generator monome app written by Jules(pixelmechanic).

boiingg document http://docs.monome.org/doku.php?id=app:boiingg

Pixelmechanic site http://www.pixelmechanics.com/

SETTINGS If you want to use bounds with 256 or 128h, please change height menu from 8 to 16.

-- ChangeLog -- v1.1 supported monome256 and 128height. v1.0 added menu to switch original mode and trigger-invert mode. v0.9 bug-fix the pitch, vel and dur of each rows. v0.8 bug-fix the step-velocity. v0.7 bug-fix the note-off timing. v0.6 Appended the note-off sustain mode. v0.5 Appended the step velocity function. v0.4 first release.

depthoffield

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

I got frustrated with certain applications not performing reliably due to auto focus. So I took a long hard look at how stretta did it and made a seperate application you can use to change the prefix by track focus.

Put this on any track, write in a prefix, and when that track is highlighted that prefix will be sent to monome serial

created by: TheAlphaNerd

with credit to: stretta

and of course: tehn

derp

derp is a simple Max For Live thing that lets you use a monome grid or arc as a control surface in Live. watch the walkthrough video:

http://vimeo.com/44092018

ben@desync.com

dj64effectm4l

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

effects section from dj64 for max4live

created by: sean pierce (stevieraysean). Bitbasic - original dj64.

prefix: /dj

Effects include: stutter, gate, granular time stretch, pitch shift, flanger, ring modulator, scratch and delay. these are accessed through the 4th column on a 64 monome. the 3 column to the left are for controlling the effects and the 3 to the right control the volume of the input signal. the bottom row is a crossfader for switching between different instances of 64fx. place the djfx master in live first and then use the other djfx file in other tracks and they will be on the crossfader in order of creation from left to right. the top left button can be used as tap tempo when sync is unengaged.

dubb

dubb is an effect plug-in, for creating spacey, dubbed-out soundscapes

created by: pewt

I haven’t seen that many monome patches that incorporate effects and live processing (though there are some really awesome ones, like DJFX), so I thought it would be fun to make a performance oriented delay/reverb patch.

Since acquiring a second monome, I’ve realized the benefits of having an entirely effects oriented patch- kind of a secondary patch to compliment a set of samples or a midi instrument controlled by another monome.

I’ve added a bunch of different features to dubb, with the overriding philosophy that it should be playable, simple, and operable (almost) entirely from a single monome 64. A lot of the stuff I’ve added is locked to a certain value: for example, the low pass button cuts only to 700hz. Feel free to open up dubb and edit to taste- the patch is pretty simple I think.

That said, this is also my first Max patch to involve sound processing as well as control- let me know if there are any weird kinks.

I also want to thank my friend Jonathan Moran, from jm-dsgn.com for helping me with the artwork.

PS: I included a couple possible sirens with the download- feel free to use them (one is from freesound.org, the other is my moog)

http://vimeo.com/20044017

flin m4l beta

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

This is a beta version of the popular app Flin by Tehn created in a M4L version for the monome 64 and 256!

created by: Tehn ported to M4L by Scrubber Fox

prefix: /flin

flin is a cyclic poly-rhythm MIDI music box.

gs.suite

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

gs.suite is a collection of Max for Live patches built around basic interactions with Ableton Live.

created by: griotspeak

liiive

liiive is a Max For Live app allows to control Ableton Live and more (with modules...).

it was designed to take full advantage of variable brightness 256 and arc 4 with "push" button. Currently, this app doesn't work with monome 64, 128 and 256 without variable brightness, essential. Arc 4 is optionnal.

created by: alexaugier

Further information

Folder .zip contains M4L file liiive_v1.0.0.axmd, the user manual liiive_doc.pdf and the first audio and midi module folders live_module_keeeys, live_module_transport and live_module_ml(ive)r.

Check the PDF in the download .zip for more info.

http://vimeo.com/72724847

live clip chopper

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

A Max4Live device for controlling the playing position of clips within Live.

MLR mash-up business in Live!

created by: Myralfur and Nonagon.

prefix: /0000clipchopper

m4lcl

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

M4L Clip Launcher for Ableton

created by: Myr

prefix: /m4lcl

m4ldr

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

Midi Drum Rack Input and Control for Ableton.

created by: Myr

prefix: /m4ldr

ml(ive)r

ml(ive)r is an adaptation of Tehn's mlr for Ableton Live (Max For Live). It allows to play in mlr style directly with the Live audio clips (also allows to play reverse and stutter processing).

For Monome 64, 128 and 256.

Arc 2 and 4 are optionnal (allows to play in scratch style).

created by: alexaugier

Thanks to Karaokaze and Galapagoose for the incredible support.

http://vimeo.com/73208238

mlr 2.27 max for live

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

created by: tehn (brian crabtree) 2006, max for live version: stevieraysean (sean pierce) 2010 thealphanerd edit 2010

prefix: /mlr

mlr 2.27 for max for live. put in your 'max audio effect' folder. has all the same functions as 2.27 only some added multi-channel outputs. drop the 4 different outs files (in the 'multi outs' folder) into the channels in live you want that groups audio to go to. next check the 'multi outs' box (this will disable the main output of mlr. the multi outputs will add a little latency as using send~ audio is not currently supported in max for live. this uses the old plugsend~ objects.

you can save and load all your presets/sets as normal. you can drag and drop .wav and .aif files from the live browser. you can also record directly into the buffer from the audio or midi channel you put mlr into.

monolive

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

MonoLive is a monome based controller for Live.

created by: monohusche

prefix: monolive

features list

advanced clip launcher with session matrix navigation
EQ + mixer controller
device controller
send controller
dummy clip controller
loop controller
XFader control
router to integrate additional M4L apps, such as MonoLive or MonoParaSteppa.

monomidi

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

MonoMIDI is a scale-based MIDI clip step sequencer to be used for drum patterns and melodic material. It works standalone or as part of MonoLive.

created by: monohusche

prefix: ###monomidi (if used standalone)

features list

support for MIDI clips with up to 64 steps (1 step = 1/16 note, which makes it 4 bars) and 49 drum pads (or 7 octaves when using scales)
Full scale support including chromatic mapping and other custom scales
Scale conversion
advanced duplication facilities for partial note sequences
supports velocity and note placement humanisation within range (“note pull/push”, low/medium/high velocity)
MIDI overview mode for selection of MIDI clip section to be controlled
Multisample mode (8 samples per note lane) and variable probabilities per sample
Probability mode (driven by note velocity)
Adjustable note length
Playhead visualisation
scene navigation
works standalone and integrated into MonoLive (see MonoLive documentation)

MonoParaSteppa

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

MonoLive is a step-based parameter modulation device for Live, to be used standalone or as part of MonoLive

created by: monohusche

prefix: ###monoparasteppa (if used standalone)

features list

Step Sequencer Control of up to 6 device parameters and up to 64 steps
storage/recall of parameter assignments in Live sets
Random timing intervals
Drag'n'drop of LFO waveforms into step sequence
Continous-random mode
Ability to sync sequence with playing clip (activate using lower toggle, default on)
Timing multiplier for longer intervals up to 32 bars
Quantization setting
2 Glide modes (fast and slow)
Full synchronisation between device and monome
Multiple sequencer directions
Randomisation of step intervals, quantization and time multiplier (flexible range)
can be run standalone or integrated with MonoLive

myr monome handling

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

primitive for max and maxforlive that allows you to use Auto Config protocol as well as AutoFocus and Manual configuration.

created by: Myralfur

prefix: na

Use this patch as a bpatcher or patcher in your patches to handle connecting your monome to monome serial or a routing app. Read instruction in the patch on how to use this as a primitive in your own patches to gain both Auto Config and Auto Focus.

plinkonome m4l

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

orginal created by: jp

m4l version by: heuristic

prefix: /plinko

to be used as midi insert in ableton live. click at the top or anywhere and the sequence moves downwards. notes will conform to scale and mode you select.

  • sequence clock is locked to live's. the interval selects note quantization.
  • new note support for the rows and default scale button
  • the sequence will stop and clear if you hit then release on specific buttons. these are buttons that have the same number for both coordinates like 0,0 1,1 and so forth through 7,7. this is a bug but it is actually helpful and makes it a bit more musical to use.
  • has only been tested within OSX 10.5.8
  • now with 64 and 256

feel free to add and better what's been hacked together

pulse

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

A Max4Live device which pulses the monome's LED intensity in sync to current tempo.

created by: narbotic/Collin Cunningham

prefix: n/a

Pulse requires no prefix to be specified, therefore it works well in combination with other monome apps/m4l devices (tested w/ pitches, polygome64, Press Cafe).

In addition to note interval, the minimum and maximum brightness levels can be set in order to soften the throb/pulse effect. The initial max/min settings can be inverted to control whether LEDs go dark or light on each beat. The “set max as default” button can be used to set the monome's default brightness.

raptor

raptor x (by pewt)

midi triggers + pattern recorders

the bottom seven rows are midi note triggers- you can change the scale and key with the menus. pretty standard midi keyboard replacement (like pitches or balron)

its the top row that makes things interesting- press any of the buttons on the top row and you open the gate to one of 8 loopers. recording starts when you play the first note, and the phrase loops in metrical time (you can set the intervals for each looper with the menus). a second press on the top row kills the loop

by alternating loop lengths, and creating phrases that trail and intersect, you can achieve some pretty nifty stuff...

ver 1.01 sacrifices the 8th pattern recorder for a mute switch: hold down the last button on the first row, the press the patterns you want to mute/unmute

ver 1.02 adds autofocus

raptor x adds a bunch of stuff:

  • chromatic scales
  • musically literate scales
  • custom scales
  • the ability to change the loop length on the monome
  • serialosc support
  • flush button
  • transpose function

video demo at: http://www.vimeo.com/11390373

RE:MIX

realtime sampling, slicing and re-sequencing. concept based on the monome application MLR.

Max 7 / Live 9.2 or later required. 
old Max 6 version is here https://github.com/el-quinto/mix/releases.

re:mix is essentially mlr, finely tuned and greatly expanded upon for a new life in max for live. it takes inspiration from many variations released over the years, particularly the mlr3 preview, mlrv, and mlr_cyst.

mlr is a monome application by Brian Crabtree. if you haven’t tried it, i’d highly recommend u start there. re:mix will make much more sense if you do.
———————————————————— 
installation
this can be done in a variety of ways, but the absolute easiest method, is to place the downloaded folder wherever you’d prefer on your hard drive, then drag it into Live’s browser, under PLACES.
-upgrading from a previous installation- just replace the previously installed folder or folder's contents with the newer files.
————————————————————
quickstart
Load the re:mix device onto an empty midi track. Group 1-6.amxd's are the audio outputs for each group. load these on separate audio tracks to get audio for those groups (and led movement). then drag wav, aiff, or mp3 files from Live’s browser, Session or Arrange view to the re:mix interface to load them to the desired row. Files/whole folders of files can be also be loaded by dragging from Finder. that’s about it, mash buttons and have fun!
————————————————————
live sampling
place the input.amxd on the track you want to record. you can load multiple instaces on different tracks, and each can be set to record to a different input buffer (1-8) in re:mix
————————————————————
midi in/out- re:mix recieves all press data and can output it as midi (if midi out is enabled). you can also send midi to the device to trigger press data. since midi only has 128 values, you need an additional midi track with the midi(row9-16).amxd for midi to/from the bottom 8 rows of a 256.
name piano roll.adg - placing this on the re:mix track makes it so u can see the row/button names on the piano roll.
———————————————————— 
sends/macros- you can control the values of the first 4 sends and first 8 device parameters on each group’s track for each row. when u trigger a sample, the sends/macros will jump to whatever values you have set for that row in re:mix. (send / macros toggles must be on) there’s an ’example macros' effect rack included to get you started, but the fx are purposefully cheesy to encourage you to experiment and make your own. (tip- try sidechaining in your racks!)
———————————————————— 
click Info in the setup tab for keyboard shortcuts!
———————————————————— 

128/256 top row controls:
1-6 stop playback for groups 1-6
7-8 modifier 1 and 2 (previous/next input when pressed quickly)
9-12    start/stop+erase pattern record
13  previous preset (mod 3 when held)
14  next preset (mod 4 when held)
15  macros toggle (can be momentary when held) (pattern recordable)
16  sends toggle (can be momentary when held)

Mod Functions
1-6 (with mod 1 held)   decrease volume for group 1-6
1-6 (with mod 2 held)   increase volume for group 1-6
1-6 (with both mods 1+2 held) mute/unmute group 1-6 (momentary when held)

9-12 (with mod 1 held)  pause pattern (press 9-12 again without mod held to resume)
9-12 (with mod 2 held)  overdub pattern (only works if pattern already recorded)
9-12 (with both mods 1+2 held)  erase paused pattern

13 (with mod 2 held) global octave -
14 (with mod 2 held) global octave +
15 (with mod 2 held) global reverse

Mods 3+4 (previous+next preset) = Record Go

9  (with mod 3 held) - step length page
10 (with mod 3 held) - reverse page
11 (with mod 3 held) - group page (columns 1-6 = groups, 7-8 = row vol, 9-12 = play mode)
12 (with mod 3 held) - octave page
(pages are momentary if you keep holding mod 3 after selecting)
15 (with mod 3 held) - set  next tempo 

11 (with mod 4 held) - record length / record select page
12 (with mod 4 held) - file page
15 (with mod 4 held) - punch-in
16 (with mod 4 held) - tap tempo

(press both mod1/2 buttons or either mod3/4 to exit pages)
——————————————————————————

64 top row controls: 
1-4 stop playback for groups 1-4
5-6 pattern recorders
7-8 modifier 1 and 2
1-4 (with mod 1 held)   decrease volume for group 1-4
1-4 (with mod 2 held)   increase volume for group 1-4
1-4 (with both mods held)   mute/unmute group 1-4 (momentary when held)
5-6 (with mod 1 held)   stop pattern without erasing
5-6 (with mod 2 held)   overdub pattern (only works if pattern already recorded)
5-6 (with both mods held)   preset - +
quickly press mod1 or 2 to trigger send/macro switches

sevenuplive

SevenUp Live is a MaxForLive application that combines 8 different monome applications into one interface. With it, your monome communicates with Ableton Live and allows MLR-like functionality along with other goodies like sliders, sequencing melodies, creating patterns of beats, saving/loading your songs, and more.

http://vimeo.com/7877824

shfflr

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

m4l mlresque 64 pad modular looper — current version b8.6.7.1 as of 7November2011

created by: lokey

prefix: /shfflr by default, but as you like it.

Shfflr is a modular audio component set up to allow multiple applications on a single monome device. It’s designed to sit on the top or bottom of a horizontal 128, running 4×16. load it into a return track or somesuch, and pipe audio at it. By default, it should load in the top 4×16 of your 128. By using the same prefix and port, and allowing toggling up and down within the patch, you can easily control two or more copies on a single 128, allowing you to cut up two separate input feeds at one time. Or drop in a modular midi component (coming soon) and control a step sequencer chordbox on one half, while you cut up the audio output on the other half. That’s the dream anyhow. If you are running an app switcher of some kind, then even more is possible. However, there are some pretty long buffers used, so it may get pretty boggy as you add more. Four copies placed in serial run fine on my core 2 duo macbook pro, your milage may vary…

terms

Terms: Sum pulled apart. A collection of essential monome applications, synchronized and integrated within Ableton Live 9.

Terms is a collection of Max for Live Devices working together to create a complete performance system within Ableton Live. Each device implements a monome application, incorporating a unified interface within Ableton Live. These apps are simplified for easy exploration with enhanced visual feedback for vari-bright grids.

Expanded versions, and other Max for Live adaptations of grid-focused apps are available from community member elquinto’s github.

thisinstance

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

this instance is a maxforlive primitive that solves the issue of multiple unique instances of the same plug-in inside a live set.

trails

midi cc slash live parameter interpolation looper

created by: kramer

use your fingers to draw trails in any direction, to which the button depress is delayed a definable amount. users can have 1-8 nodes; a node is a circular, movable, resizable, 2D representation of a parameter you want to play. the closer you drag your fingers to a node's center the higher the value. changes can be recorded, looped and overdubbed, but not stored. depending on how many nodes you have enabled, their size and position - interpolation between parameters is unavoidable and typically unpredictable. as an example; you could have 1 node which could be like one knob, 2 could crossfade between your choice of parameters or you could activate a whole mess and see what happens.

version 2 adds support for arc 2 or 4 as well external MIDI controllers, presets for nodes' size and position, preset morphing and automated preset switching.

trails m4l screenshot

velocity

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

velocity is a drum sequencer

created by: pewt

prefix: /velocity

velocity is a drum sequencer intended to work with raptor.

I'm kind of a drum machine geek, so velocity is inspired in part by my favorite drum machines, most notably my 606, my roommate's rhythm king, and my MPC.

the app can control 16 midi triggers per instance (the default setup is chromatic, for drum racks). the top row (row 0) switches between 8 16-step sequencers, which run simultaneously. each step sequencer controls two of the midi triggers- you can program the sequencers on rows 1-4: steps 1-8 are programmed on rows 1 & 2 (row 1 being the first trigger, row 2 being the second trigger) , steps 9-16 on rows 3 & 4.

the bottom two rows (6 & 7) are raptor-style midi triggers that are un-quantized to the step sequencers, so looser “feel” parts can be added as necessary. you can program a straight ahead, stiff beat, and then drop some loose cymbals or tom rolls to give it a bit of flavor.

the first four buttons on row 5 are raptor-style pattern recorders for the bottom two rows.

finally, buttons 4-7 on row 5 indicate the location of the playhead in regards to the step sequencer: each button will jump four steps, so button 4 jumps to step 0, 5 jumps to step 4, 6 to step 8, and 7 to step 12.

with repeat toggled off, pressing one of the buttons will jump to the corresponding location in the step sequencer (it won't affect the pattern recorders, so you can still have an alternate sequence running counterpoint). if you turn repeat on, pressing one of the buttons will continuously jump to that step. with the “repeat duration” amount at 8th or 16th notes, you can get some nifty snare rolls and transitions, and with 32nd or 64th notes, things can go all IDM- if that's your style.

wolves_m4l

make your inputs howl... now in live, with serialosc support.

created by: dataplex

updated and ported by: chrlstnptrck

this is an update and port of dataplex's lovely wolves patch, letting you howl and growl inside of live. the top row triggers chimes, made from sinusoidal peaks of the input signal. the next rows will do the same but also transpose each sinusoid by a harmonic interval.

drop it on a track.

play a recorded clip or input live audio.

turn up the gain.

begin howling.

https://www.youtube.com/watch?v=QdlDadzOIWE

m4l.arc.device.controller

This is a very simple app which allows an arc2 to control the appointed device in Live.

created by: declutter

audio/built-in sounds

back to top

cycles

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

6 cycle~ objects at different frequencies for the monome 64

created by: vinceent

prefix: /cycles

MAX5. this is my first monome app. it is quite simple. it uses the cycle~ object . you control frequency plus channel volume. theres is a total of 6 cycle~ objects. first and last row are faders for channel. bottom row is on/off toggle of each cycle~. each channel has 3 cycle~ going through it.

inkblot

Additive synthesis patch with rorschach patterns. Available for 256 and 64, use 256 version for monome 128.

created by: Amanda Ghassaei

http://vimeo.com/35861489

mnmewvtbl

This app requires monomebridge in order to work properly with serialosc.

Author: unsymbol

Prefix: /box

Description

mnmewvtbl is a 3-bit by 3-bit monome waveform editor for pd. the 8 x 8 grid is a representation of an audio waveform, whose shape is controlled by the grid.

Media:

http://vimeo.com/13121970

ohm

This app requires monomebridge in order to work properly with serialosc.

created by: dataplex

prefix: /klive

Harmonic theory was established back in Greece (590 b.c.) by mathematician Pythagoras. To make a long story short, his teachings focused on a three dimensional model called the Lambdoma. It's formed by combining the ratios of the arithmetic, harmonic and geometric series into one form.

This patch maps out a 8x8 lambdoma-matrix of ratios, so that a given frequency may be harmonized according to the pythagorean ratios. Kind of the //Monochord// of the 21st century...!

for more information read this;

http://drewlesso.com/index.php?option=com_content&task=view&id=81&Itemid=36

...and check out barbara hero on google.

http://vimeo.com/klive/videos

http://www.myspace.com/kliveisklive/

PIPEDREAM

http://vimeo.com/42000325

Expressive Interactive Live Chord Builder for 40h (64) + Arc2.

Features

pipedream is a software instrument made for people who want to use the arc in a performative, melodic way. Much like a bag pipe'd be used.

pipedream utilizes the sensitivity and LED feedback from the arc in explorative and clear ways. It is a developing tool in the art of subtle manipulation.

Instructions

Turn the DSP on

  • Connect Arc + Grid to pipedream.

When your Monome starts smoking, simply click the Begin button underneath the SerialOSC windows.

Once the Begin toggle box is unchecked, the monome window becomes a display window. The flashing buttons represent scale degrees,

  • Root
  • Minor Third
  • Major Third
  • Perfect Fifth
  • Major Seventh
  • + Octave

selecting one of the flashing scale degree selects a note that the arc's first encoder will combine when rotated clockwise.

This is the magic of pipedream.

The two rows to the right of the flashing row are a 13 step keyboard, and to the right of that is an LFO manipulator (scale) and an octave UP and DOWN (top and bottom buttons of the right-most column).

Open up the pipedream, and pack a little dream for meeee..

ALSO, open up your favorite VST and connect the keyboard to your favorite BASS sounds for added control!

Arc Mapping

Encoder 0 controls the rate of digital oxygen being blown into the instrument. This utilizes stretta's INERTIA arc primitive.

Encoder 1 controls the LFO through which the bagpipe plays through!

created by: Declan Murphy -- http://arc-monome.tumblr.com

skr

charged up bits release tones

Author: tehn

Description

something like charging up bits by holding them down, then they decay and let off pulses until they are silenced again. visuals follow. lots of options to play with, but pretty much a toy.

straw

created by: stretta

straw is a simple FM synthesizer adapted to the monome interface. The x-axis is pitch and the y axis controls the amount of modulation of various synthesis parameters.

To get started, turn on DSP (double click on dac~ and configure), and select a preset.

http://vimeo.com/16173049

teletype

event script typing magic

https://github.com/monome/teletype/releases/latest

teletype is currently driven by meadowphysics

how it works

meadowphysics sends trigger messages 0 to 7 whenever the corresponding rows counters hit zero.

whenever this occurs the relevant event box in teletype is triggered.

this text box can be scripted to enact changes in the synthesizer (or midi output), and multiple lines are allowed per event.

an example event, say in the top-left box:

note 4;
cc a rand 50 100;
p 50 note rand note;

this event happens when the the first meadowphysics row is triggered, sounding note index 4 and creating a cc value between 50 and 100 on cc channel a, and a 50% probability of playing a random note.

note index 4 refers to the 4th note (from low to high) selected in the tone series (highlighted keys on the keyboard). cc a is assigned to the top listed slider. the sliders represent the current value.

presets store pretty much everything. they can be manually recalled or recalled with an event:

preset 1;

this allows for some pretty weird stuff. this is maybe enough information to get you started.

theremin

theremin for monome arc2

created by: Meng Qi -- http://mengqimusic.com

2 knobs on arc : 1 for loudness/timber morph, 1 for pitch

2 sound sources : fm and bandpass noise

2 pitch modes : unquantized and quantized (thanks to ScaleMaster http://xfade.com/max/ScaleMaster/)

2 vst send effect

preset system saves everything inluding the vst plugin filepatch and settings

notice : please install scalemaster before use http://xfade.com/max/ScaleMaster/

tutorials

  • left knob = initial value
  • middle knob = from which knob position the timber morph begins
  • right knob = mod depth (left is negative, right is positive)
  • the [R] beside knobs will reset the corresponding knob to center

triggers

http://vimeo.com/91878748

https://github.com/SorenAndreasen/triggers/releases

triggers is a flexible module-based synth environment. you start out with a blank grid and shape your interface the way you want it, by making operators in forms of different shapes.

requirements: monome 15-vari-bright, 64/128/256

recommended: 128/256

edit/play

  • bottom leftmost button switches between play/edit mode
  • edit mode: make/delete operators by pressing appropriate shapes
  • play mode: interact with these operators by touching them as described below

operators

oscillator

  • x = not yet assigned
  • pressing all 4 cells toggles mute on/off
  • freemode: when holding a mode and a param button, releasing the mode button first will make the param dec/inc until stopped again.
    • stopping freemode is done by releasing the mode button last

envelope

the connector button

  • while holding the connector button:
    • Pressing any of the 4 cells in an oscillator connects/disconnects the envelope to that parameter. active connections are displayed with a lid cell.
    • Pressing anywhere in a sequencer, places the envelope there
    • NOTE: envelope diagram in "help" in triggers is displaying incorrect positions. will fix with next update.

sequencer

  • edit mode: exactly two presses in one line
    • can be horizontal or vertical
    • vertical and horizontals can overlap, thus triggering the same notes in the intersection
  • play mode:
    • 1 press: jumps to position
    • 2 presses: makes innerloope
    • 3 presses: changes tempo

credits

thanks to brian for letting me build upon a js for detecting shapes that he made

thanks to trent for inspiring conversations

thanks to kelli for useful feedback and an aeropress to keep me up at night

features for 1.0

  • arpeggi operator to do rapid pitch changes on oscsillators
  • step presses will have finer quantization also on slow tempo
  • envelope parameter visuals will have double the detail
  • possibility to make merging sequencers' playheads enter each other
  • combining envelopes
  • LFO mode for oscillators
  • sequencers can hold several envelopes in one cell
  • when holding an envelope connecter, only that envelope's active cells will show up in sequencers
  • visualization for param freemode if it's on

vnois

Author: unsymbol

Prefix: /box

Description: vnois is a step sequencer with built-in synthesis & effects for monome & arduino. some parameters can be modulated by the performer, whilst others are controlled by generative processes. if you would like to use vnois with an arduino to control the six knobs then download {{:app:vnois.zip|vnois}} & upload simplemessage system to your arduino (available in arduino 0004 & up). else download {{:app:vnois_noarduino.zip|vnois_no arduino}} & use the knobs in the patch to control the effects.

Details:

  • knob 1 - tempo
  • knob 2 - volume
  • knob 3 - eq wet/dry
  • knob 4 - null
  • knob 5 - feeback delay
  • knob 6 - feedback delay

Requirements:

[polywavesynth] abstraction: http://www.pkstonemusic.com/polyWaveSynth.html

Media:

http://vimeo.com/13147753

WEDJAT

http://vimeo.com/41663709

Time Bending Beat Station for 40h (64) + Arc2.

Features:

wedjat is a software instrument made for people who want to use the arc in a performative, rhythmic way. Much like a turn table of the 2012 kind.

wedjat utilizes the sensitivity and LED feedback from the arc in explorative and clear ways. It is a developing tool in the art of subtle manipulation.

Instructions:

  • Turn the DSP on
  • Connect Arc
  • Grid to wedjat.

When your Monome starts having signal flares, simply click one of the four quadrants of your grid.

This toggles on one of three pre-made drum kits (which are all replaceable in the max window, or the application folder.)

All you need, now, is to tap the arc knobs slightly, and begin finding the rhythm that is most suitable to you.

Finally, the fourth quadrant is hooked up to the internal microphone in your computer. Simply hold down one of the center four buttons of the fourth quadrant to begin a live recording into two- second buffer. These sounds are playable only after recording, so make sure to get them in there first.

(hint: I hum melodies or run an analog synth right next to the mic for odd rhythm / melody triggers. Experiment, friends!) each of the four

Arc Mapping:

Both Encoders work as ultra-sensitive drum hits. Clockwise movement strikes one note, while counter clockwise strikes another.

created by: Declan Murphy -- http://arc-monome.tumblr.com

design

back to top

Bit Rain

created by: ** 2D10 **

This patch was inspired by the http://vimeo.com/290706 video by tehn.

For any questions, comments, suggestions etc. please post on the monome forum thread:

SETUP

  • Connect monome to serialosc
  • Select led option (regular or discreet)
  • Double click on colmask boxes to make a column pattern
  • Pick individual or global speeds
  • //Choose column levels if using discrete level device//
  • Click start/stop toggle

SAVING

To save a pattern in the preset box (grey thing with little circles), hold shift and click on a circle.

  • To save the presets to a file click on write.
  • To load a saved file click read.
  • To clear the presets click clear.

IMPORTANT

  • Click the red button before closing the app or disconnecting the monome.

(Newer devices seem to remember the individual state of the led level and appear to carry them over to other apps. clicking this will return then to full level and clear the monome leds.)//

http://vimeo.com/290706

blinker

This app requires monomebridge in order to work properly with serialosc.

Blinker is an app designed in Pure Data for the monome. It creates a bunch of light patterns that can be controlled through a variety of toggles.

chili

chuck is looping images

by scott -- http://dinosaur.freeshell.org

make animations

  • press buttons to make a picture
  • make another picture
  • continue
  • press play
  • it's good

all controls are on the monome, easy

http://vimeo.com/64641926

(music by https://soundcloud.com/r_o)

features

  • copy current frame to next
  • change speed
  • save/load

requires

  • serialosc 1.2a (nov 2012)
  • chuck version 1.2.1.3 (nov 2009) or later

notes

  • after installing chuck, setup should be easy. chili will autodetect your monome and its size.
  • to get chuck, go to http://chuck.cs.princeton.edu/release/
  • the terminal form of chuck is easier and prettier than the graphical form. all you need to do is change to the chili directory and say "chuck chili.ck"

see full instructions in instructions.txt

clARCk

Arc 4 Clock, with 4 styles of display and some minor interaction. Really just a technical demo to get warmed up.

http://vimeo.com/22323803

created by: JP (nomeist.com)

Open the patch up, connect in the serialosc window and a 4 display clock should start. From left to right, Hours, Minutes, Seconds, Milliseconds. The pulse setting is a quarter hour flashing indicator to make it slightly easier to read (idea borrowed from Cassiels clock, props to Nick!). Pulse flickers at .25 of a second. Press the arc encoders will toggle between the two view modes, single point and progress so far. Turning the 1st and 4th encoder controls the intensity of the on/off states for the pulse.

http://vimeo.com/21906572

dune farm

make poems from taken text

by scott -- http://dinosaur.freeshell.org

overview

  • select text on your computer
  • press put
  • the lights light
  • it's on your monome
  • that's a dune

  • text is automatically distributed over the monome, one word per button.

  • press buttons to paste words back out to a text editor, and make poems.

features include

  • multiple dunes
  • jump button to move around longer texts
  • mix up words
  • pour words from dune to dune

read the full guide in README.pdf

requires

python (2, not 3) and serialosc

frames

currently hosted on archive.monome.org and needs a new home

a minimal frame by frame animation application for the monome and max

letters

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

Letters runs in chuck. each keyboard stroke is assigned its own frame on the 40h.

Created by: tehn

Prefix: /40h

Long description:

  • push a keyboard key, that key’s image is recalled
  • to edit the image, just hit the keypads on the 40h to toggle pixels, all saving happens automatically to the most recently pressed key
  • in miniaudicle, after starting the virtual machine and adding the shred, best click somewhere you don’t want to have a bunch of type show up, like the console monitor

life

written by tehn

an implementation of conway's game of life with sound reminiscent of the apple2.

requires chuck -- http://chuck.cs.princeton.edu

documentation

here are some starting patterns to try (press all at once):

more complex patterns: http://www.bitstorm.org/gameoflife/lexicon/

media

http://vimeo.com/320666

Mirrome

created by: Bastiaan

It basically displays everything your webcam sees on your beautifully low-res monome screen. Mirrored. So you can use it to check your hair or put on makeup or something.

It should work with the 40h/64/128/256 But I've only tried it on my Arduinome 64. Also, it may only work on OSX in Max5 but I think that's what most people use anyway so there.

https://www.youtube.com/watch?v=j67BZ9CKLCI

nerdscroll

https://www.youtube.com/watch?v=9hmE3iyho_0

pepito

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

Alarm Clock for 128 Edition Monomes

created by: Carson Day

prefix: /pepito

Pepito is a simple alarm clock for 128 edition monomes. There are controls for brightness and volume of the alarm sound on the gui. You set the alarm time using the monome (hitting [0,0] will open and close the alarm page). The alarm sound is loaded by the user using the dropfile on the gui.

Sleep

This app requires monomebridge in order to work properly with serialosc.

Sleep is a generative simulation

Created by: tehn

Prefix: run monomeserial concurrently with prefix set to /sleep

Long description: The two fifty six runs this simulation when powered but not plugged into the computer.

Like conway’s game of life but with probabilities and sound reminiscent of the apple2. Parameters change depending on the total population — a gradual rise and decline takes place over time.

16×16 and 8×8 versions included. push a key to begin.

http://vimeo.com/339122

Spectronome

Spectronome displays a sonogram or spectroscope for any mono audio signal.

created by: Chris Arnold (mysteryproducer)

Current features

  • Spectroscope or sonogram display
  • May be displayed at any size (up to 16 columns) or any position
  • Linear or logarithmic frequency scale
  • Linear or logarithmic amplitude scale
  • Optional discrete led level display
  • Simple exponential moving average smoothing function

Grid controls

  • Button 0,0 toggles between spectrogram and sonogram modes
  • Button 0,1 toggles between linear and logarithmic frequency scale
  • Button 0,2 toggles between linear and logarithmic amplitude scale
  • Button 0,3 toggles discrete led display
  • Button 0,4 toggles sonogram scroll direction
  • The last row controls the smoothing co-efficient, from 0 (the left-most button) to 0.5 (the right-most button)
  • Holding down a button while pressing another button will resize and move the display into the rectangle bounded by those two buttons...if that makes sense. Give it a try.

react

a little game in which you press as many (lit) buttons as you can in 10 seconds.

created by: dovemouse

Tetris

Tetris for the Monome platform.

created by: robb

Features

  • 64, 128, 256 modes supported
  • midi output
  • two 256 modes (fullscreen or partial with tetromino preview)

Controls

For 64 (experts only) Top Row Buttons = Rotation 2nd Row Outer Left & Right buttons = Move Left & Right Bottom Row = Move Down

All other sizes Top Row = Rotation Outer Left/Right Rows = Move Left & Right Bottom Row = Move Down

https://www.youtube.com/watch?v=76aViLkzhAc

tiltmap

currently hosted on archive.monome.org and needs a new home

This app requires monomebridge in order to work properly with serialosc.

a large virtual bitmap. hit the keypads to toggle the state, tilt the unit to scroll through the map. wraps at edges, total bitmap is 32×32. lo-fi blips triggered on scrolling depending on density of the frame.

use monomeserial to change the “cable orientation” if things scroll the wrong direction. (or you can change the code if you’re ambitious).

runs in chuck (use miniaudicle for ease of use) with monomeserial concurrently.

prefix: /box

requires an installed accelerometer!

emulation

back to top

Monomodular

Modular Enviroment and Monome- Emulator for Grid Controllers like Livid Ohm 64, APC 20/40 and others

created by: aumhaa

Monomodular is roughly based on a server/client principle, with Monomodular acting as an intermediary between the various Mods and supported controllers. As of version b993, Monomodular allows native communication with patches/M4L devices specifically designed to work with monome hardware, without needing anything else, using SerialOSC.

Supported controllers

  • Akai's APC 20 and APC 40
  • Livid's Block
  • Livid's Code
  • Apple's iPad, using either TouchOSC or Lemur
  • Novation's Launchpad
  • Livid's Ohm64

In addition, there is a custom tie-in script for Livid's CNTRL:R that the author uses: Livid's CNTRL:R

Mods

A 'Mod' is just a convenient name for m4l patches designed to be used with Monomodular. They all share at least one thing: they contain a javascript object that communicates directly with the Monomodular Python script, which in turn communicates with Monomodular embedded _Framework control surface scripts. An explanation of how this works, and examples of ways to use certain parts of the javascript, are contained in the Monomods_help patch that is installed in the folder with the rest of the Mods. Some of the Mods are creations of amounra, while others are ports of Monome patches (mostly Stretta's). Each one will function in an independant way, but they all have several things in common with one another. To learn about the common ground that all plugins share, you should take a look at the How Monomodular Works page. The specifics of each Mod, however, are covered on the following pages that can reached by clicking on the header of each of the following summaries:

Real Mods

  • hex
  • modlink
  • plinko
  • endcoders
  • binary
  • life
  • aumboids
  • monotes
  • swing16
  • loopmaster
  • TR256
  • pressCafe
  • polygome
  • tintinabulome
  • sment
  • boiingg
  • grainstorm
  • xor
  • clipchopper
  • monomods_help

Other Patches contained in the Monomodular suite

  • NomeOut
  • MaxLooper
  • LCD
  • AumPad and Aum256

download

tutorials

OSCream

Monome and Monome Arc emulator for BlackBerry PlayBook and Android. Connects to your computer using TCP over a wifi network. Due to this, you need to run a little server on your computer to forward OSC messages between TCP and UDP, OSCreamServer is a little JAVA tool that was made for this purpose.

http://www.smugrik.org/oscream

created by: Smugrik

tutorials

http://www.smugrik.org/osc/run-oscream-on-the-blackberry-playbook/

serialosc

back to top

serialosc

                 _       _                _
   ___  ___ _ __(_) __ _| | ___  ___  ___| |
  / __|/ _ \ '__| |/ _` | |/ _ \/ __|/ __| |
  \__ \  __/ |  | | (_| | | (_) \__ \ (__|_|
  |___/\___|_|  |_|\__,_|_|\___/|___/\___(_)

   serialosc is an osc server for yr monome

   it is a daemon that waits for you to
   plug a monome in, then it spawns off a
   dedicated server process to route OSC
   messages to and from your monome.  it
   also advertises a _monome-osc._udp
   service over zeroconf (bonjour).

                             wrl@illest.net