This sound was generated using the following 140 characters of SuperCollider code. I post these at unpredictable intervals at www.twitter.com/headcube.

play{x=Saw.ar(0.7**lag(kr(n=LFNoise0,1/5),2)*[601,500,749]);Splay.ar({|i|x=x+BAllPass.ar(x,9**n.kr(a=1b**i)*2e3)+CombL.ar(x,1,a,8)/2s}!9@8)}

This is the first one for quite a while. I've worked on a few tweets in that time, but I wasn't really happy with most of them. I quite like this one though.

I felt like doing something with synth strings, minor chords, portmanteau and phasor effects. All of those elements made it into the final version. The phasor effect is achieved by adding an all pass filter (in this case BAllPass.ar, from the sc-plugins package) to the original signal, resulting in phase cancellation effects. This is repeated nine times (the "!9" near the end of the code) with a different cutoff frequency, and each time a delay effect is also added. I originally wanted the phasor frequencies to be swept with sine wave LFOs, but in the end (for reasons of the 140-character limit) I had to use a sample-and-hold waveform instead, so each frequency is static most of the time, and occasionally changes to a new random variable. You can hear interesting little clicking sounds when this happens.

This whole effects chain is applied to three separate sawtooth waves, which are slightly detuned from a frequency ratio of 10:12:15, which is a minor chord in just intonation. The root note of the chord is randomly chosen (with no regards to any scale) every five seconds, providing further evidence for my theory that if the sound is right you can just play completely random chords and it sounds good. At the end these three sound channels are panned across the stereo field (the Splay UGen).

As always, the intention here is to make a cool sound in 140 characters just for the sake of it, and this doesn't result in code that's remotely sensible or readable. However, if you do decide to try and understand it anyway, it might help you to know that the "@" notation is a syntax shortcut for getting an element of an array. So a@10 is the same as a[10]. So the "{…}!9@8" in this tweet means "evaluate the previous function 9 times and put the results in an array, and then get element 8 of that array". It's just a different way of writing "9.do{…}", which turned out to be slightly shorter in this case.

Finally, I find it quite satisfying that this tweet contains all the digits from 0 to 9.


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

This sound was *supposed* to be the audio from a tweet, but it seems I uploaded the wrong file by mistake. This is actually some sound I generated a long time ago from some code rather longer than 140 characters.

It works (if I remember right) by having a feedback loop, and then a bunch of pitch trackers trying to track and eliminate any sustained tones that build up. I'm kind of glad I found it actually, because I've since managed to lose the code that generated it.

I would delete the erroneous upload, but a couple of people clicked "like" within half an hour of uploading it - if people like it then I'll happily leave it up for a bit :)  (though having said that, it has two likes but zero plays, so maybe those are just bots or something.)

Some random sound from my hard drive

This sound was generated using the following 140 characters of SuperCollider code:

play{mean({|j|i=j+1;CombC.ar(x=0.5**i*Pluck.ar(a=Saw.ar(1/i+1/6),a,1,1/i/(3-LFPulse.ar(1/i))/30,9,1b/i),1,SinOsc ar:i+[4,9]*1e-3,0)-x}!9)/9}

I post these at unpredictable intervals at https://twitter.com/headcube 

I've been listening to a few songs recently that have a heavy chorus effect on the bass and/or guitar, and I felt like doing something similar in a tweet. I also recently wrote a 78-character implementation of http://whitneymusicbox.org/index.php?var=v1 (here it is: play{mean({|i|99**(-1-LFSaw.kr(i+1/180,1))*SinOsc.ar(i+1*55)}!48)!2} ). This works by just having every note repeat after a fixed interval, but the intervals are different for each frequency. This tweet works in a similar way, except that the notes also periodically move up and down by a perfect fifth, so the melody plays on the harmonics of two fundamental notes, one at  60 Hz and one a fifth above it, at 90 Hz.

