Israeli funk musician and producer Kutiman, creator of the famed Thru-You, is back with an encore. Once again, he’s mixing the best performances of YouTube into a single video. Calling it a “mash-up” is perhaps unfair: this is really mix and remix. It’s no different than laying down multiple tracks in a studio, except that the players were working independently in different parts of the world. “My Favorite Color” is a jazzy, soulful number, particularly carried by those incredible vocals on the original song “Green.” The rest is really arrangement, and it works pretty darned-near perfectly. (An occasional ragged rhythmic edge seems only fitting to the form.)

This raises a question. I don’t think anyone would question that the ability to work musically in the same room, to pick up on physical gestures, eye contact, and inhabit the same space together is the ideal for collaboration. But there’s no reason that shouldn’t stop musical expression from taking place in less-than-ideal circumstances, too. You could think of it less as a poor substitute for playing together in a room, and more an improvement upon lonely solo production, a chance to add collaborative musical experiences to, say, time late at night after a long day of work. It could the ability to share something with someone who would otherwise be separated by geography – as imperfect as a letter from a pen-pal, but also as intimate.

As the above video hits my inbox this week, so, too, does a new video from the creators of Ohm Studio. Among other ambitions, they hope their software production workstation, now in progress, will be Internet-connected and collaborative. In its execution, it represents nearly the opposite of the YouTube video above: whereas a tool for simple YouTube sharing is mixed together by hand, an accidental session, this software is engineered with intricate connections of workflow. On the other hand, they both represent the same idea: cloud-connected creation, across geography, between human beings.

Software workstations have traditionally not only emulated studio hardware, but assumed one person in front of one computer working in isolation. So part of what the Ohm crew have to do is to answer how one piece of software can be used by more than one person across the Internet. They make an effort to do that in this video; it’s best to watch. (Thanks to Cid Andrade from Ohm for sending this our way.)

They write:

Ok, the Ohm Studio brings real-time music collaboration. But when two people are working together in the same project, how exactly does it look like?”

We’ve just put online a sneak peek of it, a video capture of two people starting a track from scratch. We see both screens, listen to both audios, and understand how artists will be able to compose/produce as if they were together.

I still think there’s value in solo creation, but that doesn’t have to exclude collaboration. I’m curious – YouTube upload or sophisticated DAW, does any of this look practical to you? How have you collaborated online, if at all? (Or is it back to a rehearsal room or studio to work face-to-face?)

Owing to a tradition that goes back to the first samplers and hip-hop pioneers, sampling and digital performance have become a kind of instrumental technique. You might play well, you might play poorly, but even working with samples, you can actually play.

You can look at the simple design of the monome as the hardware embodiment of digital, a reflection of an array of pixels. You can see it as an extension of Roger Linn’s MPC and other drum machine concepts. It’s probably both those things. But since the monome itself makes no sound, it’s been software that has made that design musically relevant. While the original vision of the monome was as a blank canvas that could perform any function, ultimately a community of musicians focused their efforts on expanding a single patch, creator Brian Crabtree’s original mlr. Talk to these monome players, and they’ll very likely tell you about some little modification they made last night to use in a set they’re playing tonight, because they wanted some feature or another, or a little subpatcher they borrowed from a friend to solve a problem. Add up all those little hacks, and you get evolution.

Now, descendant mlrv has evolved into a live music-making environment of its own, and not just for the monome. Version 2.0, released this week, supports monome-like controllers such as the Novation Launchpad, Akai APC, and Livid Ohm/Block, but also conventional MPC-style grids like the Akai MPD.

The word the creators use to describe the playing technique: “hypersampling.”

mlrv is built in Max/MSP, so if you have a Mac or Windows and version 5 of the software (or Ableton’s Max for Live), you can edit the patch. Otherwise, you can download a free runtime and use the patch itself for free. Pay US$18, and you get your name on the startup screen and special email news and downloads. Pay US$80, and you get limited edition vinyl from artists galapagoose and ‘%’.

