Truly generative musical scores in games have been few and far between, and “music games” has traditionally meant arcade-style rhythm games in which you repeat phrases or whole songs as accurately as possible. Pugs Luv Beats breaks those molds. Part of a vanguard of new gaming creations that generate dynamic music on the fly, it marries grid-based sequencing and resource-gathering gaming, as music making and gameplay blur together. The interactively-produced music could itself become a new way of delivering a musical signature with sound packs.

And beneath it all lurks a free and open source library, libpd – the embeddable version of tried-and-true free graphical music environment Pure Data. (That library is now on GitHub, and vastly updated, by the way, and we’re expecting a book soon from the library’s principle author Peter Brinkmann.)

Oh, yeah, and don’t forget about some seriously addictive gameplay and adorable pugs. I’m suddenly not concerned about the 15 hours Europe-to-North-America travel I’m doing tomorrow.

Here’s what the gameplay looks like, since it’s much easier to see:

Pugs Luv Beats was just approved on the iTunes App Store for iPhone and iPad.

Co-creator Yann Seznec (The Amazing Rolo) is a terrific musician; I just caught up with him in Edinburgh and Berlin and watched him play a homebrewed pig gut instrument with Matthew Herbert for the performance piece “One Pig,” on tour at Berghain. Working with Pd allowed Yann to focus on those musical impulses and not just engineering, and to let him try things he otherwise would never have imagined on a mobile title. So I asked Yann to walk us through how the project was built. He responded with an exhaustively-detailed examination of the evolution of this title, right down to the Pd patches. (Click through for high-res versions.) If your New Year’s Resolution is doing something with patching, you might want to hang onto these answers. Here’s Yann:

The origins of Pugs Luv Beats date back about two years. After making [musical iPhone game] Mujik, Jon (Jonathan Brodsky, aka jonbro) and I were trying to think of other approaches to music mobile app design, and we started thinking more and more about games. Music games, as a whole, are an oddly passive and traditionalist experience – you play along with a premade track, and you are judged on your accuracy and flair (which is strangely reminiscent of music conservatory mindset…). Obviously there are exceptions (RjDj’s Dimensions, Elektroplankton, etc.), but there you go.

Particularly interesting to me was the idea that game mechanics are often very similar to compositional techniques. So for example, when Sonic runs at a normal speed he collects rings at one rate. However when he powers up and goes super fast, he collects rings at a much higher rate. This could be compared to introducing a melody and then speeding it up – and when there are two players, doing this with two melodies. Instant fugue!

We started looking at how we could make a music game where the music and the game elements were fully intertwined and augmented by each other. So Jon prototyped a space shooter drum machine. It was awesome.

To make a (very very very long and boring) story short, our idea and prototype landed us some funding from Channel 4 and Creative Scotland to work on games that focus on musical creativity and composition.

For various reasons, we decided to put aside the space shooter drum machine for a while, and start from scratch. After going through several full prototyping iterations we eventually settled on a core game mechanic that turned out to be in many ways similar to a Tenori-on [Yamaha grid instrument]/Boiingg-style [monome hardware patch] music generation system – in our final prototype, you controlled a series of little dots that moved around the screen, creating loops. This is super fun from a musical perspective because it’s easy and rewarding within a few seconds, and when you have several loops going it can gain some pretty serious rhythmic and melodic depth.

The key from there for us was turning this into a game. We had been using free Internet graphics packs up until then (we hadn’t hired our artist Sean yet) which featured a ladybug, so we had been referring to the main characters as ‘bugs’. During some discussion one of us accidentally said ‘pugs’, and the game idea was born. We constructed a story about pugs and their love for beets (like the vegetables) which create beats (ha!), and how their love turned into greed and got out of control, destroying their world. The game, therefore, is about helping the pugs rebuild their lost civilization by guiding them to create beats. You grow your galaxy by collecting beats, which you do most efficiently when you dress your pugs up in costumes. What’s not to like?

