Tools for communicating with the SuperCollider music language environment

npm install supercolliderjs
2 downloads in the last week
5 downloads in the last month


Tools for communicating with the SuperCollider music synthesis language and directly with the SuperCollider synthesis server.

SuperCollider is an environment and programming language for real time audio synthesis and algorithmic composition. It provides an interpreted object-oriented language which functions as a network client to a state of the art, realtime sound synthesis server.

SuperCollider.js communicates with the language application and/or directly with the synthesis server, using OSC in both cases.

It contains code for use on a server (under Node.js)

and it also includes code for use in a webbrowser:

sc = new SCApi("localhost", 4040);"server.boot", ["default"], function() {
    // server is booted now"", [], function(groupID) {
        // spawn synths into this group"", ["scarysound", 100.0, 666.0, 7], function(synthID) {
            // enable things on the page to send control changes to the scarysound

Things you could do with this

Hooking up your JavaScript/processing.js app to easily trigger and control sounds from the Instr sound library. [no knowledge of SuperCollider required, just read the API and play with it]

Build dynamic localhosted web apps that communicate with your personal local copy of SuperCollider. Make use of the rich library of JavaScript graphics, networking and UI libraries. JavaScript on V8 in Chrome browser and in Node.js is significantly faster than SuperCollider and has a much larger array of development tools and documentation. WebKit has a full featured debugger with breakpoints and all of that.

Deploy webapps to a public server so that visitors can interact with your SuperCollider language based apps or can interact to play with sounds on the SC server. The server can be piped into Icecast and streamed back to the visitors or it could be used in an exhibition or gallery situation where everybody can hear it.

It uses which is loads of fun and should prove quite useful for installations and pieces that allow many people to interact with a single SuperCollider using mobile phones over normal webrowsers. Visitors can communicate with each other and messages can be broadcast to all joined parties.

Build standalone applications using App.js etc.

Communicate with the SuperCollider language via the API Quark

[webbrowser] =websockets=> [node api_server.js]

=OSC=> [API Quark in supercollider] =sc-calls-the-API=> [your API]

and then the reply:

[API Quark] =OSC=> [node api_server.js]

=websockets=> [browser]

In SuperCollider

// make sure you have the Quark

// enable the OSC in SuperCollider

This loads the APIs that come with the API Quark. See API below.

You can easily write APIs for your own application just by putting a file containing a dictionary of handlers in:


Start the Node.js web/api server

In a terminal start the webserver listening on localhost:4040

node api_server.js

Navigate to http://localhost:4040/

This is a webserver, a websocket server and an OSC client.

Index Screenshot

In the browser

javascript on that page connects to the api_server using websockets (ancient browsers will fallback to flash) which relays messages via OSC to SuperCollider's API Quark

sc = new SCApi("localhost",4040);"server.boot", ["default"], function() {
    // server is booted now"", [], function(groupID) {
        // spawn synths into this group

call returns a jQuery Deferred so you should be able to use libraries like async.

[TODO write examples of this]

Results are returned in JSON format so the SuperCollider APIs can return dictionaries and lists and these will be available as JavaScript objects in the return function.


At the moment the API quark exposes "interpreter.interpret" and "" which would allow all kinds of mischeif.

So you probably don't want to do this [1]:

gem install localtunnel
localtunnel 4040

Navigate to the URL it posts. Your laptop is now available on a public URL.

People will come and sniff your packets. Be forewarned.



See ISSUES on github

Calls will return jQuery Promises so that libraries like Q and Async can be used for chaining, waterfall, parallel etc. This is a coding style that is well suited to working with the SuperCollider server.

Support to send directly to scsynth without going through API and the language.



It receives JSON objects like {key: value, list: [1,2,3]} but at the moment doesn't send objects in requests. SuperCollider needs a solid and safe JSON parser. 3.6 has a YAML parser I think.

Mx, Instr and Patch will have full API support for web-based guis. Equivalents to Instr browser and the Mx patching interface that currently exist in SuperCollider (but are much slower there).

Develop the npm package more so the server code can be easily imported, extended, tweaked and reused.

Some way to either generate a project from a template or by forking a repo so that people can throw together sketches very quickly.

Command line args to the server.

Direct Communication with the Server

Initially all I've finished implementing is starting the server:

node boot-server.js

[Note for sc people: This is done as a proper child process so there is no need of the alive thread and guessing-game that SuperCollider language currently does. The death of the server is instantly known and never exagerrated.]


I had some problems with the OSC library I was using and am going to switch it to min-osc.

I'm not intending to replicate the SuperCollider language framework. I wrote or worked on many of the base classes for SuperCollider (Node Synth Group Bus Buffer etc) but they have become quite messy and have multiple usage styles piled on top of each other. Javascript is more flexible with mixins and prototypical inheritance so its easier to separate usage styles and keep packages clean.

The classes here will use Node's EventEmitter for Server and Synth/Group notifications.


This is probably out of date already:



For now its GPL like SuperCollider.

npm loves you