The project is the work of Trent Gill, Michael Felix, and parallelogram; check out developer galapagoose playing with it live in the video at top. (I will say, though, even as I am writing on a Website, you get more out of being in the same room with a live performance.) All the details:
http://parallelogram.cc/mlrv/

The software will be available February 1, with a release party that evening for the software and music. Also, while we’ll have details tomorrow, Handmade Music will host performances by galapagoose, %, and other monome artists (alongside chip music, MeeBlippery, and laptopism) on Saturday February 5. Both events happen in New York City at Culturefix.

On February 5 with CDM, you can come at 3pm and check out an open lab to get your hands on mlrv and talk to its developers. Then stay for the party Saturday night – US$20 buys you admission, supports the artists, and nets you a two hour open bar of beer and wine recently celebrated by the NY Times’ drink critic, Frank Bruni. Full details coming in a separate post, or in the meantime, RSVP on Facebook.

Tuesday night launch party details, NYC
http://bit.ly/hmfeb5 = Handmade Music party Saturday night, complete with hands-on during the day, more live performances at night!

Finally, here’s the obligatory, somewhat amusing, preview vid:

Does the world really need another DAW / music production tool?

That thought has to at least echo a couple of times in the back of your mind as you see a new attempt to provide all-in-one computer music making tools. But there are reasons to pay attention to Ohm Studio, aside from the fact that the music making application comes from a fairly beloved plug-in developer. One is, the tool promises to approach real-time collaboration and community (or “cohmunity,” as they say) from the ground up. It’s a desktop app for the cloud. That may or may not be of interest to you, but it at least provides differentiation.

Two, this week we get to find out that the UI looks quite gorgeous.

Cid Andrade of Ohm Force writes CDM with three screenshots of the new interface for the upcoming beta builds. (Previously, we had seen only alpha UIs.) It looks clean and clear; there are strong similarities to GarageBand (which in turn borrowed functionally from Acid), but with some twists. There are quick-access edit tools, freely-routable plug-ins, and lots of integrated tools for collaboration.

Cid walks CDM through what’s in the beta interface and how it works; see the callouts in the image below. (Thanks, Skitch!)

Cid explains:

1 – Sequencing Panel’s “Macro Viewer”: gives an overview of the whole sequence. The movable focus-square has two functions: it allows the user to navigate within the macro viewer and easily locate and go to some region of the sequence, and also shows to all other session members which sequence region the user is working on. In this example, this focus-square is the one controlled by the user who’s actually seeing this screen. It’s over the current selected pattern. All other session members will also see this user’s focus-square, so they will know what he’s working on. There will be an efficient color code allowing a quick visualization of each session member’s focus-squares and current selections.

2 – In this example, the macro-viewer is displaying two focus-squares, what would mean that there are two members working simultaneously in this session. The user who’s actually seeing this screen also sees this second focus-square (the one belonging to the other member) and thanks to that can know where in the sequence he/she is working on. Still, in this example, one user may be editing some rhythmic parts in the sequence intro while the other one is starting to compose a bass line later in the timeline.

3 – This is the current selection of the user who’s seeing this screen. The other members can see a colored pattern in one of the focus-squares that the macro-viewer is displaying. By the color they’ll know which user is.

4 – These are the “power tools”. An user will be able to make all possible audio/MIDI edits using only these tools, as their function can be altered by pressing some keys (of course each edit action will have its respective keyboard shortcut so none will be obliged to use the mouse all the time).

5 – This is the Gear Panel, where the members of a session will place (and freely route) audio effects and virtual instruments (in addition of Ohm Studio’s own built-in effects, it will support VST and VSTI).

6 – The Gear Panel’s macro-viewer. Works similarly to the Sequencing Panel’s one, this time allowing an user to navigate within the Gear Panel (which is virtually infinite in area) to easily locate a specific region. It’s also useful to let each session member know on which Gear Panel’s region the other users are working on, and see/show each one’s current selections.

Thanks, Cid!

The beta is scheduled to start mid-December. There’s still time to sign up, says Cid, if you’re interested in testing.

http://www.ohmstudio.com/ask/for/beta

…and Ohm have plenty of other information about how they’re handling collaboration, community, and versioning, all essential when your project is shared by others:

http://www.ohmstudio.com/

Ever wish your music software could do something your way, something it can’t do now? Wish you could just get in there and change it yourself?

That’s some of the ambition of Renoise 2.6, the multi-platform music creation tool. By opening up the entire music tracker to scripting, users can create custom functionality and control surface. But scripting – while it sounds like the domain of hard-core geeks – doesn’t have to be daunting. That’s important, as presumably you want to spend some time making music. Scripting should save you time and let you express ideas more directly, not act as an impediment. So, the design of the Duplex feature in Renoise does work to make this customization accessible.

Renoise 2.6 has just gone gold master, meaning you can add it to your stable music setup. New in this release:

• Lua scripting. Customize the app using an elegant, clean, friendly language.
• OSC, MIDI support. Integrated control with Duplex (MIDI/OSC), native Open Sound Control support.
• Extensive hardware support. Maybe you don’t want to write a line of code, ever. You can let someone else do it for you, and reap the rewards. Already, Renoise has native, fully-integrated support for the AlphaTrack, BCF-2000, BCR-2000, KONTROL49, FaderPort, microKONTROL, nanoKONTROL, Launchpad, Remote SL-MKII, Nocturn, Monome, Ohm64, iPad via TouchOSC… all thanks to community support for the new scripting engine.
• Sample autoseek. Absolutely essential to making audio behave in the way it does in linear arrangement tools, the sample will play back from the position in the timeline, rather than from the beginning each time you hit play. (Seems obvious, but it’s part of making Renoise bridge tracker-style apps and more conventional, linear ones.)
• Better performance, compatibility. Tweaked performance on Linux and Mac, expanded file format compatibility, plus 64-bit Linux, DSSI Linux support. Renoise is a reason to run Linux, and Linux a reason to run Renoise, if you hadn’t guessed that yet. No, seriously, you’ll enjoy it. (I always feel like it’s telling someone to go vegan. Linux can actually be fun. And you still get to eat bacon.)

The release date seems the perfect time to really explain what Duplex is about, and what it means to you. First, it’s best to see it in action in this Duplex video. What you see is fully integrated hardware and software, but in a way that doesn’t necessarily require specific hardware. (There’s no “Renoise” logo on the controller – and you could substitute something very different and get the same impact.)

More information on the Renoise forum from the video’s creator, Danoise: Duplex – Playing With Loops

Basically, I’m arranging a small song on-the-fly, using a Launchpad + monome. Since the song was basically written using the StepSequencer, the vertical resolution of each pattern is just 8 lines. I then use the new loop feature in the Matrix to “pair” patterns into longer sequences.

This is just one possible workflow among many, but it’s one that’s I’ve found to be immensely rewarding when you’re sketching a tune out.

Bjørn Nesby, Duplex’s lead developer, explains his creation to CDM:

Duplex is aimed at both people who are willing to create their own scripts, and those who just want a nice way to interact with their music using Renoise. Many of the scripts (called ‘applications’ in Duplex) are pretty generic in nature, and will simply take control of a specific part of Renoise, like the Mixer or Pattern Matrix. This is something everybody can use, so this is where I focused my efforts to begin with. More exotic applications are also planned, but we needed to get the fundamentals in place first.

A thing that was clear from the beginning was, that the whole setup and configuration process needed to be as simple as possible. I think we succeeded in that, as my personal copy of Renoise will automatically launch the applications I need when the program starts, on three separate controllers. And I’ve heard from many people that they love this aspect of Duplex, as it reduces a potentially tedious startup process to an absolute minimum. Of course you can have an initial device setup process that you need to go through (like selecting the input and output ports for your device, which might vary from system to system), but in most cases you’d only need to go through this once, after which the device is ready to use.

And I believe this is not just about ‘convenience’, because sometimes you need to be absolutely focused on the music and not the order of which you launch various programs – especially true when you bring your music to the stage.

