1 Introduction

1.1 Definition and Scope

Common Music (CM) is a portable, open-source software environment designed for algorithmic composition, sound synthesis, and music research. Developed primarily by Heinrich Taube at the University of Illinois at Urbana‑Champaign, Common Music provides a high-level programming interface in Common Lisp. This interface allows composers and researchers to describe musical processes, generate scores, and control external synthesis engines. The system supports multiple representation formats (e.g., MIDI, CLM, Csound) and features a modular architecture that facilitates experimentation with generative algorithms, real-time interaction, and music information retrieval. It has been widely used in academic computer music studios and by composers exploring systematic approaches to music creation.

1.2 Historical Development

1.2.1 Origins at Stanford and UIUC

The roots of Common Music lie in the computer music research of the 1980s. Heinrich Taube, while at Stanford University’s Center for Computer Research in Music and Acoustics (CCRMA), began developing a system that would unify various composition and synthesis tools under a Common Lisp framework. The project moved with Taube to the University of Illinois at Urbana‑Champaign, where it became a central component of the School of Music’s computer music curriculum. The initial design drew inspiration from earlier Lisp-based music systems, such as David Cope’s experiments with algorithmic composition, but aimed for greater portability and modularity.

1.2.2 Versions and Evolution

The first major release, Common Music 1.0, appeared in the early 1990s. It quickly gained traction in academic circles due to its flexible representation of musical events and its ability to output to multiple synthesis backends. Subsequent versions added support for real‑time interaction, improved pattern languages, and a graphical score editor named Grace. The most widely used version, Common Music 2.0, was released in the late 1990s and remained stable for many years. Later development shifted toward web‑based and modern Lisp implementations, but the original Common Music remains a landmark in algorithmic composition software.

2 System Architecture

2.1 Core Components

2.1.1 Reader and Parser

The reader and parser form the input interface of Common Music. They accept musical descriptions written in a Lisp‑like syntax, including note lists, pattern definitions, and algorithmic rules. The parser translates these descriptions into internal data structures that can be manipulated programmatically. This design allows composers to work with text files, command‑line inputs, or interactive Lisp sessions.

2.1.2 Event and Score Objects

The central data model in Common Music is the event object. Each event represents a sound occurrence, with attributes such as pitch, duration, amplitude, and timbre. Events are collected into score objects, which can be sorted, filtered, and transformed. The system provides a rich set of methods for manipulating scores, including transposition, rhythmic alteration, and probabilistic selection. This object‑oriented approach makes it straightforward to implement complex compositional algorithms.

2.1.3 Synthesis Backend

Common Music does not generate audio directly; instead, it interfaces with external synthesis engines. The synthesis backend module manages output to various formats: it can write note files for Common Lisp Music (CLM), score files for Csound, or MIDI sequences. The backend is pluggable, allowing users to add custom output formats. This separation of representation from sound generation is a key architectural feature, enabling composers to experiment with different synthesis paradigms without changing their compositional logic.

2.2 Representation Formats

2.2.1 Common Music Notation (CMN)

CMN is a textual notation for representing standard Western musical notation. It supports all conventional notational elements—note heads, rests, beams, ties, articulations, dynamics, and phrasing. CMN files can be rendered to graphical scores using the Grace editor or converted to PostScript for publication. This format is particularly useful for composers who want to produce traditional sheet music from algorithmic processes.

2.2.2 CLM and Csound Integration

Common Music provides native support for Common Lisp Music (CLM) and Csound, two prominent synthesis languages. For CLM, Common Music outputs instrument definitions and note lists that CLM interprets to produce audio. For Csound, it generates standard score files (.sco) and can optionally create orchestral definitions (.orc). This integration allows composers to leverage the powerful synthesis capabilities of these systems while writing composition code in a unified environment.

2.2.3 MIDI Output

