When it comes to controlling software, let’s put it bluntly: OSC good, MIDI bad. With OSC, it’s possible to control the array of things software might do, with easy use of high-resolution data, descriptive names in plain English (or your language of choice), a path hierarchy that makes it easier to structure messages in modular software, and smart networking features that makes assignment and communication a breeze. With MIDI, um… well, prepare for lots of mucking around.

Happily, visual software developers proprietary and open source alike have done what music developers generally haven’t - embrace OSC. Thanks to the fact that this community is unburdened by tradition and commercial development tends to involve small, responsive teams, change hasn’t been so tough.

So, visualists, it’s time to reap the fruit of that development work, and make the live performance rig work the way you’ve always dreamt it should work. Our friend Gian Pablo (check out his fantastic blog) clues us in to some recent developments with Resolume 3 “Avenue.”

First stop: be sure to read the full OSC thread on the forums, starting with how Resolume Avenue’s OSC receive implementation works:

OSC manual
OSC section of the manual

That’ll get you started controlling Resolume Avenue with Processing, which could make for some cool integration of your custom-coded Processing visuals with a more traditional Resolume visual or A/V set.

Last week, though, we got into some other interesting details in that thread, like how to control the BPM thread and an undocumented feature:

Page 3 of the thread

Specifically:

There is an undocumented feature that enables you to send OSC messages from the mapping panel.
This way you can quickly find out what messages you’ll need to send to specific objects.
1. Shutdown Resolume if running
2.Open the ‘config.xml’ file in ‘My Documents\Resolume Avenue 3\preferences\’ and look for the OSC section.
3. Change the section:
4. Change the port and address to whatever is appropiate for your setup.

That also holds the promise of Resolume sending as much as it receives - no reason visual software has to be receive-only. Also, this illustrates that we need a basic protocol that allows auto-discovery of OSC-controllable parameters, but that’s a separate discussion.

Have a look and let us know what you think. And feel free to share your results across different applications (not just Resolume) on Noisepages — even if it’s a quick message to say, “darnit, I’m confused about all this and don’t know where to start.”

