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

Want to interact with your computer musically using physical objects and other fancy-schmancy, science-fiction-y interfaces? Don’t want to rely on Microsoft or wait until 2019? You’re in luck. It’s like Christmas for DIYers and interactive futurists.

Enter LusidOSC, a set of protocols, libraries, and useful code, and Trackmate, a clever and cheap-to-build system for tangible interfaces. Together, you’ve just got a bunch of tools to help you start playing with blocks — erm, experiencing new spatial interfaces.

• LusidOSC, the library maps “spatial input devices” – really, any tangible devices or sensors in the real world – to applications, like live music or live visuals. It uses the network-savvy OpenSoundControl protocol. The library is available now for Processing, with Java, Python, Flash, and C++ in the works.
• LusidOSC, the apps/code: a set of Processing utilities to get you started includes a basic example app, command launcher, playlist mixer, and a MIDI sequencer. You can build on these for your own Processing apps.
• Your own input device: Tags? Sensors? Markers? Regions? Fingertips? If it’s in physical space, you can map it via LusidOSC. Or, if you want a place to start, try:
• Trackmate: A project of MIT’s Tangible Media Group, Trackmate lets you affix tags to any objects you want and use them as an interface.

LusidOSC is just the protocol; it’s physical applications like Trackmate that get really interesting. In these economically-challenged times, Trackmate gives you tangible interfaces for next to nothing. All you need is a computer (Mac, Windows, or Linux), and a camera (even a webcam will do). Print out randomly-generated tags in the free and open source software, stick them on stuff you want to use, and go to town.

You can make your own Trackmate surfaces out of hardwood or plexiglass for as little as $40 in parts. There’s even a Processing-based simulator app so you can experiment without the physical objects. (Good for troubleshooting on the bus or plane, I imagine.)

Trackmate is just one project, though; LusidOSC promises to support other interface ideas, too.

LusidOSC at Sourceforge, the work of “many research institutions and companies.” (Which, I wonder?)
Trackmate at Sourceforge, a project of the MIT Media Lab Tangible Media Group

Alternatives: TUIO, the protocol used in the Bjork-endorsed Reactable project marches forward, as well. And as both projects are open source, there could be some cross-pollination. I hear a revised TUIO is coming, and in the meantime, LusidOSC acts as a gateway to TUIO.

I want to highlight two sequencers that you play as if they’re games. (Just don’t play a Vulcan – they always win.)

Robots on a Grid

Al-Jazari is named for a 13th-Century scholar and musician who apparently invented an entire band of water-powered hydraulic robotic musicians with more than fifty facial and body movements per song. (Okay, that clearly deserves a separate post later. So, our Western education is so eager to avoid the achievements of Arabs that we skipped over the fact that he basically invented Disneyland in the Middle Ages.)

Al-Jazari in the 21st Century iteration takes the idea of robotic agents and builds a sequencer around them. Creator Dave built a grid on which you can give the robots symbolic instructions (like up, right, down, left), selected from a gamepad. Each grid square represents a note, with pitch modulated by moving bricks up and down. Like Elysium, the music is generated as events are triggered on the grid. And like Microsoft Research’s (non-musical) game Kodu, the gamepad and a set of symbols make what is essentially scripting easy and transparent. (Few would likely call this “programming” because it doesn’t look scary, but that’s what it actually is.)

Al-Jazari is open source, built in the elegant coding language Scheme (a Lisp dialect) atop a game engine called Fluxus. Dave has extensive documentation on its development, and not only the code but even the textures and models. You can use this yourself on Mac and Linux, but it’ll require some messy compiling. (Thanks for this link, MattH – this is layered with things that blow my mind!)

Al Jazari [pawful.org]

reacTogon

Mark Burton’s reacTogon was the influence for Elysium. It’s a “chain reactive performance arpeggiator” – that is, it takes the usual, static, repeating patterns of an arpeggiator and turns them into something altogether different, by allowing events to transform dynamically in two dimensions across a hexagonal grid. The interface is a multi-touch controller with physical objects, so there’s a tangible element, as well.

Looking at reacTogon alongside Al-Jazari really demonstrates some of the advantages of a hexagonal grid versus the more traditional square grid. (And if you think about most musical applications, most of what we have is relatively non-dynamic right-angle grids. There’s movement, but only left to right, with start/stop or loop points. One exception: Follow Actions in Ableton Live.)

