Alexander Chen, he of Kinect hacks and subways turned to strings, is back with another string visualization. Built in the browser (an interactive version is available), this work makes a visual accompaniment to Bach’s First Prelude from the Cello Suites. If you read music notation fluently, you may find the score itself suffices, but even so, the math to make this work – and the dance of circles across strings – is compelling. Alex, whose day job is with Google’s Creative Lab, talks to us a bit about the mathematics and process. First, his description:

baroque.me visualizes the first Prelude from Bach’s Cello Suites. Using the math behind string length and pitch, it came from a simple idea: what if all the notes were drawn as strings? Instead of a stream of classical notation on a page, this interactive project highlights the music’s underlying structure and subtle shifts.

Built in: HTML5 Canvas, Javascript, SoundManager
Made while a resident at Eyebeam

CDM: How did you settle on this particular visualization of this famous work? And how did you work out the maths, that is, why this specific number of dots, the distance from the strings, and the length of the strings themselves?

Alex: When I listened to the opening of the Bach, where it repeats the same bar twice, it made me think of a call and response. So I immediately pictured two wheels that echo each other, instead of just one wheel with four dots.

Figuring out the symbolic string lengths in pixels was a fun research project. I wanted explore the simple math behind string length. I learned that you can derive an entire chromatic scale just by using two fractions: 2/3 and 1/2. These correspond to the fifth and octave intervals. It’s called Pythagorean tuning. I stumbled onto this great little worksheet [PDF link] which seems to be intended for students.

Were there other things you tried, any failed experiments?

There were important learnings. It used to begin playing the piece right away. I started the opening tuning animation as an afterthought while I was preloading the strings. But that sequence became really critical.

What’s your sense of the music now having done this? Did it change your hearing of the piece

A lot of music visualization these days is linear, like reading a score. Logic’s editor, or even games like Guitar Hero, all follow that structure. And there’s a reason for that, as it’s convenient, for both computers and humans, since we can read it (and edit it) like a book. But I wanted to try something different. I think some of the magic of watching a performer is seeing such subtle, intricate finger movements produce such moving sounds. When I watch these strings morph, it feels more like the computer is performing, not just checking off notes one by one.

Seeing the Bach Prelude in groups of 8 notes gives me a bigger picture view of the piece. Instead of focusing on the individual notes, you can see each bar as a group. The strings start shifting very subtly, but as the piece builds, the strings seem to be panicking to me, shifting more rapidly. The computer is not expressive. All notes are played at equal volume. But the notes themselves, the data of the song, is inherently expressive.

http://blog.chenalexander.com/
http://twitter.com/alexanderchen
http://www.baroque.me/ [interactive - grab the ... circles ("grab the balls" doesn't sound quite right)]

With soft synths a dime a dozen, how do you set yourself apart? Defying conventions is a pretty good start, and a team of developers who built the Mixxx open source DJ tool are doing just that.

SodaSynth from Oscillicious is a soft synth with a different approach. With no effects and, surprisingly, no filters, SodaSynth is all about the oscillators. But apart from its ready-to-layer sound, the developers are also making their software run in new places: aside from a VST, there’s a version for HP’s defunct TouchPad and, more interestingly, the first major soft synth we’ve seen yet for Google Chrome’s Native Client. We’ve got some details on the latter that will appeal to you hardcore Web browser / coder geeks out there.

First, the sound: with no filters and no effects, SodaSynth’s developers say they’ve made a synth that’s easy to layer. You get five waveforms, up to 32 oscillators per note, and full 8 note polyphony. (Per-note oscillators to me is where things get interesting.) The controls are pretty stunningly simple, but with five “classic” waveforms and some unique morphing settings.

Also, for those new to synthesis – and for some of those more unusual parameter names new to all of us – they’ve added extensive in-line online support, in a nice touch. (More in the gallery/sounds below.)

I’m in. Mac and Windows VST, and should run fine on Linux machines with Windows VST support. US$23.

SodaSynth VST

Here’s what it sounds like:

SodaSynth VST Demo 1 by Oscillicious

And there’s an HP Touchpad version, which you’ll find for $3 in the HP App Catalog. Notable in that it may soon join our Doomed Tablet Instruments Hall of Fame. (Our friend Francis Preve had an instrument out for the Newton. Really.) Seriously, if anyone has a TouchPad, send us video, ‘kay?

But more practically…

