slippery chicken documentation - installing slippery chicken

## For the impatient

If you already have a Lisp interpreter and want to try out the basic system, see the basic installation instructions below.

## Installing slippery chicken

slippery chicken requires an ANSI Common Lisp interpreter for use. Many different interpreters are freely available for most operating systems (see below). Interpreter-specific and platform-specific installation details for slippery chicken can be found on the page install-notes.html in the sc/doc/ directory and will be updated and expanded as new details become available.

Depending on the kind of output desired, the user may be required to obtain and install additional software packages prior to installing slippery chicken. Please look at the headings below to find the appropriate installation guidelines for different usages.

### Requirements

The minimum installation requirements for all purposes are:

- the slippery chicken release package

  NB: slippery chicken uses components of Rick Taube's software Common Music 2.6.0 (CM) to generate MIDI files and perform a number of other internal processes. A full copy of this version of CM is included with the slippery chicken release. (Thanks Rick!) On OSX and Linux, slippery chicken loads CM in full, and CM is fully functional as a separate package in Lisp. On Windows, slippery chicken loads only a number of required components of CM, leaving CM itself not fully functional as an independent Lisp package.

- an ANSI Common Lisp interpreter

  Various Lisp implementations include (among others):

  - Steel Bank Common Lisp (SBCL): a free CL for Linux and MacOSX, and experimentally for Windows
  - Clozure Common Lisp (CCL) (formerly OpenMCL): a free CL available for Linux, MacOSX, and Windows
  - CLisp: a free CL available for Linux, Windows, and MacOSX
  - Carnegie Mellon University Common Lisp (CMUCL): a free CL available for Linux and MacOSX
  - Allegro Common Lisp (ACL): a commercial CL available for Windows, Linux, and MacOSX

Optional additional packages include:

- LilyPond
- Common Music Notation (CMN)
- Common Lisp Music (CLM)
- The Emacs text editor
- The SLIME Common Lisp Development mode for Emacs
  NB Running a Lisp Interpreter in a terminal window or command prompt does not provide the most convenient way of interacting with code development and evaluation. The Lisp-SLIME-Emacs combination provides a very slick programming environment so installing Emacs with SLIME is highly recommended. See install notes for further details.

slippery-chicken on its own (including CM) and in conjunction with CMN and LilyPond has been confirmed to run in the following configurations (see the above note about slippery chicken's partial loading of CM on Windows):

| Mac OSX | Linux | Windows7
--- | --- | --- | ---
x86 | x86-64 | x86 | x86-64 | x86 | x86-64
SBCL |  | X |  | X | X | X
CCL |  | X |  | X |  |

slippery-chicken in conjunction with CLM has been confirmed to run in the following configurations:

| Mac OSX | Linux | Windows7
--- | --- | --- | ---
x86 | x86-64 | x86 | x86-64 | x86 | x86-64
SBCL |  | X |  | X |  |
CCL |  | X |  | X |  |

NB: Michael Edwards ran slippery chicken on Windows XP with CM/CMN/CLM for years but found that the only Lisp/C compiler combination that worked with CLM was Allegro Common Lisp and Microsoft Visual C++. Both of these are quite expensive pieces of software (the free version of Allegro had memory limitations that made running CLM impossible). Due to this fact they are currently unsupported in slippery chicken.

## General installation instructions

### Basic installation—for MIDI output only

This basic setup will allow the creation of MIDI files only:

1. Download and unpack the slippery chicken release package.
2. Start the Lisp interpreter.
3. Load slippery chicken by entering at the Lisp prompt:

       (load "/path/to/sc/src/all.lsp")

### Installation for printable output

For the next two options it is important to note that CMN and/or CLM must be loaded into the Lisp environment and working properly before loading slippery chicken.

If slippery chicken has been loaded previously without having first loaded CMN and/or CLM, and the user would like to install one or both of these programs later, all of the files from the `sc/bin/` folder of the slippery chicken release directory must first be deleted, then CMN and/or CLM must be loaded into the Lisp environment, and then slippery chicken must be loaded again.

### Installation for music score generation

In order to generate printable notation using slippery chicken, either LilyPond or CMN must be installed.

For use with LilyPond, first obtain LilyPond and follow its instructions for installation. slippery chicken can be used to produce `.ly` files, which can then be processed separately by LilyPond.

In order to use CMN with slippery chicken, first obtain CMN and follow the instructions in its documentation to load it into the Lisp environment. Once CMN has finished compiling and loading, continue by following the steps in the "Basic installation" above.

    CL-USER> (load "/path/to/cmn/cmn-all.lisp")

### Installation for sound file generation

In order to use slippery chicken for compositions that consist of or include electroacoustic ("tape") parts, CLM must be installed.

Obtain CLM-4 and follow the instructions in its documentation to load it into the Lisp environment. Once CLM has finished compiling and loading, continue by following the steps described in the "Basic installation" above.

CLM's `nrev` reverberation instrument must also be compiled and loaded in order to use slippery chicken with CLM. To compile `nrev`, first load CLM into the Lisp environment and switch to the CLM package:

    CL-USER> (load "/path/to/clm-4/all.lisp")
    CL-USER> (in-package :clm)
    CLM> (compile-file "/path/to/clm-4/nrev.ins")
    CLM> (load "/path/to/clm-4/nrev")

The `nrev` instrument must only be compiled once. After that it need only be loaded.

## Running slippery chicken

If using CMN and/or CLM in a given slippery chicken session, these must be loaded prior to loading slippery chicken. A typical slippery chicken session in which both CMN and CLM are used may start by entering the following at the Lisp prompt:

    CL-USER> (load "/path/to/clm-4/all.lisp")
    CL-USER> (in-package :clm)
    CLM> (load "/path/to/clm-4/nrev")
    CLM> (in-package :cl-user)
    CL-USER> (load "/path/to/cmn/cmn-all.lisp")
    CL-USER> (load "/path/to/sc/src/all.lsp")

Emacs+SLIME users can alternatively add those lines of code to their `.swank` file to have them load automatically on startup. For example, the basic .swank code on Michael's CCL system would be

    (load "/lisp/cmn/cmn-all.lisp")
    (load "/lisp/clm-4/all.lisp")
    (load "/Users/medward2/lisp/sc/src/all.lsp")

    (in-package :clm)
    (compile-file "/lisp/clm-4/nrev.ins")
    (load "/lisp/clm-4/nrev.dx32fsl")

Once slippery chicken has been compiled and loaded, switch to the `sc` package by entering `(sc)` at the prompt in the Lisp listener. This changes the prompt symbol to `SC>`.

    CL-USER> (sc)
    (\  }\
    (  \_('> slippery chicken 1.0.0-beta1 (svn revision 1718 2012-05-15 18:14:24)
    (__(=_)
       -"=
    SC>

To have slippery chicken produce output from previously saved files, those files can be loaded at the `SC>` prompt of the Lisp listener:

    (load "/path/to/sc-file.lsp")

A number of example compositions and tutorials can be found in the manual.