For real‑time performance and hardware synthesis, Common Music can generate standard MIDI files. The MIDI backend maps event attributes (pitch, velocity, duration) to MIDI messages. It also supports system‑exclusive data and controller changes, making it suitable for controlling external synthesizers and samplers. This format is widely used for live electronics and interactive installations.

3 Programming Paradigms

3.1 Common Lisp for Composition

3.1.1 Functional and Object‑Oriented Styles

Common Music leverages the full expressive power of Common Lisp. Users can write compositional algorithms in a functional style, using recursion, higher‑order functions, and list processing to generate musical structures. At the same time, the object‑oriented features of Common Lisp (via CLOS – the Common Lisp Object System) allow composers to define specialized event types, pattern classes, and synthesis interfaces. This dual paradigm gives maximum flexibility: simple pieces can be written as a few lines of functional code, while large‑scale systems can be organized into clear object hierarchies.

3.1.2 Pattern and Constraint Languages

A distinctive feature of Common Music is its pattern language. A pattern is an object that generates a sequence of values (pitches, durations, dynamics, etc.) according to rules such as cycles, random selection, or weighted choices. Patterns can be nested, transformed, and combined, providing a concise way to describe repetitive or evolutionary material. The system also includes a constraint programming extension that allows composers to specify logical conditions that generated music must satisfy (e.g., “no two consecutive notes in the same pitch class”). These tools are especially useful for composing with formal constraints.

3.2 Algorithmic Composition Techniques

3.2.1 Stochastic Processes

Common Music provides a library of random and probabilistic functions suitable for music generation. These include uniform and Gaussian random number generators, as well as stochastic processes such as Markov chains (see 3.2.4) and random walks. Composers can use these to introduce controlled randomness into pitch selection, rhythmic patterns, or form. The system also supports probability distributions based on historical musical statistics.

3.2.2 Rule‑Based Systems

Rule‑based composition in Common Music is achieved through condition‑action rules. A rule might, for example, enforce voice‑leading restrictions in a chord progression or require that certain melodic intervals be avoided. Rules can be applied globally to an entire score or locally to specific events. This technique is often used for style simulation and for generating music that must adhere to predefined stylistic constraints.

3.2.3 Generative Grammars

Common Music can implement formal grammars (e.g., context‑free or Lindenmayer systems) to generate musical structures. A grammar consists of a set of production rules that rewrite an initial symbol into a sequence of musical events. This approach is particularly suited for creating hierarchical forms, such as fractal‑like melodies or self‑similar rhythms. The system includes utilities for defining and iterating grammars over multiple generations.

3.2.4 Markov Chains and State Machines

For stochastic sequence generation, Common Music offers Markov chains of arbitrary order. The user provides a transition matrix (learned from existing music or defined manually), and the system generates a sequence whose transition probabilities match the matrix. Finite state machines can also be defined to model larger‑scale formal structures, such as the alternation of verse and chorus sections. These tools are widely used for style imitation and for creating music with statistical properties similar to a given corpus.

4 User Interface and Workflow

4.1 Command‑Line and Emacs Integration

Common Music can be used entirely from a command‑line environment. After starting a Common Lisp interpreter, the user loads the Common Music library and enters Lisp forms interactively. Many users prefer to work within Emacs, using the SLIME mode for Lisp development. This setup provides syntax highlighting, inline evaluation, and debugging capabilities. Standard workflow involves writing a composition script in a text editor, evaluating it to generate a score, and then exporting the result to a sound or notation file.

4.2 Grace (Graphical Score Editor)

Grace is a graphical score editor bundled with Common Music. It displays scores in traditional notation (via CMN) and allows the user to edit notes, dynamics, and articulations directly with a mouse and keyboard. Grace can also import and export CMN files, making it a bridge between algorithmic generation and manual editing. Its interface is minimal but functional, designed for composers who want to fine‑tune algorithmically generated material.

4.3 Batch Processing and Real‑Time Use

