Supercollider on Mads Kjeldgaard — Composer and Sound Artist

Hyphal

Mon, 01 Sep 2025 00:00:00 +0000

‘Hyphal’ is a piece of algorithmic music for mechanically controlled pipe organs, commissioned by Gamut INC for Aggregate Festival, premiering at the Kaiser-Wilhelm-Gedächtniskirche in Berlin in 2025.

This piece was composed during a stay in the Pyrenees mountains on the border between France and Spain where I spent a lot of time in a mountain valley with an overwhelmingly lush microclimate. Where it seemed that out of every crack or orifice in the landscape, plants and flowers of all kinds would emerge, as if to collectively scream “I am alive!”

Empty Cloud

Thu, 13 Feb 2025 00:00:00 +0000

An enormous cycle of minimalist, ambient background music composed in 48 parts, spanning 12 hours, taking you on a peaceful stroll around the circle of fifths. Released by Exformal Records. To read more and listen to the release, go here.

The music of Empty Cloud was written and composed specifically to be played in the background in a room, quietly, or at least ideally at a barely audible volume. It’s music that’s just there, plain and simple, and if you forget about it, it’s fine, don’t worry, it will let itself be known when it needs to.

Musik for virtuelle orgler

Sun, 09 Jun 2024 00:00:00 +0000

A collection of algorithmic music written for virtual organs – that is, musical structures based on simple mathematics and probabilities and organised in ever-evolving patterns of ungraspable and unrelenting melodies and chord progressions. All the pieces were produced using programming languages and very accurate software models of pipe organs.

Composed, mixed and mastered by Mads Kjeldgaard.

Design: Tony Lugo.

Released by SuperPang.

Click here to hear more

Workshop: Composing 3D music using SuperCollider and ambisonics

Thu, 22 Sep 2022 00:00:00 +0000

Date: 1st of October

Place: LMTA Musical Innovation Studies Centre, Vilnius, Lithuania

Price: Free

Workshop material: Download on Github (will be available from the day of the workshop)

Address: Gedimino pr. 42 LT-01110 Vilnius, Lithuania

As part of the Envelope Festival, an immersive sound festival happening from September 10 till October 29 in the Baltic-Nordic region in person and online, I will be teaching a workshop on how to write algorithmic music for 3D sound systems (ambisonics) using SuperCollider.

Parallel processing in SuperCollider using SuperNova

Thu, 10 Feb 2022 09:20:36 +0100

The SuperCollider sound server scsynth is one of the most finely tuned and efficient synthesis engines out there. For most people on most modern computers, they will rarely meet limitations in terms of effeciency.

That said, scsynth does have one potential for optimization: Parallelization. And this is where supernova comes into the picture.

The original scsynth sound server in SuperCollider, like lots of other audio software, runs on one core and so your computer’s single core performance is a big limitation for the possibilities of scsynth.

Neovim as a SuperCollider IDE

Wed, 02 Feb 2022 14:01:46 +0100

SuperCollider is my favourite programming language for music and sound and I use it all the time. The programming language comes with an IDE that is quite capable, but I for one prefer doing all of my coding in one editor (sometimes I write C++, lua and SuperCollider in one and the same project and this allows me to do it in just one editor instance) and that editor for me is NeoVim. The advantages of (Neo)Vim are many but for me the primary ones are that it is a keyboard centric tool, it’s lightweight, it is highly configurable and it works everywhere.

Tutorial: How to write plugins for SuperCollider using C++

Thu, 18 Mar 2021 22:09:08 +0100

My amazing workplace allowed me time during the Covid-19 lockdowns in Oslo to spend time improving my C++ and DSP skills. The result of this is a bunch of plugins for SuperCollider, some of which are already released as well as a trunk of Notam plugins that are to be announced.

The process of creating server plugins (aka UGens) for SuperCollider is one of the most fun and gratifying ways one can experiment with DSP and C++ in my opinion. That said, getting started with it was a difficult task for me since the different resources on the process of creating plugins for SuperCollider were either spotty or out of date and did not include some of the best practices involved in creating high quality plugins.

Automatically build, compile and release SuperCollider plugins using Github Actions

Wed, 03 Mar 2021 18:22:34 +0100

Since the main SuperCollider github repository moved to using Github Actions to automatically build, compile and release cross platform, I felt intrigued to use the same technology to do the same for SuperCollider plugins.

There is a number of amazing SuperCollider plugin repositories on Github - a lot will demand that the user compiles the sourcecode themselves to use the plugins. For people used to CMake and/or a Linux-ey workflow of compiling, this is not a big problem but for a lot of others (most people perhaps), it really is a doorstopper.

