Beads
I have been looking into a new approach to making computer music with the following criteria:
- Code-based: no more of this Max-based pointing and clicking. For one thing it’s giving me RSI. For another, it’s so bad when it comes to extensibility, and it’s really is hard to work out a good design practice. Another nightmare with Max is managing access to variables. send and receive are global, patch attributes are local but inacessible from subpatches and so on. Painful. And finally, I can’t really put my finger on why, but in Max I find composing sequences of anything a nightmare. Making machines that do things is fine, but fitting composition into your patches is funny. I needed something with more flexibility than Max, and better enforcement of good design.
- But not Supercollider: despite being a really interesting and impressive language, Supercollider looks like a confusing mess. Apologies to anyone offended by that. As with Max, I’d like to be able to hop into working on the level of individual samples (i.e., get inside the UGens I’m working with) without having to hop between langauges.
Let’s sum that up:
- cleverer than Max, easier than Supercollider.
Enter Beads. This is a work in progress, but I definitely feel that it’s working for me and will have a long future. Basically, it’s a UGen-based system built on JavaSound and written entirely in Java. Java is traditionally synonymous with slow. But a few provisional tests, unpublished though they may be, suggest that you can get just as many channels of sound (e.g., number of oscillators) running in Beads as you can in Max, and maybe also SC. I got started on this after I found a dormant JavaSound project, JASS, which demonstrated the basics of implementing a UGen system in JavaSound. The power of Java OOP in a UGen framework seems like a winner. For a start, it’s really easy to write, and using an environment like Eclipse, with SVN, means that it’s really easy to manage and run. Also, the combination of inheritance and embedding just offers so many ways to build complex musical machines.
A Bead is an object that can be switched on and off and can be sent messages which are also of the Bead class. UGens are Beads with the ability to process audio, and which you can plug into each other. So far I’ve got UGens for playing sample buffers, granular playback of samples, playing wave-buffers, building FM synths, detecting onsets, and controlling gain, and I’ve got some other things working like a simple envelope manager, which can be set to control different parameters of the above UGens. I will endeavour to upload some kind of applet examples soon. In the meantime, the project is on open-access (closed commit) SVN here, and I’m currently interested in feedback and collaborators: