1 mailto(gnu-music-discuss@gnu.org)
4 redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
8 redef(code)(1)(tt(ARG1))
18 \notes{ \context Voice {
19 \repeat fold 2 { a b c d } {}
25 restStyle=mensural doesn't seem to work (lots of characters not found
32 the explanation of how lyrics mode parses words seems ridiculous.
33 Is there a simple way to explain this, or is the behavior
34 too complicated for a reasonable explanation?
36 interstaff beams (beam-interstaff.ly)
37 interstaff slurs (see preludes-1.ly)
42 This document contains Mudela fragments. You need at least
43 Yodl-1.30.18 to convert this to tex or html.
46 htmlbodyopt(bgcolor)(white)
47 htmlcommand(<font color=black>)
50 \setlength{\topmargin}{-0.25in}
51 \setlength{\textheight}{9in}
52 \setlength{\textwidth}{5.875in}
53 \setlength{\oddsidemargin}{0.25in}
54 \setlength{\evensidemargin}{0.25in}
58 whentexinfo(notableofcontents())
60 article(Mudela 1.0.21 / LilyPond 1.1.49 Reference Manual)
61 (Adrian Mariano, Han-Wen Nienhuys and Jan Nieuwenhuizen)
62 (nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())
68 * paragraphs have too much space.
73 latexcommand(\def\interexample{})
74 latexcommand(\def\preexample{\par})
75 latexcommand(\def\postexample{\par\medskip})
76 latexcommand(\def\file#1{{code(#1)}})
78 latexcommand(\def\texttt#1{\tt #1})
79 latexcommand(\def\textbf#1{\bf #1})
82 COMMENT(urg, texinfo include breaks)
84 includefile(html-disclaimer.yo-urg)
87 bf(This document is not up to date). All rendered examples of course
88 are current, but the rest probably isn't. Adjusting the tutorial was
89 considered more important than writing the reference manual. We
90 apologize for the inconvenience. For a complete and up-to-date
91 definition, see file(lily/parser.yy), file(lily/lexer.ll), and the
94 This document describes the the GNU LilyPond input format, which is an
95 effective language for defining music. We call this language (rather
96 arrogantly) The Musical Definition Language or Mudela, for
97 short.footnote(If anybody comes up with a better name, we'd gladly
98 take this. Gourlay already uses Musical Description Language,
99 G-Sharp Score Definition Language. ISO standard 10743 defines a
100 Standard Music Description Language. We're not being original here.)
102 The first aim of Mudela is to define a piece of music, being complete
103 from both from a musical typesetting, as from a musical performing
106 The Musical Definition Language (Mudela), has a logical structure,
107 making use of identifiers, that allows for flexible input, and
108 definition reuse. See the documentation file file(MANIFESTO), included
109 with the LilyPond sources for reasons and design considerations.
112 sect(Running LilyPond)
114 When invoked with a filename that has no extension, LilyPond will try adding
115 a file(.fly) extension first, and a file(.ly) extension second.
116 If the filename ends with
117 file(.fly), LilyPond processes the file as music using
118 file(init.fly). In this case, LilyPond does something
122 \input "yourfile.fly"
127 If you invoke LilyPond with a file file(foo.)var(ext) that doesn't
128 have the file(.ly) extension then LilyPond will look for a file called
129 file(init.)var(ext) and process this file. The file
130 file(init.)var(ext) must contain the code(\maininput) keyword or LilyPond
131 will not read the user specified file.
133 When LilyPond processes file(filename.ly) it will produce file(filename.tex) as
134 output. If file(filename.ly) contains a second code(\paper) keyword, then
135 LilyPond will produce file(filename-1.tex) as well. Subsequent code(\paper)
136 keywords will produces sequentially numbered file names. Several files can be
137 specified; they will each be processed independently.
141 subsect(Basic Mudela)
143 A Mudela file consists of keywords with arguments and identifier
144 assignments separated by spaces, tabs or newlines. Semicolons are
145 used by some keywords and are inconsistantly required in other
146 circumstances. A one line comment is introduced by a code(%)
147 character. Block comments are started by code(%{) and ended by
148 code(%}). They cannot be nested.
150 Mudela supports several types:
155 Formed from an optional minus sign followed by digits. Arithmetic
156 operations cannot be done with integers, and integers cannot be mixed
160 Formed from an optional minus sign and a sequence of digits followed
161 by a emph(required) decimal point and an optional exponent such as
162 code(-1.2e3). Reals can be built up using the usual operations:
163 code(+), code(-), code(*), and code(/), with parentheses for grouping.
166 Begins and ends with the code(") character. To include a code(")
167 character in a string write code(\"). Various other backslash
168 sequences have special interpretations as in the C language. A string
169 that contains no spaces can be written without the quotes. See
170 Section ref(modes) for details on unquoted strings; their
171 interpretation varies depending on the situation. On the right side
172 of identifier assignments and within the code(\header) keyword,
173 strings can be concatenated using the code(+) character.
175 dit(dimension) Consists of a real followed by one of the dimension
176 keywords: code(\mm), code(\pt), code(\in), or code(\cm). Dimensions
177 are converted immediately to a real which gives the dimension in
178 points, so they can be mixed with reals, but the result is no longer
179 of type dimension. The keywords that require a dimension
183 A pitch is a string which is the name of a pitch. Example: code(a).
184 The pitch names can be redefined with the code(\notenames) keyword.
185 See Section(notelang) for pitch names in different languages. Pitches
186 can only be specified inside note mode which is specified with
187 code(\notes). Therefore, keywords which require pitch arguments must
188 appear inside code(\notes).
191 Music is a compound type: arbitrarily complicated expressions with a
192 hierarchical structure can be formed from simple building blocks. The
193 simplest expression of type music is a single note. A note is formed
194 from a pitch and an optional duration and must be specified within
195 code(\notes). See Section ref(notedesc) for details. More
196 complicated expressions of type music are formed by surrounding a
197 sequence of expressions of type music with braces code({) and code(})
198 or with angle brackets code(<) and code(>). Items appearing in braces
199 will be treated as serial. Items in angle brackets will be
200 simultaneous. So for example code({ c e g }) represents an arpeggio
201 and code(< c e g >) represents a chord. These items can be nested any
202 way you like. This simple example shows how three chords can be
203 expressed in two different ways:
204 mudela(fragment,verbatim,center)(
207 <a c' e'> <b d' f'> <c' e' g'>
208 <{a b c'}{c' d' e'}{e' f' g'}>
217 Identifiers allow names to be assigned to constants, music, or other
218 Mudela structures. To assign an identifier you use
219 var(name)=var(value) and to refer to an identifier, you preceed its
220 name with a backslash: code(\)var(name). It is legal to redefine an
221 identifier in terms of its old value: code(foo = \foo * 2.0).
222 Identifier assignments must appear at the top level in the Mudela
223 file. Note that semicolons are forbidden after assignments appearing
224 at the top level but they are obligatory after assignments appearing
225 elsewhere. (Semicolons are also forbidden after code(\property) assignments.)
227 An identifier can be created with any string for its name, but you
228 will only be able to refer to identifiers whose names begin with a
229 letter and are entirely alphanumeric. It is also impossible to refer
230 to an identifier whose name is the same as the name of a keyword. The
231 following words are keywords:
232 verb(accepts duration midi relative textscript
233 alternative font mm remove time
234 bar musicalpitch repeat times
235 cadenza header name scm translator
236 chordmodifiers in notenames scmfile transpose
237 chords include notes score type
238 clef key paper script version
239 cm keysignature partial shape
240 consists lyrics penalty skip
241 consistsend maininput property spanrequest
242 context mark pt tempo)
244 The right hand side of an identifier assignment is parsed completely
245 when the assignment is made. It therefore must have any context
246 specified in the definition. For example, you must write
247 code(foo=\notes{a8 b c}) rather than code(foo={a8 b c}). Even though
248 the context is specified in the definition, you must refer to the
249 identifier inside the correct context:
250 verb(foo = \paper{ linewidth = 6.0\in; }
255 If code(\foo) is used here without the surrounding code(\paper) then
256 an error will result. Note however that the following is acceptible
257 verb(foo = \notes { ... }
259 It is not necessary to specify code(\notes).
261 Identifiers can be set equal to integers, reals, strings, music,
262 durations (specified with code(\duration)), note ornaments (specified
263 with code(\script), dynamics commands, or code(:)), note name tables
264 (specified with code(\notenames), translator definitions, the
265 code(\paper) block, the code(\midi) block or the code(\score) block.
266 When identifiers are used for translators, the code(\paper),
267 code(\midi), and code(\score) blocks, they may only be referred to as
268 the first item in a block. So code(\paper{\one \two}) is illegal
269 because the identifier code(\two) is not the first thing in the block.
270 Unlike other identifier definitions, translator identifier definitions
271 can only appear within code(\midi) or code(\paper) blocks. See
272 Section ref(translators) for more information.
279 To simplify different aspects of music definition (entering the notes
280 and manipulating them) Mudela has three different input modes which
281 affect how unquoted strings are interpreted.
282 In each mode, words are identified on the input. If code("word") is
283 encountered, it is treated as a string. If code(\word) is
284 encountered it is treated as a keyword or as an identifier. The
285 behavior of the modes differs in two ways: different modes treat
286 unquoted words different, and different modes have different rules for
287 deciding what is a word.
292 At the start of parsing, Mudela is in normal mode.
293 In normal mode, a word is an alphabetic character followed by
294 alphanumeric characters. If code(word) is encountered on the input it
295 is treated as a string.
297 dit(Note mode) Note mode is introduced by the keyword
298 code(\notes). In Note mode, words can only contain alphabetic
299 characters. If code(word) is encountered, LilyPond first checks for a
300 notename of code(word). If no notename is found, then code(word) is
301 treated as a string. If you mistype a notename, the parser will most
302 likely complain that you should be in code(\lyrics) mode to do lyrics.
304 dit(Chord mode) Chord mode is instroduced by the keyword code(\chords).
305 Very similar to Note mode.
306 COMMENT(I'm not sure how it differs)
308 dit(Lyric mode) Lyrics mode is introduced by the keyword
309 code(\lyrics). This mode is has rules that make it easy to include
310 punctuation and diacritical marks in words. A word in Lyrics mode
311 begins with: an alphabetic character, code(_),
312 code(?), code(!), code(:), code('),
313 the control characters code(^A) through code(^F), code(^Q) through
314 code(^W), code(^Y), code(^^), any 8-bit character with ASCII code over
315 127, or a two character combination of a backslash followed by one
316 of code(`), code('), code(") or code(^).
317 Subsequent characters of a word can be any character that is not a
318 digit and not white space. One important consequence of this is that
319 a word can end with code(}), which may be confusing if you thought the
320 code(}) was going to terminate lyrics mode. Any code(_) characters
321 which appear in an unquoted word are converted to spaces, providing a
322 mechanism for introducing spaces into words without using quotes.
323 Quoted words can also be used in lyrics mode to specify words that
324 cannot be specified with the above rules. Here are some examples.
325 Not all of these words are printable by TeX().
326 verb(a&@&@&TSI|{[ % a word
328 1THtrhortho % not a word because it starts with a digit
329 ``Hello'' % not a word because it starts with `
330 Leise DOEXPAND(Fl\)DOEXPAND("u\)ss{}teren meine Sapfe % 4 words
331 _ _ _ _ % 4 words, each one a space
334 It is possible to create words that break the rules by prefixing them with the
335 dollar sign code($). Regardless of the context, a word beginning with code($)
336 extends until the next white space character. Such words can contain numbers
337 (even in Note mode), or other forbidden characters. The dollar sign can be
338 used to create and access identifiers that could not otherwise be used.
341 These modes are of a lexical nature. Normal and Note mode largely
342 resemble each other, save the possibility of entering Reals,
343 meaning of code(_) and the resolution of words
345 What's this about reals? When can you enter them or not enter them?)
348 sect(Note Description)
351 subsect(Basic Note Specification)
353 A note specification has the form
354 var(pitch)[var(octavespec)][code(!)][code(?)][var(duration)].
355 The pitch of the note is specified by the note's name.
357 LilyPond has predefined note names for various languages. The default
358 names are the Dutch note names. The notes are specified by the
359 letters code(c) through code(b), where code(c) is an octave below
360 middle C and the letters span the ocatave above that C.
361 In Dutch, a sharp is formed by adding
362 code(-is) to the end of a pitch name. A flat is formed by adding code(-es).
363 Double sharps and double flats are obtained by adding code(-isis) or
365 Lily has predefined sets of notenames
366 for various nop(languages). See Section ref(notelang) for details.
367 Rests are specified with the note name code(r) or code(R).
368 There is also a note name code(s) which produces a nonprinting note of the
371 The optional octave specification takes the form of a series of single
373 code(') characters or a series of comma code(,) characters. Each
374 code(') raises the pitch by one octave; each code(,) lowers the pitch
377 mudela(fragment,verbatim,center)(
378 c' d' e' f' g' a' b' c''
381 mudela(fragment,verbatim,center)(
382 cis' dis' eis' fis' gis' ais' bis'
385 mudela(fragment,verbatim,center)(
386 ces' des' es' fes' ges' as' bes'
389 mudela(fragment,verbatim,center)(
390 cisis' eisis' gisis' aisis' beses'
393 mudela(fragment,verbatim,center)(
394 ceses' eses' geses' ases' beses'
397 Whenever a C-sharp is desired, you must specify a C-sharp. LilyPond
398 will determine what accidentals to typeset depending on the key and
400 A reminder accidental can be forced by
401 using the optional exclamation mark `code(!)'
403 A cautionary accidental, i.e., an accidental within paranthesis
404 can be obtained using the optional question mark `code(?)' on the pitch.
405 mudela(fragment,verbatim,center)(
406 cis' d' e' cis' c'? d' e' c'!
410 Durations are entered as their reciprocal values
411 mudela(fragment,verbatim,center)(
412 a'1 a'2 a'4 a a'8 a a'16 a'32 a'64
414 mudela(fragment,verbatim,center)(
418 If the duration is omitted then it is set equal to the previous
419 duration. If there is no previous duration, then a quarter note is
421 The duration can be followed by a dot code(.) to obtain dotted note
423 mudela(fragment,verbatim,center)(
427 Extra long notes can be obtained using the code(\breve) and
428 code(longa) durations:
429 mudela(fragment,verbatim,center)(
433 In order to get triplets and other tuplets, you must use the
434 code(\times) keyword which multiplies the duration by a fraction. The
435 syntax is code(\times) var(fraction) var(music). The length of all of
436 the specified music will be multiplied by the fraction and the
437 fraction's denominator will be printed over the notes. The most
438 common tuplet is the triplet in which 3 notes have the length of 2, so
439 the notes are 2/3 their written length:
440 mudela(fragment,verbatim,center)( b'4 \times 2/3 {c'4 c' c'} d'4 d'4 )
441 If you try to use code(\times) as the first thing in your music, you
442 may encounter the warning ``No one to print a tuplet start bracket''.
443 This happens because the Tuplet-engraver is in Voice and no Voice has
444 been created yet. You must explicitly specify the Voice context in
446 mudela(fragment,verbatim,center)(
447 \context Voice { \times 2/3 {c'4 d' e'}}
450 A shorthand for code(\times) is to write code(*)var(fraction) after a
451 duration. This shorthand will not label triplets correctly, but
452 it is convenient for long rests.
453 For long rests with durations equal to an integer number of whole notes,
454 LilyPond produces output that indicates the duration of the rest. If you use
455 code(r) then one rest symbol will be printed and several measures left blank.
456 If you use code(R) then all of the measure will be filled with whole rests.
457 mudela(fragment,verbatim,center)(
460 If you set the code(Score.skipBars) property, then only one measure will be
461 printed; with code(R), a number indicating the length of the rest will be
463 mudela(fragment,verbatim,center)(
464 \property Score.skipBars=1
467 Even though the code(\times) command is not explicit, it is still
468 necessary to specify a code(Voice) context if the music begins with
469 rests lengthened using code(*).
470 Otherwise, the following will result:
471 mudela(fragment,verbatim,center)(
476 subsect(Automatic Beam Generation)
479 By default, Lilypond will generate beams automatically. This feature can be
480 disabled by setting the code(Voice.beamAuto) property to 0. It can be
481 overridden for specific cases by specifying explicit beams as
482 described in Section ref(manualbeam).
484 In order to decide how to generate beams, Lilypond uses a large number
485 of Voice properties, whose default values appear in
486 file(auto-beam-settings.ly). In general, beams can begin anywhere,
487 but their ending location is significant. Beams can end on a beat, or
488 at durations specified by the code(Voice.beamAutoEnd) property. To
489 end beams every quarter note, for example, you could use set
490 code(Voice.beamAutoEnd) equal to code("1/4"). To end beams every
491 three eighth notes you would set it to code("3/8"). The same syntax
492 can be used to specify beam starting points using code(Voice.beamAutoBegin).
494 To allow different settings for different time signatures, these
495 property names can start with code(time)var(N)code(_)var(M) to
496 restrict the definition to var(N)code(/)code(M) time. So for example,
497 to specify beams ending only for 6/8 time you would use the property
498 code(Voice.time6_8beamAutoEnd). To allow different endings for notes
499 of different durations, the duration can be tacked onto the end of the
500 property. To specify beam endings for beams that contain 32nd notes,
501 you would use code(Voice.beamAutoEnd_32).
504 subsect(Note Spanners: Beams, Slurs and Ties)
507 A beam is specified by surrounding the beamed notes with brackets
509 mudela(fragment,verbatim,center)(
510 [a'8 a'] [a'16 a' a' a']
512 Some more elaborate constructions:
513 mudela(fragment,verbatim,center)(
514 [a'16 <a' c''> c'' <a' c''>]
515 \times 2/3 { [e'8 f' g'] }
518 Another type of spanner is the slur. Slurs connects chords and try to
519 avoid crossing stems. A slur is started with code(CHAR(40)) and stopped with
520 code(CHAR(41)). The starting code(CHAR(40)) appears to the right of the first note
521 in the slur. The terminal code(CHAR(41)) apppears to the left of the first
522 note in the slur. This makes it possible to put a note in slurs from
524 mudela(fragment,verbatim,center)(
525 f'()g'()a' [a'8 b'(] a'4 g' )f'
528 A tie connects two adjacent note heads of the same pitch.
529 When used with chords, it
530 connects all of the note heads whose pitches match.
531 Ties are indicated using the tilde symbol
532 code(~) by analogy with TeX()'s tie which connects words.
533 Note that if you try to tie together chords which have no common
534 pitches, then a warning message will appear and no tie will be created.
535 (Note that ties between different pitches can be enabled using the
536 property Voice.oldTieBehavior.)
538 mudela(fragment,verbatim,center)(
539 e' ~ e' <c' e' g'> ~ <c' e' g'>
542 It is possible to create beams and slurs that cross staffs by switching the
544 mudela(fragment,verbatim,center)(
545 \context PianoStaff <
546 \context Staff=one \notes\relative c'{
548 [c8 c \translator Staff=two \stemup c c]
549 \translator Staff=one
550 d4( \translator Staff=two )a4
552 \context Staff=two \notes{ \clef bass; s1}
558 subsect(Note Ornaments)
560 A variety of symbols can appear above and below notes to indicate
561 different characteristics of the performance. These symbols can be
562 added to a note with `var(note)code(-\)var(name)'. Numerous symbols
563 are defined in file(script.ly) and file(script.scm). Symbols can be
564 forced to appear above the note by writing
565 `var(note)code(^\)var(name)', and they can be forced to appear below
566 by writing `var(note)code(_\)var(name)'. Here is a chart showing
567 symbols above notes, with the name of the corresponding symbol
568 appearing underneath.
572 < \notes{ c''-\accent c''-\marcato c''-\staccatissimo f'-\fermata
573 c''-\stopped c''-\staccato c''-\tenuto c''-\upbow c''-\downbow
574 c''-\lheel c''-\rheel c''-\ltoe c''-\rtoe c''-\turn
575 c''-\open c''-\flageolet c''-\reverseturn
577 c''-\prall c''-\mordent c''-\prallprall c''-\prallmordent
578 c''-\upprall c''-\downprall c''-\thumb c''-\segno c''-\coda}
579 \context Lyrics \lyrics{
580 accent__ marcato__ staccatissimo__ fermata stopped__
581 staccato__ tenuto__ upbow downbow__ lheel__ rheel__ ltoe
582 rtoe__ turn__ open__ flageolet reverseturn__ trill__ prall__
583 mordent prallprall__ prallmordent__ uprall__ downprall thumb
586 \paper{ linewidth = 5.875\in;
591 In addition, it is possible to place arbitrary strings of text or
592 TeX() above or below notes by using a string instead of an identifier:
593 `code(c^"text")'. Fingerings can be placed by simply using digits.
594 All of these note ornaments appear in the printed output but have no
595 effect on the MIDI rendering of the music.
597 To save typing, a few common symbols can be abbreviated with
601 \property Voice.textStyle = typewriter
607 c''4-^_"c-\\^{ }" s4 }
608 \paper { linewidth = 12.\cm; }})
610 Dynamic marks are specified by using an identifier after a note without a dash:
611 code(c4 \ff). Note that this syntax is inconsistent with the syntax for other
612 types of ornaments. The available dynamic marks are: code(\pppppp),
613 code(\ppppp), code(\pppp), code(\ppp), code(\pp), code(\p), code(\mp),
614 code(\mf), code(\f), code(\ff), code(\fff), code(\ffff), code(\fffff),
615 code(\ffffff), code(\fp), code(\sf), code(\sff), code(\sp), code(\spp),
616 code(\sfz) and code(\rfz).
618 A crescendo mark is started with code(\cr) and terminated with
619 code(\rc). A decrescendo mark is started with code(\decr) and
620 terminated with code(\rced). There are also shorthands for these
621 marks. A crescendo can be started with code(\<) and a decrescendo can
622 be started with code(\>). Either one can be terminated with code(\!).
623 Note that code(\!) must go before the last note of the dynamic mark whereas
624 code(\rc) and code(\rced) go after the last note. Because these marks are
625 bound to notes, if you want to get several marks during one note, you must use
628 m udela(fragment,verbatim,center)(
629 c'' \< \! c'' d'' \decr e'' \rced
630 < f''1 {s4 \< \! s4 \> \! s2 } >)
634 COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
636 Tremolo marks can be printed by a note by adding code(:)[var(length)]
637 after the note. The length must be at least 8. A var(length) value
638 of 8 gives one line across the note stem.
639 If the length is omitted,
640 then the last value is used, or the value of the code(Abbrev)
641 property if there was no last value. To place tremolo marks in
642 between two notes, begin with code([:)var(length) and end with code(]).
643 The tremolo marks will appear instead of beams. Putting more than two
644 notes in such a construction will produce odd effects.
646 [TREMOLO BEAMS TEMPORARILY OUT OF ORDER]
648 COMMENT(mudela (fragment,verbatim,center)(
649 c'2:8 c':32 [:16 e'1 g'] [:8 e'4 f']
653 Is the last paragraph correct? Is it called "tremolo"? Why is
654 "abbreviation" used? (What is the unabreviated form?)
657 mudela (fragment,verbatim,center)(
664 sect(Other Ways to Enter Pitches)
666 subsect(Pitch Names in Other Languages)
669 The pitch names can be easily redefined using the code(\notenames) command.
670 Note name definitions have been provided in various languages.
671 Simply include the language specific init file. For example:
672 code(\include "english.ly"). The available language files and the names
675 verb( Note Names sharp flat
676 nederlands.ly c d e f g a bes b -is -es
677 english.ly c d e f g a bf b -s/-sharp -f/-flat
678 deutsch.ly c d e f g a b h -is -es
679 norsk.ly c d e f g a b h -iss/-is -ess/-es
680 svenska.ly c d e f g a b h -iss -ess
681 italiano.ly do re mi fa sol la sid si -d -b
682 catalan.ly do re mi fa sol la sid si -d/-s -b)
684 subsect(Relative Pitch Specification)
687 One very common error when entering music is to place notes in the wrong
688 octave. One way to avoid being confused by large numbers of octave changing
690 the code(\relative) keyword.
691 Music which appears within code(\relative) is
692 interpreted differently. The octave of a note is determined by making it as
693 close to the previous note as possible. The octave changing marks code(') and
694 code(,) can then be added to raise or lower this note by octaves. You have to
695 specify a starting pitch because the first note of a list has no predecessor.
697 mudela(fragment,verbatim,center)(
698 \relative c'' { c d b c, d b c' d
702 When the preceeding item is a chord, the first note of the chord is used to
703 determine the first note of the next chord. But other notes within the second
704 chord are determined by looking at the immediately preceeding note.
706 mudela(fragment,verbatim,center)(
707 \relative c' { c <c e g>
711 The code(\relative) keyword can only appear in music, so there must be a
712 surrounding code(\notes) keyword which does not appear in the fragments shown
713 above. Also note that if the music passed to a code(\relative) keyword
714 contains a code(\transpose) keyword, the tranposed music will not be
715 processed in relative mode. An additional code(\relative) must be placed
716 inside the code(\transpose). If code(\relative) will be used several
717 times, or if it will be used in the same music with code(\transpose),
718 then you may get bizarre effects. This can be fixed by using an
719 explicit code(Staff) context.
722 subsect(Tranposition of Pitches)
725 Another way to modify the meaning of the note names is to use the
726 code(\transpose) keyword. This keyword allows you to transpose music.
727 To use transposition, specify the pitch that middle C should be tranposed to.
728 It is important to distinguish between enharmonic pitches as they can produce
729 different transpositions. To transpose up half a step, for example, either
730 code(\transpose cis') or code(\transpose des') will work. But the first
731 version will print sharps and the second version will print flats.
732 In this example, a scale in the key of E is transposed to F, or to E-sharp
734 mudela(fragment,verbatim,center)(
735 \relative c' { \key e;
736 e fis gis a b cis dis e }
738 mudela(fragment,verbatim,center)(
739 \transpose des' \relative c' { \key e;
740 e fis gis a b cis dis e }
742 mudela(fragment,verbatim,center)(
743 \transpose cis' \relative c' { \key e;
744 e fis gis a b cis dis e }
746 If you want to use both code(\transpose) and code(\relative), then you must use
747 code(\transpose) first. Any code(\relative) keywords that are outside the
748 code(\transpose) have no effect on notes that appear inside the
749 code(\transpose). As with code(\relative), using code(\transpose)
750 repeatedly can cause bizarre effects. An explicit code(Staff) context
751 will eliminate the problems.
755 Chords can be entered either by name or by listing the notes in angle brackets.
756 Chords can be displayed either as notes or by name. To enter chords by name,
757 either place them inside the code(\chords) keyword.
758 Chord names have the form
759 var(tonic)[var(duration)][code(-)var(modifier)][code(^)var(subtractions)][code(/)var(inversion)]
760 The var(tonic) should be the tonic note of the chord, and the var(duration) is
761 the chord duration in the usual notation. There are two kinds of modifiers.
762 One type is chord additions, which are obtained by listing intervals separated
763 by dots. An interval is written by its number with an optional code(+) or
764 code(-) to indicate raising or lowering by half a step. A chord additions has
765 two effects: it adds the specified interval and all lower odd numbered
766 intervals to the chord, and it may lower or raise the specified interval.
767 Intervals must be separated by a dot (code(.)).
768 Repeating a code(-) character will remove a half step from the preceeding
770 mudela(fragment,verbatim,center)(
774 c-9-.5+.7+ c-3-.5- c-4.6.8
776 The second type of modifier that may appear after the code(-) is
778 Named modifiers are listed in the file file(chord-modifiers.ly). The
779 available modifiers are code(m) and code(min) which lower
780 the 3rd half a step, code(aug) which raises the 5th, code(dim) which lowers
781 the 5th, code(maj) which adds a raised 7th, and code(sus) which replaces the
783 mudela(fragment,verbatim,center)(
786 c1-m c-min c-maj c-aug c-dim c-sus
789 Chord subtractions are used to eliminate notes from a chord. The notes to be
790 subtracted are listed after a code(^) character, separated by dots.
791 mudela(fragment,verbatim,center)(
797 Chord inversions can be specified by appending code(/) and the name of a
798 single note to a chord. This has the effect of lowering the specified note by
799 an octave so it becomes the lowest note in the chord. If the
800 specified note is not in the chord then a warning will be printed.
801 mudela(fragment,verbatim,center)(
803 \chords { c1 c/e c/g c-7/e }
805 Throughout these examples, chords have been shifted around the staff
806 using code(\transpose). The code(\relative) keyword has odd effects
807 when combined with named chords.
809 For displaying printed chord names, use the code(ChordNames) context.
810 The chords may be entered either using the notation described above,
811 or directly using angle brackets.
812 mudela(fragment,verbatim)(
814 \context ChordNames { \chords{ a b c} \notes{ < d f g > < e g b > } }
815 \context Staff \notes{ a b c' d' e' }
818 Lilypond examines chords specified as lists of notes to determine a
819 name to give the chord. By default, LilyPond will not try to identify
821 mudela(fragment,verbatim,center)(
823 \context ChordNames {
824 \notes{ < e' g' c'' > } }
825 \context Staff \notes{ c' }
827 If you want inversions to be recognized, you must set the property
828 code(Score.chordInversion):
829 mudela(fragment,verbatim,center)(
831 \property Score.chordInversion = 1
832 \context ChordNames {
833 \notes{ < e' g' c'' > } }
834 \context Staff \notes{ c' }
841 Lyrics are entered like notes, with pitches replaced
842 by text. For example code(Twin-4 kle4 twin-4 kle4) enters four
843 syllables, each with quarter note duration. Note that the hyphen has
844 no special meaning for lyrics, and does not introduce special symbols.
845 See Section ref(modes) for a description of what is interpreted as a lyric.
847 In order to instruct LilyPond to write lyrics underneath the
848 staff, you must enter the lyrics context with code(\context Lyrics).
849 Lyrics should be entered in lyrics mode which is entered with code(\lyrics).
851 Spaces can be introduced into a lyric either by using quotes (code("))
852 or by using an underscore without quotes: code(He_could4 not4). All
853 unquoted underscores are converted to spaces. Here is a full example:
854 mudela(verbatim)(\score{
855 < \notes \transpose c'' {c d e c | c d e c | e f g'2 |
856 e'4 f g'2 \bar "|."; }
857 \context Lyrics \lyrics {
858 DOEXPAND(Fr\)`e-4 re Ja- que DOEXPAND(Fr\)`e- re Ja- que
859 Dor- mez vous?2 Dor-4 mez vous?2 }
867 Why does this warrant an URG?
870 When one word is attached to many notes, you may
871 want a continuous line after the lyric to show this. To achieve
872 this effect, add a code(__) lyric as a separate word
873 after the lyric to be extended.
875 an extender, a line that extends over the entire duration of
876 the lyric. This line will run all the way to the start of the next
877 lyric, so you may want to shorten it by using a blank lyric.
878 mudela(verbatim)(\score{
879 < \notes \relative c''{
880 a4()b()c()d c()d()b()a c()d()b()a }
881 \context Lyrics \lyrics {
882 foo1 __ bar2. __ _4 baz1 __ }
885 If you want to have hyphens centred between syllables (rather than attached
886 to the end of the first syllable) you can use the special code(--) lyric as
887 separate word between syllables. This will result in a hyphen whose length
888 varies depending on the space between syllables, and centred between the
889 syllables. For example:
890 mudela(verbatim)(\score{
891 < \notes \transpose c'' {c d e c | c d e c | e f g'2 |
892 e'4 f g'2 \bar "|."; }
893 \context Lyrics \lyrics {
894 DOEXPAND(Fr\)`e4 -- re Ja -- que DOEXPAND(Fr\)`e -- re Ja -- que
895 Dor -- mez vous?2 Dor4 -- mez vous?2 }
904 LilyPond aligns all musical objects according to the amount of time
905 they occupy. All musical objects have a duration. When music is
906 written sequentially using braces the duration is the sum of the
907 durations of the elements. When music is stacked into simultaneous music
909 brackets, the duration is the maximum of the durations of the
912 Because LilyPond knows the durations of all musical elements, the time
913 signature enables LilyPond to draw bar lines automatically. The time
914 signature is specified with the code(\time) keyword: code(\time 3/4).
915 If no time signature is given, LilyPond assumes 4/4. The automatic
916 generation of bar lines can toggled with the code(\cadenza) keyword or the
917 code(Staff.barNonAuto) property,
918 and an incomplete measure at the start of the music can be created
919 using the code(\partial) keyword: code(\partial 8*2;) creates a
920 starting measure lasting two eighth notes.
922 In order to help with error checking, you can insert bar markers in
923 your music by typing code(|). Whenever LilyPond encounters a code(|)
924 that doesn't fall at a measure boundary, she prints a warning message.
928 sect(Composition: forming bigger structures)
931 The computer savy user may be interested in a more formal
932 specification. We can capture what have learned about forming
933 sentences in Mudela in a context-free grammar.
935 latexcommand(\smallskip)
938 row(cell(em(Music))cell(: em(Note)))
939 row(cell()cell(code(|) em(Rest)))
940 row(cell()cell(code(|) code({) em(MusicList) code(})))
941 row(cell()cell(code(|) code(<) em(MusicList) code(>)))
942 row(cell()cell(code(|) em(Command)))
943 row(cell()cell(code(|) code(\context) em(string) code(=) em(string) em(Music)))
945 row(cell(em(MusicList))cell(: em(empty)))
946 row(cell()cell(code(|) em(MusicList) em(Music)))
950 latexcommand(\smallskip)
952 In mathematics you can form expressions by combining expressions,
953 which are ultimately some kind of atom or terminal symbol. The same
954 goes for Mudela: there are some basic building blocks, and by
955 combining those you create complex music.
957 You can combine music in three ways:
959 it()If you enclose a sequence of music-elements in braces ( code({)
960 and code(}) ), then you form another kind of music called
963 The duration of sequential composition is the sum of the durations of its elements
965 { c c g g a a g2 } % twinkle twinkle
966 { { c c g g} { a a g2 } }
968 it()You can stack music by enclosing a sequence of music elements
969 with code(<) and code(>). This is called simultaneous music.
970 The duration of a simultaneous composition is the maximum of the durations
971 of its elements Example:
973 <a4 {cis8 cis8} e'4> % a-major chord
975 it()You can form music by transposing music:
978 d % from c to the d that's almost one octave down
979 { e4 f4 } % the horizontal music
983 it()verb(\translator)
987 Of course you can also combine these three mechanisms.
989 { c <c e> <c e g> <c e g \transpose d' dis > } % 4 increasing chords
997 In order to specify repeats, use the code(\repeat) keyword. By
998 default, repeats are printed with repeat symbols.
999 mudela(fragment,verbatim,center)(
1001 \repeat semi 2 { c'4 d' e' f' }
1002 \repeat semi 2 { f' e' d' c' })
1003 In order to specify alternate endings, use the code(\alternative)
1005 mudela(fragment,verbatim,center)(
1007 \repeat semi 2 {c'4 d' e' f'}
1008 \alternative { {d'2 d'} {f' f} })
1009 The code(semi) specifies that normal repeats will be printed. If
1010 code(fold) is used instead then the alternatives will be stacked:
1011 mudela(fragment,verbatim,center)(
1013 \repeat fold 2 {c'4 d' e' f'}
1014 \alternative { {d'2 d'} {f' f} })
1015 When the repeats involve partial measures, it will be necessary to use
1016 code(\partial) keywords in a somewhat unexpected way
1017 to indicate some measure lengths.
1018 mudela(fragment,verbatim)(
1019 \context Staff { \relative c'{
1020 \repeat semi 2 { \partial 4; e | c2 d2 | e2 f2 | }
1021 \alternative { { g4 g g } {\partial 1; a a a a | b1 } }
1023 Repeats can be unfolded by setting the property Staff.unfoldRepeats.
1024 Note also that if your music begins with code(\repeat), you must place
1025 it in an explicit code(Staff) context or you will get bizarre results.
1027 If you don't give enough alternatives for all of the repeats, then the
1028 first alternative is assumed to be repeated enough to equal to
1029 specified number of repeats.
1030 mudela(fragment,verbatim)(
1031 \context Staff { \relative c'{
1032 \repeat semi 3 { \partial 4; e | c2 d2 | e2 f2 | }
1033 \alternative { { g4 g g } {\partial 1; e4 e e }
1034 {\partial 1; a a a a | b1 } }
1040 Keywords sometimes appear alone, but usually they require arguments.
1041 A keyword may have a single argument, a sequence of arguments in
1042 braces, or a sequence of arguments separated by spaces and terminated
1043 by a semicolon. The precise syntax of each keyword is shown below.
1044 Keywords must appear in the right context. If you use a keyword in
1045 the wrong place, even if the usage is syntactically correct, you will
1046 get the message ``parse error'' from LilyPond.
1051 dit(code(\absdynamic) code({) var(code) code(})) Internal keyword for
1052 printing dynamic marks such as $f$ under music. The parameter
1053 var(code) is unsigned and specifies the dynamic mark to print.
1054 Normally you should use the more user friendly abbreviations defined
1055 in the init file file(dynamic.ly).
1057 FIXME: Changed to code(\textscript) var(text) var(style). Defines
1060 dit(code(\accepts) var(string)code(;)) This keyword can appear only within a
1061 code(\translator) block. It specifies what contexts are allowed with the
1062 context that is being defined. See Section ref(translators).
1064 dit(code(\alternative) code({) var(music1) var(music2) ... code(}))
1065 Specifies alternative endings. Must come after a code(\repeat) keyword.
1067 dit(code(\bar) var(bartype)code(;)) Prints a special bar symbol, or at
1068 measure boundaries, replaces the regular bar symbol with a special
1069 symbol. The argument var(bartype) is a string which specifies the
1070 kind of bar to print. Options are code(":|"), code("|:"),
1071 code(":|:"), code("||"), code("|."), code(".|"), or code(".|.").
1072 These produce respectively a right repeat, a left repeat, a double
1073 repeat, a double bar, a start bar, an end bar, or a thick double bar.
1074 If var(bartype) is set to code("empty") then nothing is printed, but a
1075 line break is allowed at that spot. Note that the printing of special bars
1076 has no effect on the MIDI output.
1078 dit(code(\cadenza) var(togglevalue)code(;)) Toggles the automatic generation
1079 of bar lines. If var(togglevalue) is 0 then bar line generation is
1080 turned off. If var(togglevalue) is 1 then a bar is immediately
1081 printed and bar generation is turned on.
1083 dit(code(\clef) var(clefname)code(;)) Allowed only in music.
1084 Sets the current clef. The argument is
1085 a string which specifies the name of the clef. Several clef names are
1086 supported. If code(_8) or code(^8) is added to the end of a clef
1087 name then the clef lowered or raised an octave will be generated.
1088 Here are the supported clef names with middle C shown in each clef:
1092 %\property Voice.textStyle = typewriter
1093 \clef subbass; c'4-"\kern-10mm subbass"
1094 \clef bass; c'4^"\kern -8mm bass"
1095 \clef baritone; c'4_"\kern -10mm baritone"
1096 \clef varbaritone; c'4^"\kern -10mm varbaritone"
1097 \clef tenor; c'4_"\kern -10mm tenor"
1098 \clef "G_8"; c'4^"\kern -6mm G\_8"
1100 \paper{ linewidth= 4.5 \in; }
1105 \notes{\cadenza 1; \clef alto; c'4_"\kern -10mm alto"
1106 % \clef scarlatti; c'4_"\kern -4mm scarlatti"
1107 \clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
1108 \clef soprano; c'4_"\kern -10mm soprano"
1109 \clef treble; c'4^"\kern -6mm treble"
1110 \clef french; c'4_"\kern -10mm french" }
1111 \paper{ linewidth= 4.5 \in; }
1114 The treble clef can also be obtained using the names code(G) or
1115 code(violin). The bass clef is also available by code(\clef F).
1117 dit(code(\chord) var(chordlist)) Parse var(chordlist) in chords mode.
1119 dit(code(\chordmodifiers) var(modifierlist)) Specify the text chord
1120 modifiers that may appear after chord names. These are specified in
1121 the file file(chord-modifiers.ly).
1123 dit(code(\cm)) Specify a dimension in centimeters.
1125 dit(code(\consists) var(string)code(;)) This keyword can appear only within a
1126 code(\translator) block. It specifies that an engraver or performer named
1127 var(string) should be added to the translator. See Section
1130 dit(code(\consistsend) var(string)code(;)) Unknown function.
1132 dit(code(\context) var(contexttype) [code(=) var(contextname)]
1133 var(music) or code(\context) var(translatortype)code(;)) The first
1134 variant is used only within music to create an instance of a
1135 context. The new context can optionally be given a name. The
1136 specified var(music) is processed in the new context. The second
1137 variant appears within a code(\translator) block and specifies the
1138 type of translator being created.
1140 dit(code(\duration) code({) var(length) var(dotcount) code(})) Specify note
1141 duration. The parameter var(length) is the negative logarithm (base
1142 2) of duration: 1 is a half note, 2 is a quarter note, 3 is an eighth
1143 note, etc. The number of dots after the note is given by
1146 dit(code(\font) var(string)) Internal keyword. Used within
1147 code(\paper) to specify the font.
1150 dit(code(\header) code({) var(key1) = var(val1); var(key2) = var(val2); ... code(}))
1151 Specifies information about the music. A header should appear at the
1152 top of the file describing the file's contents. If a file has
1153 multiple code(\score) blocks, then a header should appear in
1154 each score block describing its contents. Tools like code(ly2dvi) can
1155 use this information for generating titles. Key values that are used
1156 by ly2dvi are: title, subtitle, composer, opus, poet, instrument,
1157 metre, arranger, piece and tagline.
1159 dit(code(\in)) Specify a dimension in inches.
1161 dit(code(\include) var(file)) Include the specified file. The
1162 argument var(file) is a string. The full filename including the
1163 file(.ly) extension must be given, and the filename must be quoted.
1164 (An unquoted string will not work here.)
1166 dit(code(\key) var(pitch) var(type) code(;)) Change the key signature.
1167 var(type) should be code(\major) or code(\minor) to get
1168 var(pitch)-major or var(pitch)-minor, respectively. The second
1169 argument is optional, the default is major keys.
1170 The var(\context) argument can also be given as an integer, which tells
1171 the number of semitones that should be added to the pitch given in the
1172 subsequent code(\key) commands to get the corresponding major key,
1173 e.g. code(\minor) is defined as 3. The standard mode names
1174 code(\ionian), code(\locrian), code(\aeolian), code(\mixolydian),
1175 code(\lydian), code(\phrygian), and code(\dorian) are also defined.
1177 dit(code(\keysignature) var(pitchseq)code(;))
1178 Specify an arbitrary key signature. The pitches from var(pitch) will
1179 be printed in the key signature in the order that they appear on the list.
1181 dit(code(\lyrics) var(lyriclist)) Parse var(lyriclist) in lyrics mode.
1183 dit(code(\maininput)) Internal command. This command is used for creating init
1184 files like file(init.fly) that read the user file into the middle of another
1185 file. It is illegal to use this command in a user file.
1187 dit(code(\mark) var(unsigned)code(;) or code(\mark) var(string)code(;))
1188 Allowed in music only. Prints a mark over or under (depending on the
1189 code(markDirection) property) the staff.
1190 You must add code(Mark_engraver) to the Score context.
1192 dit(code(\midi) var(statementlist)) Appears in a score block to
1193 indicate that musical output should be produced and to set output
1194 parameters. Can also appear at the top level to set default output
1195 parameters. See code(\tempo).
1197 dit(code(\mm)) Specify a dimension in millimeters.
1199 dit(code(\musicalpitch) code({) var(octave) var(note) var(shift) code(}))
1200 Specify note pitch. The octave is specified by an integer,
1201 zero for the octave containing middle C. The note is a number from 0
1202 to 7, with 0 corresponding to C and 7 corresponding to B. The shift
1203 is zero for a natural, negative to add flats, or positive to add
1206 dit(code(\name) var(context)code(;)) Appears within code(\translator) to
1207 specify the name of the context that the translator handles. See Section
1210 dit(code(\notenames) var(assignmentlist)) Define new note names. This
1211 keyword can appear only at the top level.
1212 The argument is a list of definitions of the form
1213 var(name) = var(pitch), where var(pitch) is specified with the
1214 code(\musicalpitch) keyword.
1216 dit(code(\notes) var(music)) Enter note mode and process the
1219 dit(code(\paper) var(statmentlist))
1220 Appears in a score block to indicate that the music should be printed
1221 or to set output parameters. Can also appear at the top level to set
1222 default output parameters for all of the score blocks.
1223 The var(statmentlist) contains statements that change features of the
1224 output. See Section ref(paper).
1226 dit(code(\partial) var(duration)code(;)) Specify that the first measure of
1227 the music lasts only for the specified duration. Use also to specify
1228 the duration of the first measure of the argument to
1231 dit(code(\penalty) var(int)code(;)) Allowed only in music.
1232 Discourage or encourage line breaks. See identifiers code(\break) and
1233 code(\nobreak) in Section ref(ident).
1235 dit(code(\property) var(contextname)code(.)var(propname) code(=) var(value))
1236 Sets the var(propname) property of the context var(contextname) to the
1237 specified var(value). All three arguments are strings. Depending on
1238 the context it may be necessary to quote the strings or to leave space
1239 on both sides of the dot.
1241 dit(code(\pt)) Specify a dimension in points.
1243 dit(code(\relative) var(pitch) var(music)) Processes the specified
1244 var(music) in relative pitch
1245 mode. In this mode, the octave of a pitch is chosen so that the
1246 pitch is closest to the preceeding pitch.
1247 The argument var(pitch) is
1248 the starting pitch for this comparision. In the case of chords, the
1249 first note of a chord is used as the base for the first pitches in the next
1250 chord. See Section ref(relative).
1252 dit(code(\remove) var(string)code(;)) Can appear only in a
1253 code(\translator) block. Specifies that a performer or engraver named
1254 var(string) should be removed. See Section ref(translators).
1256 dit(code(\repeat) var(style) var(count) code({) var(music) code(}))
1257 Repeats the specified
1258 music var(count) times. Alternative endings can be specified by adding a
1259 code(\alternative) keyword after the code(\repeat). The var(style)
1260 parameter should be either code(semi), for regular repeats, or
1261 code(fold) for repeats displayed vertically.
1263 dit(code(\scm) var(scheme)code(;)) Embeds specified Scheme code.
1265 dit(code(\scmfile) var(filename)code(;)) Reads Scheme code from the specified
1268 dit(code(\score) var(statementlist)) Create a Score context. This
1269 is the top level notation context.
1270 COMMENT(this still needs work)
1272 dit(code(\script) var(alias)) Prints a symbol above or below a note.
1273 The argument is a string which points into the script-alias table
1274 defined in file(script.scm). The scheme definitions specify whether
1275 the symbol follows notes into the staff, dependence of symbol
1276 placement on staff direction, and a priority for placing several
1277 symbols over one note. Usually the code(\script) keyword is not used
1278 directly. Various helpful identifier definitions appear in
1281 dit(code(\shape) code(=) var(indent1) var(width1) var(indent2)
1282 var(width2) ... code(;)) Allowed only within code(\paper). Each pair
1283 of var(indent) and var(width) values is a dimension specifying how far
1284 to indent and how wide to make the line. The indentation and width of
1285 successive lines are specified by the successive pairs of dimensions.
1286 The last pair of dimensions will define the characeristics of all
1287 lines beyond those explicitly specified.
1289 COMMENT(First pair of dimensions seems to be skipped. At least it is
1290 in the example file denneboom.ly.)
1292 dit(code(\skip) var(duration)code(;)) Skips the amount of time specified by
1293 var(duration). A gap will be left for the skipped time with no notes
1294 printed. It works in Note Mode or Lyrics Mode (but generates a
1295 mysterious error in lyrics).
1297 dit(code(\spanrequest) var(startstop) var(type)). Define a spanning request
1298 var(startstop) is either -1 (code(\start)) or 1 (code(\stop)). The var(type)
1299 parameter is a string that describes what should be started. Supported types
1300 are "crescendo", "decrescendo", "beam", "slur". This is an internal command.
1301 Users should use the abbreviations which are defined in the
1302 initialization file file(dynamic.ly).
1304 dit(code(\tempo) var(duration) = var(perminute)code(;)) Used within
1305 code(\midi) or within music to specify the tempo. For example,
1306 `code(\midi { \tempo 4 = 76;})' requests output with 76 quarter notes
1307 per minute. Note that if the music contains several tempo commands,
1308 only the last one is used to set the tempo for the entire MIDI output.
1309 COMMENT(Is this true?)
1311 dit(code(\textscript) var(text) var(style)) Print the specified text as a
1312 script in the specified style.
1314 dit(code(\time) var(numerator)code(/)var(denominator)code(;)) Change the time
1315 signature. The default time signature is 4/4.
1317 dit(code(\times) var(numerator)code(/)var(denominator) var(music))
1318 Multiply the duration of var(music) by the specified fraction.
1320 dit(code(\translator) var(statements) or code(\translator)
1321 var(context) = var(name)) The first variant appears only within
1322 code(\paper) and specifies a translator for
1323 converting music to notation. The translator is specified with a
1324 single code(\context) statement and a series of code(\accepts), and
1325 code(\consists) statements. See Section ref(translators).
1326 The second variant appears in
1327 music. It specifies that the current the contexts
1328 contained within the specified context should be shifted to the
1329 context with the specified name.
1331 COMMENT( \translator seems like a strange name for the second
1332 operation, and is the overloading desireable? )
1334 dit(code(\transpose) var(pitch) var(music)) Transposes the specified
1335 music. Middle C is tranposed to var(pitch). This is allowed in music only,
1336 and if it appears inside code(\relative), then any notes specified for
1337 transposition should be specified inside another code(\relative). See Section
1340 dit(code(\type) var(string)code(;)) Use inside code(\translator) to
1341 specify the type of the translator.
1343 dit(code(\version) var(string)) Specify the version of Mudela that a
1344 file was written for. The argument is the version number, for example
1345 code("1.0.1"). Note that the Mudela version is different from the
1351 sect(Notation Contexts)
1353 Notation contexts provide information that appears in printed music
1354 but not in the music itself. A new musical context is created using
1355 the code(\context) keyword: `code(\context) var(contexttype) [code(=)
1356 var(contextname)] var(music)'. The following context types are
1361 dit(code(LyricVoice)) Corresponds to a voice with lyrics. Handles the printing
1362 of a single line of lyrics.
1364 dit(code(Voice)) Corresponds to a voice on a staff.
1365 This context handles the conversion of noteheads,
1366 dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests.
1368 dit(code(ChordNamesVoice)) A voice with chord names. Handles printing
1369 of a line of chord names.
1371 dit(code(ChordNames)) Typesets chord names. Can contain
1372 code(ChordNamesVoice) contexts.
1374 dit(code(Lyrics)) Typesets lyrics. It can contain code(LyricVoice) contexts.
1376 dit(code(Staff)) Handles clefs, bar lines, keys,
1377 accidentals. It can contain code(Voice) contexts.
1379 dit(code(RhythmicStaff)) A context like code(Staff) but for printing
1380 rhythms. Pitches are ignored; the notes are printed on one line.
1381 It can contain code(Voice) contexts.
1383 dit(code(GrandStaff)) Contains code(Staff) or code(RhythmicStaff)
1384 contexts. It adds a brace on the left side grouping the staffs
1385 together. The bar lines of the contained staffs are connected vertically.
1386 It can contain code(Staff) contexts.
1388 dit(code(PianoStaff)) Just like code(GrandStaff) but with
1389 code(minVerticalAlign) set equal to code(maxVerticalAlign) so that
1390 interstaff beaming and slurring can be used.
1392 dit(code(StaffGroup)) Contains code(Staff) or code(RhythmicStaff)
1393 contexsts. Adds a bracket on the left side, grouping the staffs
1394 together. The bar lines of the contained staffs are connected vertically.
1395 It can contain code(Staff), code(RhythmicStaff), code(GrandStaff) or code(Lyrics) contexts.
1397 dit(code(ChoirStaff)) Identical to code(StaffGroup) except that the
1398 contained staffs are not connected vertically.
1400 dit(code(Score)) This is the top level notation context. It is specified with
1401 the code(\score) keyword rather than the code(\context) command. No
1402 other context can contain a code(Score) context. This context handles
1403 the administration of time signatures. It also makes sure that items
1404 such as clefs, time signatures, and key-signatures are aligned across
1405 staffs. It can contain code(Lyrics), code(Staff),
1406 code(RhythmicStaff), code(GrandStaff), code(StaffGroup), and
1407 code(ChoirStaff) contexts.
1411 The various contexts have properties associated with them. These
1412 properties can be changed using the code(\property) command:
1413 `code(\property) var(context)code(.)var(propname) code(=) var(value)'.
1414 Properties can also be set within the code(\translator) block
1415 corresponding to the appropriate context. In this case, they are
1416 assigned by `var(propname) code(=) var(value)'. The settings made with
1417 code(\property) are processed after settings made in the code(\translator)
1418 block, so the code(\property) settings will override code(\translator)
1421 The code(\property) keyword will create any property you specify.
1422 There is no guarantee that a property will actually be used. If you
1423 spell a property name wrong, there will be no error message. In order to find
1424 out what properties are used, you must search the source code
1425 for code(get_property).
1426 Properties that are set in one context are inherited by all of the
1427 contained contexts. This means that a property valid for the Voice
1428 context can be set in the Score context (for example) and thus take
1429 effect in all Voice contexts.
1431 subsubsubsect(Lyrics properties)
1435 dit(code(textStyle)) Set the font for lyrics. The available font
1436 choices are code(roman), code(italic), code(bold), code(large),
1437 code(Large), code(typewriter), and code(finger). The code(finger)
1438 font can only display numbers. Note also that you must be careful
1439 when using code(\property) in Lyrics mode. Because of the way strings
1440 are parsed, either put quotes around the arguments to code(\property)
1441 or be sure to leave a space on both sides of the dot.
1446 subsubsubsect(Voice properties)
1450 dit(code(stemLeftBeamCount)) Specify the number of beams to draw on
1451 the left side of the next note.
1453 dit(code(stemRightBeamCount)) Specify the number of beams to draw on
1454 the right side of the next note.
1456 dit(code(beamAuto)) If set to 1 then beams are generated
1457 automatically. If set to zero then no beams will be automatically
1458 generated. The default value is 1.
1460 dit(code(beamAutoEnd)) Specifies when automatically generated beams
1461 can end. See Section ref(autobeam).
1463 dit(code(beamAutoBegin)) Specifies when automatically generated beams
1464 can start. See Section ref(autobeam).
1466 dit(code(textEmptyDimension)) If set to 1 then text placed above or
1467 below the staff is assumed to have zero width.
1469 dit(code(noteheadStyle)) Selects type of note head. Choices are
1470 code(cross), code(diamond), code(harmonic), code(transparent), and
1471 code(""). They are shown in that order below.
1475 \property Staff.barNonAuto = 1
1476 \property Voice.noteHeadStyle = cross
1478 \property Voice.noteHeadStyle = diamond
1480 \property Voice.noteHeadStyle = harmonic
1482 \property Voice.noteHeadStyle = transparent
1484 \property Voice.noteHeadStyle = ""
1487 \paper{ linewidth = -1.;}
1492 dit(code(restStyle)) Change the layout of rests shorter than quarter notes.
1493 Currently, the standard layout code(restStyle="") and mensural notation
1494 code(restStyle="mensural") are available.
1496 dit(code("midiInstrument")) Sets the instrument for MIDI output. This
1497 property name must be quoted because of the embedded underscore. If
1498 this property is not set then LilyPond will use the code(instrument)
1499 property. This must be set to one of the strings on the list of MIDI
1500 instruments that appears in Section ref(midilist). If you use a
1501 string which is not listed, LilyPond will silently substitute piano.
1503 dit(code(transposing)) Tranpose the MIDI output. Set this property to
1504 the number of half-steps to transpose by.
1506 dit(code(oldTieBehavior)) Set to 1 in order to get old tie behavior
1507 where ties would connect unequal pitches.
1509 dit(code(verticalDirection)) Determines the direction of stems, subscripts,
1510 beams, slurs, and ties. Set to code(\down) to force them down,
1511 code(\up) to force them up, or code(\free) to let LilyPond decide.
1512 This can be used to distinguish between voices on the same staff. The
1513 code(\stemdown), code(\stemup), and code(\stemboth) identifiers set
1514 this property. See also the identifiers code(\voiceone),
1515 code(\voicetwo), code(\voicethree) and code(\voicefour).
1517 dit(code(slurVerticalDirection)) Set to code(\free) for free choice of slur
1518 direction, set to code(\up) to force slurs up, set to code(\down) to
1519 force slurs down. The shorthands code(\slurup), code(\slurdown), and
1520 code(\slurboth) are available.
1522 dit(code(tieVerticalDirection)) Set to code(\free) for free choice of tie
1523 direction, set to code(\up) to force ties up, set to code(\down) to
1526 dit(code(slurdash)) Set to 0 for normal slurs, 1 for dotted slurs, and
1527 a larger value for dashed slurs. Identifiers code(\slurnormal) and
1528 code(\slurdotted) are predefined to set the first two settings.
1530 dit(code(horizontalNoteShift)) Set to 1 to enable LilyPond to shift notes
1531 horizontally if they collide with other notes. This is useful when
1532 typesetting many voices on one staff. The identifier code(\shift) is
1533 defined to enable this. If there are several voices, every voice must
1534 have a distinct value of this property or no shifting will occur.
1536 dit(code(dynamicDir)) Determines location of dynamic marks. Set to
1537 code(\up) to print marks above the staff; set to code(\down) to print
1538 marks below the staff.
1540 dit(code(dynamicStyle)) Set the text style for dynamics.
1542 dit(code(textStyle)) Set the text style for superscripts and
1543 subscripts. See above for list of text styles.
1545 dit(code(textScriptPadding)) Determines the extra space added between
1546 super-/subscripted text and the closest staff line or note.
1548 dit(code(fontSize)) Can be used to select smaller font sizes for
1549 music. The normal font size is 0, and the two smaller sizes are -1
1552 dit(code(abbrev)) Set length for tremolo to be used if no length is
1553 explicitly specified.
1555 dit(code(tupletDirection)) Determines the direction of triplets and
1556 other tuplets. Set to code(\down) to force them below the staff,
1557 code(\up) to force them above, or code(\free) to let LilyPond decide.
1559 dit(code(tupletVisibility)) Determines whether tuplets of notes are
1560 labelled. Setting to 0 shows nothing; setting to 1 shows a number;
1561 setting to 2 shows a number and a bracket if there is no beam; setting
1562 to 3 shows a number, and if there is no beam it adds a bracket;
1563 setting to 4 shows both a number and a bracket unconditionally. The
1564 code(pletoff) and code(pleton) identifiers set the property to 0 and 3,
1567 dit(code(markScriptPadding)) Determines the extra space added between
1568 the mark and the closest staff line or note.
1570 dit(code(markDirection)) Determines if marks should be printed above
1571 or below the staff. Set to code(\up) to print marks above the staff;
1572 set to code(\down) to print marks below the staff.
1574 dit(code(articulationScriptPadding)) Determines the extra space added
1575 between articulation marks, such as staccato, tenuto, trill, up/down
1576 bow or fermata, and the closest staff line or note.
1579 subsubsubsect(Staff properties)
1583 dit(code(createInitdefaultClef)) Specify whether clefs are created on
1584 default? (Doesn't seem to do anything.)
1586 dit(code(barNumberDirection)) Set to code(\up) or code(\down) to put
1587 bar numbers above or below the staff.
1589 dit(code(barNumberHangOnClef)) Set to 1 to cause bar numbers to appear
1590 above or below the clef instead of on the bar line.
1592 dit(code(barNumberScriptPadding)) Sets extra space between the bar
1593 number and the bar it labels.
1595 dit(code(barSize)) Specify the height of the bar lines if it should be
1596 different than the staff height.
1598 dit(code(markHangOnClef)) Set to 1 to cause marks to appear by clefs
1599 instead of by bar lines.
1601 dit(code(marginDirection)) Set to code(\left) or code(\right) to
1602 specify location of marginal scripts.
1604 dit(code(marginScriptPadding)) Specify extra space for marginal scripts.
1606 dit(code(forgetAccidentals)) Causes accidentals to be printed at every
1607 note instead of remembered for the duration of a measure.
1609 dit(code(noResetKey)) Do not reset the key at the start of a measure.
1610 Accidentals will be printed only once and are in effect until
1611 overridden, possibly many measures later.
1613 dit(code(staffLineLeading)) Specifies the distance (in points) between lines
1616 dit(code(numberOfStaffLines)) Specifies the number of staff lines. The
1619 dit(code(postBreakPadding)) Extra space in points to be added after
1620 the clef, time signature and key signature on the staff.
1622 dit(code(barAtLineStart)) Set to 1 to produce a bar line after the
1623 clef at the start of each line (but not at the beginning of the
1626 dit(code(voltaVisibility)) Set to 0 to suppress the printing
1627 of brackets over alternate endings specified by code(\alternative).
1629 dit(code(voltaSpannerDuration)) Set to an integer to control the size
1630 of the brackets printed by code(\alternative). The integer specifies
1631 the number of whole notes duration to use for the brackets. It seems
1632 to be rounded to the nearest measure. This can be used to shrink the
1633 length of brackets in the situation where one alternative is very
1634 large. It may have odd effects if the specified duration is longer
1635 than the music given in an code(\alternative).
1637 dit(code(barNonAuto)) If set to 1 then bar lines will not be printed
1638 automatically; they must be explicitly created with code(\bar) keywords.
1639 Unlike with the code(\cadenza) keyword, measures are still counted. Bar
1640 generation will resume according to that count if this property is set to
1643 dit(code(defaultClef)) Determines the default clef. See code(\clef)
1646 dit(code(nuberOfStaffLines)) Sets the number of lines that the staff has.
1648 dit(code(barAlways)) If set to 1 a bar line is drawn after each note.
1650 dit(code(defaultBarType)) Sets the default type of bar line. See
1653 dit(code(keyoctaviation)) If set to 1, then keys are the same in all
1654 octaves. If set to 0 then the key signature for different octaves can
1655 be different and is specified independently: code(\keysignature bes
1656 fis'). The default value is 1. Can be set to zero with
1657 code(\specialkey) or reset to 1 with code(\normalkey).
1659 dit(code(instrument) and code(instr)) If code(Staff_margin_engraver)
1660 is added to the Staff translator, then the code(instrument) property
1661 is used to label the first line of the staff and the code(instr)
1662 property is used to label subsequent lines. If the
1663 code(midiInstrument) property is not set then code(instrument) is
1664 used to determine the instrument for MIDI output.
1665 COMMENT(This prints the instrument name on top of the staff lines.)
1667 dit(code(createKeyOnClefChange)) Set to a nonempty string if you want key
1668 signatures to be printed when the clef changes. Set to the empty string (the
1669 default) if you do not want key signatures printed.
1672 dit(code(timeSignatureStyle)) Changes the default two-digit layout
1673 for time signatures. The following values are recognized:
1675 dit(code(C)) 4/4 and 2/2 are typeset as C and struck C,
1676 respectively. All other time signatures are written with two digits.
1677 dit(code(old)) 2/2, 3/2, 2/4, 3/4, 4/4, 6/4, 9/4, 4/8, 6/8 and
1678 9/8 are typeset with old-style mensuration marks. All other time
1679 signatures are written with two digits.
1680 dit(code(1)) All time signatures are typeset with a single
1681 digit, e.g. 3/2 is written as 3.
1682 dit(code(C2/2), code(C4/4), code(old2/2), code(old3/2),
1683 code(old2/4), code(old3/4), code(old4/4), code(old6/4),
1684 code(old9/4), code(old4/8), code(old6/8), code(old6/8alt)
1685 or code(old9/8))Tells Lilypond to use a specific symbol as
1688 The different time signature characters are shown below with
1692 \notes\relative c'' {
1693 \property Voice.textStyle = typewriter
1694 \property Staff.timeSignatureStyle = "C2/2"
1695 \time 2/2; a2^"C2/2" a2
1696 \property Staff.timeSignatureStyle = "C4/4"
1697 \time 2/2; a2^"C4/4" a2
1698 \property Staff.timeSignatureStyle = "old2/2"
1699 \time 2/2; a2^"old2/2" a2
1700 \property Staff.timeSignatureStyle = "old3/2"
1701 \time 2/2; a2^"old3/2" a2
1702 \property Staff.timeSignatureStyle = "old2/4"
1703 \time 2/2; a2^"old2/4" a2
1704 \property Staff.timeSignatureStyle = "old4/4"
1705 \time 2/2; a2^"old4/4" a2
1706 \property Staff.timeSignatureStyle = "old6/4"
1707 \time 2/2; a2^"old6/4" a2
1708 \property Staff.timeSignatureStyle = "old9/4"
1709 \time 2/2; a2^"old9/4" a2
1710 \property Staff.timeSignatureStyle = "old4/8"
1711 \time 2/2; a2^"old4/8" a2
1712 \property Staff.timeSignatureStyle = "old6/8"
1713 \time 2/2; a2^"old6/8" a2
1714 \property Staff.timeSignatureStyle = "old6/8alt"
1715 \time 2/2; a2^"old6/8alt" a2
1716 \property Staff.timeSignatureStyle = "old9/8"
1717 \time 2/2; a2^"old9/8" a2
1719 \paper{ linewidth= 4.5 \in; }
1723 dit(code(clefStyle)) Determines how clefs are typeset. When set to
1724 code(transparent), the clefs are not printed at all, when set to
1725 code(fullSizeChanges), clef changes in the middle of a line are
1726 typeset with a full size clef. By default, clef changes are typeset in
1731 subsubsubsect(GrandStaff properties)
1735 dit(code(alignmentReference)) Set to code(\center) for vertical
1736 alignment reference point to be in the center of the vertical group.
1737 Set to code(\up) to put the reference point at the top of the group.
1739 dit(code(maxVerticalAlign)) Set the maximum vertical distance between
1742 dit(code(minVerticalAlign)) Set the minimum vertical distance between
1747 subsubsubsect(Score properties)
1751 dit(code(skipBars)) Set to 1 to skip the empty bars that are produced
1752 by multimeasure notes and rests. These bars will not appear on the
1753 printed output. Set to zero (the default) to expand multimeasure
1754 notes and rests into their full length, printing the appropriate
1755 number of empty bars so that synrchonization with other voices is
1756 preserved. COMMENT(meaning of "skip" here seems to be different from
1757 the meaning used for the keyword \skip.)
1759 dit(code(beamquantisation)) Set to code(\none) for no quantization.
1760 Set to code(\normal) to quantize position and slope. Set to
1761 code(\traditional) to avoid wedges. These three settings are
1762 available via code(\beamposfree), code(\beamposnormal), and
1763 code(\beampostraditional).
1765 dit(code(beamslopedamping)) Set to code(\none) for undamped beams.
1766 Set to code(\normal) for damped beams. Set to code(\infinity) for
1767 beams with zero slope. The identifiers code(\beamslopeproportional),
1768 code(\beamslopedamped), and code(\beamslopezero) each set the
1769 corresponding value.
1771 dit(code(chordInversion)) Determines whether LilyPond should look for
1772 chord inversions when translating from notes to chord names. Set to 1
1773 to find inversions. The default is 0 which does not look for inversions.
1779 sect(Pre-defined Identifiers)
1782 Various identifiers are defined in the initialization files to
1783 provide shorthands for some settings.
1786 dit(code(\aeolian)) Used as the second argument of the code(\key)
1787 keyword to get an aeolian mode.
1788 dit(code(\break)) Force a line break in music by using a large
1789 argument for the keyword code(\penalty).
1790 dit(code(\center)) Used for setting textalignment property. Is set to 0.
1791 dit(code(\cr)) Start a crescendo.
1792 dit(code(\decr)) Start a decrescendo.
1793 dit(code(\dorian)) Used as the second argument of the code(\key)
1794 keyword to get a dorian mode.
1795 dit(code(\down)) Used for setting direction setting properties. Is
1797 dit(code(\f)) Print forte symbol on the preceeding note.
1798 dit(code(\ff)) Print fortissimo symbol on the preceeding note.
1799 dit(code(\fff)) Print fortississimo symbol on preceeding note.
1800 dit(code(\ffff)) Print fortissississimo symbol on preceeding note.
1801 dit(code(\fffff)) Print fffff symbol on preceeding note.
1802 dit(code(\ffffff)) Print ffffff symbol on preceeding note.
1803 dit(code(\fp)) Print fortepiano symbol on preceeding note.
1804 dit(code(\free)) Used for setting direction setting properties. Is
1806 dit(code(\Gourlay)) Used for setting the paper variable
1807 code(castingalgorithm). Is equal to 1.0.
1808 dit(code(\infinity)) Used for setting the Score.beamslopedamping
1809 property. Is actually equal to 10000.
1810 dit(code(\ionian)) Used as the second argument of the code(\key)
1811 keyword to get an ionian mode.
1812 dit(code(\left)) Used for setting textalignment property. Is equal to -1.
1813 dit(code(\locrian)) Used as the second argument of the code(\key)
1814 keyword to get a locrian mode.
1815 dit(code(\lydian)) Used as the second argument of the code(\key)
1816 keyword to get a lydian mode.
1817 dit(code(\major)) Used as the second argument of the code(\key)
1818 keyword to get a major key.
1819 dit(code(\minor)) Used as the second argument of the code(\key)
1820 keyword to get a minor key.
1821 dit(code(\mixolydian)) Used as the second argument of the code(\key)
1822 keyword to get a mixolydian mode.
1823 dit(code(\mf)) Print mezzoforte symbol on preceeding note.
1824 dit(code(\mp)) Print mezzopiano symbol on preceeding note.
1825 dit(code(\nobreak)) Prevent a line break in music by using a large
1826 negative argument for the keyword code(\penalty).
1827 dit(code(\none)) Used for setting Score.beamslopedamping and
1828 Score.beamquantisation properties. Is equal to 0.
1829 dit(code(\normal)) Used for setting Score.beamslopedamping and
1830 Score.beamquantisation properties. Is equal to 1.
1831 dit(code(\normalkey)) Select normal key signatures where each octave
1832 has the same key signature. This sets the Staff.keyoctaviation property.
1833 dit(code(\p)) Print a piano symbol on preceeding note.
1834 dit(code(\phrygian)) Used as the second argument of the code(\key)
1835 keyword to get a phrygian mode.
1836 dit(code(\pp)) Print pianissimo symbol on preceeding note.
1837 dit(code(\ppp)) Print pianississimo symbol on preceeding note.
1838 dit(code(\pppp)) Print pianissississimo symbol on preceeding note.
1839 dit(code(\ppppp)) Print ppppp symbol on preceeding note.
1840 dir(code(\pppppp)) Print pppppp symbol on preceeding note.
1841 dit(code(\rc)) Terminate a crescendo.
1842 dit(code(\rced)) Terminate a decrescendo
1843 dit(code(\rfz)) Print a rinforzato symbol on preceeding note.
1844 dit(code(\right)) Used for setting textalignment property. Is set to 1.
1845 dit(code(\sf)) Print a subito-forte symbol on preceeding note.
1846 dit(code(\sff)) Print a subito-fortissimo symbol on preceeding note.
1847 dit(code(\sfz)) Print a sforzato symbol on preceeding note.
1848 dit(code(\shiftoff)) Disable horizontal shifting of note heads that collide.
1849 Sets the Voice.horizontalNoteShift property.
1850 dit(code(\shifton)) Enable note heads that collide with other note heads
1851 to be shifted horiztonally. Sets the Voice.horizontalNoteShift property.
1852 dit(code(\slurboth)) Allow slurs to be above or below notes. This
1853 sets the Voice.slurVerticalDirection property.
1854 dit(code(\slurdown)) Force slurs to be below notes. This sets the
1855 Voice.slurVerticalDirection property.
1856 dit(code(\slurup)) Force slurs to be above notes. This sets the
1857 Voice.slurVerticalDirection property.
1858 dit(code(\sp)) Print a subito-piano symbol on preceeding note.
1859 dit(code(\spp)) Print a subito-forte symbol on preceeding note.
1860 dit(code(\specialkey)) Allow keys signatures do differ in different
1861 octaves. This sets the Staff.keyoctaviation property.
1862 dit(code(\stemboth)) Allow stems, beams, and slurs to point either
1863 direction. This sets the Voice.verticalDirection property.
1864 dit(code(\stemdown)) Force stems, beams, and slurs to point down.
1865 This sets the Voice.verticalDirection property.
1866 dit(code(\stemup)) Force stems, beams and slurs to point up. This
1867 sets the Voice.verticalDirection property.
1868 dit(code(\traditional)) Used for setting the
1869 Score.beamquantisation property. Is equal to 2.
1870 dit(code(\up)) Used for setting various direction properties. Is
1872 dit(code(\voiceone)) Enter Voice context called code(one) and force stems down.
1873 (See code(\stemdown).)
1874 dit(code(\voicetwo)) Enter Voice context called code(two) and force stems
1875 up. (See code(\stemup).)
1876 dit(code(\voicethree)) Enter Voice context called code(three) and force stems
1878 dit(code(\voicefour)) Enter Voice context called code(four), force stems down
1879 and turn on horizontal shifting. (See code(\stemdown) and code(\shifton).)
1880 dit(code(\Wordwrap)) Used for setting the paper variable
1881 code(castingalgorithm). Equal to 0.0.
1889 The output produced by LilyPond is controlled by the code(\paper) and
1890 code(\midi) keywords. These keywords appear in the code(\score) block
1891 to indicate that printed or musical output should be produced. If
1892 neither keyword appears in a code(\score) block, then paper output is
1893 produced but MIDI output is not produced.
1895 The contents of the code(\paper) and code(\midi) blocks can change the
1896 output in various ways. These blocks can appear at the top level of a
1897 Mudela file to set default parameters for each type of output. It is
1898 still necessary to explicitly specify the output type in the
1899 code(\score) blocks if you don't want the default behavior of
1900 producing only paper output.
1902 The code(\paper) and code(\midi) blocks
1903 may begin with an optional identifier reference. No
1904 identifier references are allowed anywhere else in the block.
1905 The code(\paper) block can contain the code(\shape) keyword; the
1906 code(\midi) block can contain the code(\tempo) keyword. Both of them
1907 can contain code(\translator) keywords. The code(\paper) block can
1908 also contain identifier assignments and parameter assignments. Unlike
1909 at the top level, these assignments must be terminated by a semicolon.
1912 subsect(Paper variables)
1914 Warning: this section is outdated and inaccurate.
1916 There are a large number of paper variables that are used to control
1917 details of the layout. Usually you will not want to change these
1918 variables; they are set by default to vaules that depend on the font
1919 size in use. The only way to find out what variables are supported is
1920 to search the source code for code(get_var). Two variables that you
1921 may want to change are code(linewidth) and code(indent).
1923 In order to change the font size used for the output, many variables
1924 need to be changed. Some identifiers and initialization files can
1925 simplify this process. The default size is 20pt. In order to select
1926 a different size, you must do two things. At the top level, do
1927 code(\include "paper)var(SZ)code(.ly") where var(SZ) is the height of
1928 the staff in points. Values presently allowed are 11, 13, 16, 20, and
1929 26. This loads some definitions, but does not cause them to take
1930 effect. In order to actually change the size, you must use one of the
1931 identifiers: code(\paper_eleven), code(\paper_thirteen),
1932 code(\paper_sixteen), code(\paper_twenty) or code(\paper_twentysix)
1933 inside a code(\paper) block.
1937 dit(var(integer)) If an integer appears on the left side of an
1938 assignment then a code(\font) keyword must appear on the right
1939 side. This defines a music font at a particular size. See Voice
1940 property code(fontSize).
1942 dit(code(arithmetic_basicspace) and code(arithmetic_multiplier))
1943 The space taken by a note is determined by the formula
1946 )verb(arithmetic_multiplier * ( c + log2 (time) ))COMMENT(
1948 ) where code(time) is the amount of time a note occupies. The value
1949 of code(c) is chosen such that the smallest space within a measure is
1950 arithmetic_basicspace. The smallest space is the one following the
1951 shortest note in the measure. Typically arithmetic_basicspace is set
1952 to the width of a quarter note head.
1954 dit(code(beam_dir_algorithm)) Specify algorithm for determining
1955 whether beams go up or down. It is real valued. If set to 2.0 then
1956 majority selection is used. If set to 3.0, then mean selection is
1957 used based on the mean center distance. If set to 4.0 then median
1958 selection is used, based on the median center distance.
1959 dit(code(castingalgorithm))
1960 dit(code(crescendo_shorten))
1961 dit(code(forced_stem_shorten)) Stems that have been forced to go the
1962 unnatural direction are shortened by this amount. Equal to
1963 dit(code(forced_stem_shorten0))
1964 dit(code(gourlay_energybound))
1965 dit(code(gourlay_maxmeasures)) Maximum number of measures per line
1966 when using Gourlay method.
1967 Decreasing this greatly reduces computation time. Default value: 10.
1968 dit(code(indent)) Sets the indentation of the first line of music.
1969 dit(code(interbeam))
1970 dit(code(interbeam4))
1971 dit(code(interline)) The distance between two staff
1972 lines, calculated from the center of the lines.
1973 dit(code(linewidth)) Sets the width of the lines. If it is set to
1974 -1.0, then a single unjustified line is produced.
1975 dit(code(notewidth)) Width of an average note head.
1976 dit(code(output)) Specifies an alternate
1977 name for the TeX() output. A file(.tex) extension will be added to
1978 the string you specify.
1979 dit(code(rulethickness)) Determines thickness of staff lines and bars.
1980 dit(code(slur_clip_angle))
1981 dit(code(slur_clip_height))
1982 dit(code(slur_clip_ratio))
1983 dit(code(slur_height_limit)) Specifies the maximum height of slurs.
1984 Normally equal to staff_height.
1985 dit(code(slur_ratio)) Specifes the ratio of slur hight to slur width
1986 to aim for. Default value is 0.3.
1987 dit(code(slur_rc_factor))
1988 dit(code(slur_slope_damping)) Allows slurs to start and end at
1989 different heights ???? Default value is 0.5.
1990 dit(code(slur_thickness)) Specify slur thickness. Equal to code(1.4 *
1991 \staffline) by default.
1992 dit(code(slur_x_gap)) Horizontal space between note and slur. Set to
1993 code(\interline / 5) by default.
1994 dit(code(slur_x_minimum))
1995 dit(code(staffheight)) The height of the staff from the center of the
1996 bottom line to the center of the top line. Equal to to code(4 * \interline).
1997 dit(code(stem_length)) Specify length of stems for notes in the staff
1998 that don't have beams.
1999 dit(code(stemthickness)) Specifies the thickness of the stem lines.
2000 dit(code(tie_slope_damping))
2001 dit(code(tie_x_minimum))
2005 subsect(MIDI Instrument Names)
2008 The MIDI instrument name is set by the code(Staff.midiInstrument)
2009 property or, if that property is not set, the code(Staff.instrument)
2010 property. The instrument name should be chosen from this list. If
2011 string does not exactly match one from this list then LilyPond uses
2014 COMMENT( acordina = accordion, tango accordian = concertina
2015 distortion guitar = distorted guitar
2016 orchestral strings = harp
2017 pan flute = wood flute? )
2019 verb("acoustic grand" "contrabass" "lead 7 (fifths)"
2020 "bright acoustic" "tremolo strings" "lead 8 (bass+lead)"
2021 "electric grand" "pizzicato strings" "pad 1 (new age)"
2022 "honky-tonk" "orchestral strings" "pad 2 (warm)"
2023 "electric piano 1" "timpani" "pad 3 (polysynth)"
2024 "electric piano 2" "string ensemble 1" "pad 4 (choir)"
2025 "harpsichord" "string ensemble 2" "pad 5 (bowed)"
2026 "clav" "synthstrings 1" "pad 6 (metallic)"
2027 "celesta" "synthstrings 2" "pad 7 (halo)"
2028 "glockenspiel" "choir aahs" "pad 8 (sweep)"
2029 "music box" "voice oohs" "fx 1 (rain)"
2030 "vibraphone" "synth voice" "fx 2 (soundtrack)"
2031 "marimba" "orchestra hit" "fx 3 (crystal)"
2032 "xylophone" "trumpet" "fx 4 (atmosphere)"
2033 "tubular bells" "trombone" "fx 5 (brightness)"
2034 "dulcimer" "tuba" "fx 6 (goblins)"
2035 "drawbar organ" "muted trumpet" "fx 7 (echoes)"
2036 "percussive organ" "french horn" "fx 8 (sci-fi)"
2037 "rock organ" "brass section" "sitar"
2038 "church organ" "synthbrass 1" "banjo"
2039 "reed organ" "synthbrass 2" "shamisen"
2040 "accordion" "soprano sax" "koto"
2041 "harmonica" "alto sax" "kalimba"
2042 "concertina" "tenor sax" "bagpipe"
2043 "acoustic guitar (nylon)" "baritone sax" "fiddle"
2044 "acoustic guitar (steel)" "oboe" "shanai"
2045 "electric guitar (jazz)" "english horn" "tinkle bell"
2046 "electric guitar (clean)" "bassoon" "agogo"
2047 "electric guitar (muted)" "clarinet" "steel drums"
2048 "overdriven guitar" "piccolo" "woodblock"
2049 "distorted guitar" "flute" "taiko drum"
2050 "guitar harmonics" "recorder" "melodic tom"
2051 "acoustic bass" "pan flute" "synth drum"
2052 "electric bass (finger)" "blown bottle" "reverse cymbal"
2053 "electric bass (pick)" "skakuhachi" "guitar fret noise"
2054 "fretless bass" "whistle" "breath noise"
2055 "slap bass 1" "ocarina" "seashore"
2056 "slap bass 2" "lead 1 (square)" "bird tweet"
2057 "synth bass 1" "lead 2 (sawtooth)" "telephone ring"
2058 "synth bass 2" "lead 3 (calliope)" "helicopter"
2059 "violin" "lead 4 (chiff)" "applause"
2060 "viola" "lead 5 (charang)" "gunshot"
2061 "cello" "lead 6 (voice)")
2065 subsect(Translators)
2068 The behavior of notation contexts is defined by the translators for
2069 those contexts. The translator for a context specifies what notations
2070 are handled by the context, it specifies what other contexts the
2071 context can contain, and it sets property values for the context.
2072 There are different translators for each type of output. The
2073 translators for paper output are defined in file(engraver.ly). The
2074 translators for MIDI output are defined in file(performer.ly).
2076 The first thing that appears inside a code(\translator) definition is
2077 the type of the context being created. This is specified with the
2078 code(\type) keyword: code(\type) var(typename)code(;). After the type
2079 of the context is specified, property assignments, the code(\name)
2080 keyword and code(\consists), code(\accepts), and code(\remove)
2081 keywords can appear in any order. The code(\name) keyword specifies
2082 the name of the context that is handled by the translator. If the
2083 name is not specified, the translator won't do anything. Each
2084 code(\accepts) keyword specifies what contexts can be contained inside
2085 this one. The code(\consists) keywords specify which notations are
2086 handled by the context. Each code(\consists) keyword specifies the
2087 name of an engraver (for paper ouput) or performer (for MIDI output)
2088 which handles a certain notation. The code(\remove) keyword can be
2089 used to remove a performer or engraver from the translator.
2091 In the code(\paper) block, it is also possible to define translator
2092 identifiers. Like other block identifiers, the identifier can only
2093 be used as the very first item of a translator. In order to define
2094 such an identifier outside of code(\score), you must do
2095 verb(\paper{ foo=\translator{ ... }
2098 \paper{ \translator{ \foo ... } }
2101 Some All of the standard translators have predefined identifiers, making
2102 it easy to redefine these contexts by adding or removing items.
2103 The predefined identifiers are: code(StaffContext),
2104 code(RhythmicStaffContext), code(VoiceContext), code(ScoreContext), code(ScoreWithNumbers)
2107 subsubsect(Paper Types and Engravers and Pre-defined Translators)
2109 Some pre-defined identifiers can simplify modification of translators.
2110 The pre-defined identifiers are:
2112 dit(code(StaffContext)) Default Staff context.
2113 dit(code(RhythmicStaffContext)) Default RhythmicStaff context.
2114 dit(code(VoiceContext)) Default Voice context.
2115 dit(code(ScoreContext)) Default Score context.
2116 dit(code(ScoreWithNumbers)) Score context with numbering at the
2118 dit(code(BarNumberingStaffContext)) Staff context with numbering at
2120 dit(code(HaraKiriStaffContext))
2121 dit(code(OrchestralPartStaffContext))
2122 dit(code(OrchestralScoreContext))
2124 Using these pre-defined values, you can remove or add items to the
2125 translator verb(\paper{ \translator{ \StaffContext
2126 \remove Some_engraver;
2127 \consists Different_engraver; }})
2131 There are four types for paper translators:
2133 dit(code(Engraver_group_engraver))
2134 dit(code(Hara_kiri_line_group_engraver))
2135 dit(code(Line_group_engraver_group))
2136 dit(code(Score_engraver))
2138 COMMENT( The names of these types seem somewhat confusing. )
2140 The engravers for paper output are:
2143 dit(code(Abbreviation_beam_engraver))
2144 dit(code(Bar_engraver)) Engraves bar lines. Normally in code(Staff) and
2145 code(RhythmicStaff).
2146 dit(code(Bar_number_engraver)) Engrave bar numbers. These numbers
2147 appear at the start of each line. Not normally in any translator. Can
2148 be added to code(Score) for Score-wide numbering or to code(Staff) for
2149 numbering on each staff.
2151 dit(code(Beam_engraver)) Handles beam requests by engraving beams. Normally
2152 appears in the code(Voice) translator. If omitted, then notes will be printed
2153 with flags instead of beams.
2155 dit(code(Beam_req_swallow_translator)) Swallows beam requests. In
2157 dit(code(Chord_name_engraver)) Engraves chord names. Normally in
2158 code(ChordNameVoice)
2159 dit(code(Clef_engraver)) Engraves the clef symbol. Normally in code(Staff).
2160 dit(code(Collision_engraver))
2161 dit(code(Dot_column_engraver)) Engraves dots on dotted notes shifted to the
2162 right of the note. Normally in code(Voice). If omitted, then dots appear on
2164 dit(code(Dynamic_engraver)) Engraves dynamics symbols. Normally in code(Voice).
2165 dit(code(Font_size_engraver))
2166 dit(code(Key_engraver)) Engraves the key signature. Normally in code(Staff).
2167 dit(code(Local_key_engraver))
2168 dit(code(Lyric_engraver)) Engraves lyrics. Normally in code(LyricVoice).
2169 dit(code(Multi_measure_rest_engraver)) Engraves multi-measure rests that are
2170 produced with code(R). Normally in code(Voice).
2171 dit(code(Piano_bar_engraver))
2172 dit(code(Pitch_squash_engraver)) Treat all pitches as middle C. Used in
2173 code(RhythmicStaff). Note that the notes move, but the locations of
2174 accidentals stay the same.
2175 dit(code(Priority_horizontal_align_engraver))
2176 dit(code(Repeat_engraver)) Handles repeats? In code(Staff) and
2177 code(RhythmicStaff).
2178 dit(code(Rest_collision_engraver)) Handles collisions of rests. In code(Staff).
2179 dit(code(Rest_engraver)) Engraves rests. Normally in code(Voice).
2180 dit(code(Rhythmic_column_engraver))
2181 dit(code(Score_priority_engraver))
2182 dit(code(Script_engraver)) Handles note ornaments generated by code(\script).
2183 Normally in code(Voice).
2184 dit(code(Separating_line_group_engraver))
2185 dit(code(Skip_req_swallow_translator))
2186 dit(code(Slur_engraver)) Engraves slurs. Normally in code(Voice).
2187 dit(code(Span_bar_engraver)) Engraves lines across multiple staffs. Normally
2188 in code(Staffgroup) and code(GrandStaff). Removing this from code(StaffGroup)
2189 gives the definition of code(ChoirStaff).
2190 dit(code(Span_score_bar_engraver))
2191 dit(code(Staff_group_bar_engraver))
2192 dit(code(Staff_margin_engraver)) Prints the name of the instrument
2193 (specified by code(Staff.instrument) and code(Staff.instr)) at the
2195 dit(code(Staff_sym_engraver))
2196 dit(code(Stem_engraver)) Engraves stems. Normally in code(Voice).
2197 dit(code(Ties_engraver)) Engraves ties. Normally in code(Voice).
2198 dit(code(Time_signature_engraver)) Engraves the time signature. Normally in
2199 code(Staff) and code(RhythmicStaff).
2200 dit(code(Timing_engraver)) Responsible for synchronizing timing information
2201 from staffs. Normally in code(Score). In order to create polyrhythmic music,
2202 this engraver should be removed from code(Score) and placed in code(Staff).
2203 dit(code(Tuplet_engraver)) Engraves tuplet brackets? In code(Staff).
2204 dit(code(Vertical_align_engraver))
2208 subsubsect(MIDI Types and Performers)
2210 The types available for MIDI translators are:
2212 dit(code(Performer_group_performer))
2213 dit(code(Score_performer))
2214 dit(code(Staff_performer))
2217 The performers for MIDI translators are:
2219 dit(code(Key_performer))
2220 dit(code(Time_signature_performer))
2221 dit(code(Note_performer))
2222 dit(code(Lyric_performer))
2223 dit(code(Swallow_performer))