LilyPond wiki - User contributions [en]

Talk:SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines

2026-05-25T19:54:54Z

Lemzwerg: /* Title Change */ Reply

== Title Change ==

I believe that “non-” in the current page title is a typo; the title should instead read “… with SpanBars for special bar lines.” @[[User:Lemzwerg|Lemzwerg]] [[User:Gabriel Ellsworth|Gabriel Ellsworth]] ([[User talk:Gabriel Ellsworth|talk]]) 18:39, 25 May 2026 (UTC)

:Agreed – and moved -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 19:54, 25 May 2026 (UTC)

LSR 299

2026-05-25T19:54:24Z

Lemzwerg: Changed redirect target from SemiChoirStaff is a ChoirStaff with SpanBars for non-special bar lines to SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines

#REDIRECT [[SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines]]

Talk:SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines

2026-05-25T19:54:04Z

Lemzwerg: Lemzwerg moved page Talk:SemiChoirStaff is a ChoirStaff with SpanBars for non-special bar lines to Talk:SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines without leaving a redirect

SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines

2026-05-25T19:54:04Z

Lemzwerg: Lemzwerg moved page SemiChoirStaff is a ChoirStaff with SpanBars for non-special bar lines to SemiChoirStaff is a ChoirStaff with SpanBars for special bar lines without leaving a redirect

If you wish to typeset <code>|.</code> and friends as connected in a <code>ChoirStaff</code> while ordinary bar lines stay unconnected, you can add the <code>Span_bar_engraver</code> and instruct it to omit the <code>|</code>-style bars.

In this example a new context, <code>SemiChoirStaff</code>, is created to achieve this.

<lilypond version="2.24">
mus = {
\clef F
c4 d e f | c d e f \bar "||"
c4 d e f | c d e f \bar "|."
}

