ScalaCollider is a SuperCollider client for the Scala programming language.
It is (C)opyright 2008–2021 by Hanns Holger Rutz. All rights reserved. ScalaCollider is released under
the GNU Affero General Public License v3+ and comes
with absolutely no warranties. To contact the author, send an e-mail to contact at sciss.de
.
SuperCollider is one of the most elaborate open source sound synthesis frameworks. It comes with its own language
'SCLang' that controls the sound synthesis processes on a server, 'scsynth'. ScalaCollider is an alternative to
'SCLang', giving you the (perhaps) familiar Scala language to express these sound synthesis processes, and letting
you hook up any other Scala, Java or JVM-based libraries. ScalaCollider's function is more reduced than 'SCLang',
focusing on UGen graphs and server-side resources such as buses and buffers. Other functionality is part of the
standard Scala library, e.g. collections and GUI. Other functionality, such as plotting, MIDI, client-side
sequencing (Pdef
, Routine
, etc.) must be added through dedicated libraries (see section 'packages' below).
While ScalaCollider itself is in the form of a library (although you can use it from the REPL with sbt console
),
you may want to have a look at the ScalaCollider-Swing project that
adds an easy-to-use standalone application or mini-IDE. On the ScalaCollider-Swing page, you'll find a link to
download a readily compiled binary for this standalone version.
Note: An even more elaborate way to use ScalaCollider, is through SoundProcesses and its graphical front-end Mellite.
Please consider supporting this project through Liberapay (see badge above) – thank you!
The current version of ScalaCollider (the library) can be downloaded from git.iem.at/sciss/ScalaCollider.
More information is available from the wiki at git.iem.at/sciss/ScalaCollider/wikis/. The API documentation is available at sciss.github.io/ScalaCollider/latest/api.
The best way to ask questions, no matter if newbie or expert, is to use the Gitter channel (see badge above)
or the mailing list
at groups.google.com/group/scalacollider. To subscribe, simply
send a mail to ScalaCollider+subscribe@googlegroups.com
(you will receive a mail asking for confirmation).
The early architectural design of ScalaCollider is documented in the SuperCollider 2010 symposium proceedings: H.H.Rutz, Rethinking the SuperCollider Client.... However, many design decisions have been revised or refined in the meantime.
The file ExampleCmd.sc is a good starting point for understanding how UGen graphs are written in ScalaCollider. You can directly copy and paste these examples into the ScalaCollider-Swing application's interpreter window.
See the section 'starting a SuperCollider server' below, for another simple example of running a server (possibly from your own application code).
ScalaCollider builds with sbt against Scala 2.13, 2.12, Dotty (JVM) and Scala 2.13 (JS). The last version to support Scala 2.11 was 1.28.4. Note that because of an incompatibility between ScalaOSC and Scala.js, support for Scala.js is currently incomplete, and consequently some OSC related tests are not run under Scala.js.
ScalaCollider requires SuperCollider server to be installed and/or running. The recommended version as of this writing is 3.10. Note that the UGens are provided by the separate ScalaColliderUGens project. A simple Swing front end is provided by the ScalaColliderSwing project.
Targets for sbt:
clean
– removes previous build artefactscompile
– compiles classes into target/scala-version/classesdoc
– generates api in target/scala-version/api/index.htmlpackage
– packages jar in target/scala-versionconsole
– opens a Scala REPL with ScalaCollider on the classpath
To use this project as a library, use the following artifact:
libraryDependencies += "de.sciss" %% "scalacollider" % v
The current version v
is "2.6.3"
Please see the file CONTRIBUTING.md
The following short example illustrates how a server can be launched, and a synth played:
import de.sciss.synth._
import ugen._
import Ops._
val cfg = Server.Config()
cfg.program = "/path/to/scsynth"
// runs a server and executes the function
// when the server is booted, with the
// server as its argument
Server.run(cfg) { s =>
s.dumpOSC()
// play is imported from package de.sciss.synth.
// it provides a convenience method for wrapping
// a synth graph function in an `Out` element
// and playing it back.
play {
val f = LFSaw.kr(0.4).mulAdd(24, LFSaw.kr(Seq(8, 7.23)).mulAdd(3, 80)).midiCps
CombN.ar(SinOsc.ar(f) * 0.04, 0.2, 0.2, 4)
}
}
For more sound examples, see ExampleCmd.sc
. There is also an introductory video for
the Swing frontend
at www.screencast.com/t/YjUwNDZjMT, and some of
the Mellite tutorials also introduce ScalaCollider concepts.
Troubleshooting: If the above boots the server, but on Linux you do not
hear any sound, probably the Jack audio server does not establish connections between
SuperCollider and your sound card. The easiest is to use a program such as QJackCtl
to automatically wire them up. Alternatively, you can set environment variables
SC_JACK_DEFAULT_INPUTS
and SC_JACK_DEFAULT_OUTPUTS
before starting Scala, e.g.
export SC_JACK_DEFAULT_INPUTS="system:capture_1,system:capture_2"
export SC_JACK_DEFAULT_OUTPUTS="system:playback_1,system:playback_2"
Note: This section is mostly irrelevant on Linux, where scsynth
is normally found on $PATH
, and thus no
further customisation is needed.
You might omit to set the program
of the server's configuration, as ScalaCollider will by default read the
system property SC_HOME
, and if that is not set, the environment variable SC_HOME
. Environment variables are
stored depending on your operating system.
For example, if you run ScalaCollider from a Bash terminal, you edit ~/.bash_profile
. The entry
is something like:
export SC_HOME=/path/to/folder-of-scsynth
On linux, the environment variables probably go in ~/.profile
or ~/.bashrc
.
ScalaCollider's core functionality may be extended by other libraries I or other people wrote. The following three libraries are dependencies and therefore always available in ScalaCollider:
- UGens are defined by the ScalaCollider-UGens library.
- Audio file functionality is provided by the AudioFile library.
- Open Sound Control functionality is provided by the ScalaOSC library.
Here are some examples for libraries not included:
- Patterns functionality is available through the Patterns library, which
is supported through
SoundProcesses rather than vanilla ScalaCollider. SoundProcesses also
takes the role of more high-level abstractions similar to
NodeProxy
, for example. - MIDI functionality can be added with the ScalaMIDI library.
- Plotting is most easily achieved through Scala-Chart, which is conveniently included in ScalaCollider-Swing.