The Ticklish Guide To LilyPondby Joshua Nichols

Contents

The Ticklish Guide Introduction

The Alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Why Another Guide? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

What is LilyPond? What to Expect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Lets Begin! Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Skeletal Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Language of Music . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Plausible Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Other Assumptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Finding Agreement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Putting Muscle on Skeleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The \score Block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rules of Thumb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Other Blocks Essential to the File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A Brief Philosophizing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The \relative Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

(More) Advanced Notation Keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clef & Clef Changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Time Signatures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tempo Markings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rhythm, Rests, and the Like . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Rhythm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Accidentals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Augmentation Dot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Articulations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Slurs and Ties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hairpins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Spanners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Dynamics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

i

Miscellaneous Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Beaming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cadenza Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bars (Barlines and Bar Checks) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fingerings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Markups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tuplets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chords . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Partial Measures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bar Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Conclusion

Post Script

Appendix Dierent Views of Content Authoring

Main Examples Basic Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Answers ToMain Examples Basic Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Real Life Example

ii

AbstractIn the world of computers and programs related to creating printed materials, the way that most of

the world operates is in a program (or paradigm) that is identied as a . This kind of programoperates like this: you enter the information you wish to have displayed on the page into the computer,and then before printing it, you format the page (via a computer screen) to reect what youwant to haveexactly. What you see on the screen is what you will get on the printed page. Though most programson a computer deal almost exclusively this way, this is by no means the only way you can work in acomputer. The alternative, the , addresses things completely dierently.

Instead of what you see is what you get, you start by creating a le called an input le or sourcele (usually plain text) that contains commands and information that do not appear on the printedpage. What actually happens next is an automatic compiling engine interprets that le for you andproduces a new le that is the le you print. This secondary le depicts what you reallymean to see onthe printed page. That is why they call it what you see is what you mean, because you actually dontsee the nished product in the input le, but in a secondary le with everything formatted the way youintend it to be formatted. actually have a source le that you never see; you communicate toit and essentially write it by using the . LilyPond is a program that produces high-qualitytypeset music. It is also an open-source program rather than a proprietary program.

The Ticklish GuideIntroductionLilyPond is an incredible and immensely powerful tool for composers and engravers. It originally beganas a joint venture between two musicians who honestly felt mainline scoring applications were loweringthe standards of music notation. They believed in the fundamental principles of readability and notationdone right the rst time.

Unfortunately, in an agewhere the proliferation of editors and instant-gratication comput-ing are widespread and the normative standard of doing things, LilyPond has a slight disadvantage. Thebasic syntax of this typesetting engine is plain text.

This is one of the rst complaints by those who are switching to LilyPond and rightly so! The click-and-drag feature of countless computing programs has made the computer accessible to the regular user.Companies have been built upon the idea that you can get instant results. This raises some importantreasons for this type of program. The rst is that a program that uses a gives you instantfeedback, whereby you can make any number of minute changes in the layout, coloring, or sensibilitiesof the document or le. The other main reason that people cite in favor of this approach is the ability tocheck for errors on-the-y, whereby the user is constantly able to preempt an error in the le.

To be truthful, is the only viable option for graphics-related projects (such as posters or il-lustration) because those things are by denition required to be adjusted at a moment by moment basis.Unfortunately, there are many reasons why editors are inecient and time consuming. To lista few:

. When it comes to workow, a actually distracts the user from being creative or focused.This is because everything the user does is being minutely changed on amoment-by-moment basis

What You See Is What You GetWhat You See Is What You MeanThe Graphical User Interface is the menus, icons, and point-and-click features of a program.Proprietary programs are closed-source,meaning that you cannotmodify ormanipulate the programs coding. This is necessary

for for-prot businesses whomakemoney o of their programs; this allows them tomaintain secrecy and to attempt to have controlover the market. Open source is a paradigm which releases its code to be free and open to the public for editing and distribution,and it is inherently non-prot.

Say, for example, Adobes infamous Creative Suite, Microsofts Oce Suite, or MakeMusics Finale notation software

within the program, and it is always calling the attention of the user to respond (even when he orshe is not looking to do so). This stunts workow and ultimately makes the creative process moredicult to achieve.

. Proprietary software (that is, license-based user software) does not allow you to modify the sourcele or the program itself; it only allows you to use both. You dont actually purchase the program,you merely pay a right or license to use it. This means that, if you happen to think of a featurethat you would like to have, then you dont have any viable means of getting it into the programwithout violating software agreements or spending a lot of money to pay for the right tomodify theprogram.

. While proprietary software usually includes same-version enhancements and bug xes, the user isusually constrained to paying new licensing fees for major version changes.

. In the case of proprietary software, if the company goes out of business, or takes a major shift inpriorities, you are still bound by the whim of the company. This means that, practically, you arelost in the dark if and when a company goes under.

. almost always utilizes proprietary data formats in the source le. What this basicallymeans is that the le itself is protected by a language which only the program can understand, andit takes quite some time to decode/debug these les so that other programs can read them. Thispractically relates to the real world: if I wish to send a document format that can only be read by,lets say, a program called Macrosoft Oce Desk, and if the person I am sending it to does not havethat program or a highly proprietary means of decoding that source le, I am are out of luck.

. Proprietary data formats are also more easily corruptible and more dicult to recover in the eventof a computer crash. This means that if for any reason your computer crashes or the software fails for whatever reason, then unless the auto-save features (if any) are working in backing up lesat the crucial moment where that bit of data you need is so important, then it renders the leuseless, and you have to recover ground. This is quite annoying for a regular text document, butimagine losing all of that information in a Finale or Sibelius le, where you might have made someserious changes to the music that, unfortunately, cannot be recovered.

. Proprietary data formats are also strenuous on le sizes. A several-hundred-page score of a workwith dense notation could absorb as much as several-hundred megabytes. This is also impracticalbecause most emailing systems only accept an average of megabyte le sizes.

. In the case of workow, version control is nearly impossible, since the details of a score or le arehidden within the proprietary formatting.

. Proprietary data formats also make it nearly impossible to maintain source transparency. What ismeant by this? This means that its hard to retrieve statistical data and meta-data about the le

For instance, in Finale, the software automatically lls in the remaining unused beats of a measure for you with rests. Thishinders composition because your mind has been called to focus on the remaining beats of the measure, rather than focusing onthe composition itself. This perhaps is more apparent in word processors like Microsoft Word which deal directly with formattingas you type. What you see is your formatting, which is always calling your attention in the moment of said formatting. If youare typing a paragraph, for instance, and you notice that your word spacing is a little o (because the programs default behaviorshows you what it would look like on print), then you become distracted from actually writing, which is the intention of using theprogram. You can see this eect easily: try typing in a text editor (such as WordPad on Windows) and type like that for a couple ofweeks without using your favorite word processing program. You will surely nd productivity and content increase.

A bug is anything from a major to a minor glitch that aects the usability and stability of the program. Every program goesthrough many changes to keep bugs to a minimum.

For instance, if you had Sibelius , you would be entitled to all the bug xes and enhancements for that version, but you wouldhave to buy an upgraded license in order to use Sibelius .

Though, it is far less likely in todays computer, but still a problem, nonetheless.or managing on a transparent level the changes a le goes through

in any real and understandable way. The formatting and scoring of the programs proprietarydata format make it nearly impossible to extract critical data of and pertaining to the stu ofthe le; this is most easily seen in viewing native .doc and .docx les in an open-source wordprocessor. Generally speaking, the formatting and page styles are skewed in some way, making itdicult to understand what the intentions of the author were. This also applies to editing acrossseveral versions of the same program. Microsoft does not readily and easily transcribe the leformats of a Microsoft document le.

. Finally, applications are rarely fully featured. This is because the proprietors have tomakedecisions about what to include and exclude from the menus and shortcuts of the in order tomake it learnable for the most amount of potential clientele. Programs that are fully featured arerarely easy to learn, and the systems are usually archaic and thus only benecial to those who havebeen part of the software experience for a long time.

Most people implicitly accept these shortcomings (with exception to le risks and proprietary risks), andwalk a tight line between being fed up and satised with their user experience. It could also generallyapply that % of the users use only % of the features, and vise versa.

The AlternativeWhen it comes to alternatives, there is the system of formatting. This simplies workow andallows the user to make adjustments only when the end product doesnt meet their expectations. - also adopts the practice of handling the formatting, layout, and stylings of your le (which can bemanipulated). Products that oer a plethora of formatting options do not help the user to make pro-fessional and informed decisions. oers a user experience that simplies workow and givesthe user the opportunity to breathe their creativity, while correctly formatting their content behind thescenes to adopted standards within the scope of the program.

In addition, there is the plain text format. This method of content storage stores all the informationof a le in a plain text le (which can be edited by any text editor), and it is translated by the compiler orprogram in charge of transcribing the data. There are many advantages to organizing data this way, a fewbeing:

. Plain text les are more easily recovered in the event of a crash. Because the le is not dependenton proprietary formatting, you only lose what you didnt save, or if it is somehow corrupted, youcan at least extract information leading up to the time of the crash.

. File sizes are signicantly smaller. A proprietary le format is anywhere between - timeslarger than a plain text le of the same information.

. One hundred percent of the input le is meta-data. Styling of the information is transparent inthe input le. Even if someone does not have the compiler to produce the nished product of the

Proprietary data formats are basically encrypted les, les that use a secret language to communicate with the native . Thisis another reason why it is dicult to understand proprietary formats with programs that cannot natively understand it.

Truly, this can be a touchy subject. Many people who talk about switching to another program often lament because, frankly,they dont believe that they have the time to learn it correctly. They feel as though theyve done as much as they can with theircurrent program and have gained a thorough understanding of it. Frankly, however, this is a bit of a farce, considering most peopledont actually have a functioning knowledge of programs like Finale and Sibelius; they think that they have a functioning knowledgeof the program. This is because the menus and options give the illusion that you have that knowledge, that you are in control. Thetruth, in reality, is that we dont know the program as much as we think. This has been discussed at length in internet forums andprofessional papers when speaking about the dierences between Microsoft Word and LATEX and other related typesetting engines(TEX, XeLATEX, and LYX).

Meta-data is the part of an input le that corresponds directly to something that shows up on the printed page. For example, ifyou look at themusical note middle-c on a printed page, that note corresponds directly to a place in the input le where middle-cappears as a command. In LilyPond, everything in the input le is meta-data. However, there is a sort of u that accompaniesmost proprietary input les. It is information that is neither necessary nor directly important to the printed page; it is notmeta-dataitself but exists in addition to the meta-data. It is usually garbled and jumbled data bits (not plain text) which can only be read and

le you sent them, they can still read and parse the information on ameta-level. Also, the constantneed to create the desired format and style is signicantly reduced, if not totally eradicated.

. Plain text allows the corruptible elements found patently in s to be nearly absolved, themost critical being workow. When one is not consumed by the constant nagging of a sconstant updating of style and format, the user can focus on data production, which leads to greaterand more responsive creativity.

Why Another Guide?LilyPond utilizes the plain text workow and approach to input. Though the discussion of whyone should switch to plain text workow and editors should be clear, the challenge of switching(especially if one is a hardcore user) is still daunting and fuzzy.

LilyPond has some of themost incredible and comprehensive documentation I have ever seenwhen itcomes to open-source programs. Indeed, one should not see this even gentler introduction as a replace-ment for the documentation; on the contrary, this should be a baby language tutorial for those who seea document like the Learning Manual on LilyPonds website as a little too much too quickly.

This guide should also serve as a fundamentals interaction. The documentation, though compre-hensive and far better suited for learning, does miss the mark on explaining some of the reasons whycertain things are done.

Nevertheless, if you have found your way to this document, then you are probably searching for a wayto transition without overloading your brain. My intentions (as a former hardcore user) are foryou to get what I didnt get several years ago.

What is LilyPond?Like I have said before in the Abstract, LilyPond does not have a typical , and it is unlike any otherprogram you may be familiar with. Microsoft Word formats the text on the screen to reect the printedpage exactly. LilyPond is the exact opposite: you write plain text information into a le that the programunderstands, and instead of what you see on the screen being what prints out, the compiler converts thatinformation in the plain text le into a new le that depicts exactly what will print. LilyPond is an enginewhich translates bytes of data into formatted music. The output of the music is to PDF (via PostScript)which is the universally recognized le format for the transferring and archiving of documents and otherthings. Most all computers can read and print PDFles. The software for viewing PDFs is readily available(most people already have it on their computer) and takes up an extremely small amount of computer harddrive space.

In addition, LilyPond, though not a proprietary formatting system, does utilize jargon and variousscripts to simplify the output process. The compiler itself contains millions of lines of code, all corre-sponding to processes that, like a cell in the human body, only respond when called for by the source le.This simplies the workload on the computer and allows the engine to utilize minimal RAM and comput-ing space. This also makes the program lightweight, with the actual bulk of the program being containedin les which correspond to fonts and graphical drawing systems. The rest of the code are the pathwayswhich initialize when called upon by the source le through the compiler.

This is important for the understanding of the program because there are certain boundaries aroundwhat one can and cannot do with an input le. One of the things that the input le must contain forLilyPond is a version statement. The version statement is required because it helps the compiler to realizewhat form of the input language you are using.

The input language is also very precise. There are, however, some helpful tips about the program:interpreted by the particular program to which that the le corresponds. (It usually contains information such as bookmarks in thele, etc.) See Dierent Views of Content Authoring in the Appendix.

. It is not a space-sensitive le format. It does not require that a certain amount of spaces be presentin the syntax in order to produce the same output as another example.

. Errors are generated in a terminal or separate compiling screen which indicate where a fatal errorhas occurred within the le, or where cautionary messages advise on the status of the compiler.

. Syntax should be seen as intuitiveThe syntax at rst will seem cerebral. This is to be expected.

What to ExpectThe rest of this guide will teach you how to write your music in the form of the input language. As youbegin to use LilyPond, Expect:

. the syntax to rewire your brain. We have trained our brains to understand menus, options, andinstant gratication. This is completely inecient and wasteful of time in the long run. However,when you come to understand what you really need, and understand how to communicate eec-tively, your brain begins to transform into a end of a processing machine.

. to be frustrated from time to time. This is especially true in the beginning. Patiencewhen learningsomething new is always important.

. to feel empty and unsatised while writing input code at rst and from time to time. Being wor-shipers of instant gratication, we feel the compulsive need to see results as we are inputting infor-mation. This will shift as time moves along.

. to feel an enormous sense of accomplishment and completion when you nish and compile yourscores. You will feel this every time you create a new score!

Lets Begin!SyntaxLilyPond is organized as a syntactical language. This means that it has a specic way of identifying com-mon functions and musical text. Though the language is not space-sensitive, it is case-sensitive. This isincredibly important: the most commonmistakes made by beginners (in my opinion) are made at the ba-sic syntactical levels of the program, especially ones pertaining to lower-case, upper-case, and the locationof musical expressions.

Skeletal StructuresLilyPond has a frame, a skeletal structure, by which the basic requirements of the syntax are addressed.Here are those structures:

. The backslash (\) - The backslash introduces a linguistic function of the syntax directly into theprograms compiler. Think of it as a signal to the compiler that what comes after it containsmusicalinformation and/or data meant to be recognized in real time.

. The percent sign (%) - The percent sign signals a comment, or a thing that is ignored in real timewhile the compiler is parsing the information. A single percent sign is line-sensitive. This meansthat wherever the percent sign resides, everything to the right of it on the the same line is ignored.The percent sign can also be used with curly braces which can comment out an entire block oftext contained within the braces (e.g. %{ blah %}). This is explained in more detail later.

For instance, the compiler does not see a dierence between space and any larger number of spaces.

. The curly brace ({}) - The curly brace enclosesmusical expressions or functions. This is perhaps thesingle most important skeletal structure to understanding LilyPond. Whenever using curly braces,you must surround them in spaces (this will become obvious in further sections).

. The equal sign (=) - The equal sign does not initialize any particular pathway in the compiler, butsimply is used as a dener or signaler of sorts to bring a denition to any particular variable (e.g.composer = "J. S. Bach").

. The double quote ("") - This usually denes things that are to be quoted directly as written into thescore. It also is used as a container for scripts and other such things (to be explained more later).This container should not be confused with two single quote marks ('').

There are other fundamental structures related to music expression which will be addressed later. Mostimportantly, there are no substitutes for the above structures; they are input-sensitive. For example, abackslash cannot be replaced by a forward slash (/). Curly braces cannot be replaced by square brackets orparenthesis ([], ()). Moreover, if one forgets to complete these structures or give them proper meaning(denition), the compiler will warn you of the error you are making.

The Language of MusicLilyPond has developed a unique but intuitive way of communicating basic musical expressions. In addi-tion, LilyPond has made many things easy:

. The program has presumptions or a set of assumptions it makes when certain information is notprovided in the source le. This allows music to be quickly input and economically handled.

. The program is a , which means that instead of you having to worry about the layout allthe time, you only have to worry about the layout when you are looking at a draft product. You donot have to worry about how the music is layed out and thus can focus on the input of notes.

. The program makes many intuitive decisions about the size and characteristics (or house styles) ofthe score, which means that % of the time the compiler gets the size of the score correct.

All of these things allow you as the user to focus on the typing of information, only needing to worryabout how it looks once everything is said and done.

So, what does LilyPond recognize as musical information? The default language of LilyPond recog-nizes all of the musical alphabet as plain English:

a b c d e f gNot so dicult is it? In the case of ats and sharps, however, it can be tricky. The default syntacticallanguage of LilyPond is Dutch, which means:

at = es; sharp = is;This can be changed by default, however. If you wish to use an English spelling, changing the languageto English allows you to enter ats as f and sharps as s. Double-sharps and double-ats are repeatedsyntactically in a row (e.g. e-double-at is eff and f-double-sharp can be fss or fx).

It also recognizes rhythms by their common mathematical break-down:Do note that the double quote is not the same as stylized curly quotes. Most text editors do not create stylized double quotes,

but many word processors do. Be careful that if you edit a le in a program like LibreOce, Microsoft Oce, or OpenOce to turno the curly quote feature. If you use a program like Frescobaldi or LilyPonds native text editor, this should not be a problem.

To change the input le to reect English spellings, insert If you need to change the language of the input to english, insert:\language "english"into the le right before or right after the version number (which will be explained shortly).

1 2 4 8 16 32 64 128

Not so dicult, eh?In what order do we express characteristics of notes? The order of syntax is as follows:

. Pitch

. Accidental

. Rhythm

. Expression (addressed shortly)

So, a quarter-note e-at is expressed as: ees4. Make sense? Just remember, your information down.There are also other intuitive structures LilyPond understands. Musical expressions can be created by

remembering common textual equivalents, such as the following:

< - crescendo; > - decrescendo; . - staccato; - -tenuto; ^ - house-top accent

Slurs are written as parenthesis (()) and beams are expressed by square brackets ([]).

Plausible StructureHow do all of the idiosyncrasies combine to make musical expressions? Simple: you express the musicalthoughts like sentences. You write expressions separated by spaces, like with normal words. Heres anexample:

c4 d4 e4 f4

would produce:

noteheads noteheadsnoteheadsclefs timesig

noteheadsNotice how the compiler made some assumptions:

. The default clef is the treble clef

. The default time signature is common-time.

. Barlines are automatically placed when the default time-signature is satised within the measure.

. The compiler only places as many bars of music necessary to complete the musical informationgiven in the source le.

The compiler makes these assumptions unless you specify otherwise, and thus it signicantly reduces theamount of specic information you have to put into a source le. This comes in handy when learningLilyPond.

Any examples from here on out will be related to the concept being demonstrated. The examples may contain other elements,but in any case the focal point of the code is on the concept being demonstrated. It does not necessarily mean that the code isactually outputting the other elements of the example.

Other AssumptionsThe compiler also makes some keen assumptions about the information that you input. One of them isrhythm. As in the example above, though one can specify the specic rhythmic value of each note (whichcould become cumbersome in extended scores), it really isnt necessary. The compiler wont change therhythmic value until you tell it to. One can dene the notes as:

c4 d e f

and still come out with the same output as before. If it is at the very beginning of the score, one couldeven dene the phrase as:

c d e f

and even still be able to get the same output. This is because the default rhythmic value is a quarternote until you tell it otherwise.

Finding AgreementIm sure lots of people nd some of the above assumptions and syntactical jargon as strange or even back-wards. But, to be honest, these assumptions and intuitions are more intuitive than popular s ofthe day.

It can be argued that we read music pitch-level rst then rhythm, even if they seem simultaneous. Itcould also be argued that, much like simple-entry modes in common s, rhythm ought not beexplicitly expressed unless a change occurs. This simple line of assumptions can be your greatest ally...orenemy. Either way, the process of inputting code may feel slow, but because of the powerful compilerand engraving engines within the program, your brain will actually have done far less work than with any.

How about some fun? Lets create some examples to explore the syntax.

Putting Muscle on SkeletonEvery musical expression, or muscle, must be connected by some kind of tendon; in this case, it is thecurly brace ({}). First, start by typing in the version statement:

\version "2.18.2" %{Always check to make sure your version statement matchesthe version that you have installed on your computer.%}

And then some curly braces:

{}

And now lets begin the musical expression. Try this:

{ c d e f g a } %{those are the curly braces from directly above%}

Save your le, and then compile it. What should result is an output le that looks something like this:

noteheads noteheads noteheadsnoteheadsclefs timesig

noteheadsnoteheadsIf you are inWindows, click-and-drag the saved le into the shortcut icon for LilyPond. InMac, just click the menu button and

click compile.

Notice how there is no barline at the end of the partial measure, nor a place where the program lled-in the space with rests because it doesnt equal a measure; the compiler just did what you told it to do. Ifyou wanted a barline at the end of that measure, you could do that. Theoretically, that is no problem atall.

If you havent begun to see it yet, dont worry; it will make sense in a short while. What is beginning tohappen, however, is your brain is rewiring to think of things pragmatically, rather than programatically.Most s deal with input programatically: you have to manipulate the programs default output toachieve the goal. This is very practical for very simple input. However, once you go beyond this it becomesa matter of tracing your steps through the menus to get to the desired outcome. For some processes, itssimple. For others, however, is very cumbersome. However, in a pragmatic sense of input, youneed only be familiar enough with some of the basic linguistic characteristics of the input code in orderto accomplish what you need. Lets do some more input, shall we?

The \score BlockOne of the main assumptions that the above examples make is that of the \score block. When you usecurly braces by themselves, you are actually telling the compiler, Look, I have a simple score, and thescheme of this score is all default. This is great for getting your feet o the ground, but you will denitelybe wanting to do more complicated tasks than that. So, lets start introducing the \score block:

\version "2.18.2" %{always remember to check your version number%}\score { c d e f g a }

Save and compile. What do you get? Probably something like this:error: syntax error, unxepected NOTENAME_PITCH

with Exited with return code . as the nal message. Why did we get an error here? We got an errorbecause we have not properly dened our \score block. This brings up a signicant point: when youstart to use functions like \score, you must then start explicitly dening your parameters within thesefunctions. The typesetting engine will cease to make assumptions once you begin to dene your ownvariances and contexts.

Now that the compiler knows you are beginning to dene your own variables, you must now tell it acrucial piece of information: what exactly the information is for. What ismissing from the above example?How about a sta:

\version "2.18.2" %{always remember to check your version number%}\score { \new Staff { c d e f g a } }

And this produces:

noteheads noteheads noteheadsnoteheadsclefs timesig

noteheadsnoteheadsAh, we are back in business! Nowwehave a score! Youmay bewondering, What did I just do? Simple:

you invoked a \score block, which contains single musical expressions, and dened that you wanted asta by telling it to create a new (\new) one! Its that simple!

Heres something really important: try not to panic if you get an error message. When I rst did, Ipanicked, and I wrongfully didnt work through it. When you are calm and trying to parse what you areseeing, usually the answer is clear right from the get go.

From this point on, the Ticklish Guide assumes that you have entered the appropriate version number into your le.

Rules of ThumbWe need to establish some things. The rst thing to talk about is the open curly braces. When it comesto open braces, if they are opened, they need to be closed. It is really better to habitually draw open ({)and closed (}) braces at the same time and then enter your text between them. This habit will prevent themost frustrating of errors which most amateurs tend to make when rst using LilyPond.

Other Blocks Essential to the FileWe want to produce more than just musical information, though! We would like to be able to producetitles and composer markings to help with the identication of the music. For this, we will use a newcommand:

\header{}

Isnt it intuitive? Any title and related information can be found here. You can dene practically anyelement of the page. Here are some basic variables we can use:

%within the header blockdedication = ""title = ""subtitle = ""composer = ""poet = ""arranger = ""

Just type the information youwant between the sets of double quotes. If these ever appear in the\header{},they will appear in predened places according to common notational standards. Heres an example:

This can be modied, as described in the section of this guide entitled Markups. Of course, thereare plenty of other variables, but as a ticklish introduction, this should suce in order to go on further.Another block that is essential is the paper block:

\paper{}

In this block, we can dene all of the arbitrary variables related to the styling of the paper and its contents.Wondering what those variables look like?

%within the paper block#(set-default-paper-size "letter")right-margin = 1\inleft-margin = 1\inbottom-margin = 1\intop-margin = 1\in

Another useful way to think of braces and other related shapes are as containers. Containers need to open and close. Forexample, you never want to leave a container of cookies open.

Notice the double quotes as a container.

There are numerous advantages to this block, and those will become abundantly clear later on. The mostglaring advantage is the ability to dene a paper size, as well as the margins of the printable page! InEurope and basically the rest of the world except for the United States, the default paper size of printersis the a size, and so if you wish to change this, you will have to explicitly change it using the script#(set-default-paper-size ).

Most everything you can see so far is intuitive and thats the point. There are a lot of things that willseem backwards at rst, but -% of all the syntax of LilyPond has a common thread to a realistic viewof its command.

The last block worth mentioning is the \layout{} block. It can be put in any part of the le, but itis most commonly found nested within the \score{} block.

A Brief PhilosophizingManyhavemisunderstoodLilyPond to be a languagewhich is a lot like programming language. Languageslike C++ and Python come to mind to those who see a programs syntax like this. However, any closerdetail will tell you that it is far from it.

The structures are extremely lean and simplied and have mostly been made rid of programmingidiosyncrasies. For example, the program doesnt require you to create explicit formal arguments in orderto call certain features of the program. In fact, LilyPond is several million lines of code that have beentransformed into pathways that are turned on when one uses LilyPonds simplied syntax. So, whatthe user actually has to learn is far from coding language; in order to function eciently with C++ orPython one must be intimate withmost of the syntax. With LilyPond, one must only be familiar with thesyntactical equivalencies and basic rules in order to use it rather prociently.

The \relative CommandThink of the last you used. How did you input the music? If you are in a quick hurry, or easilyfrustrated by pointer accuracy of the click-and-drag, you used some form of simple-entry or quick-entry.How did you switch octaves? Did you use a shift+" (or shift+#) shortcut? How did you know when tochange octaves? Chances are you knew because your program, by default, actuates the octave closest tothe previous note you entered. In this case, the octave is determined by the relative note that precedesthe current note. This is common, so that you do not have weird octaves popping up in simple entry. Thedistance of that interval is usually whatever is less than or equal to a th. If it is above a th (any kind ofth, mind you) then it takes the shortcut command shift+" (or shift+#) to move to a dierent octavethan that of the note preceding it.

LilyPond has the same function; instead of writing in absolute pitch (which is useful for some things),you can write in \relative pitch, which bases the current note relative to the previous note. In order touse this command, you must initiate a starting pitch of some kind, and it can be anything:

\relative c' {music}In the above case, the notes contained within the curly braces are relative to the absolute pitch of c',which is middle c. So, lets try it out:

\relative c' { %{Line breaking and indentation is useful here because itkeeps the score clean and easy to follow. Instead of having all of yourmusic on one line, you can displace it 1-2 measures per line, or howeveryou prefer.%}

The \layout block can dene indents for specic scores, dene lyric sizes, and awhole host of other things, such as score layoutand even sta-to-sta spacing.

Especially since version ..xOf course, to ne-tune the score, onemust bemore familiar with the details of the syntax and the internal language, but at that

point you are becoming your own expert.Please note that it is a single quote after the c, not a double quote.

c d e f g a b c }This would generate the following output:

noteheadsnoteheads noteheadsnoteheadstimesigclefs noteheads noteheadsnoteheadsnoteheadsNotice how each note follows the next in a scale, and that is because each note was less than a th

away from the previous note! What if we did this without \relative command? {c d e f g a b c}would produce:

noteheadsnoteheads noteheadsnoteheadstimesigclefsnoteheads noteheadsnoteheadsnoteheads

Notice how it went back to some dierent notes. This is because you were writing in absolute pitch,which is default in LilyPond. How then, does one change octaves? Simple! Use a ' to raise an octave(relative to the pitch before) or a , to lower an octave (relative to the pitch before). Lets try a brokenchord:

\relative c' {d a' c d fis }

Produces the following output:

noteheads noteheads noteheadsaccidentalsnoteheadsclefs timesig noteheadsBut, if you take out the single quote (or tick mark), you get the following output:

noteheads noteheads noteheadsaccidentalsnoteheadsclefs timesig noteheadsVery dierent, no? This is perhaps one of the more frequent mistakes of new LilyPond users: forget-

ting to change the octave when it needed to be. Try inputting the following examples:

noteheadsnoteheadsaccidentalsnoteheads noteheadsaccidentalsnoteheadsnoteheadsnoteheadsnoteheadsnoteheadsnoteheadstimesigclefs noteheads noteheadsnoteheads

noteheads

If you get the output right the rst time, congratulations! If not, dont panic! Retrace your steps, andsee where you went wrong. If you arent quite sure what to use, experiment, and see what the outputgives you. Remember, LilyPond is a logical typesetting system, and it bases its output on the instructionsand logical output of what you write! So if there is something wrong in your le, then it has to do withwhat you wrote.

This format of writing pitches is extremely useful in experimental and post-modern notation. This is very useful if one doesnot want to have any doubt that they have written the proper pitch. With tonal music and most other music, however, \relativeis a suitable way of describing pitches.

One of the rst projects for which I used LilyPondwas transcribing a ute solo for an audition at amajor university. I had typedeverything in, compiled, and my ute line ended up four octaves lower than it should have been! I found that I had forgotten anoctave mark at one point, and once I found it, I corrected the problem, and the output xed itself!

(More) Advanced NotationNow that we have some of the groundwork established, lets consider getting on to more practical, reallife situations.

The rest of the Ticklish Guide will show you the basics of all the apsects you would need to create asimple score; with all the explanations and such, it should be a rather smooth transition into the LearningManual on the LilyPond website. The developers of the program even recommend experienced userscovering the Learning Manual once in a while because there are many things that are not covered in asgreat of detail in other manuals as in the Learning Manual. Furthermore, the Learning Manual is farmore in-depth and explanatory in its nature.

If at any point something doesnt make sense, reread it and try it again, or go to the correspondingLearning Manual chapter that covers it. Most of the time, however, your mistakes will be self-inicted(meaning its not something the manuals or I did wrong), so exercising patience is the absolute key tomaintaining composure during the early stages.

It is also important to note that there are many ways of getting help. One of them is the LilyPondmailing list. Its an email update sent several times a day with questions and responses to questions thatmay not be covered in the manuals.

The initial stage of learning LilyPond should be self-guided. However, I would highly recommenddownloading and using the gentle-giant Frescobaldi program. It is perhaps the greatest front-endprogram for interacting with LilyPond. It is extremely light-weight but heavy duty (like a carbon-bersports car) and it contains auto-completes which, when used correctly, speed up the process of syntax.

Following this guide will be an appendix of graduated examples with the answers of those examples,for your practice. None of the examples in the appendix will go beyond the scope of this guide. It will alsocontain various problems of notation for you to solve, to get comfortable and familiar with how errorscontribute to problem solving in scores. With patience, practice, and a calm mind, you can become veryprocient with the basic functionality of LilyPond.

KeysThe concept of keys in LilyPond is rather straight forward. You must rst invoke \key which is thenfollowed by two arguments: a key center and a key mode. You can use any key center you can think of,and there are a host ofmodes. Of course, themost common aremajor andminor. Heres what a key lookslike:

\key eeses \minor %{ invoking minor or major requires a backslash %}

And it produces the following output:

accidentalsaccidentalsaccidentalsaccidentalsaccidentalsaccidentalsaccidentalsclefsOnce you have nished this guide, it would be safe to drop in the .. Learning Manual starting at section ... There will be

some overlap at that point, but it will be minimal.When it comes to the email mailing list, it is easy enough to setup your email client to automatically archive these emails to

a folder dedicated to LilyPond. Then, when you have questions about using LilyPond, you can search these emails with keywordsabout what you might need, and you can also send questions to the list itself.

It can be found and downloaded from www.frescobaldi.org/You will still have to spell out every note (for example, if you are in the key of ees you still have to write ees/aes/bes every

time you use those notes). This is a so-called problem with users trying to switch over to LilyPond, citing the commoncomplaint, I only should have to type the note name and the key will take care of it for me. This thinking, in reality, is slightlyfallacious, because it does not actually make sense. The note e-at in the key of e-at is stillget ready for ite-at. Thatsbecause a key is not a mystical device used to dene arbitrary notes, but a consistent reminder of a set of accidentals to be appliedthroughout a work or piece of music.

The Notation Reference, a guide for the advanced use of LilyPond, describes custom key signatures.This is very useful for obscure or -st century music.

Clef & Clef ChangesLilyPond assumes that you will be using a treble clef. If you want to start with a dierent clef, or if youwant to change clefs in themiddle of themusic, you invoke the command \clef and the name of the clefyou wish to use. When it comes to clef changes, LilyPond can place them wherever you want inside of ameasure.

LilyPond by default supports many dierent clefs, the most common being the treble, bass, and altoclefs:

clefs clefsrestsrests restsclefs timesig clefsSo for this example, \clef bass, \clef alto, and \clef treble were used.

Time SignaturesLilyPond handles time signatures with a backslash, but there is only a small twist: the actual time signa-ture is described using a forward slash (/). To enter the time signature 34 , you must type:

\time 3/4

And the compilation will give you:

43clefsEverything following that change is aected by the command. This goes for most other things in an

input le.

TempoMarkingsThere are two very exible ways of dealing with tempo markings, which always occur starting on thebeat following this command. To create a new marking, you need to invoke \tempo and then one of twothings: a text container and/or a note value dener. They happen to look like this:

\tempo "Blady Blah Doop" 4. = 2000

Which would output:

Blady Blah Doop ( dotsnoteheads = 2000)timesigclefsThe dot after the represents an augmentation dot. That will be explained in the rhythm portion below.

Fascinating isnt it? On s you would have to create new tempo markings for each time youwanted to use something other than a traditional Italian term, but that is no fun, right? In LilyPond youcan also just use one or the other feature. For example, if youwanted to just use a text tempomarking, pre-formatted the way it was supposed to be, you could use use \tempo "Insert Tempo Here". If you justwanted a tempomarking indicating a metronomemarking, you only need to use \tempo 2 %{whateverbeat you want%} = 100 %{or whatever metronome marking%}. The number on the left side of theequals sign corresponds with the beat emphasis mentioned above. The number on the right can be set toany amount you can think.

Rhythm, Rests, and the LikeRhythmThough explained briey earlier, this sectionwill describe in detail themanner in which one should thinkof rhythm. In common s, rhythm is expressed by either clicking a value and dragging it acrossthe screen into the appropriate place on the sta or it is done by short-hand (using a keypad and choosingan arbitrary number which corresponds with the note type). In LilyPond, this is now, for the time being,more of a mental exercise. When it comes to rhythm, LilyPond makes several assumptions:

. The note value at the beginning of a piece is by default the quarter note;

. The note value changes when one invokes such a rhythm;

. The note value remains in eect until another value is invoked.

With this process, lets try a few examples:

noteheadsnoteheadsnoteheads noteheadsnoteheadsnoteheadsnoteheadstimesigclefs noteheads noteheadsnoteheadsnoteheads-or-

noteheadsnoteheadsnoteheads noteheadsnoteheadsnoteheadstimesigclefs noteheads noteheadsnoteheadsnoteheadsTry replicating these processes before looking below at the answers. What are the two ways that they

could have been written? One way:

. The rst example: \relative c''{ c4 c4 c8 c8 c8 c8 c16 c16 c8 c8 c8 c8 }

. The second example: \relative c''{ c4 c4 c16 c16 c16 c16 c8 c8 c2 c4 }

This however, would have been tedious. There is good news, though, because the notation could havecertainly been simplied. If we know that LilyPond assumes that the current note takes the previousrhythm unless changed at that moment, then how can these two examples have been cleaned up?

. The rst example: \relative c''{ c c c8 c c c c16 c c8 c c }

. The second example: \relative c''{ c c c16 c c c c8 c c2 c4 }This is much like the law of motion which says an object stays in motion until another force acts upon it.The value must always come right after the note name without a space.

Do you understand what is happening here? The compiler does not need to know the value of everynote; it just needs to know when the value is changing. This is a radical assumption that is mimickedin s. Some known issues when switching to this method of entering note values is primarilyforgetting to enter the value you are thinking. This was a common problem of mine before I got reallygood at it. Occasionally, I still make this mistake.

What about the augmentation dot? The augmentation dot comes right after the rhythm. Each noteis a syntactical unit, so it must come in immediate succession to the notes value before a space is added.For example:

e32

noteheadsdotsf16.

noteheadse

noteheadsf16

noteheadsbes8

noteheadsdotsc4.

timesigclefs noteheadsg16

noteheadsdotsa8.

noteheadsaccidentals flagsBelow the example is what input had to occur in order to create the output. See how each note is a

unit, a grammatical piece of this musical puzzle? Just like in forming sentences, certain things must bepresent in order to make sense.

RestsWhen it comes to rests, they are written exactly like notes. There are two types of rests that can be used.One is a visible and the other an invisible (or spacer). To invoke a visible rest, use r and the length ofnote you wish for it to represent, like so:

restsr32

restsrestsr1

restsr2

restsrr

restsr

restsr

restsr8

restsclefs timesigr4

restsr

restsr

restsr

When it comes to spacer rests, just use the letter s in place of r and you will create a space thelength of the rhythmic value you give it.

AccidentalsLilyPond supports a wide variety of accidentals and note-naming properties. But of course the mostcommon in music are the at, double-at, sharp, double-sharp, and natural:

accidentals accidentals accidentals accidentals accidentalsThese are invoked using simple phrases at the end of the note: es for at, is for sharp, eses for

double-at, isis for double-sharp. Naturals are invoked by not using any phrase. Therefore, LilyPonddoes not assume that a at or sharp carries until otherwise notated; that would be a disaster.

The Notation Reference describes several ways in which one can change the visual appearance of ac-cidentals in the output. The default appearance, however, is one in which an accidental carries throughthe measure unless changed. This does not mean, however, that in the input you can write somethinglike ees and just write e throughout that measure and the at will continue through it. Every time

The augmentation dot can be double-dotted as well. In fact, you can add as many dots as you like!

you want an e-at, whether you already wrote it before or not, you must write it as e-at. Here is anexample:

noteheadsaccidentalsnoteheadsaccidentals accidentalsnoteheadsaccidentalsnoteheadsaccidentalsnoteheadsaccidentalstimesigclefs noteheads noteheadsaccidentalsflagsnoteheadsaccidentals dotsnoteheads

The notation for this example is as follows: \relative c'' { ces4 bes a4. gis8 fisis gisais bis cis2 }. Notice how each note is its own unit. How would I get a natural to appear on the rsta in the example? I would write, after the syntax, an ! right before the beat value:

\relative c'' { ces4 bes a!4. gis8 fisis gis ais bis cis2 }And the resulting output would be:

accidentalsnoteheadsaccidentals accidentalsnoteheadsaccidentalsnoteheadsaccidentalsnoteheadsaccidentalsnoteheadsaccidentalstimesigclefs noteheads noteheadsaccidentalsflagsnoteheadsaccidentals noteheads dots

Imagine the exclamation mark as a jolting reminder (!), an explicit command in the note name. Thesame reasonably goes for parenthesized accidentals; you only need to use a ? after the note name. Theresulting output would be:

accidentalsnoteheadsaccidentals accidentalsnoteheadsaccidentalsnoteheadsaccidentalsnoteheadsaccidentalsnoteheadsaccidentalstimesigclefs noteheads noteheadsaccidentalsflagsnoteheadsaccidentalsaccidentalsaccidentals noteheads dots

So, in reality, both of these bits of syntax make complete sense when imagining how to code yourinput le. Both of these useful syntactical units can be used anywhere in the musical text.

Another important thing to remember (it will be brought about later on) is the fact that accidentalsare part of the identity of the note; this comes before the placement of that note in terms of the octavewhen writing the input in the source le.

The Augmentation DotAs mentioned before, this tool is used to augment the length of a note. When writing the input, It simplycomes immediately after the rhythmic value of the note, and it cannot be used in absence of a rhythmicvalue. It must also come before any other articulations or expressions. The augmentation dot can be usedad libitum to any arbitrary end. For example, you can use one dot or as many dots as you would like:

noteheads dotsdots noteheads dotsdotsdotsdots noteheads dotsdotsdotsdotsdotsdotsdotsflagsnoteheadsclefs timesig dotsThe program calculates the degree of that augmentation dot internally and very naturally. Normally,

most programs do not allow you to use more than three augmentation dots.This has bothered people in the various forums of the internet, and to some degree some people nd it tedious. Consider this,

however: whenever you read a piece of music with a key signature, especially with accidentals in it, you dont think of the othernotes in the measure as being natural, do you? This is a rewiring thing I talked about in the Introduction: we as a culture ofcomputer users with very interactive s have grown accustomed to seeing menus and not needing to think about the details ofa score; the program watches all of that for us! In exchange for this luxury, however, you are getting something far better: a veryclean and tidy score that in most cases only needs moderate to no tweaking to get right and beautiful.

LilyPond goes above and beyond just these twomethods of writing accidentals. You can adjust, change, and tweak any propertyyou want, even to include microtonal linguistics, and even change how ! or ? behave by default.

Most users will say, however, that this is a pointless feature. I would suggest that a programs ability to be expanded easily andeconomically is where the true power and authority comes from. Being able to draw an augmentation dot six times may never

ArticulationsWhen it comes to articulations, LilyPond soars. It has one of the most complete sets of articulations andrecognizable sets of articulations I have ever come across. And, as you may begin to realize, LilyPondis never limited by this fact. You can add to the list of articulations, dene your own, and design, fromscratch, anything you can imagine.

The compiler has a preconceived list of commands that the usermay use to communicate with it. Themost common articulations are:

Marcato dened as ^

Accent dened as >

Tenuto dened as -

Portato dened as _

Espressivo dened as \espressivo

Staccato dened as .

The fermata is invoked with a backslash followed by the name: \fermata. Notice how these all have anintuitive feel to them, and theymake sense. The caret key looks like amarcato accent; the greater-than-sign looks like an accent; a dash looks like a tenuto; a period looks like a staccato. In order to invoke thesearticulations (except for the fermata and the espressivo), one must use a direction dener rst. This canbe one of three things: a caret key ^ which indicates up; a dash - which indicates a neutral positions(the direction of which is ultimately dened by the compiler); and an underscore _ which denes thearticulation below the note. Heres an example of all of them in play:

scriptsnoteheadsscriptsnoteheads scriptsnoteheadsscriptsnoteheadstimesigclefs scriptsnoteheads scriptsnoteheadsscriptsnoteheads

For this example, I used the neutral dener. But, if you were to use the caret key (pointing up) or theunderscore (below), you would be telling to the compiler to override what it thinks the music should doand it would take your explicit command to do either instead.

The other great thing about LilyPond is the ability to stack articulations and other things given tothe note. For example, one can put two dierent articulations to one specic note:

noteheadsscriptsscripts

noteheadsscriptsscriptsclefs timesigThe code for that was \relative c'' { c2-^-- c^>_. }. Notice how on the second c, there

were articulations given above and below the note. Youmay bewondering, How does the compiler knowwhen Im doing an articulation? Because of the unique and simplied setup of LilyPond, the programintuitsmany of these things; you only need concern yourself with putting what youwant where youwantit.

LilyPond also has historic articulations, Kevian notation, and ancient music articulations. The Nota-tion Reference lists how to do all of these.really be necessary in real life, but the principle that you should not be limited by a programs abilities is the key to this concept inLilyPonds programming.

You can place as many articulations stacked onto one note as you would like.

ExpressionLilyPond handles other expressions dierently. Imagine being a computer program; you know that slursand ties, hairpins, and the like do not look the same twice. They are not like mordents or portatos; theyare dened on a moment by moment basis, spanning many dierent notes. For this reason, LilyPondseparates and compiles expression commands separately from regular articulations, and has a separateengine to compile those requests in the source le.

Slurs and TiesSlurs can dene many dierent things, but LilyPond only recognizes three types of slurs: slur, phrasingslur, and tie. There are necessary and dierent components to create each event.

In the case of both the slur and the phrasing slur, LilyPond treats them like the curly brace or a squarebrace: if they are opened, they must be closed. LilyPond will generate a warning saying you have notbegun or ended a slur if it is missing from your input le.

To invoke a slur, attach () to the rst and last notes you wish to slur. Heres an example:

noteheadsnoteheadsnoteheads noteheadsnoteheadsnoteheadsdotstimesigclefs noteheads noteheadsflags noteheads

If you use an articulation, the slurs are after that. Think of a slur (or any other thing related to a curve)as connecting whole units of music. The example above can be written as: \relative c'' { c4.( b8a g f e d4 c b2) }.

But what if I want to nest slurs? To do this, you need to use a phrasing slur. The dierence between aphrasing slur and a slur syntactically is the use of the backslash. For example, \relative c'' { c4.\((b8 a g) f( e d4 c) b2\) } produces:

noteheadsnoteheadsnoteheads noteheadsnoteheadsnoteheadsdotstimesigclefs noteheads noteheadsflags noteheads

When it comes to ties, you use the tilde ~ between the notes you want to tie. For example, { cis'2~ cis'4 c' } produces:

noteheads noteheadsaccidentalsnoteheadsclefs timesig accidentalsDo note that if you try to tie two dierent notes together, you will get an error message saying un-

terminated tie and you will be told where that unterminated tie is. The tie will also not display. Youmust also make sure that the notes match in terms of what octave they are in and whether or not theyhave an accidental.

Here is a combined example using all three types of slurs (ties, slurs, and phrasing slurs):

noteheadsaccidentals noteheadsaccidentalsnoteheads noteheadsaccidentals accidentals noteheadsscriptsnoteheads noteheadsnoteheads noteheads noteheadsnoteheadsclefs 43 accidentals noteheads noteheadsaccidentals noteheads

The code for this example is as follows: \relative c''{ \time 3/4 ces4\(~ ces8 b16 ais~ais4 b a g16( fis gis ais) b4 ais b\)\fermata }

Youwill nd that LilyPond shapes slurs and other expression with grace and beauty. There will be fewtimes that you will ever need to change the shape, and the initial output of slurs by default is far morereadable than other notation programs.

HairpinsHairpins, or objects that describe an active change in dynamics, are invoked with a backslash. The threerelevant syntactical units are the lesser-than symbol , and the exclamationpoint !. Both the lesser-than and greater-than symbols indicatewhat they look like: opening and closinghairpins. The exclamation point delineates the ending point of either. For example:

noteheadsnoteheadsnoteheadsmfnoteheadsnoteheadsnoteheadstimesigclefs noteheads noteheadsnoteheadsnoteheads

The corresponding code would be: \relative c'' { c4\< c c c c\! c\> c c c c\mf }.

SpannersThere are many corresponding text indications of gradual volume changes. These can be found in theLearning Manual and in the Notation Reference.

DynamicsDynamics are possibly the easiest to remember. They are invoked by a backslash, and LilyPond automati-cally supports the following: \ppppp, \pppp, \ppp, \pp, \p, \mp, \mf, \f, \ff, \fff, \ffff, \fffff, \fp,\sf, \sff, \sp, \spp, \sfz, and \rfz. They can be directly attached to a note, or the direction of thedynamics can be dictated by using the caret key (above) or underscore key (below) immediately beforeinvoking the dynamic. Heres an example:

noteheadssfz

noteheadsfpnoteheadsmf

clefs timesig noteheadsfff

The corresponding codewould be{ c''4\mf c''^\fff c''_\sfz c''^\fp }. Like before, LilyPondis capable of creating custom dynamics. The details of how to accomplish that are found in the NotationReference. Remember that the dynamic is part of the identity of the individual note, so it therefore comesdirectly after the note (with expression) without a space.

Miscellaneous NotationThere are many (more) advanced notational things that LilyPond handles that are more common withbeginners. Herein are some of those things.

Hairpins can also be stopped by dynamics, as shown in the example.

BeamingLilyPond handles most of the beaming in the syntax by itself. There might, however, come a point whenyou desire to change the beaming of a group of notes, especially just a handful of times. LilyPond accom-plishes this by use of the square bracket []. The bracket occurs after the augmentation dot but canhappen before any articulations. This example, \relative c'' { cis8.[ c16 c8] c[ c] c[ c c cc c c] }, outputs the following:

noteheadsnoteheadsnoteheadsnoteheads noteheadsnoteheadsnoteheadsnoteheadsaccidentals dotstimesigclefs noteheads noteheadsnoteheadsaccidentals noteheads

Cadenza NotationCadenza notation is quite useful when marking chant, basic cadenza notation, or when you want to usea dierent length of measure without changing the time signature itself. It is invoked with the argument\cadenzaOn and it is turned o with \cadenzaOff. Do note that you will be responsible for notating thebeaming structure of that measure (if need be), and you will also have to notate a bar line (explained inthe next section).

Bars (Barlines and Bar Checks)Bars are communicated in an intuitive way. If you desire to have something other than a traditional singlebarline, youwill have to invoke \bar followed by an argument contained in double quotes (e.g. \bar ".")Here, LilyPond goes above and beyond, and gives a plethora of options. Consider the following table:

command output

\bar "|"\bar "."\bar "||"\bar ".|"\bar ".."\bar "|.|"\bar "|."\bar ";" dots

dots

\bar "!"

As it should come as no surprise, LilyPond doesnt stop here. There are endless possibilities withLilyPond. These barlines, however, cover the gamut of most usage.

Another fundamental concept in detecting errors in LilyPond is the use of a bar check. It is used atthe end of any supposed measure in the input, and is notated by a single verticle line separator (|). Thiswill cause the compiler to check to make sure that all of the beats add up appropriately for that measure.

FingeringsFingerings are dictated in the samemanner as articulations. You are required to use a directional identier(caret key or underscore key) or a dash (which allows the compiler to choose the direction). Fingerings canalso be stacked, and they are delineated with numbers (imagine that!). The notation { c''-1_2 c''-3c''2-4^5 } would produce:

noteheads3 noteheads5

4noteheads2

1clefs timesigThe Notation Reference describes many dierent ways of doing advanced ngerings.

MarkupsThe \markup{} block is a system of entering other information, whether text-related or other-related, tobe printed in the body of the score, that is not directly addressed by the musical information. It can beused outside of the \score{} block or within any elements in a score. Think of markup as a means bywhich you can enter other printed information other than music.

Markups are perhaps themost versatilemeans of aecting text-based output. They are also incrediblypowerful, because they can also integrate text andmusic. TheNotation Reference and the LearningManualboth covermarkupsmore extensively and comprehensively than I ever could, but here are some commonuses.

The rst use is modifying the default output of a header block. A good example of this is within theuse of sacred music; whether a tune name is involved in a hymn or a song, you will generally want tomark it in small caps. LilyPond utilizes this very well, and it is invoked using the following: \markup {\smallCaps "Text Goes Here" }. There are many dierent things at play here, the rst being that Iam invoking smallCaps within the curly braces, and it is modifying the double quote container. Here isa complex series of markups:

NSA Fart

This particular example invoked \smallCaps, \italic, and \huge. Multiple markup commands canbe used on a single container of information. In addition, markups can be used on notes and music. Inorder to do that, you must explicitly indicate on which side of the note you wish the markup to occur.Heres an example:

timesigclefshere's my markupnoteheads

The input for the above example is as follows: \relative c'' { c1^\markup { \bold "here'smy markup" } }

When using markup in a short le, however, dont forget to close all necessary open braces. LilyPondcan also embed music within a markup:

violin:

noteheadsnoteheadsnoteheadsnoteheadsclefs timesig , cello: noteheadsnoteheads

noteheadsnoteheadsclefs timesigThe abilities are endless. To see a full list of markup commands, see section A. of the Notation

Reference in the manuals.Though, it can be used to create musical examples, as you will see shortly.

TupletsTuplets are essential tomixedmeter and other such notation practices. Frommy own experience, writingtuplets in other programswas a hassle and a nightmare. Luckily, LilyPond dealsmost eortlesslywith tuplets.

To begin a tuplet, one must invoke the argument \tuplet, which is followed by two things: the ratioof said tuplet and an enclosed expression of that tuplet. That practically looks like this:

\tuplet %{invoked%} 3/2 %{first # equals the number of notes, second #equals the number of notes it displaces %} { c8 d e }

Which will give you the following output:

noteheads noteheads3

noteheadsclefs timesigFurthermore, you can nest triplets, and use them ad libitum to any length, time, or proportion you

can imagine. Take, for example, this extraordinary demonstration (which even uses juxtaposed meterand irrational time signatures):

ChordsA more common need in music notation is to create chords. This notation is accomplished in LilyPondby using the less-than and greater-than symbols as a container (). If you are inside of an absolute pitchenvironment (the default of LilyPond), then the octave in which you dene the chord appears:

accidentalsaccidentalsnoteheadsnoteheadsnoteheadsnoteheadsnoteheads

1

clefs timesig

But, if you are in relative pitch, it depends on the note directly preceding it, and whether or not it isequal-to or less-than a fourth away:

accidentals noteheadsnoteheadsnoteheadsnoteheadsnoteheadsnoteheads

sorts, it is certainly far from the complex languages and grammatical structures of actual programminglanguages. Insomuch that you have read this guide, you should have a basic, functioning idea of howLilyPond works and how to enter simple notation. The Appendix contains many exercises and corre-sponding answers to hone your basic abilities with LilyPond. They should challenge you, but not beyondthe scope of this guide. If you feel condent in your abilities and do not need to practice the exercises inthe Appendix, then I would encourage you to start the Learning Manual found on LilyPonds website, andwalk through it. Much of it you will already know, but I would still encourage you to try all the things itmentions and get a successful compilation of all the examples before continuing onward through it. Yourunderstanding and habits with this program are contingent upon you understanding, comprehending,and processing this language. Should you become successful with it, it is only the beginning of a lifelongromance between you and the beautied scores youve created.

. has hundreds of thousands of scores waiting to be re-engraved for the public domain. Iwould encourage you to go there and nd a couple of scores to re-engrave, and use them as real-lifeexamples for honing your skills. Each score presents its own challenges, and there will be manymomentswhere you will actually be googling for tweaks and instructions more than you will be typing code. Justmake sure as you get used to the syntax and the various tweaks of the program to be aware of the versionnumber and that the tweak is relevant to what you are trying to accomplish. Happy Ponding!

Post ScriptHeres onemassive example thatmakes use of all the concepts covered here in this guide. You arewelcometo replicate it, or study it with the input directly below it.

flagsaccidentals noteheads noteheadsaccidentals noteheads dots noteheads accidentalsaccidentalsaccidentals noteheads noteheadsaccidentalsnoteheads

flagsnoteheads noteheadsnoteheadsclefs accidentals timesig dots noteheadsaccidentals

noteheadsnoteheads

noteheadsscriptsclefsnoteheads noteheads noteheadsnoteheads noteheadsnoteheads43accidentalsscripts4

2

noteheadsnoteheads noteheads noteheads noteheadsscripts accidentalsaccidentalsaccidentalsnoteheadsscripts

2 clefs accidentals noteheadsnoteheads1

5

scriptsnoteheadsnoteheadsscriptsaccidentals accidentalsnoteheadsscripts noteheadsscriptsnoteheads

noteheads noteheads 816clefsnoteheadsscripts noteheadsscripts

7

noteheads noteheads noteheads noteheadsnoteheads noteheads noteheads noteheads restsscriptsaccidentalsaccidentalsaccidentals5 clefs noteheads noteheads noteheads noteheadsnoteheads noteheads noteheadsrestsnoteheads

noteheads noteheads noteheads rests restsscriptsnoteheads noteheads noteheads noteheadsnoteheads noteheads noteheads noteheadsaccidentalsaccidentalsaccidentals

8

816clefs noteheads noteheads noteheads noteheads noteheads noteheadsnoteheads noteheads

\relative c { \clef bass \key f \major \time 4/4bes4.\( c8 d( e f ges)\cadenzaOn aes2\)~ aes4. bes!8 aes[ g? f ees] \cadenzaOff \bar "."2^__4_2 ^\espressivo_5_1bes16-. a-. bes-- ceses-- ees d ees f 2\time 3/4

\cadenzaOn r4 r8 bes[ bes bes bes bes] r2\fermata \cadenzaOff \bar "|.|"}

AppendixDierent Views of Content Authoring

Content

Semantic

WYSIW

YG

WYSIW

YM

Source Code View

Fact View

Figure : http://en.wikipedia.org/wiki/WYSIWYM

Main ExamplesReplicate the following examples. The answers to these examples are found in the next section.

Basic Examples

noteheadsnoteheads noteheadsnoteheads noteheads rests restsaccidentals noteheads noteheads noteheadsnoteheads noteheads noteheads1. noteheadsclefs timesig noteheads noteheadsnoteheads

accidentals noteheads noteheads noteheadsaccidentals noteheads noteheads noteheads noteheads noteheads noteheadsaccidentals noteheads noteheadsnoteheads noteheads noteheads2. noteheadsclefs 43 noteheads noteheads noteheadsaccidentals noteheads noteheads

noteheads noteheads noteheadsnoteheads noteheadsaccidentals noteheadsaccidentals noteheadsaccidentalsaccidentals noteheads dotsnoteheadsaccidentalsnoteheads noteheadsaccidentals

3.noteheadsclefs 46 accidentals accidentals noteheads noteheadsnoteheadsnoteheads

noteheads noteheadsaccidentalsnoteheads noteheads noteheads noteheads noteheads noteheadsaccidentals3

noteheads noteheads noteheadsaccidentals noteheadsaccidentals noteheads noteheadsaccidentals noteheads4. noteheadsclefs timesig noteheads noteheads dotsnoteheadsnoteheadsnoteheadsaccidentals

noteheads noteheads noteheads dotsnoteheads noteheads noteheads noteheads noteheads dotsaccidentalsnoteheads noteheadsnoteheads noteheads dots noteheads5. noteheadsclefs accidentalsaccidentals 43 noteheads noteheads noteheadsnoteheadsnoteheads

noteheadsaccidentals noteheadsaccidentals accidentals noteheads45accidentalsaccidentalsaccidentalsaccidentalsaccidentalsclefs noteheads6. noteheadsnoteheads

noteheads dotsaccidentals noteheadsflags noteheadsscriptsnoteheads noteheads noteheadsaccidentalsnoteheads33

3accidentals noteheads noteheads noteheads noteheads noteheads3

clefs accidentalsaccidentalsaccidentalsaccidentalsaccidentals noteheadsaccidentals noteheads noteheads noteheads noteheads noteheadstimesignoteheadsnoteheads accidentalsnoteheads noteheads noteheads noteheadsnoteheads noteheads noteheads noteheads noteheads rests

noteheads noteheadsnoteheads noteheads7. noteheadsclefs accidentalsaccidentals timesig noteheads noteheads noteheads noteheadsnoteheadsnoteheads

flags rests noteheadsflagsrests noteheads noteheads

noteheadsaccidentals noteheadsflagsnoteheads

3

rests restsnoteheads

restsnoteheads dots

rests noteheads noteheads4 clefs accidentalsaccidentals rests rests noteheads noteheads rests

noteheadsnoteheads noteheads

noteheads noteheadsrests

scriptsaccidentals noteheadsscripts noteheadsflagsnoteheadsscriptsaccidentals noteheads noteheadsscriptsflags

accidentalsrests accidentalsaccidentalsaccidentalsnoteheads dotsnoteheadsscriptsflags restsscripts noteheadsscriptsaccidentals noteheadsscripts dots

8. noteheadsscriptsclefs accidentalsaccidentalsaccidentalsaccidentals 87 noteheads

scriptsaccidentals noteheadsscripts dotsnoteheadsscripts

flagsnoteheadsaccidentals

noteheadsflags noteheadsflagsaccidentals noteheads

flagsnoteheads noteheadsscripts restsscriptsnoteheadsnoteheads noteheads noteheads noteheadsaccidentals noteheadsnoteheadsclefs noteheads noteheadsnoteheads noteheads noteheads accidentals noteheads noteheadsaccidentals

5 noteheadsaccidentalsaccidentalsaccidentals accidentals noteheads

noteheadsnoteheads noteheadsnoteheadsnoteheadsnoteheads

15clefs noteheads9. noteheads

noteheadsnoteheads

noteheadsnoteheadsnoteheadsnoteheadsnoteheadsnoteheadsnoteheads

restsnoteheadsnoteheadsclefs3 noteheadsnoteheads

Advanced Examples

noteheads 84noteheads noteheads noteheadsnoteheads noteheads noteheads noteheads

noteheadsscripts noteheadsscripts3 3

3

scriptsnoteheadsnoteheadsnoteheadsscriptsnoteheadsscriptsnoteheadsaccidentals

noteheads noteheadsnoteheads

Slow ( dotsnoteheads = 1)

83accidentalsaccidentalsaccidentalsaccidentalsaccidentalsaccidentals

clefs scriptsnoteheads1. dotsnoteheads noteheads noteheads noteheads noteheadsnoteheads noteheads

rests noteheads restsnoteheads

noteheads noteheadsaccidentals noteheadsscriptsnoteheadsscripts noteheads noteheadsaccidentals noteheadsscripts noteheadsscripts

noteheadsscripts845 clefs accidentalsaccidentalsaccidentalsaccidentalsaccidentalsaccidentals noteheadsscripts noteheads

noteheads noteheads noteheadsnoteheadsscripts noteheads noteheads

restsrests rests rests rests rests rests restsscriptsrests restsscripts restsrests rests rests2. restshint: this piece contains no incomplete measures.

clefs accidentals 43 rests restsrests

noteheads noteheads noteheads noteheadsnoteheadsaccidentals noteheadsaccidentals noteheadsaccidentals noteheads noteheadsnoteheads noteheadsaccidentals noteheads3. noteheadsclefsaccidentals45noteheads = 500

noteheads noteheadsnoteheads noteheadsnoteheads

noteheads noteheads accidentalsnoteheadsnoteheads noteheadsaccidentals noteheadsscripts

noteheadsnoteheadsnoteheadsnoteheads noteheads noteheads noteheadsaccidentals noteheads noteheads

noteheads5 clefs accidentals noteheads noteheads noteheadsaccidentals noteheads noteheadsaccidentals noteheadsnoteheads noteheads

dotsscriptsnoteheads noteheadsnoteheadsFasttimesigaccidentalsaccidentalsaccidentalsaccidentalsaccidentalsclefs scriptsnoteheads4. scriptsnoteheadsscriptsnoteheadsnoteheadsscripts

noteheads noteheadsaccidentals noteheadsnoteheads noteheads noteheadsnoteheadsnoteheadsnoteheads noteheads noteheads noteheads noteheadsnoteheads noteheads noteheads noteheads noteheads3

clefs accidentalsaccidentalsaccidentalsaccidentalsaccidentals noteheads noteheads noteheadsscripts noteheads noteheadsnoteheadsnoteheadsnoteheads accidentals noteheads noteheadsscriptsnoteheadsaccidentals noteheadsaccidentals noteheadsaccidentals noteheads noteheadsaccidentals

accidentalsaccidentalsaccidentalsaccidentalsclefs6 accidentals noteheads noteheads

Answers ToMain ExamplesThe answers are formatted to consume the least amount of space, but within the answers themselvesthere are indents and spacing to help facilitate the reading of the le.

Basic Examples. \relative c'' { \clef treble \time 4/4 f,4 g a b c8 b a g f4 e d fis a g f r r2

\bar "|." }

. \relative c'' { \clef treble \time 3/4 b4 a g f bes a g f ees8 f g4 bes8 c d4ees16 d c8 b a g4 \bar "|." }

. \relative c'' { \time 6/4 \clef treble cis2 d1 ees2 d4 cis a2 a8 g fis e b' cisd2. fis2 fis, bes \bar "|."

. \relative c'' { \time 4/4 \clef treble d,16 fis a cis d fis d b a8. g16 fis e8fis16 g fis g a \tuplet 3/2 { bes8 a bes } cis2 \bar ".." }

. \relative c'' { \time 3/4 \key bes \major \clef treble f,4 bes f ees2. d4 bes'c8 d ees2 d8 c bes2 a8 g f4. ees8 f g aes2. \bar "||" }

. \relative c'' { \key b \major \clef treble \time 5/4 b1~ b4 bes2 a4 gis f \tuplet3/2 { ees8 f g~} g8 b \tuplet 3/2 { ais8 b cis~ } cis8 fis, \tuplet 3/2 { cis'8dis e~ } \time 4/4 e8 dis cis b a4. fis8 b1\fermata \bar "||" }

. \relative c { \time 4/4 \clef bass \key bes \major \partial 4 f,4 bes8 c d eesf4 f8 ees f ees d c ees'4 d8 c bes a g f ees4 r d8 r r4 f r g16 f r8 ees16 d cr a' c, f, r \tuplet 3/2 { a8 ees' ces' } bes8 r d, r r f,4 r8 c2. \bar "!" }

. \relative c'' { \key f \minor \clef treble \time 7/8 f,8[-. aes-. b]-. c4.->e,8-. des!2-_ ees4.-^ e'4\fermata ees4-> des-! c8 bes8-. r bes-- r bes4. \keyees \major bes16([ aes bes c d c f, aes b des c bes c) ees,-.] r4\fermata c8 ef g16 f ees d \bar "||" }

. \relative c { \time 5/1 \clef bass c1( e g a) g,( d' c a) e( f b d') c( a g b,)b2 b b b b1 r \bar "|." }

Advanced Examples. \relative c { \time 3/8 \clef bass \key ges \major \tempo "Slow" 4. = 1

\cadenzaOn bes2\fermata \bar "||" \cadenzaOff bes4. aes8 ges aes \tuplet 3/2 {bes16[( aes bes]) } \tuplet 3/2 { ces( bes ces) } \tuplet 3/2 { des[( ees des])} bes32([ aes ges f ges aes bes) f'!]-. ges[-. ges-. ges-. ges]-. \time 4/8ges,8-> ges-> ges-> ges-> ees'[-. ees-. ees-. bes16( ces])~ ces8 ees f, c f[r ges'] r bes[ ces, c aes] \bar "|." }

. \relative c'' { \key f \major \clef treble \time 3/4 r4^\markup { \italic "hint:this piece contains no incomplete measures." } r r8 r s4 r r r8 r r s r r r16 rr2\fermata r8 s r s r s r\fermata \bar "||" }

. \relative c'' { \key g \major \clef treble \time 5/4 \tempo 4 = 500 b4(\( e,dis2) e4( fis c b2) c'4( e dis e g)\) a,8(\( eis fis4 a bes2) a4( fis c b2)\)ais4\( fis'16( g e' d) b( gis e8) dis16( fis a8) g4\) c,\fermata b( fis' b besd) g2 g, d4 \bar ".." }

. \relative c'' { \key des \major \time 4/4 \clef treble \tempo "Fast" bes4-.aes-- ges-. des-- ees2.-_ des8( ees f ges aes bes) c[( aes f des c bes desdes'-.]) c[( aes f des c f c' e]) f( c f, ges) g( d cis ees) f des aes' bes-.ces4 bes aes2 \bar "|." }

Real Life ExampleAfter you have gone away andwalked through the LearningManual, and you feel condent in your tweak-ing skills or your Google-search-for-tweak skills, try out this example. It combines a host of dierenttechniques to bring the piece together. It is also safe to use predened templates either through Fres-cobaldi (or any other front-end program of your choice) or via the internet.

3 MoodsFor Low Reed Instrument

Joshua Nichols

noteheadssfdots noteheads noteheadsflags rests 43noteheads rests noteheadsp

scriptsnoteheadsflagsnoteheads

restspp

restsclefsAdagio lugubre (noteheads = 50)

noteheadsaccidentals noteheads noteheadsI 43 noteheads noteheads 42 accidentals noteheads noteheadsnoteheadsnoteheads noteheads

scriptsnoteheads noteheadsaccidentals noteheadsrestsscriptsnoteheadsscriptsnoteheadssub. fnoteheadsaccidentalsnoteheads 44 scriptsnoteheadsaccidentals noteheads

3

noteheadssub. pnoteheads 43 noteheadsnoteheadsaccidentals noteheadsaccidentals noteheadsnoteheadspp

noteheads noteheadsclefs7

43 noteheadsaccidentalsnoteheadsnoteheadsnoteheads

noteheads noteheadsaccidentals noteheads accidentalsaccidentals noteheads noteheads

noteheadsaccidentalsnoteheadsaccidentals noteheads

noteheadsaccidentals43 noteheadsaccidentalsnoteheadsrests noteheads noteheadsaccidentalsnoteheads

rests noteheadsnoteheads noteheadsnoteheadsaccidentalsflags rests noteheads

mf42accidentals

flagsflagsscriptsnoteheads

restsnoteheads noteheadsscripts

noteheadsscripts noteheadsclefs noteheadsaccidentalsnoteheads noteheadsaccidentals11

noteheadsaccidentals noteheadsnoteheadsaccidentals noteheadsaccidentals accidentals noteheadsnoteheads noteheadsaccidentalsaccidentals noteheadsnoteheadsnoteheads noteheadsaccidentals noteheadsaccidentals noteheadsaccidentals noteheadsflagsflags rests noteheadsf8

3noteheadsclefs16

noteheadsaccidentalsaccidentals noteheads

noteheads noteheadsnoteheadsaccidentals

accidentals noteheadsaccidentals noteheadsnoteheadsffffnoteheads

43 accidentals dotsnoteheadsnoteheadsnoteheadsnoteheadsnoteheads

sub. ppnoteheadsscriptsdotsscripts

ff noteheadsflagsnoteheads

scriptsnoteheads

restsrestsrestsnoteheadsnoteheadsaccidentals noteheadsnoteheadsnoteheads21 clefs noteheadsaccidentalsnoteheadsnoteheads noteheadsnoteheadsnoteheads noteheadsnoteheadsnoteheadsnoteheadsaccidentals noteheads

restsscriptsnoteheads restsnoteheadsnoteheads accidentals44 scriptsnoteheads scriptsnoteheadsnoteheads noteheads42 noteheads3

noteheads noteheadsnoteheadsnoteheadsaccidentals noteheads accidentalsnoteheads noteheads noteheadsnoteheadsflagsclefs28

accidentals43ppnoteheadsrestsaccidentals noteheadsaccidentalsnoteheads noteheadsaccidentalsnoteheadsnoteheadsnoteheads 83noteheads

noteheadsnoteheadsnoteheads noteheadsrests

accidentalsrests rests noteheadsrests rests rests noteheadsnoteheadsaccidentals noteheadsnoteheads noteheads

scriptsclefs33

83 pnoteheads accidentalsrests rests restsrestsnoteheads44 noteheads noteheadsrestspnoteheads

2009, 2013, Joshua Nichols. All Rights Reserved.

2

noteheadsscripts noteheadsscriptsrestsrests noteheadsscripts noteheadsscripts noteheadsscripts

flags rests restsrestsnoteheads noteheads noteheadsscripts noteheadsscripts noteheadsscriptsnoteheadsscriptsclefs noteheadsscriptsrests43 noteheadsscriptsII scripts

restsscripts noteheadsscripts

rests noteheadsscriptsVivo (noteheads = 150) rests noteheadsscripts

noteheads noteheadsaccidentals noteheads noteheadsrests noteheadsscripts noteheadsscripts44 rests accidentals noteheads restsnoteheads43

noteheads noteheadsscripts noteheadsscripts

rests noteheadsscripts428 clefs noteheadssc