To get to the part that I imagine CDM readers are most interested in, the app development was done by Jon using openFrameworks, [lightweight language] Lua, our own game engine called Blud, and the audio is all done in Pure Data using libpd (through ofxPd). In hindsight we started using libpd really late in the game, just at the very end of the prototyping stage, which was rather silly. Our adoption of libpd basically made our dev cycle about a million times more efficient. My background is as a musician and sound designer, and I have very little coding knowledge. I do, however, have lots of knowledge of Max/MSP, so picking up Pure Data was pretty easy. This allowed Jon to completely pass off all the audio processing (not to mention aesthetic sound design choices) to me, saving him loads of time, giving me direct control over the sound, and letting me test and prototype different approaches to audio within an environment that I knew would be recreated in the game. Also, as Jon mentioned to me recently, by using PD we are able to take advantage of 20 years of audio DSP research and development. Pretty amazing.

How it all works:

The entire audio engine is contained within this patch. Pardon the messiness.

The simplest part of the patch is the “sounds” section, which is used to playback simple sound effects, for the most part linked with interface actions in the game. I did this by creating a very simple patch which plays a sound when it receives a bang. Which sound it plays is dictated by the argument (in this case, the sound of discovering a new capsule). The process for adding a new sound, then, is as simple as adding the sound file to the /assets/sounds/ folder, and making a new instance of “sounds.pd” and naming it the same as the new sound. Jon, in the project code, created a list called “sounds” which is sent into Pure Data. When that list contains “capsule”, a bang is sent into that subpatch, and the sound is played.

A more complex version of what could be done with this type of data is seen in the voice of Mr Puggles, who helps you learn how to play the game. Mr Puggles pops on and off the screen to guide you through the first few worlds, and when he does he send Pure Data a “puggleShow” and “puggleHide” signal. I wanted to give Puggles a funny synthesizer voice that was different every time – dead simple in PD. To do that, I take the puggleShow bang and use it to trigger five more bangs, spaced out over a second. Each of these bangs triggers a random number which is translated into a MIDI note. This note controls the pitch of two oscillators (a sine and a sawtooth), one of which is slightly modified to make them slightly different pitches. These are played through a short volume envelope and a filter which is also controlled by a random number generator. Result? Hilarious beeping boopy Mr Puggles voice, all coming from one bang.

Every time a player buys or selects a planet, a short list is sent to Pure Data comprised of the planet BPM and a random number seed. The BPM is used to calculate delay times and such, and the random number seed is used to create a sort of musical identity for the planet. This is done by choosing a “beat library” and a musical mode.

The mode is created by building a lookup table that chooses the notes from a chromatic scale that would be used in a particular mode. For example, a major scale (ionian mode) uses notes 1, 3, 5, 6, 8, 10, and 12. Each melodic sound library I used is comprised of a full chromatic octave, and the notes that are played on any given planet are controlled by this table. This ensures not only that all of the different sound libraries being played on a planet will be in the same key, but also that a planet will have a strong melodic identity.

The sound libraries in the game are all controlled by the pugs on the planets. As they run around, each time they land they will trigger a sound. The type of sound is dependent on what terrain they are on – thus, if they run through the snow they play a toy piano, if they run through lava a distorted guitar, etc. There are two states of playing the sound, one if the player deliberately tells the pug to go to that tile, and the second if the pug is traveling over that tile to get somewhere else. It’s super easy to do that kind of thing in Pd; just set up two different ‘play sound’ envelopes, maybe a little extra delay or reverb, and you’re done!

The final piece of the puzzle for making the pugs running around into music is to make each tile be a different note. The terrain of each planet is created by making a sort of height map, where different heights correspond with different terrain types (grass, water, snow, etc). This also means that each tile has a unique number between 0 and 1. When the player buys or selects a planet, a giant random number table is generated in Pure Data which creates a number between 1 and 13 for each possible value between 0 and 1. That value is what is used to pick the note of the mode. This somewhat convoluted approach again lets us make sure that each planet will have a unique, but fully reproducible, musical character.

