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 grouping 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''-\wheel}
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
627 mudela(fragment,verbatim,center)(
628 c'' \< \! c'' d'' \decr e'' \rced
629 < f''1 {s4 \< \! s4 \> \! s2 } >)
632 COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
634 Tremolo marks can be printed by a note by adding code(:)[var(length)]
635 after the note. The length must be at least 8. A var(length) value
636 of 8 gives one line across the note stem.
637 If the length is omitted,
638 then the last value is used, or the value of the code(Abbrev)
639 property if there was no last value. To place tremolo marks in
640 between two notes, begin with code([:)var(length) and end with code(]).
641 The tremolo marks will appear instead of beams. Putting more than two
642 notes in such a construction will produce odd effects.
644 [TREMOLO BEAMS TEMPORARILY OUT OF ORDER]
646 COMMENT(mudela (fragment,verbatim,center)(
647 c'2:8 c':32 [:16 e'1 g'] [:8 e'4 f']
651 Is the last paragraph correct? Is it called "tremolo"? Why is
652 "abbreviation" used? (What is the unabreviated form?)
655 mudela (fragment,verbatim,center)(
662 sect(Other Ways to Enter Pitches)
664 subsect(Pitch Names in Other Languages)
667 The pitch names can be easily redefined using the code(\notenames) command.
668 Note name definitions have been provided in various languages.
669 Simply include the language specific init file. For example:
670 code(\include "english.ly"). The available language files and the names
673 verb( Note Names sharp flat
674 nederlands.ly c d e f g a bes b -is -es
675 english.ly c d e f g a bf b -s/-sharp -f/-flat
676 deutsch.ly c d e f g a b h -is -es
677 norsk.ly c d e f g a b h -iss/-is -ess/-es
678 svenska.ly c d e f g a b h -iss -ess
679 italiano.ly do re mi fa sol la sid si -d -b
680 catalan.ly do re mi fa sol la sid si -d/-s -b)
682 subsect(Relative Pitch Specification)
685 One very common error when entering music is to place notes in the wrong
686 octave. One way to avoid being confused by large numbers of octave changing
688 the code(\relative) keyword.
689 Music which appears within code(\relative) is
690 interpreted differently. The octave of a note is determined by making it as
691 close to the previous note as possible. The octave changing marks code(') and
692 code(,) can then be added to raise or lower this note by octaves. You have to
693 specify a starting pitch because the first note of a list has no predecessor.
695 mudela(fragment,verbatim,center)(
696 \relative c'' { c d b c, d b c' d
700 When the preceeding item is a chord, the first note of the chord is used to
701 determine the first note of the next chord. But other notes within the second
702 chord are determined by looking at the immediately preceeding note.
704 mudela(fragment,verbatim,center)(
705 \relative c' { c <c e g>
709 The code(\relative) keyword can only appear in music, so there must be a
710 surrounding code(\notes) keyword which does not appear in the fragments shown
711 above. Also note that if the music passed to a code(\relative) keyword
712 contains a code(\transpose) keyword, the tranposed music will not be
713 processed in relative mode. An additional code(\relative) must be placed
714 inside the code(\transpose). If code(\relative) will be used several
715 times, or if it will be used in the same music with code(\transpose),
716 then you may get bizarre effects. This can be fixed by using an
717 explicit code(Staff) context.
720 subsect(Tranposition of Pitches)
723 Another way to modify the meaning of the note names is to use the
724 code(\transpose) keyword. This keyword allows you to transpose music.
725 To use transposition, specify the pitch that middle C should be tranposed to.
726 It is important to distinguish between enharmonic pitches as they can produce
727 different transpositions. To transpose up half a step, for example, either
728 code(\transpose cis') or code(\transpose des') will work. But the first
729 version will print sharps and the second version will print flats.
730 In this example, a scale in the key of E is transposed to F, or to E-sharp
732 mudela(fragment,verbatim,center)(
733 \relative c' { \key e;
734 e fis gis a b cis dis e }
736 mudela(fragment,verbatim,center)(
737 \transpose des' \relative c' { \key e;
738 e fis gis a b cis dis e }
740 mudela(fragment,verbatim,center)(
741 \transpose cis' \relative c' { \key e;
742 e fis gis a b cis dis e }
744 If you want to use both code(\transpose) and code(\relative), then you must use
745 code(\transpose) first. Any code(\relative) keywords that are outside the
746 code(\transpose) have no effect on notes that appear inside the
747 code(\transpose). As with code(\relative), using code(\transpose)
748 repeatedly can cause bizarre effects. An explicit code(Staff) context
749 will eliminate the problems.
753 Chords can be entered either by name or by listing the notes in angle brackets.
754 Chords can be displayed either as notes or by name. To enter chords by name,
755 either place them inside the code(\chords) keyword, or use
756 code(\notes) and surround them with
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 can be separated by a dot (code(.)) if you need to list
768 several unmodified intervals.
769 Repeating a code(-) character will remove a half step from the preceeding
771 mudela(fragment,verbatim,center)(
775 c-9-5+7+ c-3-5- c-4.6.8
777 The second type of modifier that may appear after the code(-) is
779 Named modifiers are listed in the file file(chord-modifiers.ly). The
780 available modifiers are code(m) and code(min) which lower
781 the 3rd half a step, code(aug) which raises the 5th, code(dim) which lowers
782 the 5th, code(maj) which adds a raised 7th, and code(sus) which replaces the
784 mudela(fragment,verbatim,center)(
787 c1-m c-min c-maj c-aug c-dim c-sus
790 Chord subtractions are used to eliminate notes from a chord. The notes to be
791 subtracted are listed after a code(^) character, separated by dots.
792 mudela(fragment,verbatim,center)(
798 Chord inversions can be specified by appending code(/) and the name of a
799 single note to a chord. This has the effect of lowering the specified note by
800 an octave so it becomes the lowest note in the chord. If the
801 specified note is not in the chord then a warning will be printed.
802 mudela(fragment,verbatim,center)(
804 @c1@ @c/e@ @c/g@ @c-7/e@
806 Throughout these examples, chords have been shifted around the staff
807 using code(\transpose). The code(\relative) keyword has odd effects
808 when combined with named chords.
810 For displaying printed chord names, use the code(ChordNames) context.
811 The chords may be entered either using the notation described above,
812 or directly using angle brackets.
813 mudela(fragment,verbatim)(
815 \context ChordNames { \chords{ a b c} \notes{ < d f g > < e g b > } }
816 \context Staff \notes{ a b c' d' e' }
819 Lilypond examines chords specified as lists of notes to determine a
820 name to give the chord. By default, LilyPond will not try to identify
822 mudela(fragment,verbatim,center)(
824 \context ChordNames {
825 \notes{ < e' g' c'' > } }
826 \context Staff \notes{ c' }
828 If you want inversions to be recognized, you must set the property
829 code(Score.chordInversion):
830 mudela(fragment,verbatim,center)(
832 \property Score.chordInversion = 1
833 \context ChordNames {
834 \notes{ < e' g' c'' > } }
835 \context Staff \notes{ c' }
842 Lyrics are entered like notes, with pitches replaced
843 by text. For example code(Twin-4 kle4 twin-4 kle4) enters four
844 syllables, each with quarter note duration. Note that the hyphen has
845 no special meaning for lyrics, and does not introduce special symbols.
846 See Section ref(modes) for a description of what is interpreted as a lyric.
848 In order to instruct LilyPond to write lyrics underneath the
849 staff, you must enter the lyrics context with code(\context Lyrics).
850 Lyrics should be entered in lyrics mode which is entered with code(\lyrics).
852 Spaces can be introduced into a lyric either by using quotes (code("))
853 or by using an underscore without quotes: code(He_could4 not4). All
854 unquoted underscores are converted to spaces. Here is a full example:
855 mudela(verbatim)(\score{
856 < \notes \transpose c'' {c d e c | c d e c | e f g'2 |
857 e'4 f g'2 \bar "|."; }
858 \context Lyrics \lyrics {
859 DOEXPAND(Fr\)`e-4 re Ja- que DOEXPAND(Fr\)`e- re Ja- que
860 Dor- mez vous?2 Dor-4 mez vous?2 }
868 Why does this warrant an URG?
871 When one word is attached to many notes, you may
872 want a continuous line after the lyric to show this. To achieve
873 this effect, add a code(__) lyric as a separate word
874 after the lyric to be extended.
876 an extender, a line that extends over the entire duration of
877 the lyric. This line will run all the way to the start of the next
878 lyric, so you may want to shorten it by using a blank lyric.
879 mudela(verbatim)(\score{
880 < \notes \relative c''{
881 a4()b()c()d c()d()b()a c()d()b()a }
882 \context Lyrics \lyrics {
883 foo1 __ bar2. __ _4 baz1 __ }
886 If you want to have hyphens centred between syllables (rather than attached
887 to the end of the first syllable) you can use the special code(--) lyric as
888 separate word between syllables. This will result in a hyphen whose length
889 varies depending on the space between syllables, and centred between the
890 syllables. For example:
891 mudela(verbatim)(\score{
892 < \notes \transpose c'' {c d e c | c d e c | e f g'2 |
893 e'4 f g'2 \bar "|."; }
894 \context Lyrics \lyrics {
895 DOEXPAND(Fr\)`e4 -- re Ja -- que DOEXPAND(Fr\)`e -- re Ja -- que
896 Dor -- mez vous?2 Dor4 -- mez vous?2 }
905 LilyPond aligns all musical objects according to the amount of time
906 they occupy. All musical objects have a duration. When music is
907 written sequentially using braces the duration is the sum of the
908 durations of the elements. When music is stacked into simultaneous music
910 brackets, the duration is the maximum of the durations of the
913 Because LilyPond knows the durations of all musical elements, the time
914 signature enables LilyPond to draw bar lines automatically. The time
915 signature is specified with the code(\time) keyword: code(\time 3/4).
916 If no time signature is given, LilyPond assumes 4/4. The automatic
917 generation of bar lines can toggled with the code(\cadenza) keyword or the
918 code(Staff.barNonAuto) property,
919 and an incomplete measure at the start of the music can be created
920 using the code(\partial) keyword: code(\partial 8*2;) creates a
921 starting measure lasting two eighth notes.
923 In order to help with error checking, you can insert bar markers in
924 your music by typing code(|). Whenever LilyPond encounters a code(|)
925 that doesn't fall at a measure boundary, she prints a warning message.
927 Rhythmic grouping is a concept closely associated with this.
928 A default grouping is selected for the chosen time signature.
929 The default consists of combinations of 2 and 3 beats with as many
930 groups of 3 as possible, and the groups of 3 coming first. For
931 example, 4/4 is divided into 2+2 and 8/8 is divided into 3+3+2. This
932 default grouping can be changed using the \grouping keyword which
933 takes a list of durations to specify the grouping.
937 sect(Composition: forming bigger structures)
940 The computer savy user may be interested in a more formal
941 specification. We can capture what have learned about forming
942 sentences in Mudela in a context-free grammar.
944 latexcommand(\smallskip)
947 row(cell(em(Music))cell(: em(Note)))
948 row(cell()cell(code(|) em(Rest)))
949 row(cell()cell(code(|) code({) em(MusicList) code(})))
950 row(cell()cell(code(|) code(<) em(MusicList) code(>)))
951 row(cell()cell(code(|) em(Command)))
952 row(cell()cell(code(|) code(\context) em(string) code(=) em(string) em(Music)))
954 row(cell(em(MusicList))cell(: em(empty)))
955 row(cell()cell(code(|) em(MusicList) em(Music)))
959 latexcommand(\smallskip)
961 In mathematics you can form expressions by combining expressions,
962 which are ultimately some kind of atom or terminal symbol. The same
963 goes for Mudela: there are some basic building blocks, and by
964 combining those you create complex music.
966 You can combine music in three ways:
968 it()If you enclose a sequence of music-elements in braces ( code({)
969 and code(}) ), then you form another kind of music called
972 The duration of sequential composition is the sum of the durations of its elements
974 { c c g g a a g2 } % twinkle twinkle
975 { { c c g g} { a a g2 } }
977 it()You can stack music by enclosing a sequence of music elements
978 with code(<) and code(>). This is called simultaneous music.
979 The duration of a simultaneous composition is the maximum of the durations
980 of its elements Example:
982 <a4 {cis8 cis8} e'4> % a-major chord
984 it()You can form music by transposing music:
987 d % from c to the d that's almost one octave down
988 { e4 f4 } % the horizontal music
992 it()verb(\translator)
996 Of course you can also combine these three mechanisms.
998 { c <c e> <c e g> <c e g \transpose d' dis > } % 4 increasing chords
1006 In order to specify repeats, use the code(\repeat) keyword. By
1007 default, repeats are printed with repeat symbols.
1008 mudela(fragment,verbatim,center)(
1010 \repeat semi 2 { c'4 d' e' f' }
1011 \repeat semi 2 { f' e' d' c' })
1012 In order to specify alternate endings, use the code(\alternative)
1014 mudela(fragment,verbatim,center)(
1016 \repeat semi 2 {c'4 d' e' f'}
1017 \alternative { {d'2 d'} {f' f} })
1018 The code(semi) specifies that normal repeats will be printed. If
1019 code(fold) is used instead then the alternatives will be stacked:
1020 mudela(fragment,verbatim,center)(
1022 \repeat fold 2 {c'4 d' e' f'}
1023 \alternative { {d'2 d'} {f' f} })
1024 When the repeats involve partial measures, it will be necessary to use
1025 code(\partial) keywords in a somewhat unexpected way
1026 to indicate some measure lengths.
1027 mudela(fragment,verbatim)(
1028 \context Staff { \relative c'{
1029 \repeat semi 2 { \partial 4; e | c2 d2 | e2 f2 | }
1030 \alternative { { g4 g g } {\partial 1; a a a a | b1 } }
1032 Repeats can be unfolded by setting the property Staff.unfoldRepeats.
1033 Note also that if your music begins with code(\repeat), you must place
1034 it in an explicit code(Staff) context or you will get bizarre results.
1036 If you don't give enough alternatives for all of the repeats, then the
1037 first alternative is assumed to be repeated enough to equal to
1038 specified number of repeats.
1039 mudela(fragment,verbatim)(
1040 \context Staff { \relative c'{
1041 \repeat semi 3 { \partial 4; e | c2 d2 | e2 f2 | }
1042 \alternative { { g4 g g } {\partial 1; e4 e e }
1043 {\partial 1; a a a a | b1 } }
1049 Keywords sometimes appear alone, but usually they require arguments.
1050 A keyword may have a single argument, a sequence of arguments in
1051 braces, or a sequence of arguments separated by spaces and terminated
1052 by a semicolon. The precise syntax of each keyword is shown below.
1053 Keywords must appear in the right context. If you use a keyword in
1054 the wrong place, even if the usage is syntactically correct, you will
1055 get the message ``parse error'' from LilyPond.
1060 dit(code(\absdynamic) code({) var(code) code(})) Internal keyword for
1061 printing dynamic marks such as $f$ under music. The parameter
1062 var(code) is unsigned and specifies the dynamic mark to print.
1063 Normally you should use the more user friendly abbreviations defined
1064 in the init file file(dynamic.ly).
1066 FIXME: Changed to code(\textscript) var(text) var(style). Defines
1069 dit(code(\accepts) var(string)code(;)) This keyword can appear only within a
1070 code(\translator) block. It specifies what contexts are allowed with the
1071 context that is being defined. See Section ref(translators).
1073 dit(code(\alternative) code({) var(music1) var(music2) ... code(}))
1074 Specifies alternative endings. Must come after a code(\repeat) keyword.
1076 dit(code(\bar) var(bartype)code(;)) Prints a special bar symbol, or at
1077 measure boundaries, replaces the regular bar symbol with a special
1078 symbol. The argument var(bartype) is a string which specifies the
1079 kind of bar to print. Options are code(":|"), code("|:"),
1080 code(":|:"), code("||"), code("|."), code(".|"), or code(".|.").
1081 These produce respectively a right repeat, a left repeat, a double
1082 repeat, a double bar, a start bar, an end bar, or a thick double bar.
1083 If var(bartype) is set to code("empty") then nothing is printed, but a
1084 line break is allowed at that spot. Note that the printing of special bars
1085 has no effect on the MIDI output.
1087 dit(code(\cadenza) var(togglevalue)code(;)) Toggles the automatic generation
1088 of bar lines. If var(togglevalue) is 0 then bar line generation is
1089 turned off. If var(togglevalue) is 1 then a bar is immediately
1090 printed and bar generation is turned on.
1092 dit(code(\clef) var(clefname)code(;)) Allowed only in music.
1093 Sets the current clef. The argument is
1094 a string which specifies the name of the clef. Several clef names are
1095 supported. If code(_8) or code(^8) is added to the end of a clef
1096 name then the clef lowered or raised an octave will be generated.
1097 Here are the supported clef names with middle C shown in each clef:
1101 %\property Voice.textStyle = typewriter
1102 \clef subbass; c'4-"\kern-10mm subbass"
1103 \clef bass; c'4^"\kern -8mm bass"
1104 \clef baritone; c'4_"\kern -10mm baritone"
1105 \clef varbaritone; c'4^"\kern -10mm varbaritone"
1106 \clef tenor; c'4_"\kern -10mm tenor"
1107 \clef "G_8"; c'4^"\kern -6mm G\_8"
1109 \paper{ linewidth= 4.5 \in; }
1114 \notes{\cadenza 1; \clef alto; c'4_"\kern -10mm alto"
1115 % \clef scarlatti; c'4_"\kern -4mm scarlatti"
1116 \clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
1117 \clef soprano; c'4_"\kern -10mm soprano"
1118 \clef treble; c'4^"\kern -6mm treble"
1119 \clef french; c'4_"\kern -10mm french" }
1120 \paper{ linewidth= 4.5 \in; }
1123 The treble clef can also be obtained using the names code(G) or
1124 code(violin). The bass clef is also available by code(\clef F).
1126 dit(code(\chord) var(chordlist)) Parse var(chordlist) in chords mode.
1128 dit(code(\chordmodifiers) var(modifierlist)) Specify the text chord
1129 modifiers that may appear after chord names. These are specified in
1130 the file file(chord-modifiers.ly).
1132 dit(code(\cm)) Specify a dimension in centimeters.
1134 dit(code(\consists) var(string)code(;)) This keyword can appear only within a
1135 code(\translator) block. It specifies that an engraver or performer named
1136 var(string) should be added to the translator. See Section
1139 dit(code(\consistsend) var(string)code(;)) Unknown function.
1141 dit(code(\context) var(contexttype) [code(=) var(contextname)]
1142 var(music) or code(\context) var(translatortype)code(;)) The first
1143 variant is used only within music to create an instance of a
1144 context. The new context can optionally be given a name. The
1145 specified var(music) is processed in the new context. The second
1146 variant appears within a code(\translator) block and specifies the
1147 type of translator being created.
1149 dit(code(\duration) code({) var(length) var(dotcount) code(})) Specify note
1150 duration. The parameter var(length) is the negative logarithm (base
1151 2) of duration: 1 is a half note, 2 is a quarter note, 3 is an eighth
1152 note, etc. The number of dots after the note is given by
1155 dit(code(\font) var(string)) Internal keyword. Used within
1156 code(\paper) to specify the font.
1158 dit(code(\grouping) var(durationseq)code(;)) Sets the metric structure of
1159 the measure. Each argument specifies the duration of one metric unit.
1160 For example, code(\duration 16*5;) specifies a grouping of five beats
1161 together in 5/16 time. The default grouping is to have as many groups
1162 of 3 as possible followed by groups of two.
1164 dit(code(\header) code({) var(key1) = var(val1); var(key2) = var(val2); ... code(}))
1165 Specifies information about the music. A header should appear at the
1166 top of the file describing the file's contents. If a file has
1167 multiple code(\score) blocks, then a header should appear in
1168 each score block describing its contents. Tools like code(ly2dvi) can
1169 use this information for generating titles. Key values that are used
1170 by ly2dvi are: title, subtitle, composer, opus, poet, instrument,
1171 metre, arranger, piece and tagline.
1173 dit(code(\in)) Specify a dimension in inches.
1175 dit(code(\include) var(file)) Include the specified file. The
1176 argument var(file) is a string. The full filename including the
1177 file(.ly) extension must be given, and the filename must be quoted.
1178 (An unquoted string will not work here.)
1180 dit(code(\key) var(pitch) var(type) code(;)) Change the key signature.
1181 var(type) should be code(\major) or code(\minor) to get
1182 var(pitch)-major or var(pitch)-minor, respectively. The second
1183 argument is optional, the default is major keys.
1184 The var(\context) argument can also be given as an integer, which tells
1185 the number of semitones that should be added to the pitch given in the
1186 subsequent code(\key) commands to get the corresponding major key,
1187 e.g. code(\minor) is defined as 3. The standard mode names
1188 code(\ionian), code(\locrian), code(\aeolian), code(\mixolydian),
1189 code(\lydian), code(\phrygian), and code(\dorian) are also defined.
1191 dit(code(\keysignature) var(pitchseq)code(;))
1192 Specify an arbitrary key signature. The pitches from var(pitch) will
1193 be printed in the key signature in the order that they appear on the list.
1195 dit(code(\lyrics) var(lyriclist)) Parse var(lyriclist) in lyrics mode.
1197 dit(code(\maininput)) Internal command. This command is used for creating init
1198 files like file(init.fly) that read the user file into the middle of another
1199 file. It is illegal to use this command in a user file.
1201 dit(code(\mark) var(unsigned)code(;) or code(\mark) var(string)code(;))
1202 Allowed in music only. Prints a mark over or under (depending on the
1203 code(markDirection) property) the staff.
1204 You must add code(Mark_engraver) to the Score context.
1206 dit(code(\midi) var(statementlist)) Appears in a score block to
1207 indicate that musical output should be produced and to set output
1208 parameters. Can also appear at the top level to set default output
1209 parameters. See code(\tempo).
1211 dit(code(\mm)) Specify a dimension in millimeters.
1213 dit(code(\musicalpitch) code({) var(octave) var(note) var(shift) code(}))
1214 Specify note pitch. The octave is specified by an integer,
1215 zero for the octave containing middle C. The note is a number from 0
1216 to 7, with 0 corresponding to C and 7 corresponding to B. The shift
1217 is zero for a natural, negative to add flats, or positive to add
1220 dit(code(\name) var(context)code(;)) Appears within code(\translator) to
1221 specify the name of the context that the translator handles. See Section
1224 dit(code(\notenames) var(assignmentlist)) Define new note names. This
1225 keyword can appear only at the top level.
1226 The argument is a list of definitions of the form
1227 var(name) = var(pitch), where var(pitch) is specified with the
1228 code(\musicalpitch) keyword.
1230 dit(code(\notes) var(music)) Enter note mode and process the
1233 dit(code(\paper) var(statmentlist))
1234 Appears in a score block to indicate that the music should be printed
1235 or to set output parameters. Can also appear at the top level to set
1236 default output parameters for all of the score blocks.
1237 The var(statmentlist) contains statements that change features of the
1238 output. See Section ref(paper).
1240 dit(code(\partial) var(duration)code(;)) Specify that the first measure of
1241 the music lasts only for the specified duration. Use also to specify
1242 the duration of the first measure of the argument to
1245 dit(code(\penalty) var(int)code(;)) Allowed only in music.
1246 Discourage or encourage line breaks. See identifiers code(\break) and
1247 code(\nobreak) in Section ref(ident).
1249 dit(code(\property) var(contextname)code(.)var(propname) code(=) var(value))
1250 Sets the var(propname) property of the context var(contextname) to the
1251 specified var(value). All three arguments are strings. Depending on
1252 the context it may be necessary to quote the strings or to leave space
1253 on both sides of the dot.
1255 dit(code(\pt)) Specify a dimension in points.
1257 dit(code(\relative) var(pitch) var(music)) Processes the specified
1258 var(music) in relative pitch
1259 mode. In this mode, the octave of a pitch is chosen so that the
1260 pitch is closest to the preceeding pitch.
1261 The argument var(pitch) is
1262 the starting pitch for this comparision. In the case of chords, the
1263 first note of a chord is used as the base for the first pitches in the next
1264 chord. See Section ref(relative).
1266 dit(code(\remove) var(string)code(;)) Can appear only in a
1267 code(\translator) block. Specifies that a performer or engraver named
1268 var(string) should be removed. See Section ref(translators).
1270 dit(code(\repeat) var(style) var(count) code({) var(music) code(}))
1271 Repeats the specified
1272 music var(count) times. Alternative endings can be specified by adding a
1273 code(\alternative) keyword after the code(\repeat). The var(style)
1274 parameter should be either code(semi), for regular repeats, or
1275 code(fold) for repeats displayed vertically.
1277 dit(code(\scm) var(scheme)code(;)) Embeds specified Scheme code.
1279 dit(code(\scmfile) var(filename)code(;)) Reads Scheme code from the specified
1282 dit(code(\score) var(statementlist)) Create a Score context. This
1283 is the top level notation context.
1284 COMMENT(this still needs work)
1286 dit(code(\script) var(alias)) Prints a symbol above or below a note.
1287 The argument is a string which points into the script-alias table
1288 defined in file(script.scm). The scheme definitions specify whether
1289 the symbol follows notes into the staff, dependence of symbol
1290 placement on staff direction, and a priority for placing several
1291 symbols over one note. Usually the code(\script) keyword is not used
1292 directly. Various helpful identifier definitions appear in
1295 dit(code(\shape) code(=) var(indent1) var(width1) var(indent2)
1296 var(width2) ... code(;)) Allowed only within code(\paper). Each pair
1297 of var(indent) and var(width) values is a dimension specifying how far
1298 to indent and how wide to make the line. The indentation and width of
1299 successive lines are specified by the successive pairs of dimensions.
1300 The last pair of dimensions will define the characeristics of all
1301 lines beyond those explicitly specified.
1303 COMMENT(First pair of dimensions seems to be skipped. At least it is
1304 in the example file denneboom.ly.)
1306 dit(code(\skip) var(duration)code(;)) Skips the amount of time specified by
1307 var(duration). A gap will be left for the skipped time with no notes
1308 printed. It works in Note Mode or Lyrics Mode (but generates a
1309 mysterious error in lyrics).
1311 dit(code(\spanrequest) var(startstop) var(type)). Define a spanning request
1312 var(startstop) is either -1 (code(\start)) or 1 (code(\stop)). The var(type)
1313 parameter is a string that describes what should be started. Supported types
1314 are "crescendo", "decrescendo", "beam", "slur". This is an internal command.
1315 Users should use the abbreviations which are defined in the
1316 initialization file file(dynamic.ly).
1318 dit(code(\tempo) var(duration) = var(perminute)code(;)) Used within
1319 code(\midi) or within music to specify the tempo. For example,
1320 `code(\midi { \tempo 4 = 76;})' requests output with 76 quarter notes
1321 per minute. Note that if the music contains several tempo commands,
1322 only the last one is used to set the tempo for the entire MIDI output.
1323 COMMENT(Is this true?)
1325 dit(code(\textscript) var(text) var(style)) Print the specified text as a
1326 script in the specified style.
1328 dit(code(\time) var(numerator)code(/)var(denominator)code(;)) Change the time
1329 signature. The default time signature is 4/4.
1331 dit(code(\times) var(numerator)code(/)var(denominator) var(music))
1332 Multiply the duration of var(music) by the specified fraction.
1334 dit(code(\translator) var(statements) or code(\translator)
1335 var(context) = var(name)) The first variant appears only within
1336 code(\paper) and specifies a translator for
1337 converting music to notation. The translator is specified with a
1338 single code(\context) statement and a series of code(\accepts), and
1339 code(\consists) statements. See Section ref(translators).
1340 The second variant appears in
1341 music. It specifies that the current the contexts
1342 contained within the specified context should be shifted to the
1343 context with the specified name.
1345 COMMENT( \translator seems like a strange name for the second
1346 operation, and is the overloading desireable? )
1348 dit(code(\transpose) var(pitch) var(music)) Transposes the specified
1349 music. Middle C is tranposed to var(pitch). This is allowed in music only,
1350 and if it appears inside code(\relative), then any notes specified for
1351 transposition should be specified inside another code(\relative). See Section
1354 dit(code(\type) var(string)code(;)) Use inside code(\translator) to
1355 specify the type of the translator.
1357 dit(code(\version) var(string)) Specify the version of Mudela that a
1358 file was written for. The argument is the version number, for example
1359 code("1.0.1"). Note that the Mudela version is different from the
1365 sect(Notation Contexts)
1367 Notation contexts provide information that appears in printed music
1368 but not in the music itself. A new musical context is created using
1369 the code(\context) keyword: `code(\context) var(contexttype) [code(=)
1370 var(contextname)] var(music)'. The following context types are
1375 dit(code(LyricVoice)) Corresponds to a voice with lyrics. Handles the printing
1376 of a single line of lyrics.
1378 dit(code(Voice)) Corresponds to a voice on a staff.
1379 This context handles the conversion of noteheads,
1380 dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests.
1382 dit(code(ChordNamesVoice)) A voice with chord names. Handles printing
1383 of a line of chord names.
1385 dit(code(ChordNames)) Typesets chord names. Can contain
1386 code(ChordNamesVoice) contexts.
1388 dit(code(Lyrics)) Typesets lyrics. It can contain code(LyricVoice) contexts.
1390 dit(code(Staff)) Handles clefs, bar lines, keys,
1391 accidentals. It can contain code(Voice) contexts.
1393 dit(code(RhythmicStaff)) A context like code(Staff) but for printing
1394 rhythms. Pitches are ignored; the notes are printed on one line.
1395 It can contain code(Voice) contexts.
1397 dit(code(GrandStaff)) Contains code(Staff) or code(RhythmicStaff)
1398 contexts. It adds a brace on the left side grouping the staffs
1399 together. The bar lines of the contained staffs are connected vertically.
1400 It can contain code(Staff) contexts.
1402 dit(code(PianoStaff)) Just like code(GrandStaff) but with
1403 code(minVerticalAlign) set equal to code(maxVerticalAlign) so that
1404 interstaff beaming and slurring can be used.
1406 dit(code(StaffGroup)) Contains code(Staff) or code(RhythmicStaff)
1407 contexsts. Adds a bracket on the left side, grouping the staffs
1408 together. The bar lines of the contained staffs are connected vertically.
1409 It can contain code(Staff), code(RhythmicStaff), code(GrandStaff) or code(Lyrics) contexts.
1411 dit(code(ChoirStaff)) Identical to code(StaffGroup) except that the
1412 contained staffs are not connected vertically.
1414 dit(code(Score)) This is the top level notation context. It is specified with
1415 the code(\score) keyword rather than the code(\context) command. No
1416 other context can contain a code(Score) context. This context handles
1417 the administration of time signatures. It also makes sure that items
1418 such as clefs, time signatures, and key-signatures are aligned across
1419 staffs. It can contain code(Lyrics), code(Staff),
1420 code(RhythmicStaff), code(GrandStaff), code(StaffGroup), and
1421 code(ChoirStaff) contexts.
1425 The various contexts have properties associated with them. These
1426 properties can be changed using the code(\property) command:
1427 `code(\property) var(context)code(.)var(propname) code(=) var(value)'.
1428 Properties can also be set within the code(\translator) block
1429 corresponding to the appropriate context. In this case, they are
1430 assigned by `var(propname) code(=) var(value)'. The settings made with
1431 code(\property) are processed after settings made in the code(\translator)
1432 block, so the code(\property) settings will override code(\translator)
1435 The code(\property) keyword will create any property you specify.
1436 There is no guarantee that a property will actually be used. If you
1437 spell a property name wrong, there will be no error message. In order to find
1438 out what properties are used, you must search the source code
1439 for code(get_property).
1440 Properties that are set in one context are inherited by all of the
1441 contained contexts. This means that a property valid for the Voice
1442 context can be set in the Score context (for example) and thus take
1443 effect in all Voice contexts.
1445 subsubsubsect(Lyrics properties)
1449 dit(code(textStyle)) Set the font for lyrics. The available font
1450 choices are code(roman), code(italic), code(bold), code(large),
1451 code(Large), code(typewriter), and code(finger). The code(finger)
1452 font can only display numbers. Note also that you must be careful
1453 when using code(\property) in Lyrics mode. Because of the way strings
1454 are parsed, either put quotes around the arguments to code(\property)
1455 or be sure to leave a space on both sides of the dot.
1460 subsubsubsect(Voice properties)
1464 dit(code(stemLeftBeamCount)) Specify the number of beams to draw on
1465 the left side of the next note.
1467 dit(code(stemRightBeamCount)) Specify the number of beams to draw on
1468 the right side of the next note.
1470 dit(code(beamAuto)) If set to 1 then beams are generated
1471 automatically. If set to zero then no beams will be automatically
1472 generated. The default value is 1.
1474 dit(code(beamAutoEnd)) Specifies when automatically generated beams
1475 can end. See Section ref(autobeam).
1477 dit(code(beamAutoBegin)) Specifies when automatically generated beams
1478 can start. See Section ref(autobeam).
1480 dit(code(textEmptyDimension)) If set to 1 then text placed above or
1481 below the staff is assumed to have zero width.
1483 dit(code(noteheadStyle)) Selects type of note head. Choices are
1484 code(cross), code(diamond), code(harmonic), code(transparent), and
1485 code(""). They are shown in that order below.
1489 \property Staff.barNonAuto = 1
1490 \property Voice.noteHeadStyle = cross
1492 \property Voice.noteHeadStyle = diamond
1494 \property Voice.noteHeadStyle = harmonic
1496 \property Voice.noteHeadStyle = transparent
1498 \property Voice.noteHeadStyle = ""
1501 \paper{ linewidth = -1.;}
1506 dit(code(restStyle)) Change the layout of rests shorter than quarter notes.
1507 Currently, the standard layout code(restStyle="") and mensural notation
1508 code(restStyle="mensural") are available.
1510 dit(code("midiInstrument")) Sets the instrument for MIDI output. This
1511 property name must be quoted because of the embedded underscore. If
1512 this property is not set then LilyPond will use the code(instrument)
1513 property. This must be set to one of the strings on the list of MIDI
1514 instruments that appears in Section ref(midilist). If you use a
1515 string which is not listed, LilyPond will silently substitute piano.
1517 dit(code(transposing)) Tranpose the MIDI output. Set this property to
1518 the number of half-steps to transpose by.
1520 dit(code(oldTieBehavior)) Set to 1 in order to get old tie behavior
1521 where ties would connect unequal pitches.
1523 dit(code(verticalDirection)) Determines the direction of stems, subscripts,
1524 beams, slurs, and ties. Set to code(\down) to force them down,
1525 code(\up) to force them up, or code(\free) to let LilyPond decide.
1526 This can be used to distinguish between voices on the same staff. The
1527 code(\stemdown), code(\stemup), and code(\stemboth) identifiers set
1528 this property. See also the identifiers code(\voiceone),
1529 code(\voicetwo), code(\voicethree) and code(\voicefour).
1531 dit(code(slurVerticalDirection)) Set to code(\free) for free choice of slur
1532 direction, set to code(\up) to force slurs up, set to code(\down) to
1533 force slurs down. The shorthands code(\slurup), code(\slurdown), and
1534 code(\slurboth) are available.
1536 dit(code(tieVerticalDirection)) Set to code(\free) for free choice of tie
1537 direction, set to code(\up) to force ties up, set to code(\down) to
1540 dit(code(slurdash)) Set to 0 for normal slurs, 1 for dotted slurs, and
1541 a larger value for dashed slurs. Identifiers code(\slurnormal) and
1542 code(\slurdotted) are predefined to set the first two settings.
1544 dit(code(horizontalNoteShift)) Set to 1 to enable LilyPond to shift notes
1545 horizontally if they collide with other notes. This is useful when
1546 typesetting many voices on one staff. The identifier code(\shift) is
1547 defined to enable this. If there are several voices, every voice must
1548 have a distinct value of this property or no shifting will occur.
1550 dit(code(dynamicDir)) Determines location of dynamic marks. Set to
1551 code(\up) to print marks above the staff; set to code(\down) to print
1552 marks below the staff.
1554 dit(code(dynamicStyle)) Set the text style for dynamics.
1556 dit(code(textStyle)) Set the text style for superscripts and
1557 subscripts. See above for list of text styles.
1559 dit(code(textScriptPadding)) Determines the extra space added between
1560 super-/subscripted text and the closest staff line or note.
1562 dit(code(fontSize)) Can be used to select smaller font sizes for
1563 music. The normal font size is 0, and the two smaller sizes are -1
1566 dit(code(abbrev)) Set length for tremolo to be used if no length is
1567 explicitly specified.
1569 dit(code(tupletDirection)) Determines the direction of triplets and
1570 other tuplets. Set to code(\down) to force them below the staff,
1571 code(\up) to force them above, or code(\free) to let LilyPond decide.
1573 dit(code(tupletVisibility)) Determines whether tuplets of notes are
1574 labelled. Setting to 0 shows nothing; setting to 1 shows a number;
1575 setting to 2 shows a number and a bracket if there is no beam; setting
1576 to 3 shows a number, and if there is no beam it adds a bracket;
1577 setting to 4 shows both a number and a bracket unconditionally. The
1578 code(pletoff) and code(pleton) identifiers set the property to 0 and 3,
1581 dit(code(markScriptPadding)) Determines the extra space added between
1582 the mark and the closest staff line or note.
1584 dit(code(markDirection)) Determines if marks should be printed above
1585 or below the staff. Set to code(\up) to print marks above the staff;
1586 set to code(\down) to print marks below the staff.
1588 dit(code(articulationScriptPadding)) Determines the extra space added
1589 between articulation marks, such as staccato, tenuto, trill, up/down
1590 bow or fermata, and the closest staff line or note.
1593 subsubsubsect(Staff properties)
1597 dit(code(createInitdefaultClef)) Specify whether clefs are created on
1598 default? (Doesn't seem to do anything.)
1600 dit(code(barNumberDirection)) Set to code(\up) or code(\down) to put
1601 bar numbers above or below the staff.
1603 dit(code(barNumberHangOnClef)) Set to 1 to cause bar numbers to appear
1604 above or below the clef instead of on the bar line.
1606 dit(code(barNumberScriptPadding)) Sets extra space between the bar
1607 number and the bar it labels.
1609 dit(code(barSize)) Specify the height of the bar lines if it should be
1610 different than the staff height.
1612 dit(code(markHangOnClef)) Set to 1 to cause marks to appear by clefs
1613 instead of by bar lines.
1615 dit(code(marginDirection)) Set to code(\left) or code(\right) to
1616 specify location of marginal scripts.
1618 dit(code(marginScriptPadding)) Specify extra space for marginal scripts.
1620 dit(code(forgetAccidentals)) Causes accidentals to be printed at every
1621 note instead of remembered for the duration of a measure.
1623 dit(code(noResetKey)) Do not reset the key at the start of a measure.
1624 Accidentals will be printed only once and are in effect until
1625 overridden, possibly many measures later.
1627 dit(code(staffLineLeading)) Specifies the distance (in points) between lines
1630 dit(code(numberOfStaffLines)) Specifies the number of staff lines. The
1633 dit(code(postBreakPadding)) Extra space in points to be added after
1634 the clef, time signature and key signature on the staff.
1636 dit(code(barAtLineStart)) Set to 1 to produce a bar line after the
1637 clef at the start of each line (but not at the beginning of the
1640 dit(code(voltaVisibility)) Set to 0 to suppress the printing
1641 of brackets over alternate endings specified by code(\alternative).
1643 dit(code(voltaSpannerDuration)) Set to an integer to control the size
1644 of the brackets printed by code(\alternative). The integer specifies
1645 the number of whole notes duration to use for the brackets. It seems
1646 to be rounded to the nearest measure. This can be used to shrink the
1647 length of brackets in the situation where one alternative is very
1648 large. It may have odd effects if the specified duration is longer
1649 than the music given in an code(\alternative).
1651 dit(code(barNonAuto)) If set to 1 then bar lines will not be printed
1652 automatically; they must be explicitly created with code(\bar) keywords.
1653 Unlike with the code(\cadenza) keyword, measures are still counted. Bar
1654 generation will resume according to that count if this property is set to
1657 dit(code(defaultClef)) Determines the default clef. See code(\clef)
1660 dit(code(nuberOfStaffLines)) Sets the number of lines that the staff has.
1662 dit(code(barAlways)) If set to 1 a bar line is drawn after each note.
1664 dit(code(defaultBarType)) Sets the default type of bar line. See
1667 dit(code(keyoctaviation)) If set to 1, then keys are the same in all
1668 octaves. If set to 0 then the key signature for different octaves can
1669 be different and is specified independently: code(\keysignature bes
1670 fis'). The default value is 1. Can be set to zero with
1671 code(\specialkey) or reset to 1 with code(\normalkey).
1673 dit(code(instrument) and code(instr)) If code(Staff_margin_engraver)
1674 is added to the Staff translator, then the code(instrument) property
1675 is used to label the first line of the staff and the code(instr)
1676 property is used to label subsequent lines. If the
1677 code(midiInstrument) property is not set then code(instrument) is
1678 used to determine the instrument for MIDI output.
1679 COMMENT(This prints the instrument name on top of the staff lines.)
1681 dit(code(createKeyOnClefChange)) Set to a nonempty string if you want key
1682 signatures to be printed when the clef changes. Set to the empty string (the
1683 default) if you do not want key signatures printed.
1686 dit(code(timeSignatureStyle)) Changes the default two-digit layout
1687 for time signatures. The following values are recognized:
1689 dit(code(C)) 4/4 and 2/2 are typeset as C and struck C,
1690 respectively. All other time signatures are written with two digits.
1691 dit(code(old)) 2/2, 3/2, 3/4, 4/4, 6/4, 9/4, 6/8 and 9/8 are typeset
1692 with old-style mensuration marks. All other time signatures are
1693 written with two digits.
1694 dit(code(1)) All time signatures are typeset with a single
1695 digit, e.g. 3/2 is written as 3.
1696 dit(code(C2/2), code(C4/4), code(old2/2), code(old3/2),
1697 code(old3/4), code(old4/4), code(old6/4), code(old9/4),
1698 code(old6/8) or code(old9/8))Tells Lilypond to use a
1699 specific symbol as time signature.
1701 The different time signature characters are shown below with
1705 \notes\relative c'' {
1706 \property Voice.textStyle = typewriter
1707 \property Staff.timeSignatureStyle = "C2/2"
1708 \time 2/2; a2^"C2/2" a2
1709 \property Staff.timeSignatureStyle = "C4/4"
1710 \time 2/2; a2^"C4/4" a2
1711 \property Staff.timeSignatureStyle = "old2/2"
1712 \time 2/2; a2^"old2/2" a2
1713 \property Staff.timeSignatureStyle = "old3/2"
1714 \time 2/2; a2^"old3/2" a2
1715 \property Staff.timeSignatureStyle = "old4/4"
1716 \time 2/2; a2^"old4/4" a2
1717 \property Staff.timeSignatureStyle = "old6/4"
1718 \time 2/2; a2^"old6/4" a2
1719 \property Staff.timeSignatureStyle = "old9/4"
1720 \time 2/2; a2^"old9/4" a2
1721 \property Staff.timeSignatureStyle = "old6/8"
1722 \time 2/2; a2^"old6/8" a2
1723 \property Staff.timeSignatureStyle = "old9/8"
1724 \time 2/2; a2^"old9/8" a2
1726 \paper{ linewidth= 4.5 \in; }
1730 dit(code(clefStyle)) Determines how clefs are typeset. When set to
1731 code(transparent), the clefs are not printed at all, when set to
1732 code(fullSizeChanges), clef changes in the middle of a line are
1733 typeset with a full size clef. By default, clef changes are typeset in
1738 subsubsubsect(GrandStaff properties)
1742 dit(code(alignmentReference)) Set to code(\center) for vertical
1743 alignment reference point to be in the center of the vertical group.
1744 Set to code(\up) to put the reference point at the top of the group.
1746 dit(code(maxVerticalAlign)) Set the maximum vertical distance between
1749 dit(code(minVerticalAlign)) Set the minimum vertical distance between
1754 subsubsubsect(Score properties)
1758 dit(code(skipBars)) Set to 1 to skip the empty bars that are produced
1759 by multimeasure notes and rests. These bars will not appear on the
1760 printed output. Set to zero (the default) to expand multimeasure
1761 notes and rests into their full length, printing the appropriate
1762 number of empty bars so that synrchonization with other voices is
1763 preserved. COMMENT(meaning of "skip" here seems to be different from
1764 the meaning used for the keyword \skip.)
1766 dit(code(beamquantisation)) Set to code(\none) for no quantization.
1767 Set to code(\normal) to quantize position and slope. Set to
1768 code(\traditional) to avoid wedges. These three settings are
1769 available via code(\beamposfree), code(\beamposnormal), and
1770 code(\beampostraditional).
1772 dit(code(beamslopedamping)) Set to code(\none) for undamped beams.
1773 Set to code(\normal) for damped beams. Set to code(\infinity) for
1774 beams with zero slope. The identifiers code(\beamslopeproportional),
1775 code(\beamslopedamped), and code(\beamslopezero) each set the
1776 corresponding value.
1778 dit(code(chordInversion)) Determines whether LilyPond should look for
1779 chord inversions when translating from notes to chord names. Set to 1
1780 to find inversions. The default is 0 which does not look for inversions.
1786 sect(Pre-defined Identifiers)
1789 Various identifiers are defined in the initialization files to
1790 provide shorthands for some settings.
1793 dit(code(\aeolian)) Used as the second argument of the code(\key)
1794 keyword to get an aeolian mode.
1795 dit(code(\break)) Force a line break in music by using a large
1796 argument for the keyword code(\penalty).
1797 dit(code(\center)) Used for setting textalignment property. Is set to 0.
1798 dit(code(\cr)) Start a crescendo.
1799 dit(code(\decr)) Start a decrescendo.
1800 dit(code(\dorian)) Used as the second argument of the code(\key)
1801 keyword to get a dorian mode.
1802 dit(code(\down)) Used for setting direction setting properties. Is
1804 dit(code(\f)) Print forte symbol on the preceeding note.
1805 dit(code(\ff)) Print fortissimo symbol on the preceeding note.
1806 dit(code(\fff)) Print fortississimo symbol on preceeding note.
1807 dit(code(\ffff)) Print fortissississimo symbol on preceeding note.
1808 dit(code(\fffff)) Print fffff symbol on preceeding note.
1809 dit(code(\ffffff)) Print ffffff symbol on preceeding note.
1810 dit(code(\fp)) Print fortepiano symbol on preceeding note.
1811 dit(code(\free)) Used for setting direction setting properties. Is
1813 dit(code(\Gourlay)) Used for setting the paper variable
1814 code(castingalgorithm). Is equal to 1.0.
1815 dit(code(\infinity)) Used for setting the Score.beamslopedamping
1816 property. Is actually equal to 10000.
1817 dit(code(\ionian)) Used as the second argument of the code(\key)
1818 keyword to get an ionian mode.
1819 dit(code(\left)) Used for setting textalignment property. Is equal to -1.
1820 dit(code(\locrian)) Used as the second argument of the code(\key)
1821 keyword to get a locrian mode.
1822 dit(code(\lydian)) Used as the second argument of the code(\key)
1823 keyword to get a lydian mode.
1824 dit(code(\major)) Used as the second argument of the code(\key)
1825 keyword to get a major key.
1826 dit(code(\minor)) Used as the second argument of the code(\key)
1827 keyword to get a minor key.
1828 dit(code(\mixolydian)) Used as the second argument of the code(\key)
1829 keyword to get a mixolydian mode.
1830 dit(code(\mf)) Print mezzoforte symbol on preceeding note.
1831 dit(code(\mp)) Print mezzopiano symbol on preceeding note.
1832 dit(code(\nobreak)) Prevent a line break in music by using a large
1833 negative argument for the keyword code(\penalty).
1834 dit(code(\none)) Used for setting Score.beamslopedamping and
1835 Score.beamquantisation properties. Is equal to 0.
1836 dit(code(\normal)) Used for setting Score.beamslopedamping and
1837 Score.beamquantisation properties. Is equal to 1.
1838 dit(code(\normalkey)) Select normal key signatures where each octave
1839 has the same key signature. This sets the Staff.keyoctaviation property.
1840 dit(code(\p)) Print a piano symbol on preceeding note.
1841 dit(code(\phrygian)) Used as the second argument of the code(\key)
1842 keyword to get a phrygian mode.
1843 dit(code(\pp)) Print pianissimo symbol on preceeding note.
1844 dit(code(\ppp)) Print pianississimo symbol on preceeding note.
1845 dit(code(\pppp)) Print pianissississimo symbol on preceeding note.
1846 dit(code(\ppppp)) Print ppppp symbol on preceeding note.
1847 dir(code(\pppppp)) Print pppppp symbol on preceeding note.
1848 dit(code(\rc)) Terminate a crescendo.
1849 dit(code(\rced)) Terminate a decrescendo
1850 dit(code(\rfz)) Print a rinforzato symbol on preceeding note.
1851 dit(code(\right)) Used for setting textalignment property. Is set to 1.
1852 dit(code(\sf)) Print a subito-forte symbol on preceeding note.
1853 dit(code(\sff)) Print a subito-fortissimo symbol on preceeding note.
1854 dit(code(\sfz)) Print a sforzato symbol on preceeding note.
1855 dit(code(\shiftoff)) Disable horizontal shifting of note heads that collide.
1856 Sets the Voice.horizontalNoteShift property.
1857 dit(code(\shifton)) Enable note heads that collide with other note heads
1858 to be shifted horiztonally. Sets the Voice.horizontalNoteShift property.
1859 dit(code(\slurboth)) Allow slurs to be above or below notes. This
1860 sets the Voice.slurVerticalDirection property.
1861 dit(code(\slurdown)) Force slurs to be below notes. This sets the
1862 Voice.slurVerticalDirection property.
1863 dit(code(\slurup)) Force slurs to be above notes. This sets the
1864 Voice.slurVerticalDirection property.
1865 dit(code(\sp)) Print a subito-piano symbol on preceeding note.
1866 dit(code(\spp)) Print a subito-forte symbol on preceeding note.
1867 dit(code(\specialkey)) Allow keys signatures do differ in different
1868 octaves. This sets the Staff.keyoctaviation property.
1869 dit(code(\stemboth)) Allow stems, beams, and slurs to point either
1870 direction. This sets the Voice.verticalDirection property.
1871 dit(code(\stemdown)) Force stems, beams, and slurs to point down.
1872 This sets the Voice.verticalDirection property.
1873 dit(code(\stemup)) Force stems, beams and slurs to point up. This
1874 sets the Voice.verticalDirection property.
1875 dit(code(\traditional)) Used for setting the
1876 Score.beamquantisation property. Is equal to 2.
1877 dit(code(\up)) Used for setting various direction properties. Is
1879 dit(code(\voiceone)) Enter Voice context called code(one) and force stems down.
1880 (See code(\stemdown).)
1881 dit(code(\voicetwo)) Enter Voice context called code(two) and force stems
1882 up. (See code(\stemup).)
1883 dit(code(\voicethree)) Enter Voice context called code(three) and force stems
1885 dit(code(\voicefour)) Enter Voice context called code(four), force stems down
1886 and turn on horizontal shifting. (See code(\stemdown) and code(\shifton).)
1887 dit(code(\Wordwrap)) Used for setting the paper variable
1888 code(castingalgorithm). Equal to 0.0.
1896 The output produced by LilyPond is controlled by the code(\paper) and
1897 code(\midi) keywords. These keywords appear in the code(\score) block
1898 to indicate that printed or musical output should be produced. If
1899 neither keyword appears in a code(\score) block, then paper output is
1900 produced but MIDI output is not produced.
1902 The contents of the code(\paper) and code(\midi) blocks can change the
1903 output in various ways. These blocks can appear at the top level of a
1904 Mudela file to set default parameters for each type of output. It is
1905 still necessary to explicitly specify the output type in the
1906 code(\score) blocks if you don't want the default behavior of
1907 producing only paper output.
1909 The code(\paper) and code(\midi) blocks
1910 may begin with an optional identifier reference. No
1911 identifier references are allowed anywhere else in the block.
1912 The code(\paper) block can contain the code(\shape) keyword; the
1913 code(\midi) block can contain the code(\tempo) keyword. Both of them
1914 can contain code(\translator) keywords. The code(\paper) block can
1915 also contain identifier assignments and parameter assignments. Unlike
1916 at the top level, these assignments must be terminated by a semicolon.
1919 subsect(Paper variables)
1921 Warning: this section is outdated and inaccurate.
1923 There are a large number of paper variables that are used to control
1924 details of the layout. Usually you will not want to change these
1925 variables; they are set by default to vaules that depend on the font
1926 size in use. The only way to find out what variables are supported is
1927 to search the source code for code(get_var). Two variables that you
1928 may want to change are code(linewidth) and code(indent).
1930 In order to change the font size used for the output, many variables
1931 need to be changed. Some identifiers and initialization files can
1932 simplify this process. The default size is 20pt. In order to select
1933 a different size, you must do two things. At the top level, do
1934 code(\include "paper)var(SZ)code(.ly") where var(SZ) is the height of
1935 the staff in points. Values presently allowed are 11, 13, 16, 20, and
1936 26. This loads some definitions, but does not cause them to take
1937 effect. In order to actually change the size, you must use one of the
1938 identifiers: code(\paper_eleven), code(\paper_thirteen),
1939 code(\paper_sixteen), code(\paper_twenty) or code(\paper_twentysix)
1940 inside a code(\paper) block.
1944 dit(var(integer)) If an integer appears on the left side of an
1945 assignment then a code(\font) keyword must appear on the right
1946 side. This defines a music font at a particular size. See Voice
1947 property code(fontSize).
1949 dit(code(arithmetic_basicspace) and code(arithmetic_multiplier))
1950 The space taken by a note is determined by the formula
1953 )verb(arithmetic_multiplier * ( c + log2 (time) ))COMMENT(
1955 ) where code(time) is the amount of time a note occupies. The value
1956 of code(c) is chosen such that the smallest space within a measure is
1957 arithmetic_basicspace. The smallest space is the one following the
1958 shortest note in the measure. Typically arithmetic_basicspace is set
1959 to the width of a quarter note head.
1961 dit(code(beam_dir_algorithm)) Specify algorithm for determining
1962 whether beams go up or down. It is real valued. If set to 2.0 then
1963 majority selection is used. If set to 3.0, then mean selection is
1964 used based on the mean center distance. If set to 4.0 then median
1965 selection is used, based on the median center distance.
1966 dit(code(castingalgorithm))
1967 dit(code(crescendo_shorten))
1968 dit(code(forced_stem_shorten)) Stems that have been forced to go the
1969 unnatural direction are shortened by this amount. Equal to
1970 dit(code(forced_stem_shorten0))
1971 dit(code(gourlay_energybound))
1972 dit(code(gourlay_maxmeasures)) Maximum number of measures per line
1973 when using Gourlay method.
1974 Decreasing this greatly reduces computation time. Default value: 10.
1975 dit(code(indent)) Sets the indentation of the first line of music.
1976 dit(code(interbeam))
1977 dit(code(interbeam4))
1978 dit(code(interline)) The distance between two staff
1979 lines, calculated from the center of the lines.
1980 dit(code(linewidth)) Sets the width of the lines. If it is set to
1981 -1.0, then a single unjustified line is produced.
1982 dit(code(notewidth)) Width of an average note head.
1983 dit(code(output)) Specifies an alternate
1984 name for the TeX() output. A file(.tex) extension will be added to
1985 the string you specify.
1986 dit(code(rulethickness)) Determines thickness of staff lines and bars.
1987 dit(code(slur_clip_angle))
1988 dit(code(slur_clip_height))
1989 dit(code(slur_clip_ratio))
1990 dit(code(slur_height_limit)) Specifies the maximum height of slurs.
1991 Normally equal to staff_height.
1992 dit(code(slur_ratio)) Specifes the ratio of slur hight to slur width
1993 to aim for. Default value is 0.3.
1994 dit(code(slur_rc_factor))
1995 dit(code(slur_slope_damping)) Allows slurs to start and end at
1996 different heights ???? Default value is 0.5.
1997 dit(code(slur_thickness)) Specify slur thickness. Equal to code(1.4 *
1998 \staffline) by default.
1999 dit(code(slur_x_gap)) Horizontal space between note and slur. Set to
2000 code(\interline / 5) by default.
2001 dit(code(slur_x_minimum))
2002 dit(code(staffheight)) The height of the staff from the center of the
2003 bottom line to the center of the top line. Equal to to code(4 * \interline).
2004 dit(code(stem_length)) Specify length of stems for notes in the staff
2005 that don't have beams.
2006 dit(code(stemthickness)) Specifies the thickness of the stem lines.
2007 dit(code(tie_slope_damping))
2008 dit(code(tie_x_minimum))
2012 subsect(MIDI Instrument Names)
2015 The MIDI instrument name is set by the code(Staff.midiInstrument)
2016 property or, if that property is not set, the code(Staff.instrument)
2017 property. The instrument name should be chosen from this list. If
2018 string does not exactly match one from this list then LilyPond uses
2021 COMMENT( acordina = accordion, tango accordian = concertina
2022 distortion guitar = distorted guitar
2023 orchestral strings = harp
2024 pan flute = wood flute? )
2026 verb("acoustic grand" "contrabass" "lead 7 (fifths)"
2027 "bright acoustic" "tremolo strings" "lead 8 (bass+lead)"
2028 "electric grand" "pizzicato strings" "pad 1 (new age)"
2029 "honky-tonk" "orchestral strings" "pad 2 (warm)"
2030 "electric piano 1" "timpani" "pad 3 (polysynth)"
2031 "electric piano 2" "string ensemble 1" "pad 4 (choir)"
2032 "harpsichord" "string ensemble 2" "pad 5 (bowed)"
2033 "clav" "synthstrings 1" "pad 6 (metallic)"
2034 "celesta" "synthstrings 2" "pad 7 (halo)"
2035 "glockenspiel" "choir aahs" "pad 8 (sweep)"
2036 "music box" "voice oohs" "fx 1 (rain)"
2037 "vibraphone" "synth voice" "fx 2 (soundtrack)"
2038 "marimba" "orchestra hit" "fx 3 (crystal)"
2039 "xylophone" "trumpet" "fx 4 (atmosphere)"
2040 "tubular bells" "trombone" "fx 5 (brightness)"
2041 "dulcimer" "tuba" "fx 6 (goblins)"
2042 "drawbar organ" "muted trumpet" "fx 7 (echoes)"
2043 "percussive organ" "french horn" "fx 8 (sci-fi)"
2044 "rock organ" "brass section" "sitar"
2045 "church organ" "synthbrass 1" "banjo"
2046 "reed organ" "synthbrass 2" "shamisen"
2047 "accordion" "soprano sax" "koto"
2048 "harmonica" "alto sax" "kalimba"
2049 "concertina" "tenor sax" "bagpipe"
2050 "acoustic guitar (nylon)" "baritone sax" "fiddle"
2051 "acoustic guitar (steel)" "oboe" "shanai"
2052 "electric guitar (jazz)" "english horn" "tinkle bell"
2053 "electric guitar (clean)" "bassoon" "agogo"
2054 "electric guitar (muted)" "clarinet" "steel drums"
2055 "overdriven guitar" "piccolo" "woodblock"
2056 "distorted guitar" "flute" "taiko drum"
2057 "guitar harmonics" "recorder" "melodic tom"
2058 "acoustic bass" "pan flute" "synth drum"
2059 "electric bass (finger)" "blown bottle" "reverse cymbal"
2060 "electric bass (pick)" "skakuhachi" "guitar fret noise"
2061 "fretless bass" "whistle" "breath noise"
2062 "slap bass 1" "ocarina" "seashore"
2063 "slap bass 2" "lead 1 (square)" "bird tweet"
2064 "synth bass 1" "lead 2 (sawtooth)" "telephone ring"
2065 "synth bass 2" "lead 3 (calliope)" "helicopter"
2066 "violin" "lead 4 (chiff)" "applause"
2067 "viola" "lead 5 (charang)" "gunshot"
2068 "cello" "lead 6 (voice)")
2072 subsect(Translators)
2075 The behavior of notation contexts is defined by the translators for
2076 those contexts. The translator for a context specifies what notations
2077 are handled by the context, it specifies what other contexts the
2078 context can contain, and it sets property values for the context.
2079 There are different translators for each type of output. The
2080 translators for paper output are defined in file(engraver.ly). The
2081 translators for MIDI output are defined in file(performer.ly).
2083 The first thing that appears inside a code(\translator) definition is
2084 the type of the context being created. This is specified with the
2085 code(\type) keyword: code(\type) var(typename)code(;). After the type
2086 of the context is specified, property assignments, the code(\name)
2087 keyword and code(\consists), code(\accepts), and code(\remove)
2088 keywords can appear in any order. The code(\name) keyword specifies
2089 the name of the context that is handled by the translator. If the
2090 name is not specified, the translator won't do anything. Each
2091 code(\accepts) keyword specifies what contexts can be contained inside
2092 this one. The code(\consists) keywords specify which notations are
2093 handled by the context. Each code(\consists) keyword specifies the
2094 name of an engraver (for paper ouput) or performer (for MIDI output)
2095 which handles a certain notation. The code(\remove) keyword can be
2096 used to remove a performer or engraver from the translator.
2098 In the code(\paper) block, it is also possible to define translator
2099 identifiers. Like other block identifiers, the identifier can only
2100 be used as the very first item of a translator. In order to define
2101 such an identifier outside of code(\score), you must do
2102 verb(\paper{ foo=\translator{ ... }
2105 \paper{ \translator{ \foo ... } }
2108 Some All of the standard translators have predefined identifiers, making
2109 it easy to redefine these contexts by adding or removing items.
2110 The predefined identifiers are: code(StaffContext),
2111 code(RhythmicStaffContext), code(VoiceContext), code(ScoreContext), code(ScoreWithNumbers)
2114 subsubsect(Paper Types and Engravers and Pre-defined Translators)
2116 Some pre-defined identifiers can simplify modification of translators.
2117 The pre-defined identifiers are:
2119 dit(code(StaffContext)) Default Staff context.
2120 dit(code(RhythmicStaffContext)) Default RhythmicStaff context.
2121 dit(code(VoiceContext)) Default Voice context.
2122 dit(code(ScoreContext)) Default Score context.
2123 dit(code(ScoreWithNumbers)) Score context with numbering at the
2125 dit(code(BarNumberingStaffContext)) Staff context with numbering at
2127 dit(code(HaraKiriStaffContext))
2128 dit(code(OrchestralPartStaffContext))
2129 dit(code(OrchestralScoreContext))
2131 Using these pre-defined values, you can remove or add items to the
2132 translator verb(\paper{ \translator{ \StaffContext
2133 \remove Some_engraver;
2134 \consists Different_engraver; }})
2138 There are four types for paper translators:
2140 dit(code(Engraver_group_engraver))
2141 dit(code(Hara_kiri_line_group_engraver))
2142 dit(code(Line_group_engraver_group))
2143 dit(code(Score_engraver))
2145 COMMENT( The names of these types seem somewhat confusing. )
2147 The engravers for paper output are:
2150 dit(code(Abbreviation_beam_engraver))
2151 dit(code(Bar_engraver)) Engraves bar lines. Normally in code(Staff) and
2152 code(RhythmicStaff).
2153 dit(code(Bar_number_engraver)) Engrave bar numbers. These numbers
2154 appear at the start of each line. Not normally in any translator. Can
2155 be added to code(Score) for Score-wide numbering or to code(Staff) for
2156 numbering on each staff.
2158 dit(code(Beam_engraver)) Handles beam requests by engraving beams. Normally
2159 appears in the code(Voice) translator. If omitted, then notes will be printed
2160 with flags instead of beams.
2162 dit(code(Beam_req_swallow_translator)) Swallows beam requests. In
2164 dit(code(Chord_name_engraver)) Engraves chord names. Normally in
2165 code(ChordNameVoice)
2166 dit(code(Clef_engraver)) Engraves the clef symbol. Normally in code(Staff).
2167 dit(code(Collision_engraver))
2168 dit(code(Dot_column_engraver)) Engraves dots on dotted notes shifted to the
2169 right of the note. Normally in code(Voice). If omitted, then dots appear on
2171 dit(code(Dynamic_engraver)) Engraves dynamics symbols. Normally in code(Voice).
2172 dit(code(Font_size_engraver))
2173 dit(code(Key_engraver)) Engraves the key signature. Normally in code(Staff).
2174 dit(code(Local_key_engraver))
2175 dit(code(Lyric_engraver)) Engraves lyrics. Normally in code(LyricVoice).
2176 dit(code(Multi_measure_rest_engraver)) Engraves multi-measure rests that are
2177 produced with code(R). Normally in code(Voice).
2178 dit(code(Piano_bar_engraver))
2179 dit(code(Pitch_squash_engraver)) Treat all pitches as middle C. Used in
2180 code(RhythmicStaff). Note that the notes move, but the locations of
2181 accidentals stay the same.
2182 dit(code(Priority_horizontal_align_engraver))
2183 dit(code(Repeat_engraver)) Handles repeats? In code(Staff) and
2184 code(RhythmicStaff).
2185 dit(code(Rest_collision_engraver)) Handles collisions of rests. In code(Staff).
2186 dit(code(Rest_engraver)) Engraves rests. Normally in code(Voice).
2187 dit(code(Rhythmic_column_engraver))
2188 dit(code(Score_priority_engraver))
2189 dit(code(Script_engraver)) Handles note ornaments generated by code(\script).
2190 Normally in code(Voice).
2191 dit(code(Separating_line_group_engraver))
2192 dit(code(Skip_req_swallow_translator))
2193 dit(code(Slur_engraver)) Engraves slurs. Normally in code(Voice).
2194 dit(code(Span_bar_engraver)) Engraves lines across multiple staffs. Normally
2195 in code(Staffgroup) and code(GrandStaff). Removing this from code(StaffGroup)
2196 gives the definition of code(ChoirStaff).
2197 dit(code(Span_score_bar_engraver))
2198 dit(code(Staff_group_bar_engraver))
2199 dit(code(Staff_margin_engraver)) Prints the name of the instrument
2200 (specified by code(Staff.instrument) and code(Staff.instr)) at the
2202 dit(code(Staff_sym_engraver))
2203 dit(code(Stem_engraver)) Engraves stems. Normally in code(Voice).
2204 dit(code(Ties_engraver)) Engraves ties. Normally in code(Voice).
2205 dit(code(Time_signature_engraver)) Engraves the time signature. Normally in
2206 code(Staff) and code(RhythmicStaff).
2207 dit(code(Timing_engraver)) Responsible for synchronizing timing information
2208 from staffs. Normally in code(Score). In order to create polyrhythmic music,
2209 this engraver should be removed from code(Score) and placed in code(Staff).
2210 dit(code(Tuplet_engraver)) Engraves tuplet brackets? In code(Staff).
2211 dit(code(Vertical_align_engraver))
2215 subsubsect(MIDI Types and Performers)
2217 The types available for MIDI translators are:
2219 dit(code(Performer_group_performer))
2220 dit(code(Score_performer))
2221 dit(code(Staff_performer))
2224 The performers for MIDI translators are:
2226 dit(code(Key_performer))
2227 dit(code(Time_signature_performer))
2228 dit(code(Note_performer))
2229 dit(code(Lyric_performer))
2230 dit(code(Swallow_performer))