mailto(gnu-music-discuss@gnu.org)
COMMENT(-*-text-*-)

redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
    whenhtml(sc(ARG1)))

COMMENT(urg)
DEFINEMACRO(Large)(1)(\
    whenlatex(latexcommand(\Large{)ARG1+latexcommand(}))\
    whentexinfo(texinfocommand(@strong{)ARG1+texinfocommand(}))\
    whenhtml(htmlcommand(<font size=+2>)ARG1+htmlcommand(</font>))\
    whentxt(ARG1))

COMMENT( This document contains Mudela fragments.  You need at least
Yodl-1.30.18 to convert this to tex or html.

TODO

    * pipethrough(date) sucks.
    * paragraphs have too much space.
    * fix the amount of spaces (urg:tabs) at the start of verb() blocks
      or even better: do verb and description side-by side
      (TeX: use minipage construct):

      \foo                  This does the
                            foo construct

      The explaining texts are right in between examples.
      Constructs like 'This shows' and 'The next line' are esp.
      confusing, here.
)

COMMENT(
        Mainly written by Han-Wen Nienhuys, 

        with help of (among others)

        * Jan Nieuwenhuizen
)

htmlbodyopt(bgcolor)(white)
htmlcommand(<font color=black>)

latexlayoutcmds(
    \topmargin -0.25in  
    \textheight 53\baselineskip
    \advance\textheight by \topskip
    \marginparwidth 1 in        %   Width of marginal notes.
    \oddsidemargin 0.25 in      %   Note that \oddsidemargin = \evensidemargin
    \evensidemargin 0.25 in
    \marginparwidth 0.75 in
    \textwidth 5.875 in % Width of text line.
    \input mudela-book
)

whenlatex(notableofcontents())
whentexinfo(notableofcontents())

article(Typesetting music with LilyPond)
      (Han-Wen Nienhuys and Jan Nieuwenhuizen)
      (nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())


