Use size as the absolute font size (in points) to display arg.

This function adjusts the baseline-skip and word-space properties accordingly.

\markup {
  default text font size
  \hspace #2
  \abs-fontsize #16 { text font size 16 }
  \hspace #2
  \abs-fontsize #12 { text font size 12 }
}

Used properties:

• baseline-skip (3)
• word-space (0.6)

Print arg with a bold face.

\markup {
  default
  \hspace #2
  \bold bold
}

The code \markup \bold … is a shorthand for \markup \override #'(font-series . bold) … – using the more verbose form, it is possible to obtain nuances such as semi-bold, if the text font has such variants. Refer to the documentation for the font-series properties (User backend properties).

Draw a box around arg.

This function looks at the thickness, box-padding, and font-size properties to determine the line thickness and padding around the markup.

\markup {
  \override #'(box-padding . 0.5)
  \box \line { V. S. }
}

Note that the box does not horizontally displace its argument. Use markup commands like \left-align or \table to make LilyPond realign it.

\markup {
  \override #'(box-padding . 1.5)
  \column {
    "text"
    \box "text"
    \left-align \box "text"
  }
}

Used properties:

• box-padding (0.2)
• font-size (0)
• thickness (1)

Print arg in (fake) small caps.

This function is a copy of the \smallCaps command.

\markup {
  default
  \hspace #2
  \caps {
    Text in small caps
  }
}

Use \fontCaps for real small caps (if the font provides it).

Print arg using the (music) font for dynamics.

This font only contains letters f, m, n, p, r, s, and z. When producing phrases like ‘più f’, the normal words (like ‘più’) should be done in a different font. The recommended font for this is bold and italic.

\markup {
  \dynamic {
    sfzp
  }
}

Set arg as small numbers for figured bass.

Specially slashed digits can be achieved with a trailing backslash (for numbers 6, 7, and 9) or a trailing plus (for numbers 2, 4, and 5).¹³

The use of a backslash is in analogy to \figuremode (see Entering figured bass). Note that to get a backslash character in markup it must be escaped by doubling it. Additionally, it must be put into double quotes.

\markup {
  \figured-bass {
    2 3 4+ 7 "9\\"
  }
}

Set arg as small numbers for fingering instructions.

\markup {
  \finger {
    1 2 3 4 5
  }
}

Print arg in small caps.

This command sets the font-variant property to small-caps.

Unlike \smallCaps, which merely uses capital letters at a smaller font size, this uses the actual variant of the font for small caps. (As a consequence, if you configure a custom text font, this command has no effect if that font does not have a small caps variant.)

\markup \fontCaps "Small caps"

Increase current font size by increment to print arg.

This function adjusts the baseline-skip and word-space properties accordingly.

\markup {
  default
  \hspace #2
  \fontsize #-1.5 smaller
}

Used properties:

• baseline-skip (2)
• word-space (1)
• font-size (0)

Set font size to value 2 to print arg.

\markup {
  default
  \hspace #2
  \huge huge
}

Print arg in italics.

This command sets the font-shape property to italic.

\markup {
  default
  \hspace #2
  \italic italic
}

Set font size to value 1 to print arg.

\markup {
  default
  \hspace #2
  \large large
}

Increase current font size by 1 to print arg.

This function adjusts the baseline-skip and word-space properties accordingly.

\markup {
  default
  \hspace #2
  \larger larger
}

Magnify current font by factor sz to print arg.

\markup {
  default
  \hspace #2
  \magnify #1.5 {
    50% larger
  }
}

Note that magnification only works if a font name is explicitly selected. Use \fontsize otherwise.

Set arg in subscript with a normal font size.

\markup {
  default
  \normal-size-sub {
    subscript in standard size
  }
}

Used properties:

• font-size (0)

Set arg in superscript with a normal font size.

\markup {
  default
  \normal-size-super {
    superscript in standard size
  }
}

Used properties:

• font-size (0)

Print arg with default text font.

This resets all font-related properties (except the size), no matter what font was used earlier.

\markup {
  \huge \bold \sans \fontCaps {
    huge bold sans caps
    \hspace #2
    \normal-text {
      huge normal
    }
    \hspace #2
    as before
  }
}

Switch to normal weight (in contrast to bold) to print arg.

This command sets the font-series property to normal.

\markup {
  \bold {
    some bold text
    \hspace #2
    \normal-weight {
      normal font series
    }
    \hspace #2
    bold again
  }
}

Set font size to default (i.e., to value 0) to print arg.

\markup {
  \teeny {
    this is very small
    \hspace #2
    \normalsize {
      normal size
    }
    \hspace #2
    teeny again
  }
}

Print arg using the (music) font for numbers.

This font also contains symbols for figured bass, some punctuation, spaces of various widths, some letters and text variants of accidentals. Use \dynamic to access the (very small number of) letters. For accidentals you might use \number in combination with Unicode characters to access the text representation forms of accidental glyphs, as the following table shows.

To get accidentals protected against overrides of font-name it is preferable to use \text-doubleflat, \text-flat, \text-natural, \text-sharp, \text-doublesharp or the general \text-accidental for the text variants of accidentals.

The appearance of digits in the Emmentaler font can be controlled with four OpenType features: ‘tnum’, ‘cv47’, ‘ss01’, and ‘kern’, which can be arbitrarily combined.

tnum

If off (which is the default), glyphs ‘zero’ to ‘nine’ have no left and right side bearings. If on, the glyphs all have the same advance width by making the bearings non-zero.

cv47

If on, glyphs ‘four’ and ‘seven’ have shorter vertical strokes. Default is off.

ss01

If on, glyphs ‘zero’ to ‘nine’ have a fatter design, making them more readable at small sizes. Default is off.

kern

If on (which is the default), provide pairwise kerning between (most) glyphs.