You can run SodaSynth right in Google’s Chrome Browser. We’ve seen plenty of synths and even full-blown workstations employing Adobe’s Flash. And there have been some projects built in JavaScript for Mozilla’s Audio Data API, previously called the Web Audio API (which I liked better as a moniker). Tons of examples via the Chromium site; Chrome and now an experimental Safari build have added support:

Web Audio API Samples

Soda Synth uses a third avenue, one which I’ve heard lots of people talk about but no one actually try. Google’s Native Client allows you to run native code right in the browser – not this JavaScript kids today love so much, but good, old fashioned, C/C++.

What does that mean for synths? Think low-latency live audio that out-performs other solutions, at least for now. SodaSynth isn’t just the first NC synth in the Chrome Web Store; according to the developers, it’s the first Native Client app, period. (Answer to the question “who cares whether you use native code ever again?” is, of course, “audio people.” I’m sure JavaScript advocates will be happy to chime in here, but even if JavaScript matches C/C++ performance, the ability to run C DSP code natively will continue to have advantages down the road.)

It’s free, so add it to Chrome now, and you get a synth you can jam with – there’s even a 4-bar live looper so you could produce actual sound snippets with the thing. I’m curious to hear your experience.

SodaSynth, free for Chrome Web Store

Developing in Native – Why it Matters, What it’s Like

I’m all about getting the nitty-gritty details – yes, including not only why this is exciting, but what the development process is like, warts and all.

Developer Albert writes:

Why is this news? It’s native compiled C++ code running our synthesizer in a browser at full speed, for the first time. While there’s some other pro-audio web apps like AudioTool, nothing can really get the latency low and run efficiently without native code. We think this might be a peek into a future where we there’s real pro-audio web apps.

I asked Albert specifically what challenges, if any, they’d encountered. Albert tells CDM that NaCl (get it?) still has some rough edges and needs further testing, and significantly isn’t enabled by default for some users. He did qualify that by noting NaCl’s developers have been generally helpful.

The Pepper Audio API that NaCl implements is pretty similar to SDL and performance seems to be good. The three big advantages of using NaCl over Adobe Flash for this sort of thing are raw performance, being able to directly set the audio latency, and that most audio apps are already written in C/C++, so they’re easier to port. Being able to just upload your binary to “deploy” it instead of building Windows/Mac/Linux versions is a huge time saver too.

Currently, I’m only hosting binaries for x86 and x86_64 because the Native Client doesn’t actually work on ChromeOS yet. One of the main
NaCl developers mentions this [2], though perhaps that’s been miscommunicated by Chrome’s marketing team, because I too thought it
was supposed to work.

The next milestone for the Native Client team is to implement “Portable Native Client”, or PNaCl [1], which will mean that NaCl apps will get distributed as “LLVM bitcode” instead of compiled architecture-dependent binaries. In other words, you will compile your application once, and it should run on x86, x86_64, and ARM. I think Google is waiting for this before pushing NaCl into ChromeOS.

“Early days” seems to be the key phrase here, but I’m eager to see Google put some resources behind this and turn this into a solid solution, especially on their nascent Chrome OS. (Too bad, as I was looking forward to seeing someone fire this up on a ChromeBook.)

For further reading, via Albert:

[1] The gory details about the proposed PNaCl plan
[2] Chrome/NaCl engineer at Google saying it doesn’t work in ChromeOS

More Images + Sounds

A song without and with effects, using Renoise:

SodaSynth VST Demo 2 (Dry – No Effects) by Oscillicious

SodaSynth VST Demo 2 (Wet – With Effects) by Oscillicious

The VST version:

Image of the ill-fated HP tablet version:

http://www.oscillicious.com/

If you’re looking to turn an Android phone or flashy, new Android tablet into a touch controller for music, you’ll be really glad to see OSC and MIDI controller Control. Furthermore, here’s a solid, powerful app based on the Web that lets Apple and Android fans play well together.

I’ve sung the praises of Control’s philosophy before. Templates are built on Web/HTML5 (WebKit) rendering, not proprietary, inflexible interface widgets, and can be created in JSON. You can make templates dynamic, too, because of everything JavaScript does.

(Non-jargon-filled translation: you can use the goodness of the Web to make control layouts that do whatever you like.)

The iOS version is a great option, but now Apple and Android owners (or people with both) can both get in on the action. The Android version already has multitouch on supported hardware, Bonjour/Zeroconf networking support, OSC support, and interface downloading. That means it’s already a usable wireless controller for musical and visual performance. Soon, it’ll also add sensor input and MIDI.

With new tablets from Samsung and Toshiba – the Samsung thin and slick, the Toshiba hefty but with tons of ports – the timing seems right. Also, because the app itself is open source, developers curious about adding any of those features to their own apps can share code and (ideally) contribute back to the project, which could accelerate Android development. I’ll leave our audio API gripes for another time – this is a controller app, so therefore doesn’t make sound – but for those looking for more mobile tools, this is unqualified good news.

Full feature list:

- Outputs Open Sound Control (OSC). MIDI coming soon!
- Handles multitouch on capable devices
- Bi-directional communication: use Control to set values on your computer, use your computer to set values in Control
- Dynamically add and manipulate widgets via OSC messages
- Reads and outputs data from Accelerometer and Compass sensors (on applicable devices) with adjustable update rates
- The ability to script behaviors for widgets using JavaScript
- Auto-discovery of wireless networks via Bonjour
- Interfaces can be pushed to the phone via OSC or downloaded from the web
- Supports both portrait and landscape interface orientations
- Interfaces work on both phones and tablets (tested on Droid and Asus Transformer)
- Free

And here’s some of the new, dynamic jQuery functionality, relevant to both iOS and Android users. The idea is, using OSC, you can dynamically create your own interfaces:

More documentation on that, with an example in Max/MSP:
Control 1.3: Dynamic Interfaces, jQuery integration & more

Finally, some images of the Android version, which looks – rightfully – quite a lot like the iOS version. (That’s the idea.)

Learn more about Control, and follow its development across platforms:
http://charlie-roberts.com/Control/

Or for Android users, grab a copy – I’ll be trying it on my Galaxy Tab 10.1 right away:
Control (OSC + MIDI) @ Android Market

The software is really entirely the work of Charlie Roberts – really brilliant work, mate! Thanks for keeping CDM posted!

Electric guitar pioneer Les Paul is one of the all-time greats in music instrument invention, so the guy clearly deserves an animated Google Doodle of his creation that you can play. Strum chords, pluck with the mouse, and even record phrases on Google’s homepage. (See video, above.) Since Google Doodles are archived – and since you can look at the code by choosing a View Source feature in your browser – these little novelties also have a life beyond their one day of glory. (Note, you may need to visit the US site if you’re in a part of the world that doesn’t have this Doodle, since they’re localized.)

Here’s where things get a little geekier:

Using the free and open source tool SuperCollider (Mac, Windows, Linux), composer and coder Nick Inhofe scripts Google’s interface, using the ability of SuperCollider to talk to keystrokes. You can download SuperCollider for free and try it out – it’s an insanely powerful real-time synth and processing engine – or just hit the Google shortcuts to hear the results. Full details:

Google Doodles with SC [SuperCollider mailing list]

Good, clean fun.

Check out Nick’s SoundCloud account, too, for some good listening:
http://soundcloud.com/exit_only

Behold the power of the Web: composition ideas become a tool, a tool becomes a means for even casual users sharing musical sketches, and a browser toy can be a window into a Turkish sound artist breeding musical DNA like some people breed strains of flowers.

Otomata is a simple generative online grid-based sequencer, owing to a number of step sequencers and Toshio Iwai’s Tenori-on, with some beautiful circular visualizations of the resulting sounds. I’m late in posting it, but in a way, that’s a good thing – in the time that this sequencer has spread around the Web, it’s spawned a small army of casual musicians producing their own videos and patterns.

And that brings me to an observation. In all the discussion of “apps” versus the Web – a discussion as old as the network itself, having appeared as “cloud computing” and various other forms before – people may be missing the point. Right now, Otomata is not an app, though iPhone/iPad and Android versions are reportedly in the works. It runs as a Flash file, which gives pretty much anyone access to it (including the majority of people on the planet who still don’t have either an iOS or Android device).

But it’s Web sharing that’s already making it powerful – people sending around links, sharing creations, and showing friends. App or not, the Web is what makes software successful these days, through YouTube views, blog posts like this one (ahem), and even casual “look what’s on my screen” sharing that results in the exchange of a URL anyone with a browser can run. Flash may not be the best rich tool the Web has ever seen, but it’s only the means to an end – the end being getting things in a connected browser.

Want further evidence? Look no further than the Facebook page, or better yet, open discussion on Reddit:
http://www.reddit.com/r/otomata/

