Tired of top 40 hits? Pooped on podcasts? Sapped on streams?

What if your radio could generative music that was never-before — and never-again — heard, all from dynamic, algorithmic software?

PatchWork Radio does that with Pd patches. It’s not a new idea, but the radio station here, at least, is modular – not just one patch but any number of patches can be transformed into radio, thanks to some Python scripting. Creator David Guy John notes:

I’ve recently just started up an internet radio station using PureData to stream generative music. The system will load and unload randomly chosen PD patches, synthesize all the audio in real time and then stream the results out.

You can listen to the stream at http://radio.rumblesan.com and more info is available at http://www.rumblesan.com/?p=265

I’m hoping to try and recruit some help to build patches for it as it’s a bit of a daunting task to do just on my own so if you could let people know about it I’d be really grateful.

So, who’s in – does this generate (ahem) some interest or ideas, and might you want to contribute?

It seems fitting that the kind of musical worlds imagined by artists like Brian Eno now can be deployed anywhere in the world, not just generated in one iteration, but in endlessly-transformable versions.

(But can you dance to it?)

Even before Max for Live was available, hackers had found a way of interacting with “secret” APIs inside Live for custom control, allowing them to customize Live’s behavior and make it work more seamlessly with hardware. That included providing something Ableton themselves had not: real, native control of Live via OSC, for more control than MIDI alone can provide. I was assured such hacks would continue to work, and sure enough, they have. Here’s how to get started.

You may wonder, of course, why even bother now that Max for Live is available? Max for Live is a powerful environment for creating instruments, effects, sequencers, and other devices within Ableton Live, and via its access to the Live API, it can even be a tool for customizing how Live works. But it adds an additional layer of abstraction, it is somewhat limited in how much it can manipulate interaction with hardware, and anyone wanting to use your creations will need to own Max for Live and not just Ableton Live. And not only that, but some people will simply prefer scripting in a language like Python to working with visual patching. (There’s still reason to consider M4L, too; see the full link to its “API” for Live, below. But we do have multiple options)

So, with that out of the way, here are the current solutions:

Make your own MIDI remote scripts.

Hanz Petrov has written an intensive introduction to creating your own MIDI remote scripts in Python, using the new Framework classes:

Introduction to the Framework Classes
http://remotescripts.blogspot.com/

Use OSC, via the Live OSC API Hack (or MIDI)

Ableton doesn’t have native support for OSC — unfortunate, given that’s now a feature of major visual applications (Resolume, VDMX, GrandVJ, Modul8, and others). But while we keep bugging Ableton for OSC to be on equal footing with MIDI, you can make use of a special Python hack that provides an OSC API to Live.

If the above scripting seems intimidating – and I can certainly see why it might be – the LiveOSC API is refreshingly simple. Because you can simply send OSC messages directly, controlling Live with tools like iPhone apps or Processing sketches or even hardware could become comparatively simple – and yes, simpler than working in Max for Live. If you only have MIDI, there’s even a MIDI API, too. Here’s where to start:

Complete documentation of the LiveAPI project [assembla]

http://monome.q3f.org/wiki/LiveOSC

Why it’s nice: you can send something as simple as /live/play/clip (track, clip) and trigger a clip. That’s even more direct than the usual MIDI interface.

Most importantly, this now works with Live 8.1. See the video below for an example of this in action:

mlrV4live tutorial (&casio madness) from StevieRaySean on Vimeo.

Check out his Arduinome build documentation, too. (Arduinome is an authorized clone of the monome using readily-available parts.)

The Max for Live way: Live Object Model

Complete LOM documentation at Cycling ’74

And yes, it makes my head spin a little, too. (Or perhaps the word is “oscillate.”)

Max4Live.info (Michael Chenetz) has done a great job of making this a bit more manageable. In the video below, he explains how to use the interaction between Max for Live and Live; there’s also a tutorial on sending messages to a control surface like the Launchpad. But note that some of this can actually more complex, and more hardware-specific (APC/Launchpad-only) than the hacks above. It’s a case in which the hacked version actually works a little better than (cough) the official version.

Max For Live Paths, Objects, and Observers from Michael Chenetz on Vimeo.

My own challenge for myself: just make the Launchpad intelligently control device parameters, something it currently doesn’t do. I’ll let you know how it goes.

Thoughts on the merits of these different approaches? Projects you’ve made using one or another? We’d love to see them.

As multitouch becomes more widely available, there’s an opportunity to re-imagine all sorts of interfaces. And yes, that includes the guitar.