However, I have to point out that the configuration process is not perfect yet. There’s still room for improvement when customizing application mappings – this is currently done by editing some of the accompanying configuration files by hand, and although that might sound scary, it’s actually a pretty straightforward thing to do (and if not, the Renoise forum is there to help people out). Also, finetuning a setup like this is hardly part of the music-making process itself, so I hope it’s something people can live with for a little while longer.

From a developer point of view, the Duplex framework might be technically interesting as it attempts to follow the ‘write once, run everywhere’ model, as known from the mobile computing world, but instead applied to musical gear. For example, the Mixer application is able to run on all devices, from the Novation Nocturn to the monome128. Physically speaking, those are two very different devices, but everything in the Duplex API is abstracted to the point where a standard user-interface element like a slider can be a rotary dial (Nocturn), or an array of buttons (monome). In the application code, you simply create a slider, and base your logic around that. The framework will do all the dirty work of translating that into *actual* controls. This is possible because everything in Duplex is based around a descriptive XML file, the control-map. Unlike a traditional MIDI implementation chart, the control-map will not only describe the parameters and their ranges, but rather the complete physical layout of the device. Once a proper description has been made (and they are not hard to make, several of Duplex’ control-maps are user-contributed) you can launch an application on e.g. the monome that creates virtual sliders from individual buttons, because each button “knows” where it’s located in a X/Y coordinate space.

I’ve also tried to keep the syntax as familiar as possible. Many people who’ve done a bit of actionscript will probably recognize many of the concepts in this framework, hopefully making the whole experience a little less daunting for budding scripters.

One unique aspect of Duplex: the virtual control surface. When Duplex is installed, you can try out all the various supported devices, even if you don’t own them. Again, it’s the control-map structure that makes this possible, as you can define things like button size, color etc. Of course, this is not the same as the real thing (try hitting two buttons simultaneously using a mouse?), but it’s still interesting to play with, a huge advantage for developers as you can design a control-map that device owners can then try out and test, and makes for self-documenting applications, as you can assign tool-tips to the control surface that display exactly what each button does.

More information:
What’s New in Renoise 2.6 – Renoise Geek Edition.

Renoise Lua Scripting

2.6 Forum Discussion

And, of course, you can discuss Renoise and other trackers on our own Noisepages community. Specifically, we’re looking at how to use trackers in live performance.

Trackers for Live Performance @ Noisepages

Renoise, the tracker-style music production host, has gotten a massive injection of customizability, scriptability, and hackability. If all you want to do is plug in some controller hardware and have more tangible control of music making, that scriptability can be nicely hidden away. But if you are ready to hack on your music app, this is some enormous news.

For that reason, Renoise 2.6 is being called even by its makers the “Renoise Geek Edition.” But if this hackability catches on, it could mean a music tool that’s more fun to use for everyone – not just scripting geeks.

2.6 has been released into a private beta for registered users, with the full release anticipated soon.

The video at top sums up why the open API is potentially a big deal for everyone. Right now, you can use a pre-built script for two-way integration of hardware like Novation’s Launchpad. As other folks get into the tools used here, though, that could (if hackers get so inspired) lead to lots of other hardware support and musical ideas.

The other big news, at the opposite end of the spectrum, is that longer samples now “autoseek.” That’s best seen in the video below, although I can put it this way – this means if your music isn’t all microsamples, you can now more easily produce and perform in Renoise.

Here’s my personal take on the 2.6 changes. Keep in mind, I’m just wrapping my head around this stuff, too, so take this with a grain of salt. But I can at least express why I’m excited about digging into this release, having followed these developments for some time:

Script everything – using a truly open API. Firefox has extensions. Renoise has Lua scripts. You can customize the user interface, manipulate musical elements in your song, control MIDI, audio, and OpenSoundControl, or actually dive in and create features Renoise doesn’t have yet. Those ready to code can use the elegant scripting language Lua, which means that – while you’ll definitely need some basic coding chops – the results are surprisingly simple and readable.

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

You don’t need a separate add-on product, and the API is fully documented, free, with a whole bundle of scripts and snippets under an open source MIT license. Renoise itself remains proprietary, but that means the scripts themselves are free to remix, and coders are free to distribute their work to all Renoise users.