Common Music supports batch processing: a composition script can be written as a standalone Lisp program that runs without user interaction, producing a score file or MIDI output. This is useful for generating large corpora or for running algorithmic experiments overnight. For real‑time use, Common Music can output MIDI messages live while a Lisp session is running, enabling interactive improvisation setups. Real‑time performance is, however, limited by the overhead of Lisp interpretation; for low‑latency control, many users integrate Common Music with external real‑time systems via OSC or MIDI.

5 Applications

5.1 Academic Research

5.1.1 Music Analysis and Theory

Common Music has been used to study the structural properties of existing musical works. Researchers can encode a score into the system, then apply algorithmic transformations to test hypotheses about its underlying patterns. For example, by running a Markov chain analysis on a Bach chorale, one can generate new lines that mimic Bach’s style, providing insights into statistical properties of the original. The system’s flexibility also makes it a tool for computational musicology.

5.1.2 Cognitive Science Experiments

In cognitive science, Common Music serves as a platform for generating stimuli in perception and production experiments. The ability to precisely control musical parameters (pitch, timing, timbre) and to randomize conditions is essential for experimental design. Researchers have used Common Music to create test sequences for studies on melody recognition, rhythm perception, and emotional response to music.

5.2 Composition and Performance

5.2.1 Fixed Media Works

Many composers have used Common Music to generate fixed‑media (tape) pieces. They write algorithmic processes that produce a score, then render it through CLM or Csound to create an audio file. The resulting works often exhibit complex textures and evolving forms that would be difficult to achieve manually. Notable examples include pieces by Taube himself and by students at UIUC and other institutions.

5.2.2 Live Coding and Interactive Systems

While not originally designed for live coding, Common Music’s interactive Lisp environment allows for on‑the‑fly composition during performance. A performer can evaluate Lisp forms that modify the current score or trigger new patterns, with the results sent in real time to a synthesizer. This approach has been used in laptop orchestras and in solo improvisation sets. Common Music’s stability and predictability make it a viable choice for live electronic music.

5.3 Education

5.3.1 Teaching Algorithmic Music

Common Music is a popular teaching tool for courses in algorithmic composition and computer music. Its high‑level Lisp syntax is relatively accessible to students with some programming background, and the immediate feedback of generating audible output keeps learners engaged. The system’s modularity allows instructors to introduce concepts gradually, from simple note lists to advanced constraint systems.

5.3.2 Tutorial Resources

A comprehensive set of tutorials and documentation accompanies Common Music. The official manual includes examples of stochastic processes, pattern languages, and score manipulation. Additionally, several textbooks and online courses have been developed around Common Music, including the widely used *Introduction to Common Music* by Taube. The community maintains a mailing list and an archive of example compositions.

6.1 Influence on Other Systems

Common Music influenced a generation of algorithmic composition environments. Its event‑based architecture and pattern language inspired systems such as OpenMusic (developed at IRCAM) and PWGL (a graphical environment for composition). The concept of representing musical structure as manipulable Lisp data objects also influenced the design of later real‑time systems like Impromptu and Extempore. Common Music’s approach to separating composition from synthesis became a standard pattern in computer music software.

6.2 Common Music 2 and Modern Successors

The most widely distributed version, Common Music 2, remains available and functional on modern Lisp implementations (e.g., SBCL, CCL). However, development of the original Common Music has largely ceased in favor of more modern successors. Common Music 3, also known as CM3, is a complete rewrite that takes advantage of modern Lisp features and supports real‑time audio output natively. Other related projects include Common Music Notation (CMN), a standalone library for typesetting music, and Grace (now a separate editor). Despite the shift, the original Common Music continues to be used in classrooms and by composers who value its simplicity and maturity.

6.3 Community and Documentation

The Common Music community, though small, is active and supportive. The official website (commonmusic.sourceforge.net) hosts the source code, binaries, and documentation. A mailing list archive contains years of discussions on algorithmic composition, installation issues, and creative applications. Several universities, including UIUC, still offer courses that rely on Common Music. The system’s open‑source nature has also led to ports and extensions by independent developers, ensuring that it remains accessible on contemporary operating systems.