latexcommand(\def\interexample{})
latexcommand(\def\preexample{\par})
latexcommand(\def\postexample{\par\medskip})
latexcommand(\def\file#1{{code(#1)}})

whenhtml(
includefile(html-disclaimer.yo-urg)
)


sect(Introduction)
label(tutorial:introduction)
latexcommand(\parindent2pc)
  
LilyPond prints music from a specification that you, the user, supply.
You have to give that specification using a em(language).  This
document is a gentle introduction to that language, which is called
Mudela, an acronym of Music Definition Language.

This tutorial will demonstrate how to use Mudela by presenting
examples of input along with resulting output.  We will use English
terms for notation.  In case you are not familiar with those, you may
consult the glossary that is distributed with LilyPond.

The examples discussed are included in the distribution, in the
subdirectory file(input/tutorial/).  It is recommended that you
experiment with writing Mudela input yourself, to get a feel for
how LilyPond behaves.

sect(The first tune)
label(sec:firsttune)

To demonstrate what LilyPond input looks like, we start off with a
full fledged, yet simple example. It is a convoluted version
of the famous menuet in bind(J.)bind(S.)Bach's em(Klavierbuechlein).

COMMENT(urg: the fermata sign is placed below the note by default)
mudela(verbatim)(% lines preceded by a percent are comments.
\include "paper16.ly"
\score {
    \notes			
    \relative c'' {		
            \key g;
            \time 3/4;		

        \repeat "volta" 2 {
            d4 g,8 a b c d4 g, g |
            e'4 c8 d e fis g4 g, g |
            c4 d8()c b a( )b4 c8 b a g |
            a4 [b8 a] [g fis] g2.  |
        }

        b'4 g8 a b g
        a4 d,8 e fis d |
        g4 e8 fis g d cis4 b8 cis a4 |
        a8-. b-. cis-. d-. e-. fis-.
        g4 fis e |
        fis a,  r8 cis8
        d2.-\fermata
        \bar "|.";
    }
    \paper {
       % standard settings are too wide for a book
       linewidth = 14.0 \cm;
   }
})

Enter it (or copy it, the filename is file(menuet.ly)), compile it
with LilyPond and view the output.  Details of this procedure may vary
from system to system.  To create the output, one would issue the
command `code(ly2dvi menuet)'.  file(ly2dvi) is a program that does
the job of running LilyPond and TeX(), handling of titles and
adjusting of page margins.

If all goes well, the file file(menuet.dvi) will be created.
To view this output, issue the command `code(xdvi menuet)'.

Now that we are familiar with the procedure of producing output, we
will analyse the input, line by line.COMMENT(

)verb(
        % lines preceded by a percent are comments.
)COMMENT(

)The percent sign, `code(%)', introduces a line comment.  If you want to
make larger comments, you can use block comments. These are delimited
by `code(%{)' and `code(%})'COMMENT(

)verb(
        \input "paper16.ly"
)COMMENT(

)By default, LilyPond will use definitions for a 20
nop(point)footnote(A point is the standard measure of length for
printing.  One point is 1/72.27 inch.) high staff.  We want smaller
output (16 point staff height), so we must import the settings for
that size, which is done.COMMENT(

)verb(
        \score {
) COMMENT(

) A mudela file combines music with directions for outputting that
music.  The music is combined with the output directions by putting
them into a code(\score) block.
verb(
        \notes		
) COMMENT( 

)This makes LilyPond ready for accepting notes.
verb(
        \relative c''
)COMMENT(

) As we will see, pitches are combinations of octave, note name and
chromatic alteration.  In this scheme, the octave is indicated by
using raised quotes (`code(')') and ``lowered'' quotes (commas:
`code(,)').  The central C is denoted by code(c').  The C one octave
higher is code(c'').  One and two octaves below the central C is
denoted by code(c) and code(c,) respectively.

For pitches in a long piece you might have to type many quotes.  To
remedy this, LilyPond has a ``relative'' octave entry mode.  In this
mode, octaves of notes without quotes are chosen such that a note is
as close as possible (graphically, on the staff) to the the preceding
note.  If you add a high-quote an extra octave is added.  The lowered
quote (a comma) will subtract an extra octave.  Because the first note
has no predecessor, you have to give the (absolute) pitch of the note
to start with.COMMENT(

)verb(
        \sequential {
)COMMENT(

)  What follows is sequential music, i.e.,
notes that are to be played and printed after each other.COMMENT(

)verb(
        \time 3/4;
) COMMENT(

) This command changes the time signature of the current piece: a 3/4
sign is printed.  This command is also used to generate bar lines in
the right spots.COMMENT(

)verb(
        \key g;
)COMMENT(

) This command changes the current key to G-major.  Although this
command comes after the code(\time) command, in the output, the key
signature comes before the time signature: LilyPond knows about music
typesetting conventions. COMMENT(

)verb(
        \repeat "volta" 2
) COMMENT(

) This command tells LilyPond that the following piece of music must
be played twice; code("volta") volta brackets should be used for
alternatives---if there were any.
COMMENT(

)verb(
        {
)COMMENT(

)The subject of the repeat is again sequential music.  Since
code(\sequential) is such a common construct, a shorthand is provided:
just leave off code(\sequential), and the result is the same. COMMENT(

)verb(
        d4
)COMMENT(

) This is a note with pitch code(d) (determined up to octaves).  The
relative music was started with a code(c''), so the real pitch of this
note is code(d'').  The code(4) designates the duration of the note
(it is a quarter note). COMMENT(

)verb(
        a b
)COMMENT(

)These are notes with pitch code(a') and code(b').  Because their
duration is the same as the code(g), there is no need to enter the
duration (You may enter it anyway, eg. code(a4 b4)) COMMENT(

)verb(
        d4 g, g |
)COMMENT(

) Three more notes.  The `code(|)' character is a `barcheck'.  When
processing the music, LilyPond will verify that barchecks are found at
the start of a measure.  This can help you track down errors.
COMMENT(

)verb(
        e'4 
) COMMENT(

) So far, no notes were chromatically altered.  Here is the first one
that is: code(fis). Mudela by default uses Dutch note names, and
``Fis'' is the Dutch note name for ``F sharp''.  However, there is no
sharp sign in the output. The program keeps track of key signatures,
and will only print accidentals if they are needed.
COMMENT(

)verb(
        c8 d e fis
)COMMENT(

)LilyPond guesses were beams can be added to eighth and shorter notes.
In this case, a beam over 4 eighths is added.
COMMENT(

)verb(
        c4 d8( )c b a( )b4 c8 b a g |
) COMMENT(

) The next line shows how to make a slur:
the beginning and ending note of the slur is marked with an opening and
closing parenthesis respectively.  In the line shown above this is
done for two slurs.  Slur markers (parentheses) are between
the notes.COMMENT( 
)verb(
        a4 [b8 a] [g fis] 
)COMMENT(

)Automatic beaming can be overridden by inserting beam marks
(brackets).  Brackets are put around notes you want beamed.COMMENT(

)verb(
        g2.  |
)COMMENT(

)A duration with augmentation dot  is notated
with the duration number followed by a period.COMMENT(
)verb(
        }
) COMMENT(

) This ends the sequential music to be repeated.  LilyPond will typeset
a repeat bar.  COMMENT(

)verb(
        cis'4 b8 cis a4 |
) COMMENT(

)This line shows that Lily will print an accidental if that is
needed: the first C sharp will be printed with an accidental, the
second one without.  COMMENT(

)verb(
        a8-. b-. cis-. d-. e-. fis-.
)COMMENT(

)You can enter articulation signs either in a verbose form using a
shorthand.  Here we demonstrate the shorthand: it is formed by a dash
and the the character for the articulation to use, e.g. `code(-.)' for
staccato as shown above.  COMMENT(

)verb(
        fis a, r8 cis8
) COMMENT(

)
Rests are denoted by the special notename `code(r)'.  You can also enter
an invisible rest by using the special notename `code(s)'.
verb(
        d2.-\fermata
) COMMENT(

)All articulations have a verbose form, like code(\fermata).  The
command `code(\fermata)' is not part of the core of the language (most
of the other discussed elements are), but it is a shorthand for a more
complicated description of a fermata.  code(\fermata) names that
description and is therefore called an em(identifier). COMMENT(

)verb(
        }
) COMMENT(

)
Here the music ends.
COMMENT(

)verb(
        \paper {
                linewidth = 14.0\cm;
        }
)COMMENT(

)This specifies a conversion from music to notation output.  Most of
the details of this conversions (font sizes, dimensions, etc.) have
been taken care of, but  to fit the output  in this document, it has
to be smaller.  We do this by setting the line width to 14 centimeters
(approximately 6 inches).
COMMENT(

)verb(
        }
)COMMENT(

)The last brace ends the code(\score) block.

There are two things to note here. The format contains musical
concepts like pitches and durations, instead of symbols and positions:
the input format tries to capture the meaning of em(music), and not
notation.  Therefore Second, the format tries to be em(context-free):
a note will sound the same regardless of the current time signature,
the key, etc.

The purpose of LilyPond is explained informally by the term `music
typesetter'.  This is not a fully correct name: not only does the
program print musical symbols, it also makes esthetic decisions.  All
symbols and their placement is em(generated) from a high-level musical
description.  In other words,  LilyPond would be best
described by `music compiler' or `music to notation compiler'.


sect(Lyrics and chords)

In this section we show how to typeset a song of (unknown
origin)footnote(The author would welcome information about the origin
of this song.).

verb(\header {
        title = "The river is flowing";
        composer = "Traditonal (?)";
}
\include "paper16.ly"
melody = \notes \relative c' {
        \partial 8;
        g8 |
        c4 c8 d [es () d] c4 | f4 f8 g [es() d] c g |
        c4 c8 d [es () d] c4 | d4 es8 d c4.
        \bar "|.";
}

text = \lyrics {
        The ri -- ver is flo- __ wing, flo -- wing and gro -- wing, the
        ri -- ver is flo -- wing down to the sea.
}

accompaniment =\chords {
        r8
        c2-3- f-3-.7 d-min es4 c8-min r8
        c2-min f-min7 g-7^3.5 c-min }

\score {
        \simultaneous {
%         \accompaniment
          \context ChordNames \accompaniment

          \addlyrics
            \context Staff = mel {	
              \property Staff.noAutoBeaming = "1"
              \property Staff.automaticMelismas = "1"
              \melody 
            }
            \context Lyrics \text
        }
        \midi  { }
        \paper { linewidth = 10.0\cm; }
})