That approach contrasts with the solution devised by Cycling ’74 and Ableton for Ableton Live. Live is not directly scriptable; the so-called “Live API” used by hackers was a set of private APIs. Max for Live provides some, but not all of this functionality, and it’s a paid add-on, so you can’t distribute your work to all Live users. On the other hand, the Lua scripting engine is just a scripting engine – it’s not the synth, sequencer, effect, and multimedia-processing platform that Max is. For some, that may actually make the simpler, more direct Lua interface more appealing; they’re just not directly comparable.

Two-way control of everything.

Using these scripting features, it’s possible to get much richer, two-way communication between control hardware and Renoise software.

That means one of two things:

You don’t care about code. No problem — grab control templates from a community of people who do care enough to hack things together. If you’ve got a Behringer BCF/BCR, Novation ReMOTE, Nocturn SL, or Launchpad, or Livid Ohm 64, you can get started right away. For everything else, watch for the community to fill in the gaps. (monome?)

You’re a coder. Dive in and make things work the way you want. What’s ground-breaking about what Renoise have done is that everything is built atop an open, extensible API for the software itself – rather than kludging together various protocols and tools, which has been the traditional industry solution (if you’re lucky, and there’s any customization at all). Renoise’s Duplex uses an object-oriented system for describing hardware and software and communicating events bi-directionally between them. It’s all built in the API, so it’s all customizable. There’s even an onscreen tool so you can mock-up interactions with hardware you don’t yet own (or haven’t yet built).

Everyone can share their work at a centralized site:

http://tools.renoise.com

OSC Support

Renoise joins MOTU Digital Performer, the open source DAW Ardour, and a host of visual apps that support full, native OSC. That means support for networked, transparent control from anywhere to anything. You can even send Lua scripts as OSC commands, so this new API is really controllable from anything.

Better Linux Support

Linux now adds DSSI plug-in support, bringing a full complement of Linux plug-in compatibility, as well as 64-bit Linux support.

More Support, Tweaks

Mac, Linux performance enhancements (especially on 64-bit Linux), and better support for hardware-based plugins (which I’m assuming means latency compensation) round out this update.

Needless to say, this is all something we’ll be covering more. Stay tuned here.

Thanks to Johann Baron Lanteigne and everyone who sent this in.

From the source:
http://www.renoise.com/about/what-s-new-2-6/

Surprise! Plug-in developer Ohm Force, known for their plug-ins (like effects Ohm Boys and Frohmage), today tease an upcoming collaborative host. It looks like the sort of thing Apple could have done, but hasn’t. There’s a GarageBand-style MIDI and audio editing pane, plus semi-modular routing of plug-ins on a pretty, graphical surface that resembles the “cheese grater” perforated aluminum of a Mac tower, and pop-up window palettes that resemble those we’ve seen on the “flattened UI” of the iPad.

The real feature here, though, is collaborative editing in the “cloud”: sessions are uploaded to a server, which in turn keeps track of versioning. (Actually, it’s quite unclear how that works collaboratively – this means you can “undo” from one version to another, but I can’t tell whether collaborators can try different “forks,” or if it’s all one set of linear changes.) The changes are “real-time,” though usually the trick to allowing international collaboration over the Internet is to make things delayed enough that everyone stays in sync.

There’s also an accompanying Web community for connecting with collaborators. Everything else about the product, however – more features, pricing, and specifics of how it all fits together – is as yet unknown. Mac and Windows are both supported, though – something Apple would not have done, most likely.

It’s an interesting idea, one I think we’ll see more frequently as connected applications grow in popularity. Among other options, Ableton had promised something like this with Share and then fell off the radar. Image-Line had a collaborative tool called Collab for its FL Studio, then abandoned it. The most significant competition comes from tools like Indaba. Indaba’s edge: by being powered by Web tech, you can do all your editing right in the browser; serious users can then keep using their host of choice and just bounce out audio. But while Indaba has an offline editor, too, the addition of plug-ins in Ohm Studio is a big change.

