Pure Data is a wonder: a free and open source environment for creating your own musical and multimedia creations with graphical programming, from Miller Puckette, the original creator of Max. You can produce everything from interactive sequencers and drum machines to synths to video performance tools by connecting patch cables visually, and you can run on virtually any platform, from BeagleBoards and Rasberry Pi to Mac, Windows, and Linux desktop. Via libpd, you can target other development languages and environments, embed engines in games, or work with Android and iOS.

It’s so important, in fact, that CDM invites Hans-Christoph Steiner, one of the key developers of Pd-extended, to give us a tour of what’s new. (Note: because Pd-extended includes various additional objects or “externals” that Pd Vanilla lacks, you should be careful when building patches for libpd. What I like to do is use Pd-extended as my editing environment, then double-check patches by opening them in Vanilla to make sure I haven’t accidentally used an object that’s not part of the bare-bones version. I can then substitute an object, copy an abstraction, or if necessary build that external.) -Ed.

The Pd-extended 0.43 release has been brewing an extra long time, about 18 months now, mostly because there are lots of big improvements. We wanted to make sure we got it right, so your patches all work, but the improvements all shine, so its taken a while. It’s now solidly beta, so we’re looking for testers. Download a beta build to try here:

http://puredata.info/downloads/pd-extended/releases/0.43.1

First off, the pd-gui side of Pd has been rewritten from scratch. The focus for most of the recent work has been on the editing experience, making your patching experience as productive and flexible as possible. To give some background, Pd has always been made up of two programs: pd is the core engine and pd-gui is the GUI. Since basically all computers now come with multiple CPU cores, this means that pd-gui will usually run on a separate CPU core than pd, so they don’t step on each other’s toes. pd can entirely take over its own core. If you want to make your patch use more CPU cores, then check out the [pd~] object introduced in the last release, but fine-tuned in this one.

There are so many ideas for making a better editing experience in Pd; this release makes big strides to address the editing experience. There are new features like Magic Glass, Autotips, Autopatch and Perf Mode, all available on the Edit menu.

• Magic Glass lets you magically see the messages as they pass through the cords. Just turn it on and hover above a cord, and you’ll see the messages as they go by. You can even look at signal/audio cords.
• Autotips gives you tips about what an object does, what its inlet expects, and what comes out of the outlets.
• Autopatch mode automatically connects objects as you create them.
• Perf Mode, is a mode for performance that makes it harder to accidentally close windows that are part of your performance.

A whole new Pd Window

The Pd Window is also majorly overhauled. First of all, it’s fast. Much much faster than the old one. You can now print thousands of messages per second to the Pd Window and still edit your patch. No more will an accidental dump of info cause the GUI to freeze up (well, okay, maybe if you send 10,000 messages/second, but that is way too many). There are also five levels of printing messages to the Pd Window: fatal, error, normal, debug, all. If you are only interested in fatal errors, switch the Pd Window to 0 – fatal, and you’ll only see the worst problems. You want to see every single message to debug? Switch to 4 – all, and you’ll drink from the firehose.

There is also the new log library, which lets you easily send messages for those different levels. And all messages logged with the objects from the log library are clickable: when you Ctrl-Click or Cmd-click (Mac OS X) on the line in the Pd Window, it’ll pop up the patch where the message came from, and highlight the specific object that printed it. That even works for many messages from other objects, as well.

The Pd Window also includes very basic level meters for monitoring the input and output levels. And for those who want to play with the GUI in realtime, you can type Tcl code in the Tcl entry field, and directly modify and probe the running GUI.

Customize the GUI with Plugins

One thing that you can do now is customize the GUI using GUI plugins. You can change all sorts of colors, some fonts, and many behaviors. Want to create a new object when you triple-click? Try the tripleclick example plugin Want to make the patch cords disappear when you leave Edit Mode? Check out the “only show cords in edit mode” example. Those are the simple ones. There is also Tab Completion, a search engine for the docs, a category browser for the right-click menu, a buttonbar for creating objects, and more.

You can find many GUI plugins in the new section of the downloads page as well as documentation for making your own. (What kind of GUI plugin will you write?)

Write Pd objects in more languages