Noisepages OSC Group
[Warning: Noisepages is in beta - we need your participation to see how it's used and to fix bugs, so join the Help & Development group to provide feedback, and expect more features / slicker look in the coming weeks and months]

ToonLoop Remix from Society for Arts and Technology on Vimeo.

Yes, you read that right: realtime stop motion. While stop motion is, by definition, associated with a painstaking process of creating animation frame by frame, a free and open source tool takes a different approach. ToonLoop provides the usual stop motion tools for creating loops, but takes a live performance approach to the recording and playback process, so you can turn your stop motion into a performance. The creator brought up the tool Saturday at the Open Video Conference in New York and got just the reaction you’d expect - a few confused (if delighted) chuckles, and someone asking, “That must be … slow.”

Now, if the framerate is low, you have no one to blame but yourself.

For fans of animation and live visualism, though, this is a dream. The first build was in Processing for Mac and Windows, but a new version for Linux (which should also work on Mac) is built on Python (with PyOpenGL, PyGame, Video4Linux and — oddly — Pure Data for MIDI).

http://toonloop.com/
Developers: Alexandre Quessy and Tristan Matthews
Toonloop Download
Source on Google Code
More documentation of the project at Montreal’s SAT [in French]

In fact, I’m not sure whether I should tell you to download the thing or just run with the idea itself. (There’s no reason Java/Processing shouldn’t still work, by the way, if you use the excellent GSVideo library - and OpenFrameworks and others could be likely candidates, too.)

The idea is brilliant - and yet more evidence that being a visualist can be a much broader category than simply being a “VJ,” with the two-channel mix paradigm the more conventional term suggests.

And performances evidently look like what you might expect. Below, Joy Penroz uses Toonloop in Mérida, Yucatán, México, via the ToonLoop site.

Bonus video: as I was looking for more work done with ToonLoop (there’s not much out there just yet), I came across another creation by Joy Penroz. It’s not a stop motion performance, but it runs with parallel ideas, looping to manipulate time in a modern pop take on the work of Dutch master painter Jan Vermeer. The contemporary “Milkmaid”:

THEMILKMAID from Joy Penroz on Vimeo.

Extra thanks to Michela Ledwidge and Austin Gambles on Twitter.

We have the tools. We have the techniques. Now, what happens when you put technology for tracking physical objects into the hands of artists around the world?

On June 6, members of the CDM community joined in our first “global hackday,” assembling tangible interfaces on tracking tables. Martin Kaltenbrunner of reacTIVision and the reacTable joined us from Vienna, Austria, while Adam Kumpf of the OpenFrameworks-powered Trackmate and MIT Tangible Media Group chatted from Cambridge, Massachusetts.

Much of the day was about saying “hello, world,” and helping each other through getting cameras working, troubleshooting, and the like. But there was an extraordinary variety of ideas even in one day. I can only imagine where things might go from here. I can also see the tools people were developing as being expressive for live visuals and visual performance - and via a really cheap interface, too.

Some of the accomplishments of our first day:

• Endless ideas: Drawing interfaces using objects, a floor tom as a housing, a musical instrument with soda bottles as the interface, a game with blocks featuring the Tokyo skyline, and others.
• Troubleshooting data: Both the Trackmate and reacTIVision projects got lots of feedback about how people were using the tools, where tracking was and wasn’t working, and where people got stuck up. We also compiled lots of information on cameras, drivers, builds, and operating systems. I’m working with Adam and Martin to dig through a lot of this information so we can compile a really practical guide to make it easier for people to create their own projects.
• Special guests: Marco had his augmented magic show and we had the beginnings of an interactive glove. Check out the video highlights to see what the NYC event was like.
• noisepages for networking, and other tools: Livestream video was a bit of a mixed bag; I’m still looking for easier ways of doing that (both on the video shooting side and the streaming side.) Text chat was an easy win, though IRC can still be cumbersome; I’m looking into integrating standardized XMPP chat instead, and providing access via any client or a webpage. But the other big success story was that noisepages worked nicely for documentation; see the fritzcrate and i3games sites for great examples!

Building Communities Around the World

A real highlight to me was getting to hear from Valeria (jalea.tv) and Jose (Estado Lateral Media Lab), visiting New York from Argentina. They talked about what the scene is like in Buenos Aires, and touched on issues of community, learning, open source, and the multilingual world of coding. And they do some really beautiful and hip visual work, both commercial and experimental. We also wound up with a significant amount of the online chat being in Spanish. That to me is a healthy sign - “global” really doesn’t necessarily translate to “English.”

Hackday Results, and the Future

For more documentation, head to our noisepages site:

Tangible Interface Hackday: The Projects (So Far)
http://hackday.noisepages.com/

http://trackmate.sourceforge.net/
http://reactivision.sourceforge.net/

And, yes, this is only the beginning. My suspicion is that a single weekend would be enough to get workable tracking projects going - especially as we iron out some technical wrinkles. But we’d certainly love to do more of this, whether it’s another “official” hackday or simple an open lab with chat and sharing.

To continue this moving forward, you can join the Tangible / Multi-touch Interfaces group on noisepages.com:
Tangible + Multi-Touch noisepages Group

And I’d like to brainstorm how we might proceed, whether it’s a formal event or a sort of online open lab. You can join that conversation on the group:
Let’s make every day a Global Hackday - the event continues

noisepages is still in alpha state, but we’re working aggressively to move forward to beta, and content placed there is safe and future-proof. (Most importantly, I’ve fixed the jpeg library on the server so that avatars work!)

We look forward to hearing from you.

Trackmate :: 5 ways to get started from adam kumpf on Vimeo.

The mouse is not all that interesting as an invention. When people first saw mice, in fact, they typically weren’t terribly impressed, and often simply went back to their preferred non-keyboard input, the joystick. But destroy the novelty of the mouse, give it to half the population of the world and wait a couple of decades, and fantastic things start to happen.

See also: the knob, which is basically a simple hack for changing resistance in a circuit.

So, what could happen if we take novel interfaces now and try to accelerate what you do with them? That’s what’s starting to take place with tangible, multi-touch, and augmented interfaces, with the help of shared code tools (OpenFrameworks, Processing, ActionScript), shared libraries and trackers (ReacTIVision, the TUIO protocol, and LusidOSC/Trackmate), and communities like the fantastic NUI Group.

But enough about reading about this stuff and/or working alone. We’re going to try a new experiment in which we get lots of folks building this stuff – experienced users, relatively inexperienced users, your friends – and getting as quickly as possible into the business of actually trying apps, especially for the visual and musical performance stuff that we love.

Now, you may not have folks near you who are comfortable with code or have any idea what the heck we’re talking about. But readers of CDM and fellow hackers will join up on the Internet leading up to and around June 6. We’ve got a nice, fast Internet connection in New York, and we’re setting up some tools to help us share video streams, code we create, and to allow informal text chat.

Here’s how to get involved and join us.

Head to http://hackday.noisepages.com/ for all the details. (If you’re interested in experimenting with in-development noisepages blogs and networking features as you make stuff, you may – ahem – find that registration is open.)

1. Sign up.

NYC: In the New York area, we still have some room at our special New York Internet Week event at New Work City, a coworking space and awesomeness incubator. RSVP for the in-person hackday, see the guest list on Meetup, or if you (or friends) just want to come to the party, let us know that!

Internationally: Most of you live On The Internet, though, so if you’re planning to get involved – or even to get a few friends / local hackers into it – let us know. June 6 is the “official” date, so feel free to use that as an excuse to schedule then, but really any time will work. (I’ll be working on some tests and prototypes for the full week of June 1.)

RSVP around the world

2. Get supplies, do a little planning.

This is a cheap, cheap, easy project. You basically need a surface, a webcam, a printer with paper, a light source, and some objects to track. From there, you can get fancier, which is all the fun.

The two elements that can be key to success are LED lighting strips and a good webcam. I’ve written up more details on the hackday blog on how to get these. (Not sure about shipping outside the US, so feel free to let us know about that in comments.) You can always make your own strip of LEDs and the webcams are easy to find, so you’ve still got time to gear up.

Getting Your Parts for the Tangible Surface Hackday

You’ll also see links to the two Trackmate Instructables that are our muse and inspiration for this project.

3. Hack!

Stay tuned to this site and hackday.noisepages.com for details on shared video, chat, and code, and where to contribute. I’ll also be starting some tests and will blog those, too. But the idea is, we can have effectively a virtual lab that brings together the knowledge around the planet.

The build itself is relatively easy, so the idea is:

• Test: Get something working and tested.
• Design form: See how creative you can be with the housing and tangible objects. Remember, anything you can stick a tracking sticker on can work as an object. So we’ll see what may work for practicality (interfaces that work well for running live visuals and can fit in a backpack) or unusual design (weird objects and housings).
• Design software: It’s also relatively easy to feed data into tools like Processing, Max, VDMX, and the like. So the real challenge of this will be to start experimenting with different tools for which these interfaces are useful.

Really, you can use whatever tools you want – I’m eager to see how different trackers and environments work out. But I’ll have some suggestions leading up to the event in case that’s overwhelming, and I’ll personally be using Processing for prototyping.

June 6 will be the big day and party that brings it together, but if you need to schedule on a diferent day, for it.

I’m really looking forward to this. We’re learning how to do this, but I hope this first experiment will lead to more. Let us know if you’re interested or have any questions or comments.

All the info:

http://hackday.noisepages.com/

http://trackmate.sourceforge.net/ 

Full Event Details (NYC)

(note that ReacTIVision + TUIO will work with the same physical design, too – more on recent updates to their software and the upcoming TUIO2 soon)

Share, the thesis project of Yannick Assogba in the MIT Media Lab Sociable Media Group, is an interesting idea in coding: it’s basically a peer-to-peer sketchbook for creative code. All of your sketches are synced to everyone else’s sketches, and Share tracks the connections between users.

http://share.media.mit.edu/about

You get more from Share than you would from simply, say, sharing a Subversion repository. Share not only syncs code and changes, but also tracks each time you copy and paste code from elsewhere, so that code snippets borrowed from others can be traced through the people using the system.

Up to 30 people are now invited for an online competition using the tool.

The Share Experiment is an online competition/design-a-thon/hack-a-thon and exhibition that invites 30 participants form to use Share to make new creative works over the course of ten days. The theme of this competition is "Inspired By Pong". Though the final result need not be games, artists/hackers are invited to reinterpret and remix the concept of pong while at the same time being open to reinterpretations and sampling of their own work as it being created. The Share Experiment will run from June 5th - June 14th and we are inviting applications. There will be some prizes awarded to winners (including iPod Touch[es] and Arduino kits) and we have some interesting ideas about mechanics for awarding prizes!

http://share.media.mit.edu/participate (via toxi on Twitter)

What is the Best Way to Share?

It’s a very cool idea, but this does raise some questions about implementation. It’s too bad that Share can’t run as some sort of plug-in; it loses some of the functionality of the bare-bones Processing editor, let alone the capabilities of an IDE like Eclipse or NetBeans. If it used a standard IDE, too, it’d be easier to be “language-agnostic” as the creator suggests. (OpenFrameworks or Flash or Processing, it wouldn’t really matter.)

But as a concept and an experiment, this looks really fascinating. It should be interesting to see how people use the code. And will users in a “competition” do a lot of copying and pasting, or focus mainly on their own work?

Part of the reason I bring up this is that we’re interested on CDM in doing some shared work. “Share” I think would be too limiting; it’s back to the old-fashioned Subversion approach.

So, for instance, we’re organizing a hackday around tangible interfaces in June, the first of what I hope will be many more. We’ll have people working on it in person in New York, but also folks collaborating around the world online. I’ll post more details, but just to kick off the discussion:

http://hackday.noisepages.com

(Note: that page mostly talks about using LusidOSC and Trackmate, but I really like their physical design ideas – you can easily substitute reacTIVision and TUIO if you like, and I’m definitely looking forward to the TUIO2 update soon. One advantage of the Trackmate tracker itself is that it’s built in OpenFrameworks, if that’s an environment of choice for you.)

Part of the idea is that we’d like people to contribute shared code and experiments, whether they’re advanced users or novices. I think a tool like Subversion can be ideal for that – students at NYU’s ITP, for instance, work with Subversion for Processing very early on, even though many of those students are pretty new to programming.

A traditional solution like Google Code or Sourceforge for hosting Subversion seems like not a bad idea in this case. I was likewise interested to see Project Kenai support built into a recent version of NetBeans, another example of how these sorts of things can be integrated with the IDE.

So, how would you prefer to share code – for the hackday, or any other reason? Subversion vs. Git? Google Code vs. Sourceforge? And what would an ideal tool do for you in terms of facilitating collaboration?

Interface 27 from CyberPatrolUnit on Vimeo.

There has been a long tradition in live visuals and motion graphics, inherited from many other media, of maintaining a “secret sauce,” or the guarded formula of eleven herbs and spices. Ironically, for all you hear today “DIY” and “open source” in the same sentence, a lot of the motivation for doing something yourself has historically been doing something no one else can. Keep your secrets, and raise your value.

As our friend Bryant Place / CyberPatrolUnit sends over this latest set of live clips from a recent gig, and I browse through the comments, and reflect on the conversations I had last week at OFFF and during and following my own talk there, though, I’m struck.

The world has changed. First off, the Internet isn’t really about secrets. Your value is almost in direct proportion to how much you can share. Connections are forged through links of mutual exchange and good will. It’s not just about sharing your output or getting fans (the MySpace model), but sharing with a network of enthusiasts, and fellow artists. Those are the people from whom you often get real support (artistic, technical, and personal), gigs – and inspiration. (Even if you hate 8-bit music, that community is a really amazing model: their work to support each other and advocate for the whole subgenre has been I think the single biggest ingredient in their viral success.)

The visualist community increasingly itches not only to improve the quality of their own individual work, but everyone around them. A lot of us are in a battle for the future of this whole medium. Some parts of the world are devoid of live visuals, while others have mass-produced club visuals filling the nightlife.

Before I get carried away, the video itself is just the latest from the ongoing Interface 27 series. It employs a touch interface to control abstract visual pictures formed from streams of particles.

The reason I’m pulling back into the larger question is that these visuals are enabled by a library for Processing, a library we’ve seen here previously, developed by Memo Atken:

MSAFluid for processing (and Java)

If you’d rather use openFrameworks, there’s that version, too, as pictured below running blazingly fast:

ofxMSAFluid for openFrameworks

There’s even an ActionScript 3 port, in case you want to code Flash on the beach.

ofxMSAFluid for openFrameworks from Memo Akten on Vimeo.

So, why do I bring this up? Well, the work done on Processing (Ben Fry, Casey Reas, contributors like Karsten Schmidt, and others), on openFrameworks (Zachary Lieberman, Theo Watson, and their own team), and Memo’s own library, based in turn on many other libraries and implementations, was all a big risk.

It’s not an easy thing to put blood, sweat, and tears into open source. None of those people has exactly gotten rich in the process – not even via the ways you’re supposed to profit from open source, doing the lecture circuit and such. But on the other hand, we’re seeing things that would have been otherwise impossible.

And there’s artistic merit, too. Bryant’s work looks different than Memo’s. The library actually takes on a new life as it gets in someone else’s hands. Bryant actually just wrote me:

As for the Interface video - mention how cool it is that people like Memo post code for other VJ’s to tweak and use.  Mention "FaderTouch" - a 100buk touchscreen off ebay that "vjFader" programmed - using a rear projection onto a translucent screen/ touch sensor we were able to use processing in a very intuitive way.

I got the “mention” part down, I guess. ;)