The code synthesises nine voices, numbered from 1 to 9. (9 is the highest frequency and the lowest volume.) The guitar-like sound comes from the Pluck UGen, which is triggered by the Saw. The Saw's frequency is in the range 1/6 to 1/3 cycles per second, with the bass notes being triggered more often. The LFPulse moves the frequency up and down periodically.

Finally the CombC is used as a delay line to produce a cheap-but-effective chorus effect. I modulate its delay line (with a frequency of i, so the higher notes have more intense chorusing effects) and then subtract the original, non-delayed signal. (Subtracting rather than adding means that the effect also serves as a DC blocker.) A stereo effect is created by making the delay lines slightly different lengths in the left and right channels.

And that's it. The end result puts me somewhat in mind of the theme from Twin Peaks, which is no bad thing.

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

This sound was generated by the following 129 characters of SuperCollider code:

{play{x=Impulse.ar(0.05);20.do{x=LPF.ar(AllpassL.ar(LeakDC.ar(x),4,8**kr(n=LFNoise2,0s)/2,8)*1.2,8**n.kr({0s.rand}!2)*2500,1).tanh};x*5}}!4

I post these at unpredictable intervals at twitter.com/headcube

This one takes an impulse (once every 20 seconds) and then applies a series of different delay lines, filters and distortions to it until it sounds a bit like surf breaking on the stony beach at Brighton, England, where I used to live. It also makes me look forward to this summer, when I will continue my new hobby of surfing. 

Normally I wouldn't post something like this - it's basically just filtered noise after all - but at some point I made a little tweak and the stereo imaging suddenly became really intense, at least when listened through headphones. 

The only problem was that sometimes the "waves" would seem to be breaking from far away to the left, and sometimes far away to the right. That's a bit unnatural, so I put the "!4" at the end, which makes four identical copies of the same synth. Four seems like a good balance between evening out the stereo somewhat, without just getting rid of it entirely.


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

A warts-and-all recording of my gig at Spirit of Gravity in Brighton last week.  It could do with a bit of cleaning up and limiting a bit, which I might get around to at some point.

Live electronics, implemented in SuperCollider and controlled using joysticks.

Someone came up to me after the gig and said it sounded like an alien space ship had crashed into an alien planet and the distress beacon had gone insane from loneliness and was making that noise for ever.  Which is a fair description I reckon :)

100114 Live at Spirit of Gravity

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)

This sound was entirely generated by the following 139 characters of SuperCollider code:

<code> play{f=({|i|DelayC.ar(0-LPF.ar(InFeedback.ar(2+i),2000).tanh,1,1.5**i/4e3)}!6);Splay.ar(f)++(Dust.ar(f*2e4+1)*LFSaw.kr(3/4**(0..5)/8)/5+f)} </code>

I post these at unpredictable intervals on Twitter (@headcube).

Some technical details for the interested: This code creates six feedback delay lines operating in parallel (independently from one another), each approximately a perfect fifth above the last. Some nonlinearity is provided by the tanh function, and they're excited by some noise from the Dust UGen, whose frequency is also modulated by the fed back signal, giving a breathy flute-like sound. The amplitude of the feedback in each delay line is modulated at a different tempo, such that it will never quite repeat. The overall effect vaguely reminds me of Brian Eno's ambient stuff.


SuperCollider tweet from 7/10/2012