Traditionally, Pd objects are written in Pd (abstractions), C and some in C++. This new release includes two “loaders”, Lua and Tcl, which allow you to write regular Pd objects in either Lua or Tcl. Pd is not the best for processing strings, so if you need to do that, you can now easily use Lua or Tcl, both very easy scripting languages for working with strings. Lua is often used for OpenGL work, so you can also run Lua objects to work in conjunction with Gem. Also, the Tcl loader lets you write GUI objects in pure Tcl, no C needed.

Multi-processing, Pd-style!

The [pd~] object now works out of box. In case you missed the introduction of the [pd~] object in the last release, we’ll introduce you now. [pd~] is Pd itself incapsulated into an object. You can run any patch inside that instance of Pd, the difference is that the Pd in the [pd~] object runs in a totally separate process. So if your computer has multiple CPU cores, which basically all computers do these days, then the Pd process inside the [pd~] object will run on a separate core. This means you can have a heavy Pd patch spread across multiple cores or CPUs. Or for people who work with video and audio together, you can have one instance for video running at a normal priority, then another instance for audio running at a high priority to make sure there aren’t clicks in the audio caused by heavy video processing.

Autotips, generated from help patches

This release also provides a new “autotips” feature to provide instant information about objects and their inlets and outlets. It is one of the first new developments to showcase all of the meta data that is now included in all of the help patches. (Check out the [pd META] subpatches.) When you hover above an inlet or the object itself in Edit Mode, you’ll see a short text description pop up on the lower left corner. But, of course, using a GUI plugin, you could customize how they are displayed to make it how you want to see it. If you want to add autotips to your object, then just add a [pd META] subpatch to your objects’ help patches, and fill out the description, etc. Voila! They’ll have instant information.

What’s next?

The core pd process still handles a lot of the GUI stuff, but we are working on splitting that out for the 0.44 release. That is a big chunk of work, but it will also bring big gains. In particular, it means that it will be possible for people to write their own GUIs for Pd, covering not just the display of the patch, but also the editing, and everything else. You like OpenFrameworks, Python, iOS, JUCE, Qt, etc.? Write your own pd-gui using the toolkit of your choice. That’s the idea at least. That will take a solid chunk of work, so we are looking for people to join that effort.

Try it yourself:

http://puredata.info/downloads/pd-extended/releases/0.43.1
http://puredata.info/downloads/pd-extended

Where to learn Pd:

Resources to start learning

-Hans-Christoph Steiner for CDM

First revealed last month, PreenFM is an open source hardware synth. As the name implies, it’s an FM synth, with some very serious specs: up to six-operator FM synthesis with some nine algorithms, up to 4-voice polyphony (depending on algorithm), glide, selectable LFOs, modulation matrix, and preset banks with SysEx support. It’s all usable via a display and MIDI support.

It’s also fully open source hardware; whereas early efforts often had commercial restrictions attached, PreenFM is free for use under the GPLv3 and Creative Commons. And it’s got a unique platform under the hood: the open source LeafLabs 32-bit development platform gives this some serious horsepower. It’s very much in contrast to the ultra-inexpensive 8-bit brain of our own MeeBlip synth; think of the MeeBlip as an exercise in what you can do with a little two-stroke engine versus the V8 muscle in this. (The creator says the MeeBlip helped inspire his creation – yes, synths are multiplying!)

You may have glimpsed the PreenFM making the rounds online, but I got creator Xavier Hosxe to tell us more of the gory details and share some sounds.

CDM: So this is all based on the Leaf platform?

Xavier: Yes it’s built around a LeafLab board.
I coded a first version on the Maple [development board]; then when they announced their “Maple Mini,” I realized it was going to be very easy to plug it into a PCB.
I’m not directly connected to [LeafLabs]; I participated in the forum and learnt many things from the team.

They are very friendly and helpful.

What was it like working with the Leaf?

The LeafLabs boards uses an ARM Cortex-M3 microcontroller.

It’s a 32-bit chip runing at 72Mhz that can do 32-bit multiplication in 1 clock cycle, has 128Kb of flash [memory] and 20Kb of RAM. That seems very few but it’s not, PreenFM software uses 92Kb for the moment.

LeafLabs provide a Linux/gcc toolchain that allows to develop in your IDE of choice… Eclipse in my case, which is very confortable.

They also provide a strong bootloader and some libraries that worked perferfeclty for my needs : Usart (Midi), I2C (EEPROM), LiquidCrystal (LCD).

What will you get in the PreenFM kit?