Al-Jazari requires movement only to tiles with adjacent edges. reacTogon, since it tiles hexagons, has six adjacent tiles instead of four. It can also map a harmonic table, as other musical hexagonal grids do. Now, that’s not to say reacTogon is better than the other – on the contrary, it demonstrates that just one choice – a grid of squares or a grid of hexagons – can create very different musical possibilities. So even if you’re not musically impressed by these examples just yet, think about the possibilities here. We’re still early in software design and musical interface, so early that something as simple as a simple geometric pattern can become an entire composition.

That’s something to ponder on the eve of the music manufacturers’ trade show.

(If anyone has more documentation on Mark or his creation, let me know.)

The idea of the Reactable is to make music tangible, with control of sound mapped to physical objects you move around on a table. But that hasn’t stopped the Psychosynth from creating a virtual version. (Upside: it’s a lot more portable.)

Psychosynth

Watch the video, but they seem to have made the opening minutes as dull as possible to thin out the non-believers. Skip past the generation of the white noise oscillator (wow, white noise!), and somewhere around halfway through, it becomes laugh-out-loud funny, with trance-style vocals about freeing your mind with free software. (Seriously – it’s awesome.)

While it’s in alpha stage, the software is fully free and open source (binaries available for Debian and OpenSUSE) – and that means this could be a good project to snoop around in or code through, those of you who are eager hackers.

At its heart, it’s simply an interactive modular synth inspired by Reactable. Drag objects around and connect them to make sounds and patterns. Underneath is a powerful C++ synth library, a 3D synth, and even a server version – so even if you aren’t sold on this interface, there are pieces here that could be useful. It’s all virtual now, but that’s not to say you couldn’t add input; support for the input library is planned later.

That said, I don’t think they went far enough with the virtual thing. Next, why not simulate virtual players for the virtual Reactable inside the computer. They could even behave like Sims, requiring regular stimulation and bathroom breaks. Eventually, you could unlock Bjork.

Enjoy. If anyone gets this up and running even in alpha state, let us know.

Previously: tables and tangible, like the lovely acoustic sounds of Etiquette and, of course, Spaces / Roots

Across series of colored bars, sounds warp and mutate. Vines entangle as organic threads of music. Fingers and objects traverse sonic landscapes in surprising, mysterious ways. Welcome to the worlds of BricK, the musical table interface by Jordan Hochenbaum and Owen Vallis, which, charged with software by Dimitri Diakopoulos, Jim Murphy, and Memo Akten, explores new musical frontiers. The tool uses a combination of open source tools for tracking fingers and objects on a table, then feeds those into sound and music environments.

Just following the landmark, long-awaited release of Processing 1.0, BricK demonstrates the expressive potential of the open-source platform. Processing allows quick and elegant development of stunning visual interfaces, while other tools (ChucK and Reaktor, for instance) serve as sonic engines. Sometimes the sounds themselves are not revolutionary, but by simply replacing the visuals and interaction – just as with changing the look of a score – the music is transformed, too. (At top: experiments with different interfaces for music using the platform they’ve built.)

CDM got to talk to Owen and Jordan about the projects. And now’s a perfect time – the gorgeous Roots is looking for a home, in case we have any curators / galleries / other interested parties in our audience. First, a review of what these platforms are:

Spaces, Multi-Touch Music

Spaces Multi-Touch Music Environment from BricK Table on Vimeo.

Jordan tells CDM about Spaces, their latest creation, which premiered alongside a performance by Daedelus in LA:

Spaces is the latest interactive multi-touch musical application for the Brick Table. Designed as a minimalist interface to free musicians from traditional compositional markers such as frets and keys, the environment enables musicians to compose intuitively through immediate visual and sonic feedback.

In this video, Spaces mediates a spontaneous composition and performance of a slow-moving ambient soundscape.

Spaces was developed by Jordan Hochenbaum, Owen Vallis, Dimitri Diakopoulos, and Jim Murphy.  It was recently used in a performance at the REDCAT lounge at the Walt Disney Theatre, Los Angeles, and further developments are currently underway.

Roots, an Organic Installation

Roots Multi Touch Tangible Installation Teaser from BricK Table on Vimeo.

Roots has been impressive in Web videos, but it’s looking to make the transition to the real world, after a shipping mishap prevented what was supposed to be its premiere showing at New York’s Minitek Festival earlier this fall:

“Roots” is an interactive installation for the Brick Table tangible and multi-touch interface, where multiple people can collaborate in making music in a dynamic & visually responsive environment.  Users use their fingers and tangible objects to create and interact with virtual branch-like vines that move around the screen, allowing users to create either entirely generative, semi-generative, or sudo-composed arrangements and compositions. 

