This sound was created using the following 140 characters of SuperCollider code. (Apart from the distortion, which seems to have appeared when uploading it to SoundCloud. How annoying. I sort of like the effect though.)

play{Splay.ar({Pluck.ar(BPF.ar(f=product({|i|product(
{LFPulse.ar(2**rrand(-9,1),2.rand/2)}!(i+2))/(1+i)+1}
!8)*86,f).sin,Saw.ar,1,1/f,9)}!9)}

I post these at unpredictable intervals at https://twitter.com/headcube

(I've broken the code into multiple lines in order to prevent SoundCloud's autoformatting from messing with it - it should really be all on one line.)

This one has had a long gestation. There are quite a few different techniques involved in both the algorithmic generation of the music and the actual sound generation. The composition is quite different every time this code is run, so if you have SuperCollider it's worth running the code a few times as well as listening to this rendering. If you get a good composition it's worth letting it run on for a bit longer than 3 or 4 minutes, because it will continue to change in a vaguely musically reasonable manner for quite a while.

I'll start my explanation in the middle, with the code LFPulse.ar(2**rrand(-9,1),2.rand/2) . This produces a waveform that has a period anywhere from 0.5 seconds (which you can hear as the 120bpm tempo of the piece) to 2^9 = 512 seconds, or about eight and a half minutes. This code is duplicated many times (there are three "!" characters that apply to it), so there are many such LFOs contributing to the final sound. This means that the sound changes on a range of time scales, from one note to two notes, to a four-beat bar, to four bars, to eight bars and so on. This means that the result has a more-or-less fractal structure that makes it sound quite musical, even if you listen to it for eight minutes. 

A bunch of these LFOs are created and then multiplied together. In general this means we tend to get structures that look like this over time:

101010000000101010000000000000000000101010000000101010

That is, the signal sometimes switches on and off and sometimes just pauses in the off position. The lengths of the 'off' periods vary over many scales, and the overall pattern resembles a fractal called the Cantor set (http://en.wikipedia.org/wiki/Cantor_set).

The code actually generates several of these Cantor set type signals. The way they are used is as follows: we start with a constant frequency of 86 Hz, and then each of the Cantor signals is used to transpose it upwards by a different interval. The code uses the just intervals 2/1, 3/2, 4/3, 5/4, 6/5, 7/6, 8/7, 9/8 and 10/9. The presence of the 7th harmonic gives it a nicely bluesy feel. Because some of these LFOs are fast and others are slow, the result (if we're lucky) is a melody that sometimes gets transposed up and down, either in its entirety or just a few notes at a time. The sound synthesis is set up so that a note only gets played when the frequency changes, so in the periods when all the LFOs are set to zero the sound will remain silent.

This whole process is repeated nine times, producing nine distinct signals, which are panned across the stereo field using Splay. These all play independently of each other, but because the LFOs are synchronised, they often end up playing chords, between which are sequences of individual notes played by one or two channels independently. At a given time several of the channels might be silent, but nine is enough to guarantee that at least one of them will be playing most of the time.

The sound synthesis uses Pluck to create a plucked string effect using the Karplus-Strong algorithm. However, instead of using a single wave-period burst of noise as the excitation signal, I take the frequency signal and filter it with a band-pass filter. This takes away the DC part of the signal, so we only get an impulse when the pitch changes, but it isn't just an impulse - it rings on for a short time. This is then distorted using .sin, which results in a "chirp" kind of effect that sweeps from a high frequency to a low one. To my ears, this sounds like the dispersion (frequency-dependent delay) that you hear in the strings of a piano or steel-string guitar. A bigger change in pitch results in a louder note with more high-frequency harmonics.

I mentioned that I've been working on this one a long time. I was originally going to post this:

play{Splay.ar({Pluck.ar(BPF.ar(f=product({|i|product({
LFPulse.ar(2**rrand(-9,1),2.rand/2)}!(i+2))/(1+i)+1}!8)*86
,43).sin,Saw.ar,1,1/f,9)}!9)}

which is the same thing, but with different parameters for the band-pass filter. It sounds better to my ears (more bass) but I didn't realise it was 141 characters long, just one too long to post on Twitter.

As a bonus for people who have SuperCollider installed, here are a couple of early versions of this idea that use a similar composition algorithm but a different synthesis technique, and sound, well, kind of stupid. (Especially the second one.)

{|j|play{RLPF.ar(Saw.ar((f=product
({|i|LFNoise0.ar(2**i/16)>0/(1+i)+1}!8)*50)
*[1,3/2,2]).sum,3**j*f.lag,0s)*(f-f.lag).tanh!2/9}}!4


{|j|play{RLPF.ar(Saw.ar(f=product({|i|product({LFPulse.ar(
2**rrand(-9,1),2.rand/2)}!5)/(1+i)+1}!8)*50),1.5**j*(
g=f.lag(1/2)),0s)*tanh(f-g)!2/9}}!9


SuperCollider tweet from 4.6.14 (see description for explanation and code)

Bathe in the Sun in the Sea. The sea in sun... in the sea.

Finding

Pauline Oliveros puts together a mixtape featuring some of her own work ahead of Deep Minimalism this month at the Southbank Centre

Pauline Oliveros - Deep Minimalism Mixtape

LooperAcid

Seven

Demo of a new track recorded using extensive use of my Glitch Delay module http://www.cutlasses.co.uk/uncategorized/glitch-delay-more-progress/

Koto

[LV]
Programmēts ar SuperCollider.

[ENG]
Made in SuperCollider.

CODE - http://sccode.org/1-56l-pPFc03pGOh

Pirmie Soļi v1

Pirmie Soļi v2

New Winter

Grasshopper Dub

Lorenz Attraction #brighton #electronic #music made by #LNX_Studio #SuperCollider @andyroid & @neil_cosgrove