\markuplist
  \number
  \fontsize #4.5
  \override #'((padding . 2)
               (baseline-skip . 4)
               (box-padding . 0)
               (thickness . 0.1))
  \table #'(-1 -1 -1 -1) {
      0123456789 \box 147 \concat { \box 1 \box 4 \box 7 }
    \normal-text \normalsize "(time signatures)"
    \override #'(font-features .("cv47")) {
      0123456789 \box 147 \concat { \box 1 \box 4 \box 7 } }
    \normal-text \normalsize "(alternatives)"
    \override #'(font-features .("tnum" "cv47" "-kern")) {
      0123456789 \box 147 \concat { \box 1 \box 4 \box 7 } }
    \normal-text \normalsize "(fixed-width)"
    \override #'(font-features . ("tnum" "cv47" "ss01")) {
      0123456789 \box 147 \concat { \box 1 \box 4 \box 7 } }
    \normal-text \normalsize "(figured bass)"
    \override #'(font-features . ("cv47" "ss01")) {
      0123456789 \box 147 \concat { \box 1 \box 4 \box 7 } }
    \normal-text \normalsize "(fingering)"
  }

See also the markup commands \figured-bass and \finger, which set the font features accordingly.

Overtie arg.

\markup \line {
  \overtie "overtied"
  \override #'((offset . 5) (thickness . 1))
  \overtie "overtied"
  \override #'((offset . 1) (thickness . 5))
  \overtie "overtied"
}

Used properties:

• shorten-pair ((0 . 0))
• height-limit (0.7)
• direction (1)
• offset (2)
• thickness (1)

Use replacements to replace strings in arg.

Each (key . value) pair of the replacements alist specifies what should be replaced; key gets replaced by value. Note the quasiquoting syntax with a backquote in the second example.

\markup \replace #'(("2nd" . "Second"))
  "2nd time"
\markup \replace
  #`(("2nd" . ,#{ \markup \concat { 2 \super nd } #}))
  \center-column {
    \line { Play only }
    \line { the 2nd time }
  }

Used properties:

• replacement-alist

Print arg with a sans-serif font.

This command sets the font-family property to sans.

\markup {
  default
  \hspace #2
  \sans {
    sans serif
  }
}

Print arg with a serif font.

This command sets the font-family property to serif.

\markup {
  \sans \bold {
    sans serif, bold
    \hspace #2
    \serif {
      text in serif font
    }
    \hspace #2
    return to sans
  }
}

Print string str.

\markup \simple "x" is equivalent to \markup "x". This command was previously used internally, but no longer is, and is being kept for backward compatibility only.

Set font size to value -1 to print arg.

\markup {
  default
  \hspace #2
  \small small
}

Print arg in (fake) small caps.

Unlike \fontCaps, which uses the actual small caps variant of the current font, this fakes small caps by using capital letters at a smaller font size. It can thus be used for fonts that don’t have a small caps variant.

\markup {
  default
  \hspace #2
  \smallCaps {
    Text in small caps
  }
}

Decrease current font size by 1 to print arg.

This function adjusts the baseline-skip and word-space properties accordingly.

\markup {
  \fontsize #3.5 {
    large text
    \hspace #2
    \smaller { smaller text }
    \hspace #2
    large text
  }
}

Set arg in subscript.

\markup { \concat { H \sub 2 O } }

Ssee also \super.

Used properties:

• font-size (0)

Set arg in superscript.

\markup { E = \concat { mc \super 2 } }

See also \sub.

Used properties:

• font-size (0)

Set font size to value -3 to print arg.

\markup {
  default
  \hspace #2
  \teeny teeny
}

Add a horizontal bow at the bottom or top of arg.

This function uses make-tie-stencil to create the bow; it looks at the thickness and offset properties to determine the line thickness and vertical offset, respectively. The added bow fits the extent of arg; use the shorten-pair property to modify this. The direction property may be set explicitly using override or direction modifiers, or implicitly by using voiceOne, etc.

\markup {
  \override #'(direction . 1)
  \tie "above"
  \override #'(direction . -1)
  \tie "below"
}

See also \undertie and \overtie, which are shorthands for this function.

Used properties:

• shorten-pair ((0 . 0))
• height-limit (0.7)
• direction (1)
• offset (2)
• thickness (1)

Set font size to value -2 to print arg.

\markup {
  default
  \hspace #2
  \tiny tiny
}

Print arg in typewriter.

This command sets the font-family property to typewriter, also switching off the ‘liga’ OpenType feature to disable ligatures like ‘ff’ or ‘fi’.

\markup {
  "default fi ff"
  \hspace #2
  \typewriter "typewriter fi ff"
}

Underline arg.

This function looks at the property thickness to determine the line thickness, at offset to determine the line’s vertical offset from arg, and at underline-skip to determine the distance of additional lines from the others.

The underline-shift property is used to make subsequent calls work correctly. Overriding it makes little sense since it would end up adding the provided value to the one of offset.

\markup \justify-line {
  \underline "underlined"
  \override #'(offset . 5)
  \override #'(thickness . 1)
  \underline "underlined"
  \override #'(offset . 1)
  \override #'(thickness . 5)
  \underline "underlined"
  \override #'(offset . 5)
  \override #'(underline-skip . 4)
  \underline \underline \underline "underlined thrice"
}

Used properties:

• underline-skip (2)
• underline-shift (0)
• offset (2)
• thickness (1)

Print a tie under arg.

\markup \line {
  \undertie "undertied"
  \override #'((offset . 5) (thickness . 1))
  \undertie "undertied"
  \override #'((offset . 1) (thickness . 5))
  \undertie "undertied"
}

Used properties:

• shorten-pair ((0 . 0))
• height-limit (0.7)
• direction (1)
• offset (2)
• thickness (1)

Print arg upright.

This command is the opposite of \italic; it sets the font-shape property to upright.

\markup {
  \italic {
    italic text
    \hspace #2
    \upright {
      upright text
    }
    \hspace #2
    italic again
  }
}

Set arg in a font appropriate for volta numbers.

\markup \volta-number "4."

Apply string transformer function transformer to arg.

Whenever a string is interpreted inside arg, function transformer is called first, and its result is then interpreted. The arguments passed to transformer are the output definition, the property alist chain, and the markup arg. See New markup command definition about the two first arguments.

\markup \with-string-transformer
  #(lambda (layout props str)
     (string-upcase str))
  \concat { "abc" \larger "def" }