I do wonder with all of this, though: are we consigned to collaboration existing only in proprietary, integrated app-website combinations? Isn’t the whole lesson of the Web about open standards and platform-agnostic communication? Having said that, what would a more open tool look like – and what do people really want to do? (For instance, I wonder how hard it’d be to build a system that allowed open chat and transport control, with standards-based versioning and sharing, using the open-source DAW Ardour? See the post I’m … about to write … for the OSC end of this.) On the other hand, is the kind of integration Ohm Studio is offering necessary to make it all work together? (That last question we should be able to answer once this is in our hands and ready to try.)

I don’t wish to pre-judge Ohm Studio – on the contrary, I think this is a provocative product teaser that immediately raises some of these fundamental questions. So bravo, Ohm, for starting that conversation; I can’t wait to see what you’ve cooked up. And anything that gets artists collaborating is potentially a very good thing.

In the meantime, readers, it seems the most important question falls to you. Do you even want to collaborate with other artists? What would an ideal system look like for doing so? What features would you want? How would you want to work? Is real-time important, or do you prefer some time to sit back and think about how elements combine? When you collaborate now, how do you go about it?

Updated: Your closest bet at the moment is NINJAM, which is integrated with Reaper – a host various folks are using already – or on its own. Using compressed audio streams and latency compensation, it allows the exchange of any audio, and it works on Windows and Mac. But it doesn’t exchange MIDI data. (The site refers vaguely to this happening some time in the future, but I’m unsure of their progress.) And it doesn’t have integration with the Web community, though as readers note, you may want to work with people you get to know a bit first, anyway. Thanks to “PooPoo the Korruptah!” for the tip. (Hmm, no way for me to say that and not sound silly.)

More importantly – anyone out there using it? Or is it just easier to send files back and forth?

http://ninjam.com/

The grid is in. While the monome remains the standards bearer for hardware with grids of buttons on it, arrays of buttons are suddenly everywhere, in the commercial Akai APC40 and Novation Launchpad, and, from Livid Instruments, the Ohm64 and now the Block. I think it’s a real compliment to the monome’s creators – and the community that has authored ingenious open software for the monome – that there is this excitement around the design.

The latest entry is Livid’s Block, a compact, aluminum-and-wood controller that’s easy to carry and which weighs less than 3 pounds. It’s not a monome – it eschews the monome’s stringent minimalist design aesthetic and adds knobs on top, faders on the side. That layout has made the M-Audio Trigger Finger a blockbuster hit, so I think it could attract people who want more than just buttons. (That’s why choice is generally a good thing.) But just as importantly, the Block takes cues from the monome beyond the skin-deep. As with the Ohm64, Livid is working to open-source both the guts of the hardware and the software on the computer. The instruments are made by hand using sustainable materials and finishes, manufactured in Texas in their own shop rather than the lowest bidder overseas. The hardware itself encourages hacks and customization. These are principles championed by the monome’s Brian Crabtree and Kelli Cain, and they’re badly in need of some company. Livid, like those monome creators, is a handful of individuals rather then a big company, but they give us new hardware that embodies sustainability, openness, and local production – and that makes the monome and its principles stronger. (Livid has been crafting performance hardware and Max patches for many years.) And while this bus-powered USB MIDI device doesn’t yet support (OSC) OpenSoundControl, that could come – without sacrificing conventional MIDI connections to outboard gear when you don’t have the computer connected. (Clarification: as with the Ohm64, OSC support is not yet available but should be possible. Stay tuned.)

Basic specs:

• 8×8 backlit keypad with corresponding knobs, function buttons, and faders
• Square layout that can be used at any rotation (so the USB port lies where you want it)
• Runs a suite of apps built in Max/MSP from Livid – including a sampler, synth, sequencer
• blockEditor for customizing layouts, lights
• US$399, available November 1

I’m interested in more open software, so I’m working on making an editor in Java and would love to hear what else people might want. (SuperCollider looper? Pd algorithmic grid controller? Processing library?) These I hope to make work both with the Livid hardware’s added faders and knobs, and the monome’s more minimal design. Of course, OSC will be terrific for computer applications if that comes to pass, but I love the idea of gear that can also talk to MIDI hardware.