A midi controller in a box of screws

Sat, 06 Feb 2021 21:16:09 +0000

I recently built version 2 of a “master volume control” midi controller that I had made before. This version is slightly improved on the former, the main improvement being that if you press the button while booting the device it goes into 14 bit midi mode (leveraging 13 of the Teensy’s bits for this) to allow high resolution on the potentiometer’s input.

The controller is very cheap and simple to make. It revolves around the wonderful and cheap (11$) Teensy LC.

Helpful SuperCollider plugin macros

Fri, 13 Nov 2020 21:38:31 +0100

This is a transcription of Dan Stowell’s very helpful table in the SuperCollider Book (MIT), slightly edited and transcribed for the “new” c++ style for writing plugins. It contains some of the macros available when writing UGens/Plugins in c++ in SuperCollider.

This repo contains example code for writing plugins in both the “old” and “new” style which I found helpful in understanding this subject.

Also check out this cookiecutter template for generating plugins and the Server Plugin API.

Esp32 Simple Osc Receiver

Mon, 09 Nov 2020 16:29:19 +0100

Lately I have started experimenting with the very cheap and powerful ESP32 microcontrollers.

Today I made a simple example of a firmware which receives OSC from a computer and then blinks the on-board LED according to the incoming message and I packaged it all as an easy to clone/copy/use platformio project (mostly for myself).

The firmware uses CNMAT’s OSC library:

#include "Arduino.h"
#include "WiFi.h"
#include <OSCMessage.h>

WiFiUDP Udp; // A UDP instance to let us send and receive packets over UDP
int LED_BUILTIN = 2;

// Options
int update_rate = 16;

// Network settings
char ssid[] = "wifiname"; // your network SSID (name)
char pass[] = "wifipassword"; // your network password
unsigned int localPort = 8888; // local port to listen for OSC packets

void setup() {
 pinMode(LED_BUILTIN, OUTPUT);

 /* setup wifi */
 WiFi.begin(ssid, pass);
 while (WiFi.status() != WL_CONNECTED) {
 delay(500);
 }

 Udp.begin(localPort);
}

void ledtoggle(OSCMessage &msg) {
 switch (msg.getInt(0)) {
 case 0:
 digitalWrite(LED_BUILTIN, LOW);
 break;
 case 1:
 digitalWrite(LED_BUILTIN, HIGH);
 break;
 }
}

void receiveMessage() {
 OSCMessage inmsg;
 int size = Udp.parsePacket();

 if (size > 0) {
 while (size--) {
 inmsg.fill(Udp.read());
 }
 if (!inmsg.hasError()) {
 inmsg.dispatch("/led", ledtoggle);
 } 
 //else { auto error = inmsg.getError(); }
 }
}

void loop() {
 receiveMessage();
 delay(update_rate);
}

And here is some SuperCollider code to play around with:

Working with 14bit Midi using a Teensy microcontroller and Supercollider

Wed, 21 Oct 2020 15:48:28 +0200

Lately I have been experimenting with 14bit MIDI and found it to be a huge revelation for my work with SuperCollider. Often, the regular data range of MIDI (0-127) is way too choppy and coarse for nice interactions with your systems and instruments in SuperCollider, but 14 bit MIDI provides a resolution of 16384 steps which is great. This is actually achieved quite cleverly by combining two MIDI CC signals in to one.

Networked audio using Raspberry Pi 4 (zita-njbridge and SuperCollider)

Sun, 03 May 2020 10:17:27 +0200

Jack is an incredibly flexible piece of software for making audio connections. It’s mostly used to connect and patch virtually within one computer but it has a range of amazing extra features for connecting things in alternative ways.

This is exploited to it’s fullest in the zita-njbridge package.

To quote from the manual on zita-njbridge:

The zita-j2n (sender) and zita-n2j (receiver) applications allow to exchange up to 64 channels of full-quality uncompressed audio streams between two or more systems running the Jack audio server. Sender and receiver(s) can each have their own sample rate and period size, and no word clock sync between them is assumed. The receiver uses adaptive resampling to convert the audio stream(s) to its local sample rate.

Notes for setting up a Raspberry Pi 4 for audio work

Thu, 30 Apr 2020 16:07:22 +0200

These are notes for setting up a Raspberry Pi 4 single board computer for pro audio work. Specifically for running SuperCollider programs for interactive installations.