Great design, embodying musical sense in the structure of the tool itself, makes this a hit. And for that, you can thank “computational sound artist” Batuhan Bozkurt of Istanbul. His musical expression is generally procedural by nature, expressed as a set of rules in compositional form. Check out his terrific video on this work, as built in the open source tool SuperCollider.

If you can tear yourself away from playing with this wonderful toy, you can get deep into genetic code for musical composition and spectacular SuperCollider creation.

http://www.earslap.com/projectslab

Rapid iteration? Quick contagian? Generational evolution? Hmmm… sounds a bit like what’s happening on a larger level as creations like this spread around the Web. But it’s a heck of a lot more fun than genetic engineering … or the plague. So play away, Internets.

Tons of additional information and goodness on Batuhan’s site:
http://www.earslap.com/projectslab/otomata

Thanks to Max (and others) for the tip! (Max actually suggests trying this with multiple tabs open!)

The armies of the earbuds are everywhere, as people – since the dawning of the Walkman – tune out their surroundings. What if, instead, your surroundings became soundtracks? That’s the question posed by a mobile app research project, partnering between New York’s Times Square and a creative team at the Georgia Institute of Technology.

UrbanRemix invites users to capture geo-tagged sounds with a free iOS and Android app, then to string them together into sound compositions on the Web (as seen above):

Download the app
http://urbanremix.gatech.edu/
Map + remix interface

There’s a great write-up in the local press here in New York:
Times Square Noise Gets Turned Into Music [DNAinfo.com]

You may have seen this project before – it’s been in trials for some months – but a contest to produce music with the tools is coming to its conclusion.

It’s doubly amusing as I expect New Yorkers are largely the ones focused on trying to tune out these very sounds. (Noise complaints are the most common calls to New York’s 311 city help line, by a large margin, and hopefully not just during CDM-sponsored Handmade Music events.)

It suggests some of the creative and practical use of geo-tagged, mobile field recordings. But I’m struck in particular by seeing paths drawn through the city map as a kind of interactive score – see my rant on the topic of notation’s future, or better yet, play with this interface as it makes the point better than I can in words.

Try it out, and let us know what you think. Field recordings and found sound are nothing new, but they still raise the question: can this change how you hear, or how you respond to your environment?

A music score is, in essence, a way of making space into time: traversing notation from left to right and top to bottom, you move through a series of events. So, why not make that spatial map an actual map, as in the familiar, isometric interactive cityscape popularized by Will Wright’s classic game Sim City?

Isle of Tune does just that: lay out trees, houses, and city streets, and you sequence musical patterns as virtual islands. It’s available right now on the Web, powered by Flash – Chrome users can even get a one-click install via the Chrome Web Store. If you prefer to use a phone or tablet, mobile versions are coming, too, beginning with an imminent iPad release, seen in a video below.

Isle of Tune must have hit a nerve in this surreal pairing of imaginary landscapes and simple sequenced songs, because the YouTube nation has responded en masse.

I spoke to developer Jim Hall, who gives CDM the latest update and some background on himself:

A little bit about me: I’ve worked as an animator, flash developer and art director over the last 10 years in London, UK – mainly for digital ad agencies (some previous work here: www.happylander.co.uk). Around about June last year I pretty much quit advertising work (before my soul was lost completely in the desolate mire of micro-sites and adver-games!) and took some time out to make stuff for myself – mainly based around music and playful interaction.

Isle of Tune came from a desire to make a different kind of music sequencer along the lines of http://lab.andre-michelle.com/tonematrix or the Reactable – but with less of an abstract feel and a little more game-like and social. Since it went live in December there has been over 60,000 islands made
with some properly creative tunes in there eg. http://isleoftune.com/?id=63320 or http://isleoftune.com/?id=48359

Over the last few months I’ve been making updates from user requests – mainly to the way you can browse, search and view rated islands, it seems a lot of visitors come by just to check out the islands other people have made!

I’m currently working with a talented chap – Stuart Middleton – a developer since the days of the Spectrum (and now runs a small app dev company at www.abstractalien.com) who is converting the Isle of Tune codefor various mobile platforms and also helping me take it beyond what I could online with the limitations of flash. My far-fetched dream with the app is to be able to fund further development and allow me to make more stuff like this in the future without having to go back to the world of advertising!

For those of you with iPads, Jim says you should be able to look forward to the iOS release some time around mid-May if all goes to plan.

