The latest work is at the bottom of the page

Chopping Board Pt I

I got a bamboo chopping board and some bits and pieces from a pound shop near where I live and made this thing (I don't usually use a UA-30 to record - it just fits on the table for testing!) and used a couple of contact mics on it.

I superglued (superglue is probably too brittle) 40mm steel washers to one side of the contact mics and then a lump of mouse mat to the back of them to protect the connections. The washers seem to transfer sound really nicely to me. This is a straight recording, bit clipped in places but I like the stereo spread, which surprised me over such a small surface (about 12").

Chopping Board Pt II

As above - another recording of the same thing


As the title suggests some stuff using chaotic algorithms (probably wrongly) in Max/MSP. Just feeding values from several chaotic objects back into simple [cycle~] objects.

More than anything I enjoy the purity of the sine waves and the harmonics they produce when together. Feels very neat and tidy to me somehow. There's some accidental FM synthesis going on here (at least to my ears). There are some really nice sounds in here.


Created with an algorithmic patch in Pd. It's a mixture of midi sounds being triggered by Pd (using several [random] objects in series triggered by a metro that the [random] time interval feeds back to - so there is no real rhythm) and a couple of [osc~] objects with a delay on them, with the output recorded in Audacity. The midi pitches / patches / sounds / pans / velocities are all triggered by the [metro] hitting some number of [random]s - the [random] objects all feed into other [metro] objects. The [osc~]s take an [mtof] but can be "tuned".

I've lost the patch (I made it at my last job and didn't remember to keep it - sorry I can't be more specific), but it was possible to specify a range of midi notes and sounds.

I can't remember exactly how I did it but the way it works is that if one short time interval occurs it will be followed by many more, whereas a long time interval will be followed by very few.

The [osc~] objects are very clicky because I didn't use an ADSR envelope on them, as you can tell!


Sort of nice sounding algorithmic music, one using contact mics over an algorithm capable of choosing its own notes from a limited palette.

The first uses two [cycle~] objects and two [phasor~]s with assignable ADSRs and processed input from 5 contact mics. The second, has no contact mics but more filtered [phasor~]

The notes are chosen from a preset list randomly from a random [metro] -> [random]

I managed to use an ADSR on this so it sounds smoother, possibly a bit too Eno-like though.



Tests for Damo Suzuki gig

Trying some stuff out. OpenCV plus the aforementioned thing

2nd test

3rd test


An attempt to make a random version of the ModSquad example patch in Max/MSP but with Pd and randomising the playback of the slices. Also, any number of slices can be used (ie not limited to 16 per sample file - there is no limit and no limit to sample length) and they can be played back at any speed; the [metro]s controlling the firing of the slices change speed when the [xgroove~] objects I am using have their playback speed changed, so the sliced loops change speed in relation to pitch / playback speed without going out of time.

Over the top is some time stretching stuff, for fun!

Glitchy, but I like that.


Experiment using [tabread4] in Pd to control the pitch and index of FM operators. The tables are read using [metro]s whose speeds can be changed or they can be stopped and the values from the tables frozen. Multipliers can be used to make the index and pitch values more or less extreme. The tables can be redrawn with the mouse in graphical representations of the arrays at any time (although in this case they were not).

New sounds for Vultures gigs.


Using the same 5-OP FM synth as above but pushing it a bit more and using some [freeverb]. Settings you would use in a live environment whilst trying to make someone sick, possibly in The Foundry. I've only got Ryan and Wayne from rEnDErPLAnt to thank for this. Reminds me of the horror sounds Wayne and I could get from the cheap TQ-5 4-OP Yamaha synth that looks like an answering machine from 1990 (apparently) - I got one for £12.50 off eBay - and it's genius as long as you can plug it into your computer and edit it.

Being able to automate each OP and change the index and pitch live is much more fun though. Being manual can be fun, but this patch has a way to go yet - mainly because I find FM synthesis a bit... weird. There are a couple of typical FM clangs in it here and there though.

This is not supposed to sound nice or pleasant. It's a bit like being drowned.


New track for an Akoustic Timbre Frekuency compilation featuring many artists who have taken Priapus23's source material and created new "ritual" sounds. Using the beat chopping Pd patch above (5 instances running at different speeds, varied throughout) along with the FM patch and a webcam controlled time stretch patch.


FM patch with a new 16 step random drum sequencer which has some control - the tempo stays the same but it is possible to have a little control over when the drums hit. The drums are samples played back using [soundfiler] in Pd -7 per channel if necessary, with two channels.


Made with two Maplin electronic kits - a "voice changer unit" and a "function generator kit". The function generator feeds into the mic of the voice changer. Both are fed into Max/MSP into a simple reverb and cross delay effect patch.

Music for Seth

Made from samples from the SARS Virus Project by Seth Guy. Beat chopping, time stretching, random synths, glass tapping, finger clicking. All in Pd, made live.

Love (for Robert, Amber, Mike and John)

Sort of remix of Explanation Without Words from the PAS album Pure Energy Output Sessions. Some FM, lots of sound from PAS and some earbreaking stuff.


Music made for Babylon Projects. Algorithmic synth in C minor with chopped vocal samples, glass tapping, noise and time stretching. The patch is similar to the one used for Algorbodgmic above but made in Pd this time.

As Above, So Below

More algorithmic composition in Pd. Just a gentle thing.

No Input

I got a cheap old mixer (a TEAC Model 2A - very old) from a nearby second hand shop yesterday and have been playing around with "no input" mixing - a lot of fun just using a feedback loop and playing with the various controls. What I really like is that the mixer has 4 assignable output busses, so any of the six inputs can be assigned to any combination of the 4 outputs. Using the feedback loop and using the assign buttons changes the sound radically and because it is at the click of a switch, there is no audible sweep of a pot.

No Input II

Similar to the track above but with more subtlety.

Mu26 Model-2A

A track made for an Oxfam compilation made with no input mixing. Cymbals by me and Tibbs Mink of The Miller Test. This is a test mix and not the finished thing - buy the CD to get the full Monty!


This is an algorithmic patch that needs more work. Lots of filtered [noise~] using [lores~] filters and some FM synthesis. I also used some of the objects from the PeRColate library in a fun way (there's a bowed string model and a marimba being used here but not in a particularly obvious way).

It makes extensive use of [line] to fade subpatches in and out. There are no controls for this patch - it just does what it wants. I think having not been playing many gigs recently with Pd I have become more interested in writing patches that just play themselves, but this is also inspired by music I have heard here: Patchwerk Radio which is great.

The track is called Yuri as it is exactly 50 years today (12/04/2011) since Yuri Gagarin first flew in space.

Karplus Strong Go Techno

This patch uses the Karplus Strong plucked string algorithm in Pd to make a kind of techno track. It needs work but I think something fun may come of it.

It uses [osc~] and [noise~] with a [lores~] for snare, similar for kick drum and [noise~] through a [lores~]. There's also a randomly pitched filtered [phasor~] that comes in.

I think this one could turn into something interesting - what I need to do is use the random drum synth used in Sixteen above to trigger the simple synthesised drums.


A piece made for Classwar Karaoke's latest survey (as of May 2011) number 0014. Classware Karaoke is a quarterly "survey" of experimental music, so keep an eye on the site.

More cheap sounding electronic drums, synths, glassy textures and randomised delays.


This piece is sort of inspired by Hockey by John Zorn in that it is improvised but has recurring themes, kind of. In a way the equivalents of the solos, duos and trios of musicians in Hockey are different methods of processing the sound - anywhere between one and five different things can be happening at once.

It is actually 11 short pieces of sound edited together. What you can hear is actually the output of a patch with a classical guitar played through it. The patch works in real time to process the sound through a couple of feedback delays that are programmed to have constantly shifting delay times, a looping sampler - ie it is constantly recording over itself - this sample is used to create the "scratching" effect and also a strange modulated delay. There is also a Karplus Strong element, this uses the sound of the guitar rather than [noise~] as its source and creates random pitches from it.

It's quite a glitchy patch but I like that. It's intended for live performance with acoustic musicians. The sound in the room, created by the patch, obviously ends up being another input into the patch as well as the guitar which adds strange layers of feedback through certain elements. There is actually no reverb used in this patch - it's all delay feedback running back into the patch and being kind of "smoothed" out.


In preparation for more recording this week I knew I needed to make a very fast reacting patch - this one uses 9 predefined sounds and 3 effects controlled using [hid/keyboard]. I know it doesn't but I wish it did sound like Furt.

It also uses some random sample "scratching", randomly filtered [noise~], more Karplus Strong stuff, some weirdly filtered [phasor~] stuff, pseudo drums and a very silly swooping, random, filtered [phasor~].


Another piece made for Anthony Donovan's Classwar Karaoke net label.

This was made with various sounds taken from the audio I am using and made for the Edinburgh Fringe run of Und. What is happening here is that the audio if being played from QLab, being routed through Soundflower (2ch) and into Pd and processed using my realtime DSP patches.

It's fairly frenzied but in a gentle sort of way.

C programming in 8 bits

This is really fun and odd - my friend James McKernon sent me a link to this site which looked very interesting. Basically this is a method of writing directly to the audio driver on your computer with 1 (ONE) line of C code.

I have to admit I don't really understand how this works - obviously sending bytes to the audio driver will work, but these things actually evolve over time.

I have named each piece by the code that created it - to run it on a Mac, you can't just pipe directly to /dev/audio as it does not exist so instead you need to use:

./test1 | sox --ignore-length -traw -r8000 -b8 -u - -tcoreaudio

If "test1" is your binary providing the data.

I am pretty sure that 8000 above should be 8192 and this mistake may account for the audio actually evolving, I don't really know - more exploratory missions need to be made into this realm.

I've been playing around with this stuff all day and it is stupendously good fun.

main(t) {for (t=0;;t++)

main(t) {for (t=0;;t++){putchar(0.2*(t>>17|t|t>>7)*20+2*(t&t>>5|t>>19)+24);}}

main(t) {for (t=0;;t++){putchar(0.2*(t>>17|t|t>>7)*20+2*(t&t>>15|t>>19)+64);}}

main(t) {for (t=0;;t++){putchar(0.2*(t>>9|t|t>>13|t&t)+240+(t>>7&t)*4);}}

main(t) {for (t=0;;t++){putchar(0.2*(t>>6|t|t>>12|t)+240+(t>>6)*2);}}

The Chase

I've been playing around a lot with FM synthesis recently and really enjoying it. This is a piece made in Pd using 4 sets of 2-OP synths. They use various combinations of [osc~] and [phasor~] objects. The index is controlled by using an [unsig~] object on a [phasor~] or [osc~] which is then multiplied by a controlled amount.

This is for Cloughie who is analogue man but I think he might just like this... but then he might not.