Technology may be about the next Big New Thing, but as with music making in general, making music with tech is for many of us a lifetime vocation. So, it’s welcome news to find that time-tested tools, maturing over decades rather than months, are enjoying greater use than ever before. We saw Pure Data (Pd) attracting new interest as the embeddable libpd version allows use in a range of development environments and mobile platforms. Now, it’s about to be Csound’s turn.

Of course, before we get to that, if you’ve got an iPad 2 or “3″ (aka “the new iPad”), you can more or less skip this entire article and start making wild new granular sounds on your tablet. (Sadly, the original iPad is excluded here because it’s a resource-intensive application, though owners of that tablet – and other mobile devices – have plenty more to anticipate in Csound world.)

csGrain is a multi-effects processor that works its sonic-mangling magic live on sound, making use of something called “SyncGrain,” a real-time granular synthesizer. You can record from a mic or import tracks from the iTunes library (including, of course, your own music), or even use an included sample loop. csGrain then processes those sounds via a rich set of sonic tools, either live or to a recording, with sharing via AudioCopy, AudioPaste, email, and Dropbox. You also get setting randomization and a range of live effects, too. If you’re unsatisfied by the “finger against bathroom mirror glass” feeling of the tablet, you can connect an external MIDI input.

And, of course, it sounds amazing:

All of that is nice enough, but the bigger news is how this is all possible – and what is yet in store. Think Csound running everywhere, including learning about the tool and coding with it directly on an iPad.

csGrain uses Csound, the composition and sound design language that traces its roots back to the first-ever digital synthesis languages developed by pioneer Max Mathews. (It’s worth noting that Max’s ideas inspired the work of Miller Puckette on Pd and Max/MSP, too, meaning these are “all in the family,” as it were. Some even argue the model had an indirect influence on modular synths.)

csGrain is the first of a series of apps using Csound, including a massive, promising, everything-you’d-ever-want-with-Csound-on-an-Ipad app, covering documentation and code. This isn’t just an attempt to “cash in” on a geeky sound tool in the midst of the App Gold Rush — far from it. The application is as much a teaching opportunity as product. You’ll be able to use the application and its documentation to learn more about the sound processing technique, and discover the Csound code that makes the app tick. For some, it could be a first introduction to Csound, without having to be enrolled in an academic class. And for developers and sound artists who do want to make their own Csound creations, an upcoming SDK will unlock the power of Csound on other platforms (iOS being just one). That brings the power of “run anywhere” portability to text-based language Csound much as libpd has done for the graphical-patching tool Pd.

This image of a developer build of Csound Touch should be enough to set Csound fans’ hearts racing. (Okay, not a huge segment of the population at large, but I’m fairly certain most of them read this site.)

Developer Dr. Richard Boulanger, who has been a driving force behind almost every element of Csound’s recent development from the stuff under the hood to the documentation and the community, is now taking that sonic energy and applying it here. (And I do mean energy: sonic whiz “Dr. B,” as he’s affectionately called by his students, practically bubbles with enthusiasm and ideas. I’ll have what he’s having.)

He tells us that even in its first day, csGrain has made a big impact – no small task for an App Store inundated with volume and an application most would consider to be pretty niche in appeal.

The launch of csGrain has been pretty exciting. At the App Store, on day one, in the Paid Music Apps Catagory, we reached the rank of #8 (out of 4000+ paid music apps). We had over 957 people view the csGrain video at the Boulanger Labs site, and we were contacted by Richard Devine and Jordan Rudess with praise, congratulations and advice. We got some pretty great reviews at the App Store such as this one…. (I have no idea who this is by the way… which makes it even cooler….

“csGrain is a must-have effects powerhouse for the iPad. The sounds, usability, and musicality of the instrument are at least on par with the Moog apps, but the the potential for extension and customization far surpasses anything else. If you want to blow your mind in two seconds flat with this app, just press and hold any of the parameters (esp the sync grain ones) and a randomization window pops up, change the parameters and get instantly out of this world sounds. I really like the integration with Dropbox and AudioPaste functionality. And while you don’t need it at first, the manual is very well written for when you want to dig deeper. My only complaint is that the app is not yet in Retina-display, but I am sure that will be coming soon. Another nice feature improvement would be to augment the midi capability, which is already awesome, to allow for automatic learning of cc messages based on input like the way Ableton Live works. All in all, this is most powerful effects application on the iPad. Good job!”

I should also direct owners of the first-generation iPad to Richard’s explanation of why you can’t have the app:

It really doesn’t work on iPad1. It’s optimized for iPad2 and the new iPad. In particular, the stereo granular processing is both efficient and amazing, but… it’s also pretty heavy for the iPad1 and we would get some
breakUps in the audio on that platform – so we just made if for the 2 and the new.

But let’s get to what’s coming next. Dr. Boulanger gives us the full scoop. I imagine him sounding like Vince, the Slap Chop guy (and with good reason):

[Last week] was the release of csGrain (one of Boulanger Labs’ focused/targeted “spin-off” apps) and there are others coming over the next few months. But Csound Touch – which is coming in about 1 month – is ALL of Csound on the iPad…

The Csound for iOS API and SDK will be offered in the next day or two with all sorts of working models…
It will blow you away… how “easy” it is to develop audio apps with Csound as the DSP engine.

our .csd files are all offered with the apps.

One will be able to incorporate Csound into their own apps, games, whatever.

csGrain is just ONE huge .csd file – running under the hood… and there is a button there to see the code and it’s in the manual that is included too.

- we are sharing many tricks right there. But there are also tons of tricks shown in all the models that come with the SDK

Csound Touch IS Csound – all of Csound – for the iPad.

It is built upon and synchronized with the latest version of Csound5

It supports the realtime “rendering” of any Csound “.csd” file.

It can render .csd files from within the Csound Touch App or from the Internet.

It includes realTime “Console Output” (for diagnostics and progress monitoring) and supports “OFFline Rendering” for the realization of the most complex and demanding of “orchestras and compositions.” (For instance, if you wanted to create a sound with ten thousand oscillators and five hundred reverbs and two thousands filters it’s not a problem. This is Csound… all of Csound… and with Csound the only limitation is your imagination!)

Csound Touch supports Realtime MIDI control of any Csound-based MIDI instrument.

Csound Touch supports Realtime iPad/GUI Control of Csound Instruments via custom OnScreen Sliders, Knobs, XY controls and a Piano Keyboard.

One can Save to Disk or Render to the speaker or any pro audio interface in RealTime or once can do both Simultaneously! Jam and Capture! Remix and Record.

Csound Touch supports Interapplication File Transfer on the iPad Import/Export via DropBox, Email and AudioCopy.

To get you started with Csound; to inspire your creative spirit; and to support your study and exploration of Computer Music Composition, Software Synthesis, Signal Processing, Algorithmic Composition, Physical Modeling, and so much more…
the Csound Touch App includes:

Chapter 1 of Boulanger’s “foundational text” published by MIT Press – The Csound Book

The “classic” Boulanger Csound “Toots” from the Csound Manual

Boulanger’s “Mastering Csound” Tutorials

and there’s more!

We include the latest Csound FLOSS Manual (and all the Floss Instruments)
We include the Canonical Csound Reference Manual (and all the Manual Instruments)

and even more….

Selections from Boulanger’s Csound Instrument Catalog (30 years of Csound Instruments)
Selected Csound Compositions from the Boulanger Collection and The Csound Mailing List

Selected Algorithmic/Generative Compositions

A diverse and useful assortment of Dr.B’s favorite DSP Instruments
A varied collection of Dr.B’s favorite MIDI Instruments

A collection of OpenSource Audio Samples from the OLPC Sound Sample Archive.

Of course, this isn’t just about iOS: Csound is now in one form another either available or coming soon to Android, Ableton Live (via Max for Live), Max/MSP, standalone desktop applications, and the Mac AudioUnit plug-in format. I agree when Richard calls it “The Csound Renaissance of 2012.”

By the way, I think Richard has given those of us working on Pd, too, a real sense of what we could do with that tool (as well as an excuse to play with Csound anew). He tells us:

PS…. The Pd Rennaissance is also very very wonderful – the new book, the new code, the new possibilities…. all extremely exciting. After reading your blog on bit ago, I ordered the book and am very inspired by this initiative as well. So…. all cool and extremely important.

I couldn’t agree more.

So, once again, the timeline for the Revolution:

Coming soon (in a month)

Csound Touch – all of Csound on the iPad! Run any opcode, run any orchestra, run any composition. Run the entire Csound Book, Csound Catalog, Csound Manual. It all works and it’s all there!

and the a few weeks after that….

More Csound Apps such as:

csSpectral – Realtime vocoding, convolution, and spectral processing.

csFuzz – a rack of guitar effects.

csVoice – a vocal synthesizer, harmonizer, processor.

csGen – algorithmic, probabilistic, and generative composition systems.

csModel – a collection of Physical and Physically Inspired Models.

csClassics – a collection of synths based on the classic techniques – FM/AM/RM/WaveShaping/Granular/Additive/Etc.

The Revolution will not be televised, but it will be at:
http://boulangerlabs.com

You can find csGrain on our exclusive, multi-platform Apps section:
csGrain @ apps.createdigitalmusic.com

An, as always, don’t miss the central repository for all things Csound:
http://www.csounds.com/

We’ll have an interview with Dr. Boulanger later this week, so if you’ve got questions for him, ask away!

Digital: disposable, identical, infinitely reproducible. Recordings: static, unchanging.

Or … are they?

Icarus’ Fake Fish Distribution (FFD), a self-described “album in 1000 variations,” generates a one-of-a-kind download for each purchaser. Generative, parametric software takes the composition, by London-based musicians-slash-software engineers Ollie Bown and Sam Britton, and tailors the output so that each file is distinct.

If you’re the 437th purchaser of the limited-run of 1000, in other words, you get a composition that is different from 436 before you and 438 after you. The process breaks two commonly-understood notions about recordings: one, that digital files can’t be released as a “limited edition” in the way a tangible object can, and two, that recordings are identical copies of a fixed, pre-composed structure.

Happily, the music is evocative and adventurous, a meandering path through a soundworld of warm hums and clockwork-like buzzes and rattles, insistent rhythms and jazz-like flourishes of timbre and melody. It’s in turns moody and whimsical. The structure trickles over the surface like water, perfectly suited to the generative outline. At moments – particularly with the echoes of spoken word drifting through cracks in the texture – it recalls the work of Brian Eno. Eno’s shadow is certainly seen here, conceptually; his Generative Music release (and notions of so-called “ambient music” in general) easily predicted today’s generative experiments. But Eno was ahead of his time technically: software and digital distribution – both of files and apps – now makes what was once impractical almost obvious. (See also: Xenakis, whom the composers talk about below.)

You can listen to some samples, though it’s just a taste of the larger musical environment.

Fake Fish Distribution – version 500 sampler by Icarus…

12 GBP buys you your very own MP3 (320 kbps). Details:
http://www.icarus.nu/FFD/

The creators weigh in on the project for Q Magazine:
Guest column – Electronic band Icarus on whether algorithms can be artists?

The conceptual experiment is all-encompassing. Just to prove the file is “yours,” you can even use it to earn royalties – in theory. As David Abravanel, Ableton community/social manager by day and tipster on this story, writes:

“As a sort-of justification for the price, all Fake Fish Distribution owners are entitled to 50% of the royalties should the music on that specific version ever be licensed. A very unlikely outcome, but at least it’s sticking to concept.

I spoke with Ollie and Sam to share a bit about how the mechanism of this musical machine operates. Using Ableton Live and Max for Live, each rendition is “conducted” from threads and variables into a sibling of the others. The pair talk about what that means compositionally, but also how it fits into a larger landscape of music and thought. Of course, you can also go and just experience your own download (first, or exclusively) to let the music wash over you, an experience I also find successful. But if you want to dive into the deep end as far as the theory, here we go.

CDM: How is the generative software put together? What sorts of parameters are manipulated?

Ollie: The basic plan to do the album came before any decision about how to actually realise it, and we initially thought we’d approach the whole thing from a very low level, such as scripting it all in the Beads Java library that has been a pet project of mine for some time. But although we love the creative power of working at a low level, the thought of making an entire album in this way was pretty unappealing. We looked at some of the scripting APIs that are emerging in what you might call the hacker-friendy generation of audio tools like Ardour, Audacity, and Reaper, but these also seemed like a too-convoluted way to go about it.

