Surmulot: open software for musical composition
by Stéphane Rollandin
current version is pre-10 (csound-x 2.18, muO 235) of March 7, 2010
download
documentation
Introduction
Surmulot is the integration of a set of home-made tools for musical composition. While implemented in different languages, they share a few common principles: open source, cross-platform (well at least Windows, Linux and MacOS), high-level (manipulation of abstract concepts), interactive (everything can be modified in real time, no compilation step), experimental.
These tools are:
Because Surmulot is in no way easy to master, it will not be of interest to everyone.
More specifically, you should be aware of the following points:
- Programmation skills are required, especially in Emacs Lisp and Smalltalk. Note that studying these languages is by itself a very rewarding experience which brings deep insights into the very nature of computer science. There are not difficult to learn; you just need an open mind and maybe at times set aside what you know about programming.
- All documentation is in english. This means no french documentation, sorry; it would require a LOT of work.
- The system is not oriented toward real-time composition nor public performance.
- Usual or academic musical notions are mostly ignored; we are exploring a dimension of music where the main composition structures are algorithms. Some people won´t even call this music.
- Backward compatibility is not ensured. The very open nature of the tools makes it difficult to guarantee that a given composition will be easy to port from one version of Surmulot to the next one. This is a very complex topic.
- The whole system is a very personal creation. It is not backed by any musical school nor foundation nor theory nor group of composers; it is just me. You may very well not like my approach of music or programming ...
- Surmulot is and will always be in beta stage. It will never be stable and clean on its own, although a component such as Csound-x can be considered reliable.
Provided that you feel at home with the previous points, here is what Surmulot will give you:
- A fully documented playground for wild experimentation.
- An extensible system that will grow and change according to your interests.
- Strange ideas about what musical composition can be.
- Fun :)
Notes on the development of Surmulot
Motivation
All software discussed in this page have been developed for personal usage, in order to play with musical composition ideas. Since I am not a musician those ideas are a bit weird. You can ear actual music and noise produced this way in the following pages: condiments pour silence, rivière, variations for pianos and no past no future.
Why open-source, multi-platform, high-level languages ?
Open source is a requirement for me. First of all I have no money to put into musical software. Then I want a total control of my tools. Also, very often open source code is easily portable across platforms. While currently developping under Windows Vista, soon or later I will go Linux so the tools are to be ready for this change.
High-level interpreted languages (here Lisp, Smalltalk, Keykit) free the user/composer from the compilation step, making the code modifyable on the fly and thus keeping the whole environment alive. They also make complex musical ideas much more easy to implement than, say, C. Finally, they are also more portable than low-level code.
GeoMaestro
GeoMaestro for Keykit has been my first composition environment.
Keykit by itself is a major place for MIDI composition. It provides easy manipulation of musical phrases, easy programming of algorithmic composition procedures. It comes with many toys allowing real-time interaction with automatically generated material.
This was not what I was into though, so I developped a non-realtime composition method, based on a specific, 2-dimensional, representation of notes, where rhythm is described as a set of geometrical objects and their variations, while the interaction between these objects and the static 2D notes is highly customizable. This idea was called GeoMaestro, but the eventual code also includes another environment, called the Composer, where boxes representing arbitrary musical data can be linked together to form a whole structured composition.
At this stage I was dealing with a lot of non-MIDI data, such as sound files and Csound scores and orchestras, so Keykit became limited and I decided to continue this developement with Squeak. Still, Keykit is by far the best place for doing anything MIDI, so I kept it tightly integrated with the other environments.
Csound-x for Emacs
Developing GeoMaestro implied writing a lot of code. This was done with Emacs, using a specific mode which notably allows a direct control of Keykit through Emacs, bypassing the Keykit console.
Working with Csound also implies writing a lot of code. This lead to the developement of Csound modes for Emacs, initially extending the existing modes written by John ffitch. It made it possible there again to drive Csound (and specially its multiple variations and command line options) directly from Emacs.
µO, musical objects for Squeak
Emacs lacks several features required for a comprehensive composition environment: notably graphics, and threads. This is provided by Squeak, along with its object philosophy. Squeak has been the most comfortable place to build incredibly powerful GUIs, using Morphic. Now each piece of musical data can be grabbed and modified with the mouse, along with every element of the geometric representation pionneered by GeoMaestro for Keykit.
Computer music is involved with the manipulation of huge quantities of very heterogeneous data. The most difficult point is to keep contact with the musical aspect of the data, I mean having representations of it which are "warm" (intuitive, musically meaningful, easy to grab, change and assemble) as opposed to "cold" (cold are lists of numbers, obfuscated code or 128-sliders banks/50 knobs GUIs).
At the time of this writing, I am thus porting concepts from GeoMaestro and the Composer to Squeak, revisiting all ideas as there are much more powerful ways to play with them in the Morphic world.
Side note:
The nature of the GeoMaestro paradigm being very much functional lead to the implementation of a specific class of objects suitable for functional programming in Smalltalk: see LambdaMessageSend.
And since studying these matters was very interesting indeed I quite forgot about music for some time and instead wrote a Scheme implementation for Squeak, which was a lot of fun.
It is actually now possible to run Common Music within Squeak, although it is very slow :)
Surmulot
A major problem when composing music with a computer is having all the different softwares communicate smoothly together, as it is very frustrating to have the composition process be interrupted in order to manipulate files, open new windows, rename things, start and stop anciliary programs.
Surmulot is an attempt to answer this issue.
Basically Surmulot is just Csound-x, µO communicating together via TCP/IP, plus a bunch of software (Timidity++, a MIDI synthesizer, some audio utilities) all transparently integrated to the high-level environments (Emacs and Squeak).
This is done via scripts and specific settings and customizations of the tools.
The integrated software are:
- Csound
- Wavesurfer (an audio editor)
- Timidity++ (a MIDI synthesizer)
Surmulot distribution and releases
The different components of Surmulot are available for all supported platforms.
A full package is available for Windows only. This is by far the simplest way to install Surmulot (complete with all dependencies and ancillary programs, correct settings and full documentation): just expand the archive; there are no changes made to the registry or to environment variables and path. Surmulot can coexists happily besides any other installation of Csound, Emacs or Squeak; it can even be installed multiple times.
For Linux systems a partial package is provided. It includes all code of mine, but requires that you have Emacs, Csound and Timidity already installed. It has been tested on Ubuntu systems.
Just unpack the tarball anywhere. Multiple versions can be installed alongside.
On Mac OS you will have to glue the components together by yourself or just use them separately.
(generated from the info pages included in the release)