All you need to build yourself a complete synth: PCB, screws, resistors, ICs, audio/midi jack, box, 20×4 LCD, encoders, knobs, buttons… even an USB cable [for power].

You’ll also get a Maple Mini board with PreenFM soft preloaded. The Maple Mini is easily updatable, and you can experiment lots of different things with it.

PreenFM C++ source code is available on GitHub. It’s easy to read and modifiable. If you want to see your name to welcome you on the boot screen, go ahead

To build the kit, you only need a soldering iron and some solder.

There will be 2 differences with the photos you can see on the site: the final PCB will be blue (I should receive them next week). [Ed.: See the photo in blue at top; the orange one is included here for variety! -PK]

Xavier also sends along some welcome news:

Here is a sound I can get with my soon-to-be-released StepSequencer feature in PreenFM.

This is a single voice of a simple 3-oscillator voice. 1 very slow LFO + 2 * step sequencer routed to the modulation indices.

PreenFMStepSeq by cdm

Here’s a sound sample:
PreenFM 1 by cdm

http://www.preenfm.net

The generation of people who defined modern computing seems to be passing this year. Following Max Mathews, another Bell Labs titan is lost to us: Dennis Ritchie is the man who created the original C programming language (again at Bell Labs) as well as co-developed the UNIX operating system. President Obama commented that many people learned of Steve Jobs’ death on a device “he invented.” For all Jobs’ contributions, it is as untrue to say that as it is true to say the same of Ritchie: you are quite literally reading this story as served by software derived from his creations on UNIX, using tools written primarily in the language he, with others, devised.

For music, C endures in some form as the basis of the vast majority of tools we use for musical computation – that is, his creation is at the heart of the software with which we all make music. And just as Mathews made the computer sing for the first time, C is a lingua franca on which musical expression is based, the kernel of the vast array of sounds computers today make.

But C is important not simply because, in some form, it remains at the heart of much of the computer code written today. It also introduced in a material sense the idea of portability and cross-platform code, allowing in turn music tools like Csound and others to appear on new computers rather than pass away. It formalized coding concepts that, even in radically-different, more “modern” languages survive. That means that for people expressing musical ideas in code – and anyone using the software that results – software is not tied to specific hardware, lost as new generations of gear cause the old to pass away. The ideas behind C allow computer music to pass from one generation to another – to outlive us.

Ritchie would probably at this point hasten to add that he didn’t work alone, that his work was based on others, that he had colleagues like Ken Thompson who worked with him on C and UNIX. Such is the nature of invention, and unlike the titanic egos of the past (yes, Henry Ford and Thomas Edison, we’re looking at you), some of today’s creations were built by people whose impact was no smaller, but who have been far humbler and lesser-known.

So, get to know Dennis and the many colleagues who survive him. Marvel that the “machine” is not some alien robot at all, but that in your hands, you hold the contributions of creative human beings, the thoughts of complete strangers encapsulated in front of you, and that at the end of the day, you can make it all sing a song.

Via TechCrunch

This update I believe is worth a second post, as it makes visible the otherwise-mysterious algorithms producing music in our previous post.

And yes, I believe this is “music,” naysayers aside. Whether it’s good music is in the ears of the listener, but if you can describe this much sound with this little code, imagine what’s really possible in computer music. Whatever it is you want to hear, it’s within the power of your imagination to describe it, on a score or in code, either one.

Thanks to none other than Stephan Schmitt for the tip.

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 may have already seen FaceOSC, free software that eases the use of facial tracking from a computer camera for use as a controller, here with music software (top). Synthtopia picked up the story in July, featuring artist and engineer Kyle McDonald. But one FreeKa Tet has done his own implementation (second from top), and while the video is a bit grainy, he sounds wonderfully terrifying, as if his face is trying to slip out of The Matrix.

Sometimes, I’m rendered entirely silent (no, really, it happens), and it’s best to let videos speak for themselves. So here, after the jump, are some whimsical and wild prosthetic sound light-up … hell, I don’t have any idea what’s going on, but I’m enjoying it.

I dare you to start some conversation about musicality. Just don’t be surprised, comment trolls, if you find yourself abducted by a glowing and oddly glitchy-sounding creature with long, monstrous fingers. I’d watch what I say, frankly. Remember the old saying “on the Internet, no one knows if you’re a dog?” I expect that extends to space aliens, too.