This piece was generated using only the following 140 characters of SuperCollider code (http://supercollider.sourceforge.net/). I post these at unpredictable intervals on Twitter as @headcube.

play{ar(r=RLPF,Saw.ar([200,302]).mean,5**(n={LFNoise1.kr(1/8)})*1e3,0.6)+r.ar(Saw ar:Amplitude.kr(3**n*3e3*InFeedback.ar(0)+1,4,4),1e3)/5!2}

Sonically, this piece is very simple - it's just a filtered sawtooth wave playing against a drone, which is also made up of filtered sawtooth waves (Twitter user @DanieleTatti called the result a "Scottish raga", which I think is fairly apt). But its frequency keeps changing, sometimes hitting harmonics of the drone and sometimes wavering around them in interesting ways. How does it do that?

Lately, I've been reading about cybernetics (specifically, I'm reading the really rather excellent book "The Cybernetic Brain" by Andrew Pickering - http://www.amazon.com/The-Cybernetic-Brain-Sketches-Another/dp/0226667901/), and it's got me thinking about homeostasis and feedback-based control systems. In this code, the oscillator listens to the output sound (that is, the drone combined with its own output), and chooses its frequency based on the overall amplitude of this signal. (That's the second "Saw" UGen, and the "Amplitude" and "InFeedback" ones.) The Amplitude UGen has a bit of a time lag in it, so what happens when the drone and the oscillator are out of phase, the oscillator's frequency decreases over time, whereas when they're in phase (and hence louder), the frequency increases. For reasons I understand intuitively but would have a hard time showing mathematically, this tends to result in the system falling into stable states where the frequency of the drone and the oscillator are in a nice integer ratio.

There are several sources of variation, which prevent the oscillator from remaining in the same frequency all the time. The output of the amplitude tracker is multiplied by a slowly changing value before being sent to the oscillator's frequency; but also the drone has some variation in it, and the system is sensitive to this as well. The drone has a slowly changing filter, and it consists of two tones at frequencies 200 and 302 Hz, which isn't quite a perfect fifth, so there's a beat frequency of 2 Hz. Sometimes you can hear the oscillator doing a slow vibrato as it responds to these beat frequencies.

It was quite a lot of work to fit this idea into 140 characters. I originally had a 200-ish character one that was a lot more complicated, but in the end I think I prefer this one.

SC tweet from 28.11.2012

This sound was generated using the following 140 characters of SuperCollider code. I post these to Twitter at unpredictable intervals as @headcube.

play{CombL.ar(InFeedback ar:0,1,1/4,9).sin+Pluck.ar(ar(n=LFNoise1,400),a=LFNoise0.kr(1/2),1,1/a.abs/200,99)*SinOsc.ar(n.kr(1/8)*[6,6s])*0.8}

There's no particular special story to this one, other than I felt like doing something with tremolo, delays and plucked string sounds. I added a potentially-chaotic texture generating feedback loop for good measure.

The plucked string sounds come from SuperCollider's "Pluck" UGen, which implements the Karplus-Strong algorithm, which is a very simple physical model. This is set to play notes at random frequencies every now and then, which are fed into a feedback delay line that contains a randomly varying tremolo effect and a little nonlinearity from the .sin method. If the randomly varying frequency of the tremolo happens to line up with the length of the delay then the delay line's gain can be greater than one, resulting in howling chaos. This happens about halfway through this recording.

The overall effect is vaguely horror-film-soundtrack-ish. I like the way that the combination of tremolo and delay sometimes adds up to something that sounds more like a chorus.

SuperCollider tweet from 13.12.2012

This sound was generated with the following 140 characters of SuperCollider code:

play{Splay.ar(a={|i|RLPF.ar(Trig.ar(InFeedback.ar(i+[-1,1]%6+2).sum.abs.lag(1e-3)<1e-4,8e-3),{2**10.rand*20}!4,1e-3,0s).mean.sin}!6,0.5)++a}

I post these at unpredictable intervals on Twitter at twitter.com/headcube 

In all honesty I don't know for certain how this works. I started out with one idea and tweaked it and tweaked it until it was completely different. However, I can offer a hypothesis. It's interesting because there's quite a bit of variation in the sound, over many different time scales, but there's no LFO or noise source in there to make it vary - it does it all by itself, deterministically.

What I do know is that this code defines six different resonators. Each consists of an excitation signal (about which more later) followed by four parallel resonant filters. The resonance frequencies are chosen at random, but they're all octave multiples of 20 Hz. (The frequencies are chosen randomly at the beginning, but remain fixed afterwards, so the overall character of the output is different every time the code is run.)

The six resonators are arranged in a ring, with each one "listening" to its two nearest neighbours. I think what happens is that the excitation signal tends to be generated only when the signal from the neighbours is oscillating at a very low amplitude. So after a note finishes sounding, its oscillations decay to inaudible levels and its neighbours will begin to sound.  They stop once the original note decays to such a low volume that the excitors are no longer triggered, but then this will cause their neighbours to start sounding, and so on. But the pattern never quite seems to repeat.

However it works, the result is that the six resonators "take it in turns" to sound, sometimes playing long sustained tones for up to a couple of minutes before another one takes over. I find it can produce quite interesting musical structures - it's worth listening to it in SuperCollider so that you can hear it run for more than just a couple of minutes. (I'd upload a longer recording but I don't want to run out of space on SoundCloud.)

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

This sound was produced using on the following 140 characters of SuperCollider code

x=(1..8);y=scramble(8/x);z=y/.x y;d={|d,a|Duty.ar(d,0,Dseq(a,inf))};play{d.(d.(0.16,z*.x z)/4e3,z)/5-d.(d.(0.04,x*2)/8e2,[0,1])/3!2}//#sc140

I post these at unpredictable intervals at http://twitter.com/headcube

I was just going through some old attempts at SuperCollider tweets, and I found this one lying around that I thought was pretty awesome. I think the only reason I didn't post it ages ago is that I was obsessed with trying to add a hand clap / snare drum type of element, but I could never fit one into the 140 characters. I probably wrote it in late 2010 or early 2011.

This code uses some cleverness that I no longer fully understand to produce two different waveforms, one playing a weirdly fractal melody and the other emulating a sort of distorted kick drum, all using just Duty and Dseq. These are non-antialiased waveforms and there's no space in the code for any filters or envelopes, so it has a very 8-bit sort of sound. It has a different melody and a slightly different timbre every time you play it, due to the use of the "scramble" method. It also sometimes goes hilariously out of tune, but I think that adds to its charm.

One thing to bear in mind if you do try to decipher this code is that "*.x" is a special syntax, found in SuperCollider's "J_concepts_in_SC" help file. The "x" in "*.x" is the name of a spcecial method - it doesn't refer to the variable "x" that's declared at the beginning of the code.

chiptune style SuperCollider tweet from 7.1.2013 (see description for code)

This sound was generated using the following 140 characters of SuperCollider code. I post these at unpredictable intervals at www.twitter.com/headcube.

play{Splay.ar(x=sin(CombL.ar(LPF.ar(InFeedback.ar(20,99),2e3),1,LFNoise1.kr(1e-3!99)+1/99,0.05)+Dust2.ar(0.01!99)))++(0!18)++(x-x.rotate/2)}

This code creates 99 separate feedback loops, which are panned across the stereo field. Each one has its own comb filter delay line, with its own random, slowly varying delay time. Its output is fed back into its own input, and also into the input of the next feedback line along. A little random noise (Dust2) gets things going, and a sin function provides limiting and nonlinearity.

The effect sounds like a ridiculous orchestra of random woodwind instruments (but mostly penny whistles) who can't quite seem to get their instruments in tune. After a while tends to settle into something a bit less chaotic. Because of the random numbers, it can behave in several different ways, but in this recording it quietens down a bit and the instruments start playing distinct notes in a subtly varying rhythmic sequence.

SuperCollider tweet from 12.1.13

I'm a scientist studying complex systems and the origins of life - but in my spare time I'm also an experimental musician. Most of the pieces here are SuperCollider tweets, which means sound generated by 140-character pieces of code written in a language called SuperCollider. I post them at https://twitter.com/headcube .

Most of these will go on generating sound forever, but I usually fade them out after a couple of minutes. All of them are available under a do-what-you-want-with-them-as-long-as-you-give-me-credit license. I'm happy to supply longer recordings on request.

Nathaniel Virgo

Popular tracks