\layout {
\context {
\ChoirStaff
\name "SemiChoirStaff"
\consists "Span_bar_engraver"
\override SpanBar.stencil =
#(lambda (grob)
(if (string=? (ly:grob-property grob 'glyph-name) "|")
(set! (ly:grob-property grob 'glyph-name) ""))
(ly:span-bar::print grob))
}
\context {
\Score
\accepts SemiChoirStaff
}
}

\score {
\new SemiChoirStaff {
<<
\new Staff \mus
\new Staff \mus
>>
}
}
</lilypond>

[[Category:Contexts and engravers]]
[[Category:Scheme]]
[[Category:Workaround]]
[[Category:Snippet]]

Magnetic lyrics: snap syllables together if the hyphen inbetween is too short

2026-05-19T05:11:08Z

Lemzwerg: Make it an official snippet

The current code that LilyPond uses to handle lyric hyphens (i.e., <code>LyricHyphen</code> grobs) often leads to very short hyphens or even small gaps between syllables with no hyphen visible. This snippet merges adjacent syllables into one string in such cases, also taking care of ligatures as if the string was not hyphenated.

It supersedes previous implementations of “magnetic snap” engravers that were in circulation via the lilypond-user mailing list.

<lilypond version="2.24">
% magnetic-lyrics.ily
%
% written by
% Jean Abou Samra <jean@abou-samra.fr>
% Werner Lemberg <wl@gnu.org>

#(define (Left_hyphen_pointer_engraver context)
"Collect syllable-hyphen-syllable occurrences in lyrics and store
them in properties. This engraver only looks to the left. For
example, if the lyrics input is 'foo -- bar', it does the
following.

* Set the `text` property of the `LyricHyphen` grob between 'foo' and
'bar' to 'foo'.

* Set the `left-hyphen` property of the `LyricText` grob with text
'foo' to the `LyricHyphen` grob between 'foo' and 'bar'.

Use this auxiliary engraver in combination with the
`lyric-text::apply-magnetic-offset!` hook."
(let ((hyphen #f)
(text #f))
(make-engraver
(acknowledgers
((lyric-syllable-interface engraver grob source-engraver)
(set! text grob)))
(end-acknowledgers
((lyric-hyphen-interface engraver grob source-engraver)
(when (not (grob::has-interface grob 'lyric-space-interface))
(set! hyphen grob))))
((stop-translation-timestep engraver)
(when (and text hyphen)
(ly:grob-set-object! text 'left-hyphen hyphen))
(set! text #f)
(set! hyphen #f)))))

#(define (lyric-text::apply-magnetic-offset! grob)
"If the space between two syllables is less than the value in
property `LyricText.details.squash-threshold`, move the right syllable
to the left so that it gets concatenated with the left syllable.

Use this function as a hook for `LyricText.after-line-breaking` if the
`Left_hyphen_pointer_engraver} is active."
(let ((hyphen (ly:grob-object grob 'left-hyphen #f)))
(when hyphen
(let ((left-text (ly:spanner-bound hyphen LEFT)))
(when (grob::has-interface left-text 'lyric-syllable-interface)
(let* ((common (ly:grob-common-refpoint grob left-text X))
(this-x-ext (ly:grob-extent grob common X))
(left-x-ext
(begin
;; Trigger magnetism for left-text.
(ly:grob-property left-text 'after-line-breaking)
(ly:grob-extent left-text common X)))
;; `delta` is the gap width between two syllables.
(delta (- (interval-start this-x-ext)
(interval-end left-x-ext)))
(details (ly:grob-property grob 'details))
(threshold (assoc-get 'squash-threshold details 0.2)))
(when (< delta threshold)
(let* (;; We have to manipulate the input text so that
;; ligatures crossing syllable boundaries are not
;; disabled. For languages based on the Latin
;; script this is essentially a beautification.
;; However, for non-Western scripts it can be a
;; necessity.
(lt (ly:grob-property left-text 'text))
(rt (ly:grob-property grob 'text))
;; Append new syllable.
(ltrt (if (and (string? lt) (string? rt))
(string-append lt rt)
(make-concat-markup (list lt rt))))
;; Right-align `ltrt` to the right side.
(markup (grob-interpret-markup
grob
(make-translate-markup
(cons (interval-length this-x-ext) 0)
(make-right-align-markup ltrt)))))
;; Don't print `left-text`.
(ly:grob-set-property! left-text 'stencil #f)
;; Set text and stencil (which holds all collected
;; syllables so far) and shift it to the left.
(ly:grob-set-property! grob 'text ltrt)
(ly:grob-set-property! grob 'stencil markup)
(ly:grob-translate-axis! grob (- delta) X)))))))))

#(define (lyric-hyphen::displace-bounds-first grob)
;; Make very sure this callback isn't triggered too early.
(let ((left (ly:spanner-bound grob LEFT))
(right (ly:spanner-bound grob RIGHT)))
(ly:grob-property left 'after-line-breaking)
(ly:grob-property right 'after-line-breaking)
(ly:lyric-hyphen::print grob)))

%% demonstration

music = {
<<
{ d'4 4 4 4 |
r4 4 4 4 }
\addlyrics { suf -- fice baff -- ling
car -- fuff -- ling }
>>
}

\markup "Without magnetic lyrics:"

\score {
\music
}

\markup "With magnetic lyrics:"

\score {
\music

\layout {
\context {
\Lyrics
\consists #Left_hyphen_pointer_engraver
\override LyricText.after-line-breaking =
#lyric-text::apply-magnetic-offset!
\override LyricHyphen.stencil =
#lyric-hyphen::displace-bounds-first
\override LyricText.details.squash-threshold = 0.4
\override LyricHyphen.minimum-distance = 0
\override LyricHyphen.minimum-length = 0.4
\override LyricSpace.minimum-distance = 1
}
}
}

\paper {
line-width = 83\mm
ragged-last = ##f
}
</lilypond>

[[Category:Vocal music]]
[[Category:Spacing]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

Magnetic lyrics: snap syllables together if the hyphen inbetween is too short

2026-05-19T05:07:31Z

Lemzwerg: Don't use Texinfo markup in documentation strings

User talk:Ksnortum

2026-05-18T04:40:52Z

Lemzwerg: /* Templates for convert-ly */

== Please be careful while using 'Edit' ==

Hello Knute! There is currently a bug in the 'Edit' mode: If you only change some details in the description (i.e., not touching the LilyPond code), the <code><lilypond></code> block gets ‘destroyed’ and is no longer rendered as an image. Please use 'Edit source' instead for the time being to avoid that. -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 17:26, 8 April 2026 (UTC)

:Got it, thanks. [[User:Ksnortum|Ksnortum]] ([[User talk:Ksnortum|talk]]) 19:34, 8 April 2026 (UTC)
:...and thanks for cleaning up the mess! [[User:Ksnortum|Ksnortum]] ([[User talk:Ksnortum|talk]]) 14:58, 10 April 2026 (UTC)
::You're welcome! -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 15:44, 10 April 2026 (UTC)

== Templates for convert-ly ==

I noticed that there are templates for convert-ly-stable (pointing to 2.24) and convery-ly-devel (pointing to 2.25). Should these be changed to 2.26 and 2.27 respectively? The template for convert-ly-devel is only used in a handful of places and convert-ly-stable doesn't look like it's used at all. --[[User:Ksnortum|Ksnortum]] ([[User talk:Ksnortum|talk]]) 19:05, 17 May 2026 (UTC)

: In the long run, yes. I suggest we wait for 2.26.1, then the transition to 2.26 could start in the Wiki for all snippets. -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 04:40, 18 May 2026 (UTC)

Time signature with alternate in parentheses

2026-04-15T04:35:44Z

Lemzwerg: Aaand another improvement.

In polymetric music, a composer may indicate beat structure by following one time signature with another in parenthesis, for example, ‘3/4 (6/8)’ indicating a 6/8 beat in a 3/4 measure, or ‘6/4 (6/8)’ indicating a 6/8 beat in a 6/4 measure.

This snippet provides a music function <code>\timeP</code> that is a small Scheme wrapper around the <code>\compound-meter</code> markup function. It overrides the <code>TimeSignature</code> stencil once to display both a regular and an alternate time signature.

<lilypond version="2.24">
timeP =
#(define-music-function (t tp) (list? list?)
(define ((time-parenthesized-time t tp) grob)
(let ((m1 (grob-interpret-markup
grob (markup #:compound-meter t)))
(m2 (grob-interpret-markup
grob (markup #:compound-meter tp))))
(ly:stencil-combine-at-edge
m1 X RIGHT
(parenthesize-stencil m2 0.1 0.4 0.4 0.1)
0.3)))
#{
\once \override Timing.TimeSignature.stencil =
#(time-parenthesized-time t tp)
#})

\relative c' {
\timeP #'(3 4) #'(6 8) \time 3/4
b8 b8 gis8 gis4 gis8 |
\timeP #'(4 4) #'(3 2 3 8) \time 4/4
b4. b4 b4.
}
</lilypond>

[[Category:Rhythms]]
[[Category:Scheme]]
[[Category:Snippet]]

Time signature with alternate in parentheses

2026-04-15T04:10:29Z

Lemzwerg: Improve more.

In polymetric music, a composer may indicate beat structure by following one time signature with another in parenthesis, for example, ‘3/4 (6/8)’ indicating a 6/8 beat in a 3/4 measure, or ‘6/4 (6/8)’ indicating a 6/8 beat in a 6/4 measure.

This snippet provides a small Scheme wrapper around the <code>\compound-meter</code> markup function that can be used to override the <code>TimeSignature</code> stencil, displaying both a regular and an alternate time signature.

<lilypond version="2.24">
#(define ((time-parenthesized-time t tp) grob)
(let ((m1 (grob-interpret-markup
grob (markup #:compound-meter t)))
(m2 (grob-interpret-markup
grob (markup #:compound-meter tp))))
(ly:stencil-combine-at-edge
m1 X RIGHT
(parenthesize-stencil m2 0.1 0.4 0.4 0.1)
0.3)))

\relative c' {
\once \override Staff.TimeSignature.stencil =
#(time-parenthesized-time '(3 4) '(6 8))
\time 3/4 b8 b8 gis8 gis4 gis8 |
\once \override Staff.TimeSignature.stencil =
#(time-parenthesized-time '(4 4) '(3 2 3 8))
\time 4/4 b4. b4 b4.
}
</lilypond>

[[Category:Rhythms]]
[[Category:Scheme]]
[[Category:Snippet]]

Time signature with alternate in parentheses

2026-04-14T20:42:54Z

Lemzwerg: Improved

In polymetric music, a composer may indicate beat structure by following one time signature with another in parenthesis, for example: 3/4 (6/8) indicating a 6/8 beat in a 3/4 measure, or 6/4 (6/8) indicating a 6/8 beat in a 6/4 measure.

This snippet uses a small Scheme function that overrides the <code>TimeSignature</code> stencil once to display both the regular and the alternate time signature.

<lilypond version="2.24">
#(define ((time-parenthesized-time up down upp downp) grob)
(let ((m1 (grob-interpret-markup
grob
(markup #:override '(baseline-skip . 0)
#:number (#:center-column
((number->string up)
(number->string down))))))
(m2 (grob-interpret-markup
grob
(markup #:override '(baseline-skip . 0)
#:number (#:center-column
((number->string upp)
(number->string downp)))))))
(ly:stencil-combine-at-edge
m1 X RIGHT
(parenthesize-stencil m2 0.1 0.4 0.4 0.1)
0.3)))

\relative c' {
\once \override Staff.TimeSignature.stencil =
#(time-parenthesized-time 3 4 6 8)
\time 3/4 b8 b8 gis8 gis4 gis8 |
\time 4/4 b4 b b b
}
</lilypond>

[[Category:Rhythms]]
[[Category:Scheme]]
[[Category:Snippet]]

User talk:Ksnortum

2026-04-10T15:44:01Z

Lemzwerg: /* Please be careful while using 'Edit' */ Reply

Clef change at the beginning of a piece (alternative)

2026-04-08T17:29:32Z

Lemzwerg:

When changing the clef at the beginning of the first measure, Lilypond just changes the clef for the staff. This is how to keep the staff clef and add an extra clef after the time signature and before the first note. See also [[Initial clef change]] and [[Clef change at the beginning of a piece]].

<lilypond version="2.24">
\relative c' {
%% Start with a bass clef :
\clef bass
%% Use a hidden grace note:
\once\hideNotes\grace c64
%% Adjust the clef spacing:
\once\override Staff.Clef.X-extent = #'(1 . 2)
%% Put in the treble clef:
\clef treble
c4 c c c | c1
}
</lilypond>

[[Category:Staff notation]]
[[Category:Pitches]]
[[Category:Tweaks and overrides]]
[[Category:Snippet]]

Clef change at the beginning of a piece (alternative)

2026-04-08T17:29:02Z

Lemzwerg: Reverted edit by Ksnortum (talk) to last revision by Jean Abou Samra

When changing the clef at the beginning of the first measure, Lilypond just changes the clef for the staff. This is how to keep the staff clef and add an extra clef after the time signature and before the first note.

<lilypond version="2.24">
\relative c' {
%% Start with a bass clef :
\clef bass
%% Use a hidden grace note:
\once\hideNotes\grace c64
%% Adjust the clef spacing:
\once\override Staff.Clef.X-extent = #'(1 . 2)
%% Put in the treble clef:
\clef treble
c4 c c c | c1
}
</lilypond>

[[Category:Staff notation]]
[[Category:Pitches]]
[[Category:Tweaks and overrides]]
[[Category:Snippet]]

Clef change at the beginning of a piece

2026-04-08T17:28:29Z

Lemzwerg:

When changing the clef at the beginning of the first measure, Lilypond just changes the clef for the staff. This is how to keep the staff clef and add an extra clef after the time signature and before the first note. See also [[Clef change at the beginning of a piece (alternative)]] and [[Initial clef change]].

<lilypond version="2.24">
%% http://lsr.di.unimi.it/LSR/Item?id=792
%% see also http://lilypond.org/doc/stable/Documentation/notation/displaying-pitches

% Append markup in the text property to the grob
#(define (append-markup grob old-stencil)
(ly:stencil-combine-at-edge
old-stencil X RIGHT (ly:text-interface::print grob)))

trebleToBass = {
\clef bass
% Fake staff clef appearance
\once \override Staff.Clef.glyph-name = #"clefs.G"
\once \override Staff.Clef.Y-offset = #-1
% Make sure any key signatures will printed with respect to
% correct middle c position expected for treble clef
\once \set Staff.middleCClefPosition = -6
% Append change clef to the time signature
\once \override Staff.TimeSignature.text = \markup {
\hspace #1.2
\raise #1
\musicglyph "clefs.F_change"
}
\once \override Staff.TimeSignature.stencil = #(lambda (grob)
(append-markup grob (ly:time-signature::print grob)))
}

bassToTreble = {
\clef treble
% Fake staff clef appearance
\once \override Staff.Clef.glyph-name = #"clefs.F"
\once \override Staff.Clef.Y-offset = #1
% Make sure any key signatures will printed with respect to
% correct middle c position expected for bass clef
\once \set Staff.middleCClefPosition = 6
% Append change clef to the time signature
\once \override Staff.TimeSignature.text = \markup {
\hspace #1.2
\lower #1
\musicglyph "clefs.G_change"
}
\once \override Staff.TimeSignature.stencil = #(lambda (grob)
(append-markup grob (ly:time-signature::print grob)))
}

\relative c {
\trebleToBass
\key f \major
c4 d e f
% This should not be visible
\clef bass
g a b c
% This should be visible
\clef treble
d e f g
}
</lilypond>

[[Category:Staff notation]]
[[Category:Staff notation]]
[[Category:Pitches]]
[[Category:Tweaks and overrides]]
[[Category:Snippet]]

Clef change at the beginning of a piece

2026-04-08T17:27:58Z

Lemzwerg: Reverted edit by Ksnortum (talk) to last revision by Lemzwerg

When changing the clef at the beginning of the first measure, Lilypond just changes the clef for the staff. This is how to keep the staff clef and add an extra clef after the time signature and before the first note.

<lilypond version="2.24">
%% http://lsr.di.unimi.it/LSR/Item?id=792
%% see also http://lilypond.org/doc/stable/Documentation/notation/displaying-pitches

% Append markup in the text property to the grob
#(define (append-markup grob old-stencil)
(ly:stencil-combine-at-edge
old-stencil X RIGHT (ly:text-interface::print grob)))

trebleToBass = {
\clef bass
% Fake staff clef appearance
\once \override Staff.Clef.glyph-name = #"clefs.G"
\once \override Staff.Clef.Y-offset = #-1
% Make sure any key signatures will printed with respect to
% correct middle c position expected for treble clef
\once \set Staff.middleCClefPosition = -6
% Append change clef to the time signature
\once \override Staff.TimeSignature.text = \markup {
\hspace #1.2
\raise #1
\musicglyph "clefs.F_change"
}
\once \override Staff.TimeSignature.stencil = #(lambda (grob)
(append-markup grob (ly:time-signature::print grob)))
}

bassToTreble = {
\clef treble
% Fake staff clef appearance
\once \override Staff.Clef.glyph-name = #"clefs.F"
\once \override Staff.Clef.Y-offset = #1
% Make sure any key signatures will printed with respect to
% correct middle c position expected for bass clef
\once \set Staff.middleCClefPosition = 6
% Append change clef to the time signature
\once \override Staff.TimeSignature.text = \markup {
\hspace #1.2
\lower #1
\musicglyph "clefs.G_change"
}
\once \override Staff.TimeSignature.stencil = #(lambda (grob)
(append-markup grob (ly:time-signature::print grob)))
}

\relative c {
\trebleToBass
\key f \major
c4 d e f
% This should not be visible
\clef bass
g a b c
% This should be visible
\clef treble
d e f g
}
</lilypond>

[[Category:Staff notation]]
[[Category:Staff notation]]
[[Category:Pitches]]
[[Category:Tweaks and overrides]]
[[Category:Snippet]]

User talk:Ksnortum

2026-04-08T17:26:25Z

Lemzwerg: /* Please be careful while using 'Edit' */ new section

Initial clef change

2026-04-08T17:22:41Z

Lemzwerg:

This snippet handles initial clef changes with a custom engraver. This engraver checks whether there is a difference between the initial clef (as given by <code>\with { \clef ... }</code> and the clef at the first timestep. If any difference is encountered a new clef (spaced like a cue clef) is created, while the original clef and any key signatures are modified to look like the initial clef values. See also the snippets [[Clef change at the beginning of a piece]] and [[Clef change at the beginning of a piece (alternative)]].

<lilypond version="2.24">
%%% This engraver records the initial clef properties (e.g. what is set by \with { \clef ... })
%%% If in the first timestep these changed, engrave the original clef, and change formatting and break
%%% alignment of the actual clef to mimic a clef change clef. Duplicates some procedure from clef engraver
%%% and could easily be integrated.
#(define (initial-clef-change-engraver context)
(let ((initial-clef-properties #f) (cclef #f) (keysigs '()))
; macro for checking if any clef property has changed
(define (clef-changed)
(>
(length initial-clef-properties)
(length
(filter
(lambda (x) (equal? (cdr x) (ly:context-property context (car x))))
initial-clef-properties))))
(make-engraver
; Record initials propertis
((initialize engraver)
(set!
initial-clef-properties
`((clefGlyph . ,(ly:context-property context 'clefGlyph))
(clefPosition . ,(ly:context-property context 'clefPosition))
(middleCClefPosition . ,(ly:context-property context 'middleCClefPosition))
(clefTransposition . ,(ly:context-property context 'clefTransposition)))))
; Record the actual clef to adjust. Use details.muted to not acknowledge clef created by this engraver.
(acknowledgers
((clef-interface engraver grob source-engraver)
(if (not (assoc-get 'muted (ly:grob-property grob 'details) #f))
(set! cclef grob)))
((key-signature-interface engraver grob source-engraver)
(set! keysigs (cons grob keysigs))))
; Create a clef if necessary
((process-music engraver)
(if (and initial-clef-properties (clef-changed))
(let ((clef (ly:engraver-make-grob engraver 'Clef '())))
(ly:grob-set-property! clef 'staff-position (assoc-get 'clefPosition initial-clef-properties))
(ly:grob-set-property! clef 'glyph (assoc-get 'clefGlyph initial-clef-properties))
(ly:grob-set-nested-property! clef '(details muted) #t)
(if ((lambda (x) (and (number? x) (not (= 0 x))))
(assoc-get 'clefTransposition initial-clef-properties 0))
(let ((mod (ly:engraver-make-grob engraver 'ClefModifier '()))
(formatter (ly:context-property context 'clefTranspositionFormatter))
(style (ly:context-property context 'clefTranspositionStyle))
(dir (sign (assoc-get 'clefTransposition initial-clef-properties 0)))
(abs_trans (1+ (abs (assoc-get 'clefTransposition initial-clef-properties 0)))))
(if (procedure? formatter)
(ly:grob-set-property! mod 'text (formatter (number->string abs_trans) style)))
(ly:grob-set-object! mod 'side-support-elements (ly:grob-list->grob-array (list clef)))
(ly:grob-set-parent! mod X clef)
(ly:grob-set-parent! mod Y clef)
(ly:grob-set-property! mod 'direction dir))))))
; Adjust the actual clef and key signatures
((process-acknowledged engraver)
(if (and cclef initial-clef-properties (clef-changed))
(begin

; Key signatures need to be handled if they appear before the cue-clef
; This requires the break alignment information, so this only sets a
; hook which will be processed during `before-line-breaking` of the
; BreakAlignGroups
(for-each
(lambda (keysig)
(let ((det (ly:grob-property keysig 'details))
(initial-clef-properties initial-clef-properties))
(ly:grob-set-property!
keysig
'details
(acons
'break-alignment-handler
(lambda (grob break-alignment)
(let ((start-of-line
(vector-ref
(ly:grob-property break-alignment 'break-align-orders)
2)))
(if (member 'cue-clef (or (member 'key-signature start-of-line) '()))
(ly:grob-set-property!
grob 'c0-position
(assoc-get 'middleCClefPosition initial-clef-properties)))))
det))))
keysigs)

(ly:grob-set-property! cclef 'non-default #t)
(ly:grob-set-property! cclef 'break-align-symbol 'cue-clef)
(if (not (eq? #t (ly:grob-property cclef 'full-size-change)))
(ly:grob-set-property! cclef 'glyph-name
(format #f "~a_change" (ly:grob-property cclef 'glyph)))))))
; Unset parameters
((stop-translation-timestep engraver)
(set! initial-clef-properties #f)
(set! clef #f)
(set! keysigs '())))))

\layout {
\context {
\Staff
\consists #initial-clef-change-engraver
}
\context {
\Score
\override BreakAlignGroup.before-line-breaking =
#(lambda (grob)
(let ((grobs (ly:grob-object grob 'elements))
(break-alignment (ly:grob-parent grob X)))
(if (not (null? grobs))
(set! grobs (ly:grob-array->list grobs)))
(for-each
(lambda (grob)
(let* ((det (ly:grob-property grob 'details))
(handler (assoc-get 'break-alignment-handler det)))
(if (procedure? handler)
(handler grob break-alignment))))
grobs)))
}
}

\new Staff \with { \clef "bass^15" } {
\key bes\major
\clef "treble_8"
c'1 c'1
\clef bass
c'1
}

\score {
\layout {
\context {
\Score
\override BreakAlignment.break-align-orders =
##((staff-ellipsis
left-edge
cue-end-clef
ambitus
breathing-sign
optional-material-end-bracket
signum-repetitionis
clef
cue-clef
staff-bar
key-cancellation
key-signature
time-signature
optional-material-start-bracket
custos)
(staff-ellipsis
left-edge
optional-material-end-bracket
cue-end-clef
ambitus
breathing-sign
signum-repetitionis
clef
cue-clef
staff-bar
key-cancellation
key-signature
time-signature
optional-material-start-bracket
custos)
(staff-ellipsis
left-edge
optional-material-end-bracket
ambitus
breathing-sign
signum-repetitionis
clef
cue-clef
key-cancellation
key-signature
time-signature
staff-bar
optional-material-start-bracket
custos))
}
}
\new Staff \with { \clef "bass^15" } {
\key bes\major
\clef "treble_8"
c'1 c'1
\clef bass
c'1
}
}

% Basic usage:
\score {
<<
% Just the treble clef
\new Staff {
\key bes \major
c''1
}

% Just the bass clef
\new Staff \with { \clef bass } {
\key bes \major
c1
}

% Initial treble clef, then bass clef
\new Staff {
\key bes \major
\clef bass
c1
}

% Initial bass clef, then treble clef
\new Staff \with { \clef bass } {
\key bes \major
\clef treble
c''1
}
>>

\layout {
\context {
\Staff
\consists #initial-clef-change-engraver
}
}
}
</lilypond>

[[Category:Contexts and engravers]]
[[Category:Scheme]]
[[Category:Staff notation]]
[[Category:Snippet]]

Initial clef change

2026-04-08T17:21:45Z

Lemzwerg: Reverted edit by Ksnortum (talk) to last revision by Lemzwerg

This snippet handles initial clef changes with a custom engraver. This engraver checks whether there is a difference between the initial clef (as given by <code>\with { \clef ... }</code> and the clef at the first timestep. If any difference is encountered a new clef (spaced like a cue clef) is created, while the original clef and any key signatures are modified to look like the initial clef values.

<lilypond version="2.24">
%%% This engraver records the initial clef properties (e.g. what is set by \with { \clef ... })
%%% If in the first timestep these changed, engrave the original clef, and change formatting and break
%%% alignment of the actual clef to mimic a clef change clef. Duplicates some procedure from clef engraver
%%% and could easily be integrated.
#(define (initial-clef-change-engraver context)
(let ((initial-clef-properties #f) (cclef #f) (keysigs '()))
; macro for checking if any clef property has changed
(define (clef-changed)
(>
(length initial-clef-properties)
(length
(filter
(lambda (x) (equal? (cdr x) (ly:context-property context (car x))))
initial-clef-properties))))
(make-engraver
; Record initials propertis
((initialize engraver)
(set!
initial-clef-properties
`((clefGlyph . ,(ly:context-property context 'clefGlyph))
(clefPosition . ,(ly:context-property context 'clefPosition))
(middleCClefPosition . ,(ly:context-property context 'middleCClefPosition))
(clefTransposition . ,(ly:context-property context 'clefTransposition)))))
; Record the actual clef to adjust. Use details.muted to not acknowledge clef created by this engraver.
(acknowledgers
((clef-interface engraver grob source-engraver)
(if (not (assoc-get 'muted (ly:grob-property grob 'details) #f))
(set! cclef grob)))
((key-signature-interface engraver grob source-engraver)
(set! keysigs (cons grob keysigs))))
; Create a clef if necessary
((process-music engraver)
(if (and initial-clef-properties (clef-changed))
(let ((clef (ly:engraver-make-grob engraver 'Clef '())))
(ly:grob-set-property! clef 'staff-position (assoc-get 'clefPosition initial-clef-properties))
(ly:grob-set-property! clef 'glyph (assoc-get 'clefGlyph initial-clef-properties))
(ly:grob-set-nested-property! clef '(details muted) #t)
(if ((lambda (x) (and (number? x) (not (= 0 x))))
(assoc-get 'clefTransposition initial-clef-properties 0))
(let ((mod (ly:engraver-make-grob engraver 'ClefModifier '()))
(formatter (ly:context-property context 'clefTranspositionFormatter))
(style (ly:context-property context 'clefTranspositionStyle))
(dir (sign (assoc-get 'clefTransposition initial-clef-properties 0)))
(abs_trans (1+ (abs (assoc-get 'clefTransposition initial-clef-properties 0)))))
(if (procedure? formatter)
(ly:grob-set-property! mod 'text (formatter (number->string abs_trans) style)))
(ly:grob-set-object! mod 'side-support-elements (ly:grob-list->grob-array (list clef)))
(ly:grob-set-parent! mod X clef)
(ly:grob-set-parent! mod Y clef)
(ly:grob-set-property! mod 'direction dir))))))
; Adjust the actual clef and key signatures
((process-acknowledged engraver)
(if (and cclef initial-clef-properties (clef-changed))
(begin

; Key signatures need to be handled if they appear before the cue-clef
; This requires the break alignment information, so this only sets a
; hook which will be processed during `before-line-breaking` of the
; BreakAlignGroups
(for-each
(lambda (keysig)
(let ((det (ly:grob-property keysig 'details))
(initial-clef-properties initial-clef-properties))
(ly:grob-set-property!
keysig
'details
(acons
'break-alignment-handler
(lambda (grob break-alignment)
(let ((start-of-line
(vector-ref
(ly:grob-property break-alignment 'break-align-orders)
2)))
(if (member 'cue-clef (or (member 'key-signature start-of-line) '()))
(ly:grob-set-property!
grob 'c0-position
(assoc-get 'middleCClefPosition initial-clef-properties)))))
det))))
keysigs)

(ly:grob-set-property! cclef 'non-default #t)
(ly:grob-set-property! cclef 'break-align-symbol 'cue-clef)
(if (not (eq? #t (ly:grob-property cclef 'full-size-change)))
(ly:grob-set-property! cclef 'glyph-name
(format #f "~a_change" (ly:grob-property cclef 'glyph)))))))
; Unset parameters
((stop-translation-timestep engraver)
(set! initial-clef-properties #f)
(set! clef #f)
(set! keysigs '())))))

\layout {
\context {
\Staff
\consists #initial-clef-change-engraver
}
\context {
\Score
\override BreakAlignGroup.before-line-breaking =
#(lambda (grob)
(let ((grobs (ly:grob-object grob 'elements))
(break-alignment (ly:grob-parent grob X)))
(if (not (null? grobs))
(set! grobs (ly:grob-array->list grobs)))
(for-each
(lambda (grob)
(let* ((det (ly:grob-property grob 'details))
(handler (assoc-get 'break-alignment-handler det)))
(if (procedure? handler)
(handler grob break-alignment))))
grobs)))
}
}

\new Staff \with { \clef "bass^15" } {
\key bes\major
\clef "treble_8"
c'1 c'1
\clef bass
c'1
}

\score {
\layout {
\context {
\Score
\override BreakAlignment.break-align-orders =
##((staff-ellipsis
left-edge
cue-end-clef
ambitus
breathing-sign
optional-material-end-bracket
signum-repetitionis
clef
cue-clef
staff-bar
key-cancellation
key-signature
time-signature
optional-material-start-bracket
custos)
(staff-ellipsis
left-edge
optional-material-end-bracket
cue-end-clef
ambitus
breathing-sign
signum-repetitionis
clef
cue-clef
staff-bar
key-cancellation
key-signature
time-signature
optional-material-start-bracket
custos)
(staff-ellipsis
left-edge
optional-material-end-bracket
ambitus
breathing-sign
signum-repetitionis
clef
cue-clef
key-cancellation
key-signature
time-signature
staff-bar
optional-material-start-bracket
custos))
}
}
\new Staff \with { \clef "bass^15" } {
\key bes\major
\clef "treble_8"
c'1 c'1
\clef bass
c'1
}
}

% Basic usage:
\score {
<<
% Just the treble clef
\new Staff {
\key bes \major
c''1
}

% Just the bass clef
\new Staff \with { \clef bass } {
\key bes \major
c1
}

% Initial treble clef, then bass clef
\new Staff {
\key bes \major
\clef bass
c1
}

% Initial bass clef, then treble clef
\new Staff \with { \clef bass } {
\key bes \major
\clef treble
c''1
}
>>

\layout {
\context {
\Staff
\consists #initial-clef-change-engraver
}
}
}
</lilypond>

[[Category:Contexts and engravers]]
[[Category:Scheme]]
[[Category:Staff notation]]
[[Category:Snippet]]

Splitting chords

2026-04-07T03:53:53Z

Lemzwerg:

This snippet is a 2009 contribution by Gilles Thibault in [https://lists.gnu.org/archive/html/lilypond-user/2009-01/msg00685.html lilypond-user]. It provides two functions to split a chord sequence into two separate voices, also preserving articulations and slurs: <code>\keepOnlyFirstNote</code> extracts the first note (as given in the input; this is usually the lowest one) of every chord, and <code>\deleteFirstNote</code> collects the remaining notes.

Note that these functions don't support <samp>q</samp> to repeat the last chord.

<lilypond version="2.24">
#(define (has-duration? music)
(ly:duration? (ly:music-property music 'duration)))

#(define (not-has-duration? music)
(not (has-duration? music)))

keepOnlyFirstNote =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (evt)
(when (eq? 'EventChord (ly:music-property evt 'name))
(let ((elts (ly:music-property evt 'elements)))
(when (has-duration? (car elts))
(ly:music-set-property!
evt 'elements
(cons (car elts)
(filter not-has-duration? (cdr elts)))))))
evt)
music))

deleteFirstNote =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (evt)
(when (eq? 'EventChord (ly:music-property evt 'name))
(let ((elts (ly:music-property evt 'elements)))
(when (has-duration? (car elts))
(ly:music-set-property! evt 'elements (cdr elts)))))
evt)
music))

music = \relative c' {
<c e>4-> <d f>( <b g'>) <c e>-. g2 c2
}

\markup { Music with chords }
\new Staff \music

\markup { Music split into two staves }
<<
\new Staff \deleteFirstNote \music
\new Staff \keepOnlyFirstNote \music
>>
</lilypond>

[[category:Chords]]
[[category:Scheme]]
[[category:Really cool]]

Splitting chords

2026-04-07T03:51:40Z

Lemzwerg: Not sure how it could happen that changing a single letter in the docstring completely ruined the rendering...

This snippet is a 2009 contribution by Gilles Thibault in [https://lists.gnu.org/archive/html/lilypond-user/2009-01/msg00685.html lilypond-user]. It provides two functions to split a chord sequence into two separate voices, also preserving articulations and slurs: <code>\keepOnlyFirstNote</code> extracts the first note (as given in the input; this is usually the lowest one) of every chord, and <code>\deleteFirstNote</code> collects the remaining notes.

Note that these function don't support <samp>q</samp> to repeat the last chord.

<lilypond version="2.24">
#(define (has-duration? music)
(ly:duration? (ly:music-property music 'duration)))

#(define (not-has-duration? music)
(not (has-duration? music)))

keepOnlyFirstNote =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (evt)
(when (eq? 'EventChord (ly:music-property evt 'name))
(let ((elts (ly:music-property evt 'elements)))
(when (has-duration? (car elts))
(ly:music-set-property!
evt 'elements
(cons (car elts)
(filter not-has-duration? (cdr elts)))))))
evt)
music))

deleteFirstNote =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (evt)
(when (eq? 'EventChord (ly:music-property evt 'name))
(let ((elts (ly:music-property evt 'elements)))
(when (has-duration? (car elts))
(ly:music-set-property! evt 'elements (cdr elts)))))
evt)
music))

music = \relative c' {
<c e>4-> <d f>( <b g'>) <c e>-. g2 c2
}

\markup { Music with chords }
\new Staff \music

\markup { Music split into two staves }
<<
\new Staff \deleteFirstNote \music
\new Staff \keepOnlyFirstNote \music
>>
</lilypond>

[[category:Chords]]
[[category:Scheme]]
[[category:Really cool]]

Splitting chords

2026-04-05T09:09:04Z

Lemzwerg: Formatting, improved docstring

This snippet is a 2009 contribution by Gilles Thibault in [https://lists.gnu.org/archive/html/lilypond-user/2009-01/msg00685.html lilypond-user]. It provides two functions to split a chord sequence into two separate voices, also preserving articulations and slurs: <code>\keepOnlyFirstNode</code> extracts the first note (as given in the input; this is usually the lowest one) of every chord, and <code>\deleteFirstNote</code> collects the remaining notes.

Note that these function don't support <samp>q</samp> to repeat the last chord.

<lilypond version="2.24">
#(define (has-duration? music)
(ly:duration? (ly:music-property music 'duration)))

#(define (not-has-duration? music)
(not (has-duration? music)))

keepOnlyFirstNote =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (evt)
(when (eq? 'EventChord (ly:music-property evt 'name))
(let ((elts (ly:music-property evt 'elements)))
(when (has-duration? (car elts))
(ly:music-set-property!
evt 'elements
(cons (car elts)
(filter not-has-duration? (cdr elts)))))))
evt)
music))

deleteFirstNote =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (evt)
(when (eq? 'EventChord (ly:music-property evt 'name))
(let ((elts (ly:music-property evt 'elements)))
(when (has-duration? (car elts))
(ly:music-set-property! evt 'elements (cdr elts)))))
evt)
music))

music = \relative c' {
<c e>4-> <d f>( <b g'>) <c e>-. g2 c2
}

\markup { Music with chords }
\new Staff \music

\markup { Music split into two staffs }
<<
\new Staff \deleteFirstNote \music
\new Staff \keepOnlyFirstNote \music
>>
</lilypond>

[[category:Chords]]
[[category:Scheme]]
[[category:Really cool]]

User talk:MartialR

2026-03-31T11:16:49Z

Lemzwerg: /* Recorder diagrams */ new section

== Recorder diagrams ==

Please have a look at [https://wiki.lilypond.community/wiki/Talk:Diagram_for_Recorder_baroque_in_F_and_C#c-Lemzwerg-20260331094100-Better_markup_definitions this comment] -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 11:16, 31 March 2026 (UTC)

Talk:Diagram for Recorder baroque in F and C

2026-03-31T11:10:26Z

Lemzwerg:

== Better markup definitions ==

Please ask for help on the [mailto:lilypond-user@gnu.org 'lilypond-user' mailing list] how to write a Scheme function for defining the fingering markups, avoiding tedious repetition! This will dramatically reduce the size of the definitions, also making them easier to maintain. -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 09:41, 31 March 2026 (UTC)

Talk:Diagram for Recorder baroque in F and C

2026-03-31T09:41:28Z

Lemzwerg: /* Better markup definitions */ new section

== Better markup definitions ==

Please ask for help on the [[mailto:lilypond-user@gnu.org 'lilypond-user' mailing list]] how to write a Scheme function for defining the fingering markups, avoiding tedious repetition! This will dramatically reduce the size of the definitions, also making them easier to maintain. -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 09:41, 31 March 2026 (UTC)

Key signatures for small staves

2026-03-18T18:11:37Z

Lemzwerg: Revised.

Traditionally, the spacing of key signatures in smaller staves is larger in comparison to full-size staves.

Here is a function that extends <code>\magnifyStaff</code> to automatically calculate the right key signature spacing according to the staff size.

<lilypond version="2.24">
scaleStaff =
#(define-music-function (scaleFac) (number?)
#{
\magnifyStaff #scaleFac
\override KeySignature.padding = #(* 2/3 (- 1 scaleFac))
#})

keyTest = { \key cis\major s4*4 \bar "" }

\markup\italic "Default output:"
<<
\new Staff \with { \magnifyStaff #5/7 } \keyTest
\new Staff \keyTest
>>

\markup\italic "Traditional output:"
<<
\new Staff \with { \scaleStaff #5/7 } \keyTest
\new Staff \keyTest
>>
</lilypond>

[[Category:Staff notation]]
[[Category:Vocal music]]
[[Category:Spacing]]
[[Category:Tweaks and overrides]]
[[Category:Specific notation]]
[[Category:Workaround]]
[[Category:Snippet]]

LSR 1094

2026-03-18T17:55:16Z

Lemzwerg: Changed redirect target from Key signature and small staff to Key signatures for small staves

#REDIRECT [[Key signatures for small staves]]

Key signatures for small staves

2026-03-18T17:54:43Z

Lemzwerg: Lemzwerg moved page Key signature and small staff to Key signatures for small staves without leaving a redirect

Traditionally, smaller staves key signature spacing is slightly different than full size staves ones.

Here's a function that automatically calculates the right key signature spacing according to the staff size.

<lilypond version="2.24">
%% => http://lsr.di.unimi.it/LSR/Item?id=1094

%% This extends \staffSize as defined in
%% "Changing the size of a staff with a music function"
%% http://lsr.di.unimi.it/LSR/Item?id=862
staffSize = #(define-music-function (new-size) (number?)
#{
\set fontSize = #new-size
\override StaffSymbol.staff-space = #(magstep new-size)
\override StaffSymbol.thickness = #(magstep new-size)
\override KeySignature.padding = #(* 2/3 (- 1 (magstep new-size)))
#})

keyTest = { \key cis\major s4*4 \bar "" }

\markup\italic "Default output:"
<<
\new Staff \with {
fontSize = #-3
\override StaffSymbol.staff-space = #(magstep -3)
\override StaffSymbol.thickness = #(magstep -3)
} \keyTest
\new Staff \keyTest

>>

\markup\italic "Traditional output:"
<<
\new Staff \with { \staffSize #-3 } \keyTest
\new Staff \keyTest

>>

%{
% For v.2.19 and higher:

scaleStaff = #(define-music-function (scaleFac) (number?)
#{
\magnifyStaff #scaleFac
\override KeySignature.padding = #(* 2/3 (- 1 scaleFac))
#})

sizeTest = #5/7
keyTest = { \key cis\major s4*4 \bar "" }

<<
\new Staff \with { \scaleStaff #sizeTest } \keyTest
\new Staff \keyTest
>>
%}
</lilypond>

[[Category:Staff notation]]
[[Category:Vocal music]]
[[Category:Spacing]]
[[Category:Contexts and engravers]]
[[Category:Tweaks and overrides]]
[[Category:Specific notation]]
[[Category:Workaround]]
[[Category:Snippet]]

Talk:Airy tone

2026-03-18T16:58:38Z

Lemzwerg: /* Circles not displaying in Wiki */ Reply

== Circles not displaying in Wiki ==

The circles are not displaying in the Wiki. However, if I copy and paste the code and compile it locally, the circles do display. Does anyone know how to fix this? [[User:Ksnortum|Ksnortum]] ([[User talk:Ksnortum|talk]]) 16:40, 18 March 2026 (UTC)

:The usual thing: The code for drawing the circles is Postscript, which is not supported by the SVG backend used in the Wiki. It should be rewritten using LilyPond drawing commands. -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 16:58, 18 March 2026 (UTC)

Feta font chart

2026-03-16T23:15:20Z

Lemzwerg: Revised

This chart shows all articulations or scripts that LilyPond's “feta” font contains.

<lilypond version="2.24">
<<
\new Staff \relative c'' {
c\accent c\marcato c\staccatissimo
c\staccato c\tenuto c\portato
c\upbow c\downbow c\flageolet
c\thumb c^\lheel c\rheel
c^\ltoe c\rtoe c\open
c\stopped c\turn c\reverseturn
c\trill c\prall c\mordent
c\prallprall c\prallmordent c\upprall
c\downprall c\upmordent c\downmordent
c\pralldown c\prallup c\lineprall
c\signumcongruentiae c\shortfermata c\fermata
c\longfermata c\verylongfermata c\segno
c\coda c\varcoda
}

\new Lyrics \lyricmode {
accent marcato staccatissimo
staccato tenuto portato
upbow downbow flageolet
thumb lheel rheel
ltoe rtoe open
stopped turn reverseturn
trill prall mordent
prallprall prallmordent upprall
downprall upmordent downmordent
pralldown prallup lineprall
signumcongruentiae shortfermata fermata
longfermata verylongfermata segno
coda varcoda
}
>>

\layout {
\context {
\Staff
\remove Clef_engraver
\remove Time_signature_engraver
\remove Bar_line_engraver
}
\context {
\Lyrics
\override LyricText.font-family = #'typewriter
\override LyricSpace.minimum-distance = 3
}
\context {
\Score
timing = ##f
forbidBreakBetweenBarLines = ##f
}
}
</lilypond>

[[Category:Symbols and glyphs]]
[[Category:Expressive marks]]
[[Category:Snippet]]

Positioning a \fermata over the last bar line

2026-03-15T16:41:23Z

Lemzwerg:

To position a \fermata sign over the last bar line, you must use a specially modified rehearsal mark.

<lilypond version="2.24">
\relative c'' {
\override Score.RehearsalMark.break-visibility = #begin-of-line-invisible
c1 \mark \markup { \musicglyph "scripts.ufermata" }
}
</lilypond>

[[Category:Expressive marks]]
[[Category:Breaks]]
[[Category:Staff notation]]
[[Category:Workaround]]
[[Category:Symbols and glyphs]]
[[Category:Snippet]]

Alternate \textSpanner engraver

2026-03-12T06:46:28Z

Lemzwerg:

LilyPond's default text spanner engraver can only handle a single text spanner per voice at a time. The engraver in this snippet provides an alternate implementation to circumvent this limitation; it uses spanner IDs to specify start and end of overlapping text spanners.

To use it, replace <code>Text_spanner_engraver</code> with <code>\alternateTextSpannerEngraver</code>. The example below demonstrates two possible ways to specify a spanner ID: either define a new command or use the <code>\=</code> command to directly set the ID.

To control the vertical order of text spanners, use the standard way of tweaking the <code>outside-staff-priority</code> property.

<lilypond version="2.24">
% LSR written by Dave Nalesnik
% LSR https://lists.gnu.org/archive/html/lilypond-user/2026-01/msg00006.html

% Incorporating some code from the rewrite in Scheme of
% Text_spanner_engraver in input/regression/scheme-text-spanner.ly

#(define (add-bound-item spanner item)
(if (null? (ly:spanner-bound spanner LEFT))
(ly:spanner-set-bound! spanner LEFT item)
(ly:spanner-set-bound! spanner RIGHT item)))

#(define (set-axis! grob axis)
(when (not (number? (ly:grob-property grob 'side-axis)))
(set! (ly:grob-property grob 'side-axis) axis)
(ly:grob-chain-callback
grob
(if (eq? axis X)
ly:side-position-interface::x-aligned-side
side-position-interface::y-aligned-side)
(if (eq? axis X)
'X-offset
'Y-offset))))

#(define (assign-spanner-index orig-ls)
"Determine an available position of a new spanner in an ordered
sequence of spanners (a list of pairs, where the car of the pair
gives the position). The goal is for the sequence to begin with
zero and contain no gaps. Return the index representing the
spanner's position.

Examples (only showing the cars of the pairs):

(0 1) => 2
(2 3) => 0
(0 3) => 1
(0 1 3) => 2
"
(if (null? orig-ls)
0
(let loop ((ls orig-ls)
(insert? #t)
(result 0))
(cond
((null? ls)
result)
;; Position at head of list.
((and insert? (> (caar orig-ls) 0))
(loop ls #f 0))
;; No gaps, put at end of list.
((and insert? (null? (cdr ls)))
(loop (cdr ls) #f (1+ (caar ls))))
;; Fill lowest position of gap.
((and insert?
(> (caadr ls) (1+ (caar ls))))
(loop (cdr ls) #f (1+ (caar ls))))
(else
(loop (cdr ls) insert? result))))))

alternateTextSpannerEngraver =
#(lambda (context)
(let (;; A list of pairs comprising a spanner index (not
;; `spanner-id` values) and a spanner which has been begun.
(spanners '())
(finished '()) ; A list of spanners in completion stage.
(start-events '()) ; A list of START events.
(stop-events '())) ; A list of STOP events.
(make-engraver
;; `\startTextSpan`, `\stopTextSpan`, and the like create
;; events which we collect here.
(listeners
((text-span-event engraver event)
(if (= START (ly:event-property event 'span-direction))
(set! start-events (cons event start-events))
(set! stop-events (cons event stop-events)))))

;; Populate `note-columns` property of spanners. Bounds are
;; set to note columns, and each spanner keeps a record of
;; the note columns it traverses.
(acknowledgers
((note-column-interface engraver grob source-engraver)
(for-each (lambda (s)
(ly:pointer-group-interface::add-grob
(cdr s) 'note-columns grob)
(when (null? (ly:spanner-bound (cdr s) LEFT))
(add-bound-item (cdr s) grob)))
spanners)
;; `finished` only contains spanners, no indices.
(for-each (lambda (f)
(ly:pointer-group-interface::add-grob
f 'note-columns grob)
(when (null? (ly:spanner-bound f RIGHT))
(add-bound-item f grob)))
finished)))

((process-music trans)
;; Move begun spanners from `span` to `finished`. We do
;; this on the basis of `spanner-id`. If we find a match
;; -- either the strings are the same, or both are unset --
;; a transfer can be made. Return a warning if we find no
;; match: spanner hasn't been properly begun.
(for-each
(lambda (es)
(let ((es-id (ly:event-property es 'spanner-id)))
(let loop ((sp spanners))
(if (null? sp)
(ly:warning "No spanner to end!")
(let ((sp-id (ly:event-property
(event-cause (cdar sp))
'spanner-id)))
(cond
((equal? sp-id es-id)
(set! finished (cons (cdar sp) finished))
(set! spanners
(remove (lambda (s)
(eq? s (car sp))) spanners)))
(else
(loop (cdr sp)))))))))
stop-events)

;; The end of our spanners can be acknowledged by other
;; engravers, thus announce them.
(for-each
(lambda (f)
(ly:engraver-announce-end-grob trans f (event-cause f)))
finished)

;; Make spanners in response to START events.
;;
;; Each new spanner is assigned an index denoting its
;; position relative to other active spanners. This is
;; enforced (for the moment) by adding a small amount to
;; the spanner's `outside-staff-priority` proportional to
;; this index. This is unlikely to result in conflicts,
;; though a better solution may be to organize the spanners
;; by a new alignment grob.
;;
;; Also, add any existing spanners to the
;; `side-support-elements` array of the new spanner. This
;; ensures correct ordering over line breaks when
;; `outside-staff-priority` is set to `#f` (which means
;; that it is no longer an outside-staff object -- not the
;; default).
(for-each
(lambda (es)
(let* ((new (ly:engraver-make-grob
trans 'TextSpanner es))
(new-idx (assign-spanner-index spanners))
(new-osp (ly:grob-property
new 'outside-staff-priority))
(new-osp (if (number? new-osp)
(+ new-osp (/ new-idx 1000.0))
new-osp)))
(set! (ly:grob-property
new 'outside-staff-priority) new-osp)
(set-axis! new Y)
;; Add spanners with a lower index than the new
;; spanner to its `side-support-elements` list. This
;; allows new spanners to fill gaps under the topmost
;; spanner.
(for-each (lambda (sp)
(when (< (car sp) new-idx)
(ly:pointer-group-interface::add-grob
new 'side-support-elements (cdr sp))))
spanners)
(set! spanners (cons (cons new-idx new) spanners))
(set! spanners (sort spanners car<))))
start-events)

;; Events have served their purpose for this timestep.
;; Clear the way for new events in later timesteps.
(set! start-events '())
(set! stop-events '()))

((stop-translation-timestep trans)
;; Set bounds of spanners to `PaperColumns` grobs if they
;; haven't been set. This allows spanners to be drawn
;; between spacers.
;;
;; Other uses? Doesn't appear to affect whether spanners
;; can de drawn between rests.
(for-each (lambda (s)
(when (null? (ly:spanner-bound (cdr s) LEFT))
(ly:spanner-set-bound!
(cdr s) LEFT
(ly:context-property context
'currentMusicalColumn))))
spanners)
(for-each (lambda (f)
(when (null? (ly:spanner-bound f RIGHT))
(ly:spanner-set-bound!
f RIGHT
(ly:context-property context
'currentMusicalColumn))))
finished)
(set! finished '()))

((finalize trans)
;; If spanner ends on spacer at end of context?
(for-each (lambda (f)
(when (null? (ly:spanner-bound f RIGHT))
(ly:spanner-set-bound!
f RIGHT
(ly:context-property context
'currentMusicalColumn))))
finished)
(set! finished '())
;; User didn't end spanner.
(for-each (lambda (sp)
(ly:warning "incomplete spanner removed!")
(ly:grob-suicide! (cdr sp)))
spanners)
(set! spanners '())))))

%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EXAMPLE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

startTextSpanOne =
#(make-music 'TextSpanEvent 'span-direction START 'spanner-id "1")
stopTextSpanOne =
#(make-music 'TextSpanEvent 'span-direction STOP 'spanner-id "1")
startTextSpanTwo =
#(make-music 'TextSpanEvent 'span-direction START 'spanner-id "2")
stopTextSpanTwo =
#(make-music 'TextSpanEvent 'span-direction STOP 'spanner-id "2")

\layout {
\context {
\Voice
\remove Text_spanner_engraver
\consists \alternateTextSpannerEngraver
}
}

\relative c' {
\override TextSpanner.style = ##f
\override TextSpanner.thickness = 10
% \override TextSpanner.to-barline = ##t

a4 \tweak color #red \startTextSpan
b \tweak color #green \startTextSpanOne
c \tweak color #blue \startTextSpanTwo
d \=3\startTextSpan |
a4\stopTextSpan
b \stopTextSpanOne
\tweak color #red \startTextSpan
c \stopTextSpanTwo
\tweak color #green \startTextSpanOne
d \=3\stopTextSpan
\tweak color #blue \startTextSpanTwo |
a4 \=3\startTextSpan
b c d | \break

a4 b c d |
a4\stopTextSpan
\stopTextSpanOne
\stopTextSpanTwo
\=3\stopTextSpan
b
c \startTextSpan
d \tweak outside-staff-priority #0 \=1\startTextSpan |
a4 b
c \=1\stopTextSpan
d \stopTextSpan |
}
</lilypond>

[[Category:Contexts and engravers]]
[[Category:Editorial annotations]]
[[Category:Expressive marks]]
[[Category:Scheme]]
[[Category:Workaround]]
[[Category:Snippet]]

Alternate \textSpanner engraver

2026-03-12T06:41:49Z

Lemzwerg:

LilyPond's default text spanner engraver can only handle a single text spanner per voice at a time. The engraver in this snippet provides an alternate implementation to circumvent this limitation; it uses spanner IDs to specify start and end of overlapping text spanners.

To use it, replace <code>Text_spanner_engraver</code> with <code>\alternateTextSpannerEngraver</code>. The example below demonstrates two possible ways to specify a spanner ID: either define a new command or use the <code>\=</code> command to directly set the ID.

To control the vertical order of text spanners, use the standard way of tweaking the <code>outside-staff-priority</code> property.

<lilypond version="2.24">
% LSR written by Dave Nalesnik
% LSR https://lists.gnu.org/archive/html/lilypond-user/2026-01/msg00006.html

% Incorporating some code from the rewrite in Scheme of
% Text_spanner_engraver in input/regression/scheme-text-spanner.ly

#(define (add-bound-item spanner item)
(if (null? (ly:spanner-bound spanner LEFT))
(ly:spanner-set-bound! spanner LEFT item)
(ly:spanner-set-bound! spanner RIGHT item)))

#(define (set-axis! grob axis)
(when (not (number? (ly:grob-property grob 'side-axis)))
(set! (ly:grob-property grob 'side-axis) axis)
(ly:grob-chain-callback
grob
(if (eq? axis X)
ly:side-position-interface::x-aligned-side
side-position-interface::y-aligned-side)
(if (eq? axis X)
'X-offset
'Y-offset))))

#(define (assign-spanner-index orig-ls)
"Determine an available position of a new spanner in an ordered
sequence of spanners (a list of pairs, where the car of the pair
gives the position). The goal is for the sequence to begin with
zero and contain no gaps. Return the index representing the
spanner's position.

Examples (only showing the cars of the pairs):

(0 1) => 2
(2 3) => 0
(0 3) => 1
(0 1 3) => 2
"
(if (null? orig-ls)
0
(let loop ((ls orig-ls)
(insert? #t)
(result 0))
(cond
((null? ls)
result)
;; Position at head of list.
((and insert? (> (caar orig-ls) 0))
(loop ls #f 0))
;; No gaps, put at end of list.
((and insert? (null? (cdr ls)))
(loop (cdr ls) #f (1+ (caar ls))))
;; Fill lowest position of gap.
((and insert?
(> (caadr ls) (1+ (caar ls))))
(loop (cdr ls) #f (1+ (caar ls))))
(else
(loop (cdr ls) insert? result))))))

alternateTextSpannerEngraver =
#(lambda (context)
(let (;; A list of pairs comprising a spanner index (not
;; `spanner-id` values) and a spanner which has been begun.
(spanners '())
(finished '()) ; A list of spanners in completion stage.
(start-events '()) ; A list of START events.
(stop-events '())) ; A list of STOP events.
(make-engraver
;; `\startTextSpan`, `\stopTextSpan`, and the like create
;; events which we collect here.
(listeners
((text-span-event engraver event)
(if (= START (ly:event-property event 'span-direction))
(set! start-events (cons event start-events))
(set! stop-events (cons event stop-events)))))

;; Populate `note-columns` property of spanners. Bounds are
;; set to note columns, and each spanner keeps a record of
;; the note columns it traverses.
(acknowledgers
((note-column-interface engraver grob source-engraver)
(for-each (lambda (s)
(ly:pointer-group-interface::add-grob
(cdr s) 'note-columns grob)
(when (null? (ly:spanner-bound (cdr s) LEFT))
(add-bound-item (cdr s) grob)))
spanners)
;; `finished` only contains spanners, no indices.
(for-each (lambda (f)
(ly:pointer-group-interface::add-grob
f 'note-columns grob)
(when (null? (ly:spanner-bound f RIGHT))
(add-bound-item f grob)))
finished)))

((process-music trans)
;; Move begun spanners from `span` to `finished`. We do
;; this on the basis of `spanner-id`. If we find a match
;; -- either the strings are the same, or both are unset --
;; a transfer can be made. Return a warning if we find no
;; match: spanner hasn't been properly begun.
(for-each
(lambda (es)
(let ((es-id (ly:event-property es 'spanner-id)))
(let loop ((sp spanners))
(if (null? sp)
(ly:warning "No spanner to end!")
(let ((sp-id (ly:event-property
(event-cause (cdar sp))
'spanner-id)))
(cond
((equal? sp-id es-id)
(set! finished (cons (cdar sp) finished))
(set! spanners
(remove (lambda (s)
(eq? s (car sp))) spanners)))
(else
(loop (cdr sp)))))))))
stop-events)

;; The end of our spanners can be acknowledged by other
;; engravers, thus announce them.
(for-each
(lambda (f)
(ly:engraver-announce-end-grob trans f (event-cause f)))
finished)

;; Make spanners in response to START events.
;;
;; Each new spanner is assigned an index denoting its
;; position relative to other active spanners. This is
;; enforced (for the moment) by adding a small amount to
;; the spanner's `outside-staff-priority` proportional to
;; this index. This is unlikely to result in conflicts,
;; though a better solution may be to organize the spanners
;; by a new alignment grob.
;;
;; Also, add any existing spanners to the
;; `side-support-elements` array of the new spanner. This
;; ensures correct ordering over line breaks when
;; `outside-staff-priority` is set to `#f` (which means
;; that it is no longer an outside-staff object -- not the
;; default).
(for-each
(lambda (es)
(let* ((new (ly:engraver-make-grob
trans 'TextSpanner es))
(new-idx (assign-spanner-index spanners))
(new-osp (ly:grob-property
new 'outside-staff-priority))
(new-osp (if (number? new-osp)
(+ new-osp (/ new-idx 1000.0))
new-osp)))
(set! (ly:grob-property
new 'outside-staff-priority) new-osp)
(set-axis! new Y)
;; Add spanners with a lower index than the new
;; spanner to its `side-support-elements` list. This
;; allows new spanners to fill gaps under the topmost
;; spanner.
(for-each (lambda (sp)
(when (< (car sp) new-idx)
(ly:pointer-group-interface::add-grob
new 'side-support-elements (cdr sp))))
spanners)
(set! spanners (cons (cons new-idx new) spanners))
(set! spanners (sort spanners car<))))
start-events)

;; Events have served their purpose for this timestep.
;; Clear the way for new events in later timesteps.
(set! start-events '())
(set! stop-events '()))

((stop-translation-timestep trans)
;; Set bounds of spanners to `PaperColumns` grobs if they
;; haven't been set. This allows spanners to be drawn
;; between spacers.
;;
;; Other uses? Doesn't appear to affect whether spanners
;; can de drawn between rests.
(for-each (lambda (s)
(when (null? (ly:spanner-bound (cdr s) LEFT))
(ly:spanner-set-bound!
(cdr s) LEFT
(ly:context-property context
'currentMusicalColumn))))
spanners)
(for-each (lambda (f)
(when (null? (ly:spanner-bound f RIGHT))
(ly:spanner-set-bound!
f RIGHT
(ly:context-property context
'currentMusicalColumn))))
finished)
(set! finished '()))

((finalize trans)
;; If spanner ends on spacer at end of context?
(for-each (lambda (f)
(when (null? (ly:spanner-bound f RIGHT))
(ly:spanner-set-bound!
f RIGHT
(ly:context-property context
'currentMusicalColumn))))
finished)
(set! finished '())
;; User didn't end spanner.
(for-each (lambda (sp)
(ly:warning "incomplete spanner removed!")
(ly:grob-suicide! (cdr sp)))
spanners)
(set! spanners '())))))

%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EXAMPLE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

startTextSpanOne =
#(make-music 'TextSpanEvent 'span-direction START 'spanner-id "1")
stopTextSpanOne =
#(make-music 'TextSpanEvent 'span-direction STOP 'spanner-id "1")
startTextSpanTwo =
#(make-music 'TextSpanEvent 'span-direction START 'spanner-id "2")
stopTextSpanTwo =
#(make-music 'TextSpanEvent 'span-direction STOP 'spanner-id "2")

\layout {
\context {
\Voice
\remove #"Text_spanner_engraver"
\consists \alternateTextSpannerEngraver
}
}

\relative c' {
\override TextSpanner.style = ##f
\override TextSpanner.thickness = 10
% \override TextSpanner.to-barline = ##t

a4 \tweak color #red \startTextSpan
b \tweak color #green \startTextSpanOne
c \tweak color #blue \startTextSpanTwo
d \=3\startTextSpan |
a4\stopTextSpan
b \stopTextSpanOne
\tweak color #red \startTextSpan
c \stopTextSpanTwo
\tweak color #green \startTextSpanOne
d \=3\stopTextSpan
\tweak color #blue \startTextSpanTwo |
a4 \=3\startTextSpan
b c d | \break

a4 b c d |
a4\stopTextSpan
\stopTextSpanOne
\stopTextSpanTwo
\=3\stopTextSpan
b
c \startTextSpan
d \tweak outside-staff-priority #0 \=1\startTextSpan |
a4 b
c \=1\stopTextSpan
d \stopTextSpan |
}
</lilypond>

[[Category:Contexts and engravers]]
[[Category:Editorial annotations]]
[[Category:Expressive marks]]
[[Category:Scheme]]
[[Category:Workaround]]
[[Category:Snippet]]

Alternate \textSpanner engraver

2026-03-11T08:15:18Z

Lemzwerg: Created page with "LilyPond's default text spanner engraver can only handle a single text spanner per voice at a time. The engraver in this snippet provides an alternate implementation to circumvent this limitation; it uses spanner IDs to specify start and end of overlapping text spanners. To use it, replace <code>Text_spanner_engraver</code> with <code>\alternateTextSpannerEngraver</code>. The example below demonstrates two possible ways to specify a spanner ID: either define a new com..."

LilyPond's default text spanner engraver can only handle a single text spanner per voice at a time. The engraver in this snippet provides an alternate implementation to circumvent this limitation; it uses spanner IDs to specify start and end of overlapping text spanners.

To use it, replace <code>Text_spanner_engraver</code> with <code>\alternateTextSpannerEngraver</code>. The example below demonstrates two possible ways to specify a spanner ID: either define a new command or use the <code>\=</code> command to directly set the ID.

To control the vertical order of text spanners, use the standard way of tweaking the <code>outside-staff-priority</code> property.

<lilypond version="2.24">
% LSR written by Dave Nalesnik
% LSR https://lists.gnu.org/archive/html/lilypond-user/2026-01/msg00006.html

% Incorporating some code from the rewrite in Scheme of
% Text_spanner_engraver in input/regression/scheme-text-spanner.ly

#(define (add-bound-item spanner item)
(if (null? (ly:spanner-bound spanner LEFT))
(ly:spanner-set-bound! spanner LEFT item)
(ly:spanner-set-bound! spanner RIGHT item)))

#(define (set-axis! grob axis)
(when (not (number? (ly:grob-property grob 'side-axis)))
(set! (ly:grob-property grob 'side-axis) axis)
(ly:grob-chain-callback
grob
(if (eq? axis X)
ly:side-position-interface::x-aligned-side
side-position-interface::y-aligned-side)
(if (eq? axis X)
'X-offset
'Y-offset))))

#(define (assign-spanner-index orig-ls)
"Determine an available position of a new spanner in an ordered
sequence of spanners (a list of pairs, where the car of the pair
gives the position). The goal is for the sequence to begin with
zero and contain no gaps. Return the index representing the
spanner's position.

Examples (only showing the cars of the pairs):

(0 1) => 2
(2 3) => 0
(0 3) => 1
(0 1 3) => 2
"
(if (null? orig-ls)
0
(let loop ((ls orig-ls)
(insert? #t)
(result 0))
(cond
((null? ls)
result)
;; Position at head of list.
((and insert? (> (caar orig-ls) 0))
(loop ls #f 0))
;; No gaps, put at end of list.
((and insert? (null? (cdr ls)))
(loop (cdr ls) #f (1+ (caar ls))))
;; Fill lowest position of gap.
((and insert?
(> (caadr ls) (1+ (caar ls))))
(loop (cdr ls) #f (1+ (caar ls))))
(else
(loop (cdr ls) insert? result))))))

alternateTextSpannerEngraver =
#(lambda (context)
(let (;; A list of pairs comprising a spanner index (not
;; `spanner-id` values) and a spanner which has been begun.
(spanners '())
(finished '()) ; A list of spanners in completion stage.
(start-events '()) ; A list of START events.
(stop-events '())) ; A list of STOP events.
(make-engraver
;; `\startTextSpan`, `\stopTextSpan`, and the like create
;; events which we collect here.
(listeners
((text-span-event engraver event)
(if (= START (ly:event-property event 'span-direction))
(set! start-events (cons event start-events))
(set! stop-events (cons event stop-events)))))

;; Populate `note-columns` property of spanners. Bounds are
;; set to note columns, and each spanner keeps a record of
;; the note columns it traverses.
(acknowledgers
((note-column-interface engraver grob source-engraver)
(for-each (lambda (s)
(ly:pointer-group-interface::add-grob
(cdr s) 'note-columns grob)
(when (null? (ly:spanner-bound (cdr s) LEFT))
(add-bound-item (cdr s) grob)))
spanners)
;; `finished` only contains spanners, no indices.
(for-each (lambda (f)
(ly:pointer-group-interface::add-grob
f 'note-columns grob)
(when (null? (ly:spanner-bound f RIGHT))
(add-bound-item f grob)))
finished)))

((process-music trans)
;; Move begun spanners from `span` to `finished`. We do
;; this on the basis of `spanner-id`. If we find a match
;; -- either the strings are the same, or both are unset --
;; a transfer can be made. Return a warning if we find no
;; match: spanner hasn't been properly begun.
(for-each
(lambda (es)
(let ((es-id (ly:event-property es 'spanner-id)))
(let loop ((sp spanners))
(if (null? sp)
(ly:warning "No spanner to end!")
(let ((sp-id (ly:event-property
(event-cause (cdar sp))
'spanner-id)))
(cond
((equal? sp-id es-id)
(set! finished (cons (cdar sp) finished))
(set! spanners
(remove (lambda (s)
(eq? s (car sp))) spanners)))
(else
(loop (cdr sp)))))))))
stop-events)

;; The end of our spanners can be acknowledged by other
;; engravers, thus announce them.
(for-each
(lambda (f)
(ly:engraver-announce-end-grob trans f (event-cause f)))
finished)

;; Make spanners in response to START events.
;;
;; Each new spanner is assigned an index denoting its
;; position relative to other active spanners. This is
;; enforced (for the moment) by adding a small amount to
;; the spanner's `outside-staff-priority` proportional to
;; this index. This is unlikely to result in conflicts,
;; though a better solution may be to organize the spanners
;; by a new alignment grob.
;;
;; Also, add any existing spanners to the
;; `side-support-elements` array of the new spanner. This
;; ensures correct ordering over line breaks when
;; `outside-staff-priority` is set to `#f` (which means
;; that it is no longer an outside-staff object -- not the
;; default).
(for-each
(lambda (es)
(let* ((new (ly:engraver-make-grob
trans 'TextSpanner es))
(new-idx (assign-spanner-index spanners))
(new-osp (ly:grob-property
new 'outside-staff-priority))
(new-osp (if (number? new-osp)
(+ new-osp (/ new-idx 1000.0))
new-osp)))
(set! (ly:grob-property
new 'outside-staff-priority) new-osp)
(set-axis! new Y)
;; Add spanners with a lower index than the new
;; spanner to its `side-support-elements` list. This
;; allows new spanners to fill gaps under the topmost
;; spanner.
(for-each (lambda (sp)
(when (< (car sp) new-idx)
(ly:pointer-group-interface::add-grob
new 'side-support-elements (cdr sp))))
spanners)
(set! spanners (cons (cons new-idx new) spanners))
(set! spanners
(sort spanners (lambda (x y)
(< (car x) (car y)))))))
start-events)

;; Events have served their purpose for this timestep.
;; Clear the way for new events in later timesteps.
(set! start-events '())
(set! stop-events '()))

((stop-translation-timestep trans)
;; Set bounds of spanners to `PaperColumns` grobs if they
;; haven't been set. This allows spanners to be drawn
;; between spacers.
;;
;; Other uses? Doesn't appear to affect whether spanners
;; can de drawn between rests.
(for-each (lambda (s)
(when (null? (ly:spanner-bound (cdr s) LEFT))
(ly:spanner-set-bound!
(cdr s) LEFT
(ly:context-property context
'currentMusicalColumn))))
spanners)
(for-each (lambda (f)
(when (null? (ly:spanner-bound f RIGHT))
(ly:spanner-set-bound!
f RIGHT
(ly:context-property context
'currentMusicalColumn))))
finished)
(set! finished '()))

((finalize trans)
;; If spanner ends on spacer at end of context?
(for-each (lambda (f)
(when (null? (ly:spanner-bound f RIGHT))
(ly:spanner-set-bound!
f RIGHT
(ly:context-property context
'currentMusicalColumn))))
finished)
(set! finished '())
;; User didn't end spanner.
(for-each (lambda (sp)
(ly:warning "incomplete spanner removed!")
(ly:grob-suicide! (cdr sp)))
spanners)
(set! spanners '())))))

%%%%%%%%%%%%%%%%%%%%%%%%%%%%% EXAMPLE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

startTextSpanOne =
#(make-music 'TextSpanEvent 'span-direction START 'spanner-id "1")
stopTextSpanOne =
#(make-music 'TextSpanEvent 'span-direction STOP 'spanner-id "1")
startTextSpanTwo =
#(make-music 'TextSpanEvent 'span-direction START 'spanner-id "2")
stopTextSpanTwo =
#(make-music 'TextSpanEvent 'span-direction STOP 'spanner-id "2")

\layout {
\context {
\Voice
\remove #"Text_spanner_engraver"
\consists \alternateTextSpannerEngraver
}
}

\relative c' {
\override TextSpanner.style = ##f
\override TextSpanner.thickness = 10
% \override TextSpanner.to-barline = ##t

a4 \tweak color #red \startTextSpan
b \tweak color #green \startTextSpanOne
c \tweak color #blue \startTextSpanTwo
d \=3\startTextSpan |
a4\stopTextSpan
b \stopTextSpanOne
\tweak color #red \startTextSpan
c \stopTextSpanTwo
\tweak color #green \startTextSpanOne
d \=3\stopTextSpan
\tweak color #blue \startTextSpanTwo |
a4 \=3\startTextSpan
b c d | \break

a4 b c d |
a4\stopTextSpan
\stopTextSpanOne
\stopTextSpanTwo
\=3\stopTextSpan
b
c \startTextSpan
d \tweak outside-staff-priority #0 \=1\startTextSpan |
a4 b
c \=1\stopTextSpan
d \stopTextSpan |
}
</lilypond>

[[Category:Contexts and engravers]]
[[Category:Editorial annotations]]
[[Category:Expressive marks]]
[[Category:Scheme]]
[[Category:Workaround]]
[[Category:Snippet]]

Making cross-staff beams look better

2026-03-11T08:10:11Z

Lemzwerg: Improve

Cross-staff beams might be very steep, which can be ugly sometimes. This snippet demonstrates how to change that.

<lilypond version="2.24">
\score {
\new PianoStaff <<
\new Staff = "RH" { \clef treble \time 3/4 s2.*2 }
\new Staff = "LH" { \clef bass \time 3/4 s2.*2 }
\context Staff = LH
\relative c' {
\stemDown
c,8 [ g'
\change Staff = RH
d' a' e' b' ] |
\override Beam.concaveness = #1
b [ e, a, d,
\change Staff = LH
g, c, ] |
}
>>
}

% Prevent bad cropping.
\markup \null
</lilypond>

[[Category:Keyboards]]
[[Category:Workaround]]
[[Category:Version-specific]]
[[Category:Snippet]]

Making cross-staff beams look better

2026-03-11T08:05:13Z

Lemzwerg:

Cross-staff beams may not look always good; this snippet demonstrates how to get better results.

<lilypond version="2.24">
\score {
\new PianoStaff <<
\new Staff = "RH" { \clef treble \time 3/4 s2.*2 }
\new Staff = "LH" { \clef bass \time 3/4 s2.*2 }
\context Staff = LH
\relative c' {
\stemDown % Change into \stemUp to fix the bug
c,8 [ g'
\change Staff = RH
d' a' e' b' ]
% This makes the second beam look much better.
\override Beam.concaveness = #0
b [ e, a, d,
\change Staff = LH
g, c, ]
}
>>
}

% Prevent bad cropping.
\markup \null
</lilypond>

[[Category:Keyboards]]
[[Category:Workaround]]
[[Category:Version-specific]]
[[Category:Snippet]]

Fingering spanner

2026-03-11T06:41:51Z

Lemzwerg: Revise

Draw a straight or dashed line between two fingerings.

Syntax is

-\guide <var>dashed?</var> <var>offset</var> -<var>f</var>

If Boolean argument <var>dashed?</var> is set to <code>#t</code>, draw a dashed line. The target fingering number is given by <var>f</var>, the offset from <var>f</var> to the start fingering is <var>offset</var>, which is coordinate pair (the X-value of this pair is thus always negative).

This function should be only used after the complete music has been typeset. Any change in the formatting will make the X-offsets invalid.

<lilypond version="2.24">
% LSR Credits: PPS in May 2015

guide =
#(define-music-function (dashed? coord fingering)
(boolean? pair? ly:music?)
"Make a line or dashed spanner, starting from the end
fingering and ending at the start fingering.
One should define the ending point with x and y coordinates."
(let ((fingering-ev (make-music 'FingeringEvent))
(finger (ly:music-property fingering 'digit)))
#{
\tweak stencil
#(lambda (grob)
(grob-interpret-markup grob
#{
\markup
\concat {
\line {
\translate #'(0 . 0.5)
\override #'(thickness . 1.3)
\with-dimensions #'(0 . 0) #'(0 . 0)
#(if dashed?
#{
\markup
\override #'(on . 0.8)
\override #'(off . 0.4)
\draw-dashed-line $coord
#}
#{ \markup \draw-line $coord #})
}
\hspace #0.4
#(number->string finger)
}
#}))
$fingering-ev
#}))

%%%% Test:
voiceI = {
\set fingeringOrientations = #'(up)

<cis'-3>16 <e'-0> <a-2> b
<c'-\guide ##f #'(-4 . 1) -2
-1>8
cis' d' dis' e' f' |
fis' g'
<gis'-\guide ##t #'(-39.5 . -2.5) -2
-\guide ##t #'(-39.5 . -2.5) -1>
<a'-3
-\guide ##f #'(-3.5 . -0.2) -1> bes' b'
<c''-\guide ##t #'(-13 . -0.8) -3
-\guide ##t #'(-13 . -0.8) -1>
<cis''-2-4> |
}

voiceII = {
r4 a16 a, ais a, b a, bis a, cis' a, d' a, |
dis' a, e' a, eis' a, fis' a, g' a, gis' a, a' a, g' a, |
}

{
\clef "G_8"
\key d \major
<< \voiceI \\ \voiceII >>
}
</lilypond>

[[Category:Editorial annotations]]
[[Category:Snippet]]

Indicating cross-staff chords with a bracket

2026-03-10T06:19:36Z

Lemzwerg:

A non-arpeggiato bracket can indicate that notes on two different staves are to be played with the same hand. In order to do this, the <code>PianoStaff</code> must be set to accept cross-staff arpeggios, and the arpeggios must be set to the bracket shape in the <code>PianoStaff</code> context.

The following example typesets measure 65 of Debussy’s prelude ''Les collines d'Anacapri''.

<lilypond version="2.24">
\new PianoStaff <<
\set PianoStaff.connectArpeggios = ##t
\override PianoStaff.Arpeggio.stencil =
#ly:arpeggio::brew-chord-bracket

\new Staff \relative c' {
\key b \major
\time 6/8
b8-.(\arpeggio fis'-.\> cis-.
e-. gis-. b-.)\!\fermata^\laissezVibrer \bar "||"
}

\new Staff \relative c' {
\clef bass
\key b \major
<< { <a e cis>2.\arpeggio } \\
{ <a, e a,>2. } >>
}
>>
</lilypond>

[[Category:Keyboards]]
[[Category:Real music]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

LSR 466

2026-03-10T06:16:54Z

Lemzwerg: Changed redirect target from Indicating cross-staff chords with arpeggio bracket to Indicating cross-staff chords with a bracket

#REDIRECT [[Indicating cross-staff chords with a bracket]]

Indicating cross-staff chords with a bracket

2026-03-10T06:16:24Z

Lemzwerg: Lemzwerg moved page Indicating cross-staff chords with arpeggio bracket to Indicating cross-staff chords with a bracket without leaving a redirect: Synchronize with LilyPond git repository

An arpeggio bracket can indicate that notes on two different staves are to be played with the same hand. In order to do this, the <code>PianoStaff</code> must be set to accept cross-staff arpeggios, and the arpeggios must be set to the bracket shape in the <code>PianoStaff</code> context.

The following example typesets measure 65 of Debussy’s prelude ''Les collines d'Anacapri''.

<lilypond version="2.24">
\new PianoStaff <<
\set PianoStaff.connectArpeggios = ##t
\override PianoStaff.Arpeggio.stencil =
#ly:arpeggio::brew-chord-bracket

\new Staff \relative c' {
\key b \major
\time 6/8
b8-.(\arpeggio fis'-.\> cis-.
e-. gis-. b-.)\!\fermata^\laissezVibrer \bar "||"
}

\new Staff \relative c' {
\clef bass
\key b \major
<< { <a e cis>2.\arpeggio } \\
{ <a, e a,>2. } >>
}
>>
</lilypond>

[[Category:Keyboards]]
[[Category:Real music]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

Adjusting vertical positioning of lyric hyphens

2026-03-09T05:15:17Z

Lemzwerg:

For joining syllables, LilyPond doesn’t use the hyphen of the text font but instead draws a simple line with variable length (this limitation is tracked as {{Issue|1255}}). Its standard vertical position doesn’t always fit the proportions of the text font. When using a font with a large x-height, it may be too low.

You can adjust the vertical positioning of the hyphens manually. To get a good result you may want to insert a “real” hyphen for comparison (like between ‘l-e’ in the snippet). You may also want to adjust the thickness of LilyPond hyphens using the <code>thickness</code> property of the <code>LyricHyphen</code> grob to match the font’s hyphen character.

<lilypond version="2.24">
% LSR contributed by Hannes Kuhnert <hannes.kuhnert@gmx.de> 1.2.2012.

\score {
<<
\new Voice = "Lied" {
\relative {
\clef G
\key c \major
e'2 d c1
}
}

\new Lyrics = "Lied"
\lyricsto Lied {
La -- l-e -- lu.
}
>>

\layout {
\context {
\Lyrics
\override LyricHyphen.Y-offset = #0.16
\override LyricHyphen.thickness = #2.1
}
}
}

\paper {
#(define fonts
(make-pango-font-tree
"Serif"
"Sans"
"Monospace"
(/ 20 20)))
}
</lilypond>

[[Category:Paper and layout]]
[[Category:Text]]
[[Category:Vocal music]]
[[Category:Snippet]]

Repeat with brackets

2026-03-07T15:44:07Z

Lemzwerg:

This snippet adds brackets with the number of repetitions above a bar or a group of bar. Very useful when dealing with minimal music, for instance. To summon it, simply use <code>\repeatBracket <var>N</var> music</code>, where <var>N</var> is the number of repetitions. Example: <code>\repeatBracket 7 { c'2 e' }</code>

<lilypond version="2.24">
% LSR based on the wonderful spanner by David Nalesnik; see
% LSR http://lists.gnu.org/archive/html/lilypond-user/2014-10/msg00446.html

#(define (test-stencil grob text)
(let* ((orig (ly:grob-original grob))
(siblings (ly:spanner-broken-into orig)) ; have we been split?
(refp (ly:grob-system grob))
(left-bound (ly:spanner-bound grob LEFT))
(right-bound (ly:spanner-bound grob RIGHT))
(elts-L (ly:grob-array->list (ly:grob-object left-bound 'elements)))
(elts-R (ly:grob-array->list (ly:grob-object right-bound 'elements)))
(break-alignment-L
(filter
(lambda (elt) (grob::has-interface elt 'break-alignment-interface))
elts-L))
(break-alignment-R
(filter
(lambda (elt) (grob::has-interface elt 'break-alignment-interface))
elts-R))
(break-alignment-L-ext (ly:grob-extent (car break-alignment-L) refp X))
(break-alignment-R-ext (ly:grob-extent (car break-alignment-R) refp X))
(num
(markup text))
(num
(if (or (null? siblings)
(eq? grob (car siblings)))
num
(make-parenthesize-markup num)))
(num (grob-interpret-markup grob num))
(num-stil-ext-X (ly:stencil-extent num X))
(num-stil-ext-Y (ly:stencil-extent num Y))
(num (ly:stencil-aligned-to num X CENTER))
(num
(ly:stencil-translate-axis
num
(+ (interval-length break-alignment-L-ext)
(* 0.5
(- (car break-alignment-R-ext)
(cdr break-alignment-L-ext))))
X))
(bracket-L
(markup
#:path
0.1 ; line-thickness
`((moveto 0.5 ,(* 0.5 (interval-length num-stil-ext-Y)))
(lineto ,(* 0.5
(- (car break-alignment-R-ext)
(cdr break-alignment-L-ext)
(interval-length num-stil-ext-X)))
,(* 0.5 (interval-length num-stil-ext-Y)))
(closepath)
(rlineto 0.0
,(if (or (null? siblings) (eq? grob (car siblings)))
-1.0 0.0)))))
(bracket-R
(markup
#:path
0.1
`((moveto ,(* 0.5
(- (car break-alignment-R-ext)
(cdr break-alignment-L-ext)
(interval-length num-stil-ext-X)))
,(* 0.5 (interval-length num-stil-ext-Y)))
(lineto 0.5
,(* 0.5 (interval-length num-stil-ext-Y)))
(closepath)
(rlineto 0.0
,(if (or (null? siblings) (eq? grob (last siblings)))
-1.0 0.0)))))
(bracket-L (grob-interpret-markup grob bracket-L))
(bracket-R (grob-interpret-markup grob bracket-R))
(num (ly:stencil-combine-at-edge num X LEFT bracket-L 0.4))
(num (ly:stencil-combine-at-edge num X RIGHT bracket-R 0.4)))
num))

#(define-public (Measure_attached_spanner_engraver context)
(let ((span '())
(finished '())
(event-start '())
(event-stop '()))
(make-engraver
(listeners ((measure-counter-event engraver event)
(if (= START (ly:event-property event 'span-direction))
(set! event-start event)
(set! event-stop event))))
((process-music trans)
(if (ly:stream-event? event-stop)
(if (null? span)
(ly:warning "You're trying to end a measure-attached spanner but you haven't started one.")
(begin (set! finished span)
(ly:engraver-announce-end-grob trans finished event-start)
(set! span '())
(set! event-stop '()))))
(if (ly:stream-event? event-start)
(begin (set! span (ly:engraver-make-grob trans 'MeasureCounter event-start))
(set! event-start '()))))
((stop-translation-timestep trans)
(if (and (ly:spanner? span)
(null? (ly:spanner-bound span LEFT))
(moment<=? (ly:context-property context 'measurePosition) ZERO-MOMENT))
(ly:spanner-set-bound! span LEFT
(ly:context-property context 'currentCommandColumn)))
(if (and (ly:spanner? finished)
(moment<=? (ly:context-property context 'measurePosition) ZERO-MOMENT))
(begin
(if (null? (ly:spanner-bound finished RIGHT))
(ly:spanner-set-bound! finished RIGHT
(ly:context-property context 'currentCommandColumn)))
(set! finished '())
(set! event-start '())
(set! event-stop '()))))
((finalize trans)
(if (ly:spanner? finished)
(begin
(if (null? (ly:spanner-bound finished RIGHT))
(set! (ly:spanner-bound finished RIGHT)
(ly:context-property context 'currentCommandColumn)))
(set! finished '())))
(if (ly:spanner? span)
(begin
(ly:warning "I think there's a dangling measure-attached spanner :-(")
(ly:grob-suicide! span)
(set! span '())))))))

% necessary layout options
% note that you can have more than one single layout block
% (some of them may even be outside and some inside \score)
\layout {
\context {
\Staff
\consists #Measure_attached_spanner_engraver
\override MeasureCounter.font-encoding = #'latin1
\override MeasureCounter.font-size = 0
\override MeasureCounter.outside-staff-padding = 2
\override MeasureCounter.outside-staff-horizontal-padding = #0
}
}

% function itself
repeatBracket = #(define-music-function
(N note)
(number? ly:music?)
#{
\override Staff.MeasureCounter.stencil =
#(lambda (grob) (test-stencil grob #{ #(string-append(number->string N) "×") #} ))
\startMeasureCount
\repeat volta #N { $note }
\stopMeasureCount
#}
)

%%%%%%%%%%%%%%%%%%%%%% EXAMPLE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

{
\repeatBracket 7 {c'1}
\repeatBracket 32 {d' g}
\repeatBracket 14 {e' f g}
\repeatBracket 29 {f' a bes \break cis' e''}
\repeatBracket 1048 {g'1}
}
</lilypond>

[[Category:Repeats]]
[[Category:Automatic notation]]
[[Category:Contemporary notation]]
[[Category:Specific notation]]
[[Category:Contexts and engravers]]
[[Category:Snippet]]

Curly bracket with variable length (path)

2026-03-05T17:31:57Z

Lemzwerg:

Curly brackets (or flat braces).

See also snippet [[Orchestral grouping with a custom brace]].

<lilypond version="2.24">
%% LSR: Credits: PPS on April 2015

%%% Defining a custom straight brace with a variable length:
#(define-markup-command (long-curly-bracket layout props arg-height)
(number?)
"Draw a curly bracket with a variable length."
(interpret-markup layout props
(markup
#:translate (cons 0 (* arg-height -1))
(#:with-dimensions (cons -0.001 0) (cons 0.001 0)
(#:override (cons (quote filled) #t)
(#:path 0.01 `(
(moveto -0.8 0.0)
(curveto -0.2 0.4 -0.3 0.7 -0.3 1.5)
(lineto -0.3 ,arg-height)
(curveto -0.4 ,(+ arg-height 1.3) 0.5
,(+ arg-height 2.8) 0.7
,(+ arg-height 2.8))
(curveto 0.6 ,(+ arg-height 2.5) 0.1
,(+ arg-height 2) 0.1
,arg-height)
(lineto 0.1 1.5)
(curveto 0.1 0.7 0.1 0.0 -0.8 0.0)
(closepath)
(curveto -0.2 -0.4 -0.3 -0.7 -0.3 -1.5)
(lineto -0.3 ,(* arg-height -1))
(curveto -0.4 ,(* (+ arg-height 1.3) -1) 0.5
,(* (+ arg-height 2.8) -1) 0.7
,(* (+ arg-height 2.8) -1))
(curveto 0.6 ,(* (+ arg-height 2.5) -1) 0.1
,(* (+ arg-height 2) -1) 0.1
,(* arg-height -1))
(lineto 0.1 -1.5)
(curveto 0.1 -0.7 0.1 0.0 -0.8 0.0)
(closepath))))))))

%%%% Examples:
\markup \with-dimensions #'(-1 . 110) #'(-95 . 3) \column {
\italic "long-curly-bracket #Y:"
\line {
\center-column { "#2.5" \vspace #1 \long-curly-bracket #2.5 }
\hspace #4
\center-column { "#5" \vspace #1 \long-curly-bracket #5 }
\hspace #4
\center-column { "#10" \vspace #1 \long-curly-bracket #10 }
\hspace #4
\center-column { "#22" \vspace #1 \long-curly-bracket #22 }
% \hspace #4
% \center-column { "#40" \vspace #1 \long-curly-bracket #40 }
\hspace #30
\center-column {
"\\rotate #90 & #-90"
\vspace #1
"#3"
\rotate #90 \raise #3 \long-curly-bracket #3
\vspace #1
% "#6"
% \rotate #90 \raise #6 \long-curly-bracket #6
% \vspace #1
"#12"
\rotate #90 \raise #12 \long-curly-bracket #12
\vspace #1
"#20"
\rotate #90 \raise #20 \long-curly-bracket #20
\vspace #1
% "#30"
% \rotate #90 \raise #30 \long-curly-bracket #30
% \vspace #1
% "#28"
% \rotate #-90 \raise #28 \long-curly-bracket #28
% \vspace #1
"#18"
\rotate #-90 \raise #18 \long-curly-bracket #18
\vspace #1
"#7"
\rotate #-90 \raise #7 \long-curly-bracket #7
\vspace #1
% "#4"
% \rotate #-90 \raise #4 \long-curly-bracket #4
% \vspace #1
"#2"
\rotate #-90 \raise #2 \long-curly-bracket #2
}
}
}
</lilypond>

[[Category:Staff notation]]
[[Category:Editorial annotations]]
[[Category:Text]]
[[Category:Symbols and glyphs]]
[[Category:Snippet]]

Print chord names with same root and different bass as slash and bass note

2026-03-05T16:59:52Z

Lemzwerg: Revise comments.

To print subsequent chord names only differing in their bass note as slash and bass note without a root symbol, use the Scheme engraver defined in this snippet. The is controlled by the <code>chordChanges</code> context property.

<lilypond version="2.24">
#(define Bass_changes_equal_root_engraver
(lambda (ctx)
"Drop root for follow-up chord names that differ only in bass.

In other words, the chord name sequence 'D D/C D/B' gets actually
printed as 'D /C /B'.

Set the `chordChanges` context property to `#t` to activate this
feature."
(let ((chord-pitches '())
(last-chord-pitches '())
(bass-pitch #f))
(make-engraver
((initialize this-engraver)
(let ((chord-note-namer (ly:context-property ctx
'chordNoteNamer)))
;; Set `chordNoteNamer`, respecting user setting if already
;; done.
(ly:context-set-property! ctx 'chordNoteNamer
(if (procedure? chord-note-namer)
chord-note-namer
note-name->markup))))

(listeners
((note-event this-engraver event)
(let* ((pitch (ly:event-property event 'pitch))
(pitch-name (ly:pitch-notename pitch))
(pitch-alt (ly:pitch-alteration pitch))
(bass (ly:event-property event 'bass #f))
(inversion (ly:event-property event 'inversion #f)))
;; We look at the `bass` and `inversion` event properties
;; to decide how to handle the current note event. If
;; `inversion` is set we add the bass note to the chord as
;; an ordinary member so that we can compare inversed
;; chords; if `bass` is set the bass note is not added to
;; the chord.
;;
;; In the `chord-pitches` list we actually collect only
;; the notes' pitch names (which are integers) and pitch
;; alterations as pairs, ignoring the octave.
(cond (bass (set! bass-pitch pitch))
(inversion
(set! bass-pitch pitch)
(set! chord-pitches
(cons (cons pitch-name pitch-alt)
chord-pitches)))
(else
(set! chord-pitches
(cons (cons pitch-name pitch-alt)
chord-pitches)))))))

(acknowledgers
((chord-name-interface this-engraver grob source-engraver)
(let ((chord-changes (ly:context-property ctx
'chordChanges #f)))
;; If subsequent chords are equal apart from their bass,
;; we change the `text` property to print only the slash
;; and the bass note (via the formatter stored in the
;; `chordNoteNamer` context property).
;;
;; Equality is tested by comparing the sorted lists of
;; this chord's elements and the previous chord. Sorting
;; is needed because inverted chords may have a different
;; order of pitches. Note that we only do a simplified
;; sorting using the pitch name, ignoring the alteration.
(if (and bass-pitch
chord-changes
(equal? (sort chord-pitches car<)
(sort last-chord-pitches car<)))
(ly:grob-set-property!
grob 'text
(make-line-markup
(list
(ly:context-property ctx 'slashChordSeparator)
((ly:context-property ctx 'chordNoteNamer)
bass-pitch
(ly:context-property ctx
'chordNameLowercaseMinor))))))
(set! last-chord-pitches chord-pitches)
(set! chord-pitches '())
(set! bass-pitch #f))))

((finalize this-engraver)
(set! last-chord-pitches '()))))))

myChords = \chordmode {
% \germanChords

\set chordChanges = ##t
d2:m d:m/cis

d:m/c
\set chordChanges = ##f
d:m/b

e1:7
\set chordChanges = ##t
e
\break

\once \set chordChanges = ##f
e1/f
e2/gis e/+gis e e:m/f d:m d:m/cis d:m/c
\set chordChanges = ##f
d:m/b
}

<<
\new ChordNames
\with { \consists #Bass_changes_equal_root_engraver }
\myChords
\new Staff \myChords
>>
</lilypond>

[[Category:Chords]]
[[Category:Contexts and engravers]]
[[Category:Scheme]]
[[Category:Staff notation]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

Lyrics alignment

2026-03-03T10:29:27Z

Lemzwerg:

Horizontal alignment for lyrics can be set by overriding the <code>self-alignment-X</code> property of the <code>LyricText</code> object. Value  -1 means left-aligned, 0 centered, and 1 right-aligned. Alternatively, you can use the Scheme values <code>LEFT</code>, <code>CENTER</code>, and <code>RIGHT</code> instead of numbers. Other numeric values are possible, too – don't forget to add the <samp>#</samp> Scheme prefix for negative numbers!

<lilypond version="2.24">
\layout {
ragged-right = ##f
}

\relative c'' {
c1 c c c
}

\addlyrics {
\once \override LyricText.self-alignment-X = #LEFT
"left-aligned"
\once \override LyricText.self-alignment-X = #CENTER
"centered"
\once \override LyricText.self-alignment-X = 1
"right-aligned"
\once \override LyricText.self-alignment-X = #-1.5
"overly left-aligned"
}
</lilypond>

[[Category:Really simple]]
[[Category:Text]]
[[Category:Vocal music]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

Adjusting vertical positioning of lyric hyphens

2026-03-02T08:55:14Z

Lemzwerg:

For joining syllables, LilyPond doesn’t use the hyphen of the text font but instead draws a simple line with variable length (this limitation is tracked as {{Issue|1255}}). Its standard vertical position doesn’t always fit the proportions of the text font. When using a font with a large x-height, it may be too low.

You can adjust the vertical positioning of the hyphens manually. To get a good result you may want to insert a “real” hyphen for comparison (like between ‘l-e’ in the snippet). You may also want to adjust the thickness of LilyPond hyphens using the <code>thickness</code> property of the <code>LyricHyphen</code> grob to match the font's hyphen character.

<lilypond version="2.24">
% LSR contributed by Hannes Kuhnert <hannes.kuhnert@gmx.de> 1.2.2012.

\score {
<<
\new Voice = "Lied" {
\relative {
\clef G
\key c \major
e'2 d c1
}
}

\new Lyrics = "Lied"
\lyricsto Lied {
La -- l-e -- lu.
}
>>

\layout {
\context {
\Lyrics
\override LyricHyphen.Y-offset = #0.16
\override LyricHyphen.thickness = #2.1
}
}
}

\paper {
#(define fonts
(make-pango-font-tree
"Serif"
"Sans"
"Monospace"
(/ 20 20)))
}
</lilypond>

[[Category:Paper and layout]]
[[Category:Text]]
[[Category:Vocal music]]
[[Category:Snippet]]

Creating guitar scales on fretboards

2026-03-02T08:51:28Z

Lemzwerg:

This snippet creates fretboards with guitar scales.

The syntax is

\scale-diagram #'( (string1 fret1) (string2 fret2) ... )
#notes-in-scale #size

As an example, here is a c pentatonic scale (first six notes).

\scale-diagram #'((5 3) (5 5) (4 3) (4 5) (3 2) (3 5)) #5 #1.5

You can wrap this up in a markup command for building up a list of scales as follows

cpenta = \markup
\scale-diagram #'((5 3) (5 5) (4 3) (4 5) (3 2) (3 5)) #5 #1.5

and use it like this

c^\cpenta d f g a c

The snippet doesn't show it, but the (1) position of the scale is inverted.

<lilypond version="2.24">
% Helper function to invert first elements of scales
#(define (inverted num mod)
(if (zero? (modulo num mod))
(list '1 'inverted)
(list (1+ (modulo num mod)))))

% Expand the (string fret) pairs to valid lilypond syntax
#(define (fret-from-list l1 l2 n1)
(if (null? l1)
l2
(fret-from-list (cdr l1) (append l2 (list (append '(place-fret) (car l1) (inverted (length l2) n1)))) n1)))

% arg1 is the list of (string fret) pairs making up the scale
% arg2 is the number of unique tones in the scale (i.e. 7 for major scale, 5 for pentatonic)
% arg3 is a scale factor used to enlarge the fret diagram
#(define-markup-command (scale-diagram layout props arg1 arg2 arg3) (list? integer? number?)
(interpret-markup layout props
(markup
(#:override (cons 'size arg3 )
(#:override '(fret-diagram-details
. (
(finger-code . in-dot)
(number-type . arabic)
(label-dir . -1)
(orientation . landscape)
(dot-radius . 0.4)
(fret-count . 8)
(top-fret-thickness . 7)))
#:fret-diagram-verbose
(fret-from-list arg1 '() arg2))))))

cmajor=\markup\scale-diagram #'((5 3) (5 5) (4 2) (4 3) (4 5) (3 2) (3 4)
(3 5) (2 3) (2 5) (2 6) (1 3) (1 5) (1 7) (1 8)) #7 #1.0

dmajor=\markup\scale-diagram #'((5 5) (5 7) (4 4) (4 5) (4 7) (3 4) (3 6)
(3 7) (2 5) (2 7) (2 8) (1 5) (1 7) (1 9) (1 10)) #7 #1.35

cpenta=\markup\scale-diagram #'((5 3) (5 5) (4 3) (4 5) (3 2)
(3 5) (2 3) (2 6) (1 3) (1 5) (1 8)) #5 #1.7

\relative c' {
c d^\cmajor e f g^"c Ionic" a b c d e f g a b c r | \break
d,, e^\dmajor fis g a^"d Ionic" b cis d e fis g a b cis d r | \break
c,, d^\cpenta f g a^"c pentatonic" a c d f g a c |
}
</lilypond>

[[Category:Fretted strings]]
[[Category:Scheme]]
[[Category:Pitches]]
[[Category:Snippet]]

Harmonizing bar line thickness for staves with different sizes

2026-03-01T11:31:00Z

Lemzwerg:

When using <code>\magnifyStaff</code> only for some staves in a <code>StaffGroup</code>, <code>BarLine</code> grobs do not align any more due to its changed properties <code>thick-thickness</code>, <code>hair-thickness</code>, and <code>kern</code>.

To fix this, multiple workarounds are available, as demonstrated below.

<lilypond version="2.24">
% LSR originally contributed by -vv for \version 2.20.

\markuplist {
% First row.
\fill-line {
\score {
\new StaffGroup <<
\new Staff \with { \magnifyStaff #1/2 } {
\textMark \markup \tiny "default"
b1 b \bar "|."
}
\new Staff { b b }
>>
}
\score {
\new StaffGroup <<
\new Staff \with { \magnifyStaff #1/2 } {
\textMark \markup \tiny \column { "reverting only the"
"final bar line" }
b1 b
\revert Staff.BarLine.thick-thickness
\revert Staff.BarLine.hair-thickness
\revert Staff.BarLine.kern
\bar "|."
}
\new Staff { b b }
>>
}
\score {
\new StaffGroup <<
\new Staff \with { \magnifyStaff #1/2
#(revert-props 'magnifyStaff 0
'((BarLine thick-thickness)
(BarLine hair-thickness)
(BarLine kern))) } {
\textMark \markup \tiny \column { "cancelling"
\typewriter "\\magnifyStaff"
"only for bar lines" }
b1 b \bar "|."
}
\new Staff { b b }
>>
}
}

\vspace #2

% Second row.
\fill-line {
\score {
\new StaffGroup <<
\new Staff \with { \magnifyStaff #1/2 } {
\textMark \markup \tiny \column { "mimicking"
\typewriter "\\magnifyStaff"
"on the other staves" }
b1 b \bar "|." }
\new Staff \with { #(scale-props 'magnifyStaff 1/2 #t
'((BarLine thick-thickness)
(BarLine hair-thickness)
(BarLine kern))) } {
b b }
>>
}
\score {
\new StaffGroup <<
\new Staff \with { \magnifyStaff #1/2
#(scale-props 'magnifyStaff 3/2 #t
'((BarLine thick-thickness)
(BarLine hair-thickness)
(BarLine kern))) } {
\textMark \markup \tiny \column { "applying an"
"intermediate"
"value to all staves" }
b1 b \bar "|." }
\new Staff \with { #(scale-props 'magnifyStaff 3/4 #t
'((BarLine thick-thickness)
(BarLine hair-thickness)
(BarLine kern))) } {
b b }
>>
}
""
}
}
</lilypond>

[[Category:Staff notation]]
[[Category:Spacing]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

Flat ties

2026-03-01T11:28:44Z

Lemzwerg:

This snippet provides a function <code>flared-tie</code> to draw a tie that consist of straight lines. It is intended as a replacement for the default tie-drawing function (i.e., a replacement argument for the <code>stencil</code> property of the <code>Tie</code> grob).

The argument of <code>flared-tie</code> is a list of coordinate pairs that specify additional points between the first and last point to span up the tie’s lines. The first and last point are identical to the original tie’s start and end point, respectively. The X and Y coordinate values are multiples of the bounding box length and height of the original tie (also taking care of the tie’s direction); consequently, the first point has coordinates (0,0), and the last point (1,0).

The function <code>flare-tie</code> defines a shorthand for a flat tie. Further tweaking of the shape is possible by overriding <code>Tie.details.height-limit</code> or with <code>\shape</code>. It is also possible to change the custom definition on the fly.

<lilypond version="2.24">
#(define ((flared-tie coords) grob)
(define (pair-to-list pair)
(list (car pair) (cdr pair)))

(define (normalize-coords goods x y dir)
(map
(lambda (coord)
(cons (* x (car coord)) (* y dir (cdr coord))))
goods))

(define (my-c-p-s points thick)
(make-connected-path-stencil points thick 1.0 1.0 #f #f))

;; Calling `ly:tie::print` and assigning its return value to a
;; variable in this outer `let` triggers LilyPond to position the
;; tie, allowing us to extract its extents. We only proceed,
;; however, if the tie doesn't get discarded (for whatever reason).
(let ((sten (ly:tie::print grob)))
(if (grob::is-live? grob)
(let* ((layout (ly:grob-layout grob))
(line-thickness (ly:output-def-lookup layout
'line-thickness))
(thickness (ly:grob-property grob 'thickness 0.1))
(used-thick (* line-thickness thickness))
(dir (ly:grob-property grob 'direction))
(xex (ly:stencil-extent sten X))
(yex (ly:stencil-extent sten Y))
(lenx (interval-length xex))
(leny (interval-length yex))
(xtrans (car xex))
(ytrans (if (> dir 0)(car yex) (cdr yex)))
;; Add last point.
(coord-list (append coords '((1.0 . 0.0))))
(uplist
(map pair-to-list
(normalize-coords coord-list lenx (* leny 2) dir))))
(ly:stencil-translate
(my-c-p-s uplist used-thick)
(cons xtrans ytrans)))
'())))

% Define a default tie shape consisting of three straight lines.
#(define flare-tie
(flared-tie '((0.1 . 0.3) (0.9 . 0.3))))

\relative c' {
a4~ a
\once \override Tie.stencil = #flare-tie
a4~ a \break

<a c e a c e a c e>~ q
\once \override Tie.stencil = #flare-tie
q~ q\break

<>^\markup \small \typewriter "height-limit = 14"
\override Tie.details.height-limit = 14
a'4~ a
\once \override Tie.stencil = #flare-tie
a4~ a \break

<>^\markup \small \typewriter "height-limit = 0.5"
\override Tie.details.height-limit = 0.5
a4~ a
\once \override Tie.stencil = #flare-tie
a4~ a \break

\revert Tie.details.height-limit

<>^\markup \small \typewriter
"\\shape #'((0 . 0) (0 . -1) (0 . -1) (0 . 0))"
\shape #'((0 . 0) (0 . -1) (0 . -1) (0 . 0)) Tie
a4~ a
\once \override Tie.stencil = #flare-tie
\shape #'((0 . 0) (0 . -1) (0 . -1) (0 . 0)) Tie
a4~ a \break

<>^\markup \small \typewriter
"#(flared-tie '((0.2 . 2) (0.5 . -3) (0.8 . 1))"
\once \override Tie.stencil =
#(flared-tie '((0.2 . 2) (0.5 . -3) (0.8 . 1)))
a4~ a
<>_\markup \small \typewriter
"#(flared-tie '((0.5 . 2)))"
\once \override Tie.stencil = #(flared-tie '((0.5 . 2)))
a'4~ a
}
</lilypond>

[[Category:Contemporary notation]]
[[Category:Scheme]]
[[Category:Staff notation]]
[[Category:Tweaks and overrides]]
[[Category:Included in the official documentation]]
[[Category:Snippet]]

User talk:SimonAlbrecht

2026-02-28T09:59:55Z

Lemzwerg: /* Bitte LilyPond-Version beachten! */ Reply

== Bitte LilyPond-Version beachten! ==

Danke für das Update von [[Adjusting vertical positioning of lyric hyphens]]! Allerdings mußte ich deine Änderungen teilweise wieder rückgängig machen, weil Du Syntax verwendet hast, die es in 2.24 noch nicht gibt. Wenn möglich, verwende bitte nichts neueres als 2.24 in diesem Wiki. Falls neueres demonstriert werden soll, muß die Versionsnummer in <code><lilypond></code> angepaßt werden. -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 06:06, 28 February 2026 (UTC)

:Oh, das war natürlich ein handwerklicher Fehler. Ich bin gerade nicht mehr sicher, ob ich gar nicht an 2.24 gedacht hatte oder ob ich dachte, das wäre da schon drin gewesen. So oder so danke fürs revidieren! [[User:SimonAlbrecht|SimonAlbrecht]] ([[User talk:SimonAlbrecht|talk]]) 09:50, 28 February 2026 (UTC)
:Wäre es sinnvoll, die <code>property-defaults</code>-Syntax als Kommentar drin zu lassen für das Update zu 2.26? [[User:SimonAlbrecht|SimonAlbrecht]] ([[User talk:SimonAlbrecht|talk]]) 09:53, 28 February 2026 (UTC)
::Eher nicht, denk' ich mal, da <code>convert-ly</code> das automatisch handhabt (also zumindest die Standardfälle). -- [[User:Lemzwerg|Lemzwerg]] ([[User talk:Lemzwerg|talk]]) 09:59, 28 February 2026 (UTC)

Watermark

2026-02-28T06:19:04Z

Lemzwerg:

Add a watermark directly into a LilyPond file, without using a third-party PDF tool.

<lilypond version="2.24" full>
watermark = \markup
\with-dimensions-from\null {
\translate #'(-70 . -120)
\rotate #50
\fontsize #13
\pattern #12 #Y #3
\pattern #3 #X #5
\bold\with-color #(rgb-color .9 .9 .9) "copyrighted material"
}
\paper {
print-first-page-number = ##t
%page-count = 2
ragged-last-bottom = ##f
oddHeaderMarkup = \markup {
\combine\watermark
\fill-line {
\null
\if \should-print-page-number
\fromproperty #'page:page-number-string
}
}
evenHeaderMarkup = \markup {
\combine\watermark
\fill-line {
\if \should-print-page-number
\fromproperty #'page:page-number-string
\null
}
}
}
\header {
dedication = \markup \italic "This music is dedicated to the LSR"
title = "This is a Title"
subtitle = "This is a Subtitle"
subsubtitle = "This is a Subsubtitle"
piece = "This is a Piece"
opus = "Op. 000"
instrument = "This is an Instrument"
composer = "This is a Composer"
arranger = "This is an Arranger"
poet = "This is a Poet"
copyright = "Copyrighted material"

}
{ \repeat unfold 60 { c' d' e' f' } \bar "|." }
</lilypond>

[[Category:Editorial annotations]]
[[Category:Text]]
[[Category:Paper and layout]]
[[Category:Snippet]]