Even though Max for Live was in hindsight the obvious choice, it wasn’t so obvious at the time, because we weren’t sure how much top-down control it provided. (As a matter of fact, one of the hardest things turned out to be managing the most top-level part of the process: setting up a process that would continuously render out all 1000 versions of each track.) Although it was quite elementary and unstable (at the time), [Max for Live] did everything we wanted to do: control the transport, control clips, device parameters, mix parameters, the tempo … you could even select and manipulate things like MIDI elements, although we didn’t attempt that. 

So we made our tracks as Live project files, as you might do for a live set (i.e., without arranging the tracks on the timeline), then set up a number of parametric controls to manipulate things in the tracks. Many of these were just effects and synth parameters, which we grouped through mappings so that one parameter might turn up the attack on a synth whilst turning down the compression attack in a compensatory way. So the parameter space was quite carefully controlled, a kind of composed object in its own right.

We also separated single tracks out into component parts so that they could be parametrically blended. For example, a kick drum pattern could be spilt into the 1 and 3 beats on the one hand, and a bunch of finer detail patterning on the other, so that you could glide between a slow steady pattern and a fast more syncopated one. So loads of the actual parameterisation of the music could actually be achieved in Live without doing any programming. Likewise, for many of the parts on the track, we made many clip variations, say about 30, such as different loops of a breakbeat. The progression through those clips — quantised in Live, of course — could also be mapped to parameters.

Finally, by parameterising track volumes and using diverse source material in our clips, we could ultimately parameterise the movement through high-level structures in the tracks. So we could do things like have a track start with completely different beginnings but end up in the same place. We did this in Two Mbiras, which is probably the track where we felt most like we were just naturally composing a single piece of music which just happened to be manifest it a multiplicity of forms. In that sense, this was the most successful track. Some of the other tracks involved more of an iterative approach where we didn’t have a clear plan for how to parameterise the track to begin with, but that fits with our natural approach to making tracks. At one point, we wondered if we could just drop a bank of 1000 different sound effects files into an Ableton track, to load as clips. To our glee, Live just crunched for a couple of seconds and then they were there, ready to be parametrically triggered. So each version of the track MD Skillz could end on a different sound effect.

The Max software consisted of a generic parametric music manager and track-specific patches that farmed out parametric control to the elements that we’d defined in Live. The manager device centred around a master “version dial”, a kind of second dimension (along with time), so you could think of the compositional process as one of composing each track in time-version space.

We used Emanuel Jourdan’s ej.function object, which is a powerful JavaScript alternative to the built-in Max breakpoint function object, and wrote some of our own custom function generators and function interpolation tools to interact with it. Using the ej.function object, we composed many alternative timelines to control the parameters, and then used the version dial to interpolate smoothly between these timelines, resulting in a very gentle transition between versions. I.e., version 245 and 246 are going to be imperceptibly different, but version 124 and 875 will be notably different (we quickly broke from our own rule and started to introduce non-smooth number sequences into some of the tracks, so for example in Colour Field two adjacent versions will actually have quite different structures). We spent some time making it well integrated into Live so that once we really got into the compositional process it would work smoothly and be generally applicable to all of the different ideas we wanted to throw at it. That said, it’s a few steps of refinement from being releasable software. 

Pictured: the master controller device, very minimal, just a version dial and a few debug controls. Double clicking on bp_gui leads to the other figure, a multitrack timeline editor, with generative tools for automatically generating timeline data using different probability distributions.

How did you approach this piece compositionally, both in terms of those elements that do get generated, and the musical conception as a whole?

Sam: Since 2005, we had been working a lot in the context of performance, not only as Icarus, but with improvising musicians through our label / collective Not Applicable. This is reflected in the records we put out both as Icarus and individually during that time, which increasingly used generative and algorithmic compositional techniques as structural catalysts for live improvisations. (As Icarus: Carnivalesque, Sylt and All Is For The Best In The Best Of All Possible World. Individually: Rubik Compression Vero, Five Loose Plans, Nowhere, Erase, Chaleur and The Resurfacing Of An Atavistic Trait). Our performance software was made using Max/MSP and Beads and we started by crafting various low level tools that would loop and sequence audio files in various different ways, giving us control parameters that were devised around musical seeds we were interested in exploring.