Plenty more where those came from.

Oh, look, I could have done my research and seen there’s a bio for Mr. FreeKa Tet, aka Bacon ClapCLAP.
:

Extreme violent bursts, silence, speech, hard rock samples, strange atmospheres, Burgers , American Idol Icon, crackles, retardation, puking static, rocking a gabber party, cutting a worm in half and watching both parts moving, get a watch tatoo on his wrist, confusing videogames with music, drawing little puke characters on friends faces …

Right. Okay. That cleared everything up.

Enjoy your weekend, folks, and stay high and dry, those of you here on the Eastern seaboard of the US.

I think the first time I really understood handheld music making was when I first tried Nanoloop on Game Boy. While the more-popular LSDJ tracker is powerful, Nanoloop’s interface was unlike anything I’d seen before: aggressively minimal, it embodies in its interface design the feeling of a blank sheet of paper. Adding an idea feels like composition, like genuinely exploring open-ended possibilities and discovering what melodies may result. Now, Nanoloop – already on iOS – is available for Android, too.

It remains simple stuff, the sense of what a music maker looks like when designed for your hand rather than translated to mobile from desktop, studio-style workstations. There are six fixed channels, each assignable to a synth (FM, noise, or filtered wave) or a sampler. Then, each channel takes eight patterns. There’s a step sequencer, the ability to resample, and song editor with loops. The sampling capabilities are especially nice on Android, as you can now sample from the mic or load samples right onto the SD card. (The mic you can use on iOS, but not the SD card, of course.) You can export OGG files to your library, turning your Android device into a DJ-set-ready pocket music library, or send and receive projects via email. Via iTunes, you can even exchange files with the iPhone version, in case you have an Android phone and an iPod touch or some similar arrangement.

This isn’t a port of the Game Boy nanoloop, developer Oliver Wittchow is quick to note. It’s not for chip music, or emulating game consoles. It’s for … well, Android music. But make no mistake: while the tool feels fresh and native to the new platform, it also carries the spirit of the Game Boy version. And that spirit is handheld music making, not just the aesthetics of the chip, but the feeling of using a minimal device scaled to your hands, something you can use on the go.

Oliver tells CDM that he has used a lot of native code (via the NDK), as he did non-object-oriented C (not Objective-C) in the iOS version. He says it’s about 1:1 C and Java: “I could use the iOS code almost unmodified and get the sound engine and touch input to work immediately. I had an almost fully working nanoloop within few days – without any graphics though.
Now I ‘just’ had to write Java code for GUI, file access, recording functions and the different menu structure.”

The results, he says, are a little strange if you’re looking at the code (lots of getters and setters, C mixed with Java), but it works well.

Android owners, I’d love to hear how this works on your device. Let us know – just be sure to fill out a bug report. As the Market page notes:

Nanoloop works on a variety of devices, including HTC Desire, Motorola Droid and also midrange phones such as HTC Legend and XPERIA X10 mini. However, this is the first release and of course it has not been tested on all Android devices yet. If you experience crashes or other problems, please report them via e-mail or the anonymous bug report form at www.nanoloop.com. Thank you.

Now if we can just have some luck with Bluetooth MIDI at our hacklab tomorrow, this could be another candidate.

Oh, and most of all, I’d love to hear the music you make.

nanoloop on the Android Market (a stunning EUR1 … that’s a no-brainer. Better than an espresso shot!)

nanoloop.de [iOS, Android]

See our previous Android music round-up

For the historical record, here’s nanoloop for Game Boy on CDM – from 2004. It’s actually come quite a ways since that release, but the spirit is the same.
http://createdigitalmusic.com/2004/11/updated-nanoloop-20-game-boy-instrument/

Ben X Tan writes to let us know he’s working with hacks for Microsoft’s Kinect 3D camera system for Xbox to perform MIDI control. Result: depth-sensing, gestural musical manipulations! It’s just a prototype, but since today I cover the larger landscape of what’s happening with Kinect, it’s well worth teasing. From the description:

Coded in C#.net using this: http://codelaboratories.com/nui

Very hacky ugly, yucky, alpha prototype, source code available here:
http://benxtan.com/temp/pmidickinect.zip

Next project is making a version of pmidic that uses Kinect. Then, you can control Ableton Live or any other MIDI software or hardware with you limbs. Isn’t that amazing!!!