The actual playing of the sounds is probably the messiest part of the patch structure. Purists look away now.

I wanted to make sure this part of the patch was as flexible as possible, so I ended up using the soundfiler and tabread~ objects, rather than tabplay~, which is great in practice though does look rather uncouth. Additionally, I had some limitations imposed upon the structure of the patch – namely, I had to keep the number of tables down as much as possible, to save on memory. So each sound bank has two voice polyphony – there are many sound banks, and the beats and sound effects aren’t counted in this, so that limitation is not really heard in the final product at all. It did mean I had to work out a decent voice allocation system though!

I think my memory issues were probably my only problem with using PD in this project – though only indirectly. As I mentioned, they were hardly a problem artistically, however it took me a while to get used to the idea that not everything I patched on a computer would work on an iPhone. Similarly, I had to be very careful about things like relative volumes. In a generative music game like Pugs Luv Beats, the player could quite easily send 15 pugs running around making sound, which mounts up pretty quickly. It means that all of the patches and sound need to be designed to withstand lots of triggering without distorting. None of these things are problems, really, all they require is regular testing on devices and simulators – something that every mobile developer is already used to.

That’s the Pure Data audio engine in a nutshell. The end result is a flexible and powerful audio engine that sounds really great and is fully integrated into Pugs Luv Beats. The game is a great combination of music, silliness, and strategy – there’s a bit of something in there for everyone. You can definitely just play with the game to make beats, or you can try and collect all of the costumes, or you can try and make the most efficient planet ever. You can also explore the galaxies being made by your Game Center friends, to hear what they’re up to.

The background story:

And, just for fun, a silly promo featuring real pugs. Anyone traumatized by the sight of Pd patches, these should relax you.

More information at the developer site:
http://luckyframe.co.uk/pugsluvbeats/game.html

You know you’re in for something different with an article that contains this line: “as 256 bytes is becoming the new 4K, there has been ever more need to play decent music in the 256-byte size class. ”

In just a single line of code, Finnish artist and coder countercomplex, working with other contributors, is creating “bitwise creations in a pre-apocalyptic world.” What’s stunning is to listen to the results, even if you have trouble following the code – the results are complex and organic, glitchy but with compositional direction, as though the machine itself had learned to compose in its own, strange language.

This is, naturally, the opposite of the musical coding in the previous post: in place of human-readable languages representing abstractions atop other abstractions, this is pure algorithm transformed into music. Geeky, yes, but it also says something about musical composition and thought independent of the computer. It is as compact an expression of a human musical idea as one could imagine.

I recommend reading the whole blog post (and following the blog for new developments). Embedded in this whole exercise are thoughts about musical algorithms, the history of chip and 8-bit music and the demoscene, and, most interestingly, the question of whether digital music might yet yield “new” (or at least largely unknown) discoveries:

Hasn’t this been done before?

We’ve had the technology for all this for decades. People have been building musical circuits that operate on digital logic, creating short pieces of software that output music, experimenting with chaotic audiovisual programs and trying out various algorithms for musical composition. Mathematical theory of music has a history of over two millennia. Based on this, I find it quite mind-boggling that I have never before encountered anything similar to our discoveries despite my very long interest in computing and algorithmic sound synthesis. I’ve made some Google Scholar searches for related papers but haven’t find anything. Still, I’m quite sure that at many individuals have come up with these formulas before, but, for some reason, their discoveries remained in obscurity.

Algorithmic symphonies from one line of code — how and why? [countercomplex]

But can you dance to it?

Matt Ganucheau contributed to this story from San Francisco.

“You had to be there.” Live performance has always been dictated by being present in a particular place, at a particular time. Now, the same is true of an interactive album produced by brothers Hays and Ryan Holladay, aka Bluebrain.