The responsibility is partly ours to make all of this work: file bug reports, fix bugs if you can, document your work, properly credit the people making it, write documentation for projects, and so on. But it’s not hard to see an ideal start to happen:

1. Person x makes a library / framework.

2. Person y build on that library to make their own tool – and contributes it.

3. Artist uses the tool, gives back to the project, goes in a new direction.

4. More and better work spreads, the project grows, the medium grows, and the audience grows.

None of this happens automatically. We all have a lot more work to do. But having stood onstage in front of a few thousand people calling for just this, it’s nice to keep opening my inbox and seeing it happening. We’re seeing the first seeds planted for what could ultimately be a larger ecosystem. Now, I know there’s also a big gap left – Processing doesn’t have nearly enough contributors, bug squashers, or documenters, and it’s one of the biggest projects, so you can imagine what happens when you get upstream to libraries and the like.

Over the coming months, I think we’ll continue to look for opportunities to help structure some of that involvement and to explaining how you can contribute, too. Stay tuned.

In the meantime, go play with some particles.

For more on Bryant, here he is on his current activities:

- I just did Coachella with [Friend of CDM and contributor] Momo, and in the near future, will be heading to Detroit for http://www.myspace.com/detroitmusicfest

I’m not on the website, however, Kero.fm and Derek Michael - two people who essentially helped build the festival from the ground up 10 years ago - are booking me to play with various acts including CLP, Richard Devine, Drumcell, Busy P (which I did a solo VJ set with at Coachella) so I am super excited to be a part for the first time this year.

