SuperCollider as a Modular Synth

A performance technique I don't generally employ a whole lot during Algorave-type sets using SuperCollider as a modular synth - and ProxySpace is very strong in this regard too. Each NodeProxy can be seen as an individual module, and each module can be plugged into others to create a complex network of interconnected musical and control elements. This is achieved by setting up audio (.ar) and control (*.kr) proxies - for more info on audio vs control rate see this and this

I can't really talk about this in any great depth, so here is an in-depth example of how SuperCollider can be used as a live-codeable modular synth. An important thing to note though is that if you want a lot of freedom in this approach, a lot of familiarity with types of UGens available (as well as some of the stranger quirks of SuperCollider syntax) will be very helpful.

//load setup

//run this to smooth out transitions

//Using SuperCollider as a Modular synth
//snippets help with building these sets a LOT, as standard elements such as modulation signals can be called upon very quickly
//NOTE: this will get !!! L O U D !!! - there's protection from StageLimiter of course, but be aware.
//NOTE II: There may also be some DC bias. Be prepared for this. more information here -

//a sine wave
~sin = {[80,82],0,0.5)}
//a pulse wave
~pulse = {[20,21],,1),0.5)}
//a new proxy multiplying sine and pulse waves
~sinpulse = { *}
//feed this into a delay with its delay line modulated slightly
~delay = {,1,,0.3),4)}
//increase the pulse speed and decrease the width, play it alongside the original
~pulse2 = {[40,41],,0.1),0.5)};
//actually no that would sound much better just in the delay, so ~pulse2 from playing and add it into ~delay by using
~delay = {[,]),1,,0.3),4)};
//now we have some drones, some heavily gated and filtered noise would be good.
~noise = {,,2000),,0.4),1)};
~noiseEnv = {,0.1),};
~totalNoise = {*};;
//oh no. it is mono. i'm going to pan it over 2.
//In order to make a mono proxy stereo, I will have to .clear it and then evaluate a stereo version, as the number of channels is set at initialisation time.
//luckily with Pan2 I will only have to re-evaluate the ~totalNoise proxy
~totalNoise = {*,};;
//the filtering on the noise isn't extreme enough, change it!
~noise = {,,2000),,0.2),1)};
//the noise could also do with some delay, which would sound nice if it was fed back through a pitch shifter:
//set up the delay, and play it
~noiseDelay = {[]),1,0.4,7,1)};
//establish the pitch shifter
~pitchShift = {,0.2,,2,}
//play the pitch shifter, it will slow the delay speed by half
//if we then put the results of ~pitchShift back into ~noiseDelay, then things get interesting.
//NB - this is bad practice and gets very loud before ending up in being DC bias, but i'm doing it here to prove a point.
//If you have super high end audio equipment or just don't want any DC bias then skip this step
~noiseDelay = {[,]),1,0.4,7,1)}
//in order to avoid this getting totally out of control, reduce the volume of ~pitchShift inside of ~noiseDelay
~noiseDelay = {[,(*0.11)]),1,0.4,7,1)}
//or modulate it to get varying amounts of feedback
~noiseDelay = {[,(*,0.2).abs)]),1,0.4,7,1)}
//modulating the delay time too will make things get a bit wild
~noiseDelay = {[,(*,0.2).abs)]),1,,0.6),7,1)}
//~noiseDelay seems to be glitching a bit and throwing DC bias - add a LeakDC around it
~noiseDelay = {[,(*,0.2).abs)]),1,,0.6),7,1))}
//let's cut the original pulse/sine waves over a few seconds
//then put them inside of a DFM1 that can self-oscillate
//make sure you evaluate ~noiseDelayAdd twice before you .play it
~noiseDelayAdd = {[,]),500,,2),1,0,0.03)}
//if you've evaluated the above line twice, play it
//a lot of these sounds are quite degraded, some harsh sounds would be nice, let's have some chaos
//go to the help file for Henon2DC and copy-paste the second example but don't evaluate it (you'll need sc3-plugins for this)
    2200, 8800,, 0.2, 1.2),, 0.15, 0.15)
) * 0.2 }.play(s);
//turn it into a node proxy and remove the .play(s) from the end
~henon = {
    2200, 8800,, 0.2, 1.2),, 0.15, 0.15)
) * 0.2 };
//make an envelope that has a long sweeping modulation on the amount of envelopes triggered
~chaosEnv = {,0.02),,10)))}
//and combine in stereo
~chaos = {*~chaosEnv)}
//it is SUPER quiet, up the volume on ~henon
~henon = {
    2200, 8800,, 0.2, 1.2),, 0.15, 0.15)
) * 3.5 };
//add some reverb which will work in parallel
//if you want to change the parameters of any effect without re-evaluating it - set up that value as another NodeProxy
~room = {30};
~time = {3};
~verb = {,~room,~time)}
//increase the reverb time
~time = {40};
//this needs some melody - add two melodies in stereo, slightly out of phase:
~saws = {[,1000).round(50),,1000).round(50)],0,0.3)}
//too harsh, needs filtering
~saws = {[,1000).round(50),,1000).round(50)],0,0.8),1000,0.8,0.6,10)};
//another delay would be nice
~sawDelay = {,1,0.5,10)};;
//some heavy decimation on the delay
~sawDelay = {,1,0.5,10),2200,10)};
//further bit reduction
~sawDelay = {,1,0.5,10),2200,5)};
//even further
~sawDelay = {,1,0.5,10),2020,3)};
//plugging the ~sawDelay into the original for more noise
~noiseDelay = {[,,(*,0.2).abs)]),1,,0.6),7,1))}
//plugging ChaosEnv into ~noiseDelay too
~noiseDelay = {[,,,(*,0.2).abs)]),1,,0.6),7,1))};
//then plugging it also into a more intense ~noiseDelayAdd for more mad effects
~noiseDelayAdd = {[,,~noiseDelay]),,10000),,100),1,0,0.03)}
//it doesn't appear to be playing, probablt because ~noiseDelay is SO loud. Multiply it by half
~noiseDelay = {[,,,(*,0.2).abs)]),1,,0.6),7,1)) * 0.3};
//then plug ~noiseDelayAdd into ~noiseDelay and roll off the multiplication for maximum damage
~noiseDelay = {[,,,(*,0.2).abs),]),1,,0.6),7,1))};
//increase the ridiculousness of the modulation of the delaytime
~noiseDelay = {[,,,(*,0.2).abs),]),1,,4),7,1))};
//put another delay on top of that?
~delay2 = {,1,0.4,30)}
//then plug that back into ~noiseDelay (which by now contains most things that are playing.
~noiseDelay = {[,,,(*,0.2).abs),,]),1,,4),7,1))};
//also modulate ~delay2, really slowly
~delay2 = {,1,,0.2),80))}
//things broke up for me here and I have no idea why, there's multiple things feeding back through each other here.
//and you have noise music!