I used Raspbian Lite for this, since my intention is to run the Raspberry Pi in headless mode, meaning using no display and no desktop environment (to save resources).

It is presumed that you have installed Raspbian on an SD card, with ssh enabled (allowing you to log in to the pi over the network and execute commands using a terminal), and that you are logged in.

Awesome SuperCollider: A curated list

Thu, 30 Apr 2020 12:57:31 +0200

A while ago I started compiling a list of links to SuperCollider based things that I found interesting and wanted to save for later.

The list grew and at one point I organized it all in one public repository where the SuperCollider community could help curate links to awesome SuperCollider things and it has since then become a truly rich resource for things like tutorials, reading material, nice projects and tools.

SuperCollider workshop at Notam, january 2020: Algorithmic composition using patterns

Thu, 23 Jan 2020 21:18:29 +0000

Here are the slides for the SuperCollider workshop at Notam, january 2020.

Download slides

Algorithmic composition using patterns

Notam, january 2020

About me

Name: Mads Kjeldgaard
Occupation: Composer and developer
Work: The Norwegian Center for Technology and Art (Notam)

Notam

Development for art projects (hardware, software, tech and artistic guidance)
Communities / meetups (SC meetup among others), see website notam.no
Studios / 3D sound / VR / Visuals / Electronics
Courses

My practice

Computer music / livecoding
Concrete music
Cybernetic / systemic music

Contact info

About algorithmic composition

What is an algorithm?

An algorithm is a process that takes something as an input, computes on it, and then outputs the result.

Pattern workshop, Herlev Bibliotek 2019

Wed, 06 Nov 2019 11:22:54 +0000

Here are the materials for the SuperCollider workshop at Herlev Bibliotek, Denmark, November 2019.

The SynthDef used for the workshop [can be downloaded here.][1]

Download slides here.

SuperCollider workshop

Herlev Bibliotek, Denmark, 2019

About me

Name: Mads Kjeldgaard
Occupation: Composer and developer
Work: The Norwegian Center for Technology and Art (Notam)

Notam

Development for art projects (hardware, software, tech and artistic guidance)
Communities / meetups (SC meetup among others)
Studios / 3D sound / VR / Visuals
Courses

My practice

Computer music / livecoding
Field recording
3D sound composition
Sound environments

Contact info

Design

Short history of SuperCollider

SC was designed by James McCartney as closed source proprietary software

How to change the default synth in SuperCollider

Fri, 18 Oct 2019 12:42:12 +0000

The default synth sound in SuperCollider is a cheesy old piano sound. If you have ever tried the event pattern examples in the documentation of SuperCollider or been in the process of testing some pattern specifics of your own, you will have heard this extremely unconvincing synthesizer:

A nice alternative: A triangle wave synth with a low pass filter

Imagine a utopian world where the default cheese-piano-synth has been replaced by a nicer, kind of gameboy like synth. Well that world is here and now.

Introduction to SuperCollider, Notam 2019

Sun, 01 Sep 2019 12:54:46 +0000

Here you will find the material for the introductory workshop held at Notam, Oslo in late summer 2019.

The slides may be used as a sort of cheatsheet as well as notes for remembering the topics covered:

• An overview: What is SuperCollider and what can you do with it?

• The design and architecture of SuperCollider

• Language basics: syntax, variables, expressions and functions

• Learning resources: How to proceed from here

SuperCollider tutorial: Mass producing SynthDefs

Mon, 19 Aug 2019 10:36:35 +0000

In SuperCollider, one of the most common ways of making sounds is by first defining a sort of recipe for a UGEN patch in a SynthDef and then from that recipe produce Synths that make sounds.

But when you write a SynthDef, the patch architecture cannot change after the definition (as opposed to changing arguments in the patch).

This becomes annoying when working with UGens that want to know the exact number of channels used, eg. PlayBuf, when defining the Synth.

SuperCollider tutorial: Easily render generative compositions as sound files using NRT

Mon, 05 Aug 2019 17:46:09 +0000

One of the many powerful features of SuperCollider is it’s ability to render sounds offline. This is called Non-Realtime Synthesis (NRT). NRT is for example useful for fast, offline processing of sounds, doing sound analysis or rendering generative compositions.

NRT works like this (normally): First you write a list of server OSC messages (stored in a Score usually) which will tell the (offline) server what to do at what point in time when you decide to render it. These are in the format [beat, [osc_command]]. An example: Making a Synth using synthdef \boring_sine at beat number 2 looks like this in such a OSC form: [2.0, [\s_new, \boring_sine, 1001, 0, 0]]