Both a two-man band and a two-man development team, there’s no clear dividing line between “coder” and “musician” for the artists on this project. But the only way to hear the work is to physically go to Washington, D.C.’s National Mall, and begin walking around. The satellites that populate the GPS received in your smartphone, currently on iOS but with an Android release planned, realize the work. You, and your device, then, participate in a kind of performance. The album is the first of a series; New York’s Flushing Meadows, site of a World’s Fair and a failed Olympics bid, is next.

The Washington Post‘s Chris Richards talk with the two artists; I’m quoted as the story pans back to look at music technology in general:
Bluebrain make magic with the world’s first location aware album [Washington Post]

It’s well worth a full read, as the artists describe some of their intentions, and claim they’re uninterested in this as technological gimmick. Richards also explains the experience of hearing the work, since not all of us can go to DC:

Approach that crazy-looking thing while listening to “The National Mall,” and you’ll hear a keyboard weep. Get closer and digital cellos begin to trace a regal melody. Closer. There’s percussion. Keep going. The volume creeps up. The drums push toward anarchy. Walk right up to the monument, press your hand against the cool, smooth stone and listen, as if the obelisk were a giant radio needle receiving some riotous transmission from deep space.

At one point when Richards interviewed me for the story, he asked me point blank whether technology’s greater impact has been on distribution or production. Caught off guard – it’s a question so fundamental I hadn’t really thought to choose – I found myself choosing production. After all, while distribution has been profound, the advent of recording, not the advent of the computer, is the fundamental breakthrough. But with computer music software, the ability to re-imagine what music actually is has taken the grandest leap since the gramophone.

Ironically, though, Bluebrain are taking the same approach to conventional recording technology as they are the new smartphone – they’re intervening to ensure music is limited and local. A “surprise” record release earlier this year not only went straight-to-vinyl (see previous editorial here), but required that you go to an actual store in the DC area.

In vinyl, the approach is an intentional throwback. In digital, it suggests a new way of making music for a space with a device as the medium rather than live performance.

There have certainly been locative digital works before this one, but I couldn’t think of one that was introduced as an album in this way. Then again, if the idea is worthwhile, it may prove worth repeating.

Follow Bluebrain’s work via their blog and site (and you may have to literally follow it, geographically):
http://bluebrainmusic.blogspot.com/
http://bluebra.in/

And do point us to other examples of locative work – including anything that might challenge their claim of being first, at least for our historical benefit.

Swarm Music Album Black Allegheny from Evan Merz on Vimeo.

We’ve heard albums made by singular compositional minds and by bands. What would an album sound like if composed by swarm intelligence, by computer evolutionary models of individual agents or bots? That’s the question asked by composer Evan Merz in his new, full-length album “Black Allegheny.” (At top: the composer explains in a video.)

Western musical and creative tradition is steeped in linearity, from the forward motion of the music staff to the mythos of Aristotle’s Poetics.

So, maybe it’s little wonder that generative music – music that may not have linearity, or a beginning, middle, and end – hasn’t exactly been a big hit with the kids. Pioneers like Brian Eno have helped spread the gospel of generative music, but apart from lots of interesting experiments, there hasn’t been a lot of actual musical content. If you were to make a stack of generative music albums, your listening list would be fairly short.

All of that could be about to change. Programming code, the essential medium in which such models can be developed, is more accessible than ever. It’s also more visual, thanks to the popularization of tools like Processing, which can help make the abstract rules of generative music easier to grok. Merz, for his part, has taken on the challenge with his own Java-based software.

Saying the bots “compose” the music may be a little misleading. Generative music needs rules to operate. Before Eno, there was John Cage, whose “chance” compositions were as much defined by choices of materials as by ranges of indeterminacy. Merz makes a nod to Cage’s notion of a “gamut,” a collection of raw musical elements used as the input in the chance system. Here, though, Merz is aided by something Cage didn’t have: a swarm of intelligent “agents” can navigate those materials via simple rules, giving the music form and substance. Because they aren’t aware of the big picture, the music evolves more naturally, rather than being subjected to an over-arching narrative.

