LilyPond — 学习手册

附录

1. Installing

This gentle, step-by-step installation tutorial guides you through installing LilyPond and creating a first music score.

LilyPond input files are simple text files. You can use any raw text editor to edit a LilyPond file (not a rich text editor such as Microsoft Word), but there are several editors tailored specifically for LilyPond, making the editing process very comfortable. Because a choice has to be made, this tutorial uses Frescobaldi, which is the most popular among such editors right now. However, there are several other options available. For more information, see editing Easier editing.

Please choose the tutorial according to your needs. (If you don’t know what the “command line” is, you want the graphical setup!)

1.1 Graphical setup under GNU/Linux

These instructions work for the GNOME environment, for example on the default flavors of Ubuntu and Fedora. In other desktop environments, they can likely be adapted. For more minimal GNU/Linux distributions, see Command line setup.

First, find the GNOME Software app.

In GNOME Software, search “Frescobaldi”.

Install Frescobaldi. Behind the scenes, this should also automatically install some version of LilyPond.

Open Frescobaldi. It starts on a new file with some pre-filled text that will be explained later.

After the \version line, enter a new line containing exactly this:

{ c' }

Now click on the LilyPond icon, or press Control-M. On the right, a simple score appears.

Congratulations, you have just created your first music sheet with LilyPond! If you’re satisfied now, you can skip the rest of this section. However, it may be that the version of LilyPond that was installed is not the same one as this documentation is for. If you want a different LilyPond version, you can register it in Frescobaldi, without losing the initial one. To do this, first download the archive from Download, and double-click to unpack it.

Move the unpacked folder out of your Downloads folder to the folder where you want to permanently store it. For example, put it in your home folder.

Now, in Frescobaldi, go the Preferences.

Select “LilyPond Preferences”, and click “Add” to register a new LilyPond version.

Click on the file explorer icon.

Navigate to the folder you just extracted, then inside this folder, to ‘bin’ and finally ‘lilypond’.

You’re done! You can click ‘OK’. You now have two versions of LilyPond installed.

Now turn to 教程 to learn more about LilyPond’s syntax.

1.2 Graphical setup under Windows

Download LilyPond for Windows from Download. The file will a ZIP archive called ‘lilypond-x.y.z-mingw-x86_64.zip’ (where “mingw” means it’s for Windows). Extract this in the file explorer. Place the resulting directory lilypond-x.y.z-mingw-x86_64 in a permanent location; the actual folder doesn’t matter, you just need to put it somewhere you won’t move it afterwards. For example, you could choose your home folder.

After this, download the latest release of Frescobaldi from the project’s download page. Choose the ‘.exe’ file.

Double-click on the downloaded file in the file explorer. This launches the setup wizard.

Accept the license and install Frescobaldi using the wizard. You will find a startup screen like this:

Navigate to the Frescobaldi preferences.

Navigate to “LilyPond Preferences” on the left.

Click “Edit” on the right. This leads to a dialog for choosing the LilyPond executable.

Click on the folder icon and navigate to the lilypond-x.y.z-mingw-x86_64 folder you previously created. Inside this folder, open ‘lilypond-x.y.z’, then ‘bin’, and finally select ‘lilypond’.

Now click “OK”.

Click “OK” again.

Type this simple file in the window:

\version "2.24.4"

{ c' }

Compile it with Control-M or using the “LilyPond” icon. A minimal score appears.

Congratulations, you have just created your first music sheet with LilyPond! Now continue with the 教程 to learn more about LilyPond’s syntax.

1.3 Graphical setup under macOS

Download LilyPond for macOS from Download. The file will be an archive called ‘lilypond-x.y.z-darwin-x86_64.tar.gz’ (where “darwin” means it’s for macOS). In the Finder, extract this archive. Place the resulting directory lilypond-x.y.z-darwin-x86_64 in a permanent location; the actual folder doesn’t matter, you just need to put it somewhere you won’t move it afterwards. For example, you could choose your home folder.

After this, download the latest release of Frescobaldi from the project’s download page. Choose the ‘.dmg’ file.

In the Finder, double-click on the file to run the installer. At this point, you might encounter a problem:

This is because Frescobaldi is developed independently from Apple. Nevertheless, it is totally secure software, but you have to tell Apple so. To do this, you first need to click “Cancel”. After having clicked “Cancel”, open the “System Preferences” app and select “Security & Privacy”.

Then click “Open Anyway”.

This leads to a new security warning. This time, you have the option to accept. Select “Open”. Again, do not fear: Frescobaldi is completely secure for your system.

Frescobaldi is now open. Find the Preferences.

Click on “LilyPond Preferences” on the left.

Click “Edit” on the right. This opens a new window:

Click on the ‘folder’ icon. A Finder window opens. Navigate to the ‘lilypond-x.y.z-darwin-x86_64’ folder you saved earlier. Inside it, find ‘lilypond-x.y.z’, then ‘bin’ and finally ‘lilypond’.

When you press “OK”, a new security warning about LilyPond will likely appear. Again, first click “Cancel”, then enable LilyPond in the preferences, and redo the procedure to select ‘lilypond’ in the Finder.

Now click “OK” to everything until you are back to the main Frescobaldi window. Enter this simple file in source view on the left:

\version "2.24.4"

{ c' }

Click on the button with the LilyPond icon to compile the file, or use the Control-M keyboard shortcut. For a third time, the system will warn you about security, this time with “gs” (GhostScript). Once more, go to the System Preferences to enable the program to be executed.

Finally, the next compilation run will work and you will find a minimal score.

Congratulations! You have compiled your first music sheet with LilyPond. Now continue with the 教程 to learn more about LilyPond’s syntax.

1.4 Command line setup

On many GNU/Linux distributions, LilyPond can be installed from the package manager. This is also the case on macOS using either MacPorts or Homebrew.

In any case, you can install LilyPond by downloading the archive from Download and unpacking it. The binaries are usable immediately after unpacking. You can run

/.../lilypond-x.y.z/bin/lilypond file.ly

(on Windows, replace the slashes ‘/’ with backslashes ‘\’).

This compiles file.ly, and produces file.pdf. To test your setup, you can use this minimal file:

\version "2.24.4"

{ c' }

This will produce this output in ‘file.pdf’:

Now continue with the 教程 to learn more about LilyPond’s syntax, or see Command-line usage for more information on calling LilyPond on the command line.

2. 教程

这一章是使用 LilyPond 的基本介绍.

2.1 编译文件

这一节介绍了 “编译”—处理你写的 LilyPond 输入文件从而生成输出文件.

“编译” 说的是处理 LilyPond 格式的输入文件从而生成输出文件的过程。输出文件 一般是 PDF 格式（用于打印或直接浏览）、MIDI 格式（用于演奏）、或 PNG 格式（用于在线使用）。LilyPond 的输入文件就是简单的文本文件。

这个例子展示了一个简单的输入文件：

\version "2.24.4"
{
  c' e' g' e'
}

图形输出为：

此外，LilyPond 的输入是 大小写敏感的。 ‘{ c d e }’ is 有效输入；‘{ C D E }’ 会报错。

2.2 如何写输入文件

本节将会介绍介绍一些 LilyPond 的基本语法，帮助你开始写输入文件。

2.2.1 简单记谱法

LilyPond 会自动添加一些记谱元素。下面的例子中，我们只指定了四个音高，但是 LilyPond 已经为我们加上了谱号，拍子记号和节奏。

{
  c' e' g' e'
}

这些东西都是可以手动更改的，但是大多数情况下这些自动生成的东西十分有用。

音高

Music Glossary: pitch, interval, scale, middle C, octave, accidental.

LilyPond 用小写字母表示音高。 本节中所有例子中的音名都用荷兰命名系统（对应钢琴上的白键 c-b）. 然而 LilyPond 也支持很多不同的命名方法，比如英语，或者唱名 ‘Fixed-Do’ (do-re-mi-...). See Note names in other languages. 字母 c 到 b 表示 中央 C 下面的一个 ‘小八度’。加上 ' 或者 , 的后缀表示高八度或低八度。 下面是一段从 middle C 开始的音阶和琶音：

{ c' d' e' f' g' a' b' c'' g c' e' g' c'' e'' g'' c''' }

最简单的输入音符的方法是用 \relative （相对）模式. 这个模式中，系统会自动认为下一个音符总是处在与上一个音符最近的那个八度位置上。即它会位于上一个音符的上下三个谱表范围内。我们开始输入一段最基本的音乐，一段 音阶，其中每一个音符都是比上一个音符高一个谱表距离。

\relative {
  c' d e f
  g a b c
}

初始音符是 中央 C，记为 c'. 每一个后继音符都被放在与上一个音符最近的位置上 – 换句话说，第一个 c 是与中央 C 最近的 C。之后是与前面的 C 最近的 D。我们仍然可以使用 \relative 相对模式，写一段音高变化更大的旋律：

\relative {
  d' f a g
  c b f d
}

前面的例子中，第一个音符 – d' 有一个单引号 ' 标记 – 表示处在中央 C 到上面的 B 之间的这个八度中的 D。

通过从第一个音符中添加或移除单引号 ' 或逗号 , 我们可以更改起始的八度。

\relative {
  e'' c a c
}

相对模式一开始可能有点乱，但确实是最方便的输入旋律的方法。接下来我们看一下实际应用中相对模式到底如何计算的。从一个高音谱中中间线上的 B 开始，向上可以达到在其上三个谱表距离之内的 C, D, E，向下可以达到在其下三个谱表距离之内的 A, G, F。所以如果 B 后面跟的是 C, D, E，它们就会被默认是在 B 之上的，如果后面跟的是 A, G, F，它们就会被默认是在 B 之下的。

\relative {
  b' c % c is 1 staff space up, so is the c above
  b d  % d is 2 up or 5 down, so is the d above
  b e  % e is 3 up or 4 down, so is the e above
  b a  % a is 6 up or 1 down, so is the a below
  b g  % g is 5 up or 2 down, so is the g below
  b f  % f is 4 up or 3 down, so is the f below
}

不管这些音符是被升了还是降了，结果都是一样的，只取决于其本身在谱子上的位置。变音记号 在计算相对位置时会 完全被忽略掉。 谱表上处于任何位置的谱线之间的距离计算总是等价的。

使音程大于三个谱线距离，我们可以通过加入一个 ' 来对这个音符进一步升高一个 八度；可以通过加入一个逗号 , 来对这个音符进一步降低一个 八度。

\relative {
  a' a, c' f,
  g g'' a,, f'
}

要改变两个或（或更多!）八度，可以用多个 '' 或 ,, – 但要注意这里是两个单引号 '' 而不是一个双引号 " !

时值 (节奏)

音乐术语： beam, duration, whole note, half note, quarter note, dotted note.

一个音符的 时值 由音符后面的数字确定：1 为全音符，2 为半音符，4 为四分音符，以此类推。连音会自动生成.

如果你不指定时值，那么该音符的时值就会和上一个音符一样。第一个音符如果不加声明，则默认为四分音符。

\relative {
  a'1
  a2 a4 a8 a
  a16 a a a a32 a a a a64 a a a a a a a a2
}

要写附点音符，只需要在时值数字后面加一个 . 就可以了。浮点音符的点前面必须有数字。

\relative {
  a'4 a a4. a8
  a8. a16 a a8. a8 a4.
}

休止符

音乐术语： rest.

休止符用 r  表示：

\relative {
  a'4 r r2
  r8 a r4 r4. r8
}

拍子记号

音乐术语： time signature.

拍子记号用 \time 命令设置：

\relative {
  \time 3/4
  a'4 a a
  \time 6/8
  a4. a
  \time 4/4
  a4 a a a
}

速度记号

音乐术语： tempo indication, metronome.

速度记号和节拍器记号用 \tempo 命令设置：

\relative {
  \time 3/4
  \tempo "Andante"
  a'4 a a
  \time 6/8
  \tempo 4. = 96
  a4. a
  \time 4/4
  \tempo  "Presto" 4 = 120
  a4 a a a
}

谱号（音部记号）

音乐术语： clef.

谱号用 \clef 命令设置：

\relative {
  \clef "treble"
  c'1
  \clef "alto"
  c1
  \clef "tenor"
  c1
  \clef "bass"
  c1
}

所有的都放在一起

下面这个例子把我们现在学过的元素都用上了：

\relative {
  \clef "bass"
  \time 3/4
  \tempo "Andante" 4 = 120
  c,2 e8 c'
  g'2.
  f4 e d
  c4 c, r
}

参见

记谱法参考： Writing pitches, Writing rhythms, Writing rests, Time signature, Clef.

2.2.2 处理输入文件

LilyPond 输入文件和很多编程语言的源文件非常类似。他们都包含版本声明，都是区分大小写的，都会自动忽略掉空格。表达式用大括号 { } 组织，注释用 % 或 %{ … %}  表示。

如果你不理解前面所说的，也没有关系！下面就会一一解释他们的意思：

• 版本声明: 每一个 LilyPond 文件都会带有一个版本声明。版本声明是一行

  \version "2.24.4"
  

  依惯例，版本声明会放在 LilyPond 文件的最开头。

  版本声明非常重要，原因有二。一是它能够使得 LilyPond 语法更新自动应用在输入文件上。二是它指明了编译这份文件所需的 LilyPond 版本。

  如果输入文件中忘记标版本声明了，LilyPond 会在编译文件时给出警告。

• 大小写敏感: 小写 (e.g. a, b, s, t) 和大写 (e.g. A, B, S, T) 的效果是不一样的。音符都是用小写字母表示的：‘{ c d e }’ 是有效的输入； ‘{ C D E }’ 会报错。
• 空格不敏感: 多少个空格（或制表符或换行）都不重要（不起作用）。下面这三个都是一样的效果：‘{ c4 d e }’， ‘{ c4       d e }’ 和：

  { c4                       d
                     e   }
  

  当然，最后一个写法很不易读。所以最好在一个代码块中加入两个空格（或一个制表符）的缩进：

  {
    c4 d e
  }
  

  然而，空格是需要用来分隔不同语法元素的。换句话说，空格总可以多加，但不一定能省略。因为缺失必要的空格分隔会导致出现奇怪的错误，所以强烈建议在每一个语法元素前后都加上空格，和前后语法元素隔开；比如每个大括号前后都加上空格。

• 表达式: 每条 LilyPond 输入都需要用 { 大括号 } 括起来。这些大括号告诉 LilyPond 括号里的输入是一个单独的音乐表达式，就像数学中的小括号 () 一样。 这些括号两侧都需要加入空格以避免歧义，除非是在行首或行末。

  一个 LilyPond 指令后面跟的大括号内的简单表达式（如 ‘relative { … }’）也会被视为单一音乐表达式。

• Comments: 注释是为了让人们读懂音乐输入而写的标记；注释会在语法分析中被忽略掉，所以不会对输出结果产生影响。注释有两种类型：百分号 % 是单行注释；该行在 % 后的内容都会被编译器忽略。依惯例，单行注释都加在要说明的代码之上。

  a4 a a a
  % this comment refers to the Bs
  b2 b
  

  注释块标记表明一大段音乐输入都是注释。所有在 %{ 和 %} 之间的内容都会被忽略。然而，注释块不能‘嵌套’。这意味着你不能把注释块放在另一个注释块内。如果你这样尝试的话，第一个 %} 会终止 这两个注释块。下面是展示可能用到注释块情形：

  % notes for twinkle twinkle follow
    c4 c g' g a a g2
  
  %{
    This line, and the notes below are ignored,
    since they are in a block comment.
  
    f4 f e e d d c2
  %}
  

2.3 处理报错

有时候 LilyPond 没有输出你想要的结果。这一节会为你通过一些链接帮助你解决这些你可能遇到的问题。

2.3.1 一般解决问题的方法

解决 LilyPond 的问题对于熟悉使用图形化交互界面的人来说可能很具有挑战性，因为无效的输入文件可能会被创建。当这种情况发生时，一个符合逻辑的方法就是最好的确定并解决问题的方法。 Troubleshooting 中提供了一些指导，可以帮你学会这些方法。

2.3.2 常见的错误

有一些常见错误，仅靠显示的简单报错信息也很难解决。这些在 Common errors 中有具体说明。

2.4 如何阅读教程

这一节展示了如何高效阅读文档，并介绍了一些在线版本中有用的交互性特征。

2.4.1 忽略掉的内容

LilyPond 必须写在 { } 或 ‘relative { … }’ 中，正如 处理输入文件 中所说的。教程的后面部分，会涉及一些简短的例子，会忽略掉这种符号。如果你想复制这些例子的话，你可以直接复制这些例子，但需要把它们粘贴在 { 和 } 中。

{
  …example goes here…
}

当然，要记住每一个 LilyPond 文件都需要有 \version 声明。由于教程中的例子都是片段而非文件， \version 声明也忽略掉了。但你需要在实际使用中加上这个版本声明。

2.4.2 可以点开的例子

很多人学编程都是通过不断地尝试探索。学 LilyPond 也是一样的。如果你点击 HTML 版本教程的图片，你可以看到生成图片中例子所对应的原始的 LilyPond 输入。试试下面这个图像吧：

复制粘贴 "ly snippet" 部分的内容，得到的是一个用于实验的模板。如果想得到完全一样的输出结果（包括行距等等），就要复制粘贴 "Start cut-&-pastable section" 之后的全部内容。

2.4.3 手册概览

LilyPond 有很多文档。新用户可能有时候不知道应该阅读哪一部分，并且有时候会跳过重要的部分。

• 在做 任何事 之前：请阅读 Learning manual’s 教程 和 Common notation。如果你遇到了你不认识的音乐术语，请看 Glossary.
• 在写一段完整音乐之前：阅读学习教程的 Fundamental concepts。之后，你可能会想去看 Notation reference 部分的相关章节。
• 在改变默认输出之前：阅读学习教程 Tweaking output 部分。
• 在做大项目之前: 阅读用户手文档的 Suggestions for writing files 部分。

3. Common notation

This chapter explains how to create beautifully printed music containing common musical notation. For the most basic steps, see 教程.

3.1 Single staff notation

This section introduces common notation that is used for one voice on one staff.

3.1.1 Bar lines and bar checks

Bar lines

Single bar lines are automatically placed in the music so there is no need to add them manually. Other types of bar lines are added using \bar, for example \bar "||" for a double bar line, or \bar "|." for an ending bar line. For a full list of bar lines see Bar lines.

\relative { g'1 e1 \bar "||" c2. c'4 \bar "|." }

Bar checks

Though not strictly necessary, bar checks should be used in the input code to show where bar lines are expected to fall. They are entered using the bar symbol, ‘|’. With bar checks, the program can verify that you have input durations where each measure adds up to the correct length. Bar checks also make your input code easier to read, since they help keep things organized.

\relative {
  g'1 | e1 | c2. c' | g4 c g e | c4 r r2 |
}

If you compile the code in the example above, you should see a warning in the console output:

warning: barcheck failed at: 1/2
 g'1 | e1 | c2. c'
                   | g4 c g e | c4 r r2 |

Although the missing duration is clear in the musical output in this simple example, the warning in the console output is far more effective in drawing attention to the missing ‘4’ in bar 3.

参见

Notation Reference: Bar and bar number checks.

3.1.2 Pitches and key signatures

Pitch alterations

Music Glossary: sharp, flat, double sharp, double flat, accidental.

Note names in LilyPond identify pitches. For example, ‘c’ always means C-natural, regardless of the key signature.

In many languages, a note name consists of a base name referring to the diatonic steps of the C major/a minor scale (for example, ‘d’) and a suffix, which indicates alteration of this base pitch. The default input language for note names is ‘nederlands’ (Dutch). A sharp pitch is made by adding ‘is’ to the name, and a flat pitch by adding ‘es’. As you might expect, a double sharp or double flat is made by adding ‘isis’ or ‘eses’. This syntax is derived from note naming conventions in Nordic and Germanic languages, like German and Dutch. To use other naming schemes for note names, see Note names in other languages.

\relative { cis''4 ees fisis, aeses }

Key signatures

Music Glossary: key signature, major, minor.

The key signature is set with the command \key followed by a pitch and \major or \minor.

\relative {
  \key d \major
  d'4 fis a c |
  \bar "||" \key c \minor
  c,4 ees g b |
}

Warning: key signatures and pitches

Music Glossary: accidental, key signature, pitch, flat, natural, sharp, transposition, Pitch names.

LilyPond makes a distinction between musical content and its printed representation. Input such as ‘d4 e fis2’ defines the pitches and durations of notes, which is musical content. The key signature is part of the printed representation. The key signature also sets rules for the printed representations of notes. LilyPond compares each input pitch to the key signature to determine whether to print an accidental.

The command \key sets the key signature, which affects the printed representation, but does not change the pitch assigned to a note such as ‘c’ in the input.

Consider this example.

\relative {
  \key d \major
  cis''4 d e fis
}

No note has a printed accidental, but you must still add ‘is’ and type ‘cis’ and ‘fis’ in the input file.

The code ‘b’ does not mean “print a thick black dot just on the middle line of the staff”. Rather, it means “there is a note with pitch B-natural”. In the key of A-flat major, it does get an accidental:

\relative {
  \key aes \major
  aes'4 c b c
}

To say it differently: Whenever you enter a pitch that is a black key on the piano, you must add ‘is’ or ‘es’ to the note name.

Adding all alterations explicitly might require a little more effort when typing, but the advantage is that transposing is easier, and accidentals can be printed according to different conventions. For some examples of how accidentals can be printed according to different rules, see Automatic accidentals.

参见

Notation Reference: Note names in other languages, Accidentals, Automatic accidentals, Key signature.

3.1.3 Ties and slurs

Ties

Music Glossary: tie.

A tie is created by appending a tilde ‘~’ to the first of the two notes being tied.

\relative { g'4~ g c2~ | c4~ c8 a~ a2 | }

When the pitch does not change, as is always the case with tied notes, subsequent pitches may be omitted, specifying just the bare duration:

\relative { g'4~ 4 c2~ | 4~ 8 a~ 2 | }

This shorthand may be useful in other places where the rhythm changes with an unchanging pitch, but remember that a bare pitch followed by a space and a bare duration will be interpreted as a single note. In other words, ‘c4 a 8 8’ would be interpreted as ‘c4 a8 a8’, not as ‘c4 a4 a8 a8’. Write ‘c4 a4 8 8’ instead.

Slurs

Music Glossary: slur.

A slur is a curve drawn across many notes. The starting note and ending note are marked with ‘(’ and ‘)’, respectively. Note that ‘(’ comes after the first note of the slur.

\relative { d''4( c16) cis( d e c cis d) e( d4) }

Phrasing slurs

Music Glossary: slur, phrasing.

Slurs to indicate longer phrasing can be entered with \( and \). You can have both slurs and phrasing slurs at the same time.

\relative { g'4\( g8( a) b( c) b4\) }

Warnings: slurs vs. ties

Music Glossary: articulation, slur, tie.

A slur looks like a tie, but it has a different meaning. A tie simply makes the first note longer, and can only be used on pairs of notes with the same pitch. Slurs indicate the articulation of notes, and can be used on larger groups of notes. Slurs and ties can be nested.

\relative { c''4(~ c8 d~ 4 e) }

参见

Notation Reference: Ties, Slurs, Phrasing slurs.

3.1.4 Articulations and dynamics

Articulations and dynamics are indicated by adding special codes after the notes to which they apply.

Articulations

Music Glossary: articulation.

Common articulations can be added to a note using a dash (‘-’) and a single character.

\relative {
  c''4-^ c-+ c-- c-!
  c4-> c-. c2-_
}

Fingerings

Music Glossary: fingering.

Similarly, fingering indications can be added to a note using a dash (‘-’) and the digit to be printed:

\relative { c''4-3 e-5 b-2 a-1 }

Articulations and fingerings are usually placed automatically, but you can specify a direction by replacing the dash (‘-’) with ‘^’ (up) or ‘_’ (down). You can also use multiple articulations on the same note. However, in most cases it is best to let LilyPond determine the articulation directions.

\relative { c''4_-^1 d^. f^4_2-> e^-_+ }

Dynamics

Music Glossary: dynamics, crescendo, decrescendo.

Dynamic signs are made by adding the markings (with a backslash) to the note:

\relative { c''2\ff c\mf c\p c\pp }

Crescendi and decrescendi are started with the commands \< and \>. The next dynamics sign, for example \f, ends the (de)crescendo, or the command \! can be used:

\relative { c''2\< c | c4\ff\> c c c\! }

参见

Notation Reference: Articulations and ornamentations, Fingering instructions, Dynamics.

3.1.5 Adding text

Text may be added to your scores:

\relative { c''2^"espr" a_"legato" }

Extra formatting may be added with the \markup command:

\relative {
  c''2^\markup { \bold espr }
  a2_\markup {
    \dynamic f \italic \small { 2nd } \hspace #0.1 \dynamic p }
}

参见

Notation Reference: Writing text.

3.1.6 Automatic and manual beams

Music Glossary: beam.

All beams are drawn automatically:

\relative { a'8 ais d ees r d c16 b a8 }

If you do not like the automatic beams, they may be overridden manually. To correct just an occasional beam mark the first note to be beamed with ‘[’ and the last one with ‘]’. Note that ‘[’ comes after the first beamed note.

\relative { a'8[ ais] d[ ees r d] c16 b a8 }

If you want to turn off automatic beaming entirely or for an extended section of music, use the command \autoBeamOff to turn off automatic beaming and \autoBeamOn to turn it on again.

\relative {
  \autoBeamOff
  a'8 c b4 d8. c16 b4 |
  \autoBeamOn
  a8 c b4 d8. c16 b4 |
}

参见

Notation Reference: Automatic beams, Manual beams.

3.1.7 Advanced rhythmic commands

Partial measure

Music Glossary: anacrusis.

A pickup (or anacrusis) is entered with the keyword \partial. It is followed by a duration: ‘\partial 4’ is a quarter note pickup and ‘\partial 8’ an eighth note.

\relative {
  \partial 8 f''8 |
  c2 d |
}

Tuplets

Music Glossary: note value, triplet.

Tuplets are made with the \tuplet keyword. It takes two arguments: a fraction and a piece of music. The fraction is the number of tuplet notes over the number of notes normally filling the same duration. For triplets, there are three notes instead of two, so triplets have 3/2 as their fraction.

\relative {
  \tuplet 3/2 { f''8 g a }
  \tuplet 3/2 { c8 r c }
  \tuplet 3/2 { f,8 g16[ a g a] }
  \tuplet 3/2 { d4 a8 }
}

Grace notes

Music Glossary: grace notes, acciaccatura, appoggiatura.

Grace notes are created with the \grace command, although they can also be created by prefixing a music expression with the keyword \appoggiatura or \acciaccatura:

\relative {
  c''2 \grace { a32 b } c2 |
  c2 \appoggiatura b16 c2 |
  c2 \acciaccatura b16 c2 |
}

参见

Notation Reference: Grace notes, Tuplets, Upbeats.

3.2 Multiple notes at once

This section introduces notation having more than one note at the same time: multiple instruments, multiple staves for a single instrument (i.e., piano), and chords.

Polyphony in music refers to having more than one voice occurring in a piece of music. Polyphony in LilyPond refers to having more than one voice on the same staff.

3.2.1 Music expressions explained

In LilyPond input files, music is represented by music expressions. A single note is a music expression:

a'4

Enclosing music in braces creates a compound music expression. Here we have created a compound music expression with two notes:

\relative { a'4 g4 }

Putting a group of music expressions (e.g., notes) in braces means that they are in sequence (i.e., each one follows the previous one). The result is another music expression:

\relative { { a'4 g } f4 g }

Analogy: mathematical expressions

This mechanism is similar to mathematical formulas: a big formula is created by composing small formulas. Such formulas are called expressions, and they can contain other expressions, so you can make arbitrarily complex and large expressions. For example,

1
1 + 2
(1 + 2) * 3
((1 + 2) * 3) / (4 * 5)

This is a sequence of expressions, where each expression is contained in the next (larger) one. The simplest expressions are numbers, and larger ones are made by combining expressions with operators (like +, *, and /) and parentheses. Like mathematical expressions, music expressions can be nested arbitrarily deep, which is necessary for complex music like polyphonic scores.

Simultaneous music expressions: multiple staves

Music Glossary: polyphony.

This technique is useful for polyphonic music. To enter music with more voices or more staves, we combine expressions in parallel. To indicate that two voices should play at the same time, simply enter a simultaneous combination of music expressions. A ‘simultaneous’ music expression is formed by enclosing expressions inside << and >>. In the following example, three sequences (all containing two separate notes) are combined simultaneously:

<<
  \relative { a'2 g }
  \relative { f'2 e }
  \relative { d'2 b }
>>

Note that we have indented each level of the input with a different amount of space. LilyPond does not care how much (or little) space there is at the beginning of a line, but indenting LilyPond code like this makes it much easier for humans to read.

Simultaneous music expressions: single staff

To determine the number of staves in a piece, LilyPond looks at the beginning of the first expression. If there is a single note, there is one staff; if there is a simultaneous expression, there is more than one staff. The following example shows a complex expression, but as it begins with a single note it will be set out on a single staff.

\relative {
  c''2 <<c e>> |
  << { e2 f } { c2 <<b d>> } >> |
}

3.2.2 Multiple staves

LilyPond input files are constructed out of music expressions (see Music expressions explained). If the score begins with simultaneous music expressions, LilyPond creates multiples staves. However, it is easier to see what happens if we create each staff explicitly.

To print more than one staff, each piece of music that makes up a staff is marked by adding \new Staff before it. These Staff elements are then combined in parallel with << and >>:

<<
  \new Staff { \clef treble c''4 }
  \new Staff { \clef bass c4 }
>>

The command \new introduces a ‘notation context’. A notation context is an environment in which musical events (like notes or \clef commands) are interpreted. For simple pieces, such notation contexts are created automatically. For more complex pieces, it is best to mark contexts explicitly.

There are several types of contexts. Score, Staff, and Voice handle melodic notation, while Lyrics sets lyric texts and ChordNames prints chord names.

In terms of syntax, prepending \new to a music expression creates a bigger music expression. In this way it resembles the minus sign in mathematics. The formula (4+5) is an expression, so -(4+5) is a bigger expression.

Time signatures entered in one staff affect all other staves by default. On the other hand, the key signature of one staff does not affect other staves. This different default behavior is because scores with transposing instruments are more common than polyrhythmic scores.

<<
  \new Staff { \clef treble \key d \major \time 3/4 c''4 }
  \new Staff { \clef bass c4 }
>>

3.2.3 Staff groups

Music Glossary: brace, staff, system.

Piano music is typeset in two staves connected by a brace. Printing such a staff is similar to polyphonic music in multiple staves (see Multiple staves). However, now this entire expression is inserted into a PianoStaff:

\new PianoStaff <<
  \new Staff …
  \new Staff …
>>

Here is a small example.

\new PianoStaff <<
  \new Staff \relative { \time 2/4 c''4 e | g g, | }
  \new Staff \relative { \clef bass c4 c' | e c | }
>>

Other staff groupings are introduced with \new GrandStaff, suitable for orchestral scores, and \new ChoirStaff, suitable for vocal scores. These staff groups each form another type of context, one that generates the brace at the left side of every system and also controls the extent of bar lines.

参见

Notation Reference: Keyboard and other multi-staff instruments, Displaying staves.

3.2.4 Combining notes into chords

Music Glossary: chord.

We saw earlier how notes can be combined into chords: by enclosing them in double angle brackets we indicated that they are simultaneous. However, the normal way of producing a chord is to surround the pitches with single angle brackets. Note that all notes in a chord must have the same duration, and that the duration is placed after the closing bracket.

\relative { r4 <c'' e g> <c f a>2 }

Think of chords as almost equivalent to single notes: virtually everything you can attach to a single note can be attached to a chord, and usually these attachments must be put outside the angle brackets. For example, you can combine markings like beams and ties with chords.

\relative {
  r4 <c'' e g>~ <c f a>2 |
  <c e g>8[ <c f a> <c e g> <c f a>]
    <c e g>8\>[ <c f a> q q]\! |
  r4 <c e g>8.\p q16( q4-. <c f a>) |
}

The above example also demonstrates a very useful feature: a chord can be repeated by using the symbol ‘q’. This even works with interspersed single notes.

\relative { c'8 <e g>8 q q g, q q q }

参见

Notation Reference: Chorded notes.

3.2.5 Single staff polyphony

Polyphonic music in LilyPond, while not difficult, uses concepts that we have not discussed yet, so we are not going to introduce them here. Instead, the following sections establish the basics of these concepts and explain them thoroughly.

参见

Learning Manual: Voices contain music.

Notation Reference: Simultaneous notes.

3.3 Songs

This section introduces vocal music and simple song sheets.

3.3.1 Setting simple songs

Music Glossary: lyrics.

Here is the start of the melody to a nursery rhyme, Girls and boys come out to play.

\relative {
  \key g \major
  \time 6/8
  d''4 b8 c4 a8 | d4 b8 g4
}

The lyrics can be set to these notes, combining both with the \addlyrics keyword. Lyrics are entered by separating each syllable with a space.

<<
  \relative {
    \key g \major
    \time 6/8
    d''4 b8 c4 a8 | d4 b8 g4
  }
  \addlyrics {
    Girls and boys come out to play,
  }
>>

Note the double angle brackets << … >> around the whole piece to show that the music and lyrics are to occur at the same time.

3.3.2 Aligning lyrics to a melody

Music Glossary: melisma, extender line.

The next line in the nursery rhyme is The moon doth shine as bright as day. Let’s extend it:

<<
  \relative {
    \key g \major
    \time 6/8
    d''4 b8 c4 a8 | d4 b8 g4 g8 |
    a4 b8 c b a | d4 b8 g4. |
  }
  \addlyrics {
    Girls and boys come out to play,
    The moon doth shine as bright as day;
  }
>>

Looking at the music, we see that the extra lyrics do not align properly with the notes. The word shine should be sung on two notes, not one. This is called a melisma, a single syllable sung to more than one note. There are several ways to spread a syllable over multiple notes, the simplest being to add a slur across them. See Ties and slurs, for more information.

<<
  \relative {
    \key g \major
    \time 6/8
    d''4 b8 c4 a8 | d4 b8 g4 g8 |
    a4 b8 c( b) a | d4 b8 g4. |
  }
  \addlyrics {
    Girls and boys come out to play,
    The moon doth shine as bright as day;
  }
>>

The words now line up correctly with the notes, but the automatic beaming for the notes above shine as does not look right. We can correct this by inserting manual beaming commands to override the automatic beaming here. See Automatic and manual beams, for more information.

<<
  \relative {
    \key g \major
    \time 6/8
    d''4 b8 c4 a8 | d4 b8 g4 g8 |
    a4 b8 c([ b]) a | d4 b8 g4. |
  }
  \addlyrics {
    Girls and boys come out to play,
    The moon doth shine as bright as day;
  }
>>

As an alternative to using slurs, melismata may be indicated in just the lyrics by using an underscore ‘_’ for each note that should be included in the melisma.

<<
  \relative {
    \key g \major
    \time 6/8
    d''4 b8 c4 a8 | d4 b8 g4 g8 |
    a4 b8 c[ b] a | d4 b8 g4. |
  }
  \addlyrics {
    Girls and boys come out to play,
    The moon doth shine _ as bright as day;
  }
>>

If a syllable extends over several notes or a single very long note an extender line is usually drawn from the syllable extending under all the notes for that syllable. It is entered as two underscores (__). It is important that the underscores are separated with one or more spaces from the preceding (and following) syllable.

Here is an example from the first three bars of Dido’s Lament, from Purcell’s opera Dido and Æneas:

<<
  \relative {
    \key g \minor
    \time 3/2
    g'2 a bes | bes2( a) b2 |
    c4.( bes8 a4. g8 fis4.) g8 | fis1
  }
  \addlyrics {
    When I am laid,
    am laid __ in earth,
  }
>>

None of the examples so far have involved words containing more than one syllable. Such words are usually split one syllable to a note, with hyphens between syllables. Such hyphens are entered as two consecutive dashes (--), resulting in a centered hyphen between the syllables. It is important that the dashes are separated with one or more spaces from the preceding and following syllable.

Here is an example showing this and everything we have learned so far about aligning lyrics to notes.

<<
  \relative {
    \key g \major
    \time 3/4
    \partial 4
    d'4 | g4 g a8( b) | g4 g b8( c) |
    d4 d e | c2
  }
  \addlyrics {
    A -- way in a __ man -- ger,
    no __ crib for a bed,
  }
>>

Some lyrics, especially those in Italian, require the opposite: setting more than one syllable to a single note. This is achieved by linking the syllables together with a single underscore (‘_’, with no spaces), or enclosing them in quotes. Here is an example from Rossini’s opera Il barbiere di Siviglia, where al has to be sung on the same note as the go of Largo in Figaro’s aria Largo al factotum:

<<
  \relative {
    \clef bass
    \key c \major
    \time 6/8
    c'4.~ 8 d b | c8([ d]) b c d b | c8
  }
  \addlyrics {
    Lar -- go_al fac -- to -- tum del -- la cit -- tà
  }
>>

参见

Notation Reference: Vocal music.

3.3.3 Lyrics to multiple staves

The simple approach using \addlyrics can be used for placing lyrics under more than one staff. Here is an example from Handel’s oratorio Judas Maccabæus.

<<
  \relative {
    \key f \major
    \time 6/8
    \partial 8
    c''8 | c8([ bes]) a a([ g]) f | f'4. b, | c4.~ 4
  }
  \addlyrics {
    Let flee -- cy flocks the hills a -- dorn, __
  }
  \relative {
    \key f \major
    \time 6/8
    \partial 8
    r8 | r4. r4 c'8 | a'8([ g]) f f([ e]) d | e8([ d]) c bes'4
  }
  \addlyrics {
    Let flee -- cy flocks the hills a -- dorn,
  }
>>

Scores any more complex than this simple example are better produced by separating out the score structure from the notes and lyrics with variables. See Organizing pieces with variables, for an introduction.

参见

Notation Reference: Vocal music.

3.4 Final touches

This is the final section of the tutorial; it demonstrates how to add the final touches to simple pieces, and provides an introduction to the rest of the manual.

3.4.1 Organizing pieces with variables

When all of the elements discussed earlier are combined to produce larger files, the music expressions get a lot bigger. In polyphonic music with many staves, the input files can become very confusing. We can reduce this confusion by using variables.

With variables (also known as identifiers or macros), we can break up complex music expressions. A variable is assigned as follows:

namedMusic = { … }

The contents of the music expression namedMusic can be used later by placing a backslash in front of the name (\namedMusic), just like a normal LilyPond command.

violin = \new Staff {
  \relative {
    a'4 b c b
  }
}

cello = \new Staff {
  \relative {
    \clef bass
    e2 d
  }
}

{
  <<
    \violin
    \cello
  >>
}

By convention, variable names consist of alphabetic characters only. For detailed information, see File structure.

Variables must be defined before the main music expression, but may be used as many times as required anywhere after they have been defined. They may even be used in a later definition of another variable, giving a way of shortening the input if a section of music is repeated many times.

tripletA = \relative { \tuplet 3/2 { c'8 e g } }
barA = { \tripletA \tripletA \tripletA \tripletA }

{ \barA \barA }

Variables may be used for many other types of objects in the input. For example,

myWidth = 60      % a number to pass to a \paper variable
                  % (the unit is millimeter)
myName = "Wendy"  % a string to pass to a markup
aFivePaper = \paper { #(set-paper-size "a5") }

Depending on its contents, the variable can be used in different places. The following example uses the above variables:

\paper {
  \aFivePaper
  line-width = \myWidth
}

{
  c4^\myName
}

3.4.2 Adding titles

The title, composer, opus number, and similar information are entered in the \header block. This exists outside of the main music expression; the \header block is usually placed underneath the version number.

\version "2.24.4"

\header {
  title = "Symphony"
  composer = "Me"
  opus = "Op. 9"
}

{
  … music …
}

When the file is processed, the title and composer are printed above the music. More information on titling can be found in Creating titles headers and footers.

3.4.3 Absolute note names

So far we have used \relative to define pitches. This is usually the fastest way to enter most music. Without \relative, pitches are interpreted in absolute mode.

In this mode, LilyPond treats all pitches as absolute values: a ‘c'’ always means middle C, a ‘b’ always means the note one step below middle C, and a ‘g,’ always means the note on the bottom line of a staff with a bass clef.

{
  \clef bass
  c'4 b g, g, |
  g,4 f, f c' |
}

Writing a melody in the treble clef involves a lot of quote ‘'’ marks. Consider this fragment from Mozart:

{
  \key a \major
  \time 6/8
  cis''8. d''16 cis''8 e''4 e''8 |
  b'8. cis''16 b'8 d''4 d''8 |
}

Common octave marks can be indicated just once, using the command \fixed followed by a reference pitch:

\fixed c'' {
  \key a \major
  \time 6/8
  cis8. d16 cis8 e4 e8 |
  b,8. cis16 b,8 d4 d8 |
}

With \relative, the previous example needs no octave marks because this melody moves in steps no larger than three staff positions:

\relative {
  \key a \major
  \time 6/8
  cis''8. d16 cis8 e4 e8 |
  b8. cis16 b8 d4 d8 |
}

If you make a mistake with an octave mark (‘'’ or ‘,’) while working in \relative mode, it is very obvious – many notes will be in the wrong octave. When working in absolute mode, a single mistake will not be as visible, and will not be as easy to find.

However, absolute mode is useful for music with large intervals, and is extremely useful for computer-generated LilyPond files. When cutting and pasting melody fragments, absolute mode preserves the original octave.

Sometimes music is arranged in more complex ways. If you are using \relative inside of \relative, the outer and inner relative sections are independent:

\relative { c'4 \relative { f'' g } c }

To use absolute mode inside of \relative, put the absolute music inside \fixed c { … } and the absolute pitches will not affect the octaves of the relative music:

\relative {
  c'4 \fixed c { f'' g'' } c |
  c4 \fixed c'' { f g } c
}

3.4.4 After the tutorial

After finishing the tutorial, you should probably try writing a piece or two. Start by adding notes to one of the templates (see Templates). If you need any notation that was not covered in the tutorial, look at the Notation Reference, starting with Musical notation. If you want to write for an instrument ensemble that is not covered in the templates, see Extending the templates.

Once you have written a few short pieces, read the rest of the Learning Manual (chapters 3–5). There’s nothing wrong with reading it now, of course! However, the rest of the Learning Manual assumes that you are familiar with LilyPond input. You may wish to skim these chapters right now, and come back to them after you have more experience.

In this tutorial and in the rest of the Learning Manual, there is a paragraph See also at the end of each section, which contains cross references to other sections: you should not follow these cross references at first reading; when you have read all of the Learning Manual, you may want to read some sections again and follow cross references for further reading.

If you have not done so already, please read 手册概览. There is a lot of information about LilyPond, so newcomers often do not know where they should look for help. If you spend five minutes reading that section carefully, you might save yourself hours of frustration looking in the wrong places!

4. Fundamental concepts

You’ve seen in the Tutorial how to produce beautifully printed music from a simple text file. This section introduces the concepts and techniques required to produce equally beautiful but more complex scores.

4.1 How LilyPond input files work

The LilyPond input format is quite free-form, giving experienced users a lot of flexibility to structure their files however they wish. But this flexibility can make things confusing for new users. This section will explain some of this structure, but may gloss over some details in favor of simplicity. For a complete description of the input format, see File structure.

4.1.1 Introduction to the LilyPond file structure

A basic example of a LilyPond input file is

\version "2.24.4"

\header { }

\score {
   … compound music expression …   % all the music goes here!
  \layout { }
  \midi { }
}

There are many variations of this basic pattern, but this example serves as a useful starting place.

Up to this point none of the examples you have seen have used a \score{} command. This is because LilyPond automatically adds the extra commands which are needed when you give it simple input. LilyPond treats input like this:

\relative {
  c''4 a b c
}

as shorthand for this:

\book {
  \score {
    \new Staff {
      \new Voice {
        \relative {
          c''4 a b c
        }
      }
    }
    \layout { }
  }
}

In other words, if the input contains a single music expression, LilyPond will interpret the file as though the music expression was wrapped up inside the commands shown above.

A word of warning! Many of the examples in the LilyPond documentation will omit the \new Staff and \new Voice commands, leaving them to be created implicitly. For simple examples this works well, but for more complex examples, especially when additional commands are used, the implicit creation of contexts can give surprising results, maybe creating extra unwanted staves. The way to create contexts explicitly is explained in Contexts and engravers.

For now, though, let us return to the first example and examine the \score command, leaving the others to default.

A \score block must always contain exactly one music expression. Remember that a music expression could be anything from a single note to a huge compound expression like

{
  \new StaffGroup <<
     … insert the whole score of a Wagner opera in here … 
  >>
}

Since everything is inside { … }, it counts as one music expression.

As we saw previously, the \score block can contain other things, such as

\score {
  { c'4 a b c' }
  \header { }
  \layout { }
  \midi { }
}

Note that these three commands – \header, \layout and \midi – are special: unlike many other commands which begin with a backward slash (\) they are not music expressions and are not part of any music expression. So they may be placed inside a \score block or outside it. In fact, these commands are commonly placed outside the \score block – for example, \header is often placed above the \score command, as the example at the beginning of this section shows.

Two more commands you have not previously seen are \layout { } and \midi {}. If these appear as shown they will cause LilyPond to produce a printed output and a MIDI output respectively. They are described fully in the Notation Reference – Score layout, and Creating MIDI output.

You may code multiple \score blocks. Each will be treated as a separate score, but they will be all combined into a single output file. A \book command is not necessary – one will be implicitly created. However, if you would like separate output files from one ‘.ly’ file then the \book command should be used to separate the different sections: each \book block will produce a separate output file.

In summary:

Every \book block creates a separate output file (e.g., a PDF file). If you haven’t explicitly added one, LilyPond wraps your entire input code in a \book block implicitly.

Every \score block is a separate chunk of music within a \book block.

Every \layout block affects the \score or \book block in which it appears – i.e., a \layout block inside a \score block affects only that \score block, but a \layout block outside of a \score block (and thus in a \book block, either explicitly or implicitly) will affect every \score in that \book.

For details see Multiple scores in a book.

Another great shorthand is the ability to define variables, as shown in Organizing pieces with variables. All the templates use this:

melody = \relative {
  c'4 a b c
}

\score {
  \melody
}

When LilyPond looks at this file, it takes the value of melody (everything after the equals sign) and inserts it whenever it sees \melody. There’s nothing special about the name – it could be melody, global, keyTime, pianorighthand, or something else. Remember that you can use almost any name you like as long as it contains just alphabetic characters and is distinct from LilyPond command names. For more details, see Saving typing with variables and functions. The exact limitations on variable names are detailed in File structure.

参见

For a complete definition of the input format, see File structure.

4.1.2 Score is a (single) compound musical expression

We saw the general organization of LilyPond input files in the previous section, Introduction to the LilyPond file structure. But we seemed to skip over the most important part: how do we figure out what to write after \score?

We didn’t skip over it at all. The big mystery is simply that there is no mystery. This line explains it all:

A \score block must contain exactly one music expression.

To understand what is meant by a music expression, you may find it useful to review the tutorial, Music expressions explained. In that section, we saw how to build big music expressions from small pieces – we started from notes, then chords, etc. Now we’re going to start from a big music expression and work our way down. For simplicity, we’ll use just a singer and piano in our example. We don’t need a StaffGroup for this ensemble, which simply groups a number of staves together with a bracket at the left, but we do need staves for a singer and a piano, though.

\score {
  <<
    \new Staff = "singer" <<
    >>
    \new PianoStaff = "piano" <<
    >>
  >>
  \layout { }
}

Here we have given names to the staves – “singer” and “piano”. This is not essential here, but it is a useful habit to cultivate so that you can see at a glance what each stave is for.

Remember that we use << … >> instead of { … } to show simultaneous music. This causes the vocal part and piano part to appear one above the other in the score. The << … >> construct would not be necessary for the Singer staff in the example above if it were going to contain only one sequential music expression, but << … >> rather than braces is necessary if the music in the Staff is to contain two or more simultaneous expressions, e.g., two simultaneous Voices, or a Voice with lyrics. We’re going to have a voice with lyrics, so angle brackets are required. We’ll add some real music later; for now let’s just put in some dummy notes and lyrics. If you’ve forgotten how to add lyrics you may wish to review \addlyrics in Setting simple songs.

\score {
  <<
    \new Staff = "singer" <<
      \new Voice = "vocal" { c'1 }
      \addlyrics { And }
    >>
    \new PianoStaff = "piano" <<
      \new Staff = "upper" { c'1 }
      \new Staff = "lower" { c'1 }
    >>
  >>
  \layout { }
}

Now we have a lot more details. We have the singer’s staff: it contains a Voice (in LilyPond, this term refers to a set of notes, not necessarily vocal notes – for example, a violin generally plays one voice) and some lyrics. We also have a piano staff: it contains an upper staff (right hand) and a lower staff (left hand), although the lower staff has yet to be given a bass clef.

At this stage, we could start filling in notes. Inside the curly braces next to \new Voice = "vocal", we could start writing

\relative {
  r4 d''8\noBeam g, c4 r
}

But if we did that, the \score section would get pretty long, and it would be harder to understand what was happening. So let’s use variables instead. These were introduced at the end of the previous section, remember? To ensure the contents of the text variable are interpreted as lyrics we preface them with \lyricmode. Like \addlyrics, this switches the input mode to lyrics. Without that, LilyPond would try to interpret the contents as notes, which would generate errors. (Several other input modes are available, see Input modes.)

So, adding a few notes and a bass clef for the left hand, we now have a piece of real music:

melody = \relative { r4 d''8\noBeam g, c4 r }
text   = \lyricmode { And God said, }
upper  = \relative { <g' d g,>2~ <g d g,> }
lower  = \relative { b,2 e }

\score {
  <<
    \new Staff = "singer" <<
      \new Voice = "vocal" { \melody }
      \addlyrics { \text }
    >>
    \new PianoStaff = "piano" <<
      \new Staff = "upper" { \upper }
      \new Staff = "lower" {
        \clef "bass"
        \lower
      }
    >>
  >>
  \layout { }
}

When writing (or reading) a \score section, just take it slowly and carefully. Start with the outer level, then work on each smaller level. It also really helps to be strict with indentation – make sure that each item on the same level starts on the same horizontal position in your text editor.

参见

Notation Reference: Structure of a score.

4.1.3 Nesting music expressions

It is not essential to declare all staves at the beginning; they may be introduced temporarily at any point. This is particularly useful for creating ossia sections – see ossia. Here is a simple example showing how to introduce a new staff temporarily for the duration of three notes:

\new Staff {
  \relative {
    r4 g'8 g c4 c8 d |
    e4 r8
    <<
      { f8 c c }
      \new Staff {
        f8 f c
      }
    >>
    r4 |
  }
}

Note that the size of the clef is the same as a clef printed following a clef change – slightly smaller than the clef at the beginning of the line. This is usual for clefs printed in the middle of a line.

The ossia section may be placed above the staff as follows:

\new Staff = "main" {
  \relative {
    r4 g'8 g c4 c8 d |
    e4 r8
    <<
      { f8 c c }
      \new Staff \with {
        alignAboveContext = "main"
      } { f8 f c }
    >>
    r4 |
  }
}

This example uses \with, which will be explained more fully later. It is a means of modifying the default behavior of a single Staff. Here it says that the new staff should be placed above the staff called “main” instead of the default position which is below.

参见

Ossia are often written without clef and without time signature and are usually in a smaller font. These require further commands which have not yet been introduced. See Size of objects, and Ossia staves.

4.1.4 Structure of a note entry

A note entry in LilyPond consists of a pitch, followed by a duration, optionally followed by one or more ‘post-events’. LilyPond post-events add things such as articulations, fingerings, string numbers, slurs, ties and explanatory text.

The pitch may be explicitly defined using the current LilyPond input language as described in Note names in other languages. The pitch may be omitted. If the pitch is omitted, the pitch of a current note will be the same as the pitch of the previous note in the input file, see Durations. Note that neither r nor s is a pitch.

The duration includes a number and optionally one or more dots. If a duration is not explicitly defined, the duration of a current note will be the same as the duration of the previous note, chord, rest, or spacer rest, see Durations.

Post-events follow the note to which they are attached. Suppose we want to have an eighth note c’ with a fingering of 1, a tenuto articulation, a slur beginning with the note, a tie beginning with the note, and a text annotation. This can be accomplished as shown.

{ c'8-1--(~^\markup{"text annotation"} c' d') }

参见

Learning Manual: Ties and slurs, Articulations and dynamics, Adding text.

Notation Reference: Pitches, Rhythms, Expressive marks.

4.1.5 On the un-nestedness of brackets and ties

You have already met a number of different types of bracket and bracket-like constructs in writing the input file to LilyPond. These obey different rules which can be confusing at first. Let’s first review the different types of brackets and bracket-like constructs.

To these we should add other constructs which generate lines between or across notes: ties (marked by a tilde, ~), tuplets written as \tuplet x/y { … }, and grace notes written as \grace { … }.

Outside LilyPond, the conventional use of brackets requires the different types to be properly nested, like this, << [ { ( … ) } ] >>, with the closing brackets being encountered in exactly the opposite order to the opening brackets. This is a requirement for the three types of bracket described by the word ‘Encloses’ in the table above – they must nest properly. However, the remaining bracket-like constructs, described with the word ‘Marks’ in the table above together with ties and tuplets, do not have to nest properly with any of the brackets or bracket-like constructs. In fact, these are not brackets in the sense that they enclose something – they are simply markers to indicate where something starts and ends.

So, for example, a phrasing slur can start before a manually inserted beam and end before the end of the beam – not very musical, perhaps, but possible:

\relative { g'8\( a b[ c b\) a] g4 }

In general, different kinds of brackets, bracket-like constructs, and those implied by tuplets, ties and grace notes, may be mixed freely. This example shows a beam extending into a tuplet (line 1), a slur extending into a tuplet (line 2), a beam and a slur extending into a tuplet, a tie crossing two tuplets, and a phrasing slur extending out of a tuplet (lines 3 and 4).

\relative {
  r16[ g' \tuplet 3/2 { r16 e'8] }
  g,16( a \tuplet 3/2 { b16 d) e }
  g,8[( a \tuplet 3/2 { b8 d) e~] } |
  \tuplet 5/4 { e32\( a, b d e } a4.\)
}

4.2 Voices contain music

Singers need voices to sing, and so does LilyPond. The actual music for all instruments in a score is contained in Voices – the most fundamental of all LilyPond’s concepts.

4.2.1 I’m hearing Voices

The lowest, most fundamental or innermost layers in a LilyPond score are called ‘Voice contexts’ or just ‘Voices’ for short. Voices are sometimes called ‘layers’ in other notation packages.

In fact, a Voice layer or context is the only one which can contain music. If a Voice context is not explicitly declared one is created automatically, as we saw at the beginning of this chapter. Some instruments such as an Oboe can play only one note at a time. Music written for such instruments requires just a single voice. Instruments which can play more than one note at a time like the piano will often require multiple voices to encode the different concurrent notes and rhythms they are capable of playing.

A single voice can contain many notes in a chord, of course, so when exactly are multiple voices needed? Look first at this example of four chords:

\relative {
  \key g \major
  <d' g>4 <d fis> <d a'> <d g>
}

This can be expressed using just the single angle bracket chord symbols, < … >, and for this just a single voice is needed. But suppose the F-sharp were actually an eighth-note followed by an eighth-note G, a passing note on the way to the A? Now we have two notes which start at the same time but have different durations: the quarter-note D and the eighth-note F-sharp. How are these to be coded? They cannot be written as a chord because all the notes in a chord must have the same duration. And they cannot be written as two sequential notes as they need to start at the same time. This is when two voices are required.

Let us see how this is done in LilyPond input syntax.

The easiest way to enter fragments with more than one voice on a staff is to enter each voice as a sequence (with { … }), and combine them simultaneously with angle brackets, << … >>. The fragments must also be separated with double backward slashes, \\, to place them in separate voices. Without these, the notes would be entered into a single voice, which would usually cause errors. This technique is particularly suited to pieces of music which are largely homophonic with occasional short sections of polyphony.

Here’s how we split the chords above into two voices and add both the passing note and a slur:

\relative {
  \key g \major
  %    Voice = "1"             Voice = "2"
  << { g'4 fis8( g) a4 g } \\ { d4 d d d }  >>
}

Notice how the stems of the second voice now point down.

Here’s another simple example:

\relative {
  \key d \minor
  %    Voice = "1"           Voice = "2"
  << { r4 g' g4. a8 }   \\ { d,2 d4 g }       >> |
  << { bes4 bes c bes } \\ { g4 g g8( a) g4 } >> |
  << { a2. r4 }         \\ { fis2. s4 }       >> |
}