Lilypond music preprocessor
Failed to load latest commit information.
bin Fix directory watcher globs, report relative path when a file changes… Dec 13, 2010
examples/simple Incorporated rpl syntax into processing, added simple example. Jul 21, 2009
lib Update for lilypond 2.16.2. Jul 3, 2013
spec Update specs (5 failures remaining). Feb 6, 2013
.gitignore Update for lilypond 2.16.2. Jul 3, 2013
Gemfile Update Gemfile and Rakefile (use jeweler2). Feb 6, 2013
Gemfile.lock Update Gemfile and Rakefile (use jeweler2). Feb 6, 2013
SYNTAX.markdown Fix syntax examples, add lydown file. Oct 13, 2013
alternative_figures_syntax Added support for working inside work directory. Nov 12, 2010
ripple.gemspec Regenerate gemspec for version 1.0.6 Oct 13, 2013


Ripple - DRY for Lilypond

Ripple is a small program that helps you generate scores and parts without repeating yourself, performing complex includes or writing scheme macros.

Here are some of Ripple's features:

  • Create scores and parts from files organized in a consistent, easy-to-understand directory hierarchy.
  • Improved Lilypond syntax for writing music, with support for macros (very useful for notating recurring rhythms), better accidentals, prefixed beams and slurs, and shorthand notation for stuff like divisi, appogiaturas, etc.
  • Automatically create MIDI versions of your scores.
  • Proof mode for faster editing - get your PDF regenerated every time you save your source.
  • Compilation mode for mixing different musical works together in a single score or part.

For comprehensive examples of the improved syntax checkout out my music scores project (mainly works by Bach).

A Ripple project:

Ripple expects your files to be organized a certain way for it to function correctly. Here is a simple example:


The music is contained in .ly or .rpl files (the latter are assumed to be in Ripple syntax and are converted to normal Lilypond syntax). The _work.yml file is a YAML file that contains the attributes of the work:

title: Sonata for Viola da Gamba and Harpsichord G-dur BWV1027
composer: Johann Sebastian Bach
    title: Viola da gamba
  order: gamba, cembalo

To process the files into parts and scores, simply cd into the directory and run ripple.

cd my_music

Lyrics are entered in a separate file with the same part name and using the .lyrics or .lyr extension (the latter using enhanced syntax). Basso continuo figures are also entered in a separate file with the same part name and a .figures or .fig extension (the latter also using the improved Ripple syntax).

Ripple will generate Lilypond files and put them into my_music/_ly, and then run Lilypond to produce PDF files that will be put in my_music/_pdf.

Multi-movement works

Ripple also supports multi-movement works. Consider the following file hierarchy:


Ripple will generate gamba and cembalo parts containing all three movements, as well as a score containing the three movements. The directory names are converted into movement titles, e.g. "1. Allegro", "2. Adagio" and "3. Vivace".

Configuration files

Each work should have its own _work.yml file. This file can be used to configure the different parts and their order in the score. Here is a sample file:

title: Missa Brevis G-dur BWV 236
composer: Johann Sebastian Bach
editor: Sharon Rosner
copyright: © IBS 2009 - all rights reserved
  hide_empty_staves: true
    - oboe1
    - oboe2
    - violino1
    - violino2
    - viola
    - soprano
    - alto
    - tenore
    - basso
    - continuo

Each movement can also have its own _movement.yml file containing overrides for the specific movement. You can for example specify colla parte without copying the music:

    source: soprano
    source: alto
    source: soprano
    source: alto
    source: tenore

This configuration file specifies that the oboe1 and violino1 parts take their music from the soprano part, oboe2 and violino2 from the alto part, and the viola from the tenore part.

In addition, default settings can be stored in a _ripple.yml file, which can be used for setting for example the editor's name or the copyright notice.

Ripple also currently includes the following default settings for several voice types and instruments:

  1. Clef - the clef is automatically inserted by Ripple unless it is set to none.
  2. AutoBeam:false/true (default is true) - this setting is can be used in order to insert a \autoBeamOff macro in vocal parts.

Overriding default settings

The settings used by Ripple to process the source files are merged from the different settings files (ripple/lib/defaults.yml, _ripple.yml, _work.yml, _movement.yml) and can further be overriden by specifying an --opt switch:

ripple BWV17 --opt "editor:Someone else but me"

Auto-regeneration mode

Ripple can be put into auto-regeneration mode, in which it watches the source directory and process the specified files each time a file is saved in that directory. To use ripple in auto-regenration mode, add auto:true to your _ripple.yml file, or specify the --auto switch:

ripple BWV17 --auto

Proof mode

Proof mode is similar to auto-regeneration mode, except that each time a file is changed or added, it is compiled into PDF (as a single movement and part) and opened in the background. This mode is very useful when entering parts. To use ripple in proof mode, add proof:true to your _ripple.yml file, or specify the --proof or -P switch:

ripple BWV17 -P

Compilation mode

Compilation mode allows you to compile different pieces/movements into a single score or part. The compilation settings are defined in a YAML file. Here's a simple example:

title: My First Ripple Compilation
subtitle: Just Testing
  - work: bach/BWV1041
    movement: 01-allegro
  - work: bach/BWV1066
    movement: "09-bourree-II"
    score_breaks: 2
        source: fagotto
        breaks: 1
    source: continuo
    clef: bass
    hide_figures: true

In order to process the compilation, use the -c switch:

ripple -c compilations/test

When no parts are specified, Ripple will process all parts specified in the compilation file. As the example above shows, you can also control page breaks for individual parts and for the score. For more examples of usage look at my own compilations.

Ad-hoc compilations

Ripple also lets you perform ad-hoc compilations without preparing a compilation file by using the -C switch:

ripple -C bach/BWV156 bach/BWV044 bach/BWV017

If no parts are specified, only the score will be prepared. You can also compile specific movements by specifying them using the format work#movement. Ripple will also understand movement numbers instead of complete movement references:

ripple -C bach/BWV156#1 bach/BWV044#2

You can also specify a title for the compilation by including the -t switch:

ripple -C -t "My own title" bach/BWV156#1 bach/BWV044#2

More ripple tips

Process multiple works

ripple bach/BWV017 bach/BWV166

Create a MIDI version of your score:

ripple bach/BWV017 -M

Open the rendered PDF file once it is ready:

ripple bach/BWV017 -o

This also works for MIDI files:

ripple bach/BWV017 -M -o

If you find yourself always using the -o switch, you can add the following setting to your _ripple.yml file instead:

open_target: true

Process only the score:

ripple bach/BWV017 -s

Process only the parts:

ripple bach/BWV017 --no-score

Process a specific part:

ripple bach/BWV017 -p continuo
ripple bach/BWV017 -p violino1,violino2

Process a specific movement:

ripple bach/BWV017 -m 01-coro