Create an invisible object taking up absolute horizontal space of amount points.

\markup {
  one
  \abs-hspace #20
  two
  \abs-hspace #40
  three
}

See also \hspace.

Create an invisible object taking up absolute vertical space of amount points.

\markup {
    \center-column {
    one
    \abs-vspace #20
    two
    \abs-vspace #40
    three
  }
}

See also \vspace.

Align markup self on markup other along axis.

This function uses self-dir and other-dir for mutual alignment of self and other, respectively, translating self as requested relative to its surroundings. other is not printed.

If self-dir or other-dir is #f, use the reference point of self or other, respectively.

\markup \column {
  12
  \align-on-other #X #RIGHT 12
                     #LEFT 12345
  \align-on-other #X #RIGHT 123
                     #LEFT \fermata
  123
  \align-on-other #X #RIGHT 123
                     ##f \fermata
}

Align arg to its X center.

\markup {
  \column {
    one
    \center-align two
    three
  }
}

Put args into a centered column.

See also \column.

\markup {
  \center-column {
    one
    two
    three
  }
}

Used properties:

• baseline-skip

Stack the markups in args vertically.

The property baseline-skip determines the space between markups in args (to be more precise, the space between the baselines of the markups).

\markup {
  \column {
    one
    two
    three
  }
}

The baseline of the output of \column is the baseline of its first line.

Used properties:

• baseline-skip

Print arg1, then print arg2 on top of it.

Note: \combine cannot take a list of markups enclosed in curly braces as an argument; for this purpose use \overlay instead.

\markup {
  \fontsize #5
  \override #'(thickness . 2)
  \combine
    \draw-line #'(0 . 4)
    \arrow-head #Y #DOWN ##f
}

Concatenate args in a horizontal line, without spaces in between.

Strings are concatenated on the input level, allowing ligatures. For example, \concat { "f" "i" } is equivalent to "fi".

\markup {
  \concat {
    one two three
  }
}

Make a column of args.

Depending on the setting of the direction layout property, the arguments are stacked upwards or downwards.

\markup {
  \override #`(direction . ,UP)
  \dir-column {
    going up
  }
  \hspace #1
  \dir-column {
    going down
  }
  \hspace #1
  \override #'(direction . 1)
  \dir-column {
    going up
  }
}

The baseline of the output of \dir-column is the baseline of its first line.

Used properties:

• baseline-skip
• direction

Put markups args into a horizontal line.

The markups are spaced or flushed to fill the entire line. If there are no arguments, return an empty stencil.

The width of the horizontal line can be modified by overriding the line-width property.

\markup {
  \column {
    \fill-line {
      Words evenly spaced across the page
    }
    \null
    \fill-line {
      \line { Text markups }
      \line {
        \italic { evenly spaced }
      }
      \line { across the page }
    }
    \null
    \override #'(line-width . 50)
    \fill-line {
      Width explicitly specified
    }
  }
}

Used properties:

• line-width (#f)
• word-space (0.6)
• text-direction (1)

Put left and right at the start and end of a line, respectively, and fill the space inbetween with repeated pattern markups.

Patterns are spaced apart by space and aligned to direction dir. The width of the line is given by the line-width property.

\markup \column {
  "right-aligned:"
  \fill-with-pattern #1 #RIGHT . first right
  \fill-with-pattern #1 #RIGHT . second right
  \null
  "center-aligned:"
  \fill-with-pattern #1.5 #CENTER - left right
  \null
  "left-aligned:"
  \override #'(line-width . 50) {
    \fill-with-pattern #2 #LEFT : left first
    \fill-with-pattern #2 #LEFT : left second
  }
}

Used properties:

• line-width
• word-space

Align arg in axis direction to the dir side.

\markup {
  \column {
    one
    \general-align #X #LEFT two
    three
    \null
    one
    \general-align #X #CENTER two
    three
    \null
    \line {
      one
      \general-align #Y #UP two
      three
    }
    \null
    \line {
      one
      \general-align #Y #3.2 two
      three
    }
  }
}

Print arg with horizontal alignment set to dir.

If dir is -1, arg is left-aligned, while +1 makes it right-aligned. Values inbetween interpolate the alignment accordingly.

\markup {
  \column {
    one
    \halign #LEFT two
    three
    \null
    one
    \halign #CENTER two
    three
    \null
    one
    \halign #RIGHT two
    three
    \null
    one
    \halign #-5 two
    three
  }
}

Center arg horizontally within a box of extending length/2 to the left and right.

\new StaffGroup <<
  \new Staff {
    \set Staff.instrumentName = \markup {
      \hcenter-in #12 Oboe
    }
    c''1
  }
  \new Staff {
    \set Staff.instrumentName = \markup {
      \hcenter-in #12 Bassoon
    }
    \clef tenor
    c'1
  }
>>

Create an invisible object taking up amount horizontal space.

\markup {
  one
  \hspace #2
  two
  \hspace #8
  three
}

amount can be also a negative value, which can be best visualized as if the current drawing point gets moved to the left.