But for anyone, you can use this right now with Flash:
http://isleoftune.com/

And yes, even Requiem for a Dream gets the Island of Tune treatment. Hmmmm… this island seems a bit too sunny and cheery, no? Maybe the title needs a dreary, overcast Coney Island mode.

The beauty of modeling an instrument is that it involves ideas – taking a design from one context and translating it to another. With software, we’re able to put sound-making things everywhere, from obscure game consoles to a tab in your web browser that can distract you with music instead of Facebook updates. In the process of moving those ideas from place to place, we discover things.

Just ask Shannon Smith. He’s been on a great tear emulating favorite synthesizers in free toys for the browser. Through the power of the Internet, the New Zealand-born, California-based developer heard from Japan-based Monotron designer, who shared tips like these:

- filter doesn’t sound nearly as aggressive at maximum peak.
- LFO is slower at minimum (about 15s period) and faster at maximum (>1kHz).
- monotron resets the LFO at the moment the ribbon is touched, so it
works like a simple cycling EG at slow LFO rates.
- monotron has fixed intensity keytrack. cutoff tracks ribbon position
by factor of two. only tracks ribbon not pitch knob.

(We get to enjoy a much cooler industry that keeps friendly, and leaves the competition more often to the engineering departments than to the legal departments.)

And so there’s something wonderful about getting to fiddle with squelchy sounds in the tab of Chrome or Firefox. A few examples:
“Webotron” (Korg Monotron)
“Webotribe” (not-even-out-yet Monotribe)
Yamaha CS01
A 4-op FM synth
A (mini) Minimoog

There are useful tools, too, like a Java patch editor for the microKORG XL. Amazingly, it can actually transmit MIDI to the keyboard:
microKORG XL

Shannon tells us a bit more about the development process…

How they were developed:

All Java (interface and sound). It’s not really possible to use flash to generate sound real-time with low latency. Java also has built-in MIDI support that works in your browser which is pretty handy.

I was curious if things like this would be useful on tablets (particularly if someone got them working with HTML5 in place of Java – it’s a bit sobering that our “futuristic” Web tech represents a step backward in some respects):

I have considered writing apps for tablets and have been meaning to look into it but can never find the time. Also the market seems pretty saturated with much better products than I could produce in my spare time.

Shannon’s background:

I studied Electronic Engineering at a university in New Zealand and now work full time as a developer for a GPS company in California.

The most important lessons learned by doing these:

Hmm, that’s a tough one. I guess an appreciation for just how hard it is to digitally generate good sounds from scratch. I assumed before I started writing synthesizers that doing it digitally would be trivially easy compared to the analog days. In the digital realm you can do things with a few keystrokes that would have taken dozens of components and hours to wire up physically. Unfortunately even though it’s easy to get something working quickly there are some rather nasty artifacts that creep in when you do things digitally that means you have to be very careful anything you do doesn’t generate frequencies outside of the limited range dictated by your sampling rate. Anything you generate that falls outside this range folds back down into the audio spectrum and makes it sound crap.

I’m actually supposed to be writing games in my spare time. I only started writing synthesizers because I thought it would be a way to have decent sounding music in my games and keep the download size very small. I started out trying to do a Nord Lead emulation but utterly failed and realized just how complicated it was to get a good sound. Even though it was a failure it was a lot of fun to try and I continued writing them and lately I’ve been writing many more synths than games, also I tend to finish (mostly) the synths which is something I can’t seem to do with games.

Lots more goodies to explore:
http://www.angryoctopus.co.nz/

Alexander Chen transforms the steady pulse of the (actual) New York City subway system into gentle, generative string plucks in his new interactive piece “Conductor.” The visual effect as well as the musical one is mesmerizing, as the subway is viewed in the abstract, sparse geometries of designed Massimo Vignelli’s 1972 diagram.

New York subway nerds and long-time residents will note that the schedule itself is from 1972, hence the appearance of the K train and the elevated along Third Avenue (the 8), one I imagine we wish we still had.

http://mta.me/

The work is also a glimpse of the Web as a canvas (figurative and literal) for this kind of work – your browser as your very own virtual chamber music setting. And it’s a window into some of the challenges (cough, buggy audio implementations!) to making that happen.

Built in HTML5′s Canvas element with SVG vector data and JavaScript, the application must rely on Flash as a back end for audio delivery, though via a very cool JavaScript tool, SoundManager (which also supports HTML5 audio if its implementation improves). There’s also some use of open source sounds of string plucks, via the freesound project.