I’m way behind on mentioning it, but thanks to all the readers who spotted the fascinating Misa digital guitar. Strings and frets are each replaced with digital touch controls, and the soundboard touchscreen is set up to control notes, velocity, pitch, and filters. In fact, it makes the guitar more like a keyboard, and less like a guitar. But as with all digital instruments, abstracting the gesture from the actual sound means that you can arbitrarily redefine what the instrument really does.

Engadget wrote up the Misa last month

Misa Digital of Sydney has a bare-bones site and waiting list / queries via email.

Don’t want to wait around on a list for the fully-integrated version? Thinking about how you could just strap an iPod touch or iPhone to an instrument and use that instead? You’re in luck. In fact, if you’ve got an Apple mobile and Ableton Live, you can start right now.

Jim Purbrick first experimented with iPhone performance at an open OSCestra. Unlike the Misa, his guitar remains a real guitar. The addition of an iPhone (or an iPod touch, if you’d rather) is simply a way to augment the instrument. In the grand tradition of the one man band, touch control with the open-source control application Mrmr allows him to manipulate Ableton Live tracks.

The solution is an open source Python hack that connects his mobile device to Ableton Live through Live’s LiveAPI. And incidentally, this solution requires far less effort – and yields more immediate integration – than running a Max for Live device. (I have to point that out, because while I’m impressed by Max’s extraordinary capabilities inside Live, there are practical ways in which direct OSC integration is better for controlling Live itself.)

And good news, Windows users – this all works on your OS, too. In fact, the only problem is the lack of an interface builder for Mrmr on Windows, which is something I think we’ll soon solve. (JavaFX would be a nice choice, as you’d have a cross-platform Java interface that looks nice but runs anywhere, without the pain of developing in Swing. That last sentence will be meaningful only to Java developers; everyone else, pretend I just temporarily started speaking in tongues.)

Details and full instructions for the hack:

An Open Source, Guitar Mounted, Multi Touch, Wireless, OSC Interface for Ableton Live [The Creation Engine No. 2 (Jim's blog)]

Videos

For further inspiration, here’s both the Misa and Jim’s own (real) guitar augmented by touch, in action:

“Okay,” you say to the Web geeks, “I’ve had enough. I don’t want another little app that looks at my iTunes collection and tells me that if I like Lady Gaga, I probably also like Madonna. I want to listen in new ways and, most importantly, make music. What have you got, Web 2.0… 3.0… whatever we’re on now, that I can actually use. I want some of the deliciousness of the future, now.”

“Oh, and another thing – can I patch this Android phone of mine in absurd ways?”

Wish granted.

The latest Music Hackday in Stockholm was filled with the usual simple, first-draft hacks – as it should be; the whole idea is to do something quickly and start something real. But among them were some really strong ideas about how connecting music makers to the Web could do intelligent, new things.

Here are some of the best. Themes emerging:

There is a “there” there. Use proximity, and make location start to help people share musical tastes (and, by the same token, music making).

Put music creation in the browser – without Flash. New JavaScript-based tools can do live synthesis. There’s even a Nanoloop-style sequencer, built entirely with JavaScript and HTML. While these won’t be replacing dedicated music software any time soon, they can have the inverse effect, which is bringing musical creativity to more online apps. (Trust me, it’s more fun than most of what’s on Facebook.)

Make musicians’ online lives easier. Thanks to open APIs, all your gig info, tour info, and music uploads can finally come together.

Get physical. Hacks involving everything from big robotic visualizers to physical radio controls connect open hardware platforms like Arduino and Android.

(And yes, there were a lot of new Android apps, early proof that open mobile development could make a splash.)

Here’s a look at some of the coolest individual projects:

AlbexOne
Data as connected, kinetic sculpture

It’s one thing to talk to a Web API and put the results on the screen. It’s quite another to turn that feedback into a massive, mechanical sculpture.

Ingredients:
One Web API (Echo Nest Java API, for song analysis)
One Google NexusOne phone, running Android, receiving data on wifi and sending on bluetooth
One microcontroller, receiving signals from the Android and rotating a giant, mechanical arm to make a drawing

Here’s hoping co-creators Albin Karlsson and Alex Olwal can send us video of the project working in action.

ProximRadio + Blobble
Making software and hardware proximity-aware

The work by Michael Coffey (github | @eartle) and Jonty Wareing (github | @jonty) may seem at first like more of the usual social song-playing stuff. But it’s really a clever use of Bluetooth and proximity that could have significant implications for listening to and making music with other people in the same room.

Using new clients and servers, Michael and Jonty change the experience of listening to music. As people enter and leave a room, radio feeds respond accordingly. And the experience of “scrobbling” — writing a piece of music played on your computer to the Web — changes from solo to ensemble experience. If you and a few friends listen to Dark Side of the Moon while watching The Wizard of Oz, now all of your Last.fm accounts respond accordingly.

Note, too, that by using the open-source GUI framework Qt4, what looks like a native Mac UI is actually portable across (cough) platforms.

Let’s say you’d rather make music than play it. Well, good news: developed could use these same tricks to build Bluetooth-enabled musical instruments that respond to proximity, not only for social interactions but better-integrated
hardware.

Radio Free Hackday
Virtual radio meets the physical radio object

Simon Hohberg and Robert Böhnke (aka @ceterum_censeo) had a brilliant, simple hardware hack: put the soul of an Arduino mini into a friendly-looking Panasonic FM radio. Result: physical controls for virtual radio, and an actual, local FM stream transmitted back from the computer into the stream.

With some minor upgrades (like a beefier, non-Arduino minicomputer), this could be a self-contained Internet radio. But it’s a reminder that making physical controls for software can be fun, frivolous, and novel. After all, it’s really the way we interact with real-world objects that makes them meaningful.

Webloop
Game Boy mainstay Nanoloop, reimagined as JavaScript

Start with Nanoloop, the unique, elegantly-designed music creation software for the Game Boy. Now imagine it as a browser application – no Flash, no standalone app, but all JavaScript, even down to the audio output.

That’s what Jan Krutisch did with his Webloop, now in its second iteration. It’s a testament to the universality of Oliver Wittchow’s design for Nanoloop, and the growing power of the browser and JavaScript as an open platform on which to make music software.

Synthism
Patching synthesis in online browser modules

This is a bit hard to see in action, so we’ll have to take their word for it. But the idea is compelling – and is another example of the action that could take place in the browser (in this case, with the actual sound work done elsewhere in a more traditional fashion):

Synthism.com our frontend to the powerful BrainBeat compiler, which is also built by the synthism.com team. This gives you the possibility to export synthesizers from synthism.com to different platforms, e.g. as a VST instrument. The flexibility of the BrainBeat compiler allows us to add support for exotic hardware such as FPGAs or special purpose built DSPs found in different hardware synthesizers, making export to such platforms available.

And yes, all of this is meant to be “collaborative,” which could add more dimension to it.

Songkick On Tour from Matt Biddulph on Vimeo.

Songkick on Tour
A Web service that adds information to your trip

It may be technologically less impressive, but part of what I think will make the Web more useful is the use of open Web APIs to reduce the amount of work you have to do to get information. Songkick on Tour is a great example of that: it figures out your travel itinerary from the awesome Dopplr and lets you know what gigs are happening when you’re traveling. I’m a big fan of Dopplr and feel it’s underused; this demonstrates the sort of thing that could be done.

Of course, this quick hack is only the start – it could make it easier for touring musicians to stay on top of information when they’re on the road.

Along the same lines, and on a grander scale…

Holodeck
One place on the Web, all your artist stuff – automatically

“A tool for artists to create their own website with music from SoundCloud, gigs from Songkick or Last.fm, news/posts from Tumblr.”

That says it all, doesn’t it? Instead of adding yet another Web service to keep track of, another dimension of complexity in your life, this mashes together information you’ve already put elsewhere.

Imagine if every time you made a note of something, you scattered it in a different part of the house. Imagine how complex your life would be.

Oh, wait. I don’t have to imagine that. I do that. Anyway, yeah, let’s have the Web not work that way so it pays for the time, electricity, and money it consumes, ‘kay?

Echonest Midi Player

A Web-to-MIDI converter

Internet comes in, music goes out. Connect an Ethernet cable to one side of this gadget (via the Arduino Ethernet Shield), connect the other to a MIDI instrument, and Bertrand Gondouin’s creation plays MIDI music automatically.

Of course, this has other creative implications, like the ability to pipe your own music or musical events to installations, remote players, to rig up an Ethernet- (or wifi-) powered MIDI band, or whatever you might imagine.

And bless the presence of simple, free Web servers, like the one on which this site runs. (Actually, CDM is LXMP – Linux nginx MySQL PHP – not LAMP with Apache, but I digress.)

More cool projects

Tired of embedding a whole Flash-powered player? the hackable SoundCloud JS player is customizable and lightweight. (It’s not Flash-free – you still need Flash as the back-end to decode the audio, as sadly HTML5 still doesn’t mean consistent MP3 and OGG codec support across browsers, at least so far.)

HacKey asks a fascinating question, which is whether people’s musical tastes are related to key.

BuddyJ for iPhone adds a dead-simple, cueable music output. Now, true, this may not look like an all-powerful DJ app, but that’s not the point: it makes the iPhone or iPod touch into a cueable “deck” you could connect to a mixer, etc.

SleepApp is a simple Android demo app, but it also demonstrates – with all the code on Google Code – how to do basic UIs and stream Internet radio, meaning it could be a good starting point if you’re dabbling in Android music development.

More coverage

Five music hacks from the future [Pocket-lint]

New Echo Nest APIs demoed at the Stockholm Music Hackday [Music Machinery, where you can also follow the Echo Nest APIs]

Hacking in Stockholm [A report from Last.fm's LAST.HQ]

48 Hours, 31 Hacks – Stockholm Music Hack Day [Programmable Web]

And here is some rough mobile video of the presentations:

New York?

NYCers, I’d really love to help host a Music Hackday here (I missed the nearby Boston event, but we have some specific folks in NY who would be great to involve.) The only remaining challenge: a venue that can host 100 or 200 people, free. Suggestions?

http://musichackday.org/

All the Stockholm hacks

Max For Live Sneak Peak from max4live on Vimeo.

Suddenly, I have an image of American Ableton hackers patching on their MacBook over Thanksgiving turkey.

After a long, long wait, a public beta of Max for Live is available. The software incorporates the full version of Max/MSP/Jitter – complete with visual output, video processing, and 3D capabilities – with the Live host. Max patches operate with all their usual capabilities as devices inside Live. User interface elements are available to give Max patches conventional Ableton device interfaces, and there are even pre-built elements for useful functions like frequency displays and MIDI patterns. Via the Live API, Max for Live patches are also able to control most elements of the Live interface.

Because of Max’s networking capabilities, Max for Live devices can also be used to route OpenSoundControl data into Live. That isn’t necessarily with the same ease as you might route MIDI, and there’s still no native support in the Live interface, but it is a step forward.

Our friend Michael at max4live.info has been busy documenting the new software. His overview video is at top, and for OSC coverage, see his tutorial [part 1 | part 2].

Updated: Pricing has now been announced.
Max for Live is not included with Live 8 or even (perhaps surprisingly) Live Suite. It will be a US$299 / EUR249 download, available separately, on top of the cost of Live 8 or Live Suite 8. If you already own Max, you’ll have a set of crossgrades available:
1. You own Live. You can add Max for Live for US$99.
2. You don’t own Live, and want just Live. You can get that and Max for Live for US$449.
3. You don’t own Live, and want the whole Suite. Suite plus Max for Live crossgrade, US$699.

Total cost:
Max owners without Live: US$449-699
Live owners without Max: US$299 + cost of the upgrade to Live 8
Max + Live owners: US$99 + cost of the upgrade to Live 8

I think this could arguably be worth the investment, but given the discontinuation of support for developing VST, RTAS, and AU plug-ins in Max – a feature that was formerly free – I expect some resistance. Also, as previously announced, there is no known Max for Live “runtime,” meaning Max patch developers don’t really have a distribution outlet for work made in Max for Live, other than other Max for Live users.

Sign up for the public beta on Ableton’s site, and you’ll be able to grab the downloads (details below). You must be an Ableton Live 8 owner, though you don’t need to own Max 5:
http://www.ableton.com/maxforlive/beta

At the bottom of the page, you’ll have a direct link to download Live 8.1 (the official current build of Live is 8.0.9 otherwise), and a link to Cycling’s site to download Max. (Note: the Max link worked this morning, then promptly disappeared, so it’s possible they’re uploading an updated build is now back up.)

There are full instructions there. I was able to simply click a button and become a beta tester; hopefully you have the same experience. You’ll need to install two pieces of software, both Ableton Live 8.1 on the Live side and Max 5.1.

For the Python-based Live API, and the MIDI and OSC interfaces based on it, this should also come as good news. Live 8.1 should theoretically represent a more stable, feature-complete, fully documented version of the Live API under the hood in Live. That means even without Max for Live, it may be possible to, say, route an OSC input into Live as easily as a MIDI control surface.

If you’d like to join in with other people working on hacking Ableton Live and ask questions, try out our Noisepages group, which should now be functioning properly with a forum, wire, and networking features. More to come with this, with Max for Live, with OSC, with other tools, with… yeah, I’m glad I own a coffee maker.

http://noisepages.com/groups/ableton-hackers

As computer music practice – part composition, part instrumental play – spreads, the idea of software interface as performance tool is becoming second nature. Putting those opposable thumbs and sensitive fingertips to work, multitouch controllers are growing in number, variety, and sophistication. Berlin-based artist Marco Kuhn shows off his beautiful creation, the PlayBox multitouch hardware, and its first app, PlayLive. That first software focuses on Ableton Live performance, but Live could be just the beginning – Marco has worked with Pd in the past and promises other apps to come. He’s interested in selling this device in the future, and he shares with us the tools he used to create this work for those of you doing development along similar lines.

The Project:

“Play Box” is is a User Interface for Natural User Interaction.
? allows multi-touch and object recognition (TUIO marker)
? hovering is also possible
? 22 ” TFT display , 1680 x 1050 pixel
? robust
? plug`n play

“Play Live” is a dedicated multitouch controller surface for Ableton Live.

- GUI Elements support multi-touch interaction
- easy to setup , just load the “Play” Control Surface
- you need no controller assignment
- you can control 32 tracks and 127 scenes, that are 4064 clips
- track controls are mute, solo, record, send1, send2, pan, level
- scene feedback name and state
- clip feedback color, name and state
- Transport control
- 2 Returns
- Master
- support bidirectional communication
- display track level meter, name

The whole app is coded in python.
- use Python Ableton Live API
- and libavg www.libavg.de for the GUI and Trackingengine
- PyPortMidi receive/send Midi Messages

“Play Live” Future plans:
- FX View per Track
- subpage for abstract clip controlling

I tested it with my mac book pro, “Play Live” and “Ableton Live” is running at the same machine. It should work on all platforms (Windows, Linux, Mac OS X). That Project started with my Diploma Thesis in Applied Computer Science 1 year ago.

Everything is coded and built by myself. The GUI – elements has been designed by Gösta Wellmer.

In this work, I created a GUI-Controller Library which allow me to Develop very rapidly Multitouch Interfaces for other Audio Environments.
More Apps coming soon

I [plan] to sell the” Play Box” and Apps like “Play Live” if anyone is interested.
The price is yet not specified.

That`s not my first multitouch Interface. 2 Years ago I created forfour – http://forfour.hi-pi.de/
- used PD, Processing, Reactivision and OGRE.
But the “Play Box” is another level;-)

For more on the project:
www.hi-pi.de/play

I hope to have video to share soon – and yeah, it’s time to plan another visit to Berlin.

The “space bassoon” Eigenharp seems to have landed from another planet. Today, I’ve got good news: it’s bringing alien gifts with it. By next year, both the software and the high-performance protocol the instrument uses will be open source. Taken together with other advancements in the open source community and with protocols like OSC, that could mean we’re at the vanguard of a golden age for more open, more intelligent, more expressive digital instruments.

Genuinely new music controllers made available commercially don’t come along very often. So this week’s news of a strange but wonderful-looking instrument shaped like a bassoon with customizable key controls turned many heads. With high-resolution, high-frequency data and reliance on the computer for everything from sound generation to mapping the keys to different tunings, the computer connection matters. Eigenharp’s chairman, John Lambert, sets the record straight for CDM on the software, the way it talks to your computer and other gear, and how open the tools and protocol will be.

I’ll be talking more with John next week, but I want to bring you this news now. Part of blogging means that you don’t hold back – you share that first reaction and then learn more. I’m pleased to say I was dead wrong on the Eigenharp. What looked on the spec sheet like MIDI-only communication and proprietary software turns out to be just the opposite. Sometimes, being wrong is great. Here are all the details:

What protocol do the instruments use?

The instruments talk to their base station by a dedicated, high speed, differential, transformer-coupled, error-correcting digital protocol designed (and tested) for use in noisy stage environments by ourselves. The wire used is a 4 core, standard star quad mic cable and can be up to 40M long. The base station then talks to the control software running on the host PC (Mac at the moment) via a dedicated protocol over USB2. In the host system, the native protocol used between agents (our software components) is a network protocol called Eigentalk. This can run over Ethernet wires (with slightly increased latencies due to some smart jitter buffering we do). We will be making this public and freely available (when we open-source our main software) in Febuary next year. There is an open API, to be published at the same time, for our equivalent of AU’s or VST’s, hosted in our software, EigenD. This is rather richer than the AU and VST API’s, for reasons connected with the expressiveness and configure-ability (is that a word?) of our system. A couple of interesting AU vendors are looking at producing native EigenD instruments at the moment, and I think there will be many more in time. We try to avoid MIDI wherever possible as it has so many serious performance limitations.

Had you considered OSC?

We did have a look at OSC but there are a bunch of things that our protocol does that OSC didn’t (not least of which, for example, is clock syncronisation for jitter removal, utterly vital over ethernet for live performance) so we decided to grow our own and release it. Absolutely no reason whatsoever that we can’t interoperate fuly with it though, I suspect that an OSC EigenD Agent will probably come quite soon after the open source release.

Ed.: Actually, with OSC (OpenSoundControl) moving increasingly toward broader input and assimilating other standards, I can easily imagine that a future implementation of OSC could begin to implement these features. More on both protocols in the coming months. -PK

Is it possible to use this as a controller for MIDI hardware? MIDI software?

Yes, EigenD has in and out MIDI gateway programs. The incoming [MIDI] is mainly used for pedalboards at the moment (to control scale, key, tempo, etc.), although there is no reason you couldn’t use a midi keyboard to play notes. We’re using the MIDI out to do a wide variety of things, including playing MIDI sound modules, and controlling video DJ software and lighting systems. There is a huge reduction in effective bandwidth when ‘downsampling’ to MIDI, but for a lot of things it still works very well. And of course, the AU and VST standards (which we fully support) are a kind of MIDI interface.

Is it possible to access its native protocol for custom software / Max-Pd patches and the like?

Well, we’re open sourcing the whole thing early next year, and I think there’ll be a lot of work done to glue all sorts of external stuff in then. Max/MSP has attracted a lot of interest in this area. The whole of EigenD is kind of built for this really. We’re an Open Source company: my main personal desktop is Linux and I have a strong personal commitment to open standards. I offer a number of ‘programming bounties’ for Linux improvements on my personal website at http://johnhenrylambert.com.

Tell us more about open-sourcing the software. What tools did you use to build the software.

It’s written in a mixture of C++ and Python. It’s quite scary code, but very clean and pretty, with little ‘cruft’. I think the open source community are going to have fun with it. Its a big system too, 8 years of R&D in one huge release. I don’t think that there’s been anything quite like this open sourced before in the music world – it is a bit as if Logic or Ableton were GPL’d tomorrow.

Thanks, John! Stay tuned for more details, and let me know if you have specific questions for the creators.

Getting handy with the $60 KORG Nano Series controllers and Ableton Live keeps getting more sophisticated. I did a "quick hack" using the text-based MIDI Remote Scripts with the nano as an example, and provided a download. Next, Raymond Weitekamp modified those scripts and added a monome for a full-blown Live performance. But now James Waterworth aka Myralfur takes the whole idea to the next level, with a fully custom set of scripts with control of additional channels, more control over tracks, and most importantly, interactive scene triggers.

I’ve built a custom python script for the nanoKontrol based on the hacked python scripts for the Axiom controller decompyled from live 7. It adds the ability to switch up to controlling channels 9-16 by changing midi channel (or changing up to scene 2 on the nanokontrol, which I had sending out on midi channel 2 instead of 1). It also has track on/off, solo/cue, panning, and also has the bottom row of buttons triggering clips on the relevant track, with forward and reverse skipping up and down scenes, and the loop button triggering the selected scene.

Best of all, you really don’t need to know – ahem – what you’re doing with scripting to make this work. Just follow the instructions below, and you’re ready to play – so you can get back to your set.

Now, James has polished off the script and fixed compatibility with Ableton Live 8, and this is ready for public testing. Give it a go and let us know what you think. I’ll work on a permanent home for all of this stuff, but for now, let’s just use comments for any issues. For some insane sounds, be sure to check out Myralfur’s music and DJ mixes on Soundcloud, too! He’s working on a rig that also incorporates a Sony PlayStation 3 controller.

nanoKONTROLMyr

A midi remote script for use with Ableton Live 8 and the Korg nanoKontrol.

Set-Up

1. Download and Unzip the file.

2. Move the nanoKONTROLMyr folder to the MidiRemoteScript folder within your Ableton Live application folder.

3. Open your Korg nano series editor and load the presets within the NanoKontrol Presets folder, over-writing your previous settings.

4. Select nanoKONTROLMyr as a control surface in the midi pane of the preferences window.

Mappings

Banks

Bank 1 controls tracks 1 – 8

Bank 2 controls tracks 9 – 16

Bank 3 maps the encoders to the selected device and provides functions for moving tracks and devices.

Bank 4 is free for mapping to whatever you like, sending on midi channel 4.

Global

The Ninth Slider is Always mapped to Master Volume, regardless of bank or midi channel.

The Ninth Encoder is Always mapped to Cue Volume, regardless of bank or midi channel.

Transport

Transport functions only work when receiving midi cc numbers on channel 16.

Different functions are called when in session view and arranger view for some of the buttons. The Loop button acts as a Shift to allow more functions to be called with the other transport buttons.

Loop = Shift

Play = Play (Scene Launch when Shift held)

Stop = Stop (Stop All Clips when Shift held)

Record = Record (Overdub On/Off when Shift held)

Session Specific

Rewind = Scene Up (Scene Up by 5 when Shift held)

Forward = Scene Down (Scene Down by 5 when Shift held)

Arranger Specific

Rewind = Cue Position Left

Forward = Cue Position Right

Encoders

The Encoders map to the Pans of the tracks. When sent on different midi channel numbers they map to different tracks. Channel 1 maps to tracks 1 – 8 and Channel 2 maps to 9 – 16 etc.

When sent on midi channel 16 they map to the selected device. This works in conjunction with the pads and buttons sending on channel 16 which provide functions for moving track and controlling devices.

Sliders

The Sliders map to the Volumes of the tracks. The tracks they are mapped to changes with the midi channel they are sent on. Channel 1 maps to tracks 1 – 8 and Channel 2 maps to 9 – 16 etc.

There is as yet no function for when they are sent on channel 16.

Top Row of Buttons

The buttons on the top row turn Tracks On/Off. The Ninth Button on the row acts as a Shift and when this is held the other buttons Record Arm the tracks. They function the same as the sliders and encoders in that they map to tracks depending on the midi channel.

However, when sent on midi channel 16 the buttons select and view tracks 1 – 8 mapping the encoders above to the first device in that track.

Bottom Row of Bottons/Pads

The buttons, or pads, on the bottom row Trigger Clips. The Ninth Button on the row acts as a Shift and when this is held the other buttons Stop the relevant clips. They function the same as the sliders, encoders and top row of buttons in that they map to tracks depending on the midi channel.

However, when sent on midi channel 16 the buttons provide various functions for controlling devices.

Button 10 = Track Left

Button 11 = Track Right

Button 12 = Device Left

Button 13 = Device Right

Button 14 = Bank 1

Button 15 = Bank 2

Button 16 = Device On/Off

Button 17 = Clip View/Device View

Download:

nanoKONTROLMyr.zip

TUIO is a simple but powerful emerging protocol for multitouch control for live music and visuals, as used on the powerful live tangible synth reacTable. Apparently no one told Apple, however. While the App Store rubber-stamps useless toys like fake cigarette lighter flames, they bizarrely rejected a powerful application by a leading digital artist that would enable standardized TUIO control – for free. (More back story below; see an example in action above.)

As a blogger, my reaction is usually to whine and pontificate, for better or worse. The engineering approach would be to find some hack away the problem. That’s what Andrew Turley did with the TUIO protocol. So, Apple won’t allow an app that does the trick? Why not go back to what developers did before the SDK, and just use the iPhone browser?

As Andrew explains it:

After reading the story I started thinking about seeing how far one could push Safari as an application platform, using web apps to get around Apple’s tight control of the app store. Since you would be connecting to another computer anyway to use an OSC application, why not just have the app be a web app running on a web server somewhere on the local network? The web server can then take care of things like sending out OSC messages or playing music or doing whatever it is people want to do.

To that end I created a little system that implements the TUIO protocol. You use an iPhone to run a web app, which in turn talks to the web server, which in turn sends OSC messages.

Details:

touchy feely [Pillowsopher Blog]

Needless to say, there are some downsides: you have to run the Python server, you’re more limited in input and control than you would be in a real app, and you’re stuck inside the Safari browser, which could be a bit inconvenient. So I’m not backing down from my original complaint – I don’t see Apple doing anyone a service by blocking this kind of app, and the only rational explanation seems to be that the folks doing the review process don’t understand what the app is.

Most importantly, I do know that all our griping was sent to Apple, so I’m hopeful the App Store will reconsider the decision once they get it.

But I love solutions, too, and this can be one for many applications.

It also illustrates an important point: the browser on mobile devices (Apple and otherwise) could be a powerful outlet. It doesn’t always make sense to build an entire application; there will be various cases in which a little browser tool will do a job. Need a quick remote control for a live performance / art installation / club lighting rig? You might try the easy solution with the browser first.

Thanks for the great hack, Andy, and I’m curious to hear if anyone uses or extends this.

Previously:

Apple Rejects Free iPhone Tool For Artists Because of “Minimal User Functionality”

Ever feel like you’ve found the seam dividing past and future?

The past: restrictive UI frameworks requiring pages and pages of code to produce dated-look 2D displays. Proprietary software with rigid interfaces. Input bottlenecked through the x and y coordinates of a single mouse pointer.

The future: UIs whipped together graphically or with a few lines of code. 3D mixed with 2D. Open-source, friendly frameworks. Creating your own interface or drawing upon a community of creative software makers. Input that uses multitouch for gestures, collaborative input, manipulation of 2D and 3D space, and … well, just a lot more fun.

There’s no need to wait around for the future. Creative software inventors are building it for themselves. Here are two of the most promising multitouch interface projects I’ve seen in my inbox.

In no time at all, you’ll be painting a cow! (Okay, more on that in a moment…)

Make Max Multitouch

Max Multitouch Framework by composer Mathieu Chamagne makes turning your Max patch into a multitouch interface a breeze. When I first reviewed the Lemur, I was frustrated by the hardware-style abstraction between your software and the interface. Why was I having to go through Max patches painstakingly assigning Lemur controls to Max controls – why not just make the Max controls appear on the multitouch screen? Well, that’s exactly what you get with MMF. Using a set of Max abstractions, all you have to do is build your Presentation Mode style UI and add in the MMF ingredients – it automagically becomes touchable on a variety of displays.

It’s not hard to imagine how great this could be for musicians, especially those who have already been building original sonic creations in Max/MSP. Best of all, you don’t need an expensive, non-portable table with a projector inside, either – commodity hardware works just fine right now.

Requirements :

- cycling’74 Max5 (version 5.0.6 required)
- any multitouch interface that sends TUIO messages.

MMF has been tested and works fine with : Stantum SMK-15.4 multitouch screen, HP XT2 tablet pc (windows7 + W2TUIO), Demand Evolution + home made multitouch screen + Reactivision / Tbeta , …

MMF (Max Multitouch Framework) @ Mathieu Chamagne’s Site

Hmmm… apps that send (cough) TUIO, eh? Ah, yes, but that’s why you need companies like Apple to tell you what qualifies as useful in an iPhone app. You see, without Apple’s app review team and their superior wisdom, I might wrongfully assume this sort of app would be something I’d want. Now I know better – thanks! (Sorry, couldn’t resist.)

Back to the on-topic discussion, this does demonstrate a real advantage of Max: it has its UI absolutely nailed, and the open-source alternative Pd is woefully behind. It also demonstrates that the beauty of Presentation Mode is, by abstracting the UI from the underlying guts, you can consider alternative interfaces. We should see that in Max for Live, as well.

Pd is fantastic in other ways, but if there’s anyone out there who fancies writing a lightweight new front-end, it could use it – perhaps in Python. Which brings us to the next item.

pymt demo reel from Thomas Hansen on Vimeo.

PyMT: Juicy Multitouch, Just a Few Lines o’ Code

PyMT is a glimpse of what future development could look like. While Microsoft putzes around with their Windows-only Surface, PyMT makes multitouch platform agnostic, open, and easy. That frees up artists to dream up creative new ways of applying this interface to expressive musical and visual creations (among others). Instead of reinventing the wheel as far as plumbing, you can focus on the reason for using devices in the first place – your art.

PyMT is profoundly portable, using Python and OpenGL to deliver windowing and multimedia features across platforms. Documentation and code are both under heavy development, but there are already some friendly-looking resources. This is almost enough to shake me from my loyalty to Java, though, in fairness, you can do some of the same things with Java and other tools. What’s most important is that there are libraries that are providing standards, like TUIO, and implementations in cross-platform languages that can be easily developed.

There’s good reason to be bullish on the future of this tech. And if you want to see it happen, don’t wait – you can get involved in the project directly.

PyMT at Google Code

PyMT Project Page