\markup \concat {
  \hspace #4
  \column {
    \box \concat { AAAA \hspace #4 }
    \box \concat { AAAA \hspace #-4 }
    \box \concat { \hspace #4 AAAA }
    \box \concat { \hspace #-4 AAAA }
  }
}

See also \abs-hspace.

Print args as lines aligned both at the left and the right.

Like \wordwrap, but with lines stretched to justify the margins. Use \override #'(line-width . X) to set the line width; X is the number of staff spaces.

\markup {
  \justify {
    Lorem ipsum dolor sit amet, consectetur adipisicing elit,
    sed do eiusmod tempor incididunt ut labore et dolore
    magna aliqua.  Ut enim ad minim veniam, quis nostrud
    exercitation ullamco laboris nisi ut aliquip ex ea
    commodo consequat.
  }
}

The baseline of the output of \justify is the baseline of its first line.

Used properties:

• text-direction (1)
• word-space
• line-width (#f)
• baseline-skip

Justify the data that has been assigned to symbol.

\header {
  title = "My title"
  myText = "Lorem ipsum dolor sit amet, consectetur
    adipisicing elit, sed do eiusmod tempor incididunt
    ut labore et dolore magna aliqua.  Ut enim ad minim
    veniam, quis nostrud exercitation ullamco laboris
    nisi ut aliquip ex ea commodo consequat."
}

\paper {
  bookTitleMarkup = \markup {
    \column {
      \fill-line { \fromproperty #'header:title }
      \null
      \justify-field #'header:myText
    }
  }
}

\markup {
  \null
}

Put markups args into a horizontal line.

The markups are spread to fill the entire line and separated by equal space. If there are no arguments, return an empty stencil.

The width of the horizontal line can be modified by overriding the line-width property.

\markup {
  \justify-line {
    Constant space between neighboring words
  }
}

Used properties:

• line-width (#f)
• word-space (0.6)
• text-direction (1)

Print string arg as lines aligned both at the left and the right.

Paragraphs are indicated by double newlines. Use \override #'(line-width . X) to set the line width; X is the number of staff spaces.

\markup {
  \override #'(line-width . 40)
  \justify-string "Lorem ipsum dolor sit amet, consectetur
      adipisicing elit, sed do eiusmod tempor incididunt ut
      labore et dolore magna aliqua.


      Ut enim ad minim veniam, quis nostrud exercitation
      ullamco laboris nisi ut aliquip ex ea commodo
      consequat.


      Excepteur sint occaecat cupidatat non proident, sunt
      in culpa qui officia deserunt mollit anim id est
      laborum"
}

The baseline of the output of \justify-string is the baseline of its first line.

Used properties:

• text-direction (1)
• word-space
• line-width
• baseline-skip

Align arg on its left edge.

\markup {
  \column {
    one
    \left-align two
    three
  }
}

Put args into a left-aligned column.

\markup {
  \left-column {
    one
    two
    three
  }
}

Used properties:

• baseline-skip

Put args into a horizontal line.

The property word-space determines the space between markups in args. For right-to-left scripts like Hebrew, text-direction should be set to -1.

\markup
  \override #'(word-space . 3)
  \column {
    \line { "A B" "C D" "E F" }
    \override #'(text-direction . -1)
    \line { "A B" "C D" "E F" }
  }

Used properties:

• text-direction (1)
• word-space

Lower arg by the distance amount.

A negative amount indicates raising; see also \raise.

The argument to \lower is the vertical displacement amount, measured in (global) staff spaces, which is independent of the markup’s current font size. If you need vertical movement that takes the font size into account, use \translate-scaled instead.

This function is normally used to move one element inside of a markup relative to the other elements. When using it on the whole markup, bear in mind that spacing mechanisms that place the markup itself on the page could cancel this shift. Consider using grob properties such as padding, Y-offset, or extra-offset, or spacing variables such as markup-system-spacing.

\markup {
  one
  \lower #3 two
  three
}

Take a list of markups args and combine them.

\markup {
  \fontsize #5
  \override #'(thickness . 2)
  \overlay {
    \draw-line #'(0 . 4)
    \arrow-head #Y #DOWN ##f
    \translate #'(0 . 4) \arrow-head #Y #UP ##f
  }
}

Add padding amount all around arg.

Identical to function \pad-markup.

\markup {
  \box {
    default
  }
  \hspace #2
  \box {
    \pad-around #0.5 {
      padded
    }
  }
}

Add padding amount all around arg.

Identical to function \pad-around.

\markup {
  \box {
    default
  }
  \hspace #2
  \box {
    \pad-markup #1 {
      padded
    }
  }
}

Make arg take at least x-ext, y-ext space.

\markup {
  \box {
    default
  }
  \hspace #4
  \box {
    \pad-to-box #'(0 . 10) #'(0 . 3) {
      padded
    }
  }
}

Add padding amount around arg in the X direction.

\markup {
  \box {
    default
  }
  \hspace #4
  \box {
    \pad-x #2 {
      padded
    }
  }
}

Put arg2 next to arg1 along axis to the dir side, without moving arg1.

\markup \column {
  text
  \put-adjacent #X #LEFT text *
  text
}

Raise arg by the distance amount.

A negative amount indicates lowering, see also \lower.

The argument to \raise is the vertical displacement amount, measured in (global) staff spaces, which is independent of the markup’s current font size. If you need vertical movement that takes the font size into account, use \translate-scaled instead.

This function is normally used to move one element inside of a markup relative to the other elements. When using it on the whole markup, bear in mind that spacing mechanisms that place the markup itself on the page could cancel this shift. Consider using grob properties such as padding, Y-offset, or extra-offset, or spacing variables such as markup-system-spacing.

\markup { C \small \bold \raise #1.0 9/7+ }

Align arg on its right edge.

\markup {
  \column {
    one
    \right-align two
    three
  }
}

Put args into a right-aligned column.

\markup {
  \right-column {
    one
    two
    three
  }
}

Used properties:

• baseline-skip

Rotate arg by ang degrees around its center.

\markup {
  default
  \hspace #2
  \rotate #45
  \line {
    rotated 45°
  }
}

Translate arg relative to its surroundings.

offset is a pair of numbers representing the displacement in the X and Y axes. See also \translate-scaled.

This function is normally used to move one element inside of a markup relative to the other elements. When using it on the whole markup, bear in mind that spacing mechanisms that place the markup itself on the page could cancel this shift. Consider using grob properties such as padding, X-offset, Y-offset or extra-offset, or spacing variables such as markup-system-spacing.

\markup {
  *
  \translate #'(2 . 3)
    \line { translated two spaces right, three up }
}

Translate arg by offset, scaling the offset by the font size.

This function is normally used to move one element inside of a markup relative to the other elements. When using it on the whole markup, bear in mind that spacing mechanisms that place the markup itself on the page could cancel this shift. Consider using grob properties such as padding, X-offset, Y-offset or extra-offset, or spacing variables such as markup-system-spacing.

See also \translate.

\markup {
  \fontsize #5 {
    * \translate #'(2 . 3) translate
    \hspace #2
    * \translate-scaled #'(2 . 3) translate-scaled
  }
}

Used properties:

• font-size (0)

Align arg to its Y center.

\markup {
  one
  \vcenter two
  three
}

Create an invisible object taking up vertical space of amount multiplied by 3.

\markup {
    \center-column {
    one
    \vspace #1
    two
    \vspace #3
    three
  }
}

amount can be also a negative value, which can be best visualized as if the current drawing point gets moved up.

\markup {
  \vspace #1
  \box \column { AAAA \vspace #0.4 }
  \box \column { AAAA \vspace #-0.4 }
  \box \column { \vspace #0.4 AAAA }
  \box \column { \vspace #-0.4 AAAA }
}

See also \abs-vspace.

Print args as left-aligned lines.

This function provides simple word-wrap. Use \override #'(line-width . X) to set the line width; X is the number of staff spaces.

\markup {
  \wordwrap {
    Lorem ipsum dolor sit amet, consectetur adipisicing elit,
    sed do eiusmod tempor incididunt ut labore et dolore
    magna aliqua.  Ut enim ad minim veniam, quis nostrud
    exercitation ullamco laboris nisi ut aliquip ex ea
    commodo consequat.
  }
}

The baseline of the output of \wordwrap is the baseline of its first line.

Used properties:

• text-direction (1)
• word-space
• line-width (#f)
• baseline-skip

Word-wrap the data that has been assigned to symbol.

\header {
  title = "My title"
  myText = "Lorem ipsum dolor sit amet, consectetur
    adipisicing elit, sed do eiusmod tempor incididunt ut
    labore et dolore magna aliqua.  Ut enim ad minim
    veniam, quis nostrud exercitation ullamco laboris nisi
    ut aliquip ex ea commodo consequat."
}

\paper {
  bookTitleMarkup = \markup {
    \column {
      \fill-line { \fromproperty #'header:title }
      \null
      \wordwrap-field #'header:myText
    }
  }
}

\markup {
  \null
}

Print string arg as left-aligned lines.

Paragraphs are indicated by double newlines. Use \override #'(line-width . X) to set the line width; X is the number of staff spaces.

\markup {
  \override #'(line-width . 40)
  \wordwrap-string "Lorem ipsum dolor sit amet,
      consectetur adipisicing elit, sed do eiusmod tempor
      incididunt ut labore et dolore magna aliqua.


      Ut enim ad minim veniam, quis nostrud exercitation
      ullamco laboris nisi ut aliquip ex ea commodo
      consequat.


      Excepteur sint occaecat cupidatat non proident,
      sunt in culpa qui officia deserunt mollit anim id
      est laborum"
}

The baseline of the output of \wordwrap-string is the baseline of its first line.

Used properties:

• text-direction (1)
• word-space
• line-width
• baseline-skip

Print an arrow head along axis in direction dir.

Fill the head if filled is set to #t.

\markup {
  \fontsize #5 {
    \general-align #Y #DOWN {
      \arrow-head #Y #UP ##t
      \arrow-head #Y #DOWN ##f
      \hspace #2
      \arrow-head #X #RIGHT ##f
      \arrow-head #X #LEFT ##f
    }
  }
}

Draw a beam with given width, slope, and thickness.

\markup {
  \beam #5 #1 #2
}

Draw vertical brackets around arg.

\markup {
  \bracket {
    \note {2.} #UP
  }
}

Draw a circle around arg.

Use properties thickness, circle-padding, and font-size to set the line thickness and padding around the markup.

\markup {
  \circle {
    Hi
  }
}

Used properties:

• circle-padding (0.2)
• font-size (0)
• thickness (1)

Draw a circle with given radius and thickness.

Fill the circle if filled is set to #t.

\markup {
  \draw-circle #2 #0.5 ##f
  \hspace #2
  \draw-circle #2 #0 ##t
}

Draw a dashed line along vector dest.

Properties on and off give the length of a dash and the space between two dashes, respectively; phase shortens the first dash by the given amount.

If the full-length property is set to #t (which is the default), the value of property off (and on under some boundary conditions) gets adjusted so that there is neither whitespace at the end of the line nor the last dash truncated.

\markup {
  \override #'((on . 0.3) (off . 0.5))
  \draw-dashed-line #'(6 . 2)

  \draw-dashed-line #'(6 . 2)

  \override #'(full-length . #f)
  \draw-dashed-line #'(6 . 2)

  \override #'(phase . 0.5)
  \draw-dashed-line #'(6 . 2)

  \override #'((full-length . #f) (phase . 0.5))
  \draw-dashed-line #'(6 . 2)
}

Used properties:

• full-length (#t)
• phase (0)
• off (1)
• on (1)
• thickness (1)

Draw a dotted line along vector dest.

Property off gives the space between two dots; its value gets adjusted so that the first and last dot exactly start and end the line, respectively. phase shifts all dots along the vector by the given amount.

\markup {
  \draw-dotted-line #'(5.1 . 2.3)
  \override #'((thickness . 2) (off . 0.2))
  \draw-dotted-line #'(5.1 . 2.3)
}

Used properties:

• phase (0)
• off (1)
• thickness (1)

Draw a horizontal line.

The property span-factor sets the length of the line as a multiple of the line-width property.

\markup {
  \column {
    \draw-hline
    \override #'(span-factor . 1/3)
    \draw-hline
  }
}

Used properties:

• span-factor (1)
• line-width
• thickness (1)

Draw a line along vector dest.

\markup {
  \draw-line #'(4 . 4)
  \override #'(thickness . 5)
  \draw-line #'(-3 . 0)
}

Used properties:

• thickness (1)

Draw a squiggled line along vector dest.

sq-length is the length of the first bow; this value gets always adjusted so that an integer number of squiggles is printed. If eq-end? is set to #t, the squiggled line ends with a bow in the same direction as the starting one.

The appearance of the squiggled line may be customized by overriding the thickness, angularity, height, and orientation properties.

\markup
  \column {
    \draw-squiggle-line #0.5 #'(6 . 0) ##t
    \override #'(orientation . -1)
    \draw-squiggle-line #0.5 #'(6 . 0) ##t
    \draw-squiggle-line #0.5 #'(6 . 0) ##f
    \override #'(height . 1)
    \draw-squiggle-line #0.5 #'(6 . 0) ##t
    \override #'(thickness . 5)
    \draw-squiggle-line #0.5 #'(6 . -2) ##t
    \override #'(angularity . 2)
    \draw-squiggle-line #0.5 #'(6 . 2) ##t
  }

Used properties:

• orientation (1)
• height (0.5)
• angularity (0)
• thickness (0.5)

Draw an ellipse around arg.

Use properties thickness, x-padding, y-padding, and font-size to set the line thickness and padding around the markup.

This is the same as function \oval but with different padding defaults.

\markup {
  \ellipse {
    Hi
  }
}

Used properties:

• y-padding (0.2)
• x-padding (0.2)
• font-size (0)
• thickness (1)

Inline an image file-name, scaled along axis to size.

See \image for details on this command; calling

\markup \epsfile axis size file-name

is the same as

\markup
  \override #'(background-color . #f)
  \image axis size file-name

Draw a box of dimensions xext and yext, with rounded corners given by blot.

For example,

\filled-box #'(-.3 . 1.8) #'(-.3 . 1.8) #0

creates a box extending horizontally from -0.3 to 1.8 and vertically from -0.3 up to 1.8, with corners formed from a circle of diameter 0 (i.e., sharp corners).

\markup {
  \filled-box #'(0 . 4) #'(0 . 4) #0
  \filled-box #'(0 . 2) #'(-4 . 2) #0.4
  \combine
    \filled-box #'(1 . 8) #'(0 . 7) #0.2
    \with-color #white
      \filled-box #'(3.6 . 5.6) #'(3.5 . 5.5) #0.7
}

Draw horizontal brackets around arg.

\markup {
  \hbracket {
    \line {
      one two three
    }
  }
}

Inline an image file-name, scaled along axis to size.

The image format is determined based on the extension of file-name, which should be .png for a PNG image, or .eps for an EPS image (.PNG and .EPS are allowed as well).

EPS files are only supported in the PostScript backend – for all output formats –, and in the Cairo backend – when creating PostScript or EPS output.

If the image has transparency, it will appear over a colored background with the color specified by the background-color property, which defaults to "white".

To disable the colored background, set background-color to #f. For EPS images, this always works (where EPS images work in the first place). On the other hand, for PNG images, it works in the Cairo backend (which can output all supported formats), as well as in the SVG backend, but not in the PostScript backend, which is the default. See Advanced command-line options for LilyPond for how to activate the Cairo backend.

Use \withRelativeDir as a prefix to file-name if the file should be found relative to the input file.

Used properties:

• background-color ("white")

Draw an oval around arg.

Use properties thickness, x-padding, y-padding, and font-size to set the line thickness and padding around the markup.

This is the same as function \ellipse but with different padding defaults.

\markup {
  \oval {
    Hi
  }
}

Used properties:

• y-padding (0.75)
• x-padding (0.75)
• font-size (0)
• thickness (1)

Draw parentheses around arg.

This is useful for parenthesizing a column containing several lines of text.

\markup {
  \parenthesize
  \column {
    foo
    bar
  }
  \override #'(angularity . 2)
  \parenthesize
  \column {
    bah
    baz
  }
}

Used properties:

• width (0.25)
• line-thickness (0.1)
• thickness (1)
• size (1)
• padding
• angularity (0)

Draw a path with line thickness according to the directions given in commands.

commands is a list of lists where the car of each sublist is a drawing command and the cdr comprises the associated arguments for each command.

There are seven commands available to use in commands: moveto, rmoveto, lineto, rlineto, curveto, rcurveto, and closepath. Note that the commands that begin with ‘r’ are the relative variants of the other three commands. You may also use the standard SVG single-letter equivalents: moveto = M, lineto = L, curveto = C, closepath = Z. The relative commands are written lowercase: rmoveto = r, rlineto = l, rcurveto = c.

The commands moveto, rmoveto, lineto, and rlineto take 2 arguments, namely the X and Y coordinates of the destination point.

The commands curveto and rcurveto create cubic Bézier curves, and take 6 arguments; the first two are the X and Y coordinates for the first control point, the second two are the X and Y coordinates for the second control point, and the last two are the X and Y coordinates for the destination point.

The closepath command takes zero arguments and closes the current subpath in the active path.

Line-cap styles and line-join styles may be customized by overriding the line-cap-style and line-join-style properties, respectively. Available line-cap styles are butt, round, and square. Available line-join styles are miter, round, and bevel.

The property filled specifies whether or not the path is filled with color.

samplePath =
  #'((lineto -1 1)
     (lineto 1 1)
     (lineto 1 -1)
     (curveto -5 -5 -5 5 -1 0)
     (closepath))

\markup \scale #'(2 . 2) {
  \path #0.25 #samplePath

  \override #'(line-join-style . miter)
  \path #0.25 #samplePath

  \override #'(filled . #t)
  \path #0.25 #samplePath
}

Used properties:

• filled (#f)
• line-join-style (round)
• line-cap-style (round)

A polygon delimited by the list of points.

Property extroversion defines how the shape of the polygon is adapted to its thickness: if it is 0, the polygon is traced as-is. If it is -1, the outer side of the line is just on the given points. If set to 1, the line has its inner side on the points. The thickness property controls the thickness of the line; for filled polygons, this means the diameter of the blot.

regularPentagon =
  #'((1 . 0) (0.31 . 0.95) (-0.81 . 0.59)
     (-0.81 . -0.59) (0.31 . -0.95))

\markup \scale #'(2 . 2) {
  \polygon #'((-1 . -1) (0 . -3) (2 . 2) (1 . 2))
  \override #'(filled . #f)
    \override #'(thickness . 2)
      \combine
        \with-color #(universal-color 'blue)
          \polygon #regularPentagon
        \with-color #(universal-color 'vermillion)
          \override #'(extroversion . 1)
            \polygon #regularPentagon
}

Used properties:

• thickness (1)
• filled (#t)
• extroversion (0)

Insert str directly into the output as a PostScript command string.

This command is meant as a last resort. Almost all needs are better fulfilled by other markup commands (see, for example, \path and \draw-line). If you do use this command, keep the following points in mind:

• \postscript does not work in SVG output.
• Only a subset of the PostScript language is supported during the conversion from PostScript to PDF.
• There are no stability guarantees on the details of how LilyPond produces its own output (i.e., the context into which the PostScript code is inserted). They may change substantially across versions.
• LilyPond cannot understand the shape of the drawing, leading to suboptimal spacing. Usually, it is necessary to explicitly set up dimensions with a command like \with-dimensions.
• Depending on how you install LilyPond, the version of the PostScript interpreter (Ghostscript) can vary, and some of its features may be disabled.

str is processed with the following constraints.

• The string is embedded into the (intermediate) output file with the PostScript commands

  gsave currentpoint translate 0.1 setlinewidth
  

  before and

  grestore
  

  after it.

• After these preceding commands (i.e., currentpoint translate) the origin of the current transformation is the reference point of \postscript. Scale and rotation of the current transformation reflect the global staff line distance and (if applied) other transformation markup commands (e.g., \scale and \rotate) encapsulating the \postscript command.
• The current point is set to the coordinate (0, 0).
• If an unwanted line appears at the beginning of your PostScript code, you are probably missing a call to newpath.

ringsps = "
  0.15 setlinewidth
  0.9 0.6 moveto
  0.4 0.6 0.5 0 361 arc
  stroke
  1.0 0.6 0.5 0 361 arc
  stroke
  "

rings = \markup {
  \with-dimensions #'(-0.2 . 1.6) #'(0 . 1.2)
  \postscript #ringsps
}

\relative c'' {
  c2^\rings
  a2_\rings
}

Draw a box with rounded corners around arg.

This function looks at properties thickness, box-padding, and font-size to determine the line thickness and padding around the arg. The corner-radius property defines the radius of the round corners (default value is 1).

c4^\markup {
  \rounded-box {
    Overtura
  }
}
c,8. c16 c4 r

Note that the box does not horizontally displace its argument. Use markup commands like \left-align or \table to make LilyPond realign it.

\markup {
  \override #'(box-padding . 1.5)
  \column {
    "text"
    \rounded-box "text"
    \left-align \rounded-box "text"
  }
}

Used properties:

• box-padding (0.5)
• font-size (0)
• corner-radius (1)
• thickness (1)

Scale arg.

factor-pair is a pair of numbers representing the scaling factor of the X and Y axes. Negative values may be used to produce mirror images.

\markup {
  \line {
    \scale #'(2 . 1)
    stretched
    \scale #'(1 . -1)
    mirrored
  }
}

Draw a triangle.

Fill the triangle if filled is set to #t.

The appearance can be controlled with properties extroversion, font-size, and thickness.

\markup {
  \triangle ##t
  \triangle ##f
  \override #'(font-size . 5)
  \override #'(thickness . 5) {
    \override #'(extroversion . 1)
    \triangle ##f
    \override #'(extroversion . -1)
    \triangle ##f
  }
}

Used properties:

• thickness (1)
• font-size (0)
• extroversion (0)

Add a link to URL url around arg.

This only works in the PDF backend.¹⁴

\markup {
  \with-url "https://lilypond.org/" {
    LilyPond ... \italic {
      music notation for everyone
    }
  }
}

Select an accidental glyph for alteration, given as a rational number.

Use \text-accidental instead if you need glyph representation forms that fit and align well with text.

\markup {
  text
  \tiny { \accidental #1/2 \accidental #-1/2 }
  text
  \tiny { \text-accidental #1/2 \text-accidental #-1/2 }
  text
}

Used properties:

• alteration-glyph-name-alist

Print a bar line in markup.

The allowed characters for input string strg are ‘;|.:!S[]{}’, having the same meaning as with the \bar command. The additional characters ‘{’ and ‘}’ denote left and right braces, respectively.

The output is vertically centered.

Changes of font-size are respected.

The default of height is 4 staff-space units. Apart from the bracket tips of a bracket bar line and the segno bar line all other bar lines are scaled with height. We don’t scale bracket tips and segno to meet the behaviour of SystemStartBracket and the segno barline.

\bar-line is further customizable by overriding dot-count and dash-count for dotted and dashed bar lines. The values for hair-thickness, kern and thick-thickness are customizable as well; defaults are the same as the values of the corresponding BarLine grob properties.

\markup {
   \override #'(word-space . 2)
   \column {
      \line {
        Examples
        \fontsize #-5 \translate-scaled #'(0 . 2) {
          \bar-line ":|.|:"
          \bar-line ";!S!;"
          \bar-line "]{|}["
        }
      }
      \line {
        Examples
        \fontsize #0 \translate-scaled #'(0 . 2) {
          \bar-line ":|.|:"
          \bar-line ";!S!;"
          \bar-line "]{|}["
        }
      }
      \line {
        Examples
        \fontsize #5 \translate-scaled #'(0 . 2) {
          \bar-line ":|.|:"
          \bar-line ";!S!;"
          \bar-line "]{|}["
        }
      }
   }
}

Used properties:

• thick-thickness (6.0)
• kern (3.0)
• hair-thickness (1.9)
• dash-count (5)
• dot-count (4)
• height (4)
• font-size (0)

Draw a coda sign.

\markup {
  \coda
}

Draw a numeric time signature based on time-sig.

time-sig can be a single number, a pair of numbers, a simple list, or a list of lists, as the following example demonstrates.

\markuplist {
  \override #'(baseline-skip . 4.5)
  \override #'(padding . 4.5)
  \table #'(-1 -1) {
    "Single number"  \compound-meter #3
    "Conventional"   \line {
                       \compound-meter #'(4 . 4) or
                       \compound-meter #'(4 4)
                     }
    "Subdivided"     \compound-meter #'(2 3 5 8)
    "Alternating"    \line {
                       \compound-meter #'((2) (3)) or
                       \compound-meter #'((2 3 8) (3 4))
                     }
  }
}

Setting the denominator-style property to note prints denominators as a note and dots when exact representation is possible. Example:

\markup {
  \override #'(denominator-style . note)
  \line {
    \compound-meter #'(2 2) or
    \compound-meter #'(4 1/2) or
    \compound-meter #'((2 8/3) (3 4)) but not
    \compound-meter #'(8 20)
  }
}

The nested-fraction-mixed property controls whether fractional parts are printed as mixed numbers or as common fractions. Example:

\markup {
  \override #'(nested-fraction-mixed . #f)
  \compound-meter #'(5/2 4) or
  \override #'(nested-fraction-mixed . #t)
  \compound-meter #'(5/2 4)
}

The nested-fraction-orientation property controls how nested fractions are arranged. Supported values are horizontal and vertical. Example:

\markup {
  \override #'(nested-fraction-orientation . horizontal)
  \compound-meter #'(5/2 4) or
  \override #'(nested-fraction-orientation . vertical)
  \compound-meter #'(5/2 4)
}

The nested-fraction-relative-font-size property controls the size of the numerals in nested fractions. Recommended values are -5.5 and 0. Using large numerals may take precedence over related properties. Example:

\markup {
  \override #'(nested-fraction-relative-font-size . -5.5)
  \compound-meter #'(5/2 4) or
  \override #'(nested-fraction-relative-font-size . 0)
  \compound-meter #'(5/2 4)
}

Used properties:

• note-staff-position (-2)
• note-head-style (())
• note-flag-style (())
• note-dots-direction (0)
• nested-fraction-relative-font-size (())
• nested-fraction-orientation (default)
• nested-fraction-mixed (#t)
• font-size (0)
• denominator-style (default)

Draw a clef in sans-serif style for a tablature with num-strings lines spaced by staff-space.

This markup command is used to implement \clef moderntab within a TabStaff context.

\markup {
  \customTabClef #4 #1
}

Draw a double flat symbol.

\markup {
  \doubleflat
}

Draw a double sharp symbol.

\markup {
  \doublesharp
}

Create a fermata glyph.

If property direction is DOWN, use an inverted glyph.

Note that within music, one would normally use the \fermata articulation instead of a markup.

{ c''1^\markup \fermata d''1_\markup \fermata }

\markup { \fermata \override #`(direction . ,DOWN) \fermata }

Used properties:

• direction (1)

Draw a flat symbol.

\markup {
  \flat
}

Return a multi-measure rest symbol for length measures.

If the number of measures is greater than the number given by expand-limit a thick horizontal line is printed. For every multi-measure rest lasting more than one measure a number is printed on top. However, if property multi-measure-rest-number is set to #t, this number gets suppressed.

\markup {
  Multi-measure rests may look like
  \multi-measure-rest-by-number #12
  or
  \override #'(multi-measure-rest-number . #f)
    \multi-measure-rest-by-number #7
  (church rests)
}

Used properties:

• multi-measure-rest-number (#t)
• width (8)
• expand-limit (10)
• hair-thickness (2.0)
• thick-thickness (6.6)
• word-space
• style (())
• font-size (0)

Print music symbol glyph-name.

See The Emmentaler font for a complete listing of the possible glyph names.

\markup {
  \musicglyph "f"
  \musicglyph "rests.2"
  \musicglyph "clefs.G_change"
}

Draw a natural symbol.

\markup {
  \natural
}

Draw a note of given duration with a stem pointing into direction dir.

duration gives the note head type and augmentation dots; dir controls both the direction and length of the stem.

See also function \note-by-number.

\markup {
  \note {4..} #UP
  \hspace #2
  \override #'(style . cross)
  \note {4..} #0.75
  \hspace #2
  \note {\breve} #0
}

Used properties:

• style (())
• dots-direction (0)
• flag-style (())
• font-size (0)

Draw a note of length log, with dot-count dots and a stem pointing into direction dir.

By using fractional values for dir, longer or shorter stems can be obtained.

Ancient note-head styles (via the style property, see Note head styles) get mensural-style flags by default; use flag-style to override this. Supported flag styles are default, old-straight-flag, modern-straight-flag, flat-flag, stacked, mensural, and neomensural. The last flag style is the same as mensural and provided for convenience.

\markup {
  \note-by-number #3 #0 #DOWN
  \hspace #2
  \note-by-number #1 #2 #0.8
  \hspace #2
  \override #'(style . petrucci)
  \note-by-number #3 #0 #UP
  \hspace #2
  \override #'(flag-style . modern-straight-flag)
  \note-by-number #4 #0 #DOWN
}

Used properties:

• style (())
• dots-direction (0)
• flag-style (())
• font-size (0)

Return a rest symbol with length duration.

If the multi-measure-rest property is set to #t, a multi-measure rest symbol may be returned. In this case the duration needs to be entered as { 1*N } to get a multi-measure rest for N bars. Actually, only the scaling factor (i.e., the number after ‘*’) determines the length; the basic duration is disregarded.

See also functions \rest-by-number and \multi-measure-rest-by-number for more information on the used properties.

\markup {
  Rests:
  \hspace #2
  \rest { 4.. }
  \hspace #2
  \rest { \breve }
  \hspace #2
  Multi-measure rests:
  \override #'(multi-measure-rest . #t)
  {
    \hspace #2
    \rest { 1*7 }
    \hspace #2
    \rest { 1*12 }
  }
}

Used properties:

• multi-measure-rest-number (#t)
• width (8)
• expand-limit (10)
• hair-thickness (2.0)
• thick-thickness (6.6)
• word-space
• style (())
• font-size (0)
• style (())
• ledgers ((-1 0 1))
• font-size (0)

Draw a rest of length log, with dot-count dots.

For duration logs that appear in the ledgers property, rest symbols with ledger lines are selected.

\markup {
  \rest-by-number #3 #2
  \hspace #2
  \rest-by-number #0 #1
  \hspace #2
  \rest-by-number #-1 #0
  \hspace #2
  \override #'(ledgers . ())
  \rest-by-number #-1 #0
}