Roots is truly a unique and expressive interactive installation which came together through an internet collaboration between Brick Table’s creators (Jordan Hochenbaum and Owen Vallis), and the super-talented London-based designer/developer Memo Akten.  It was recently selected as a featured Processing Exhibition on Processing.org and we feel it is time to release Roots into the wild…

So! We are calling out to all of you lovely CDM readers out there to get Roots out and into the public.

For more information on how Roots works, please see What is Roots?

Please use the contact on the BricK Table website if you are interested.

Behind the Scenes

CDM: How do the visuals relate to the sound?

BricK: The nature of the vine-like branches in Roots lends itself to creating music with what is — in our opinion — an organic and open feeling. We felt that the music should both sound and feel as if it is coming out of the visuals, and vice-versa, and so we did our best to stay true to this relationship in the overall musical aesthetic of the sounds produced.

The Spaces environment expands on the theme of unconventional visual representations of sound manipulation. Each column is an open space connecting an idea with a musical parameter. Combined with the visual feedback, we decided Spaces would work best with slow-moving ambient soundscapes, although it is certainly possible to experiment with other musical styles..

What sorts of relationships did you experiment with before settling on something you liked?

BricK: With Roots, we first worked with Memo to develop the visual elements before even attempting the musical side of things.  We discussed various approaches to its visual and musical relationships. Did we want it to be completely generative? Did we want a more direct and repeatable relationship between your finger and the resulting sound?  We really liked both ideas, and so we made it all inclusive– making it able to create completely generative, semi-generative, or directly manipulated/composed musical outcomes by the use of finger pressing, sliding, and tangible object interaction.  This really makes Roots unique in comparison to other environments which enable generative musical arrangements.  Each performer can exert as much or as little control over the relationship between physical, visual, and musical interaction as they want at any given moment.

In Spaces, we discussed a few different ideas about the layout and design of the interface. Ultimately, we decided on Spaces being able to control four different instruments, each with four parameters (volume, and three others). We toyed with different methods for visually representing the value of each column without turning them into a traditional slider. We felt the cool-to-hot color morph in each column was fitting: the user has to rely more specifically on the sonic result rather than exact value, veering from more traditional musical interface paradigms.

How did you deal with timing relative to the visuals?

BricK: In Roots, it was necessary to have the generative data play in a relatively synchronized manner to maintain a degree of musicality. As the vines move around the environment, the musical outcomes are quantized to various beats. [Ed.: The quantization all happens in ChucK.] That being said, continuous finger movement scrubs audio in a direct 1:1 relationship that gives the user the feeling of direct manipulation when that is wanted.

Spaces has no generative movement (at the moment) which means timing is always completely synchronous with finger movement, both sonically and visually. We tried to make sure that the way in which the colors morph feel as free and smooth as the slowly evolving musical outcome.

Can you talk a bit about how the sound is generated?

BricK: Roots uses audio buffers as its underlying sound source (although the musical outcome is VERY different than the original material). Each vine gets assigned an audio buffer which is then ’scrubbed’ through as the vine generatively maneuvers around the screen.  The audio and buffer manipulation is done using the ChucK audio programming language. By simply changing its source material, Roots will produce vastly differing musical results.

Spaces generates sounds in a number of different ways, all using Reaktor. Each of the four instruments employs a selection of synthesis methods. Some columns control pitch, other columns control combinations of filters and effects. The clicky percussive sounds are generated from an audio loop which is granulized and re-synthesized with altered delay rate, etc.

What are your future plans for these pieces?

BricK: Roots is ready to go, but in our free-time, Owen and I play with using it as a sequencing device in other ways — using movement and vine-location to pluck notes, control effects and filters, etc.

Exploring Roots along these other avenues will probably create the need for a new GUI interface, which means perhaps Roots will have a new little cousin sometime in the future.  That being said, we are really happy with Roots as is (we reached our specific goals), and we are more interested in giving it the proper debut it deserves, rather than changing the way it works.  We had a great time working with Memo, whose work I actually first came across here on CDM, and would love to work with him again in the future.

Spaces was developed in a very short timeframe for a performance at the REDCAT Lounge at the Walt Disney Concert Hall in downtown Los Angeles, and so we are absolutely looking to expand the possibility of what the Spaces interface is capable of. First, we would like to expand the number of instruments capable of being performed. Secondly, we would also like the interface to be “physics”-enabled, for example, using a flick motion to send a bouncing ball down a column to automate a parameter as the user concentrates on other instruments.

The Software

Just to review, here’s the software powering BricK:

tbeta (“The Beta”): finger tracking. tbeta is an open-source, cross-platform computer vision and multi-touch sensing platform. It’s the successor to the former touchlib, which wasn’t as cross-platform or quite as awesome. More on tbeta on Create Digital Motion.

reacTIVision: fiducial marker tracking for objects. (Fiducial markers are these funny, cellular-looking patterns pictured at right that allow you to track specific objects manipulated on the table. reacTIVision is the open-source library developed by the folks who did reactable. Sounds as though we might get fiducial tracking in the other library, though.)

ChucK: a strongly-timed, quick-to-code sound and synthesis language. It’s elegant enough that it’s used for real-time programming – as in, onstage, in laptop ensembles like PLOrk and (its West Coast descendent we just saw here on CDM) SLOrk.

Native Instruments Reaktor: The modular sequencer, instrument, and effect builder, which we cover regularly on our Kore minisite. It’s the only commercial / non-open-source choice here, though it may actually replace ChucK on Roots in the future.

More Info

Brick website

It helps that Bjork pulls out some of her synthiest, electronicilicious-est tracks, like Pluto:

and Hyperballad:

And, of course, part of what happens is that the computer screen here has become the interface. When it works — when the visuals match the sounds, and suggest some new ways of constructing music — it really does show potential for this kind of instrument. (Even if you don’t buy into the blocks, the way the visualization itself works has a lot of promise.)

That’s the idea behind Microsoft’s Surface, too … but sometimes the gimmick can be a solution in search of a problem. Well, actually, maybe your computer of the future really will be “a big-ass table.” (Thanks, SarcasticGamer.com, for making me laugh so heartily.)

MultiTouch Console

Quite a lot of tools have been connected to make this happen, but they’re all out there so you could do something similar. Let’s see if I can get this right: the software is a collaboration of two projects that resulted in the multi-touch loopArena MTC, for making music interactively. loopArena itself was built in the free, Java-based Processing, originally with MIDI support via the ProMIDI library but now evidently using OpenSoundControl. The graphics library libAVG (“picking up where Director left off”) does the tracking, though there’s also a link to the free multi-touch library Touchlib.

And, long story short, here’s what you get:

YouTube readers sum it up best: “air hockey is cool again” … “this is the real future voodoo.” Couldn’t have said it better myself.

More fun than organizing your digital photos in a hotel lobby, huh?

It’s interesting to me, though, that after all this work, you don’t necessarily get a different kind of music — just a different way of making it. And there seem to be two major directions in interface. On one end of the spectrum, there are glitzy, complex interfaces with sophisticated hardware. On the other end, we have increasing interest in minimalism, like the grid of buttons on the Monome, retro-styled software interfaces in trackers on computers and game systems, and, at some point, just a desire to take that KAOSS Pad and MacBook and MIDI keyboard and just practice making music rather than worrying about interface. I actually thing these seemingly divergent threads may all lead back to the same places in the end, and don’t know that they’re even incompatible — but, “ooh, aah” factor aside, it’s fun to watch them spinning themselves out.

If this makes one thing abundantly clear, though, it’s that even though Microsoft has an easier time getting on the Today Show, they by no means have a monopoly on experimenting with these kinds of interfaces.

Got more resources for building your own tools? Diagrams, software libraries, code, blogs about how yours didn’t quite work, blog about how awesome yours is? Let us know!

The good news: Microsoft is taking multi-touch, camera tracking, and gestural technologies seriously, and they have what looks like a very nice implementation that will be one of the first commercial implementations. The bad news: it’ll cost US$10,000 out of the gate. That high price will mean you’ll see at places like T-Mobile stores and Sheraton hotel lobbies first. But what you need to know: you can build your own version, thanks to available open source tools, with is likely to be more useful for music.

Good sources of commentary:
New Media Initiatives Blog at Walker Arts Center, which notes this could be museum-friendly tech.

Chris O’Shea @ Pixelsumo, who has built a device something like this himself.

The video does show what’s cool about Surface — and it’s easy to imagine these same techniques being applied to live visual and music performance. (People have already tried experiments in that, and I think there’s a lot more to be done — once you’re talking music rather than just digital snapshots, you get into deeper questions about how to model the interface.)

But let’s get a few things out of the way:
1. Enough about Minority Report, already! Minority Report was a terrific movie from an interface design perspective. (Slightly less so from a … well, movie perspective, but that’s another story.) But this has nothing to do with Minority Report’s free-form, table-free, gestures in 3D space with gloves interface, unless all vaguely futuristic interfaces will now be compared to that movie. Actually, this thing is more practical, unless you want to share gloves with people at the Sheraton. (Ewwww … oh, and incidentally, there’s no logical reason why in the future we need gloves to do tracking.)