Important as the technical details are, though, I find what Alexander says about the inspiration for music made from subways to be the most compelling.

He shares with CDM some insight into the process, technical and artistic.

How did this project come about? What made you decide to translate subway schedules into music?

I’ve been kind of interested in turning everyday things into music. I did a project in 2003 called Sonata for the Unaware, where I used security-cam style footage of commuters and generated music from that.

This project sort of started last September when my friend David Lu (velluminous.org) and I were having a conversation about an idea he
had for an illustrated string instrument, where drawn lines turn into plucked strings. This turned into a project (which is still in progress) called Crayong. So I had written code for that. As a violist, I really wanted to duplicate the feel of grabbing and pulling a string, how there’s more tension near the pinned points.

Once I had that string code, I started brainstorming other things I could do with it. My wife and I started talking about a subway map that you could strum. My friend owns a print of the 1972 Vignelli map, which is really beautiful.

I liked the idea of the trains being the performers. And with all of the realtime location-sensitive information we can get now, I thought about a website that starts off feeling realtime, but then time starts unraveling.

How it was put together — good notes on your site, but want to share any tips that you learned in the process? You had to give up on HTML5 audio, it seems; was that in all browsers or just some of them? With Flash for sound and Canvas for visuals, seems the results are at least largely compatible, yes?

I’m excited about HTML5. The graphics went pretty flawlessly, but unfortunately there definitely were limitations in the audio layering. There’s an in-detail post at my site:

Limitations of layering HTML5 Audio

I ran into problems layering multi-shot triggers of the same sample. It could layer a handful of sounds (seemed to cap off around 8), but would increase load time unnecessarily. This was at least happening in Safari, where I could see the HTTP requests. I tried some workarounds but every approach had its trade-offs.

So all in all, I think Flash still performs better for the audio portion of these types of experiments. But I’m hoping that will change, as it would be nice to not rely on any plugins.

For projects where I am triggering say, 30+ samples, I often compile them into one audio file and manually store the start times of each sample in the code. Seems to load faster overall, because each HTTP request has some overhead. (But I didn’t have to do that here, because I only had 20 notes.)

I also think it’s nice to work with technical limitations. For example, Flash has a limit of how many sounds can be simultaneously layered. Instead of trying massive code fixes, I decided to simply use samples with shorter sustain. That’s why I ended up going with cello pizzicato instead of say, a sustained harp. The samples are from the http://www.freesound.org, recorded by user corsica_s.

Can you tell us a little bit about yourself?

About me – Besides doing interactive work, I’ve released three albums as Boy in Static and one as The Consulate General. I’ve toured on-and-off the past
few years, usually performing on viola and vocals. I’m currently working at Google Creative Lab in New York.

Besides various new art and technology projects I see everyday, my wife and I recently found a DVD of Al Jarnow’s stop animation from the 80′s. Incredible mathematical grid-based animation experiments done by hand, frame by frame.

More on Alexander:
chenalexander.com
presentcompany.tv

Music:
theconsulategeneral.com
boyinstatic.com

His day job is at the Google Creative Lab.

Tim Exile, laptop virtuoso, vocalist, and Reaktor software creator, has apparently taken a liking to the recording features SoundCloud is touting. He’s got a novel idea: you record samples into SoundCloud, he takes your samples and incorporates them into his set. It takes someone like Tim to pull that off; it should be a good set. If you have a day job, this one will be a bit tricky – the interactive online show is at 7pm today, Thursday, GMT (aka CUT) time; that’s evening for all of Europe but 2pm New York and 11am in Los Angeles, etc.

Do let us know how it goes (thanks for the tip, “wantless”!):

I’ll be taking sounds that you record and share with me in realtime using Soundcloud’s new capture & share feature. Just capture your sound, whatever it is, and share it with exile@timexile.com and I’ll weave it into the track live. Watch the preview vid above to get a peak…

http://www.timexile.com/interactive/

I’m curious to hear thoughts about how this recording feature could work. Keep in mind, what SoundCloud is doing is just taking a recording from a browser (in Flash) or mobile app (currently iOS) and uploading the file; it’s not really a cloud-specific recording. That means the idea could be ported to other service, or other clients for use with SoundCloud. Could this be useful for your music? What else would you want to see such features do?

Previously: Social Recording: SoundCloud Adds iOS, Web Record Buttons, More Social Integration