If you are interested, you should also check out:
http://pmidic.sourceforge.net/
http://benxtan.com

He tells me, “It’s just proof of concept for now, but want to make something nicer in the long run The community on IRC for this stuff is great. Very supportive. I love all the hacking going on at the moment. Especially after watching the Social Network. Very inspiring!”

So, what’s this whole Kinect thing about, why should you care, why might it be useful to artists and musicians and designers generally, and where do you go to find the code? I’ve rounded up various hackers working on the project to answer those questions on Create Digital Motion (in this case, Capture Digital Motion):
Kinect Hacking and Art Round Table: Why it Matters, What You Need to Know

What if you could make any device or any software a re-programmable musical instrument, effect, or soundmaker? Your phone could be a touch-controlled effect, your tablet a sketchpad for interactive drum sequencers. Patches assembled on your desk on a computer could be taken with you in your pocket. And what if you could do all of this for free, using a time-tested environment?

libpd, authored by Peter Brinkmann, takes on that vision. It’s a way of making Pure Data (Pd), the visual development tool for interactive music and media, more accessible across a range of applications and gadgets. It lets you embed Pd pretty much anywhere. It’s not a new version of Pd. Instead, it makes use of the standard, “vanilla” distribution of the free and open source software. What’s different is that it separates the sound processing part of Pd from the part that talks to audio hardware, allowing Pd to run on a greater variety of mobile devices and inside other applications.

libpd:

• turns Pd into an audio synthesis and processing library
• liberates Pd from GUI and drivers
• allows for easy communication between Pd and the code into which it is embedded (so you can send and receive messages with your Pd patch)

Today, a team of developers and testers (including myself) is releasing the first version of libpd. It’s free to use on any device you wish, and free to modify. Because of its licensing, you can even build commercial applications with it. (That is, yes, it’s open source – but yes, it can also be useful if you’re a commercial developer. You don’t have to choose.)

http://gitorious.org/pdlib | community discussion

We’re just pleased to have a tool that makes experimenting with sound and music quicker, easier, and more flexible and compatible. It’s more fun that way.

Supported Platforms, What You Can Make

Right now, today, you can use libpd with:

Android: Thanks to Google’s NDK (Native Development Kit), you can use libpd with any Android device running OS 1.6 or later. Note that devices without the Google Market are often non-standard in other respects, so your mileage may vary, but we’ve found a wide variety of devices work quite well, including the Motorola Droid and Droid X, HTC Legend, and Google NexusOne.

iOS: iPhone and iPad models with the latest, armv7 processors work (3GS, iPad); we’re working to extend compatibility across more devices. Working with Peter Brinkmann, the RjDj development team contributed (and continues to contribute) free code that’s making iOS support compatible and high-performance. But the Objective-C classes mirror the Android and Java classes, meaning the two will stay in sync, and once you’ve learned one, the other will be a piece of cake. (Or coffee. Or cocoa. Or whatever.)

In each case, you just need libpd, Pd for making your patches (graphically), and a copy of the SDK for each mobile platform you want to use.

Additionally, you will soon be able make user interfaces for libpd using cross-platform HTML5, via Chris McCormick’s project WebKitPd. (It’s not quite ready for consumption yet, but will also be free and open source.) Android was the impetus and initial test platform for libpd, so right now it’s the most mature. But we hope to improve iOS compatibility and testing next.

Some Sample Apps to Try for Android

libpd is really aimed at developers who want to embed Pure Data into mobile devices, games, and so on, and soon also people working with Processing, Open Frameworks, and the like.

But if you’re eager to try this out as an end user, there are a number of packages you can try. They don’t show off everything libpd and Pd can do, but they do allow you to load up something on your device and make some noise.

Download the test packages from the libpd site:
http://gitorious.org/pdlib/pages/Packages

It includes a scene player for RjDj (see below).

Among the code included in the repository is one complete app, Peter Brinkmann’s own Circle of Fifths. He tells us:

Circle of Fifths: I wanted a circle of fifths tool for the subway, with exactly this kind of GUI. It also nicely illustrates the newly possible separation of concerns — Pd only does DSP, and an elaborate GUI is built somewhere else. It’s a demo and not optimized for universal consumption. In particular, it’s a bit CPU hungry because it’s actually simulating six Karplus-Strong strings in real time.

Of course, if string simulation is what you want to do, this also illustrates that you can – even on a phone.

