Soundboard & Soundboard Scholar

I’ve been holding off making this announcement, but I’m going to go ahead and post it: I am now the musical engraver for the magazines “Soundboard” & “Soundboard Scholar”!

A few years back I became a member of the Guitar Foundation of America and from that time forward I was thinking about how I could contribute to the GFA. My answer came as a combination of my specific talents and knowledge. Who better to typeset music and musical excerpts than a guy who’s taught rudiments and music technology? Combine that with a deep love of the guitar, aesthetics of scoring, and a complete computer nerd and you’ve got me in a nutshell.

I’ve submitted all the scores for the next issue of Soundboard and am now just doing some work on Soundboard Scholar. How am I doing this typesetting? Open source of course… I’m using Lilypond as the vehicle to typeset. Unlike other notation programs like Finale/Sibelius it is rules based and it creates the layouts itself (everything right down to the arch of a slur and how far the end points are from noteheads). I’ve spent the last 6 months working on my own ‘house rules’ and creating a cheat sheet for classical guitar. I believe the result to be something truly special.

All this has happened while I quietly launched a new link in this site’s menu called ‘Stella Pulvis’ (Ok so I’m not only a computer/guitar geek, but also a space guy…. the name is Latin meaning ‘space dust’, from a famous Carl Sagan quote). ‘Stella’ is my freelance typesetting service. I’ve already been very busy with 10+ scores this summer.¬†Since Lilypond is open source software and free, I will donate part of any income I make from this endeavor back to the developers of the software as my little thank you to them.

I’ll be posting examples of the notation here soon under the ‘Stella’ link, and I encourage you to take a look when they appear and if you like my ¬†work and have something you’d like notated, get in touch!


My initiation to programming: Rudi

Exciting news: I’ve created a new program which randomly generates music theory/rudiments worksheets and corresponding answer keys. I’ve been working on this a few months and I’ve got most of the bugs worked out.
To use the program itself you need to download the source and you have to have Python3 and lilypond installed on linux.
The code can be found here:

If you don’t want to do it the ‘hard’ way, a former guitar student of mine is creating a web interface, you just go to the website, click the options you want and poof! you get two pdfs to print off and use.
Justin’s website can be found here:

Of course all the code is free to use, change… basically do whatever you want with… I wrote this to help my life out at university, now I give it away freely to whoever else wants it (my thanks to the open source community, Python, and of course Lilypond)

Lilypond variables part 2 – different page layouts for parts and scores

“Necessity is the mother of invention”

I’m typesetting a piece for 2 guitars and in the end I want to print off individual parts and a score. This can easily be achieved in Lilypond using the following method:

  • First I create a file called “” this is the file which will contain all the music. I make 2 variables called “classicalguitara” and “classicalguitarb” being the notes for each part
  • next I make a file called “” and inside this file I include a statement to load the file with the notes in it and then I call for the first guitar part by it’s variable name:

    \include “”
    { \classicalguitara }

  • I then repeat the process for the guitar 2 part with a file name “” containing the following code:

    \include “”
    { \classicalguitarb }

  • And finally for the score I create a file called “” containing:

    \include “”
    { << \new Staff { \guitara } \new Staff { \guitarb } >> }

Now for the real problem….I need to have logical page breaks (which will happen in different places for the 2 guitar parts and the score). Now if I put in a page break into a single guitar part using the command:


then the score will break in the same place….this will really be a problem when it comes to different page break locations for each of the parts…..there has got to be a good way to deal with this without constantly changing code for each individual part! And that’s when it came to me….wonderful variables can save the day…’s the low down:

Instead of using the page break command in the parts I use a variable called “partpagebreak”
then in the individual guitar files ( and I add the following line:

partpagebreak = { \pageBreak }

And in the score file ( I add the following line:

partpagebreak = { }

Now when I print the individual parts the command \partpagebreak will be replaced with the command for a page break and when I print the score the same variable will be converted into an empty space…problem fixed….different page layouts using the same code. Very cool!

Note: If I actually wanted to have specified page breaks in the score I could easily create a variable called “scorepagebreaks” and that would do the trick

Lilypond Template

With Lilypond each time I start a new project I start with a template file….here is the code:

%% Headers
\version “2.10.33”
\header {
title = “”
subtitle = “”
tagline = “Eugene Cormier – 2008”
\paper {
print-page-number = ##f
ragged-last-bottom = ##t
ragged-right = ##f
indent = 0\in
#(set-global-staff-size 20)

%% Variables

% Time
notimesig = { \override Staff.TimeSignature #’transparent = ##t }
numbertimesig = { \override Staff.TimeSignature #’style = #'() }

% Key
nokeysig = { \override Staff.KeySignature #’transparent = ##t }
nokeycancel = { \set Staff.printKeyCancellation = ##f }

% Barlines
nobarlines = { \override Staff.BarLine #’transparent = ##t }
nobarlinenumbers = { \override Score.BarNumber #’transparent = ##t }

% Clefs
noclefresize = { \override Staff.Clef #’full-size-change = ##t }
noclef = { \override Staff.Clef #’transparent = ##t }

% notes
nonoteheads = { \override NoteHead #’transparent = ##t }
nostems = { \override Stem #’transparent = ##t }
nobeams = { \override Beam #’transparent = ##t }

%% Body

After this all I need to do is put in the code for the music I want to enter and I have variables defined for most of the most common changes I need to make.

Note: before using this code you should:

  • change the \version # to match whichever version of lilypond you are using….remember this number is very important for down the road when new versions of Lilypond are released….if some of the code is different in newer versions, this number will help Lilypond automatically update your code to work with the new version
  • change the tagline to your own name

Lilypond variables

I use Lilypond quite a lot, and over time I’ve realized the usefulness of variables.

In Lilypond you can easily make a variable by doing the following:

variablename = { whatever you want your variable to contain }

let me give an example….If I want to typeset a piece for guitar quartet (or any collection of instruments) there is certain information that will be used for each instrument:

\time 4/4
\key e \major
\partial 8

each of these lines would be nesseary for each individual part….the first line defines the time signature as 4/4, the second line defines the key signature and the last line tells Lilypond to have a pickup measure or partial measure) which is an eighth note duration.

to put this in a variable all I need to do is this:

piecesetup = {
\time 4/4
\key e \major
\partial 8

now in each of the individual guitar parts all I have to enter to get all those is:


Note: when you define the variable, you don’t put a \ in front, but when you call for the variable in a part you must put the \ before the variable name (also be careful, you can’t use numbers or special characters in your variable name….just letters)

One nice aspect of this is after you’ve created all 4 guitar parts using the \piecesetup variable if you realize the key signature was wrong, you only need to change it once in the variable and all the parts are automatically fixed.

Combine noteheads of different values in Lilypond

I’ve been recently typesetting some classical guitar notation into Lilypond and wanting to get as close to the original as possible I noticed that Lilypond was handling doubled notes with different values incorrectly (for my purposes).

Here is some example code to demonstrate what I mean:

\relative c”{
<<{ g8 c g c g2 } \\{ g4. c8 g2 }>>



To get around this use the “Staff.NoteCollision” command like this:

\relative c”{
\override Staff.NoteCollision #’merge-differently-dotted = ##t
<<{ g8 c g c g2 } \\{ g4. c8 g2 }>>

And the resulting output:


Please note: this is how it works on my Lilypond which is an older version (2.10.33) which ships with Ubuntu 8.10. If you are using the newest stable version (2.12.1) the command looks a little different:

\relative c”{
<<{ g8 c g c g2 } \\{ g4. c8 g2 }>>