1 mailto(gnu-music-discuss@gnu.org)
4 redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
7 COMMENT( This document contains Mudela fragments. You need at least
8 Yodl-1.30.18 to convert this to tex or html.
12 pipethrough(date) sucks.
14 paragraphs have too much space.
19 Mainly written by Han-Wen Nienhuys,
21 with help of (among others)
33 htmlbodyopt(bgcolor)(white)
34 htmlcommand(<font color=black>)
38 \textheight 53\baselineskip
39 \advance\textheight by \topskip
40 \marginparwidth 1 in % Width of marginal notes.
41 \oddsidemargin 0.25 in % Note that \oddsidemargin = \evensidemargin
42 \evensidemargin 0.25 in
43 \marginparwidth 0.75 in
44 \textwidth 5.875 in % Width of text line.
48 whenlatex(notableofcontents())
49 whentexinfo(notableofcontents())
51 article(Mudela -- Using LilyPond to typeset music)
52 (Han-Wen Nienhuys and Jan Nieuwenhuizen)
53 (nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())
56 latexcommand(\def\interexample{})
57 latexcommand(\def\preexample{\par})
58 latexcommand(\def\postexample{\par\medskip})
59 latexcommand(\def\file#1{{code(#1)}})
62 includefile(html-disclaimer.yo-urg)
67 label(tutorial:introduction)
68 latexcommand(\parindent2pc)
70 LilyPond is a program that can print music from a specification that
71 you, the user, supply. Using LilyPond may be a bit quaint in the
72 beginning, because you have to give that specification using a
73 em(language). This document is a gentle introduction to that
74 language, which is called Mudela, an abbreviation for Music Definition
77 We will demonstrate the working of Mudela by presenting examples of
78 input alongside with the resulting output. We will comment on these
79 examples using English terms for notation, so if you are not familiar
80 with these terms, you should consult the glossary that is distributed
81 with LilyPond: it contains a list of musical terms along with
82 explanations and translations in some other languages.
87 To demonstrate what LilyPond input looks like, we start off with a
88 full fledged, yet simple, example. It is a convoluted version
89 of one of the menuets in bind(J.)bind(S.)Bach's em(Clavierbuchlein).
92 % lines preceded by a percent are comments.
101 d4 g,8 a b c d4 g, g |
102 e'4 c8 d e fis g4 g, g |
103 c4 d8( )c b a( )b4 c8 b a g |
109 g4 e8 fis g d cis4 b8 cis a4 |
110 a8-. b-. cis-. d-. e-. fis-.
117 linewidth = 14.0 \cm; % standard settings are too wide for a book
121 Before we will discuss the contents of the above, it would be best if
122 you would try to enter and save this text with a text editor, compile
123 it with LilyPond and view the output. Details of this procedure may
124 vary from system to system. On a Unix system, you should enter the
125 input in a file ending in file(.ly), such as file(menuet.ly). To
126 create the output, one would issue code(ly2dvi menuet).
128 file(ly2dvi) is a little program that does the job of calling the
129 LilyPond and TeX() and adjusting page margins.
131 If all goes well, this will create the output file file(menuet.dvi).
132 To view this output, issue the command code(xdvi menuet). Now that we
133 are familiar with the procedure to view the output, we will analyse
134 the input itself, line by line.
136 verb(% lines preceded by a percent are comments.)COMMENT(
138 )The percent sign, `code(%)', introduces a line comment. If you want
139 make larger comments, you can use block comments. These are delimited
140 by `code(%{)' and `code(%})'
142 verb(\input "paper16.ly")
144 By default, LilyPond will use definitions for a staff of 20
145 nop(point)footnote(A point is the standard measure of length for
146 printing. One point is 1/72.27 inch.)
148 high. If you want smaller output (e.g., 16 point), you have to import
149 the settings for that size. You can do this by including a file.
150 code(\include "file") is replaced by the contents of code(file).
151 LilyPond will inspect the standard search to look for the requested
157 ) A mudela file combines music with directions for outputting that
158 music. The music is combined with the output directions by putting
159 them into a code(\score) block.
164 )This makes LilyPond ready for accepting notes.
169 ) As we will see, pitches are combinations of octave, note name and
170 chromatic alteration. In this scheme, the octave is indicated by
171 using raised quotes (`code(')') and ``lowered'' quotes (commas:
172 `code(,)'). The central C is denoted by code(c'). The C one octave
173 higher is code(c''). One and two octaves below central C is denoted
174 by code(c) and code(c,) respectively.
176 If you have to indicate the pitches in a long piece that is written in
177 either a high or very low octave, you would have to type very many
178 quotes. To remedy this, LilyPond has a so-called ``relative'' octave
179 entry mode. In this mode, notes without quotes are chosen in such an
180 octave that they are the closest to the preceding note. If you add a
181 high-quote an extra octave is added. The lowered quote will substract
182 an extra octave. Because the first note obviously has no predecessor,
183 you have to give the (absolute) pitch of the note to start with.
187 { % sequential music follows
190 ) The brace indicates that what follows is sequential music, i.e.,
191 notes that are to be played and printed after each other. This is in
192 contrast with simultaneous music: notes that are to be played like a
193 chord. You should be careful not to confuse this brace with the one
194 coming after code(\score).
198 \time 3/4; % set the time signature.
201 ) This command changes the time signature of the current piece: this
202 prints a 3/4 sign. The 3/4 value is also used to generate bar lines
208 ) This command changes the current key to G-major. Although
209 this command comes after the code(\time) command, in the
210 output, the key comes before the time signature: LilyPond knows about
211 music typesetting conventions.
216 ) This command tells LilyPond that the enclosed piece of music must
222 ) This is a code(d) note. The relative music was started with a
223 code(c''), the real pitch of this note is code(d''). The 4
224 designates the duration of the note (it is a quarter note). COMMENT(
230 )These are notes with pitch code(a') and code(b'). Because their
231 duration is the same as the code(g), there is no need to enter the
232 duration (It is not illegal to enter it anyway. You would then enter
233 code(a8 b8)) COMMENT(
239 ) Three more notes: The code(|) is a ``barcheck''. When processing the
240 music, LilyPond will check that barchecks are found at the start of
241 a bar. This can help you track down notes you forgot to enter.
246 ) So far, no notes were chromatically altered. Here is the first one
247 that is: code(fis). Mudela by default uses Dutch note names, and
248 ``Fis'' is the Dutch note name for ``F sharp''. However, there is no
249 sharp sign in the output. The program keeps track of key signatures,
250 and will only print accidentals if they are needed.
252 c4 d8( )c b a( )b4 c8 b a g |
255 ) The next line shows something new: In mudela, one enters a slur by
256 marking the beginning and ending note of the slur with an opening and
257 closing parenthesis respectively. In the line shown above this is
258 done for two slurs. Note that parentheses (slur markers) are between
259 the notes. As you can see, parentheses do not have to nest.
264 ) A duration that is to be augmented with a duration dot, is notated
265 with a duration number followed by periods, as many as you want
271 ) The end of the repeated music. LilyPond will typset a repeat bar.
276 ) This line shows that Lily will print an accidental if that is
277 needed: the first C sharp will be printed with an accidental, the
278 second one without. COMMENT(
280 )verb( a8-. b-. cis-. d-. e-. fis-. % try some super and subscripts.)COMMENT(
282 )There is more to music than pitches and rhythms. An important
283 aspect is articulation. You can enter articulation signs either in an
284 abbreviated form, by a dash and the the character for the
285 articulation to use, e.g. code(-.) for staccato as shown above.
293 Rests are denoted by the special notename code(r). You can also make
294 an invisible rest by using the special notename code(s).
299 ) All articulations have a verbose form, like code(\fermata). The
300 ``command'' COMMENT(Hi Adrian :-) code(\fermata) is not part of the
301 core of the language (most of the other discussed elements are), but
302 it is an abbreviation of a more complicated description of a fermata.
303 code(\fermata) names that description and is therefore called an
311 This ends the sequential music.
316 This specifies a conversion from music to notation output. Most of
317 the details of this conversions (font sizes, dimensions, etc.) have
318 been taken care of, but to fit the output in this document, it has
319 to be smaller. We do this by setting the line width to 10 centimeter
320 (approximately 4 inches).
326 )The last brace ends the code(\score) block.
330 There are a couple of things to note here. The input format tries to
331 capture the meaning of em(music), and not notation. Therefore the
332 format contains musical concepts like pitches and durations, instead
333 of symbols and positions. Second, the format tries to be
334 em(context-free): a note will sound the same regardless of the current
335 time signature, the key nop(etc.)
337 The purpose of LilyPond informally is explained by the term `music
338 typesetter'. As you may have figured out by now, this is not a really
339 adequate name: not only does the program print musical symbols, it
340 also tries to make esthetic decisions, and it also em(generates) both
341 the symbols and the decisions from a high-level musical description.
342 In other words, the function of LilyPond would be best described by
343 `music compiler' or `music to notation compiler'.
345 As you can see, the most interesting part of the input is music
346 itself, in this case the sequence of notes. We will therefore focus
347 on entering music for now. Consequently, when we mean
353 ) we will leave out the the repetitive details for now and only print
358 sect(When you know the notes to nop(print)ellipsis())
360 The basic building block of music is the note. We lightly touched
361 notes in the previous example. Here comes the full explanation A note
362 is made of a pitch and a duration. The pitch of the central C is
363 written as code(c'). This is in line with musicological notation;
364 there this pitch is transcribed as nop(c)sups(1) or c'. A
365 quarter-note duration is written as code(4). So, to print a quarter
366 note whose pitch is central C, you enter the following code(c'4).
370 The duration of a note is specified as a number: a whole note is
371 denoted by 1, a half note by 2, a quarter by 4, and so on. If you
372 want to augment a duration with a dot, simply affix a period to the
373 number. You can also print notes longer than a whole. You do this by
374 using identifiers (code(\breve) and code(\longa)):
375 Here are some random notes to show how it works.
379 c'1 c'2 c'4 c'8 c'16 c'32 c'64 c'64 c'2. c'8. c'16
386 c'1 c'2 c'4 c'8 c'16 c'32 c'64 c'64 c'2. c'8. c'16
390 \translator { \type "Score_engraver";
392 \consists "Note_heads_engraver";
393 \consists "Stem_engraver";
394 \consists "Rhythmic_column_engraver";
399 subsect(Basic pitches)
401 The pitch code(c') consists of two parts: one part for the note name,
402 and one for the octave. The letter specifies which note name to use:
403 note names simply are the letters code(a) to code(g). The number of
404 apostrophes specifies the octave to use: the central C is denoted by
405 code(c').footnote(By convention, the A above central C at concert
406 pitch is the tone that is used to tune instruments. Its frequency is
407 about 440 Hz.) The C which is an eighth higher (the C in the
408 ``two-line octave'') is denoted by code(c''): every octave adds a
409 quote. A note name without quotes designates the pitch below code(c')
410 (the C in the ``small octave''). If you want to go down even further,
411 commas (sunken apostrophes) should be added, e.g., the C in the
412 ``contra octave'' is expressed as code(c,,).
414 This example demonstrates pitches
415 mudela(fragment,verbatim,center)(
416 c,,4 c, c c' c'' c''' d'4 e'4 f'4 g'4
422 We have so far ignored chromatically altered pitches. The names `a'
423 to `g' for entering pitches are convenient: they are short,
424 pronounceable and they resemble the words for pitches in normal
427 Enter flats and sharps. In English there is no standard terse word
428 for C sharp or C flat. For this reason, mudela uses a different,
429 non-English convention for entering altered pitches: a note is made
430 sharp by adding the suffix `--is' to its name, and flat by adding the
431 suffix `--es'. For a double sharp another `--is' suffix is added, for
432 flats another `--es' nop(suffix.) footnote(Variations on this
433 convention are used in a number of germanic languages, notably Dutch,
434 German, Swedish, and Norwegian.) The names for the alterations of C
435 are given in bind(Table)ref(notename-tab).
437 latexcommand(\begin{table}[h])
440 row(cell(English)cell(LilyPond))
442 row(cell(c double flat)cell(ceses))
443 row(cell(c flat)cell(ces))
444 row(cell(c natural)cell(c))
445 row(cell(c sharp)cell(cis))
446 row(cell(c double sharp)cell(cisis))
449 latexcommand(\caption{Default note names})
451 latexcommand(\end{table})
453 Throughout this document we will continue to use these names.footnote(
454 Mudela defaults to Dutch notenames. To make (Dutch) pronunciation
455 easier, the a-flat and e-flat are contracted to code(as) and
456 code(es). Similarly, the a double flat and e double flat are
457 contracted to code(ases) and code(eses). For consistency, the dutch
458 names also include code(aes), code(aeses), code(ees) and
461 If you are not comfortable with these names, you can make your own.
462 Note names for different languages are included with the example
463 initialisation files, amongst others English (C sharp is abbreviated
464 to code(cs)), Italian, Swedish and Norwegian. If you want to use
465 these names, issue code(\include "LANGUAGE.ly") where you could
466 substitute code(italiano), code(deutsch) etc. for LANGUAGE. You
467 should include these files at toplevel, i.e., before opening a
473 The previous examples all notes that were to be played sequentially, one
474 note following the other. You can also use LilyPond to typeset
475 chords. You do this by expressing in mudela simultaneous music,
476 i.e., notes that are to be played concurrently.
478 subsect(Where the chords have no names)
479 In Mudela you can form simultaneous music by enclosing notes in
480 pointed parentheses, bind(i.e.)bind(langle())bind(and)rangle(). ASCII
481 doesn't really have these delimiters, so Mudela uses the larger-than
482 (code(>)) and smaller-than (code(<)) signs instead. For example, a
483 D-major chord is expressed as
484 mudela(fragment,verbatim,center)(
488 Chords can be entered in the music in the same places that notes
489 can. As an example we give a snippet of ``Twinkle Twinkle Little
490 Star'' in chords. The chords may seem slightly unconventional, but
491 they only serve to show how chords work. We've aligned the chords in
492 the input on their starting beat to help you reading it. This
493 layout does not influence the typesetting result in any way.
495 mudela(verbatim, fragment)(
499 <c e a> <b d a'> <b2 d g>
500 <a4 d f> <bes d f> <bes c e> <g c e>
501 <e a d> <a, g' cis'> <d2 f d'>
505 There is one thing to note, in sequences of chords, the (relative)
506 pitch of a is taken with reference to the first note of the previous
509 You can nest simultaneous and sequential music in any way you want,
512 )mudela(verbatim,fragment,center)(
514 { c'8 <c' e'> c' <c' e'> } >
518 As you can see, LilyPond has difficulty typesetting this
519 elegantly. To adequately solve this, you have to persuade LilyPond to
520 make separate stems for both sequential music lists. This is a topic
521 that is covered in bind(Section)ref(sec:polyphonic).
523 [Chords and relative mode]
525 subsect(Chords with names)
527 In the previous section we have been talking more about `stacked notes'
528 rather than `chords'.
529 If you need to enter a lot of chords that have proper names, you can use
530 the code(\chords) mode as an alternative:
532 )mudela(verbatim,fragment,center)(
533 \chords\transpose c''{ c1 d e }
536 \chords\relative c''{ c1 d e }
539 subsect(Names with chords)
541 A more common problem is the typesetting of chord names. LilyPond has
542 a special kind of staff for this, the code(ChordNames) staff.
543 The code(ChordNames) staff accepts music like a normal staff,
544 but typesets only the name of each chord:
547 )mudela(verbatim,center)(
549 \context ChordNames {
551 { c1 d-min e-maj5+.9 }
559 ) Because the ChordNames staff accepts normal music, it can be transposed,
560 and you may enter it any way you like, either as chords or as notes.
562 sect(Adding nuances: articulation and dynamics)
564 Music can have articulation, dynamics (louder and softer), etc. These
565 aspecs have notation, so LilyPond can print those. We'll start out by
566 explaining how to obtain the smallest grains of nuance: the
567 articulation of a single note. Articulation is entered by writing a
568 dash and the name of the desired articulation mark. You have to add a
569 backslash in front of the name to distinguish it from the name of a
572 )mudela(fragment,verbatim)(
574 c''4-\tenuto )COMMENT(
576 ) Typing a lot of staccato notes in this syntax will get tedious very
577 quickly. Therefore, Mudela has handy abbreviations for
578 articulation marks such as staccato and tenuto. They are shown in the
579 following example: COMMENT(
583 \property Score.textstyle = typewriter
584 \context Staff \notes {
592 \context Lyrics\lyrics {
593 "."4 "-" "+" "|" ">" "\^{ }" }
595 \paper { linewidth = -1.\cm; }
598 )Text and digits for fingering can be entered in the same manner: add a
599 dash and the text or digit to be printed:
602 )mudela(fragment,verbatim)(c''4-1 g''4-5 c''-"Sul tasto" )
603 COMMENT(Currently, the meaning of the
604 syntax `note-dash-digit/articulation/text' is ``add a superscript to this
605 note.'' This is not in line with our goal to em (define) music with
606 Mudela. We hope that this will be fixed in a future version of the
607 language. In the meantime you can abuse this: the super- and
608 subscripts can be forced into up or down position respectively by entering an
609 a caret (code(^)) or an underscore, code (_) instead of the dash:
610 mudela (fragment,verbatim,center) (
611 c'4-^ c'4^^ c'''4-^ c'''4_^
614 Dynamic markings are another way to add a nuance to a note. They are
615 entered by adding the name for the dynamic sign after the note. You
616 should not enter a dash between the name and the note.footnote(This
617 is inconsistent. We hope that this will be fixed in a later
618 version of the language.)COMMENT(
620 )mudela(verbatim,fragment)(
621 c4 \ff c4 \fp c4 c4 \ppp c4 c4 \sfz
627 sect(Bridging the notes: beams, slurs and ties)
629 Music typesetting does not use fixed symbols only. A lot of symbols
630 are variable: they run from one note to another. In LilyPond
631 terminology, such a symbol is called a em(spanner). To print a
632 spanner, you have to attach a marker to the note that begins it and to
633 the one that ends it. These are the spanners that are entered like
638 The slur has the opening parenthesis as
639 start marker is. The stopping marker is the closing parenthesis.
641 mudela(fragment,center,verbatim)( c'4( )c'4 )
643 The slur is flexible: you can nest nop(slurs,)footnote(This is
644 inconsistent when compared to the syntax for articulation hints. This
645 will be fixed some time, we hope.) and you can connect a note with a
646 slur on both the left and the right side:
648 mudela(fragment,verbatim,center)(
649 c'4(( )c''4 )c'4( )g'4
654 The starting marker for the beam is the opening bracket, the ending
655 marker is the closing bracket. The brackets have to be em(around) the
656 beamed notes. footnote(Strictly speaking, a beam is not a musical
657 concept: beaming doesn't change the meaning of music, it only
658 clarifies the rhythmic structure. One might argue that beams should
659 not be present in a music representation language. Unfortunately,
660 LilyPond is not smart enough to insert beams into music on its own.
662 LilyPond does have code that guesses what the pattern should look
663 like, so that you don't have to specify the beaming for complicated
664 patterns. Alas, the algorithm used is not foolproof
665 yet: code([c8. c32 c32]) will produce incorrect results.)
667 mudela(fragment,verbatim)(
668 [c'8 c'] [c'16 c' c' c'] [c'16. c'32 c' c'16.]
671 The brackets themselves have no duration, so they are grammatically
672 equivalent to the barcheck.
674 dit(Tie) LilyPond's tie is entered as a tilde, `code(~)', in analogy
675 with TeX()'s tie (which ties together words with a space), The tie is
676 similar to the slur: it looks like a slur, but a slur connects whole
677 chords, whereas the tie connects note heads.
679 The following example demonstrates the use of ties:
680 mudela(fragment,verbatim,center)(
682 <c'2. g' es''> ~ <c'4 g' es''>
685 Since the tie is thought to be inbetween the notes, it has no
686 duration, and is grammatically equivalent to the barcheck.
689 Crescendi and decrescendi can be printed in hairpin style. The
690 starting marker for the crescendo is code(\<), and for the decrescendo
691 code(\>). Both have code(\!) as the ending marker.
692 mudela(fragment, verbatim)(
693 \relative c'' { c4 \< \! c4 \> \! c2
695 { s4 \< \! s4 \> \! s2 } > }
697 This example shows a trick: by attaching the markings to space rests
698 that run parallel to the whole note, you can have dynamic markings
703 It is your job to make sure that each spanner that you start, also
704 ends. If it doesn't, then Bad Things are likely to happen. If you end
705 spanners that are not started, LilyPond will warn you about illegal
711 Music notation constructs with no duration, like clefs and key
712 signatures, can be entered by inserting various
713 commands between the music. The general form of these commands is
716 )center(code(\keyword argument argument ... ;))COMMENT(
718 )These are the commands that are currently supported in alfabetic order:
720 dit(code(\bar) var(bartype))
721 This command makes LilyPond print special bar
722 lines and repeat symbols. You can also use it to allow line breaks
723 when entering cadenzas. The argument var(bartype) is a string that
724 describes what kind of bar line to print.
727 )mudela(fragment,verbatim)(
728 \bar "|:"; c'4 \bar ":|:"; c'4 \bar ":|"; c'4 \bar "||";
729 c'4 \bar "empty"; c'4 \bar "|.";
732 )The command `code(\bar "empty")' does not create any visible bar
733 line, but it tells LilyPond to allow a linebreak at that position.
734 The `code(\bar)' command prints the specified symbol where you enter
735 it. If you give a `code(\bar)' command at the end of a measure then
736 the specified symbol replaces the automatic bar line.
738 The code(\bar) command does not affect metric structure.
740 dit(code(\cadenza) var(togglevalue)) This command toggles the
741 automatic printing of barlines. `code(\cadenza 1)' turns off the
742 automatically generated bar lines. They are switched on again with
743 `code(\cadenza 0)'. Then a bar line is printed, and LilyPond will act
744 as if you are again at the start of a measure.
747 This is useful when typesetting music without a meter (such as an ad
750 dit(code(\clef) var(clefname)) This command sets the current clef for notation,
751 i.e., a clef symbol is printed and the notes following this command
752 are shifted vertically. The argument is a string, the name of the
753 new clef. The default clef is the treble clef.
754 mudela(fragment,verbatim)(
760 dit(code(\key) var(pitch) var(type)) This command changes the current
761 key signature. The key signature is printed at the start of every
762 line. The var(type) argument is an integer. Useful values are
763 available as the predefined identifiers code(\major) and
764 code(\minor). Omitting the second argument gives major keys. The
765 key of C-minor can thus be specified as `code(\key es)' or
766 `code(\key c \minor)'.
768 dit(code(\keysignature) var(pitchlist))
770 This command changes the current key signature. Unlike the
771 `code(\key)' command, this command can produce arbitrary key
772 signatures, which can be useful for unconventional keys or modes. The
773 key signature is given in the form of a list of notes. The notes will
774 be printed in the key signature in the order that they appear on the
775 list. For example, the key of C-minor can be specified as
776 `code(\keysignature bes es as)'. The command `code(\keysignature fis
777 es bis)' provides a more exotic example.
780 dit(code(\time) var(numerator)code(/)var(denominator))
781 This command changes the current time signature.
782 The default value for this time signature is common time (4/4).
784 dit(code(\partial) var(duration))
785 This command allows you to make
786 upsteps at the start of a piece.
787 The var(duration) argument has the same form as the duration of a
790 The `code(\partial)' command cannot be used to generate partial
791 measures in the middle of the music.
793 mudela(fragment,verbatim)(
796 [d'8 dis'] e' c''4 e'8 c''4
799 dit(code(\grouping) var(durationslist)) sets the metric structure of the measure.
800 Its effect can best be shown by an example:
801 mudela(fragment,verbatim,center)(
811 In practice, you won't be needing this command often: the
812 grouping is switched automatically when you issue a code(\time)
813 command. It is set to a combination of groups
814 of 2 and 3 beats, with as many groups of
815 3 as possible (in other words: 4/4 is divided in two times two beats
819 The commands described above aren't really music, but they can best be
820 thought as as notes with no duration. Since they are grammatically
821 equivalent to notes, these commands can be used in the same places as
824 sect(Notation context)
826 COMMENT(This section is about translation contexts, a topic of LilyPond that
827 is advanced. You don't have to understand this to use
828 LilyPond to print simple music. If you don't want to typeset fancy
829 polyphonic music or tweak the LilyPond notation engine, you can skip
830 the next two sections.)
832 In bind(Section)ref(tutorial:more-staffs) it was explained that there
833 are more ways to notate a simple chord: as a single voice on a single
834 staff or in multiple staffs (and we'll soon see, that you can typeset
835 it as multiple voices on a staff). Obviously the concept of staff is
836 not really something musical. But what is it then?
838 The most simplistic explanation is: a staff is a graphic peculiarity
839 of the notation system. In other words, a staff is a picture of five
840 lines on which one can print note heads. We will call this view on
841 the concept of staff `staff symbol' from now on.
844 there is more to a staff than the symbol. A staff
845 contains---besides a staff symbol--- more components:
849 it()A staff can have a key signature (printed at the left)
850 it()A staff can have a time signature (printed at the left)
851 it()A staff has bar lines
852 it()A staff has a clef (printed at the left)
856 To explain what a staff really is, we'll try to print music without
857 these components. Without those, it is still
858 possible to print music:
860 \notes \relative c' { \time 2/4; g'4 c,4 a'4 f4 e c d2 }
865 \remove "Time_signature_engraver";
866 \remove "Bar_engraver";
867 \remove "Staff_symbol_engraver";
868 \remove "Clef_engraver";
869 \remove "Key_engraver";
874 ) As you can see, you can still make out the general form of the
875 melody and the rhythm that is to be played, but the notation is
876 difficult to read. Moreover, the musical information is not complete.
877 The stress pattern in the notes can't be deduced from this output.
878 For this, we need a time signature:
882 \notes \relative c' { \time 2/4; g'4 c,4 a'4 f4 e c d2 }
887 \remove "Bar_engraver";
888 \remove "Staff_symbol_engraver";
889 \remove "Clef_engraver";
890 \remove "Key_engraver";
894 )Technically speaking you can find out where the strong and weak beats are, but
895 it is difficult to find them quickly. Bar lines help you in finding
896 the location of the notes within the measure:
899 \notes \relative c' { \time 2/4; g'4 c,4 a'4 f4 e c d2 }
904 \remove "Staff_symbol_engraver";
905 \remove "Clef_engraver";
906 \remove "Key_engraver";}
911 We can remedy part of the difficulties with reading pitches by adding a staff
915 \notes\relative c' { \time 2/4; g'4 c,4
916 a'4 f4 e c d2 } \paper {
921 \remove "Clef_engraver";
922 \remove "Key_engraver";
928 This makes the output decidedly easier to read, but you still don't
929 know what the pitches of the notes above are. So this is still not
930 enough. But suppose you see the following notation:
932 \notes \relative c' {\clef alto; \time 2/4; g'4 c,4 a'4 f4 e c d2 }
938 ) Now you know the pitch of the notes: you look at the start of the line
939 and see a clef, and with this clef, you can determine the notated pitches.
940 You have found the em(context) in which the notation is to be
943 So the context determines the relationship between a piece of music
944 and its notation: you, the reader, use context to deduce music from
945 notation. Because LilyPond writes notation, context works the
946 other way around for LilyPond: with context a piece of music can be
947 converted to notation.
949 We see that a staff forms context, and that context is needed to
950 convert between notation and music. In LilyPond we turn around this
951 reasoning: LilyPond has a notion of notation context, and the staff is
952 an example of a notation context. In fact, the arguments of the
953 code(\context) command (Staff, GrandStaff) were all names of different
954 contexts. A notation context is a conversion between music and
957 We make one final observation before listing the standard notation
958 contexts: a score can contain many staffs and a staff can contain many
959 voices. This suggests that notation contexts are objects that can
960 contain other notation contexts.
963 is a list in alfabetic order of the contexts that are supported by
964 LilyPond. Each notation context is characterised by its name, the
965 notation elements it creates, and the contexts that it can contain.
969 dit(GrandStaff) A code(GrandStaff) context contains code(Staff)
970 contexts, and it adds a brace to the output at the
971 nop(left.)footnote(The GrandStaff is limited, LilyPond can not do
972 cross staff beaming and slurring.)
974 A code(GrandStaff) context can contain code(Staff)s. Typically, it
975 will contain two code(Staff)s, one treble staff, and one bass
976 staff. The bar lines of the contained staffs are connected
979 dit(Lyrics) As its name suggests, The code(Lyrics) context deals with
980 typesetting lyrics. This topic will be covered in
981 bind(Section)ref(tutorial:lyrics).
983 dit(Score) The code(Score) context is the toplevel context: no context
984 can contain a code(Score) context. The code(Score) context handles
985 the administration of time signatures. It also makes sure that
986 items such as clefs, time signatures, and key-signatures are aligned
987 in columns across staffs.
989 The code(Score) can contain code(Staff), code(StaffGroup),
990 code(Lyrics), code(GrandStaff) and code(RhythmicStaff) contexts.
992 dit(RhythmicStaff) The code(RhythmicStaff) context is like the staff,
993 but much simpler: the notes are printed on one line, and pitches are
994 ignored. code(RhythmicStaff) can contain code(Voice)
998 dit(Staff) The code(Staff) context handles clefs, bar lines, keys,
999 accidentals. A code(Staff) context can contain code(Voice)
1002 dit(StaffGroup) A code(StaffGroup) context contains
1003 code(Staff) or code(Lyrics) contexts, and prints a bracket at the
1004 left. The bar lines in the participating staffs are connected.
1007 dit(Voice) The code(Voice) context is a context that corresponds to a
1008 voice on a staff. This context handles the conversion of noteheads,
1009 dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests
1011 COMMENT(do ChoireStaff)
1015 If you are familiar with structured documents, you might see the
1016 analogy of a context with a stylesheet: a stylesheet is neither
1017 presentation nor information, but rather a recipe em(how) a specific
1018 piece of information should be presented. The big difference with
1019 stylesheets is that in music notation the elements provided by context
1020 are essential to understanding what is notated.
1022 The notions of ``current clef'' and ``current position within the
1023 measure'' are all properties of notation contexts. Commands like
1024 code(\clef) and code(\cadenza) change these properties, and this
1025 explains why they are fundamentally different from musical expressions
1026 like notes and rests.
1028 A notation context is not a primitive element of LilyPond: in
1029 bind(Section)ref(tutorial:engravers) it will be explained how you can
1030 form your own notation contexts.
1032 sect(Nested music: multiple staffs)
1033 label(tutorial:more-staffs)
1035 Now we explain how to typeset music that runs in multiple staffs.
1036 Consider the following---unrealistic---example:
1039 \context GrandStaff <e'4 {\clef bass; g4^""} >
1042 In this example the music consists of two notes. The above would
1043 sound the same if it were written as a single chord on a single staff,
1050 ) The Mudela construct for multiple staffs reflects the similarity
1051 between the two examples: to get multiple staffs in Mudela you enter a
1052 chord, with an additional instruction to tell LilyPond that the chord
1053 does not represent notes stacked together, but staffs stacked
1056 If a piece of music is to be interpreted as a staff, then this can be
1057 expressed with the code(\context) construct. The following input says
1058 ``the quarter note with pitch e should be put on a staff.''
1064 ) The same can be done for the other note, i.e.,
1070 ) If you want to stack these staffs, you must create a chord of both:
1073 < \context Staff e'4
1078 This looks reasonable, but the effect of this input is not what you
1081 < \context Staff e'4
1086 ) Since there are no names specified for the desired staffs, LilyPond
1087 thinks your wishes are fullfilled by putting the code(g) on the same
1088 staff as the code(e). The correct solution is to label both staffs
1089 with different names, for example code(trebleStaff) and
1090 code(bassStaff). This makes LilyPond distinguish between them, and
1093 mudela(verbatim,fragment)(
1094 < \context Staff = trebleStaff e'4
1095 \context Staff = bassStaff g4
1099 ) The names that you choose do not matter as long as they are
1100 different. This is almost right, except for the brace at the left and
1101 the clef of the second staff. If you want a brace, then you have to
1102 tell LilyPond that the chord you formed is to be interpreted as a
1103 so-called grand staff. This is also done with the code(\context)
1104 command. The bass clef is made with a clef command: COMMENT(
1106 ) mudela(verbatim,fragment)(
1107 \context GrandStaff <
1108 \context Staff = treblestaff e'4
1109 \context Staff = bassstaff { \clef "bass"; g4 }
1114 sect(Polyphonic music (or: Notation context properties))
1115 label(sec:polyphonic)
1117 In the section on notation contexts we explained that a notation
1118 context can have properties that influence the conversion from music
1119 to notation. A simple example of such a property is the clef: the
1120 type of a clef helps determines the vertical position of note heads in
1121 a staff. Some of these properties can be modified by commands such as
1122 code(\clef) and code(\time). But notation contexts can have other
1123 properties, that are settable in
1124 a generic fashion. We will demonstrate this feature by printing
1125 multiple voices on a staff.
1127 Printing more than one voice on a staff is like printing multiple
1128 staffs stacked together. This suggests that the template to follow is
1133 \context Voice = one ...
1134 \context Voice = two ...
1138 ) On the ellipsis there should be music going from left to right, in
1139 other words, notes enclosed in braces. Let us try the following counterpoint:COMMENT(
1141 )mudela(fragment,verbatim)(
1143 \context "Voice" = "one" { r4 as'4 () as'4 g'4 }
1144 \context "Voice" = "two" { g'2 f'4 e'4 }
1147 As you can see the result is not perfect. The notes on the last
1148 two beats look like plain chords and not like separate voices. What
1149 really happened was that the stems of the upper and lower voices were
1150 printed on top of each other.
1152 To remedy this, engravers traditionally make the stems of the lower
1153 voice point down, and the stems of the upper up, as shown in
1154 bind(Figure)ref(tutorial:multi-voice-fig).
1156 Surely the direction of a single stem is a property of the stem as a
1157 graphical object. But the fact that all of the stems in a voice point
1158 in the same direction is not directly graphical. Since this is a
1159 property shared by all the stems in the voice, this property is a
1160 property of the context code(Voice). The context code(Voice) has an
1161 attribute whose value is the direction to use for stems. You can
1162 change it to `up' by issuing the following phrase:
1164 \property "Voice"."verticalDirection" = "1"
1167 This command should be read as ``change the property called
1168 code(verticalDirection) within the current code(Voice) context to the value
1169 code(-1).'' For the property code(verticalDirection) the value code(1) means
1170 `up', and code(-1) means `down'. So, the
1171 proper way to code the polyphonic example is given in
1172 bind(Figure)ref(tutorial:multi-voice-fig).
1174 latexcommand(\begin{figure}[h])
1175 mudela(fragment,verbatim,center)(
1177 \context "Voice" = "one" {
1178 \property Voice.verticalDirection = "1"
1179 r4 as'4 () as'4 g'4 }
1180 \context "Voice" = "two" {
1181 \property Voice.verticalDirection = "-1"
1185 latexcommand(\caption{Multiple voices})
1186 label(tutorial:multi-voice-fig)
1187 latexcommand(\end{figure})
1189 As you can see, this property also controls the directions of slurs.
1191 Other properties can also be set, and they can be within different
1192 contexts. In general, you can set a property by specifying
1193 code(\property) var(contexttype)code(.)var(propertyname) code(=)
1194 var(value). Both var(contexttype), var(propertyname) and var(value)
1197 The effect of a property is pretty much hardwired into the
1198 implementation (and thus subject to change), so we will not deal with
1199 all the possible properties in detail. Among other characteristics
1200 that can be set are the layout of slurs and beams. The initialisation
1201 file file(property.ly) and the reference manual contain explanations
1205 label(tutorial:lyrics)
1207 Since a lyrics can have durations like notes, we consider them to
1208 be music too. Entering lyrics in mudela has two aspects. First, you
1209 have to enter the text, i.e., the syllables along with their
1210 durations. After this, you have to specify how to convert these to
1213 Lyrics consist of syllables, which are strings together with
1214 durations. For entering lyrics we have to instruct LilyPond that what
1215 we enter are not note names but strings. This instruction is the
1216 keyword code(\lyrics). After entering this keyword you can enter a
1217 musical construct---sequential music, simultaneous music, code(\context)
1218 entries, etc.--- but with syllables instead of pitches. For example:
1221 )verb(\lyrics { 'got8 me on my knees4, Le-8 lie! })COMMENT(
1223 ) Next comes the conversion to notation. LilyPond can't (yet) figure
1224 out that lyrics need different treatment than notes. As a result, the
1225 default conversion will try to put the text you entered as note heads
1226 onto a staff, and this will fail. This default must be overridden
1227 with a code(\context) keyword. Printing syllables of text in a line is
1228 done by a context called code(Lyrics). You can select this context
1229 with the code(\context) keyword. Here is a simple example with output:
1232 )mudela(fragment,verbatim)(
1233 \context Lyrics \lyrics { 'got8 me on my knees,4 Le-8 lie! })COMMENT(
1235 )The result is technically correct, but it needs a melody to make it
1236 perfor0mable: COMMENT(
1238 )mudela(fragment,verbatim)(
1241 \property Voice.beamAuto = "0" % no beams in melody
1242 c''8. c''16 bes'8. a'16 g'4 f'8 g'4.
1244 \context Lyrics \lyrics { 'got8. me16 on8. my16 knees,4 Le-8 lie!4. }
1248 ) The strings that makes up each syllable in the lyrics block are
1249 passed along to TeX() verbatim, so if you are proficient with TeX()
1250 you can do various nifty things. Keep in mind that a syllable
1251 either starts with a letter (a character in the range `code(a)' to
1252 `code(z)' or `code(A)' to `code(Z)'), or it is a string enclosed
1253 double quotes. It ends with either a number for the duration, or a space.
1254 These tricks are demonstrated in the following example:
1258 \context Lyrics \lyrics { 'got8 m\textbf{e}8 on8. m$\cal_Y$16 knees,4 Le-8 lie!4.}
1259 \context Lyrics \lyrics { 'got8 m{\bf e}4 on8. m$\cal_Y$16 knees,4 Le-8 lie!4.}
1262 )mudela(fragment,verbatim)(<
1264 \property Voice.beamAuto = "0" % no beams in melody
1265 c''8. c''16 bes'8. a'16 g'4 f'8 g'4.
1267 \context Lyrics \lyrics { 'got8 me8 on8. m$\cal_Y$16 "3s,"4 Le-8 lie!4.}
1272 ) COMMENT(Groen is de kleur van geluk. Dat geldt zeker voor Bj"ork)
1274 sect(Toplevel Mudela)
1276 Back in bind(Section)ref(sec:firsttune) we said we would ignore
1277 toplevel constructions (e.g., code(\score)) until a later moment.
1278 Now we will look at these constructions.
1281 Mudela allows you to name constructs of the language. This is done by
1282 using an em(identifier). Generally you can define an
1283 identifier by entering code(identifierName = ... ) where there can be
1284 a variety of things on the ellipsis.
1286 Here is a (partial) list of what you can abbreviate with identifiers
1289 it()The code(\score) block
1290 it()The code(\paper) block
1291 it()The code(\midi) block (to be explained in
1292 bind(Section)ref(tutorial:sound))
1293 it()Music (sequential music, simultaneous music etc.)
1296 it()Translators (to be explained in bind(Section)ref(tutorial:engravers))
1303 to the abbreviated entity, you must precede code(identifierName)
1304 with a backslash, i.e., code(\identifierName). For example:
1306 czerny = \notes { [c16 g e g] }
1308 \notes \context GrandStaff <
1310 { \clef bass; \czerny \czerny \czerny \czerny}
1318 You can also see identifiers in action within the code(\paper) block:
1319 the value code(-1.0) is assigned to code(linewidth). Within the
1320 code(\paper) block, identifiers are not used as abbreviation only:
1321 assigning to some identifiers can influence the output: in this case,
1322 the music line is printed at natural width.
1324 Recall the properties of a context, that could be set with
1325 code(\property). It is a very general mechanism to tune the output of
1326 the music, that is neatly separated from the real music.
1327 Unfortunately, it is not convenient to type or read, and the precise
1328 effect of a setting property isn't always apparent from its
1329 definition. To remedy this, we can use an identifier to capture the
1330 meaning of a code(\property).
1333 stemup = \property Voice.verticalDirection = "1"
1334 stemdown = \property Voice.verticalDirection = "-1"
1335 shift = \property Voice.hshift = "1"
1337 \context "Staff" \notes <
1338 \context "Voice" = "one" { \stemup r4 as'4 () as'4 g'4 }
1339 \context "Voice" = "two" { \stemup \shift g'2 f'4 e'4 }
1340 \context "Voice" = "three" { \stemdown [d'8 dis'] [d' cis'] [c' b] c'4 } >
1341 \paper{ linewidth = -1.0\pt; }
1344 Several abbreviations like code(\stemup) are defined in the standard
1345 initialisation file file(property.ly). Setting or changing context
1346 properties can have a similar effect as the commands that were
1347 discussed in bind(Section)ref(sec:commands). Don't be fooled by the
1348 similarity in appearance between a declared property-setting entry and
1349 a real command like code(\clef) or code(\bar). Real commands are
1350 hardcoded into the language and they have to be terminated by
1354 label(tutorial:sound)
1356 You get output by combining music with definition a conversion to
1357 output. LilyPond currently supports one other conversion besides
1358 notation: the conversion from abstract music to sound. You can have
1359 LilyPond play the music that you entered. The format that is used for
1360 this output is MIDI. The result is not very pretty, but it is useful
1361 for prooflistening your files: typing errors stand out when you
1362 listen, especially if they involve accidentals.
1364 The only information that you need to enter is the
1365 tempo (Unfortunately, at this time, this the only thing that can be
1366 tuned.). The syntax for the tempo is code(\tempo )var(duration) =
1367 var(beatsperminute);, for example: COMMENT(
1372 \midi { \tempo 4 = 76; }
1377 sect(Contexts revisited: engravers)
1378 label(tutorial:engravers)
1380 As was promised, we will now take a dive into the more wizardrous parts
1381 of LilyPond: redefining (notation) contexts. We previously explained
1385 it()is a conversion from music to notation,
1386 it()can contain other contexts
1387 it()handles specific notation constructs
1390 This characterization almost automatically explains what the definition of a
1391 context should look like:
1393 it() It should define a name
1394 it()It should be part of the ``notation output definition,'' i.e., the
1397 It should contain a specification of what other contexts may be contained
1398 in the context we're defining.
1400 It should contain a list of the notation constructs to be
1404 LilyPond can create notation for a large number of symbols. This code
1405 is split up into basic building blocks. Each building block is called
1406 an em(engraver), and an engraver generally handles only one notation
1407 construct: the code(Clef_engraver) takes care of the clefs, the
1408 code(Time_signature_engraver) takes care of printing time signatures,
1411 A notation context is formed by a group of engravers. A special class
1412 in LilyPond---the code(Engraver_group_engraver)---allows engravers to
1413 cooperate in a group, thus forming a notation context. A variant of
1414 this grouping object is the code(Line_group_engraver_group), which
1415 puts the output of all the engravers (clefs, bars, etc) into a
1416 compound object, so that these symbols can be treated as a whole.
1418 The following definition shows a simplified Staff context: COMMENT(
1423 \context "Line_group_engraver_group";
1426 \consists "Bar_engraver";
1427 \consists "Clef_engraver";
1428 \consists "Key_engraver";
1429 \consists "Local_key_engraver";
1430 \consists "Time_signature_engraver";
1431 \consists "Staff_symbol_engraver";
1433 defaultClef = treble;
1438 ) This context, named Staff, puts its graphic objects into a compound
1439 object (a so-called ``Line group''). At Staff level, bars, clefs,
1440 keys, accidentals, time signatures and the staff symbol are handled.
1441 A staff can contain a Voice context. You can also preset properties
1442 of contexts: for instance, the clef that is printed upon starting a
1443 Staff, is the treble clef.
1447 As a practical example, we will show how to typeset polymetric music,
1448 i.e., music where the meter can differ for each staff. The solution
1449 is not very complicated: normally all timing information (time
1450 signature, rhythmic grouping) is synchronised across each staff. This
1451 is done by having only one administration for timing information: in
1452 the default configuration there is only one code(Timing_engraver), in
1453 the code(Score) context.
1455 All staffs use the information in the code(Timing_engraver) for
1456 generating bar lines and time signatures. So, we can have different
1457 timing for every staff, by moving the code(Timing_engraver) into the
1460 You can also declare contexts, and reference them. This is useful in
1461 combination with code(\remove "..."): code(\remove) does the opposite
1468 \context Staff = one { \time 2/4; c'4 c'4 c'4 c'4 c'4 c'4 }
1469 \context Staff = two { \time 3/4; c'4 c'4 c'4 c'4 c'4 c'4 }
1475 \remove "Timing_engraver";
1479 \consists "Timing_engraver";
1485 The context definitions provided as a default are in the standard
1486 initialisation file file(engraver.ly).
1489 sect(Urtexts and context selection)
1490 label(tutorial:urtext)
1492 In bind(Section)ref(tutorial:more-staffs), we have shown you how to
1493 make multiple staffs, and explained that you have to label every staff
1494 (or more precisely: different contexts), to make sure that new ones
1495 are created when you need them. In this section, the real power of
1496 this mechanism will be unveiled.
1498 By naming other contexts that you create, you can reference other
1499 contexts than the current context from within the music. For example,
1500 from within the music that you enter for staff code(One), one could
1501 enter a small piece of music, and send it to staff code(Two), e.g.,
1504 ) mudela(fragment,verbatim)(
1506 \context Staff = one { c''4 \context Staff = two { c4 c4 } c''4 }
1507 \context Staff = two { \clef bass; g,4 g,4 g,4 g,4 }
1513 The mechanism of context selection can be used to fabricate an
1514 nop(Urtext)footnote(em(Urtext) is the German word for `original text'.
1515 The Urtext edition of a piece of music, is an edition that reflects
1516 the original writing of the composer. Such editions are useful for
1517 musicologists, and performers that want to perform authentic
1518 interpretations. However, for mere mortals, the Urtext can be
1519 hard to read. It might not contain fingering and beaming, and
1520 typically it is full of footnotes. Moreover, common interpretations
1521 may have emerged---after the composer died. For this reason, the
1522 music that can be had as Urtext usually is also available in enhanced
1523 and edited editions. ) and an edited edition from em(one source). We
1524 will use the first few bars of bind(J.)bind(S.)Bach's first Cello
1525 suite to demonstrate this. The example makes heavy use of space
1526 rests; here they are used as a placeholder to attach articulation
1530 bach = \notes \relative c { g16 d' b' a b d, b' d, }
1531 bachBeams = \notes { [s4] [s4] }
1532 staffStuff = \notes { \clef bass; \time 4/4; s1 \bar "|."; }
1534 slursOne = \notes { s16( s s s s16 s s )s }
1535 slursTwo = \notes { s16-. s s() s s16() s s ()s }
1541 \context Voice = celloVoice { \bach \bach}
1542 \context Voice = celloVoice < { \slursOne \slursOne }
1543 { \bachBeams \bachBeams } >
1547 \context Voice = celloVoice { \bach \bach }
1548 \context Voice = celloVoice < { \slursTwo \slursTwo }
1549 { \bachBeams \bachBeams } >
1553 \paper { linewidth = -1.;}
1557 The slurs that you define should be put on the music that is defined
1558 by the code(\bach) identifier. By labeling a code(Voice) context, and
1559 directing both the articulation and the notes to that same code(Voice)
1560 context, the articulation is put over the right notes.
1564 label(tutorial:more-grammar)
1567 One of the things that you can do with music is em(transposing) it.
1568 If you want to transpose a piece of music, then you should prefix it
1569 with the keyword code(\transpose) along with the pitch (relative to
1570 the central C, i.e., code(c')) for the transposition.footnote(the
1571 code(\context Staff) is to make sure that no separate staffs are created
1572 for the code(\scale) and code(\transpose cis' \scale) part.)
1576 scale = \notes \relative c' { [c8 d e f] }
1579 \context Staff { \scale \transpose cis' \scale }
1581 \paper { linewidth = -1.0; }
1585 sect(Staff switching)
1587 We have seen that contexts can be nested. This means that they form a
1588 tree. It is possible to edit this tree: for example, a code(Voice)
1589 context can be taken out of a code(Staff) context, and put into
1590 another. This has the effect of the voice switching staffs (something
1591 that often happens in keyboard music). The syntax for this operation
1592 with these particular contexts is code(\translator Staff = newStaffName).
1594 The effect is analogous to the first example in section
1595 ref(tutorial:urtext), but with the code(\translator) construction it
1596 is possible to split the real music and the commands that determine in
1597 which staff the music is printed. For example:
1602 aVoice = \context Voice = voiceA \notes { c''4 c4 c4 c''4 }
1603 bVoice = \context Voice = voiceB \notes { g,4 g,4 g,4 g,4 }
1605 % staff switching stuff
1606 switch = \context Voice = voiceA \notes { s4 \translator Staff = staffB s4
1607 s4 \translator Staff = staffA s4 }
1611 \context Staff = staffA < \aVoice \switch >
1612 \context Staff = staffB < \bVoice \clef bass; >
1614 \paper { linewidth = -1.; }
1618 If you want to switch staffs you are in the middle of a slur or a
1619 beam, you should take special precautions. In the paper block,
1620 you must tell how far the staffs will be apart:
1621 mudela(verbatim,center)(
1623 \context GrandStaff <
1624 \context Staff=one \notes{ s2 }
1625 \context Staff=two \notes\relative c{
1629 \translator Staff=one \stemup
1635 % slur damping gets confused
1636 slur_slope_damping = 100.0;
1638 % we're using a grand staff
1640 minVerticalAlign = 3.0*\staffheight;
1641 maxVerticalAlign = 3.0*\staffheight;
1646 as LilyPond cannot determine the interstaff distance.
1650 The notes in a triplet take 2/3 of their notated duration. The syntax
1651 for triplet in LilyPond reflects this. To make a triplet, you enter
1654 )mudela(verbatim,fragment,center)(
1655 \context Voice \times 2/3 { c''4 c''4 c''4 }
1658 )Since tuplet brackets are printed by the Voice context, a Voice
1659 context must exist before code(\times) is interpreted. To ensure this,
1660 a context is instantiated explicitly with code(\context Voice). You
1661 don't need this, if a Voice context is already instantiated, like in
1662 the following example:
1665 )mudela(fragment,verbatim,center)(
1666 c''4 \times 2/3 { c''4 c''4 c''4 } c''4
1671 Of course, you can also use different ratios, and use beamed notes or
1675 lilypond: score-element.cc:134: class Paper_def * Score_element::paper() const: Assertion `pscore_l_' failed.
1678 \context Voice \times 4/5 { [c''8 c''16 c''16] r8 [g'8 g'8] }
1681 If you make a tuplet of beamed notes, where the beam is as wide as
1682 the bracket, the bracket is omitted.
1686 A repeated piece of music can consist of two parts: one part to be
1687 repeated, and optionally, a list of alternative endings:
1689 )mudela(verbatim,fragment,center)(
1699 ) The number code(repeat-count) defines how many times the piece should be
1700 played. You may leave out the code(\alternative) part. There must not
1701 be more alternative endings than the code(repeat-count).
1703 A less intuitive form may be needed for lyrics, when there are
1704 a couple alternatives, but nothing is repeated. The code(\repeat) command
1705 must be present, but it may specify an empty music list:
1707 )mudela(verbatim,fragment,center)(
1708 \context Lyrics \lyrics {
projects / lilypond.git / blob