In many respects, our approach was very similar and partly inspired by Xenakis’ writings in Formalised Music, although the context is obviously very different. These low-level tools were augmented by various hand-crafted MSP processing tools which used generated trajectories and audio analysis as a method of automating the various parameters that effected the sounds themselves, the logic being that an FX unit as a manipulator of sound is in some way loosely coupled to the musical scenario it is contextualised in. In both cases above, the idea was to step back from performance ‘knob twiddling’ by using the computer to simulate specific types of behaviour that would control these processes directly (hence the reason why we have never used controllers in performance).

Our search for different methods of coupling our increasing parameter space led us to develop various higher-level control strategies at Goldsmiths and IRCAM respectively, culminating in autonomous performance systems built in the context of the Live Algorithms for Music Group at Goldsmiths College. The autonomous systems we developed used a battery of different techniques to effect control, from CTRNNs and RBNs to analysis-based sound mosaicing, psychoacoustic mapping and pattern recognition. This work resulted in us being commissioned to put together a suite of pieces for autonomous software in collaboration with improvising musicians Tom Arthurs and Lothar Ohlmeier called “Long Division” for the North Sea Jazz Festival in 2010. The challenge of putting together a 45-minute programme of autonomous music really forced us to think more strategically about how it was possible to structure musical elements within a defined software framework and how they could vary not only within each individual piece, but also from piece to piece.

The most obvious inspiration for how we might do this ultimately came from reflecting on what it is we do when we perform live as Icarus. The experience of working up entirely new live material and touring it without formulating it as specific tracks or compositions proved to be an ideal prototype not only for Long Division, but also ultimately for FFD. Here, in a similar sense to the work of John Cage, large-scale structure and form became a contextually-flexible entity, which meant that for us it became to a far greater extent derived from the idiosyncrasies of the performance software we developed and keyed in by our own specific way of listening out for certain musical structures and responding to them in either a complementary or deliberately obstructive fashion (or perhaps even not at all). Creating these two pieces (‘Long Division’ and ‘All Is For The Best In The Best Of All Possible Worlds’) gave us the conviction that we could devise musical structures that were both detailed enough and robust enough to benefit positively from some level of automated control.

Therefore, when we came to start working on FFD, the main question we had to ask ourselves was; within the music making practices we had already been working with, what were the tolerances for automation within which we were still ultimately in control of and ultimately composing the music we were creating? In the end, the framework we set up was comparatively restrained; the generative aspect of each track was always notated as a performance via a breakpoint function and therefore able to be rationalised by us, the variation between different versions of the same track was done using interpolation and is completely predictable and incremental and finally, the entire space of variation is bounded to 1000 versions, meaning that the trajectories of the variation never extend into some extreme and unrealisable space.

More notes on the album:

Web: http://www.icarus.nu
RSS: feed://www.icarus.nu/wp/feed/

Last.FM: http://www.last.fm/music/Icarus
Discogs: http://www.discogs.com/artist/Icarus+(2)

SoundCloud: http://soundcloud.com/icaruselectronic
Twitter: http://twitter.com/#!/birdy_electric

Myspace: http://www.myspace.com/icaruselectronic
Facebook: http://www.facebook.com/pages/Icarus/132324596558

CREDITS

Music, Software, Scripting – Icarus (Ollie Bown and Sam Britton)
Mastering – Will Worsley, Trouble Studios
Artwork – Harrison Graphic Design

Icarus gratefully thank the following for their support of the FFD project

The PRSF Foundation (UK)
STEIM (Netherlands)
Ableton (Germany)
The University of Sydney (Australia)
Emmanuel Jourdan (France)

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.

Composing with rules instead of playing notes directly, composer Richard Garrett has built a series of generative, algorithmic, ambient note makers and processors in Ableton Live and the Max for Live add-on. (And yes, user-generated content continues to be a rationale for why many people would purchase Max for Live in addition to Live itself.)