Or, as Merz puts it, “the tiny ant on the ground knows only what it sees around it.”

So, that’s the theory — what does the music sound like? Far from “ennui,” as Merz puts it, to me the results are organic. The structure is emergent from its materials, sounding almost like a natural physical process, like watching ice melt. The content ranges based on the gamut; like a lot of generative music, some sounds a whole lot like Brian Eno’s work. Others borrow from minimalist composers (Reich’s music itself might be seen as partially generative), and others take on an edgy urgency. The models that determine the bots are based on a popular, simple mathematical predator/food model, one often used in these works. Sometimes, you might imagine that evolutionary struggle playing out in the music.

You can read more about the process of developing this tool and the compositional ideas behind it at Evan’s blog:
Black Allegheny, Swarm Generated Music [Computer Music Blog]

For more explorations of sound and composition, check out Noise for Airports, which recently featured the work:
http://noiseforairports.com/

And you can stream the album or buy it for yourself for the light price of US$5 — though I’d like to see a software release, since that would mean each playback could be different. (Eno released an album in software form in the 90s, though tracking down the software now is evidently impossible – anyone with tips?)
Black Allegheny @ Bandcamp [Stream / download purchase]

Swarm Controlled Sampler – Becoming Live from Evan Merz on Vimeo.

For many musical artists, the frontier of reactive, interactive music has been a long time coming. RjDj, an app which we first saw as a series of interactive musical scenes on the iPhone, is now being expanded by its developers into a mini-ecosystem of interactive music tools for creation and distribution. I don’t think it’s likely to work for everyone – some artists may have their own ideas about how to distribute such work, or may take this concept in different directions for performance. But it’s nothing if not stimulating to watch.

Here’s the basic formula:

1. Authoring: The RJC1000 looks like an MPC-style drum pad, but it’s actually a tool for assembling scenes. (Currently Mac-only, but I believe built in Python so it could show up on other platforms.) In “expert mode,” you can write your own modules in the free patching environment Pd (Pure Data).

2. Playback: The RjDj on the iPhone and iPod touch, and now the Voyager app on iPad (top) provide “player” mechanisms – whether for your own performance, or as a way to distribute your work as “interactive albums” to listeners/users. Check out the RjDj apps for more. (Little Boots and AIR each did their own, exclusive artist app based on the same tech.) Lest you think this is all about Apple platforms, there’s also an “RjDjroid” Android app.

3. Network of music: The RjDj network is a means by which artists, for free, can get their work in the hands of users.

4. Open-source tools and patches you can steal use: Not everything the RjDj crew have done has been open sourced, which I have seen generate some disagreement. But there is some very nice stuff in the developer sandbox, a public API, and best of all, a brilliant Composers’ Pack chock full of Pd goodness. In fact, it’s probably the most useful set of Pd patches I’ve ever seen, a whole mess of useful macros for building usable instruments.

Check out the Voyager app, in particular. I love that it breaks out of the traditional interface paradigms — even those RjDj themselves are exploring with the MPC-style authoring tool. Voyager reimagines music listening not in lists of tracks or grids of beats, but in the liquid, alien landscapes of your dreams.

RjDj isn’t enough for you? With the open source tooling behind RjDj, there’s the possibility for an “ecosystem” beyond just the RjDj universe. (Pardon the use of that ecosystem word again. Let’s translate to “other good stuff could be happening,” or “general hoopla is involved,” or “see also: awesomeness.”) It means if you like the idea but not the implementation, you can try your own ideas. And it means, thanks to Pd’s ability to run just about anywhere (thanks to support for ARM architectures and Linux and not just the narrow world of x86 on Mac and Windows), the future isn’t dependent on one company’s vision. It can depend on yours.

I do think RjDj and the Pd development team that worked with them deserve some credit here, though. For the first time, we’ve seen an interactive “label” that’s devoted to making music dynamic and changing for the listener. If they’ve got it right, that means there’s far more to come.

And seriously. Go “steal” those patches. That’s the whole idea.