Here is a cool video from previous Interface 26:

http://www.vimeo.com/4145774

After Detroit - Mutek.

http://www.mutek.org/

There are also some killer podcasts from past Mutek - http://www.mutek.org/podcast

I am going to meet artists, see the latest AV performances, attend workshops.

I’ll be at Mutek, too, so see you there.

What will become of 3D gaming engines when in the hands of new digital artists? You’ll get plenty of surprises and unexpected artwork. This is no ordinary California bicycle trip: it’s a trippy, Magical Mystery Tour in 3D, played as a game from a (real) stationary bike.

Reader Bince McKelvie writes to describe his project:

Lb to Sf via bike is an interactive installation/game that documents a bike trip my friend and I took from long beach to san francisco. The user rides a stationary bike through a the 3d world by pedaling forward and steering with the bike handle bars. The world consists of three mini games and a huge chunk of the california coast. I am going to be releasing a version that is playable on a computer without the hardware soon. It is made with the blender game engine, a bit of processing, a wii controller and the makingthings board.

By the way, if you happen to be near CalArts in Valencia, the piece will be exhibited there May 2-15.

With the exception of the (very affordable) Wii controller, this is all free and open source technology in the toolchain. In addition to Processing [site | cdmo tag], it’s a fascinating use of the Blender Game Engine. Not satisfied with being just a hugely-powerful, free and open-source, triple-platform (Mac/Windows/Linux) 3D design tool and video composition tool, Blender also has a real-time engine built in – something well worth considering if you’re looking for a live 3D performance and installation environment. That’s already gotten attention for this piece from the excellent Blender blog BlenderNation.

The 3D models and physics are sometimes a bit rough around the edges, but I actually rather like that effect: in a world of look-alike, big budget 3D creations, I can imagine a renaissance of “outside art” for 3D.

Hope to have more details on this and the tools soon.

What if one environment blended the code goodness of Processing with visual programming metaphors and patches, creating a single world for high definition video and OpenGL-powered 3D, with friendly-looking HyperCard-style inspectors, live coding, extensible graphical elements everywhere, an open-ended canvas, drawing with splines and images…

In other words, what if you could make anything, more easily?

That’s the vision of Field, a new authoring environment built on Java and Jython (Python on the Java VM). It’s Mac-only, with other platforms possible in the future (the underlying libraries are largely cross-platform, and apparently there’s the beginnings of a Windows build somewhere).

I asked Nick Rothwell to describe what it was about. Nick is collaborating with creator Marc Downie on choreographic generation and visualisation tools for Wayne McGregor’s Random Dance Company at Sadler’s Wells in London. Wayne, in turn, is choreographer in residence at the Royal Opera House and has worked on the Harry Potter Movies.

And Field can make your development environment feel, well, like a Muggle.

Field — Hybrid lines & code from OpenEndedGroup on Vimeo.

Here’s Nick’s capsule description:

Field is an open-source Mac-based media authoring system, built in Java by Marc Downie of the OpenEnded Group based on ideas formulated at the MIT Media Lab, and subsequently used for a variety of hi-def video installations and choreographic projects. It’s a graphical development environment attached to a high-resolution 3D OpenGL rendering engine, and applications are built on a display canvas with object boxes reminiscent of MaxMSP. But Field is different to MaxMSP because it’s language-based: the object boxes are individual containers of Python code, and the canvas is a flexible, scriptable interaction surface: Python code can draw on it using a 2D renderer, and user interactions and timing markers call back into the code.