With loads of useful controls for duration, start, and voicing – and the ability to feed events into anything you like – the results in your own work could sound very different than what you see hear. But whatever your musical aspirations, you can check out the work in action in a demo video (top) and tutorial on how to work with the interface (bottom). And – provided you own Max for Live – it’s all free.

In another interesting twist, this isn’t necessarily just for making self-generating music. The event generator also has an input, so it could accompany live playing or otherwise respond to events.

Here’s how creator Richard describes the work:

I just thought I’d let you know about nwdlbots, my suite of algorithmic (generative) devices for the composition of music within Ableton Live. They include event generators, pitch and velocity selectors and control devices for interaction with each other and with other MIDI tracks and input devices.

As well as generating events at random, nwdlbots can respond to activity on other MIDI tracks in Live, or to input from a MIDI instrument. In effect, nwdlbots control the density of a piece by reducing their activity when things get too busy. They also have some rudimentary ideas about harmony and can follow a chord sequence.

The first set of nwdlbots are available for free download at sundaydance.co.uk. Also on the site: documentation and videos

By the way, this and many other conversations are now happening on LinkedIn:
Ableton Live Users @ LinkedIn [invite group]

nwdlbots (“noodlebots”), free download at Sunday Dance Music

“Noodling” sounds like a great description – and I know many of us musicians do enjoy a good noodle.

What makes music software popular? Simple recording, DJ, and remix apps unsurprisingly do well. But perhaps as a testament to the importance of individual music expression, some stranger entries do, too. And those less-typical software creations can give you new ways of exploring music creation and performance. Just take Nodal.

GarageBand sits comfortably at the top of the sellers list on Apple’s App Store. But, at least briefly, a generative composition tool has rocketed to second place. Nodal 1.7, available for both Mac and Windows, is unlike most music production tools. In place of linear track arrangement, clusters of graphical nodes represent musical structure, awaiting real-time experimentation. In a network you create, “virtual players” produce patterns by traversing a geometric map defining pitch, rhythm, and sequence.

Nodal and tools like it have always been able to create musical machines from simple elements, letting the user define an arrangement and then set it in motion. But Nodal 1.7 is a major release in that it allows MIDI control, so that you can actually “play” the structure and not just sit back and let it roll.

This isn’t just for ambient music lovers, either – sync features mean you can use Nodal just as easily in rhythmic pieces or even dance music.

Developer Peter Mcilwain tells CDM:

We think new features make [Nodal 1.7] a serious composing tool. Firstly, it can be synced to other applications. Next, individual networks can be triggered (like clips in Ableton) from MIDI notes. The velocity levels in these networks can be scaled according to the velocity of the triggering note. Also, the edges or connections between nodes can now contain MIDI controller curves. This is all demonstrated in [the YouTube clip at top].

The triggering aspect means that you can perform with a generative system in a very intuitive way. Also, I have been working on a piece for a flute ensemble in which I create a triggering score in Logic. This information is then sent to Nodal. Nodal then sends back MIDI which is rendered and recorded in Logic. I’m finding this a fascinating and natural way to work.

Nodal has slipped a bit since Peter first contacted me, but seeing this among the top Mac App Store apps to me is tremendously satisfying. Peter tells us they’re not giving up their day jobs, but it’s nice just to get to support great software.

Nodal: Generative Music Software

I’d love to hear more about Nodal here, especially if you’re making interesting stuff with it. Of course, to discuss with other Nodal users, your best bet is the Nodal discussion group:

Support | Nodal Google Group

The development team – Jon McCormack, Alan Dorin, Aidan Lane, Jon McCormack and Peter McIlwain of Monash University’s Centre for Electronic Media Art in Australia – have published technical papers, too:

Nodal R&D / Technical Papers

Nodal fans / users … or other folks doing development … we’d love to hear from you.

For more generative goodness, see also:

Intermorphic and Noatikl / Mixtilk, a cross-platform system that also includes mobile tools for iOS, from the same team that collaborated with Brian Eno and worked on the landmark SSEYO Koan system.

Hans Kuder’s Tiction uses graphical nodes as does Nodal, and, built in Processing, works on any OS (including Linux). Unfortunately, I’m not sure what happens to Hans or the tool; if anyone knows, let us know.

There are probably others I’m forgetting as the coffee settles in, so chime in in comments.

