36C3 Wikipaka WG: LilyPond: programming beautiful musical scores

36C3 preroll music

Herald: Welcome back to the WikipakaWG,

live from Congress, wir haben Lucas da,
Lucas is back, Lucas was just here 15

minutes ago, and now he's going to talk
about LilyPond. LilyPond is like LaTeX but

for music notes and I hope you will have
fun!

Lucas: Yeah. Thank you. Yeah, so I just
want to talk a bit about LilyPond, which

is a really cool program, in my opinion,
to turn basically plain text input, such

as the code you can see up here, into
beautifully typeset musical scores, such

as down here, and that's actually the
result of this code up here, so you can

try to find what belongs to what or
something. And, yeah, it’s free software

obviously, it takes plain text as input,
which means you can put the code in a git

repository and add comments and stuff,
it's all very nice, the output is PDF, or

MIDI if you want to listen back to it, or
you can even integrate it into LaTeX or

Texinfo documents, such as these slides,
which are created with LaTeX beamer and

LilyPond in them, which is really funny
combination and it works perfectly well.

So let's just start with some of the
syntax elements in a LilyPond file, and

it's pretty straightforward to make a note
with a certain note name, you write that

note name, so this is (I think) the
American note names, I'm not sure if the

English ones use different ones, but
ABCDEFGA are the note names, and you write

the letter and you get a note in return,
and the relative mode here means that each

note is going to be as close as possible
to the previous one, for example this A

here at the beginning and the one at the
end, that's the same input, but you can

see they resulted in different notes, so
this is one octave higher than the

original one, because that's the note
that's closest to the preceding note, and

to control the duration of a note, you put
a number after it, for example this is a

quarter note, so you put a number four
after it, this is a sixteenth note, so you

put a sixteen after it, and if it's a
dotted note, such like this one, you put a

literal dot after it. So there's a fair
bit of ASCII art in there, which is kind

of cute, and if it's more complicated,
like the triplets here at the end, you

write something like this \tuplet, so
that's kind of inspired by LaTeX syntax,

this backslashes and braces business, so
this started out, actually, as a – I

assume horrible – hack to make actually
LaTeX produce these scores, and then

eventually they realized that's not going
to work, we should actually write this as

a dedicated program in C or C++ (I don't
remember which one), but the syntax kind

of stayed similar, at least, in
remembrance of that. And let's go back to

a bit more syntax, as I said, in relative
mode the notes try to stay close together,

for example if I would just write C after
this G, it would be the upper C up here,

because that's closer than the lower C
down here, and to get the lower C, which

