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.

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.)

lights on from thesystemis on Vimeo.

Digital visuals are often confined to a screen or a panel of wall. So there’s something magical about projects that get an entire building as a canvas. “Lights” is a live audiovisual performance for the Ars Electronica museum in Linz, Austria. The facade has some 1085 LED windows, controllable in real-time. The performance involved coordinating these windows with broadcast music.

The work was put together, stunningly, in just three days. OpenFrameworks, the artist-focused, C++-based code framework for “creative coding”, became a critical part of the process, assembling all of the real-time visuals. Zach Lieberman, co-developer of OF, also worked on the project and describes its ingredients and team:

this project was made as a collaboration between 4 different folks,
including daito manabe (musician & hacker), damian stewart (artist and
one of the creators of rjdj), joel gethin lewis (formerly with united
visual artists, where he worked on projects like massive attack’s LED
show) and myself (developer of openframeworks).
–> (daito) [daito.ws]
–> (joel) [http://www.joelgethinlewis.com/]
–> (damian) [http://frey.co.nz/]

we did alot of stuff with software that might be interesting for your readers — the tools involved (abelton, max, pd, openframeworks, dmx) and the challenges of a display like that, etc….

Breakdown of the tools:

• OpenSoundControl (OSC) for connecting audio and visual elements (and as Zach and I discussed privately in an email, it’s really the power of being able to relate different media, physical, aural, and visual, that defines the project more than any one tool)
• Max/MSP and Ableton Live for the audio score
• Pd (Pure Data), Max’s open-source cousin, for recording audio and OSC control signals

Zach notes “what I liked about it was how eye opening it was to feel that you can use each tool for what it’s good for.” 

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

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.