A language for music notation

Related tags

lydown
Overview

Build Status

Lydown is a language and compiler for creating music scores, parts and snippets. The lydown code is compiled to lilypond code and then compiled to PDF, PNG or MIDI files.

About

Lydown builds on the ideas put forth by lilypond and makes the following improvements:

  • a greatly simplified syntax for entering notes, for more rapid note entry and improved legibility.
  • ability to enter lyrics and bass figures interspersed with the music.
  • rhythmic macros for rapid entry of repeated rhythmic patterns.
  • zero lilypond boilerplate code.
  • a sane file/folder structure for creating multi-part, multi-movement works with automatic part extraction.

Installation

If you have Ruby on your machine, you can simply install lydown as a gem:

gem install lydown

If not, you can simply grab the release file for your OS, which already includes Ruby.

Once you got lydown installed, you can verify it woks correctly by running:

lydown version

Lydown will display its version and also the version lilypond installed. If lilypond is not installed on your machine, you can install it by either running:

lydown install lilypond

Or by downloading it from the lilypond website.

Hello world in lydown

The following is a basic example of the lydown syntax:

// helloworld.ld
\key:D \time:2/4
4d''\"Hello world!" 6cbag 3fgag6fd 4e

And here's the equivalent lilypond code:

\version "2.18.2"
relative c' {
  \key d major
  \time 2/4
   d'4\"Hello world!" cs16 b a g fs32 g a g fs16 d e4
}

To compile the lydown source file into a PDF and then display it, invoke lydown as follows:

lydown -O helloworld.ld

More examples and resources

Examples of lydown code, used to test lydown, could be found in the specs directory of the lydown repository.

A recent reconstruction of Bach's Markuspassion BWV 247 is the first large-scale work to be written in Lydown.

Additional information and resources could be found on the lydown wiki.

Compiling lydown code

The lydown command line tool can compile the code into lilypond code, PDF, PNG, MIDI or MP3. The program creates an output file with the same name as the input file and the corresponding extension. Specifiying the -O switch causes the output to be opened immediately.

To create a lilypond file:

lydown -O --ly helloworld.lydown

To create a PDF file:

lydown -O --pdf helloworld.lydown

To create a PNG file:

lydown -O --png helloworld.lydown

To create a MIDI file:

lydown -O --midi helloworld.lydown

Proofing mode

Lydown can be run in a special proofing mode designed to minimize the turnaround time between editing and viewing the result when entering new music or when editing existing music. To run lydown in proofing mode, use the proof subcommand:

lydown proof

Lydown will then start to monitor all subdirectories and files in the current directory, and compile them whenever they're changed. Lydown will detect the lines that have changed and insert skip markers in order to speed up compilation and typeset only the music that has actually changed. In addition, notes in the bars that changed will be colored red.

In proof mode, lydown will generate parts and not a score. To include another part for reference along with the part that changed, you can use the include_parts parameter:

lydown proof --include_parts continuo # or:
lydown proof -i continuo

This is useful when editing baroque music for example, or when any other part can give context and aid in verifying the music.

Interactive mode

When invoked without any parameters, an interactive lydown session is started. This mode is useful when working on music involving multiple movements or multiple parts. In this mode, you can move between directories, edit files (using vim), and compile specific movements or specific parts.

Just like in proofing mode, any changes you make to files within the working directory are immediately compiled and shown in the system viewer.

To get a list of available commands, type help.

The lydown syntax

The lydown syntax is designed for faster note entry, better legibility and minimal boilerplate. The lydown syntax takes the basic ideas put forth by lilypond and simplifies them, with the following main differences:

  • musical context (staves, parts, etc) is implicit rather than explicit.
  • whitespace between notes is optional.
  • durations come before notes.
  • duration macros allow rapid entry of repeated rhythmic patterns (such as dotted rhythm).

It must be stressed that lydown is made to process music that is relatively simple, and it was designed to support the processing of baroque music in particular. Therefore, a lot of stuff that is possible with plain lilypond would not be possible with lydown.

For the sake of this tutorial, some familiarity with the concepts and syntax of lilypond is presumed. The lydown code will be shown alongside its lilypond equivalent.

Notes and durations

In lydown, durations are entered before the note to which they refer, and they stay valid for subsequent notes, until a new value is entered:

4c8de2f => c4 d8 e f2

In addition to the usual values (1, 2, 4, 8, 16, 32 etc), lydown adds two shortcuts for commonly used values: 6 for 16th notes and 3 for 32th notes:

8c6de3fefefede2f => c8 d16 e f32 e f e f e d e f2

Lydown recognizes the following values:

l   // longa
0   // breve
1   // whole note (semi breve)
2   // half note
4   // 1/4 note
8   // 1/8 note
6   // 1/16 note
16  // 1/16 note
3   // 1/32 note
32  // 1/32 note
64  // 1/64 note
128 // 1/128 note
256 // 1/256 note

Augmentation dots are entered like in lilypond:

8.c6d 8.e6f 2g => c8. d16 e8. f16 g2
8..g 3g 4c => g8.. g32 c4

Notes can be repeated using the @ placeholder:

[email protected]@@ => c4 c c c

(The repeating note placeholder is useful when entering repeated notes with accidentals).

Chords are written using angled brackets, like in lilypond:

(2<fd>4<ge>) => <f d>2( <g e>4)

Accidentals

Accidentals can be entered using + and -, altering the note relative to the key signature.

8cgb-c2a => c8 g bes c a2
- key: D
4dc-2b- => d4 c bes2

But can also be entered using the characters # for sharp, ß for flat and h for natural:

c#dßeh => cis des e

In lydown notes follow the key signature by default:

- key: g major
ff#fhfßd#bß => fis fisis f f dis bes

The accidental mode can be changed by specifiying the manual accidental mode:

- key: g major
- accidentals: manual
8g6f+edcba2g

In the default, automatic mode, when deviating from the key signature the accidental must be repeated for each note, regardless of barlines.

In the same manner as lilypond, accidentals can be forced by following the note name and accidental with a ! (for a reminder), or ? (for a cautionary accidental in parentheses):

cc+c+!cc? => c cs cs! c c?

A ficta accidental (an non-original accidental that appears above the staff) can be entered using the ^ symbol after the accidental:

cdef+^g

Octaves

In Lydown, the first note in the document carries an absolute octave marker, using the ' and , signs:

c,,   // contrabass octave
c,    // great octave
c     // small octave
c'    // first octave (middle c)
c''   // second octave
c'''  // third octave
...   // etc.

For the following notes, the octave markers ' and , are used for jumping between octaves, using the same rules as lilypond's relative mode:

Grace notes

Grace notes are signified by appending a grace kind after the the duration value:

// grace
6°d8edcd2c

// appoggiatura
6^d8cbag

// acciaccatura
6`dc8bcde

The grace holds until the next change of duration.

Barlines

Just like in lilypond, barlines are taken care of automatically according to the time signature. Final bar lines and repeat bar lines can be entered explicitly by using shorthand syntax:

|: cege :|: cfaf :|

When entering unmetered music, an invisible barline can be added in order to provide line breaks:

-time: unmetered
cdef ?| gag

Repeats with alternatives

Repeats with alternatives can be written by using the following syntax:

|:*2 // start a repeat
|*   // start a volta
*|   // end the repeat

// example: 2 repeats
|:*2 1c d |* e f |* g a *| b c

Rests and silences

Normal rests are written like in lilypond:

4ce2r => c4 e r2

Full bar rests are similar to lilypond, except there's no need to enter the rest value (it is implicit in the time signature):

- time: 3/4
// 4 bar rest in the middle
2c4e R*4 2.g

Silences (Invisible rests) are signified using s for normal silences and S for whole measure silences:

4ddsd
S*2
2.s4d

Beams, slurs and ties

Lydown uses automatic beaming as the default, except in the case of vocal parts (see document settings). Auto beaming can be

Beaming and sluring is similar to lilypond, except the beam/slur start comes before the note:

8(cdef)g[6fe]4f => c8( d e f) g f16[ e] f4

a regular tie is written just like in lilypond:

4g~6gfed2c => g4 ~ g16 f e d c2

Lydown also supports a shortened tie form, where the tied note is not repeated:

4g6&fed2c => g4 ~ g16 f e d c2

Articulation and expression marks

Lilypond shorthand articulation marks can be entered after a backslash

c\^ e\+ g\_ => c-^ e-+ g-_

Common articulation marks can be entered immediately after the note:

// tenuto, staccato, staccatissimo
c_e.g` => c-- e-. g-!

Other arbitrary lilypond articulations can be entered after a backslash:

c\staccato e\mordent g\turn => c\staccato e\mordent g\turn

Note: While whitespace between notes is usually optional, in the case of backslashed articulations you will have to add a whitespace after the articulation, so lydown will be able to parse it.

Dynamic marks are entered before the note to which they apply:

c\f eg

\f cege \p cfaf => c\f e g e c\p f a f

Arbitrary expression markup can be entered as a string following a backslash. Lydown supports basic markdown syntax for formatting the expression:

c\"hello" // displayed above the note
c\_"hello" // displayed below the note
c\<"hello" // right-aligned
c\|"hello" // centered
c\_|"hello" // centered, below the note
c\"_hello_" // italic
c\"__hello__" // bold

Repeated articulation and rhythmic patterns: macros

An important feature of lydown is the macro, which facilitates rapid entry of repeated rhythmic and articulative patterns.

A common scenario is repeated articulation, for example a sequence of staccato notes:

{.}cdefgabc => c-. d-. e-. f-. g-. a-. b-. c-.

A macro can also contain a fully qualified lilypond articulation specifier:

{\tenuto}cege => c\tenuto e\tenuto g\tenuto e\tenuto

Rhythmic macros can be used for repeated rhythmic patterns. A common scenario is a dotted rhythm:

// The _ symbol denotes a note placeholder
{8._6_}cdefgfed => c8. d16 e8. f16 g8. f16 e8. d16

A repeating diminution may also be expressed succintly:

// The @ symbol denotes a repeated pitch
{[email protected]@@}cfgf => c16 c c c f f f f g g g g f f f f

A macro can include both durations and articulation marks:

{[email protected](_._._.)}cdefgfed => c4 ~ c16 d-.( e-. f-.) g4 ~ g16 f-.( e-. d-.)

A macro containing durations will remain valid until another duration or duration macro is encountered. A macro containing articulation only will be valid until another duration, macro or empty macro is encountered:

6{.}gg{}aa => g16-. g-. a a

Named macros

Macros can be defined with a name and reused:

- macros:
  - dotted: 8._6_
{dotted}gaba2g{dotted}abcb2a => g8. a16 b8. a16 g2 a8. b16 c8. b16 a2

Clefs, key and time signatures

Clefs are determined automatically by lydown based on the specified part. In case no part is specified, the default clef is a treble clef. The clef values are the same as in lilypond. The clef can be changed at any time with a clef setting:

- clef: bass
8cdefgabc
- clef: tenor
defedcbd
- clef: bass
1c

Key and time signatures are entered inline as document settings (see below). The key and time values follow the lilypond syntax:

- key: d major
- time: 3/4

In the case of key signatures, accidentals will follow the lydown syntax:

- key: b- major
- key: f+ minor

Key signatures can also be specified using shorthand notation (upper case for major, lower case for minor):

- key: B- // b flat major
- key: f+ // f sharp minor

The default key signature is C major, and the default time signature is 4/4.

Key or time signatures can be changed on the fly:

- time: 4/4
4c e g b
- time: 3/4
c e g 2.c

Pickup bars

Pickup bars (anacrusis, upbeat) are defined with the pickup setting:

- time: 3/4
- pickup: 4
    4g
c8cdcb4aaa
d8dedc4bb

Lilypond Commands and inline settings

Lilypond commands and settings can be entered inline as part of the note stream:

cd \key:E- e \stemDown f

A useful shorthand is for one-time (\once) overrides, with an exclamation mark between the backslash and the command:

\!override:"NoteHead.color = #red"

Multiple arguments can be given, separated by colons. Arguments need to be quoted only if they contain whitespace, or colons:

\!override:AccidentalSuggestion:"#'avoid-slur = #'outside"

Some lilypond command arguments are expected to be quoted. Quotes can be escaped by prefixing them with a backslash:

\footnote:"#'(-1 . 1)":"\"slurred?\""

Inline lyrics

Lyrics for vocal parts can be entered on separate lines prefixed by a > symbol:

4c[8de]4fd(4c[8de]2f)
> Ly-down is the bomb__

Or between notes using quotes:

4c[8de]4fd(4c[8de]2f) >"Ly-down is the bomb__"

Text alignment follows the duration, beaming and slurring of the music, just like in lilypond. Sillables are expected to be separated by a dash. Melismas, i.e. a single sillable streched over multiple notes, is signified by one or more underscores.

Multiple stanzas for the same music can be specified by including the stanza number in parens:

4cege1c
> Ly-down is the bomb.
>(2) Li-ly-pond is too.

Stream switching

Lyrics can be entered in a block, before or after musical notation, by switching streams:

8ccg'gaa4g
8ffeedd4c
=lyrics
Twin-kle twin-kle lit-tle star,
How I won-der what you are.
=music
8g'gffeed4
...

Multiple lyrics stanzas can be written by including the stanza number in parens:

=lyrics(1) // the numbering is optional, same as =lyrics
...
=lyrics(2)
...

Figured bass

Figured bass is entered inline, following notes or even between notes, when multiple figures align with a single note.

c<6>de<5>c // figures are automatically rhythmically aligned 
e<7`> // barred figure
f<6+> // sharp 6th
g<6-> // flat 6th
g<6!> // natural sixth
a<h> // natural third
a<#> // sharp third
a<b> // flat third
b<7#>b<6_> // extender (tenue) line on sharp third
1c2<6><7-> // use durations to change figures over a long note
1c2<><7-> // <> is an empty figure
c<->dec<.> // extender (tenue) line without figures over the four notes

Multiple parts

Multiple parts can be entered in the same file by prefixing each part's content with a -part setting:

- part: violino1
8c'cg'gaa4g
- part: continuo
4cefe

Multiple movements

For multi-movement works, prefix each movement with a -movement setting:

- movement: Adagio
...
- movement: Allegro
...

Multiple voices

Multiple voices on the same staff can be easily entered using the following notation:

1: 8egfdeg4f 2: 4cded u: ...

the u:<\code> command is used to return to single voice (unisono) mode.

Lyrics can be added for individual voices by using inline lyrics:

1: ceg >"yeah yeah yeah" 2: gbd >"no no no" u: ...

Piano scores

Piano/keyboard scores can be created by using the r/l (right/left) prefixes:

- part: piano
r: 8cdeccdec
l: 4cgcg

In order to jump between staves, you can use the special commands \r, \l

r: 8<e'c'> \l g,f+g \r <g'' c'> \l e,,d+e \r
l: 1s

multi-part scores and part extraction

As the example above shows, lydown supports multiple parts in the same file, but parts can also be written in separate files. This is useful for long pieces or those with a large number of parts.

For this we create a main file which defines the score structure:

// score.lydown
- score:
   - [violino1, violino2]
   - viola
   - violoncello
- time: 4/4
- key: c major

Then we enter the music in a separate file for each part:

// violino1.lydown
8c''cg'gaa4g 8ffeedd4c

And so forth.

To compile the score, we use the following command:

lydown -o -s score.lydown

To extract a specific part, we use the -p switch:

lydown -o -p violino1 score.lydown

Colla parte and part sources

lydown provides two ways to reuse a part's music in another part. The first is by defining a part source:

- parts:
  - violino1:
    - source: soprano

When dealing situations such as a choral being doubled by many instruments, a more convenient approach would be the colla_parte setting:

- colla_parte:
  - soprano: violino1, flute1, flute2, oboe1
  - alto: violino2, oboe2
  - tenor: viola, gamba1
  - basso: gamba2

It is important to remember that the colla_parte setting is the opposite of the part source. Instead of defining a source for a part, it defines the parts that follow the source part.

Including another part when extracting parts

When extracing parts, some cases, such as recitatives, require displaying another part together with the part to be extracted. Parts can be included in extracted parts using the include_parts setting:

- parts:
  - continuo:
    - include_parts: tenore

multiple parts can be specified by comma separating them.

Mode specific code

The \mode and \nomode commands can be used to render code for specific modes. This can be useful when the extracted part should display a different music than the score. The mode command causes anything after it to be rendered only when the rendering mode matches the specified mode.

\mode:score 4cege \mode:part 4cded \mode:none 1c

The example above will be render as 4cege1c when in score mode, and as 4cded1c in the extracted part.

To cancel a mode, use either \mode:none or \nomode

Staff and system appearance

Numerous settings can be used to control the way staves and systems are displayed. Normally, lydown will follow standard conventions when putting together a score: the different parts will be ordered correctly (e.g. flutes, then oboes, then strings, then vocal parts, then continuo), and braced/bracketed according to convention.

When a single movement switches between different ensembles, for example a recitativo secco followed by a recitativo accompagnato, empty staves may be hidden using setting empty_staves setting:

- empty_staves: hide

Normally, instrument names are shown according to convention, to the left of each staff in the first system. To hide the instrument names on the first system, use the instrument_names setting:

- instrument_names: hide

The instrument_names setting can also be set to , in which case the instrument name will be displayed above the beginning of each staff in the first system.

To show the instrument name inline at any point in the music, use the \instr command:

- part: flute
R*4
// when no parameter is given, the part name is used, 
// and engraved capitalized with numbers formatted to roman numerals
\instr 4c8eg2c
...
// when the instrument name is specifed, it is used in place of the 
// part name:
\instr:"Flute II" 4c8eg2c

The \instr command can also accept an alignment modifier:

\<instr // right-aligned
\>instr // left-aligned (default)
\|instr // centered

Another setting which controls the display of instrument names is instrument_name_style which can be set to normal or smallcaps, in which case the instrument name will be engraved using small caps.

Rendering MIDI && mp3 files

In order to render the source code into MIDI, the midi format should be specified:

lydown --midi score.ld

The playback tempo can be specified either using the midi_tempo setting:

- midi_tempo: 4=96

Or inline using the tempo command, putting the tempo in parens:

\tempo:(4=120)
cdef
/tempo:(4=54)
gabc

Rendering of mp3 files requires both timidity and LAME to be installed.

Including files

Lilypond files can be included into the generated lilypond code by using include settings:

- include: abc.ly

Multiple files can be included by adding an include setting for each file. Mode-specific include files can be defined by nesting include statements inside of score or parts settings:

- score:
  - include: def.ly // included only in score mode
- parts:
  - include: ghi.ly // included only in part mode

The include statements are placed inside of a movement's score block as lilypond \include commands, so for each movement different includes can be defined.

To place includes at the beginning of the lilypond document, includes should be defined under the document setting:

- document:
  - include: def.ly // this will be included at the top of the lilypond doc

Pathnames are relative to the lydown source file.

Requiring packages

Lyp packages can be loaded by using -include settings, usually in work.ld:

- require: better-slurs

Including templates

In addition to including normal lilypond files, Lydown also supports the rendering of templates into the generated lilypond doc, by using the .ely extension. The templates should be written using Ruby's ERB syntax, and are supplied with the lydown context object as self. A trivial example:

\markup {
  % will output either 'score' or 'part' according to the rendering mode
  <%= self.render_mode %> 
}

Adding a front cover

To be continued...

Issues
  • Looks like a confusion in getting arguments

    Looks like a confusion in getting arguments

    Hi! I'm trying to check out installation and when I evaluate lydown --version, I'm getting this error:

    {"format"=>:pdf, "path"=>"--version", "source_filename"=>"--version", "output_filename"=>"--version"}
    Processing score...
    /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/work.rb:56:in `process_work_files': Could not read --version (LydownError)
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/work.rb:20:in `initialize'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/compiler.rb:174:in `new'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/compiler.rb:174:in `create_work_from_opts'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/compiler.rb:24:in `process'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/commands.rb:64:in `compile'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor/command.rb:27:in `run'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor/invocation.rb:126:in `invoke_command'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor.rb:359:in `dispatch'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor/base.rb:440:in `start'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/bin/lydown:5:in `<top (required)>'
        from /usr/local/bin/lydown:23:in `load'
        from /usr/local/bin/lydown:23:in `<main>'
    

    Something similar I get, when I'm trying to compile a lydown file:

    Ales:Desktop alestsurko$ lydown -O --pdf HelloWorld.lydown
    {"format"=>:pdf, "open_target"=>true, "path"=>"--pdf", "source_filename"=>"--pdf", "output_filename"=>"--pdf"}
    Processing score...
    /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/work.rb:56:in `process_work_files': Could not read --pdf (LydownError)
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/work.rb:20:in `initialize'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/compiler.rb:174:in `new'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/compiler.rb:174:in `create_work_from_opts'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/compiler.rb:24:in `process'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/lib/lydown/cli/commands.rb:64:in `compile'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor/command.rb:27:in `run'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor/invocation.rb:126:in `invoke_command'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor.rb:359:in `dispatch'
        from /Library/Ruby/Gems/2.0.0/gems/thor-0.19.1/lib/thor/base.rb:440:in `start'
        from /Library/Ruby/Gems/2.0.0/gems/lydown-0.10.0/bin/lydown:5:in `<top (required)>'
        from /usr/local/bin/lydown:23:in `load'
        from /usr/local/bin/lydown:23:in `<main>'
    
    opened by ales-tsurko 8
  • Translate Ripple code into Lydown code

    Translate Ripple code into Lydown code

    • Usage: lydown translate 01-choro The above command will translate the entire subdirectory, leaving the role files in place and creating new lydown files in the same directory
    • Translation code will reside in lib/lydown/translation/ripple
    • Parsing using custom treetop rules
    • Look for macros in _work.yml, _movement.yml files
    • Parse relative command to determine octave of first note.
    • Ignore curly brackets
    • Parse and translate note events: note head, duration, expressions
    • Parse key signature and translate chromatic note names into diatonic ones
    • Parse and translate duration macros
    • Look for lyrics files and as them to output under a =lyrics section
    enhancement 
    opened by ciconia 2
  • Parts sourced from other parts

    Parts sourced from other parts

    In movement.ld:

    - parts:
      - alto:
        - source: soprano // sources both music and lyrics from soprano
      - violino:
        - music_source: soprano // sources music only from soprano
    
    opened by ciconia 1
  • Exclude part from score

    Exclude part from score

    Add option to exclude part from score. Suppose there's a part that's there only for part extraction, not for being rendered as part of the score.

    - parts:
      - tenore_without_turbas:
        - render_modes: part
    

    Where the default is part, score.

    opened by ciconia 1
  • Mode specific code

    Mode specific code

    The code will be rendered only when the rendering mode fits corresponds to the specified mode:

    \score // everything after this directive will be rendered only in score mode
    \part // everything after this directive will be rendered only in part mode
    \all // everything after this directive will be rendered in any mode
    
    opened by ciconia 1
  • lypad - Lilypond package manager (non lydown-related)

    lypad - Lilypond package manager (non lydown-related)

    The idea is to be able to install libs & tools related to lilypond, and use them without too much hassle.

    • Dependencies for a project are declared in a filename called Lypadfile
    • packages are Ruby gems, downloadable using the gem tool.
    • package names are prefixed with lypad-. That way we can tell which gems are lypad-related. For example, a package called lilyjazz will be published as a gem called lypad-lilyjazz.
    • system is ruby based.
    • lypad command line tool is basically a wrapper around gem / bundler.
    • lypad also provides some lib tools for stuff like installing fonts, or changing the stock lilypond installation in any way.

    When Lypad is installed it modifies lilypond to add a few lilypond commands used to reference and load packages.

    Loading packages in lilypond sources

    \require "lilyjazz" % that's all folks
    

    Command line interface

    lypad update # updates the lypad installation and installs hooks in the current lilypond installation
    lypad install # installs anything in Lypadfile
    lypad install <gem> # installs the gem
    lypad install <gem> -s # installs the gem and writes it to Lypadfile
    lypad uninstall <gem>
    lypad list # lists all lilypond-related gems
    
    opened by ciconia 1
  • Accept whitespace between = and stream selector

    Accept whitespace between = and stream selector

    right now lydown recognizes a stream switch only without any whitespace:

    =lyrics
    

    while

    = lyrics
    

    is considered illegal and leads to a mess. This should be accepted as valid syntax.

    opened by ciconia 0
  • Use absolute octave markers for first note

    Use absolute octave markers for first note

    This would avoid some of the confusion with relative mode, and facilitate reading and writing the source code.

    enhancement 
    opened by ciconia 0
  • When run on a movement, lydown should process the work directory

    When run on a movement, lydown should process the work directory

    When invoked in a movement directory, lydown should automatically process the work.ld file of the parent directory, and treat the movement name as an -m parameter.

    Same thing when the specified path given to lydown is a movement. For example:

    BWV247$ lydown 01-choro
    

    Should be equivalent to

    BWV247$ lydown -m 01-choro
    

    See also issue #2.

    opened by ciconia 0
  • Better lilypond variable names

    Better lilypond variable names

    It turns out numbers and other symbols can be used in variable names, provided they are quoted.

    So, instead of doing the whole dance of converting numbers to roman numbers, capitalizing, upcasing etc, we use a much simpler variable naming scheme, which reflects the stream path in the work context:

    "01-choro/soprano/music" = { ... }
    "01-choro/soprano/lyrics/..." = { ... }
    "01-choro/violino1/music" = { ... }
    
    % usage:
    ... \"01-choro/violino1/music" ...
    
    opened by ciconia 0
  • compile issue in lilypond_doc.rb

    compile issue in lilypond_doc.rb

    Compiling to anything but a .ly file results in an error:

    /tmp/lydown20160830-5140-17wl25n:4:1: error: unknown escaped string: '\pinclude'
    
    \pinclude "/home/REDACTED/.rbenv/versions/2.3.1/lib/ruby/gems/2.3.0/gems/lydown-0.14.0/lib/lydown/ly_lib/lib.ly"
    

    I tracked the issue down to line 9 of lib/lydown/templates/lilypond_doc.rb, which reads "\pinclude" rather than "\include". Changing that line and re-building/installing the gem seems to resolve the issue.

    opened by hushpiper 0
  • Add notation for alternatives

    Add notation for alternatives

    Allow specifying two alternatives. The first in black the second in red.

    opened by ciconia 0
  • Add statistics for processed file

    Add statistics for processed file

    • note count
    • part count
    • movement count
    • file count
    opened by ciconia 0
  • Add syntax for debugging slurs (showing & tweak control points)

    Add syntax for debugging slurs (showing & tweak control points)

    Show control points:

    8a (?6bc de8d)
    

    Tweak control points:

    8a (!{[0,0.5][0,0.5][0,0.5][0,0.5]}6bc de8d)
    
    // omit zero values:
    8a (!{[,0.5][,0.5][,0.5][,0.5]}6bc de8d)
    
    // move all control points by same displacement:
    8a (!{0,0.5}6bc de8d)
    
    // change only second segment of broken slur ({} means 0 displacement)
    8a (!{}{0,0.5}6bc \break de8d)
    

    Things to consider:

    • Tweaking ties:
    //show control points
    1c~? 8c
    //tweak:
    1c~!{[0,0.5][0,0.5][0,0.5][0,0.5]} 8c 
    
    • mode-specific tweaks

    Documentation for modifying slurs:

    http://lilypond.org/doc/v2.18/Documentation/notation/modifying-shapes

    Show control points code here:

    https://github.com/openlilylib/snippets/blob/master/debugging-layout/display-control-points/display-curve-control-points.ly

    opened by ciconia 0
  • Use one-line-breaking in proof mode

    Use one-line-breaking in proof mode

    Here:

    http://lilypond.org/doc/v2.18/Documentation/notation/one_002dline-page-breaking

    and also:

    http://leighverlag.blogspot.fr/2015/02/panorama-mode.html

    Since the page width is automatically adjusted, this looks like a good fit. With this algorithm, we can expect a significant speedup in compilation.

    opened by ciconia 0
  • Use minimal_breaking in proofing mode

    Use minimal_breaking in proofing mode

    In order to potentially speed up lilypond when in proof mode, use the minimal-breaking algorithm:

    \paper {
      page-breaking = #ly:minimal-breaking
    }
    
    opened by ciconia 0
  • Better page/line breaks

    Better page/line breaks

    From a discussion on lilypond-user:

    - score:
      // page breaks on specific measures
      - page_breaks: 13, 27, 50
      // line breaks on specific measures
      - line_breaks: 14, 25
    

    See also issue #38

    opened by ciconia 0
  • Package lydown using traveling ruby

    Package lydown using traveling ruby

    Create a single file archive using traveling-ruby for osx and linux that includes:

    • ruby 2.2.x
    • lydown
    • lilypond 2.19.x

    A copy of lilypond will be bundled as part of the release (for each platform), and used exclusively from within lydown. lydown should be able to detect that a lilypond distribution is present inside its tree, and use it instead of looking for a lilypond installation.

    In addition, we should prepare an installer script that could be downloaded and piped into bash, as used by tools like rvm.

    So in the README file the installation instructions would include:

    To install lydown issue the following command in your terminal:

    curl -s http://git.io/p6oxyA | bash
    

    The installer should script referenced by the URL should download the latest release for the user's platform, untar it, and install it in the relevant location (~/.lydown). So the release's lib directory would be copied to ~/.lydown/lib, and the lydown binary would be at ~/.lydown/lib/app/bin/lydown. The installer will also create a symlink from ~/.lydown/lib/app/bin/lydown to ~/bin/lydown.

    opened by ciconia 0
  • Shorthand for switching parts

    Shorthand for switching parts

    Inspired by alda:

    violino1: ...
    violino2: ...
    ...
    
    opened by ciconia 0
  • Command and provisions for installing lilypond

    Command and provisions for installing lilypond

    In order to make installation easier, and also in order to be able to use a relatively up to date version of lilypond, lydown should be able to install its own copy of lilypond, which it should download (the binary that is) and install somewhere.

    Mode of operation:

    • When lydown is invoked (for compilation), it checks that lilypond is installed, and verifies its version. If lilypond is not installed or too old, lydown should display an error message and suggest installing lilypond by issuing a command such as lydown install lilypond, and then exit.
    • When lydown is invoked with the version command (lydown version), it should display the lydown version as well as the lilypond version. If lilypond is not available or too old, it should display the error message and suggest installing lilypond as above.
    • When the install command is invoked, lydown performs the following:
      • detect the platform
      • download the relevant archive from the lilypond website
      • extract its content (according to platform), then put it in /usr/local/lydown/lilypond/<version>/
      • create a symlink at /usr/local/bin/lilypond
      • test that lilypond works by detecting its version

    Remarks:

    • Windows not supported at first, only linux and osx
    • Should eventually add commands to uninstall, list versions etc
    opened by ciconia 1
Releases(0.14.0)
Owner
Sharon Rosner
père, bricoleur, rêveur
Sharon Rosner
A beautiful cross platform Desktop Player for Google Play Music

Google Play Music™ Desktop Player Windows: MacOS / Linux: Run "Google Play Music" as a standalone desktop app. Never again will you have to hunt throu

Samuel Attard 8.5k Sep 12, 2021
🎵 Music notation engraving library for MEI with MusicXML and Humdrum support and various toolkits (JavaScript, Python)

Verovio is a fast, portable and lightweight library for engraving Music Encoding Initiative (MEI) digital scores into SVG images. Verovio also contain

RISM Digital Center 426 Sep 22, 2021
Music typeset with the Lilypond system

Intro (from long ago) This repo contains sheet music typeset with the Lilypond typesetter. The music chosen is in favour of cello music (mostly chambe

Enthusiastic about  the Cello 95 Sep 24, 2021
网易云音乐第三方

ieaseMusic Elegant NeteaseMusic desktop app, Rock with NeteaseMusic ?? Built by Electron, React, MobX, JSS API 由 Binaryify/NeteaseCloudMusicApi 提供。 Pr

null 8.6k Sep 22, 2021
OpenSheetMusicDisplay renders sheet music in MusicXML format in your web browser based on VexFlow. OSMD is brought to you by PhonicScore.com.

OpenSheetMusicDisplay (OSMD) A MusicXML renderer for the Browser opensheetmusicdisplay.org About OSMD • Demo • Key Features • Limitations • How to Use

Open Sheet Music Display 800 Sep 15, 2021
A music programming language for musicians. :notes:

Installation | Docs | Changelog | Contributing composers chatting Alda is a text-based programming language for music composition. It allows you to co

Alda 4.7k Sep 25, 2021
A Music programming language. Translates source code into MIDI. Includes a player. Supports MIDI-Karaoke. Includes a MIDI analyzer.

Get Started | Features | Screenshots | Programming | CLI | Contribute | License Midica is an interpreter for a Music Programming Language. It translat

Jan Trukenmüller 47 Sep 17, 2021
MuseScore is an open source and free music notation software. For support, contribution, bug reports, visit MuseScore.org. Fork and make pull requests!

Music notation and composition software MuseScore is an open source and free music notation software. For support, contribution, and bug reports visit

MuseScore 6.3k Sep 24, 2021
C++ library and Python bindings for the Music Encoding Initiative format

LibMEI LibMEI is a C++ library for reading and writing MEI files It is developed by the Distributed Digital Music Archives and Libraries Lab at the Sc

Distributed Digital Music Archives and Libraries Lab 49 Aug 30, 2021
A JavaScript library for rendering music notation and guitar tablature.

VexFlow 3 A JavaScript library for rendering music notation. Copyright (c) 2010 Mohit Muthanna Cheppudira Sponsor this Project If you use VexFlow in y

Mohit Cheppudira 3.1k Sep 25, 2021
Music player for deepin desktop environment.

deepin-music Deepin music is a local music player with beautiful design and simple functions developed by Deepin Technology. Dependencies Build depend

Wuhan Deepin Technology Co.,Ltd. 155 Sep 16, 2021
Mopidy is an extensible music server written in Python

Mopidy Mopidy is an extensible music server written in Python. Mopidy plays music from local disk, Spotify, SoundCloud, Google Play Music, and more. Y

Mopidy 7.2k Sep 17, 2021
Frescobaldi LilyPond Editor

README for Frescobaldi Homepage: http://www.frescobaldi.org/ Main author: Wilbert Berendsen Frescobaldi is a LilyPond sheet music text editor. It aims

Frescobaldi 501 Sep 21, 2021
music library manager and MusicBrainz tagger

beets Beets is the media library management system for obsessive music geeks. The purpose of beets is to get your music collection right once and for

beetbox 10.4k Sep 15, 2021
Lilypond music preprocessor

Ripple - DRY for Lilypond Ripple is a small program that helps you generate scores and parts without repeating yourself, performing complex includes o

Sharon Rosner 21 Mar 24, 2020
web based music sheet viewer (go, pdfjs) as a single binary

Digital Music Stand A simple cross-platform browser-based pdfjs-based viewer to display and search music sheets. A single binary including all assets.

Patrick Wieschollek 21 Aug 27, 2021
Streaming music player that finds free music for you

Desktop music player focused on streaming from free sources Links Official website Mastodon Twitter Support channel (Matrix): #nuclear:matrix.org Disc

null 6.8k Sep 17, 2021
The git repository of the advanced drum machine

Hydrogen drum machine Hydrogen is an advanced drum machine for GNU/Linux, Mac and Windows. It's main goal is to bring professional yet simple and intu

Hydrogen 702 Sep 15, 2021
Collaborative Programmable Music

888 888 _ooooooooo._ 888 ,o888PP""""PP88

Overtone 5.2k Sep 24, 2021