Tired of top 40 hits? Pooped on podcasts? Sapped on streams?

What if your radio could generative music that was never-before — and never-again — heard, all from dynamic, algorithmic software?

PatchWork Radio does that with Pd patches. It’s not a new idea, but the radio station here, at least, is modular – not just one patch but any number of patches can be transformed into radio, thanks to some Python scripting. Creator David Guy John notes:

I’ve recently just started up an internet radio station using PureData to stream generative music. The system will load and unload randomly chosen PD patches, synthesize all the audio in real time and then stream the results out.

You can listen to the stream at http://radio.rumblesan.com and more info is available at http://www.rumblesan.com/?p=265

I’m hoping to try and recruit some help to build patches for it as it’s a bit of a daunting task to do just on my own so if you could let people know about it I’d be really grateful.

So, who’s in – does this generate (ahem) some interest or ideas, and might you want to contribute?

It seems fitting that the kind of musical worlds imagined by artists like Brian Eno now can be deployed anywhere in the world, not just generated in one iteration, but in endlessly-transformable versions.

(But can you dance to it?)

Let’s start with what’s really important: Chris McCormick’s squeakyshoecore tunes may well make you tap your All Stars and smile. The words “algorithmically-generated acid” and mention of the multimedia patching environment Pd might not suggest feel-goody, cheery, geeky-sounding electronic grooves, but that’s exactly what’s come out. These robots know what they’re doing.

And yes, even a tune named after Chris’ favorite fractal can be good summer fun.

Behind the scenes, Chris’ music is produced generatively using algorithms created in the free and open source visual patching and programming environment Pure Data. The patches actually began as a scene for the iPhone/iPod touch interactive music environment RjDj, but you can now grab all the patches, try them out, and learn them, all with an explicit GPLv3 open source license.

GarageAcidLab

It’s not just about sitting back and letting the robots do the work, either; you can control the results live with a MIDI controller.

Check out the tunes, which are themselves available under a Creative Commons license (BY-NC-SA):
http://sciencegirlrecords.com/chr15m/squeakyshoecore/
On Archive.org / CC-licensed download page

And read the blog:
http://mccormick.cx/news/tags/squeakyshoecore

And great work, Chris. I hope that soon we can work with Chris and others to get some more information for newcomers to Pd on making their own musical creation and performance tools.

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.

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.

Composing music is not unlike programming – and either, at their best, can be expressive. In the early days of IT (before “IT” was even a term), many computer programmers came from a musical background. (And even early in the computer age, there was more call for software than symphonies – and more pay.)

But what if you could program music easily, using musical syntax in a programming language? That’s the question asked by languages like Velato. The commands actually aren’t as esoteric as you might expect; they include references to standard pitch and commands like “Change root note.” The language expresses notes, mapped to the alphabet, a bit like teaching the computer solfege. Using additional expressions, you can transform notes and generate musical materials.

The results sound a bit like an academic-sounding ragtime. And yes, they do sound as though they were generated by a computer. (Have a listen to a .MID file.)

For more on Velato:
Velato wiki page @ Esoteric Languages
A compiler built in .NET (Windows-only, though if you really wanted to I imagine you could quickly port to Mono or other environments)
An introduction [Rottytooth blog]

Creator Rottytooth is Daniel Temkin of New York. Along the same lines is Fugue, which specifies notes as intervals (oddly, the same way I learned atonal sightsinging, but that’s another story).

So, what use is all of this? Creating languages for music could be a first step to being able to write compositionally-useful generative music algorithms. That could allow composers writing for games, installations, performance, or software to create interactive music that generates itself without sounding like a bunch of random notes. And having an elegant, musical language to do so could allow you to sketch ideas with just a few keystrokes.

In fact, I’d argue that sitting with a big, monolithic music editor, you might actually spend more time and effort than a reduced language, once you learn it. I’m not sure these are mature enough to use yet, but the idea is fascinating. And who knows, maybe you’ll someday see this as a scripting option in the sequencer you already use.

Previously:
Code Your Own Sequencer? Archaeopteryx Generates MIDI with Ruby

Thanks to Grant Michaels, via Twitter, for the tip. (Grant’s Twitter feed includes lots of other goodies, too.)