Here’s a look at the authoring app, in video demo form, running on the Mac:

Michael Breidenbrücker of RjDj has more to share with CDM. He writes us:

Scenes produced with the RJC1000 can currently be distributed into two different apps that have different interfaces and use cases. This is a strategy that we will increasingly apply. I think with the RJC1000 we have a very powerful authoring tool for reactive music. Music which is produced with the RJC1000 can be listened to or consumed in different ways on different RjDj apps. For example we implemented a very simple paging interface in our iPhone app because we think that is a good interface for the device. On the iPad though we did implement a drag and drop and twist and push interface for scene playback. The important point for the producer is that he only produces once and cans distribute his creation into several apps. The next app we are working on is a music game…

With the RJC1000 we are releasing a free authoring tool which is the tool to get your music into the RjDj network http://more.rjdj.me/make-music/ . We will continue development on new apps even on different platforms and the RJC1000 will increasingly be our main tool for that.

The RJC1000 runs on Pd (like everything we do which means it is a very powerful tool. You know we have started off with Pd as our main authoring tool but soon discovered that it is way too abstract for many musicians and their approach to music. I think with the RJC1000 we have found an elegant way to get musicians and producers on board and at the same time keep Pd very close.

Got questions? Made anything cool with those Pd patches and macros? Let us know.

Dreaming of a future in which music, instead of just being rendered audio files, arrives in fully generative, interactive form? Albums might “listen” to the world around you, and listeners could record their own alternate versions of music and share with others.

RjDj, the generative mobile music platform for Apple devices, realizes that future right now, instead of at some nebulous time in the future. In addition to the iPhone, you can make use of a second-generation iPod to use it. (You’ll need a headset with a mic; I have one by Griffin I’m testing.) And the RjDj folks have a whole bevy of significant updates to share:

• Free downloads (limited time): All three RjDj releases are available now for free. That includes the RjDj app itself (from which you can now grab and share releases), as well as RjDj Album (with a selection of generative/interactive/reactive releases) and the new RjDj shake.
• Download “scenes”: From the beginning, we knew that RjDj was imagined as a platform for other people to release interactive music. Now you can download scenes for free or fee. (Paid scenes currently redirect to the browser, but with iPhone SDK 3.0, you’ll be able to buy right from the app.)
• Share recordings: Because RjDj-generated music is controlled by the user and often records from the environment, the music may sound different each time. You can now share recordings with others from the device and the new social site.
• RjDj.me community: The RjDj folks have built a little community where you can share your favorite scenes and upload recordings, and keep track of scenes coming out from other artists.

By the way, with all of these releases, I know there’s some confusion. RjDj is the main app — the platform from which you’ll be able to grab scenes in the future. RjDj Album is a collection of “player”-style RjDj scenes — ones we have seen released previously. RjDj Shake is a newer, accelerometer-powered set of scenes. It comes with the amusing admonition that you should “PLEASE TAKE CARE, DON’T HURT ANYONE AND DON’T SMASH YOUR DEVICE.” If you missed Shake before, it now also has the recording sharing features. But the main RjDj app is the big release going forward.

We’re also awaiting news on more “sprints,” community-driven development efforts for making new scenes. And if you’re a fan of this sort of thing, RjDj isn’t the only game in town. RjDj itself is powered on Pure Data, the open source patching cousin of Max/MSP. Pd is making its way to other mobile devices; I even have it working on the BUG Labs gadget. At the same time, I’m curious to see if the RjDj gang can succeed in building a platform for lots of people doing this sort of work.

Regardless of how you look at it, more mobile generative / responsive music is most definitely in your future. Stay tuned.

Elsewhere:
Free trip into the rainbow vein: reality-enhancing iPhone app RjDj free with social update [Boing Boing Offworld]

RjDj.me community site
RjDj 0.7 out now [RjDj News]

RjDj [iTunes]
RjDj Album [iTunes]
RjDj Shake [iTunes]

Be sure to see our previous interview with the creators:
Exclusive RjDj Interview: Interactive Music Listening, Everywhere You Go

Also, expect more iPod/iPhone news and hands-on’s soon — I’m way behind, but let’s assume that means the best stuff will rise to the top.

As an addendum to the last story, Ivica Ico Bukvic sends along an example of the [myu] Max/MSP + Unity game engine combination in action. Here’s the surprise: Unity isn’t generating visuals. Instead, Unity simulates ripples created by movement in the space, and builds physical models that are sonified and spatialized by Max/MSP.

Speaking of work involving art museums and the combination of Max and Unity, VJ Anomolee notes in comments his own work with the pairing. Lightbent Synth is an in-progress piece with alternative controllers and sensors that produces sound with a novel visual representation (sound’s very quiet in this preview — more hopefully once it progresses):

Lightbent Synth from VJ Anomolee on Vimeo.

Ivica explains the top work:

This past fall [myu] had seen its first real-world implementation in an exhibit that was a part of the grand opening of the Taubman Museum of Art in Roanoke, VA (http://www.taubmanmuseum.org/). The exhibit utilized [myu] as part of an interactive aural installation titled "elemental." An online tech
demo video of the installation, including written synopsis is available also via Youtube at http://www.youtube.com/watch?v=PA-9BOgc1gk. Below is a brief synopsis of the installation:

"elemental" interactive communal soundscape premiered in November 2008 as part of the Revo:oveR collection commissioned for the grand opening of the Taubman Museum of Art in Roanoke, VA. The Youtube video focuses primarily on the technical aspects of the installation. Using Max/MSP/Jitter, a homebrew IR webcam with fish eye lens and a LED-based IR spotlights, entire 24×36-foot exhibit space is converted into an aural sandbox giving visitors an opportunity to generate and shape the
ensuing soundscape. Positional data of up to 20 visitors is forwarded to Unity3d using [myu] Max-Unity interoperability toolkit developed at DISIS (http://disis.music.vt.edu). Unity is used for physical simulation of ensuing ripples and the resulting data is sent back to Max for spatialization across a 12-channel (4×3) ceiling-mounted speaker array. Driven by communal interaction, virtual ripples refract from each other spawning an algorithmically generated aural fireworks. The exhibit ran non-stop for approximately 5 months until March 2009.

Bonus video below: an early prototype that did include visuals. After days of looking at emulated knobs and faders, it certainly does speak to some of the possibilities for musical interface and expression.

Sequencers by definition traditionally lock musical patterns into repetitive, unchanging blocks of time. But a new generation of generative sequencers can instead form organic patterns that change and transform.

Nodal is a totally free-as-in-beer (closed-source) sequencer for composing music. (A license is needed for commercial use.) As the name implies, it uses a matrix of nodes to represent musical structure. The best way to understand what that means exactly is to check out the examples and give the app a shot, but is good fun – and capable of creating some lovely, unusual musical textures.

The good news now is that if you’re on Windows XP/Vista, you’re no longer left out of the fun: the app now runs Universal on Mac and on Windows, as well.

Aside from Windows support, also new in version 1.1:

• New, more polished UI
• Keyboard shortcuts
• Internal MIDI synth support on Windows

It does sound as though Nodal may not remain free-as-in-beer, but with some significant updates coming later this year will move into the cheap-as-in-beer territory. Stay tuned.

Composer and co-developer Peter Mcilwain sends along the video here with a live improvisation made in the software. It’s a bit Minimalist-influenced, but shows how you can use Nodal to drive some musical inspiration. Peter also explains just what Nodal means musically to him and the small but growing collection of users taking advantage of Nodal’s paradigm:

Interest in Nodal probably centres around the fact that the software enables sophisticated, or “deep”, generative approaches within an intuitive graphical user interface that is simple and easy to use. Many users say that the program can be learnt within a short space of time and that is fun, inspiring and is fascinating to use. Once a little experience is gained people come to recognize the rich possibilities that the network approach gives them. Nodal offers a wealth of compositional possibilities that enable users to explore transformations of musical ideas quickly and easily.

Much music has been made using processes such as looping. Nodal does this too, but with a number significant additions. For example, it is possible to have loops within loops. The musical diversity that is possible takes Nodal beyond from the concept of a loop into a territory that is more like creating maps of musical pathways with which musical possibilities can be navigated. Musical materials can be played forwards and backwards, recombined or played with different rhythms. All of these transformations can happen in real-time making it a rich tool for computer assisted improvisation.
In fact working with Nodal can be very similar to more traditional composition processes. Here a small musical cell might be created which is then developed, elaborated or transformed into new material. Seen in this way, composing does not necessarily involve making a string of new ideas but instead it is the exploration of different aspects of a single idea. By limiting a composition to a small number of ideas the music maintains coherence and a sense of unity. While composers have done this manually, and in some cases masterfully, Nodal enables the transformation of idea to be automated and extended to transformational processes that would be very difficult to achieve with pen and paper.

Nodal: Generative Music Software

Previously:

Nodal: Generative Music Software for Mac (Free for Non-Commercial Use)

Tiction: Animated, Nodal Generative Music App in Progress, in Processing

Alternative Sequencers: Elysium Generative Mac App and the Joy of Hex

A Mutating Drum Step Sequencer, New MIDI Library for Processing

Fractals, those wacky self-similar, rough geometries that resemble so many patterns in nature, were once all the rage. Ravers and digital artists embraced them, only to get bored with them, apparently. To billions of years of evolution and natural phenomena, they’re still cool. And to me, there’s still plenty to talk about when it comes to thinking how fractals might be all the rage.

Composer Terran Olson, a musician with a long resume that includes work with the Ives Quartet and Quartet San Francisco, takes on the idea of fractals in a new article. Writing for our friends at Rain Pro – makers of music and visual pro PC laptops – Terran explores how fractal patterns could be applied to sound.

Exploring Audio Fractals

The results are fascinating: they’re a kind of fractal synthesis. Of course, that gets at the heart of the question: just how do you map a visual pattern like a fractal – or anything else visual – to music? The answers aren’t always intuitive. The biggest question is whether to work at the scale of sound (Terran focuses on individual samples and impulses), or to deal with musical patterns. I knew I had read a fractal article in Electronic Musician; sure enough, in 1999 EM did a story on fractals that focused instead on pitch mappings. (Bonus: Bach even comes up.)

Fractals and Music

Composer Gustavo Diaz-Jerez penned that story, and the results tend toward algorithmic music. Many of the tools are now gone, though some survive (Csound) and other tools (Max/MSP, Pd, SuperCollider, Reaktor, ChucK) could certainly fill in.

And, of course, for a truly high-level musical approach to fractals, skip the individual sounds or individual notes and write a whole song, like Jonathan Coulton’s brilliant fractal ode, “Mandelbrot Set.” (It should also help anyone needing to, erm, brush up on their fractal theory.)

Sadly, neither of these articles is especially useful as how-to – great on theory, but not so practical if you haven’t tried these things before. That begs for a new tutorial. Are you working with fractals these days? I’d love to hear what you’re doing.

I hesitate to share this, because a) YouTube numbers suggest you may have seen it already and b) it’s pretty depressing. On the other hand, it’s not like the fact the economy is depressing is news, exactly, so I suggest we employ the time-tested coping method that is laughter. Thanks (?) to Paul Norheim for this.

It also suggests a pleasing solution: the world economy just has the pitch control set wrong! Just start that turntable up again.

Or, more disturbingly, the fall of the economy is all part of some deep Schenkerian urlinie, a global capitalistic descent to the tonic. (What? No one up for some Friday afternoon theory humor?)

And yes, with apologies to the very-talented Microsoft Songsmith team, your product is becoming the new Hitler meme.

That’s it. We’re out for the weekend. I got nothin’.