I really like Novation’s Launchpad, but for a little more money, you get a beautiful case, additional controls, and added flexibility, all in gear handcrafted by the maker and with an open approach to hardware and software. Without getting into a debate over the merits one way or another, consider this: you can choose. We didn’t use to have these kinds of choices in music hardware. The fact that we do now – not only the ability to choose the nameplate, but the very philosophy behind the device’s manufacture – I think can benefit everyone, users and manufacturers alike. It opens up the entire music tech industry to new ideas and new variety.

http://www.lividinstruments.com/hardware_block.php

So, you’ve been looking at that Akai APC40. And it’s appealing. It’s got lots of lights and a huge array of buttons for triggering samples or video or what have you, and plenty of knobs and faders.

Now the APC40 has some serious “indie” competition, though, in the form of Livid’s Ohm64. Let’s compare:

APC40:

• Proprietary connection to Ableton Live
• A proprietary handshake that ensures only a real APC is being used with Live
• Fixed MIDI assignments – no MIDI assignment editor
• MIDI only
• No MIDI out jacks, so you can’t use it with outboard gear
• No bus power
• 40 buttons
• Made in some factory somewhere we’ve never seen

Livid Ohm64:

• Open source editor, partially open source firmware, open source patches to connect to whatever you want
• Custom MIDI assignments, for use with whatever you want
• MIDI for now, but the chipset supports open source solutions for OpenSoundControl (OSC) in the near future – and even DMX (for lighting) is a possibility
• USB and standard MIDI jacks so you can sequence outboard gear
• Bus power
• 64 trigger buttons in a more logical 8×8 array
• “Made in the USA by humans” – with a beautifully-crafted body
• Free Cell DNA video software included

Both the APC and Ohm are class-compliant, so at least neither needs drivers to work over USB for MIDI on Mac, Windows, and Linux.

Sure, the APC is plug-and-play with Live. But just as lots of non-programmers use open source browsers like Firefox, the whole point is that the Ohm could wind up being more plug and play with more tools thanks to its more open approach.

Most important is the programmability of the Ohm64. You can make your own custom light interactions – or, if you’re not into that sort of programming, count on what may be a growing community of open source musicians and visualists doing it for you.

In fact, Livid is so committed to customization that in addition to the natural, blue, and red finishes, you can order it unfinished and stain or paint it whatever color you like.

The Ohm64 is also priced at just US$599, meaning it doesn’t cost much more than the APC40. And with future OSC support, hardware MIDI support, bus power so you don’t have to carry a dongle, fully programmable visual feedback and assignments, and open source editing software, the APC has some real explaining to do about what its long-term payoff may be.

The editor is currently built in Max/MSP with some interesting possibilities coming up in Max for Live, but I’m also interested in working on some editing and performance tools in fully open source environments. Stay tuned.

Now, mind, this isn’t a review – I’ll get my hands on the Ohm64 next week here in New York, and I’ve only had a brief encounter with the APC. But if I were a betting man, I have to say, the contest here isn’t looking like it’s in the APC’s favor.

Available now.

Livid Ohm64

http://www.lividindustry.com/culture/ blog with more videos

Updated: I should note, one issue is definitely that, in order to maintain bus power, there are some compromises. You don’t get quite as much interaction from the lights as you do on the Akai APC – I do like the APC’s lovely LED rings around its encoders. You can interactively dim the lights on the knobs on the Ohm, though, which would work nearly as well. More once I get my hands on the Ohm, and theoretically, I should have an APC for testing at some point, too, assuming I didn’t just make Akai angry. (Uh…. competition is good. Blogs are all about opinions. Don’t hurt me.)

By the way, if you aren’t convinced and think you can do better, Livid is also distributing the brains of this device – the MIDIDIY – so you can build your own creations. Other such solutions exist, but the MIDIDIY is distinguished in its ability to support a lot more contacts for doing this sort of more complex device.

http://www.lividinstruments.com/hardware_mididiy.php

