Frescobaldi: a two-way editor for LilyPond sheet music

What Frescobaldi is

Frescobaldi is a LilyPond sheet music text editor that aims to be powerful, yet lightweight and easy to use, and it is free software under the General Public License. The main author is Wilbert Berendsen, and the project homepage is frescobaldi.org.

The name comes from Girolamo Frescobaldi, 1583 to 1643, an Italian composer of keyboard music from the late Renaissance and early Baroque period, which is a reasonable reference for a tool that treats notation as text.

The important thing to understand is what kind of program this is. Frescobaldi does not draw a score. It edits a .ly file, which is LilyPond's text format, and it invokes LilyPond to produce the PDF. It is written in Python and uses PyQt for its user interface, so it is a desktop application, not a plugin and not a web service.

The feature list is longer than that of most editors, and it divides into three groups. There is the text editor part, with syntax highlighting, automatic completion, auto-indent and code formatting. There is the music part, with the music view and its advanced two-way point and click, a MIDI player to proof-listen the MIDI files LilyPond generates, MIDI capturing to enter music, and a powerful Score Wizard to set up a score quickly. And there is the tooling part, with a Snippet Manager to store and apply text snippets, templates or scripts, the ability to use multiple versions of LilyPond with the correct one selected automatically, a built-in LilyPond documentation browser and built-in help, a configurable document outline for navigating large scores, and smart layout control functions such as colouring specific objects in the PDF.

There is also import and export. ABC, Midi and MusicXML can be imported using the tools LilyPond provides, and export to MusicXML is described as experimental.

The workflow, and the loop that makes it worth using

The README describes the basic workflow as a sequence, and reading it tells you what the editor is actually for.

You start Frescobaldi. You open a .ly file, or create one with File, New Document, or from a template with File, New, Score Wizard, and fill in some music. You press Ctrl+M to run LilyPond. If the LilyPond output shows errors, you press Ctrl+E to jump to the first error. If you see other mistakes in the music, you click the notes to move the text cursor there. You fix the errors or mistakes in the text. You press Ctrl+M again to update the music view. And when a piece is finished, you press Ctrl+Shift+P once to run LilyPond with point and click turned off, which results in a much smaller PDF file.

Four of those steps are about the relationship between the picture and the text, and that is the whole point of the tool.

The point and click view is two-way. In the rendered score, each note is a clickable region, and clicking it moves the text cursor to the corresponding place in the source. The reverse direction is the error jump, which turns a compiler error into a cursor position. Together they mean that a score is not a separate artefact you have to keep in sync with the text, it is a view of the text.

The last step is the one that shows the tool's practicality. Point and click embeds information in the PDF to make the clicks work, and that makes the file much larger. Running LilyPond once more with point and click off produces the small PDF you would actually print or send, so the workflow ends with a deliberate switch rather than a separate export command.

For a large score, the outline view for navigating documents and the Quick Insert panel for adding spanners, dynamics and articulation are the other two pieces that matter, since hand-writing LilyPond markup for a crescendo is exactly the kind of thing nobody wants to type.

The music functions that are really a LilyPond convenience layer

The music functions section lists the operations the editor performs on the source for you, and it is worth reading as a description of what a LilyPond user does constantly.

You can transpose music. You can change music from relative to absolute and vice versa, which is the operation that decides whether a passage is written as a scale degree or as a note name, and which LilyPond users change for reasons of readability rather than of pitch. You can change the language used for note names, which matters for the localised note spellings LilyPond supports. You can change the rhythm, doubling, halving, adding or removing dots, copying and pasting. And you can hyphenate lyrics using word-processor hyphenation dictionaries, which is a genuine convenience, since manual lyric hyphenation in LilyPond is tedious and easy to get subtly wrong.

Then there are the bulk edits. Spanners, dynamics and articulation can be added through the Quick Insert panel, and LilyPond syntax can be updated using convert-ly with a display of the differences, which is the migration tool that matters when a new LilyPond release changes the syntax of old files. The display of differences is what makes that safe, since convert-ly rewrites your score and you need to see what it changed.

Together these functions cover the two kinds of work that dominate LilyPond editing: changing the music, and keeping the source in step with the tool version. Both are the kind of thing that is tedious in a text editor and tedious in a graphical one for different reasons, and having them in one place is the value.

The interface itself is described as modern, with configurable colours, fonts and keyboard shortcuts, and the translation list is a sign of a project with real international use: Dutch, English, French, German, Italian, Swedish, Czech, Russian, Spanish, Galician, Turkish, Polish, Brazilian, Ukrainian, Traditional Chinese, Simplified Chinese, Japanese and Korean.

What the packaging says about the dependencies

The pyproject.toml is small and tells you what Frescobaldi needs and how it is built.

The build backend is hatchling, the project requires Python 3.10 or newer, and the dependencies are:

dependencies = [
  "pyqt6>=6.6",
  "pyqt6-webengine",
  "python-ly >= 0.9.5",
  "qpageview>=1.0.1"
]

Four dependencies, and each one says something. PyQt6 and pyqt6-webengine are the interface, and the WebEngine component is the embedded browser that renders the PDF preview, so the music view is a web view showing the output rather than a custom renderer. python-ly is the LilyPond library, which is how the editor can read a .ly file properly, understand its structure and apply the music functions. qpageview is a page view widget, again for the preview.

The manifest also carries a comment that is worth repeating to anyone tempted to add a dependency: do not add pygame dependency. The MIDI player and MIDI capturing features are built on a system MIDI backend rather than on a cross platform synthesiser library, and keeping that out of the dependency list is a deliberate choice about what Frescobaldi pulls into a user's environment.

The version is dynamic, and the mechanism is unusual enough to be worth noting. The hatch version section reads the version out of frescobaldi/appinfo.py with a pattern, and the console script is frescobaldi = frescobaldi.__main__:main. The project is also packaged for mobile with Briefcase, under the bundle identifier org.frescobaldi, and the config there carries a hardcoded version of 4.0.7 with a comment explaining that Briefcase does not support dynamic versions yet, with a link to the issue.

The build configuration also lists artefacts that have to be included in the source distribution, the compiled translation files and the Linux desktop entry and metainfo files, which is a small illustration of the difference between a pip package and a desktop application.

Release engineering, the Linux packaging and the update check

The repository is a full application repository rather than a library, and the top level listing shows the parts of that.

There is a frescobaldi directory for the application code, an i18n directory for translations, a linux directory holding the desktop entry and the AppStream metainfo file, a frescobaldi.1 manual page, a pyproject.toml, a tox.ini for test environments, a justfile, and INSTALL.md for installation instructions, plus PACKAGES.md, TRANSLATIONS.md, THANKS, TODO, CONTRIBUTING.md and a CHANGELOG.md.

The justfile is a small but telling file. It defines a check-updates target that loops over a list of packages, which includes python-ly, qpageview, pygame-ce, PyQt6 and its components, and for each one prints the available versions from PyPI with pip index versions. The comment above the target says it should be run before a new release to check whether newer versions are available.

That is a release engineer writing down a task in a form that can be run by hand, with a list of the exact packages that matter, and it tells you something about how the project handles its dependency set across platforms. A PyQt6 application that also has to run on Linux distributions with different Qt packaging has to watch several package names at once, and a hardcoded list is the pragmatic way to do that.

The Linux directory is the other platform-specific corner. The desktop file and the metainfo XML are what a Linux distribution needs in order to list the application in its menu, and they are generated or maintained as part of the package, which is why the pyproject explicitly lists them as artefacts that must survive into the source distribution.

The wiki holds the installation instructions for the program and for MIDI support, and the README says so, which is the right place for it since the steps vary by platform and by what is already installed on the machine.

Licence, releases and the judgement to make

The licence is GPL-2.0-or-later, recorded in the pyproject metadata with the LICENSE file listed as the licence file, and the README describes the project as free software under the General Public License. This describes the published terms rather than legal advice.

The release history is steady and recent. Version 4.0.7 was published on 2026-05-30, 4.0.6 on 2026-04-28 and 4.0.5 on 2026-02-11, and the last push to the repository was on 2026-10-19. The repository is not archived, and the 4.x line is the current one.

The judgement comes down to a question about LilyPond itself. Frescobaldi is a specialist tool for a specialist format, and it is a very good one. The point and click view, the error jump, the Quick Insert panel and the convert-ly integration are the features that make writing LilyPond by hand practical, and the fact that the editor selects the right LilyPond version automatically means a user with several installed can work across them without thinking about it.

The limitations follow from the same specialism. It does nothing for anyone who does not already write .ly files, and its MusicXML export is described as experimental, so it is not a route to a format other tools read. The preview needs a web engine, so the installation is not as small as a pure Python application would be, and LilyPond itself has to be installed separately, which the README is careful to point at rather than to assume.

For a user who already has LilyPond, the honest comparison is with a plain text editor plus the LilyPond manual, and the gap is the two-way view. That is what makes the program worth installing rather than merely possible.

Editorial conclusion

Adopt Frescobaldi if you write LilyPond, especially for large scores, because the two-way point and click view, the error jump and the snippet manager remove the three things that make LilyPond unpleasant to work with by hand. It is the wrong tool if you do not already use LilyPond, and it is not a graphical notation application, since it edits text rather than a score. Before adopting, check which LilyPond versions you have installed, because the editor selects the right one automatically and the version matters, and read INSTALL.md rather than the README, since the README points there for the actual installation and MIDI requirements.

Frequently asked questions

Official sources

1. frescobaldi/frescobaldi on GitHub
2. License: GPL-2.0
3. Project website
4. README
5. Releases