1 mailto(gnu-music-discuss@gnu.org)
4 redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
8 def(indexcode)(1)(cindex(ARG1@code(ARG1)))
9 def(indexandcode)(1)(code(ARG1)indexcode(ARG1))
10 def(keyindex)(1)(cindex(ARG1@code(\ARG1)))
12 redef(code)(1)(tt(ARG1))
19 restStyle=mensural doesn't seem to work (lots of characters not found
29 This document contains Mudela fragments. You need at least
30 Yodl-1.30.18 to convert this to tex or html.
33 htmlbodyopt(bgcolor)(white)
34 htmlcommand(<font color=black>)
37 \setlength{\topmargin}{-0.25in}
38 \setlength{\textheight}{9in}
39 \setlength{\textwidth}{5.875in}
40 \setlength{\oddsidemargin}{0.25in}
41 \setlength{\evensidemargin}{0.25in}
47 whentexinfo(notableofcontents())
49 article(LilyPond 1.2.0 Reference Manual)
50 (Adrian Mariano, Han-Wen Nienhuys and Jan Nieuwenhuizen)
51 (nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())
54 latexcommand(\def\interexample{})
55 latexcommand(\def\preexample{\par})
56 latexcommand(\def\postexample{\par\medskip})
57 latexcommand(\def\file#1{{code(#1)}})
59 latexcommand(\def\texttt#1{\tt #1})
60 latexcommand(\def\textbf#1{\bf #1})
63 COMMENT(urg, texinfo include breaks)
65 includefile(html-disclaimer.yo-urg)
73 This bind(document)footnote(This document was revised for LilyPond
74 1.2.) describes the the GNU LilyPond input format, which is a
75 language for defining music. We call this language (rather
76 arrogantly) The Musical Definition Language or Mudela, for
77 short.footnote(If anybody comes up with a better name, we'd gladly
78 take this. Gourlay already uses Musical Description Language, G-Sharp
79 Score Definition Language. ISO standard 10743 defines a Standard
80 Music Description Language. We're not being original here.)
82 Mudela is a language that allows you to
84 it() create musical expressions by combining pitches, durations to
85 it() output those musical expressions to various formats
86 it() give those musical expressions and output definitions names, so
87 you can enter them in manageable chunks.
90 Mudela aims to be a language that defines a piece of music completely
91 both for typesetting and for a performance point of view.
95 The percent sign introduces line comments.
97 The syntax for most constructions follows this pattern: A keyword that
98 is the name of the construction, followed by a list of items, which is
99 enclosed in braces, e.g. a paper block looks like this
101 linewidth = 14.0 \cm; % one item
102 indent = \linewidth / 12.0 ; % another one.
105 Words without backslashes are
106 strings, like ``linewidth'' in the above example. When you do an
107 assigment, the left hand side is a string, the name name of the
108 identifier you wish to assign to. When you refer to an identifier,
109 you must put a backslash before the name, like in second item of the
114 sect(Lexical devices)cindex(Lexical devices)
116 subsect(Comments)cindex(Comments)
119 A one line comment is introduced by a indexandcode(%)
120 character. Block comments are started by code(%{) and ended by
121 code(%}). They cannot be nested.
127 Keywords start with a backslash, followed by a number of lower case
128 alphabetic characters.
131 subsect(Tokenizer commands)
133 The tokenizer accepts the following commands. They can appear
137 dit(code(\maininput)) keyindex(maininput) Internal command. This
138 command is used for creating init files like file(init.fly) that read
139 the user file into the middle of another file. It is illegal to use
140 this command in a user file.
142 dit(code(\include)) keyindex(include)var(file) Include the specified file. The
143 argument var(file) may be a quoted string, (An unquoted string will
144 not work here.) or a string identifier. The full filename including
145 the file(.ly) extension must be given,
147 dit(code(\version) var(string))
149 Specify the version of LilyPond that a
150 file was written for. The argument is the version number, for example
151 code("1.2.0"). This is used to detect invalid input, and to aid
152 code(convert-mudela), a tool that automatically upgrades input files.
155 subsect(Pitch Names in Other Languages)cindex(other languages)
158 Note name definitions have been provided in various languages.
159 Simply include the language specific init file. For example:
160 code(\include "english.ly"). The available language files and the names
163 verb( Note Names sharp flat
164 nederlands.ly c d e f g a bes b -is -es
165 english.ly c d e f g a bf b -s/-sharp -f/-flat
166 deutsch.ly c d e f g a b h -is -es
167 norsk.ly c d e f g a b h -iss/-is -ess/-es
168 svenska.ly c d e f g a b h -iss -ess
169 italiano.ly do re mi fa sol la sid si -d -b
170 catalan.ly do re mi fa sol la sid si -d/-s -b)
172 The pitch names can be easily redefined using the
173 code(\notenames)keyindex(notenames) command, see Subsection ref(notenames).
175 subsect(Lexical modes)cindex(Lexical modes)cindex(modes)
178 To simplify different aspects of music definition (entering the notes
179 and manipulating them) Mudela has four different input modes which
180 affect how unquoted strings are interpreted. In each mode, words are
181 identified on the input. If code("word") is encountered, it is
182 treated as a string. If code(\word) is encountered it is treated as a
183 keyword or as an identifier. The behavior of the modes differs in two
184 ways: different modes treat unquoted words differently, and different
185 modes have different rules for deciding what is a word.
188 dit(Normal mode)cindex(mode!normal)
189 At the start of parsing, Mudela is in normal mode.
190 In normal mode, a word is an alphabetic character followed by
191 alphanumeric characters. If code(word) is encountered on the input it
192 is treated as a string.
194 dit(Note mode) cindex(mode!note) Note mode is introduced by the keyword
195 code(\notes)keyindex(notes). In Note mode, words can only contain alphabetic
196 characters. If code(word) is encountered, LilyPond first checks for a
197 notename of code(word). If no notename is found, then code(word) is
200 Since combinations of numbers and dots are used for indicating
201 durations, you can not enter real numbers in this mode.
203 dit(Chord mode)cindex(mode!chord) Chord mode is introduced by the keyword
204 code(\chords)keyindex(chords). Similar to note mode, but words are also looked
205 up in a chord modifier table (containg code(maj), code(dim) etc.)
207 Since combinations of numbers and dots are used for indicating
208 durations, you can not enter real numbers in this mode. Dashes and
209 carets are used to indicate chord additions and substractions, so
210 scripts can not be entered in chord mode.
212 dit(Lyric mode) cindex(mode!lyric) Lyrics mode is introduced by the keyword
213 code(\lyrics)keyindex(lyrics). This mode is has rules that make it easy to include
214 punctuation and diacritical marks in words. A word in Lyrics mode
215 begins with: an alphabetic character, code(_), code(?), code(!),
216 code(:), code('), the control characters code(^A) through code(^F),
217 code(^Q) through code(^W), code(^Y), code(^^), any 8-bit character
218 with ASCII code over 127, or a two character combination of a
219 backslash followed by one of code(`), code('), code(") or
220 code(^).footnote(The purpose of lyrics mode is that you can enter lyrics in
221 TeX() format or a standard encoding without needing quotes. The
222 precise definition of this mode indeed is ludicrous. This will remain
223 so until the authors of LilyPond acquire a deeper understanding of
224 character encoding, or someone else steps up to fix this.)
226 Subsequent characters of a word can be any character that is not a
227 digit and not white space. One important consequence of this is that
228 a word can end with code(}), which may be confusing if you thought the
229 code(}) was going to terminate lyrics mode.footnote(LilyPond will
230 issue a warning, though). Any code(_) characters
231 which appear in an unquoted word are converted to spaces, providing a
232 mechanism for introducing spaces into words without using quotes.
233 Quoted words can also be used in lyrics mode to specify words that
234 cannot be specified with the above rules. Here are some examples.
235 Not all of these words are printable by TeX().
240 2B_||_!2B % not a word because it starts with a digit
241 ``Hello'' % not a word because it starts with `
242 _ _ _ _ % 4 words, each one a space
246 Since combinations of numbers and dots are used for indicating
247 durations, you can not enter real numbers in this mode.
251 It is possible to create words that break the rules by prefixing them
252 with the dollar sign indexandcode($). Regardless of the context, a word
253 beginning with code($) extends until the next white space character.
254 Such words can contain numbers (even in Note mode), or other forbidden
255 characters. The dollar sign can be used to create and access
256 identifiers that could not otherwise be used.footnote(Use of $ hampers
257 readability and portability to future LilyPond versions. Use of $ is
263 subsect(Types)cindex(Types)
265 Mudela has a limited set of types:
270 it() music expressions,
272 it() note name tables
273 it() context definitions,
274 it() output definitions (code(\paper)keyindex(paper) blocks and code(\midi)keyindex(midi) blocks)
275 it() score definitions
279 Type is a syntactical property: Mudela has no real type system, so
280 there is no support for generic expressions, functions or user defined
281 types. For the same reason, it is not possible to mix reals and
282 integers in arithmetic expressions, and ``type errors'' cindex(type error) (eg. using a
283 string identifier to initialize a code(\paper)keyindex(paper) block)
284 will yield ``parse error''.
286 subsubsect(Integers)cindex(Integers)
288 Formed from an optional minus sign followed by digits. Arithmetic
289 operations cannot be done with integers, and integers cannot be mixed
292 subsubsect(Reals)cindex(Reals)
293 Formed from an optional minus sign and a sequence of digits followed
294 by a em(required) decimal point and an optional exponent such as
295 code(-1.2e3). Reals can be built up using the usual operations:
296 indexandcode(+), indexandcode(-), indexandcode(*), and indexandcode(/), with parentheses for grouping.
298 A real constant can be followed by one of the dimension keywords:
299 cindex(dimension) code(\mm)keyindex(mm), code(\pt)keyindex(pt),
300 code(\in)keyindex(in), or code(\cm)keyindex(cm), for millimeters,
301 points, inches and centimeters. This converts the number a real that
302 is the internal representation of dimensions.
304 subsubsect(String)cindex(String)
306 Begins and ends with the code(") character. To include a code(")
307 character in a string write code(\"). Various other backslash
308 sequences have special interpretations as in the C language. A string
309 that contains no spaces can be written without the quotes. See
310 Section ref(modes) for details on unquoted strings; their
311 interpretation varies depending on the situation. Strings can be
312 concatenated with the code(+) operator.
316 subsubsect(Pitch and duration)cindex(pitch)cindex(duration)
318 The syntax for pitch specification is
319 code(\musicalpitch)keyindex(musicalpitch) code({) var(octave)
320 var(note) var(shift) code(}) The octave is specified by an integer,
321 zero for the octave containing middle C. The note is a number from 0
322 to 7, with 0 corresponding to C and 7 corresponding to B. The shift
323 is zero for a natural, negative to add flats, or positive to add
326 In note and chord mode, pitches may be designated by names.
327 See Section ref(notelang) for pitch names in different languages.
330 The syntax for duration specification is
331 code(\duration)keyindex(duration) code({) var(length) var(dotcount)
332 code(}) var(length) is the negative logarithm (base 2) of duration: 1
333 is a half note, 2 is a quarter note, 3 is an eighth note, etc. The
334 number of dots after the note is given by var(dotcount).
338 subsubsect(Music expressions)cindex(Music expressions)
340 Music in mudela is entered as a music expression. Notes, rests, lyric
341 syllables are music expressions (the atomic expressions),
342 cindex(atomic music expressions) and you can
343 combine music expressions to form new music expressions. This example
344 forms a compound expressions out of the quarter code(c) note and a
345 code(d) note:COMMENT(
347 )verb(\sequential { c4 d4 })COMMENT(
349 )The meaning of this compound expression is to play the code(c) first,
350 and then the code(d) (as opposed to playing them simultaneously, for
353 Atomic music expression are discussed in
354 bind(Subsection)ref(atomicmusic). Compound music expressions are
355 discussed in bind(Subsection)ref(compoundmusic).
357 subsubsect(Score definitions)cindex(score definitions)
358 These couples music expressions to output definitions.
361 subsubsect(Output definitions)cindex(output definitions)
362 These define how to output music expressions.
364 subsubsect(Context definitions)cindex(context definitions)
365 Part of output definitions. See Section ref(context) for more
369 subsubsect(Durations)cindex(durations)
370 Durations of notes and rests.
373 subsubsect(Notename tables)cindex(notename tables)
375 Tables with sets of pitch names (in different languages)
378 sect(Top level)cindex(top level)
380 This section describes what you may enter at top level.
382 subsect(Score definitions)cindex(score definition)
384 The output is generated combining a music expression with an output
385 definition. A score block has the following syntax code(\score {)
386 var(musicexpr) var(outputdefs) code(}). var(outputdefs) are zero or
387 more output definitons. If no output definiton is supplied, the
388 default code(\paper) block will be added.
390 subsect(Information header)cindex(header)keyindex(header)0
392 code(\header) code({) var(key1) = var(val1); var(key2) = var(val2); ... code(}))
394 A header describing the file's contents can appear at top level. If a
395 file has multiple code(\score) blocks, then a header can appear in
396 each score block describing its contents. Tools like
397 indexandcode(ly2dvi) can use this information for generating titles.
398 Key values that are used by ly2dvi are: title, subtitle, composer,
399 opus, poet, instrument, metre, arranger, piece and tagline.
401 It is custom to put the code(\header) at the top of the file.
403 subsect(Setting notenames and chordnames)
406 Note name tables can be specified using code(\notenames)keyindex(notenames) code({)
407 var(assignmentlist) code(}). var(assignmentlist) is a list of definitions of
408 the form var(name) = var(pitch).
410 Chord modifiers can be set analogously, with
411 code(\chordmodifiers)keyindex(chordmodifiers).
415 subsect(Output definitions)
417 A code(\paper) block at top level sets the default paper block. A
418 code(\midi) block at top level works similarly.
421 subsect(GUILE and Scheme)
423 code(\scm)keyindex(scm) var(scheme)code(;) evaluates the specified Scheme
424 code. The result is discarded. keyindex(scm)
426 code(\scmfile)keyindex(scmfile) var(filename)code(;) reads Scheme code from the
427 specified file. The result is discarded. keyindex(scmfile)
431 Identifier assignments may appear at top level.
434 sect(Identifiers)cindex(Identifiers)
436 Identifiers allow names to be assigned to constants, music, or other
437 Mudela structures. To assign an identifier you use
438 var(name)=var(value) and to refer to an identifier, you preceed its
439 name with a backslash: code(\)var(name).
440 Identifier assignments must appear at the top level in the Mudela
441 file. Semicolons are forbidden after assignments appearing
442 at the top level but they are obligatory after assignments appearing
447 An identifier can be created with any string for its name, but you
448 will only be able to refer to identifiers whose names begin with a
449 letter and are entirely alphanumeric. It is impossible to refer to an
450 identifier whose name is the same as the name of a keyword.
452 The right hand side of an identifier assignment is parsed completely
453 before the assignment is done, so it is legal to redefine an
454 identifier in terms of its old value: code(foo = \foo * 2.0).
456 Identifiers can be set equal to
462 it() durations (specified with code(\duration)keyindex(duration)),
463 it() articulations and spanner marks.
464 it() note name tables (specified with code(\notenames)keyindex(notenames)),
465 it() translator definitions,
466 it() output definitions (code(\paper)keyindex(paper) blocks and code(\midi)keyindex(midi) blocks)
467 it() score definitions (code(\score)keyindex(score) blocks)
470 When an identifier is referenced, the information that it points to is
471 copied. Therefore it only makes sense to put identifiers for
472 translators, output definitions and code(\score)keyindex(score) blocks as the first
473 item in a block. For this reason, if you reference to a code(\foo)
474 variable in a code(\foo) block, it must be the first item in the list
475 following code(\foo).footnote(code(\paper{\one \two}) does not make
476 sense, because the information of code(\two) would overwrite the
477 information of code(\one), thereby making the reference to the first
481 sect(Atomic music expressions)
484 subsect(Basic Note Specification)cindex(Basic Note Specification)
485 label(notedesc)cindex(pitches)cindex(entering notes)
488 A note specification has the form
489 var(pitch)[var(octavespec)][code(!)][code(?)][var(duration)].
490 The pitch of the note is specified by the note's name.
492 LilyPond has predefined note names for various languages. The default
493 names are the Dutch note names. The notes are specified by the
494 letters code(c) through code(b), where code(c) is an octave below
495 middle C and the letters span the ocatave above that C.
496 In Dutch,cindex(notenames!Dutch) a sharp is formed by adding
497 code(-is) to the end of a pitch name. A flat is formed by adding code(-es).
498 Double sharps and double flats are obtained by adding code(-isis) or
500 Lily has predefined sets of notenames
501 for various nop(languages). See Section ref(notelang) for details.
503 The optional octave specification takes the form of a series of single
505 indexandcode(') characters or a series of comma indexandcode(,) characters. Each
506 code(') raises the pitch by one octave; each code(,) lowers the pitch
509 mudela(fragment,verbatim,center)(
510 c' d' e' f' g' a' b' c''
513 mudela(fragment,verbatim,center)(
514 cis' dis' eis' fis' gis' ais' bis'
517 mudela(fragment,verbatim,center)(
518 ces' des' es' fes' ges' as' bes'
521 mudela(fragment,verbatim,center)(
522 cisis' eisis' gisis' aisis' beses'
525 mudela(fragment,verbatim,center)(
526 ceses' eses' geses' ases' beses'
529 Whenever a C-sharp is desired, you must specify a C-sharp. LilyPond
530 will determine what accidentals to typeset depending on the key and
532 A reminder accidental cindex(reminder accidental) can be forced by
533 using the optional exclamation mark `code(!)'
535 A cautionary accidental, cindex(cautionary accidental) i.e., an accidental within parentheses
536 can be obtained using the optional question mark `indexandcode(?)' on the pitch.
537 mudela(fragment,verbatim,center)(
538 cis' d' e' cis' c'? d' e' c'!
542 Durations are entered as their reciprocal values
543 mudela(fragment,verbatim,center)(
544 a'1 a'2 a'4 a a'8 a a'16 a'32 a'64
546 mudela(fragment,verbatim,center)(
550 If the duration is omitted then it is set equal to the previous
551 duration. If there is no previous duration, then a quarter note is
553 The duration can be followed by a dot indexandcode(.) to obtain dotted note
555 mudela(fragment,verbatim,center)(
559 Extra long notes can be obtained using the code(\breve)keyindex(breve) and
560 indexandcode(longa) durations:
561 mudela(fragment,verbatim,center)(
565 You can alter the length of duration by writing code(*)var(fraction) after a
571 Rests are entered like notes, with note name indexandcode(r) or
572 indexandcode(R). There is also a note name indexandcode(s) which produces a
573 nonprinting note of the specified duration.
575 The shape of notes and normal rests will be unchanged. When used in
576 this whole-measure rest code(R) will fill measures with rest symbols.
579 )mudela(fragment,verbatim,center)(
582 If you set the cindex(skipBars)code(Score.skipBars) property, then only one measure will be
583 printed; with indexandcode(R), a number indicating the length of the rest will be
585 mudela(fragment,verbatim,center)(
586 \property Score.skipBars=1
590 subsubsect(Lyrics)cindex(Lyric expressions)
592 Lyrics are entered like notes, with pitches replaced
593 by text. For example code(Twin-4 kle4 twin-4 kle4) enters four
594 syllables, each with quarter note duration. Note that the hyphen has
595 no special meaning for lyrics, and does not introduce special symbols.
596 See Section ref(modes) for a description of what is interpreted as a lyric.
598 Spaces can be introduced into a lyric either by using quotes (code("))
599 or by using an underscore without quotes: code(He_could4 not4). All
600 unquoted underscores are converted to spaces. Printing lyrics is
601 discussed in Section ref(lyricprint).
603 subsect(Properties)cindex(Properties)
605 code(\property)keyindex(property) var(contextname)code(.)var(propname) code(=) var(value)
606 Sets the var(propname) property of the context var(contextname) to the
607 specified var(value). All three arguments are strings. Depending on
608 the context it may be necessary to quote the strings or to leave space
609 on both sides of the dot.
611 subsect(Translator switches)cindex(Translator switches)
613 code(\translator)keyindex(translator) var(contexttype) = var(name)
614 A music expression that the context which is a direct child of the
615 a context of type var(contexttype) should be shifted to a context of
616 type var(contexttype) and the specified name.
619 subsect(Commands)cindex(Commands)
621 Commands are music expressions that have no duration. They fall in
624 subsubsect(Key signatures)
626 code(\key)keyindex(key) var(pitch) var(type) code(;) Change the key
627 signature. var(type) should be code(\major)keyindex(major) or code(\minor)keyindex(minor)
628 to get var(pitch)-major or var(pitch)-minor, respectively. The second
629 argument is optional, the default is major keys. The var(\context)
630 argument can also be given as an integer, which tells the number of
631 semitones that should be added to the pitch given in the subsequent
632 code(\key)keyindex(key) commands to get the corresponding major key,
633 e.g. code(\minor)keyindex(minor) is defined as 3. The standard mode names
634 code(\ionian)keyindex(ionian), code(\locrian)keyindex(locrian), code(\aeolian)keyindex(aeolian),
635 code(\mixolydian)keyindex(mixolydian), code(\lydian)keyindex(lydian), code(\phrygian)keyindex(phrygian), and
636 code(\dorian)keyindex(dorian) are also defined.
638 code(\partial)keyindex(partial) var(duration)code(;) Music expression that makes
639 the first measure of the music last for the specified duration.
642 code(\keysignature)keyindex(keysignature) var(pitchseq)code(;)
643 Specify an arbitrary key signature. The pitches from var(pitch) will
644 be printed in the key signature in the order that they appear on the list.
647 subsubsect(Rehearsal marks)
649 code(\mark)keyindex(mark) var(unsigned)code(;) or code(\mark)
650 var(string)code(;)) A music expression. Prints a mark over or under
651 (depending on the indexandcode(markDirection) property) the staff. You must
652 add indexandcode(Mark_engraver) to the either Score or Staff context for this
656 subsubsect(Bar lines)
658 code(\bar)keyindex(bar) var(bartype)code(;) Music expression that requests
659 LilyPond to print a special bar symbol, or at
660 measure boundaries, replaces the regular bar symbol with a special
661 symbol. The argument var(bartype) is a string which specifies the
662 kind of bar to print. Options are indexandcode(":|"), indexandcode("|:"),
663 indexandcode(":|:"), indexandcode("||"), indexandcode("|."), indexandcode(".|"), or indexandcode(".|.").
664 These produce respectively a right repeat, a left repeat, a double
665 repeat, a double bar, a start bar, an end bar, or a thick double bar.
666 If var(bartype) is set to code("empty") then nothing is printed, but a
667 line break is allowed at that spot.
669 You are encouraged to use code(\repeat) for repetitions.
671 subsubsect(Timing commands)
673 code(\cadenza)keyindex(cadenza) var(togglevalue)code(;) Music expression that
674 toggles the automatic generation of bar lines. If var(togglevalue) is
675 0 then bar line generation is turned off. If var(togglevalue) is 1
676 then a bar is immediately printed and bar generation is turned on.
678 code(\time)keyindex(time) var(numerator)code(/)var(denominator)code(;) Change the time
679 signature. The default time signature is 4/4. The time signature is
680 used to generate bar lines at correct places.
683 code(\tempo)keyindex(tempo) var(duration) = var(perminute)code(;) Used within
684 code(\midi) or within music to specify the tempo. For example,
685 `code(\midi { \tempo 4 = 76;})' requests output with 76 quarter notes
688 code(\partial)keyindex(partial)var( duration)code(;) This creates an incomplete
689 measure at the start of the music, eg. code(\partial 8*2;) creates a
690 starting measure lasting two eighth notes.cindex(anacrouse)cindex(upstep)
692 code(|)cindex(|)cindex(barcheck)
694 code(|) is a barcheck. Whenever a
695 barcheck is encountered during interpretation, a warning message is
696 issued if it doesn't fall at a measure boundary. This can help you
697 finding errors in the input. The beginning of the measure will also be
698 relocated, so you can also use this to shorten measures.cindex(shorten measures)cindex(upstep)
700 subsubsect(Other commands)
702 code(\penalty)keyindex(penalty) var(int)code(;)
703 Discourage or encourage line breaks. See identifiers code(\break)keyindex(break) and
704 code(\nobreak)keyindex(nobreak) in Section ref(ident).
706 code(\clef)keyindex(clef) var(clefname)code(;) Music expression that
707 sets the current clef. The argument is
708 a string which specifies the name of the clef. Several clef names are
709 supported. If code(_8) or code(^8) is added to the end of a clef
710 name then the clef lowered or raised an octave will be generated.
711 Here are the supported clef names with middle C shown in each clef:
715 %\property Voice.textStyle = typewriter
716 \clef subbass; c'4-"\kern-10mm subbass"
717 \clef bass; c'4^"\kern -8mm bass"
718 \clef baritone; c'4_"\kern -10mm baritone"
719 \clef varbaritone; c'4^"\kern -10mm varbaritone"
720 \clef tenor; c'4_"\kern -10mm tenor"
721 \clef "G_8"; c'4^"\kern -6mm G\_8"
723 \paper{ linewidth= 4.5 \in; }
728 \notes{\cadenza 1; \clef alto; c'4_"\kern -10mm alto"
729 \clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
730 \clef soprano; c'4_"\kern -10mm soprano"
731 \clef treble; c'4^"\kern -6mm treble"
732 \clef french; c'4_"\kern -10mm french" }
733 \paper{ linewidth= 4.5 \in; }
736 The treble clef can also be obtained using the names code(G) or
737 code(violin). The bass clef is also available by code(\clef F).
739 code(\skip)keyindex(skip) var(duration)code(;) Skips the amount of time
740 specified by var(duration). If no other music is played, a gap will
741 be left for the skipped time with no notes printed. It works in Note
742 Mode or Lyrics Mode. In notes mode, this has the same effect as the
746 subsubsect(Beams)cindex(beams)
749 A beam is specified by surrounding the beamed notes with brackets
750 indexandcode([) and indexandcode(]).
751 mudela(fragment,verbatim,center)(
752 [a'8 a'] [a'16 a' a' a']
754 Some more elaborate constructions:
755 mudela(fragment,verbatim,center)(
756 [a'16 <a' c''> c'' <a' c''>]
757 \times 2/3 { [e'8 f' g'] }
760 Beaming can be generated automatically see Section ref(autobeam).
762 cindex(Tremolo beams)
764 To place tremolo marks in between two notes, begin with
765 code([:)var(length) and end with code(]). The tremolo marks will
766 appear instead of beams. Putting more than two notes in such a
767 construction will produce odd effects.
769 mudela(fragment,verbatim,center)(
770 [:16 e'1 g'] [:8 e'4 f']
773 mudela(fragment,verbatim,center)(
777 COMMENT(ref to normal tremolos?)
779 subsubsect(Lyric helpers)
780 cindex(--)cindex(___)cindex(extender)cindex(hyphen)
782 The syntax for an extender mark is code(__). This syntax can only be
783 used within lyrics mode. The syntax for a spanning hyphen (a hyphen
784 that will be printed between two lyric syllables) is code(--)
788 subsubsect(Tie)cindex(tie)
790 A tie connects two adjacent note heads of the same pitch. When used
791 with chords, it connects all of the note heads whose pitches match.
792 Ties are indicated using the tilde symbol indexandcode(~) by analogy with
793 TeX()'s tie which connects words. Note that if you try to tie
794 together chords which have no common pitches, then a warning message
795 will appear and no tie will be created. COMMENT(
797 )mudela(fragment,verbatim,center)(
798 e' ~ e' <c' e' g'> ~ <c' e' g'>
801 subsect(Atomic music expressions: add-ons)
806 subsubsect(Articulations)cindex(articulations)cindex(scripts)cindex(ornaments)
808 A variety of symbols can appear above and below notes to indicate
809 different characteristics of the performance. These symbols can be
810 added to a note with `var(note)code(-\)var(name)'. Numerous symbols
811 are defined in file(script.ly) and file(script.scm). Symbols can be
812 forced to appear above the note by writing
813 `var(note)code(^\)var(name)', and they can be forced to appear below
814 by writing `var(note)code(_\)var(name)'. Here is a chart showing
815 symbols above notes, with the name of the corresponding symbol
816 appearing underneath.
820 < \notes{ c''-\accent c''-\marcato c''-\staccatissimo f'-\fermata
821 c''-\stopped c''-\staccato c''-\tenuto c''-\upbow c''-\downbow
822 c''-\lheel c''-\rheel c''-\ltoe c''-\rtoe c''-\turn
823 c''-\open c''-\flageolet c''-\reverseturn
825 c''-\prall c''-\mordent c''-\prallprall c''-\prallmordent
826 c''-\upprall c''-\downprall c''-\thumb c''-\segno c''-\coda}
827 \context Lyrics \lyrics{
828 accent__ marcato__ staccatissimo__ fermata stopped__
829 staccato__ tenuto__ upbow downbow__ lheel__ rheel__ ltoe
830 rtoe__ turn__ open__ flageolet reverseturn__ trill__ prall__
831 mordent prallprall__ prallmordent__ uprall__ downprall thumb
834 \paper{ linewidth = 5.875\in;
839 In addition, it is possible to place arbitrary strings of text or
840 TeX() above or below notes by using a string instead of an identifier:
841 `code(c^"text")'. Fingerings cindex(fingering) can be placed by
842 simply using digits. All of these note ornaments appear in the
843 printed output but have no effect on the MIDI rendering of the music.
845 To save typing, fingering instructions (digits 0 to 9 are supported)
846 and a few common symbols can be abbreviated with single characters:
851 \property Voice.textStyle = typewriter
863 % \paper { linewidth = 12.\cm; }
866 Dynamic marks are specified by using an identifier after a note
867 without: code(c4 \ff). The available dynamic marks are:
868 code(\pppppp)keyindex(pppppp), code(\ppppp)keyindex(ppppp),
869 code(\pppp)keyindex(pppp), code(\ppp)keyindex(ppp),
870 code(\pp)keyindex(pp), code(\p)keyindex(p), code(\mp)keyindex(mp),
871 code(\mf)keyindex(mf), code(\f)keyindex(f), code(\ff)keyindex(ff),
872 code(\fff)keyindex(fff), code(\ffff)keyindex(ffff),
873 code(\fffff)keyindex(fffff), code(\ffffff)keyindex(ffffff),
874 code(\fp)keyindex(fp), code(\sf)keyindex(sf), code(\sff)keyindex(sff),
875 code(\sp)keyindex(sp), code(\spp)keyindex(spp),
876 code(\sfz)keyindex(sfz) and code(\rfz)keyindex(rfz).
879 subsubsect(Slur)cindex(Slur)
881 Slurs connects chords and try to avoid crossing stems. A slur is
882 started with code(CHAR(40)) and stopped with code(CHAR(41)). The
883 starting code(CHAR(40)) appears to the right of the first note in the
884 slur. The terminal code(CHAR(41)) apppears to the left of the first
885 note in the slur. This makes it possible to put a note in slurs from
888 )mudela(fragment,verbatim,center)(
889 f'()g'()a' [a'8 b'(] a'4 g'2 )f'
893 code(\spanrequest)keyindex(spanrequest) var(startstop) var(type).
894 Define a spanning request var(startstop) is either -1
895 (code(\start)keyindex(start)) or 1 (code(\stop)keyindex(stop)). The
896 var(type) parameter is a string that describes what should be started.
897 Supported types are code(crescendo), code(decrescendo), code(beam),
898 code(slur). This is an internal command. Users should use the
899 abbreviations which are defined in the initialization file
902 You can attach a (general) span request to a note using
903 mudela(fragment,center)(
904 c4-\spanrequest \start "slur"
905 c4-\spanrequest \stop "slur"
907 The slur syntax with parentheses is an abbreviation of this.
909 code(\textscript)keyindex(textscript)) var(text) var(style). Defines a text to be
910 printed over or under a note. var(style) is a string that may be one
911 of code(finger), code(roman), code(italic), code(dynamic), code(Large)
914 You can attach a general textscript request using this syntax
915 verb(c4-\textscript "6" "finger"
916 c4-\textscript "foo" "normal"
918 This is equivalent with code(c4-6 c4-"foo").
920 code(\script)keyindex(script) var(alias) Prints a symbol above or below a note.
921 The argument is a string which points into the script-alias table
922 defined in file(script.scm). The scheme definitions specify whether
923 the symbol follows notes into the staff, dependence of symbol
924 placement on staff direction, and a priority for placing several
925 symbols over one note. Usually the code(\script)keyindex(script) keyword is not used
926 directly. Various helpful identifier definitions appear in
929 COMMENT(came till here with indexifying)
931 subsubsect(Crescendo)cindex(Crescendo)
933 A crescendo mark is started with code(\cr)keyindex(cr) and terminated with
934 code(\rc)keyindex(rc). A decrescendo mark is started with code(\decr)keyindex(decr) and
935 terminated with code(\rced)keyindex(rced). There are also shorthands for these
936 marks. A crescendo can be started with code(\<)keyindex(<) and a decrescendo can
937 be started with code(\>)keyindex(>). Either one can be terminated with code(\!)keyindex(!).
938 Note that code(\!) must go before the last note of the dynamic mark whereas
939 code(\rc) and code(\rced) go after the last note. Because these marks are
940 bound to notes, if you want to get several marks during one note, you must use
941 spacer notes. COMMENT(
943 )mudela(fragment,verbatim,center)(
944 c'' \< \! c'' d'' \decr e'' \rced
945 < f''1 {s4 \< \! s4 \> \! s2 } >)
947 subsubsect(Tremolo marks)cindex(Tremolo marks)
949 Tremolo marks can be printed by a note by adding code(:)[var(length)]
950 after the note. The length must be at least 8. A var(length) value
951 of 8 gives one line across the note stem.
952 If the length is omitted,
953 then the last value is used, or the value of the code(abbrev)
954 property if there was no last value.
955 mudela(verbatim,fragment,center)(c'2:8 c':32
958 sect(Compound music expressions)cindex(Compound music expressions)
962 Music is a compound type: arbitrarily complicated expressions with a
963 hierarchical structure can be formed from simple building blocks.
964 Syntactically, these items can be nested any way you like. This
965 simple example shows how three chords can be expressed in two
966 different ways: COMMENT(
968 )mudela(fragment,verbatim,center)(
969 \notes\context Staff{
970 <a c' e'> <b d' f'> <c' e' g'>
971 <{a b c'}{c' d' e'}{e' f' g'}>
976 subsect(Context selection)cindex(Context selection)
978 code(\context)keyindex(context) var(contexttype) [code(=) var(contextname)]
981 Interpret var(musicexpr) within a context of type
982 var(contexttype). If the context does not exist, it will be created.
983 context. The new context can optionally be given a name.
984 This is a Music expression itself. See Section ref(contexts) for
985 more information on interpretation contexts.
987 subsect(Music entry modes)
991 Mode switching keywords form compound music expressions:
992 code(\notes)keyindex(notes)var( musicexpr), code(\chords)keyindex(chords)var( musicexpr), and
993 code(\lyrics)keyindex(lyrics)var( musicexpr). This indicates that var(musicexpr)
994 should be parsed in indicated mode. See Section ref(modes) for more
995 information on modes.
997 subsect(Sequential music)cindex(Sequential music)
999 All musical expressions have a duration. The duration of sequential
1000 music is the the sum of the durations of the elements. The syntax is
1001 code(\sequential)keyindex(sequential)code( {)var( musicexprlist )code(}). There is an
1002 abbreviated form, which leaves out the keyword:
1003 code({)var( musicexprlist )code(}).
1005 subsect(Simultaneous music)cindex(Simultaneous music)
1007 Simultaneous music using angle brackets, the duration is the maximum
1008 of the durations of the elements. The syntax is
1009 code(\simultaneous)keyindex(simultaneous)code({)var( musicexprlist )code(}). The
1010 abbreviated form, code(<) var(musicexprlist) code(>) is common idiom.
1012 If you try to use a chord as the first thing in your score, you
1013 might get multiple staffs in stead of a chord.COMMENT(
1015 )mudela(verbatim)(\score { \notes <c''4 e''>
1016 \paper { linewidth = -1.; }
1019 ) This happens because the chord is interpreted by a score context.
1020 Each time a note is encountered a default Voice context (along with a
1021 Staff context) is created. The solution is to explicitly instantiate a
1023 mudela(verbatim,center)(\score { \notes\context Voice <c''4 e''>
1024 \paper { linewidth = -1.; }
1027 More information on context selection can be found in Section ref(contextselection)
1029 subsect(Chord names)
1031 Chord names are a way to generate simultaneous music expressions that
1032 correspond with traditional notenaming.
1033 var(tonic)[var(duration)][code(-)var(modifier)][code(^)var(subtractions)][code(/)var(inversion)]
1034 var(tonic) should be the tonic note of the chord, and the var(duration) is
1035 the chord duration in the usual notation. There are two kinds of modifiers.
1036 One type is chord additions, which are obtained by listing intervals separated
1037 by dots. An interval is written by its number with an optional code(+) or
1038 code(-) to indicate raising or lowering by half a step. A chord additions has
1039 two effects: it adds the specified interval and all lower odd numbered
1040 intervals to the chord, and it may lower or raise the specified interval.
1041 Intervals must be separated by a dot (code(.)).
1042 Repeating a code(-) character will remove a half step from the preceding
1044 mudela(fragment,verbatim,center)(
1048 c-9-.5+.7+ c-3-.5- c-4.6.8
1050 The second type of modifier that may appear after the code(-) is
1052 Named modifiers are listed in the file file(chord-modifiers.ly). The
1053 available modifiers are code(m) and code(min) which lower
1054 the 3rd half a step, indexandcode(aug) which raises the 5th, indexandcode(dim) which lowers
1055 the 5th, indexandcode(maj) which adds a raised 7th, and indexandcode(sus) which replaces the
1057 mudela(fragment,verbatim,center)(
1060 c1-m c-min c-maj c-aug c-dim c-sus
1063 Chord subtractions are used to eliminate notes from a chord. The notes to be
1064 subtracted are listed after a code(^) character, separated by dots.
1065 mudela(fragment,verbatim,center)(
1071 Chord inversions can be specified by appending indexandcode(/) and the name of a
1072 single note to a chord. This has the effect of lowering the specified note by
1073 an octave so it becomes the lowest note in the chord. If the
1074 specified note is not in the chord then a warning will be printed.
1075 mudela(fragment,verbatim,center)(
1077 \chords { c1 c/e c/g c-7/e }
1079 Throughout these examples, chords have been shifted around the staff
1080 using code(\transpose). The code(\relative) keyword has odd effects
1081 when combined with named chords.
1084 This syntax can only be used in chord mode.
1087 subsect(Tuplets)cindex(Tuplets)
1089 Tuplets are made out of a music expression, by multiplying their
1090 length with a fraction. The syntax is code(\times)keyindex(times) var(fraction)
1093 The length of var(musicexpr) will be multiplied by the fraction.
1094 In print, the fraction's denominator will be printed over the notes,
1095 optionally with a bracket. The most
1096 common tuplet is the triplet in which 3 notes have the length of 2, so
1097 the notes are 2/3 their written length:
1100 )mudela(fragment,verbatim,center)( b'4 \times 2/3 {c'4 c' c'} d'4 d'4 )
1102 subsect(Grace notes)cindex(Grace notes)
1104 Grace notes are specified as code(\grace )keyindex(grace )var(musicexpr). A grace
1105 note expression has duration 0; the next real note is assumed to the
1108 You cannot have the grace note after the main note in music
1109 expressions, terms of duration and main notes, but you can typeset the
1110 grace notes to the right of the main note using the property
1111 indexandcode(graceAlignPosition).
1113 When grace music is interpreted, a score-within-a-score is set up:
1114 var(musicexpr) has its own time bookkeeping, and you could for example
1115 have separate barlines within grace notes. Within this
1116 score-within-a-score you can create notes, beams, slurs, etc. Unbeamed
1117 eighth notes and shorter by default have a slash through the stem.
1118 This behavior can be controlled with the indexandcode(stemStyle) property.
1121 \relative c'' { \grace c8 c4 \grace { [c16 c16] } c4
1122 \grace { \property Grace.stemStyle = "" c16 } c4 }
1125 At present nesting code(\grace)keyindex(grace) notes, eg. code(\grace { \grace
1126 c32 c16} c4) may result in run-time errors of LilyPond. Since the
1127 meaning of such a construct is unclear, we don't consider this a loss.
1128 Similarly, juxtaposing two code(\grace) sections syntactically valid,
1129 but makes no sense and may cause runtime errors.
1131 Ending a staff or score with grace notes may generate a run-time
1132 error, since there will be no main note to attach the grace notes to.
1134 subsect(Repeats)cindex(Repeats)
1136 In order to specify repeats, use the code(\repeat)keyindex(repeat) keyword. Since
1137 repeats look differently when played and when printed, there are a few
1138 different variants of repeats.
1141 dit(unfolded) repeated music is fully written (played) out. Useful
1143 dit(volta) This is the normal notation: repeats are not
1144 written out, but alternative endings (voltas), are printed, one after
1146 dit(folded) alternative endings are written stacked, which is useful
1150 The syntax for repeats is code(\repeat )var(variant)var(
1151 repeatcount)\var(repeatbody). If you have alternative endings, you
1152 may add code(\alternative)keyindex(alternative)code({ )var(alternative1) var(alternative2)
1153 var(alternative3) .. code(}), where each var(alternative) is of type Music.
1155 Normal notation repeats are used like this:
1156 mudela(fragment,verbatim,center)(
1158 \repeat volta 2 { c'4 d' e' f' }
1159 \repeat volta 2 { f' e' d' c' })
1161 With alternative endings:
1162 mudela(fragment,verbatim,center)(
1164 \repeat volta 2 {c'4 d' e' f'}
1165 \alternative { {d'2 d'} {f' f} })
1167 Folded repeats look like this:footnote(Folded repeats offer little
1168 more over simultaneous music. However, it is to be expected that more
1169 functionality --especially for the MIDI backend-- will be implemented)
1172 mudela(fragment,verbatim,center)(
1174 \repeat fold 2 {c'4 d' e' f'}
1175 \alternative { {d'2 d'} {f' f} })
1177 mudela(fragment,verbatim)(
1178 \context Staff { \relative c'{
1179 \partial 4; \repeat volta 2 { e | c2 d2 | e2 f2 | }
1180 \alternative { { g4 g g } { a a a a b1 } }
1183 If you don't give enough alternatives for all of the repeats, then the
1184 first alternative is assumed to be repeated enough to equal to
1185 specified number of repeats.
1186 mudela(fragment,verbatim)(
1187 \context Staff { \relative c'{
1188 \repeat volta 3 { \partial 4; e | c2 d2 | e2 f2 | }
1189 \alternative { { g4 g g } {\partial 1; e4 e e }
1190 {\partial 1; a a a a | b1 } }
1195 It is possible to nest code(\repeat). This is not entirely supported,
1196 the notes will come be in the right places, but the repeat bars will
1201 subsubsect(Relative Pitch Specification)cindex(Relative Pitch Specification)
1204 One can easily get confused by the large numbers of octave changing
1205 marks in the music, and it is easy to accidentally put a pitch in the
1206 wrong octave. A much better way of specifying a
1207 note's octave is `the relative octave' mode.
1209 The syntax for relative mode is code(\relative)keyindex(relative)var( startpitch )(var
1212 The octave of notes that appear in var(musicexpr) are calculated as
1213 follows: when no octave changing marks are used, the basic interval
1214 between this and the last note is always taken to be a fourth or
1215 less.footnote(The interval is determined without regard accidentals.
1216 A code(fisis) following a code(ceses) will be put above the
1217 code(ceses)) The octave changing marks code(') and code(,) can then be
1218 added to raise or lower the pitch by an extra octave.. Upon entering
1219 relative mode, an absolute starting pitch must be specified that will
1220 act as the predecessor of the first note of the following music.
1222 Entering scales is straightforward in relative mode.
1224 mudela(fragment,verbatim,center)(
1225 \relative c' { c d e f g a b c c, }
1228 and octave changing marks are used for intervals greater than a fourth.
1230 mudela(fragment,verbatim,center)(
1231 \relative c'' { c g c f, c' a,, e''' }
1234 When the preceding item is a chord, the first note of the chord is used to
1235 determine the first note of the next chord. But other notes within the second
1236 chord are determined by looking at the immediately preceding note.
1238 mudela(fragment,verbatim,center)(
1239 \relative c' { c <c e g>
1240 <c' e g> <c, e' g> }
1243 The pitch after the code(\relative) contains a notename. To parse the
1244 pitch as a notename, you have to be in note mode, so there must be a
1245 surrounding code(\notes)keyindex(notes) keyword (which is not shown here).
1247 The relative conversion will not affect sections in its argument that
1248 contain code(\transpose) or code(\relative). If you want transposed
1249 music within a code(\relative), you must place an additional
1250 code(\relative) inside the code(\transpose).
1252 You are strongly recommended to use relative pitch mode: it is less
1253 typing, less error-prone and more readable.
1257 subsect(Tranposition of Pitches)cindex(Tranposition of Pitches)
1260 With code(\transpose)keyindex(transpose) a music expression can be transposed.
1261 The syntax is code(\transpose) var(pitch) var(musicexpr)
1263 Middle C is tranposed to var(pitch). If it appears inside
1264 code(\relative)keyindex(relative), then any notes specified for transposition
1265 should be specified inside another code(\relative). See Section
1268 code(\transpose) distinguishes between enharmonic pitches: both
1269 code(\transpose cis') or code(\transpose des') will transpose up half
1270 a tone. The first version will print sharps and the second version
1271 will print flats. COMMENT(
1273 )mudela(fragment,verbatim,center)(
1275 \clef "F"; { \key e; c d e f } \clef "G";
1276 \transpose des'' { \key e; c d e f }
1277 \transpose cis'' { \key e; c d e f } }
1280 If you want to use both code(\transpose) and code(\relative), then you
1281 must use code(\transpose) first. Any code(\relative) keywords that
1282 are outside the code(\transpose) have no effect on notes that appear
1283 inside the code(\transpose).
1287 subsect(Automatic lyric durations)cindex(Automatic lyric durations)
1289 If you have lyrics that are set to a melody, you can import the rhythm
1290 of that melody into the lyrics using
1291 code(\addlyrics)keyindex(addlyrics).
1292 The syntax for this is
1293 code(\addlyrics)var( musicexpr1 musicexpr2). This means that both
1294 var(musicexpr1) and var(musicexpr2) are interpreted, but that every
1295 non-command atomic music expression (``every syllable'') in
1296 var(musicexpr2) is interpreted using timing of var(musicexpr1).
1301 )mudela(verbatim,fragment)(
1303 \transpose c'' { c4 d8. e16 f2 }
1304 \context Lyrics \lyrics { do4 re mi fa }
1307 )You should use a single rhythm melody, and single rhythm lyrics (a
1308 constant duration is the obvious choice). If you do not, you will get
1309 undesired effects when using multiple stanzas: COMMENT(
1311 )mudela(verbatim,fragment)(
1313 \transpose c'' { c4 d8. e16 f2 }
1314 \context Lyrics \lyrics < { do4 re mi fa }
1318 It is valid (but probably not very useful) to use notes i.s.o. lyrics
1319 for var(musicexpr2). COMMENT(
1321 mudela(verbatim,fragment)(
1322 \context Voice \addlyrics
1329 sect(Ambiguities)cindex(ambiguities)
1331 The grammar contains a number of ambiguities.footnote(The authors hope
1332 to resolve them at a later time.)
1341 )Can be interpreted as making a string identifier code(\foo)
1342 containing code("bar"), or a music identifier code(\foo) containing
1347 )Can be interpreted as making a int identifier containing -6, or a
1348 request identifier containing the fingering `6' (with neutral direction).
1351 If you do a nested repeat,
1356 ) then it is ambiguous to which code(\repeat) the code(\alternative)
1357 belongs. This is the classic if-then-else dillema. It may be solved
1361 (an as yet unidentified ambiguity)
1364 sect(Notation conversion specifics)
1366 subsect(Automatic Beam Generation)cindex(Automatic Beam Generation)
1369 By default, Lilypond will generate beams automatically. This feature can be
1370 disabled by setting the indexandcode(Voice.beamAuto) property to 0. It can be
1371 overridden for specific cases by specifying explicit beams as
1372 described in Section ref(manualbeam).
1374 In order to decide how to generate beams, Lilypond uses a large number
1375 of Voice properties, whose default values appear in
1376 file(auto-beam-settings.ly). In general, beams can begin anywhere,
1377 but their ending location is significant. Beams can end on a beat, or
1378 at durations specified by the indexandcode(Voice.beamAutoEnd) property. To
1379 end beams every quarter note, for example, you could use set
1380 indexandcode(Voice.beamAutoEnd) equal to code("1/4"). To end beams every
1381 three eighth notes you would set it to code("3/8"). The same syntax
1382 can be used to specify beam starting points using indexandcode(Voice.beamAutoBegin).
1384 To allow different settings for different time signatures, these
1385 property names can start with code(time)var(N)code(_)var(M) to
1386 restrict the definition to var(N)code(/)code(M) time. So for example,
1387 to specify beams ending only for 6/8 time you would use the property
1388 code(Voice.time6_8beamAutoEnd). To allow different endings for notes
1389 of different durations, the duration can be tacked onto the end of the
1390 property. To specify beam endings for beams that contain 32nd notes,
1391 you would use code(Voice.beamAutoEnd_32).
1393 subsect(Printing chord names)cindex(chord names)cindex(chords)cindex(printing!chord names)
1395 For displaying printed chord names, use the indexandcode(ChordNames) context.
1396 The chords may be entered either using the notation described above,
1397 or directly using angle brackets.
1398 mudela(fragment,verbatim)(
1400 \context ChordNames { \chords{ a b c} \notes{ < d f g > < e g b > } }
1401 \context Staff \notes{ a b c' d' e' }
1404 Lilypond examines chords specified as lists of notes to determine a
1405 name to give the chord. By default, LilyPond will not try to identify
1407 mudela(fragment,verbatim,center)(
1409 \context ChordNames {
1410 \notes{ < e' g' c'' > } }
1411 \context Staff \notes{ c' }
1413 If you want inversions to be recognized, you must set the property
1414 indexandcode(Score.chordInversion):
1415 mudela(fragment,verbatim,center)(
1417 \property Score.chordInversion = 1
1418 \context ChordNames {
1419 \notes{ < e' g' c'' > } }
1420 \context Staff \notes{ c' }
1425 subsect(Printing lyrics)cindex(Lyrics)cindex(printing!lyrics)
1428 In order to instruct LilyPond to write lyrics, the syllables must be
1429 interpreted within a code(Lyrics) context cindex(context!Lyrics).
1431 Here is a full example:
1432 mudela(verbatim)(\score{
1433 < \notes \transpose c'' {c d e c | c d e c | e f g'2 |
1434 e'4 f g'2 \bar "|."; }
1435 \context Lyrics \lyrics {
1436 Va-4 der Ja- cob Va- der Ja- cob
1437 Slaapt gij nog?2 Slaapt4 gij nog?2 }
1442 When one word is attached to many notes, you may
1443 want a continuous line after the lyric to show this. To achieve
1444 this effect, add a code(__) lyric as a separate word
1445 after the lyric to be extended.
1447 an extender, a line that extends over the entire duration of
1448 the lyric. This line will run all the way to the start of the next
1449 lyric, so you may want to shorten it by using a blank lyric.
1450 mudela(verbatim)(\score{
1451 < \notes \relative c''{
1452 a4()b()c()d c()d()b()a c()d()b()a }
1453 \context Lyrics \lyrics {
1454 foo1 __ bar2. __ _4 baz1 __ }
1457 If you want to have hyphens centered between syllables (rather than attached
1458 to the end of the first syllable) you can use the special code(--) lyric as
1459 separate word between syllables. This will result in a hyphen whose length
1460 varies depending on the space between syllables, and centered between the
1461 syllables. For example:
1462 mudela(verbatim)(\score{
1463 < \notes \transpose c'' {c d e c | c d e c | e f g'2 |
1464 e'4 f g'2 \bar "|."; }
1465 \context Lyrics \lyrics {
1466 Va4 -- der Ja -- cob Va -- der Ja -- cob
1467 Slaapt gij nog?2 Slaapt4 gij nog?2 }
1474 sect(Notation Contexts)cindex(Notation Contexts)
1476 Notation contexts are objects that only exist during a run of
1477 LilyPond. During the interpretation phase of LilyPond, the Music
1478 expression contained in a code(\score) block is interpreted in time
1479 order. This is the order in which humans read, play and write music.
1481 A context is an object that holds the reading state of the expression:
1482 it contains information like
1484 it() What notes are playing at this point?
1485 it() What symbols will be printed at this point?
1486 it() In what style will they printed?
1487 it() What is the current key signature, time signature, point within
1491 Contexts are grouped hierarchically: a Voice context is contained in a
1492 Staff context (because a staff can contain multiple voices at any
1493 point), a Staff context is contained in a Score, StaffGroup,
1494 ChoirStaff context (because these can all contain multiple Staffs.)
1496 The Contexts associated with sheet music output are called notation
1497 contexts, those with associated with sound output are called playing
1500 Context are created either automatically, or manually.
1501 Initially, the top level music expression is reported to the top level
1502 context (the Score context).
1503 When a atomic music expression (a note, a rest, a code(\bar),
1504 code(\time) command), a nested set of context is created that can process these
1505 atomic expressions, so in this example,COMMENT(
1507 )verb(\score { \notes < c4 > })COMMENT(
1509 )the sequential music, code({ c4 }) is interpreted by Score context.
1510 When the note code(c4) itself is interpreted, a set of contexts is needed
1511 that will accept notes. The default for this is a Voice context,
1512 contained in a Staff context.
1514 subsect(Context selection)
1515 label(contextselection)
1517 You can also create contexts manually, and you probably have to do so
1518 if you want to typeset complicated multiple voice/multiple staff
1519 material. If a code(\context )var(name musicexpr) expression is
1520 encountered during the interpretation phase, the var(musicexpr)
1521 argument will be interpreted with a context of type var(name). If you
1522 specify a name, the specific context with that name is searched.
1524 If a context of the specified type and name can not be found, a new
1525 one is created. For example,
1528 )verb(\score { \notes \relative c'' { c4 <d4 \context Staff = "another" e4> f} })COMMENT(
1530 ) in this example, the code(c) and code(d) are
1531 printed on the default staff. For the code(e), a context Staff called
1532 code(another) is specified; since that does not exist, a new context is
1533 created. Within code(another) a (default) Voice context is created
1534 for the code(e4). When all music referring to a context is finished, the
1535 context is ended as well. So after the third quarter, the
1536 code(another) is removed.
1538 Almost all music expressions inherit their interpretation context from
1539 their parent. In other words, suppose that the syntax for a music
1540 expression is code(\keyword) var(musicexpr1) var(musicexpr2) dots().
1541 When the interpretation of this music expression starts, the context
1542 for var(musicexpr1), var(musicexpr2), etc. that of the total
1545 Lastly, you may wonder, why doesn't this:
1546 verb(\score { \notes \relative c'' { c4 d4 e4 }})
1548 mudela()(\score { \notes \relative c'' { <c4> <d4> <e4> }})
1550 For code(c4) a default Staff (with contained Voice) context is
1551 created. After the code(c4), ends no music refers to this default
1552 staff, so it would be ended, with the result shown. To prevent this
1553 inconvenient behavior, the context to which the sequential music
1554 refers is adjusted during the interpretation. So after the code(c4)
1555 ends, the context of the sequential music is also the default Voice
1556 context. The code(d4) gets interpreted in the same context as code(c4)
1559 subsect(Predefined contexts)
1561 These are the contexts that come presupplied with LilyPond.
1562 They are defined in init file(ly/engraver.ly).
1566 dit(code(Grace))indexcode(Grace) The context for handling grace notes, it is
1567 instantiated automatically when you use code(\grace). It is a
1568 "embedded" miniature of the Score context. Since this context needs
1569 special interaction with the rest of LilyPond, you should not
1570 explicitly instantiate it.
1572 dit(code(LyricVoice))indexcode(LyricVoice) Corresponds to a voice with lyrics. Handles the printing
1573 of a single line of lyrics.
1575 dit(code(Thread))indexcode(Thread) Handles note heads, and is contained in the Voice
1576 context. You have to instantiate these explicitly if you want to
1577 adjust the style of individual noteheads.
1579 dit(code(Voice))indexcode(Voice) Corresponds to a voice on a staff. This context
1580 handles the conversion of dynamic signs, stems, beams, super- and
1581 subscripts, slurs, ties and rests.
1583 You have to instantiate these explicitly if you want to have
1584 multiple voices on the same staff.
1586 dit(code(ChordNamesVoice))indexcode(ChordNamesVoice) A voice with chord names. Handles printing
1587 of a line of chord names.
1589 dit(code(ChordNames))indexcode(ChordNames) Typesets chord names. Can contain
1590 code(ChordNamesVoice) contexts.
1592 dit(code(Lyrics))indexcode(Lyrics) Typesets lyrics. It can contain code(LyricVoice) contexts.
1594 dit(code(Staff))indexcode(Staff) Handles clefs, bar lines, keys,
1595 accidentals. It can contain code(Voice) contexts.
1597 dit(code(RhythmicStaff))indexcode(RhythmicStaff) A context like code(Staff) but for printing
1598 rhythms. Pitches are ignored; the notes are printed on one line.
1599 It can contain code(Voice) contexts.
1601 dit(code(GrandStaff))indexcode(GrandStaff) Contains code(Staff) or code(RhythmicStaff)
1602 contexts. It adds a brace on the left side grouping the staffs
1603 together. The bar lines of the contained staffs are connected vertically.
1604 It can contain code(Staff) contexts.
1606 dit(code(PianoStaff))indexcode(PianoStaff) Just like code(GrandStaff) but with
1607 code(minVerticalAlign) set equal to code(maxVerticalAlign) so that
1608 interstaff beaming and slurring can be used.
1610 dit(code(StaffGroup))indexcode(StaffGroup) Contains code(Staff) or code(RhythmicStaff)
1611 contexsts. Adds a bracket on the left side, grouping the staffs
1612 together. The bar lines of the contained staffs are connected vertically.
1613 It can contain code(Staff), code(RhythmicStaff), code(GrandStaff) or code(Lyrics) contexts.
1615 dit(code(ChoirStaff))indexcode(ChoirStaff) Identical to code(StaffGroup) except that the
1616 contained staffs are not connected vertically.
1618 dit(code(Score))indexcode(Score) This is the top level notation context. No
1619 other context can contain a code(Score) context. This context handles
1620 the administration of time signatures. It also makes sure that items
1621 such as clefs, time signatures, and key-signatures are aligned across
1622 staffs. It can contain code(Lyrics), code(Staff),
1623 code(RhythmicStaff), code(GrandStaff), code(StaffGroup), and
1624 code(ChoirStaff) contexts.
1626 You can not explicitly instantiate a Score context (since it is not
1627 contained in any other context.). It is instantiated automatically
1628 when an output definition (a code(\score) or code(\paper) block) is
1632 subsect(Context properties)
1634 Properties that are set in one context are inherited by all of the
1635 contained contexts. This means that a property valid for the Voice
1636 context can be set in the Score context (for example) and thus take
1637 effect in all Voice contexts.
1639 Properties can be preset within the code(\translator) block
1640 corresponding to the appropriate context. In this case, the syntax is
1641 `var(propname) code(=) var(value)'. This assignment happens before
1642 interpretation starts, so a code(\property) expression will override
1643 any pre defined settings.
1645 The code(\property) expression will create any property you specify.
1646 There is no guarantee that a property will be used. So if you spell a
1647 property name wrong, there will be no error message.
1649 The property settings are used during the interpretation phase. They
1650 are read by the LilyPond modules where interpretation contexts are
1651 built of. These modules are called em(translators). Translators for
1652 notation are called em(engravers) and translators for sound are called
1655 The precise result of a property is determined by the implementation
1656 of the translator that reads them. Therefore, the result of a
1657 property can vary, since it is implementation and configuration
1660 In order to fully find out what properties are used, you must search
1661 the source code for calls to code(get_property). The rest of the
1662 section is devoted to an (incomplete) overview of available properties.
1664 subsubsubsect(Lyrics properties)cindex(properties!Lyrics)
1668 dit(code(textStyle))indexcode(textStyle) Set the font for lyrics. The available font
1669 choices are code(roman), code(italic), code(bold), code(large),
1670 code(Large), code(typewriter), and code(finger). The code(finger)
1671 font can only display numbers. Note also that you must be careful
1672 when using code(\property) in Lyrics mode. Because of the way strings
1673 are parsed, either put quotes around the arguments to code(\property)
1674 or be sure to leave a space on both sides of the dot.
1679 subsubsubsect(Thread properties)cindex(properties!Thread)
1682 dit(code(noteheadStyle))indexcode(noteheadStyle) Selects type of note head. Choices are
1683 code(cross), code(diamond), code(harmonic), code(transparent), and
1684 code(""). They are shown in that order below.
1688 \property Staff.barNonAuto = 1
1689 \property Voice.noteHeadStyle = cross
1691 \property Voice.noteHeadStyle = diamond
1693 \property Voice.noteHeadStyle = harmonic
1695 \property Voice.noteHeadStyle = transparent
1697 \property Voice.noteHeadStyle = ""
1700 \paper{ linewidth = -1.;}
1706 subsubsubsect(Voice properties)cindex(properties!Voice)
1710 dit(code(stemLength))indexcode(stemLength) Set length of stems. Unit is
1711 code(interline)/2, so stemLength defaults to 7.
1713 dit(code(stemLeftBeamCount))indexcode(stemLeftBeamCount) Specify the number of beams to draw on
1714 the left side of the next note. Overrides automatic beaming. The
1715 value is only used once, and then it is erased.
1717 dit(code(stemRightBeamCount))indexcode(stemRightBeamCount) Specify the number of beams to draw on
1718 the right side of the next note. Overrides automatic beaming. The
1719 value is only used once, and then it is erased.
1721 dit(code(beamAuto))indexcode(beamAuto) If set to 1 then beams are generated
1722 automatically. If set to zero then no beams will be automatically
1723 generated. The default value is 1.
1725 dit(code(beamAutoEnd))indexcode(beamAutoEnd) Specifies when automatically generated beams
1726 can end. See Section ref(autobeam).
1728 dit(code(beamAutoBegin))indexcode(beamAutoBegin) Specifies when automatically generated beams
1729 can start. See Section ref(autobeam).
1731 dit(code(textEmptyDimension))indexcode(textEmptyDimension) If set to 1 then text placed above or
1732 below the staff is assumed to have zero width.
1734 dit(code(beamquantisation))indexcode(beamquantisation) Set to code(\none) for no quantization.
1735 Set to code(\normal) to quantize position and slope. Set to
1736 code(\traditional) to avoid wedges. These three settings are
1737 available via code(\beamposfree), code(\beamposnormal), and
1738 code(\beampostraditional).
1740 dit(code(beamslopedamping))indexcode(beamslopedamping) Set to code(\none) for undamped beams.
1741 Set to code(\normal) for damped beams. Set to code(\infinity) for
1742 beams with zero slope. The identifiers code(\beamslopeproportional),
1743 code(\beamslopedamped), and code(\beamslopezero) each set the
1744 corresponding value.
1746 dit(code(restStyle))indexcode(restStyle) Change the layout of rests shorter than quarter notes.
1747 Currently, the standard layout code(restStyle="") and mensural notation
1748 code(restStyle="mensural") are available.
1750 dit(code(midiInstrument))indexcode(midiInstrument) Sets the instrument for MIDI output. This
1751 property name must be quoted because of the embedded underscore. If
1752 this property is not set then LilyPond will use the code(instrument)
1753 property. This must be set to one of the strings on the list of MIDI
1754 instruments that appears in Section ref(midilist). If you use a
1755 string which is not listed, LilyPond will silently substitute piano.
1757 dit(code(transposing))indexcode(transposing) Tranpose the MIDI output. Set this property to
1758 the number of half-steps to transpose by.
1760 dit(code(oldTieBehavior))indexcode(oldTieBehavior) Set to 1 in order to get old tie behavior
1761 where ties would connect unequal pitches. This property is
1762 deprecated, and use is not recommended.
1764 dit(code(verticalDirection))indexcode(verticalDirection) Determines the direction of stems, subscripts,
1765 beams, slurs, and ties. Set to code(\down) to force them down,
1766 code(\up) to force them up, or code(\free) to let LilyPond decide.
1767 This can be used to distinguish between voices on the same staff. The
1768 code(\stemdown), code(\stemup), and code(\stemboth) identifiers set
1769 this property. See also the identifiers code(\voiceone),
1770 code(\voicetwo), code(\voicethree) and code(\voicefour).
1772 dit(code(slurVerticalDirection))indexcode(slurVerticalDirection) Set to code(\free) for free choice of slur
1773 direction, set to code(\up) to force slurs up, set to code(\down) to
1774 force slurs down. The shorthands code(\slurup), code(\slurdown), and
1775 code(\slurboth) are available.
1777 dit(code(tieVerticalDirection))indexcode(tieVerticalDirection) Set to code(\free) for free choice of tie
1778 direction, set to code(\up) to force ties up, set to code(\down) to
1781 dit(code(slurDash))indexcode(slurDash) Set to 0 for normal slurs, 1 for dotted slurs, and
1782 a larger value for dashed slurs. Identifiers code(\slurnormal) and
1783 code(\slurdotted) are predefined to set the first two settings.
1785 dit(code(horizontalNoteShift))indexcode(horizontalNoteShift) Enable LilyPond to shift notes
1786 horizontally if they collide with other notes. This is useful when
1787 typesetting many voices on one staff. The identifier code(\shift) is
1788 defined to enable this. Traditionally, the outer chords (the upmost
1789 and downmost voices), should have no horizontalNoteShift. Voice s
1792 dit(code(forceHorizontalShift))indexcode(forceHorizontalShift) Force horizontal shift for collision
1793 resolution. It overrides automatic collision resolution.
1794 This will only work if the context also has its stem direction and
1795 horizontalNoteShift property set. The value is the shift amount
1796 expressed in code(note_width), as set in the paper section.
1798 dit(code(dynamicDir))indexcode(dynamicDir) Determines location of dynamic marks. Set to
1799 code(\up) to print marks above the staff; set to code(\down) to print
1800 marks below the staff.
1802 dit(code(dynamicStyle))indexcode(dynamicStyle) Set the text style for dynamics.
1804 dit(code(textStyle))indexcode(textStyle) Set the text style for superscripts and
1805 subscripts. See above for list of text styles.
1807 dit(code(textScriptPadding))indexcode(textScriptPadding) Determines the extra space added between
1808 super-/subscripted text and the closest staff line or note.
1810 dit(code(fontSize))indexcode(fontSize) Can be used to select smaller font sizes for
1811 music. The normal font size is 0, and the two smaller sizes are -1
1814 dit(code(abbrev))indexcode(abbrev) Set length for tremolo to be used if no length is
1815 explicitly specified.
1817 dit(code(tupletDirection))indexcode(tupletDirection) Determines the direction of triplets and
1818 other tuplets. Set to code(\down) to force them below the staff,
1819 code(\up) to force them above, or code(\free) to let LilyPond decide.
1821 dit(code(tupletVisibility))indexcode(tupletVisibility) Determines whether tuplets of notes are
1822 labelled. Setting to 0 shows nothing; setting to 1 shows a number;
1823 setting to 2 shows a number and a bracket if there is no beam; setting
1824 to 3 shows a number, and if there is no beam it adds a bracket;
1825 setting to 4 shows both a number and a bracket unconditionally. The
1826 code(pletoff) and code(pleton) identifiers set the property to 0 and 3,
1829 dit(code(markScriptPadding))indexcode(markScriptPadding) Determines the extra space added between
1830 the mark and the closest staff line or note.
1832 dit(code(markDirection))indexcode(markDirection) Determines if marks should be printed above
1833 or below the staff. Set to code(\up) to print marks above the staff;
1834 set to code(\down) to print marks below the staff.
1836 dit(code(articulationScriptPadding))indexcode(articulationScriptPadding) Determines the extra space added
1837 between articulation marks, such as staccato, tenuto, trill, up/down
1838 bow or fermata, and the closest staff line or note.
1841 dit(code(articulationScriptVerticalDirection))indexcode(articulationScriptVerticalDirection) Determines the location
1842 of articulation marks. Set to code(\up) to print marks above the
1843 staff; set to code(\down) to print marks below the staff. This
1844 property does not override explicit directions marked with code(^) or
1845 code(_) in the mudela file.
1848 subsubsubsect(Staff properties)cindex(properties!Staff)
1852 dit(code(createInitdefaultClef))indexcode(createInitdefaultClef) Specify whether clefs are created on
1853 default? (Doesn't seem to do anything.)
1855 dit(code(barNumberDirection))indexcode(barNumberDirection) Set to code(\up) or code(\down) to put
1856 bar numbers above or below the staff.
1858 dit(code(barNumberHangOnClef))indexcode(barNumberHangOnClef) Set to 1 to cause bar numbers to appear
1859 above or below the clef instead of on the bar line.
1861 dit(code(barNumberScriptPadding))indexcode(barNumberScriptPadding) Sets extra space between the bar
1862 number and the bar it labels.
1864 dit(code(barSize))indexcode(barSize) Specify the height of the bar lines if it should be
1865 different than the staff height.
1867 dit(code(markHangOnClef))indexcode(markHangOnClef) Set to 1 to cause marks to appear by clefs
1868 instead of by bar lines. Deprecated, use is not recommended.
1870 dit(code(marginDirection))indexcode(marginDirection) Set to code(\left) or code(\right) to
1871 specify location of marginal scripts.
1873 dit(code(marginScriptPadding))indexcode(marginScriptPadding) Specify extra space for marginal scripts.
1875 dit(code(forgetAccidentals))indexcode(forgetAccidentals) Causes accidentals to be printed at every
1876 note instead of remembered for the duration of a measure.
1878 dit(code(noResetKey))indexcode(noResetKey) Do not reset the key at the start of a measure.
1879 Accidentals will be printed only once and are in effect until
1880 overridden, possibly many measures later.
1882 dit(code(staffLineLeading))indexcode(staffLineLeading) Specifies the distance (in points) between lines
1885 dit(code(numberOfStaffLines))indexcode(numberOfStaffLines) Specifies the number of staff lines. The
1888 dit(code(postBreakPadding))indexcode(postBreakPadding) Extra space in points to be added after
1889 the clef, time signature and key signature on the staff.
1891 dit(code(barAtLineStart))indexcode(barAtLineStart) Set to 1 to produce a bar line after the
1892 clef at the start of each line (but not at the beginning of the
1895 dit(code(noVoltaBraces))indexcode(noVoltaBraces) Set to true to suppress the printing
1896 of brackets over alternate endings specified by code(\alternative).
1898 dit(code(voltaSpannerDuration))indexcode(voltaSpannerDuration) Set to an integer to control the size
1899 of the brackets printed by code(\alternative). The integer specifies
1900 the number of whole notes duration to use for the brackets. It seems
1901 to be rounded to the nearest measure. This can be used to shrink the
1902 length of brackets in the situation where one alternative is very
1903 large. It may have odd effects if the specified duration is longer
1904 than the music given in an code(\alternative). [FIXME: This was
1907 dit(code(barNonAuto))indexcode(barNonAuto) If set to 1 then bar lines will not be printed
1908 automatically; they must be explicitly created with code(\bar) keywords.
1909 Unlike with the code(\cadenza) keyword, measures are still counted. Bar
1910 generation will resume according to that count if this property is set to
1913 dit(code(defaultClef))indexcode(defaultClef) Determines the default clef. See code(\clef)
1916 dit(code(numberOfStaffLines))indexcode(numberOfStaffLines) Sets the number of lines that the staff has.
1918 dit(code(barAlways))indexcode(barAlways) If set to 1 a bar line is drawn after each note.
1920 dit(code(defaultBarType))indexcode(defaultBarType) Sets the default type of bar line. See
1923 dit(code(keyOctaviation))indexcode(keyOctaviation) If set to 1, then keys are the same in all
1924 octaves. If set to 0 then the key signature for different octaves can
1925 be different and is specified independently: code(\keysignature bes
1926 fis'). The default value is 1. Can be set to zero with
1927 code(\specialkey) or reset to 1 with code(\normalkey).
1929 dit(code(instrument) and code(instr)) If code(Staff_margin_engraver)
1930 cindex(instrument)cindex(instr)
1931 is added to the Staff translator, then the code(instrument) property
1932 is used to label the first line of the staff and the code(instr)
1933 property is used to label subsequent lines. If the
1934 code(midiInstrument) property is not set then code(instrument) is
1935 used to determine the instrument for MIDI output.
1937 dit(code(createKeyOnClefChange))indexcode(createKeyOnClefChange) Set to a nonempty string if you want key
1938 signatures to be printed when the clef changes. Set to the empty string (the
1939 default) if you do not want key signatures printed.
1941 dit(code(timeSignatureStyle))indexcode(timeSignatureStyle) Changes the default two-digit layout
1942 for time signatures. The following values are recognized:
1944 dit(code(C))indexcode(C) 4/4 and 2/2 are typeset as C and struck C,
1945 respectively. All other time signatures are written with two digits.
1946 dit(code(old))indexcode(old) 2/2, 3/2, 2/4, 3/4, 4/4, 6/4, 9/4, 4/8, 6/8 and
1947 9/8 are typeset with old-style mensuration marks. All other time
1948 signatures are written with two digits.
1949 dit(code(1))indexcode(1) All time signatures are typeset with a single
1950 digit, e.g. 3/2 is written as 3.
1951 dit(indexandcode(C2/2), code(C4/4), code(old2/2), code(old3/2),
1952 code(old2/4), code(old3/4), code(old4/4), code(old6/4),
1953 code(old9/4), code(old4/8), code(old6/8), code(old6/8alt)
1954 or code(old9/8))Tells Lilypond to use a specific symbol as
1957 The different time signature characters are shown below with
1961 \notes\relative c'' {
1962 \property Voice.textStyle = typewriter
1963 \property Staff.timeSignatureStyle = "C2/2"
1964 \time 2/2; a2^"C2/2" a2
1965 \property Staff.timeSignatureStyle = "C4/4"
1966 \time 2/2; a2^"C4/4" a2
1967 \property Staff.timeSignatureStyle = "old2/2"
1968 \time 2/2; a2^"old2/2" a2
1969 \property Staff.timeSignatureStyle = "old3/2"
1970 \time 2/2; a2^"old3/2" a2
1971 \property Staff.timeSignatureStyle = "old2/4"
1972 \time 2/2; a2^"old2/4" a2
1973 \property Staff.timeSignatureStyle = "old4/4"
1974 \time 2/2; a2^"old4/4" a2
1975 \property Staff.timeSignatureStyle = "old6/4"
1976 \time 2/2; a2^"old6/4" a2
1977 \property Staff.timeSignatureStyle = "old9/4"
1978 \time 2/2; a2^"old9/4" a2
1979 \property Staff.timeSignatureStyle = "old4/8"
1980 \time 2/2; a2^"old4/8" a2
1981 \property Staff.timeSignatureStyle = "old6/8"
1982 \time 2/2; a2^"old6/8" a2
1983 \property Staff.timeSignatureStyle = "old6/8alt"
1984 \time 2/2; a2^"old6/8alt" a2
1985 \property Staff.timeSignatureStyle = "old9/8"
1986 \time 2/2; a2^"old9/8" a2
1988 \paper{ linewidth= 4.5 \in; }
1992 dit(code(clefStyle))indexcode(clefStyle) Determines how clefs are typeset. When set to
1993 code(transparent), the clefs are not printed at all, when set to
1994 code(fullSizeChanges), clef changes in the middle of a line are
1995 typeset with a full size clef. By default, clef changes are typeset in
2000 subsubsubsect(GrandStaff properties)cindex(properties!GrandStaff)
2004 dit(code(alignmentReference))indexcode(alignmentReference) Set to code(\center) for vertical
2005 alignment reference point to be in the center of the vertical group.
2006 Set to code(\up) to put the reference point at the top of the group.
2008 dit(code(maxVerticalAlign))indexcode(maxVerticalAlign) Set the maximum vertical distance between
2011 dit(code(minVerticalAlign))indexcode(minVerticalAlign) Set the minimum vertical distance between
2016 subsubsubsect(Score properties)cindex(properties!Score)
2020 dit(code(skipBars))indexcode(skipBars) Set to 1 to skip the empty bars that are produced
2021 by multimeasure notes and rests. These bars will not appear on the
2022 printed output. Set to zero (the default) to expand multimeasure
2023 notes and rests into their full length, printing the appropriate
2024 number of empty bars so that synrchonization with other voices is
2025 preserved. COMMENT(meaning of "skip" here seems to be different from
2026 the meaning used for the keyword \skip.)
2029 subsubsubsect(ChordNamesVoice properties)cindex(properties!ChordNamesVoice)
2032 dit(code(chordInversion))indexcode(chordInversion) Determines whether LilyPond should look for
2033 chord inversions when translating from notes to chord names. Set to 1
2034 to find inversions. The default is 0 which does not look for inversions.
2038 sect(Notation output definitions)cindex(Output)cindex(Notation output)
2039 cindex(output definition)
2043 The most important output definition is the code(\paper) block, for
2044 music notation. The syntax is
2045 code(\paper {) [var(paperidentifier)] var(items) code(}),
2046 where each of the items is one of
2050 it() An assignment. The assignment must be terminated by a semicolon.
2051 See Section ref(papervars) for information on paper variables.
2053 it() A context definition, see Section ref(contextdefs) for more
2054 information on context definitions.
2056 it() A margin shape declaration. The syntax is code(\shape)
2057 var(indent1)code(,) var(width1)code(,) var(indent2)code(,) var(width2)
2060 Each pair of var(indent) and var(width) values is a
2061 dimension specifying how far to indent and how wide to make the line.
2062 The indentation and width of successive lines are specified by the
2063 successive pairs of dimensions. The last pair of dimensions will
2064 define the characeristics of all lines beyond those explicitly
2067 it() A font declaration. Its syntax is var(fontsize) code(=)
2068 code(\font)keyindex(font) var(fontname). var(fontsize) is an integer
2069 describing the font to be used. 0 is the default font. var(fontname)
2070 is the basename of a font (usually a member of the Feta family).
2077 subsect(Changing Font Size and Paper Size)cindex(Changing Font Size and Paper Size)
2079 The Feta font provides musical symbols at six different sizes. These
2080 fonts are 11 point, 13 point, 16 point, 20 point, 23 point, and 26
2081 point. The point size of a font is the height of the five line staff
2082 when displayed in the font.
2084 Definitions for these sizes are the files file(paperSZ.ly), where
2085 code(SZ) is one of 11, 13, 16, 20, 23 and 26. If you include any of
2086 these files, the identifiers code(paper_eleven), code(paper_thirteen),
2087 code(paper_sixteen), code(paper_twenty), code(paper_twentythree), and
2088 code(paper_twentysix) are defined respectively. The default
2089 code(\paper) block is also set.
2091 To change the paper size, you must first set the code(papersize)
2092 variable at the top level. Set it to the strings code(a4),
2093 code(letter), or code(legal). After this specification, you must set
2094 the font as described above. If you want the default font, then use
2095 the 20 point font. The new paper size will not take effect if the
2096 font is not loaded and selected afterwards. Paper size selection
2097 works by loading a file named after the paper size you select.
2101 subsect(Paper variables)cindex(Paper variables)
2104 There are a large number of paper variables that are used to control
2105 details of the layout. These variables control layout defaults for the
2106 entire score. Usually you will not want to change these
2107 variables; they are set by default to vaules that depend on the font
2108 size in use. The values are used by the graphic objects while
2109 formatting the score; they are therefore implementation dependent.
2110 Most variables are accompanied by documentation in the
2111 initalization file file(params.ly) or file(paperSZ.ly), where code(SZ)
2112 is the staff height in points.
2114 Nevertheless, here are some variables you may want to use or change:
2117 dit(code(indent))indexcode(indent) The indentation of the first line of music.
2119 dit(code(interline))indexcode(interline) The distance between two
2120 staff lines, calculated from the center of the lines. You should use
2121 either this or code(rulethickness) as a unit for distances you modify.
2123 dit(code(linewidth))indexcode(linewidth) Sets the width of the
2124 lines. If it is set to -1.0, then a single unjustified line is
2127 dit(code(output))indexcode(output) Specifies an alternate name for
2128 the TeX() output. A file(.tex) extension will be added to the string
2131 dit(code(rulethickness))indexcode(rulethickness) Determines thickness of staff lines and bars.
2133 code(castingalgorithm)indexcode(castingalgorithm)0
2134 The algorithm to use for breaking lines.
2135 Choices are code(\Gourlay)keyindex(Gourlay) for a TeX() like dynamic
2136 programming algorithm, and code(\Wordwrap)keyindex(Wordwrap) for a
2137 simple algorithm. Gourlay breaking looks much better, but takes em(a
2138 lot) more resources. Wordwrap leaves really spaced out lines at the
2147 subsect(Context definitions)cindex(context definition)
2150 A notation contexts is defined by the following information
2154 it() The LilyPond modules that do the actual conversion of music to
2155 notation. Each module is a so-called code(Engraver)cindex(Engraver).
2156 it() How these modules should cooperate, i.e. which ``cooperation
2157 module'' should be used. This cooperation module is a special type
2159 it() what other contexts the context can contain,
2160 it() what properties are defined
2164 A context definition has this syntax: code(\translator
2165 { )var(translatorinit) var(translatormodifierlist) code(}).
2167 var(translatorinit) can be an identifier, or code(\type
2168 )var(typename)code(;). var(typename) is one of
2170 it() indexandcode(Engraver_group_engraver) the standard cooperation engraver.
2171 it() indexandcode(Score_engraver) this is cooperation module that should be
2172 in the top level context.
2173 it() indexandcode(Grace_engraver_group)
2174 This is a special cooperation module (resembling Score_engraver),
2175 that is used to created an embedded `miniscore'
2178 var(translatormodifierlist) is a list of items, where each item is one
2182 it() code(\consists) var(engravername)code(;)
2183 Add var(engravername) to the list of modules in this
2184 context. Section ref(engravers) contains an overview of the
2185 engravers available. The order of engravers added with
2186 code(\consists) is significant.
2188 it() code(\consistsend) var(engravername)code(;)
2189 Analogous to code(\consists), but makes sure that var(engravername)
2190 is always added to the end of the list of engravers. Useful if this
2191 context is to be modified with identifiers and code(\remove) later
2194 Some engraver types need to be at the end of the list; this
2195 insures they are put there, and stay there, if a user adds or
2196 removes engravers. This command is usually not needed for
2201 it() code(\accepts) var(contextname)code(;)
2202 Add var(contextname) to the list of context this context can
2203 contain. The first listed context the context to create by
2206 it() code(\remove) var(engravername)code(;)
2207 Remove a previously added (with code(\consists)) engraver
2209 it() code(\name) var(contextname)code(;) This sets name of the
2210 context, eg. code(Staff), code(Voice). If the name is not
2211 specified, the translator won't do anything.
2214 var(propname)code(=)var(value)code(;) A property assignment. It is
2215 legal to use reals for var(value)
2221 In the code(\paper) block, it is also possible to define translator
2222 identifiers. Like other block identifiers, the identifier can only
2223 be used as the very first item of a translator. In order to define
2224 such an identifier outside of code(\score), you must do
2226 \paper{ foo=\translator{ ... } }
2229 \paper{ \translator{ \foo ... } }
2232 subsubsect(Paper Types and Engravers and Pre-defined Translators)cindex(Paper Types and Engravers and Pre-defined Translators)
2234 Some pre-defined identifiers can simplify modification of translators.
2235 The pre-defined identifiers are:
2237 dit(code(StaffContext))indexcode(StaffContext)
2238 Default Staff context.
2239 dit(code(RhythmicStaffContext))indexcode(RhythmicStaffContext)
2240 Default RhythmicStaff context.
2241 dit(code(VoiceContext))indexcode(VoiceContext)
2242 Default Voice context.
2243 dit(code(ScoreContext))indexcode(ScoreContext)
2244 Default Score context.
2245 dit(code(ScoreWithNumbers))indexcode(ScoreWithNumbers)
2246 Score context with numbering at the Score level.
2248 dit(code(BarNumberingStaffContext))indexcode(BarNumberingStaffContext)
2249 Staff context with numbering at the Staff level.
2251 dit(code(HaraKiriStaffContext))indexcode(HaraKiriStaffContext)
2252 Staff context that does not print if it only contains rests. Useful for
2253 orchestral scores.footnote(Hara kiri is the ritual suicide of the Samourai)
2254 dit(code(OrchestralPartStaffContext))indexcode(OrchestralPartStaffContext)
2255 dit(code(OrchestralScoreContext))indexcode(OrchestralScoreContext)
2258 Using these pre-defined values, you can remove or add items to the
2259 translator verb(\paper{ \translator{ \StaffContext
2260 \remove Some_engraver;
2261 \consists Different_engraver; }})
2264 subsubsect(Engravers)
2268 The engravers for paper output are:
2273 dit(code(Bar_engraver))indexcode(Bar_engraver) Engraves bar lines. Normally in code(Staff) and
2274 code(RhythmicStaff).
2275 dit(code(Bar_number_engraver))indexcode(Bar_number_engraver) Engrave bar numbers. These numbers
2276 appear at the start of each line. Not normally in any translator. Can
2277 be added to code(Score) for Score-wide numbering or to code(Staff) for
2278 numbering on each staff.
2280 dit(code(Beam_engraver))indexcode(Beam_engraver) Handles beam requests by engraving beams. Normally
2281 appears in the code(Voice) translator. If omitted, then notes will be printed
2282 with flags instead of beams.
2284 dit(code(Beam_req_swallow_translator))indexcode(Beam_req_swallow_translator) Swallows beam requests. In
2286 dit(code(Chord_name_engraver))indexcode(Chord_name_engraver) Engraves chord names. Normally in
2287 code(ChordNameVoice)
2288 dit(code(Chord_tremolo_engraver))indexcode(Chord_tremolo_engraver)
2289 dit(code(Clef_engraver))indexcode(Clef_engraver) Engraves the clef symbol. Normally in code(Staff).
2290 dit(code(Collision_engraver))indexcode(Collision_engraver)
2291 dit(code(Dot_column_engraver))indexcode(Dot_column_engraver) Engraves dots on dotted notes shifted to the
2292 right of the note. Normally in code(Voice). If omitted, then dots appear on
2294 dit(code(Dynamic_engraver))indexcode(Dynamic_engraver) Engraves dynamics symbols. Normally in code(Voice).
2295 dit(code(Font_size_engraver))indexcode(Font_size_engraver)
2296 dit(code(Key_engraver))indexcode(Key_engraver) Engraves the key signature. Normally in code(Staff).
2297 dit(code(Local_key_engraver))indexcode(Local_key_engraver)
2298 dit(code(Lyric_engraver))indexcode(Lyric_engraver) Engraves lyrics. Normally in code(LyricVoice).
2299 dit(code(Multi_measure_rest_engraver))indexcode(Multi_measure_rest_engraver) Engraves multi-measure rests that are
2300 produced with code(R). Normally in code(Voice).
2301 dit(code(Piano_bar_engraver))indexcode(Piano_bar_engraver)
2302 dit(code(Pitch_squash_engraver))indexcode(Pitch_squash_engraver) Treat all pitches as middle C. Used in
2303 code(RhythmicStaff). Note that the notes move, but the locations of
2304 accidentals stay the same.
2305 dit(code(Priority_horizontal_align_engraver))indexcode(Priority_horizontal_align_engraver)
2306 dit(code(Repeat_engraver))indexcode(Repeat_engraver) Handles repeats? In code(Staff) and
2307 code(RhythmicStaff).
2308 dit(code(Rest_collision_engraver))indexcode(Rest_collision_engraver) Handles collisions of rests. In code(Staff).
2309 dit(code(Rest_engraver))indexcode(Rest_engraver) Engraves rests. Normally in code(Voice).
2310 dit(code(Rhythmic_column_engraver))indexcode(Rhythmic_column_engraver)
2311 dit(code(Score_priority_engraver))indexcode(Score_priority_engraver)
2312 dit(code(Script_engraver))indexcode(Script_engraver) Handles note ornaments generated by code(\script).
2313 Normally in code(Voice).
2314 dit(code(Separating_line_group_engraver))indexcode(Separating_line_group_engraver)
2315 dit(code(Skip_req_swallow_translator))indexcode(Skip_req_swallow_translator)
2316 dit(code(Slur_engraver))indexcode(Slur_engraver) Engraves slurs. Normally in code(Voice).
2317 dit(code(Span_bar_engraver))indexcode(Span_bar_engraver) Engraves lines across multiple staffs. Normally
2318 in code(Staffgroup) and code(GrandStaff). Removing this from code(StaffGroup)
2319 gives the definition of code(ChoirStaff).
2320 dit(code(Span_score_bar_engraver))indexcode(Span_score_bar_engraver)
2321 dit(code(Staff_group_bar_engraver))indexcode(Staff_group_bar_engraver)
2322 dit(code(Staff_margin_engraver))indexcode(Staff_margin_engraver) Prints the name of the instrument
2323 (specified by code(Staff.instrument) and code(Staff.instr)) at the
2325 dit(code(Staff_sym_engraver))indexcode(Staff_sym_engraver)
2326 dit(code(Stem_engraver))indexcode(Stem_engraver) Engraves stems. Normally in code(Voice).
2327 dit(code(Ties_engraver))indexcode(Ties_engraver) Engraves ties. Normally in code(Voice).
2328 dit(code(Time_signature_engraver))indexcode(Time_signature_engraver) Engraves the time signature. Normally in
2329 code(Staff) and code(RhythmicStaff).
2330 dit(code(Timing_engraver))indexcode(Timing_engraver) Responsible for synchronizing timing information
2331 from staffs. Normally in code(Score). In order to create polyrhythmic music,
2332 this engraver should be removed from code(Score) and placed in code(Staff).
2333 dit(code(Tuplet_engraver))indexcode(Tuplet_engraver) Engraves tuplet brackets? In code(Staff).
2334 dit(code(Vertical_align_engraver))indexcode(Vertical_align_engraver)
2338 sect(Pre-defined Identifiers)cindex(Pre-defined Identifiers)
2341 Various identifiers are defined in the initialization files to
2342 provide shorthands for some settings.
2345 dit(code(\break))keyindex(break) Force a line break in music by using a large
2346 argument for the keyword code(\penalty).
2347 dit(code(\center))keyindex(center) Used for setting textalignment property. Is set to 0.
2348 dit(code(\down))keyindex(down) Used for setting direction setting properties. Is
2350 dit(code(\free))keyindex(free) Used for setting direction setting properties. Is
2352 dit(code(\infinity))keyindex(infinity) Used for setting the Score.beamslopedamping
2353 property. Is actually equal to 10000.
2354 dit(code(\left))keyindex(left) Used for setting textalignment property. Is equal to -1.
2355 dit(code(\nobreak))keyindex(nobreak) Prevent a line break in music by using a large
2356 negative argument for the keyword code(\penalty).
2357 dit(code(\none))keyindex(none) Used for setting Score.beamslopedamping and
2358 Score.beamquantisation properties. Is equal to 0.
2359 dit(code(\normal))keyindex(normal) Used for setting Score.beamslopedamping and
2360 Score.beamquantisation properties. Is equal to 1.
2361 dit(code(\normalkey))keyindex(normalkey) Select normal key signatures where each octave
2362 has the same key signature. This sets the Staff.keyoctaviation property.
2363 dit(code(\right))keyindex(right) Used for setting textalignment property. Is set to 1.
2364 dit(code(\shiftoff))keyindex(shiftoff) Disable horizontal shifting of note heads that collide.
2365 Sets the Voice.horizontalNoteShift property.
2366 dit(code(\shifton))keyindex(shifton) Enable note heads that collide with other note heads
2367 to be shifted horiztonally. Sets the Voice.horizontalNoteShift property.
2368 dit(code(\slurboth))keyindex(slurboth) Allow slurs to be above or below notes. This
2369 sets the Voice.slurVerticalDirection property.
2370 dit(code(\slurdown))keyindex(slurdown) Force slurs to be below notes. This sets the
2371 Voice.slurVerticalDirection property.
2372 dit(code(\slurup))keyindex(slurup) Force slurs to be above notes. This sets the
2373 Voice.slurVerticalDirection property.
2374 dit(code(\specialkey))keyindex(specialkey) Allow keys signatures do differ in different
2375 octaves. This sets the Staff.keyoctaviation property.
2376 dit(code(\stemboth))keyindex(stemboth) Allow stems, beams, and slurs to point either
2377 direction. This sets the Voice.verticalDirection property.
2378 dit(code(\stemdown))keyindex(stemdown) Force stems, beams, and slurs to point down.
2379 This sets the Voice.verticalDirection property.
2380 dit(code(\stemup))keyindex(stemup) Force stems, beams and slurs to point up. This
2381 sets the Voice.verticalDirection property.
2382 dit(code(\traditional))keyindex(traditional) Used for setting the
2383 Score.beamquantisation property. Is equal to 2.
2384 dit(code(\up))keyindex(up) Used for setting various direction properties. Is
2392 subsect(output definition)
2394 The MIDI block is analogous to the paper block, but it is simpler.
2395 The code(\midi) block can contain:cindex(MIDI block)
2398 it() a code(\tempo) definition.
2399 it() context definitions
2402 Assignments are illegal in the code(\midi) block.
2405 subsect(Context definitions) cindex(context definitions)
2407 Context definitions follow the precisely the same syntax as within the
2408 \paper block. Translation modules for sound are called performers.
2409 The contexts for MIDI output are defined in file(performer.ly).
2412 subsect(MIDI Instrument Names)cindex(MIDI Instrument Names)
2415 The MIDI instrument name is set by the indexandcode(Staff.midiInstrument)
2416 property or, if that property is not set, the ndexandcode(Staff.instrument)
2417 property. The instrument name should be chosen from this list. If
2418 string does not exactly match one from this list then LilyPond uses
2421 COMMENT( acordina = accordion, tango accordian = concertina
2422 distortion guitar = distorted guitar
2423 orchestral strings = harp
2424 pan flute = wood flute? )
2426 verb("acoustic grand" "contrabass" "lead 7 (fifths)"
2427 "bright acoustic" "tremolo strings" "lead 8 (bass+lead)"
2428 "electric grand" "pizzicato strings" "pad 1 (new age)"
2429 "honky-tonk" "orchestral strings" "pad 2 (warm)"
2430 "electric piano 1" "timpani" "pad 3 (polysynth)"
2431 "electric piano 2" "string ensemble 1" "pad 4 (choir)"
2432 "harpsichord" "string ensemble 2" "pad 5 (bowed)"
2433 "clav" "synthstrings 1" "pad 6 (metallic)"
2434 "celesta" "synthstrings 2" "pad 7 (halo)"
2435 "glockenspiel" "choir aahs" "pad 8 (sweep)"
2436 "music box" "voice oohs" "fx 1 (rain)"
2437 "vibraphone" "synth voice" "fx 2 (soundtrack)"
2438 "marimba" "orchestra hit" "fx 3 (crystal)"
2439 "xylophone" "trumpet" "fx 4 (atmosphere)"
2440 "tubular bells" "trombone" "fx 5 (brightness)"
2441 "dulcimer" "tuba" "fx 6 (goblins)"
2442 "drawbar organ" "muted trumpet" "fx 7 (echoes)"
2443 "percussive organ" "french horn" "fx 8 (sci-fi)"
2444 "rock organ" "brass section" "sitar"
2445 "church organ" "synthbrass 1" "banjo"
2446 "reed organ" "synthbrass 2" "shamisen"
2447 "accordion" "soprano sax" "koto"
2448 "harmonica" "alto sax" "kalimba"
2449 "concertina" "tenor sax" "bagpipe"
2450 "acoustic guitar (nylon)" "baritone sax" "fiddle"
2451 "acoustic guitar (steel)" "oboe" "shanai"
2452 "electric guitar (jazz)" "english horn" "tinkle bell"
2453 "electric guitar (clean)" "bassoon" "agogo"
2454 "electric guitar (muted)" "clarinet" "steel drums"
2455 "overdriven guitar" "piccolo" "woodblock"
2456 "distorted guitar" "flute" "taiko drum"
2457 "guitar harmonics" "recorder" "melodic tom"
2458 "acoustic bass" "pan flute" "synth drum"
2459 "electric bass (finger)" "blown bottle" "reverse cymbal"
2460 "electric bass (pick)" "skakuhachi" "guitar fret noise"
2461 "fretless bass" "whistle" "breath noise"
2462 "slap bass 1" "ocarina" "seashore"
2463 "slap bass 2" "lead 1 (square)" "bird tweet"
2464 "synth bass 1" "lead 2 (sawtooth)" "telephone ring"
2465 "synth bass 2" "lead 3 (calliope)" "helicopter"
2466 "violin" "lead 4 (chiff)" "applause"
2467 "viola" "lead 5 (charang)" "gunshot"
2468 "cello" "lead 6 (voice)")
2471 subsubsect(MIDI Types and Performers)cindex(MIDI Types and Performers)
2473 The types available for MIDI translators are:
2475 dit(code(Performer_group_performer))indexcode(Performer_group_performer)
2476 dit(code(Score_performer))indexcode(Score_performer)
2477 dit(code(Staff_performer))indexcode(Staff_performer)
2480 The performers for MIDI translators are:
2482 dit(code(Key_performer))indexcode(Key_performer)
2483 dit(code(Time_signature_performer))indexcode(Time_signature_performer)
2484 dit(code(Note_performer))indexcode(Note_performer)
2485 dit(code(Lyric_performer))indexcode(Lyric_performer)
2486 dit(code(Swallow_performer))indexcode(Swallow_performer)
2493 sect(Running LilyPond)cindex(Running LilyPond)
2496 When invoked with a filename that has no extension, LilyPond will try
2497 adding a file(.ly) extension first, then a file(.sly) and then a
2498 file(.ly) extension second. If the filename ends with file(.fly),
2499 LilyPond processes the file as music using file(init.fly). In this
2500 case, LilyPond does something like: COMMENT(
2504 \input "yourfile.fly"
2509 If you invoke LilyPond with a file file(foo.)var(ext) that doesn't
2510 have the file(.ly) extension then LilyPond will look for a file called
2511 file(init.)var(ext) and process this file. The file
2512 file(init.)var(ext) must contain the code(\maininput) keyword or LilyPond
2513 will not read the user specified file.
2515 When LilyPond processes file(filename.ly) it will produce
2516 file(filename.tex) as output. If file(filename.ly) contains a second
2517 code(\paper) keyword, then LilyPond will produce file(filename-1.tex)
2518 as well. Subsequent code(\paper) keywords will produces sequentially
2519 numbered file names. Several files can be specified; they will each
2520 be processed independently.footnote(Not entirely true: the status of
2523 sect(Future improvements)cindex(Future improvements)
2525 Chord tremolos will be done with a code(\repeat) variant in
2528 The syntax of repeats is not entirely crystallised. You can expect
2529 more variants, better MIDI integration, better time handling.
2533 latexcommand(\printindex)