Not a whole lot to see in this very first video, but it does give you a feel for what the hardware itself is like.  Update: AKAI requested that the first video in this story be removed by its author on Vimeo, so we no longer have a video to embed.

The integration between software and hardware we should see revealed more over the coming weeks. I’m hoping to get my hands on one myself in the near future; I haven’t yet.

Of course, the APC isn’t alone. I’m still eagerly awaiting the Ohm64 from Livid, a beautiful controller with a wooden body, made with care in the US. Unlike the APC, the Ohm has a customizable MIDI response — the way the hardware itself responds is programmable. And, of course, there’s still the classic monome (site | cdm tag), open source hardware with an elegant minimalist design. Custom Max control patches have made the monome a favorite, especially for those with the chops to not only use the community-made patches, but build their own – by coincidence, the monome folks just posted a link to a library of Max monome objects. For both the Ohm and monome, it’ll be easier and more powerful to integrate Max objects with Live when Max for Live ships later this year. Even the APC will get its own custom patches. And, as Hédi points out, there’s also the elegant, compact, solidly-built Faderfox, which could also get a new lease on life with Max patching.

The upshot of all of this: even if people are using the same controller, they won’t necessarily use it the same way, which is how it should be. Stay tuned.

Update: this just in – a second video of the APC, this one sent to us by our friend Stephan Vankov (tetmusic.com). We’ve seen Stephan before, tearing up a wild audiovisual remix of The Karate Kid with the crew at the CDM NAMM party last year. It’s nice to see the APC out of the trade show floors, naturally.

Look out, Akai APC40. There’s another contender in the emerging Controller With Lots of Buttons And Also Faders and Knobs and Crossfader product category. Livid’s Ohm64 combines the light-up button grid with faders, knobs, trigger buttons, and most importantly, unique customization options and a lovely wooden case. What’s unique about this one:

• High-end materials: anodized aluminum faceplate, “immersion gold-platted circuit boards” (guess that’s circuit bling), an optional wooden body (aluminum is available, as well, but wood is more fun).
• Not mass-market: hand-assembled, small-production Austin creation.
• Fully class-compliant, no drivers (also true of the APC as far as I know, but nice – and ideal for Linux, too, in case you want to run this with a netbook or a Pd-running souped-up *nix laptop)
• Open-source, customizable MIDI talkback: when you’re ready to customize just how those LEDs light up, there are included open source tools and fully programmable MIDI mapping

Bonus: it comes with a powerful, full-featured VJ app in the box, Cell DNA, though of course you can use it with anything you like.

The real story to me is the customization. Whereas the APC40 is entirely proprietary in design, has evidently limited MIDI mappings, and a mysterious mechanism for programming two-way communication, the Ohm64 is open, open source, and software-agnostic. If the open source thing catches on, that could mean a community of friendly folk thinking of smart ways to reprogram this thing for different apps. Ironically, that means that in the long run, the Ohm64 could wind up with better Ableton Live integration than the hardware Ableton chose to back – though all bets are off until we get these devices in our hands.

I would say the APC is probably more direct competition for the Ohm64 than the Monome, despite the 8×8 light-up buttons. The Monome is much lighter and slimmer, it takes a minimalist approach (no big knobs or faders), and uses OpenSoundControl in place of MIDI. The Ohm64 seems likely to appeal to those who weren’t Monome fans, and visa versa. And some lucky bastards are naturally going to own both.

But the important thing is that the Ohm64 joins the Monome in its crusade for open-source customization of a commercial product. Whatever the Ohm64 is when it ships, it’s that question of what people can do with it that may determine its real value. I have no doubt people will be reverse engineering the APC40, too — starting with figuring out how to fake the hardware “handshake” it uses so other devices can emulate it in Live. But it’ll be interesting to see how these different philosophies pan out, so to speak.

I hope to sit down with the Ohm64 as soon as they ship to Hoboken, New Jersey, across the river from me in Livid’s NYC-area offices. Stay tuned.

No pricing yet; the existing Ohm with fewer buttons is priced at US$599-699 on sale.

Ohm64 Product Page