The result would look bind(this)footnote(The titling and font size shown
may differ, since the titling in this document is not generated by
file(ly2dvi).).

center(bf(Large(The river is flowing))

var(Traditonal (?))
)

mudela(center)(\header {
        title = "The river is flowing";
        composer = "Traditonal (?)";
}
\include "paper16.ly"
melody = \notes \relative c' {
        \partial 8;
        g8 |
        c4 c8 d [es () d] c4 | f4 f8 g [es() d] c g |
        c4 c8 d [es () d] c4 | d4 es8 d c4.
        \bar "|.";
}

text = \lyrics {
        The ri -- ver is flo- __ wing, flo -- wing and gro -- wing, the
        ri -- ver is flo -- wing down to the sea.
}

accompaniment =\chords {
        r8
        c2-3- f-3-.7 d-min es4 c8-min r8
        c2-min f-min7 g-7^3.5 c-min }

\score {
        \simultaneous {
%         \accompaniment
          \context ChordNames \accompaniment

          \addlyrics
            \context Staff = mel {
	      \property Staff.noAutoBeaming = "1"
              \property Staff.automaticMelismas = "1"
              \melody 
            }
            \context Lyrics \text
        }
        \midi  { }
        \paper { linewidth = 10.0\cm; }
})

Again, we will dissect the file line by line.COMMENT(

)verb(
        \header {
)COMMENT(

)Information about the music you are about to typeset goes into a
code(\header) block.  The information in this block is not used by
LilyPond, but it is included in the output.  file(ly2dvi) uses this
information to print titles above the music.
verb(
        title = "The river is flowing";
        composer = "Traditonal (?)";)COMMENT(

)the code(\header) contains block assignments.  An assignment starts
with a string.  (which is unquoted, in this case). Then comes the
equal sign `code(=)'.  After the equal sign comes the expression you
want to store.  In this case, you want to put in strings.  The
information have to be quoted, because they contain spaces. The
assignment is finished with a semicolon.COMMENT(

)verb(
        \include "paper16.ly"
)COMMENT(

)Smaller size for inclusion in a book.COMMENT(

)verb(
        melody = \notes \relative c' {
)COMMENT(

)The structure of the file will be the same as the previous one, a
code(\score) block with music in it.  To keep things readable, we will
give the different parts of music names, and use names to construct
music within the score block.

verb(
        \partial 8;
)

The piece starts an anacrusis of one eighth.  COMMENT(

)verb(
        c4 c8 d [es () d] c4 | f4 f8 g [es() d] c g |
        c4 c8 d [es () d] c4 | d4 es8 d c4.
        \bar "|.";
)COMMENT(

)We use explicit beaming.  Since this is a song,  we turn automatic
beams off, and use explicit beaming where needed.COMMENT(

)verb(
        }
)COMMENT(

)This ends the definition of code(melody).  Note that there are no
semicolons after declarations at top level.COMMENT( 

)verb(
        text = \lyrics {
)COMMENT(

)Another identifier assignment.  This one is for the lyrics. 
Lyrics are formed by syllables that have duration, and not by
notes. To make LilyPond parse words as syllables,  switch it  into
lyrics mode with code(\lyrics).  Again, the brace after code(\lyrics)
is a shorthand for code(\sequential {). COMMENT(

)verb(
        The4 ri -- ver is flo- __ wing,  flo -- wing and gro -- wing, the
        ri- ver is flo- __ wing down to the sea.
        }
)COMMENT(

)The syllables themselves, separated by spaces.  You can get syllable
extenders by entering `code(__)', and centered hyphens with
`code(--)'.  We enter the syllables as if they are all quarter notes
in length (hence the code(4)), and use a feature to align the
syllables to the music, which obviously isn't all quarter notes.
COMMENT(

)verb(
        accompaniment =\chords {
)COMMENT(

)We'll put chords over the music.  There is a special mode (analogous
to code(\lyrics) and code(\notes) mode) where you can give the names
of the chords you want, instead of the notes comprising the chord.
COMMENT(

)verb(
        r8
)COMMENT(

)There is no accompaniment during the anacrusis.COMMENT(

)verb(
        c2-3- f-3-.7
)A chords is started by a note that is the tonic of the chord. The
first one lasts a half note.  An unadorned note creates a major
triad, while a minor triad is wanted.  code(3-) modifies the third to
be small. code(7) modifies (adds) a seventh, which is small by default
to create the code(f a c es) chord.  Multiple modifiers must be
separated by a dot.COMMENT(

)verb(
        d-min es4 c8-min r8
)COMMENT(

)Some modifiers have predefined names, eg. code(min) is  the same as
code(3-), so code(d-min) is a minor code(d) chord.COMMENT(

)verb(
        c2-min f-min7 g-7^3.5 c-min }
)COMMENT(

)A named modifier code(min) and a normal modifier code(7) do not have
to be separated by a dot.  Tones from a chord are removed with chord
subtractions.  Subtractions are started with a caret, and they are
also separated by dots.  In this example, code(g-7^3.5) produces a
minor seventh.  The brace ends the sequential music. COMMENT(

)verb(
        \score {
                \simultaneous {
)COMMENT(

)We assemble the music in the code(\score) block.  Melody, lyrics and
accompaniment have to sound at the same time, so they should be
code(\simultaneous).COMMENT(

)verb(
        %\accompaniment
)COMMENT(

)Chord mode generates notes grouped in code(\simultaneous) music.  If
you remove the comment sign, you can see the chords in normal
notation.  The chords will then be printed as chords of note heads on
a separate staff. COMMENT(

)verb(
        \context ChordNames \accompaniment
)COMMENT(

)Normally, the notes that you enter are transformed into note heads.
The note heads alone make no sense, they need surrounding information:
a key signature, a clef, staff lines, etc.  They need em(context).
This context also is a thing that has to be created. This is done by
code(\context).  It takes two arguments.  The first is the name of a
em(notation) or em(interpration context).  The name is a string, it
can be quoted with code(") quotes).  The second argument is the music
that should be interpreted in this context.

By default, LilyPond will create a Staff context for you.  If you
would remove the code(%) sign in the previous line, you see that
mechanism in action.  For the previous line, we could have written
code(\context Staff \accompaniment), and get the same effect.COMMENT(

)verb(
        \addlyrics
)COMMENT(
        
)The lyrics need to be aligned with the melody.  This is done by
combining both with code(\addlyrics).  code(\addlyrics) takes two
pieces of music (usually a melody and lyrics, in that order) and
aligns the lyrics syllables of the second piece under the notes of the
first piece.  If you would reverse the order, the notes would be
aligned on the lyrics, which is not very useful. (Besides, it looks
silly.)COMMENT(

)verb(
        \context Staff = mel {
)COMMENT(

)This is first piece of music.  We instantiate a code(Staff) context
explicitly: should you chose to remove comment before the ``note
heads'' version of the accompaniment, the accompaniment will be on a
nameless staff.  In that case, the melody has to be on a different
staff as the accompaniment.  This is accomplished by giving the melody
staff a different name.COMMENT(

)verb(
        \property Staff.noAutoBeaming = "1"
)COMMENT(

)An interpretation context has variables that tune its behaviour.  One
of the variables is code(noAutoBeaming).  If set and non-zero (i.e.,
true) LilyPond will not try to automatic beaming on the current
staff.COMMENT(

)verb(
        \property Staff.automaticMelismas = "1"
)COMMENT(

)Similarly, we want do not want to put a lyric syllable when there is
a slur. This sets up the Staff context to signal slurs while
code(\addlyrics) is processed. COMMENT(

)verb(
          \melody
        }
)COMMENT(

)Finally, we put the melody on the current.  Note that the
code(\property) directives and code(\melody) are grouped in sequential
music.  So the property settings are done before the melody is
processed.  COMMENT(

)verb(
        \context Lyrics \text
)COMMENT(

)The second argument of code(\addlyrics) is the text.  Text also
should land on a Staff, but on a context for syllables,
extenders, hyphens etc.  This context is called Lyrics.COMMENT(

)verb(
        }
)COMMENT(

)This ends code(\simultaneous).COMMENT(

)verb(
        \midi  { }
)COMMENT(

)This makes the music go to a MIDI file as well.  MIDI is great for
checking music you enter.  You listen to the MIDI file: if you hear
something unexpected, it's probably a typing error.  code(\midi) is a
`output definition', a declaration that specifies how to output music
analogous to code(\paper { }).COMMENT(

)verb(
        \paper { linewidth = 10.0\cm; }
)COMMENT(

)We also want notation output.COMMENT(

)verb(
        }
)COMMENT(

)End the score block.