Welcome one and all to this SuperClean InstallParty.

SuperClean is a SuperCollider framework which easily provides access to some basic utilities inside of SuperCollider itself. Not only can you play back all of your samples without needless hassle in an environment that can grow with you. SuperClean also contains a bunch of synths and a very flexible routing system.

SuperClean is, in short, a one-stop-shopping-experience for folks who want:

• An MPC,
• a bunch of synths,
• a whoole lot of effects, and,
• a flexible routing system

for the low, low asking price of: Free! Free as in costs nothing but more importantly, free as in breaking out of jail kind of free. Also, on a personal note here, hey, this is what I use to make music with every day. I really like making music and, for me, this makes it way funner. Try it! What have you got to loose?

Let’s go ahead and download SuperCollider, SuperClean and the SC3 plugins:

If for some reason there is some kind of snag regarding that whole downloading stuff from The Public Internet maneuver, raise your hand and I’ll come over with a USB for you. If we are not in the same room, then let me know through email and I’ll sort you out. You can find my email on my index page. Now boot up SuperCollider.

Next let’s go to File, Open user support directory. This is a hidden place on your computer. If you ever need to get back here then, now you know how. Grab hold of the folder called sc3plugins and the SuperClean folder and drag them both to the Extensions folder. Click your way into the SuperClean folder. Now open the file superclean_startup.scd and copy that whole mess of text. Go to File, Open startup file, paste into there. Save the file. Quit and then start up SuperCollider again. That should do it!

Let’s try it out by opening examples.scd which is also located in the SuperClean folder. Any time after starting SuperCollider you see the message [ SuperClean up + running ] that means everything is ready to go. Put the text cursor inside a code black and run it by pressing cmd + Enter. At this point you should hear something. If no go, take a look at the video walkthrough below. If still no go, I can come over to help you, or let me know through email and we can work something out that works for you.

Now that everybody is up + running the sky is the limit! We could literally have any sound arrive at any time. Go forth in thrash! Really looking forward to hanging out and getting into SuperClean together. Don’t be a stranger!

Check this project out on github

Here’s a lil piece of boilerplate code to get us started:

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \sin,
    ])
).play
)

Now, what that lil sucker does is give us a comfortable interface. With this we can put the text cursor anywhere inside of the outermost parantheses and evaluate it with Command Enter, and it goes. It does the bleeps forever. How do we stop this thing? That’s Command + period (the little dot at the end of a sentence). Next we see Pdef which gives us a running pattern definition. We can redefine this stream of musical events, while it’s running. To me this is essential, otherwise I get annoyed at how clunky the workflow is. Let’s do a quick redefining of what we are hearing. First get the pattern started, then, while it’s running, overwrite \sin with saw\ and then reevaluate. This changes what we are hearing. SuperClean has a bunch of synths available to us. We just redefined our running pattern from making sine wave bleeps to saw wave bloops. Next in the boilerplate code block is Pbind which binds the parameters in the left column to the values in the right column. The colon character is in the middle, between the two columns, keeping them separate. The first parameter in the left column is type and we set that value to \cln in the right column. I like to think of this as the on button for SuperClean. This tells SuperCollider to make everything SuperClean has to offer available to us in this block of Pattern code. The next parameter in the left column is snd which stands for sound and refers to either the name of a synth or the name of a folder containing samples. Let’s set that to \mmd and evaluate. Now, what that does is play the zeroth file in a sample folder called mmd. This folder is inside of the SuperClean folder that we dragged to the Extensions folder earlier. The folder contains thirteen short drum synthesis sounds that I made on my Micro Modular. They are only 10Mb all together and they get loaded into RAM when SuperClean boots up. I put those in there as a utility. They are good for getting started quickly and trying stuff out with samples. Let’s add a new parameter so we can control which file inside this folder gets played.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: 1,
    ])
).play
)

Oh hey now that made the sound change didn’t it? We’ve set the sample player to the second file in the folder. Go ahead and change this number a bunch of times to audition all of the different samples in that folder. As you were doing that did you notice that the thing counts from zero and that there are 13 samples in the folder and also that it wraps around so that the value 0 and the value 13 trigger the same sample. That’s how that works. Let’s do some linear sequencing with Pseq.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Pseq([1, 7, 9, 11, 12, 6, 5], inf),
    ])
).play;
)

But this is so boringly slow. Let’s make it faster.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Pseq([1, 7, 9, 11, 12, 6, 5], inf),
        dur: 1/8,
    ])
).play;
)

Alright that’s better, but now it’s beginning to bore me again because it’s just the same thing over and over again. Let’s fix that by introducing a new pattern object that does stochastic sequencing, Prand:

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([1, 7, 9, 11, 12, 6, 5], inf),
        dur: 1/8,
    ])
).play;
)

I want more variation so let’s add another parameter. amp will let us vary the amplitude. Let’s also get Plprand in there as a new Pattern object. This one is a nice pairing with amplitude because reasons.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([1, 7, 9, 11, 12, 6, 5], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
    ])
).play;
)

Nice to have some dynamics going. Next I want to add some panning and I’ll pair that parameter nicely with Pmeanrand which prefers the middle of the value range.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([1, 7, 9, 11, 12, 6, 5], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
        pan: Pmeanrand(0.0, 1.0),
    ])
).play;
)

You might want to know how the change “the BPM”, but do you really though? This will change it globally, for all patterns, until you recompile:

TempoClock.default.tempo = 128/60;

I think it’s way nicer to just change this per pattern with stretch

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([1, 7, 9, 11, 12, 6, 5], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
        pan: Pmeanrand(0.0, 1.0),
        stretch: 0.75,
    ])
).play;
)

Setting stretch to 0 is infinitely fast and setting stretch to 2 is half tempo. Using stretch opens up a door to polytempic music and musics that morph fluidly between different tempos. Imagine that for a minute. Wild right? Here’s an example of two patterns starting at the same time and slowly drifting out of phase with each other because they have slightly different stretch values.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([1, 7, 9, 11], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
        pan: 0,
        stretch: 1,
    ])
).play;

Pdef(1,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([12, 6, 5], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
        pan: 1,
        stretch: 1.01,
    ])
).play;
)

You can reevaluate the above pattern block to make the two patterns start over in sync. When you’ve had enough you can run this nifty little “remote control” code block to stop both Pdefs at the same time and let them ring out. Notice how this is different from stopping things with Command + period. This will become more apparent when we use longer sounds.

(
Pdef(0).stop;
Pdef(1).stop;
)

Actually come to think of it, let’s take care of that now by adding a sustain line with the value 99. I do this because I know that 99 seconds is for sure longer than any of these samples. Later on we could look at making something which adapts the sustain to changing conditions, but for now this works. Just be aware that this quick fix could eat up a lot of CPU if we for example have a very short dur value, which leads to a lot of samples playing really fast and ending up layered on top of each other.

(
Pdef(0,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([1, 7, 9, 11], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
        pan: 0,
        stretch: 1,
        sustain: 99,
    ])
).play;

Pdef(1,
    Pbind(*[
        type: \cln,
        snd: \mmd,
        num: Prand([12, 6, 5], inf),
        dur: 1/8,
        amp: Plprand(0.25, 1.0),
        pan: 1,
        stretch: 1.01,
        sustain: 99,
    ])
).play;
)

∞