There is a sophisticated editing environment for the code, and the canvas contents are version-controlled in a Mercurial repository which Field itself can inspect. Fieldis sufficiently self-referential to be regarded as a meta-environment: for example, click-and-drag editing operations on graphical elements cause Python code to be generated (and, of course, version-controlled). The text of the Python code itself can even contain embedded user interface components. Because Field is written in Java, it has access to all the Java libraries out there as well as portable Python libraries. Field can bridge to the Processing environment, allowing Processing to be scripted in Python and animated using Field’s canvas timelines and user interface components.

Working with Processing

Field — Processing Plugin overview from OpenEndedGroup on Vimeo.

The Processing integration is documented in a video shown here, as well as in a full tutorial. With everything built on the Java platform, though, it’s not really necessary for environments to “compete” – it’s a perfect example of how they can coexist, and how the Java platform can be more than just the Java language and the sometimes-ragged APIs that live in the JDK. (If you don’t know what that means, just trust me – that can be a world of hurt.)

Built with Field

Synchronous Objects by choreographer William Forsythe and a team at Ohio State led by Norah Zuniga Shaw is a spectacular example of ways in which motion can inform choreography. (Indeed: it really is about creating digital motion. Correction: this work is presently built in Adobe’s Flash 10, but there’s new work going toward Field – and it remains a great example of the intersection of choreography and digital visuals.)

As Nick put it in a recent email:

We’re all kind-of hooked up into this loose rebel alliance of choreographic software/systems research - I’ve worked at Forsythe’s Ballett Frankfurt and we’re all hooking up for a session at Sadler’s Wells next weekend… so I need to get Fieldworking again with the 3D visualisers…

It’s funny, I think that was once the way things were with Max and Isadora, except generally not in the hands of people who really knew how to code. Now, as fear of code and real research melts away, people are pushing the envelope in all of these tools.

Most importantly, of course, you’ll want to check out the work of the OpenEndedGroup. Among their literally open-ended projects, Loops is an ongoing work with Merce Cunningham, based on his 1971 solo. Merce more than any 20th Century choreographer was interested in extending the body into a new, digital self – I’d say even his non-technological work is fertile ground for inspiration in this arena. (See also the software he worked with early on, LifeForms … actually, this is probably the subject for a whole other post.)

There’s endless, beautiful work to check out at the OpenEndedGroup’s own site, like the Point A –> B stills above:

http://www.openendedgroup.com/

In a way, Field itself is an artwork by the group. It’s stunning work. Stay tuned for more both on the artwork made with this environment, and the evolving tools behind it.

We can continue to ponder how to convince Apple to let Memo’s simple but powerful-looking MSA Remote multitouch app on the App Store. But in the meantime, a resourceful developer has tried simply writing a quick app for the Safari browser. This is doubly promising to me. I love full-blown apps, and they typically allow access to some of the powerful sensor and location features of mobile devices. But that’s not to say browser apps won’t also have a place for quick prototyping, live performance, and installation. WebKit browsers are now not only on iPhone and iPod touch, but Palm Pre and Android – and, I suspect, more places soon. This could be a great outlet even for extending functionality of apps.

Anyway, if you’re looking for a quick way of using the TUIO protocol – as Memo is doing with his (App Store-rejected) app + Processing above – Andrew Turley’s app is a quick fix. I’ll be looking at mobile browser development alongside app development, I know, and I imagine all of us will keep praying for the MSA app.

TUIO Multitouch for iPhone: Browser App Hack Replaces Rejected App [Create Digital Music]

touchy feely [Pillowsopher Blog]

And yes, as this is a browser app, it should work on other platforms, too. The disadvantage of Android G1 is you’ll get only one-touch … while we wait for generally-available multitouch capabilities on Android, I imagine more specialized apps with specific platform tie-ins will be more useful.

Enrico Nau aka naus3ayt is playing with code-for-artists environment Processing (site | cdmo tag). It’s yet another example that reveals that computer vision, aside from the useful-ish applications like tracking what you’re doing, can be used to purely aesthetic ends. No code excerpt here, but the best place to begin here would be the official Processing tutorials or the OpenCV tutorial recently posted here on CDM.

Blog post here:

Chroma-sampler: painting with light

Enrico describes his creation to us:

I recently coded a toy that samples colors from a video feed and used them to create virtual brushes; similar mood to data moshing, different approach.

In other news, we have this gorgeous glitchy … something or other. Okay, actually, I have no idea what this is or where it came from (and neither does tipster con), but boy, does it take the opposite tack compared to the one suggested by David O’Reilly – it’s a maximalist, intentional overuse of a particular data compression artifact. In this case, though, it fits nicely with the musical content, which is what O’Reilly suggested.

godxilliary.com [QuickTime link]

I guess my ban on datamosh, incidentally, is well over, especially after I temporarily moshed the story database on Create Digital Music by importing with some setting wrong. (It doesn’t help that WordPress and MySQL once defaulted to Swedish. Swedish: the new lingua franca.)

Anyway, enjoy – and keep experimenting, everyone. Experiments, by definition, can be ugly, and that’s good. It’s all part of the process.