Chris McCormick has created two libpd-based apps, one of which I feature in the video above. Can of Beats also makes use of WebKit as its UI rendering engine. Chris describes what he’s made:

Can of Beats: This is a procedural hiphop beat generator. The beats are generated using simple hand-crafted probability weightings for each type of sound at each position in the beat. In the Android app, you can also input simple melodies or basslines to go along with the beats.
http://mccormick.cx/projects/CanOfBeats/

Garage Acid Lab: This is an algorithmic, 303-style acid bassline generator. The app will make you an infinite number of different acid bass lines and garage style beats. You can also have some fun with the cutoff filter and delay unit settings with a kaos-pad style input. I want to work on this app a bit more to provide an ‘advanced’ mode which will let you write custom basslines, beats, and have more control over the effects. http://mccormick.cx/projects/GarageAcidLab/

RjDj, RjDj team. If you don’t know it by now, RjDj is a fantastic application built on Pd that makes interactive musical and sonic experiences deliverable in the same way as a digital album, not only to musicians, but anyone who wants to experience music and sound in new ways. libpd makes use of code contributed by RjDj. Future development on RjDj will use libpd. (More on those libpd-based versions, and the evolution of RjDj and RjDj Voyager, soon.)
http://www.rjdj.me/

Where to Get It, Where to Get Involved

1. Get the library. To get started, download libpd from its Gitorious source repository:
http://gitorious.org/pdlib

You’ll need Pd, too, if you don’t have it; vanilla Pd builds are available from the official Pd download page.

2. Join the community. You can discuss patching for libpd, developing using Pd, and making instruments and effects and other sonic creations for gadgets everywhere on our new community group:
http://noisepages.com/groups/pd-everywhere/

That will be a location specifically dedicated to the unique challenges of working with mobile gadgets; of course, see also the other great community resources for Pd.

Who made this: libpd was conceived by a team including Peter Brinkmann, Hans-Christoph Steiner, and myself, with input from the RjDj team (particulary Martin Roth). It was primarily developed by Peter Brinkmann, who applied his talents and the work he has done in JJACK, a Java API for JACK, with additional contributions and testing by our team and by Chris McCormick. Major thanks to Martin Roth and the folks at RjDj, to Miller Puckette (creator of Pd), and the generous attendees of our first hackday at the NYC Patching Circle, along with others who are testing now.

Tutorial Next Week; Your Feedback Wanted

I’ve been preparing a tutorial for working with libpd Android (initially), to be followed eventually for developing on iOS devices once we have a better handle on making that go smoothly. We’ll have a complete tutorial for you by next week. Processing is then my next priority.

An FAQ will also be available by then. That means, first, ask some questions!

Got specific questions about what this is for? How to get started? What you’d like to see in the tutorial? Ask away.

And please do get the discussion going not only here in comments, but in the Pd Everywhere group. (Noisepages registration is now open; if you have any trouble, let me know and I’ll sort you out.)

Party like it’s 1991 – your browser’s invited. A full-blown music production tool has been directly ported from the desktop to the browser using Flash, modeled with a tracker-style interface for fast, precise music editing. (In fact, a tracker, thanks to speedy entry from a QWERTY keyboard, seems to me an ideal interface for browser music. Trust me – it looks arcane at first, but trackers can be extremely friendly music interfaces. Just be prepared to look like a total geek once you’ve worked it out, because it’ll look even more arcane to everyone else)

The resulting tool comes with all the modules you’ll need, and it’s completely free to use. There’s even an included sample library.

Now, the next time you’re stuck in an Internet cafe, you can compose a song.

Creator Ruben Ramos says this is the first tracker on the Web, and shares his development process with us:

The sourcecode of the application is the same than the desktop version, it’s C++. I used a research project from Adobe Labs to build my sources for the AVM2 (ActionScript Virtual Machine 2), which is the last virtual machine used in Flash. This way, I got a binary version as a .swf of my original desktop-based application.

I wrote some parts code for this version, but only a few. For example the graphic rendering: in the desktop version was using the graphic card acceleration; for this version I implemented a software renderer.

After it, I added some special features for this version. For example, I implemented a filesystem with remote access to allow the load of resources stored on the server. With this feature songs and samples can be loaded from the webserver, which is good to have a base sample library available on the server.

Try it out for yourself:
http://www.skale.org/