is correct in this melody (if you can
identify it that's an Easter Egg for you),

I put a comma after it, and to then jump
back to the upper G instead of the lower

one, I put an apostrophe after it, which
depending on the font – in this one it

works really well, it's kind of the same
character, just at the bottom and at the

top the line. In German the apostrophe is
also sometimes called the Hochkomma, the

upper comma, so it kind of makes sense
that you have these two characters to jump

up and down between octaves, and then you
start to get a feel eventually when you

need them and when you don't need them.
But otherwise you can just compile your

LilyPond code as often as you want and see
if it's right or not, because it doesn't

take that long. And if you need to modify
the notes further, so if you have flat or

sharp notes, you can teach LilyPond to
understand “G sharp”, for example, but no

one will understand your score, because
the standard notation in LilyPond is to

add either an -is or an -es to the end of
the note, which is exactly what these

notes are called in German, which is very
convenient if you're German, like me – the

manual says it's Dutch notation or
something – so fis means the F sharp, but

what's important is, this doesn't
literally mean: put an F and then put a

sharp right in front of it, it means,
logically, in the music, there's an F

sharp, but then LilyPond can look, for
example here it just puts an F, because

the F sharp is already part of the key
signature, this whole snippet is in B

minor, so it has to have… no, it's in E
minor, sorry, so it has to have F sharp

already and we don't need to put one here.
On the other hand, here we have an F, and

in the syntax, in the input that's just an
F, but then LilyPond knows, because the

key signature has an F sharp, it actually
needs to put a natural sign here to cancel

that out. So what you put in is kind of
the logical, real music, so to speak, and

then it's LilyPond’s job to figure out,
where do I need to put these accidentals,

where do I need to put these natural
signs, and this depends even on which

century’s style you're trying to emulate
and which instrument, like sometimes these

things are in parentheses and sometimes
they're not, but in general all of this is

LilyPond’s job, you put in just the music
and LilyPond makes a beautiful score for

you, that's the job, at least. If that
doesn't work out, you can tweak the

output, and here I have some… a bit
sillier tweaks, for example I wanted a

larger note head, for some reason, and the
note head is a character in a special font

which LilyPond ships and embeds in this
PDF file, and if I say, I would like to

add 4 to the font size, then I get a
larger note head, at least for this one

note. Or I can say I would like the color
of all the note heads to be in dark red

now, or this tie, which would normally be
downwards, like this one, it should now go

upwards, because I've overridden it here,
and I can even say – so this tie is

actually a cubic Bezier curve, so it's
going to have four control points, and I

would like to add these four pairs of
offsets to the four control points, to

make this kind of looping shape – that's
obviously very silly, but sometimes this

can be useful, like if you have a score
where you have a long… articulation bow

(I'm not sure what it's called in English,
actually), but this kind of thing over a

long period of notes, where it makes like
a Z shape or an S shape, and LilyPond

can't figure that out by itself, then you
can tell it, I would like the curve to

look exactly like this, and kind of tweak
the output as much as you want. And you

can actually go even further than this –
does anyone in the audience recognize this

kind of syntax here? This kind of –
(audience member: Lisp!) Yes! Lisp, it is

a dialect of Lisp called Scheme, so you
can embed whole Scheme programs in your

score, so here I've said the color of each
stem should be controlled by this lambda,

this anonymous function, which takes a
graphical object, in this case that's

going to be the stem, and compare the
direction of that to “up”, if it's “up”,

then return red, otherwise return blue, so
now I have a score where all the stems are

blue if they point down and red if they
point up, which is completely pointless,

but it's very funny. And you can go much
further than this, like, this is some

monstrosity I wrote because I wanted to
have this score, where you can see, in the

right hand, here, you have the same notes
twice, once in the baseline and then one

octave higher, and it's just always one
octave higher, and for some reason I could

not be bothered to actually add the second
note to each of the eight chords here,

which would have taken, like, two minutes
at most, and instead I spent, like, one

and a half hours putting together this
code, which takes an arbitrary melody and

goes through it and for each note creates
a copied note which is somewhere here,

yeah, it creates a copy of the note, then
sets the pitch to something else and

copies some of the articulations but not
others, so this has a second tie here but

it should not have a second fermata sign,
and in the end you have this function and

you can even put it on StackOverflow or
something, and that kind of represents

what I really like about LilyPond, that it
represents this whole spectrum between

just simple music transcription and full-
blown programming, so if I get home at the

end of the day, and I'm really tired and
don't have much mental capacity, I can

just take some public domain score and
transcribe it and just say, this is a D,

this is an F sharp, this is a quarter
note, and so on, and it doesn't take much

work, but if I want, if I feel up to it or
if I want to have some fun, then I can

also do the whole programming thing and
write monsters like this and completely

bend the score to my will, make it look
exactly how I want to, and that's what I

find really neat about LilyPond, and if
you want to find out more about that,

there are two manuals here, they're really
well written, I basically read them front

to back a while ago, and they have lots of
examples as well. The LilyPond snippet

repository is even cooler, it's just a
huge collection of tiny snippets of

LilyPond code, and all of them are CC0, so
you can use them however you want without

worrying about attribution or anything,
and you can even try it out in your

browser, on lilybin.com, without
installing anything, and if you're

wondering, “wait, doesn't that mean I'm
running arbitrary code on someone else's

computer?” – it's not my computer,… I
don't know, knock yourself out, I guess,

but that's all I have already, I'm out of
time, but thank you for indulging me!

applause

postroll music

Subtitles created by c3subtitles.de
in the year 2020. Join, and help us!