How about other comparisons? My apartment looks kinda like Blade Runner. This ATM is exactly like Lost in Space. If I start selling giant rubber costumes with fins, I can be the first to bring commercially-viable Doctor Who monster technology to a mainstream public. Oh, never mind.

2. “First commercial implementation” is sometimes meaningless. Since the dawn of time, pricey, first-to-market versions have often failed. Look at Apple: Lisa? Newton? Even the Mac initially lost out to the Apple II. That’s just one company. Now, there’s the additional reality of readily-available tools allowing people to take concepts like this and do whatever they want, freely experimenting without market restrictions. The commercial implementations may be more successful in that case — but the independent efforts could be sexier.

3. Tables take up space. Part of the reason you’ll be seeing this in hotel lobbies is that the tracking here presumably requires a large physical object in order to work, much like other interactive tables we’ve seen. If you want gestural or multi-touch technologies to be portable, or work with much smaller computer form factors, you need a different design. I’m still intrigued by what cameras may be able to do with enhanced computing resources.

None of this is intended to criticize Microsoft. I’m personally excited this stuff is catching on. I just want to make sure we remain tethered to the larger realities here.

That said, I’ll be eager to try out the demo version in New York in a couple of weeks, which just happens to coincide with a conference of people interested in musical interface design. Heck, maybe we can convince the Microsoft engineers to come over for a few drinks.

DIY Surface Computing

Be Your Own Bjork: If you want to build your own device like this, the reacTable software is available open source. It’s even available as a library for the free tool Processing, which is an ideal environment in which to learn how to code this stuff. reacTable is a little different from Surface, in that reacTable has objects on the surface to manipulate. That rules out some gestures you might make with your hands, but it does add additional tactile feedback, and, hey, playing with blocks is fun. Actual touch might be more difficult, though other computer vision tools that enable tracking are available.

Chris O’Shea (who comments on today’s announcement on his blog Pixelsumo) had also begun an open source software and hardware project using blocks on tables, called Sonic Forms. That project ultimately didn’t take off, but Chris has gone on to write about, speak publicly about, and do other wonderful things, like a table installation with music boxes.

Of course, my significant other doesn’t live in the world of blogs, and says, wisely, “but would you really want to do that?” That’s not a bad question to answer. It’s worth weighing this against other interface possibilities, and, for that matter, balancing the time you spend on the interface with the time you spend on music. More on both those topics soon.

And yes, obviously whoever shoots photos of these things doesn’t really get this concept. Here’s a hot tip to save you US$10,000:squeeze someone you love right now, huddle next to your computer in front of Google Maps, and you, too, can have “collaborative computing.” (Make sure they point meaningfully at the screen and laugh with delight at … the … directions … to the airport.) Since you can do this with a normal laptop, you don’t have to put a giant, clunky digital table in your living room. Which is good, because those coffee table books might screw up the tracking.

So you’ve been reading ths site long enough to see lots of interactive tables — alternative musical interfaces that involve moving blocks around a surface. But what practical use would this ever have, you say?

Clearly, outfitting the workplace of the future — or at least so says Lexus to its designers, which is equipping them with interactive desks. The Ecco Design Personal Pond desk (Trendir story) creates soothing music and lighting effects while you move around your hands or two stones on the table. And this helps us be more productive — how, exactly? Nonetheless, it’s nice to see the mainstream taking note of interactive musical table tech — keep your resumes handy, interactive designers.

(See CDM’s musical table roundup, or check out the pixelsumo blog for more tables.)

Here’s even more open source code for creating new sound interfaces using free-moving blocks for control. We looked at Sonicforms, which is both intended as a project and a repository for information. Chris’ project uses a projector aimed at a tabletop for additional feedback, and IR lights for sensing. That adds cost to the system and makes it less portable (though it does provide a cooler visual interface.)

The d-touch project, in contrast, uses tags on the blocks that are recognized by a simple webcam (fiducial recognition). Advantage: no projector, no fancy interface, ultra-portable, ultra-cheap. Sure, you lose out on the tricky visuals (and, importantly, visual feedback) — but you get the even more mysterious effect of moving around ordinary blocks with strange hieroglyphics on them.

d-touch features cross-platform C++ code (compiled on Mac OS X, but tested on Linux and Windows, too); the code is open source and regularly updated. Give us a buzz if you do something with it, because I can’t program my way out of a paper ba– uh, tangible interface.