Post a message

For several months, I have been feeling unhappy, uncomfortable, frustrated. Then a couple of weeks ago, I finally realized what felt wrong, deeply down in my heart: I wasn’t using the KDE4 desktop environment anymore! With the recent release of KDE4.4, I decided to get rid of all things GTK-ish alltogether (bye-bye LXDE, XFCE, GNOME, IceWM, Fluxbox...) and found myself with a slick, responsive, glamourous desktop environment again: then I realized what I had been missing in my life.

Feeling lighthearted again, I decided that the time had come for something I hd been meaning to do for a long time already: give Frescobaldi a proper review!

• • History

Frescobaldi is a LilyPond-oriented text editor for KDE4. It has originally been intended as a plugin for the Kate editor, for KDE3 then for KDE4 when it became widely used. Frescobaldi is now developed as an independent program, albeit deeply integrated into the KDE desktop environment. It has its own website, in English and Dutch; Frescobaldi itself is well localized, and supports no less than ten languages!

• • Author

Much like LilyPondTool, the other easy-LilyPond-editing environment of choice, Frescobaldi is essentially a one-man work. Wilbert Berendsen is a well-known contributor of our project, and is responsible for the Dutch LilyPond community. Wilbert is also an organist, teacher, editor, composer, conductor, performer (if I understand well, he’ll be giving a concert in a few days). His website is quite interesting, and contains some scores and recordings; I particularly like this short piece by Louis Vierne.

• • Development

Unlike LilyPondTool, where many features and graphical widgets had to be implemented (almost) from scratch, Frescobaldi uses the KDE libraries, glued together in Python using PyKDE. As a result, it has a very nice, professional look (did I mention how fond I am of KDE4 ?).

This is particularly visible when comparing, for instance, Frescobaldi:

... with the Kate editor:

As you can see, the text-editing part looks basically the same.

• • Installation

From what I can tell, Frescobaldi is relatively well-known in the KDE community (with an 85% rating!); as a result it is available in most major distributions and you may not have to compile it from source (which is, by the way, not a particularly pleasant experience for any KDE app, as it requires installing hundreds of megabytes of -devel packages, plus cmake and the like).

Interestingly, the Frescobaldi packagers for my distribution (Funda Wang & Frederik Himpe) didn’t specify LilyPond as a dependency, and that was a smart move: this leaves me free to download and install whatever LilyPond version I want, be it the stable, development branch, or even a home-compiled git source.

A couple of clicks is all it took for me to find myself with Frescobaldi installed, and listed in my menu under "Sound&Video" (go figure). The very last version (1.0.2) had been released just a few days ago, and yet my distribution’s repository had already been updated.

• • Interface

By default, Frescobaldi opens with a very minimal text area. When you’re used to KDE, your first reaction will probably be to look at the vertical tabs on the left and right borders, that actually are retractable panels.

The left panel gives access to a number of articulation marks:

On the right, you may notice a "LilyPond" button. Clicking on it immediately opens two things : a terminal emulator at the bottom, and a PDF-preview panel on the right. KDE’s PDF engine is used here (like in the Okular reader), whereas LilyPondTool has to rely on the JPedal library, that Bertalan had to debug on his own. One minor downside though: there aren’t any buttons/icons/toolbars in Frescobaldi’s PDF-preview panel (let alone LilyPondTool-exclusive features such as PDF ruler or reverse point-and-click), so you better have a scrollwheel if you want to zoom it...

Unlike in jEdit/LilyPondTool, you do not have to save your source code first (and carefully give it a .ly extension). Frescobaldi is obviously meant to work "out of the box", and does indeed a great job at it: similarly, I did not have to manually specify the full path to the LilyPond binary.

At the bottom of the window, a few tabs (that I missed at first) allow you to open a terminal (just like in Dolphin,, KDE’s file manager), consult the log (if any), and... record music using Rumor!

Unfortunately, I did not have the necessary tools to properly test this feature. But its interface sure looks attractive.

• • Documentation

The right panel contains another tab: that’s the online documentation browser. Where LilyPondTool embeds its own copy of the docs (with a very useful documentation browser that includes a search function), Frescobaldi, once again, takes advantage of the KDE libraries by embedding a web browser (the same engine as Konqueror).

This might come as a disadvantage though, as you will need an active connection to be able to browse the docs. On the plus side, this ensures that you will always have access to the latest docs build. But then again, there’s still room for improvement: the browser points to the stable Documentation by default (which might be fine), but surprisingly enough, users are not offered with an option to change the URL (for example to use the latest development documentation, or an offline doc-build instead).

Another annoyance, that Frescobaldi is certainly not to blame for, is that the language detection didn’t work, so foreign users may have to use the documentation and website in English by default.

Frescobaldi itself comes with its own offline handbook, like LilyPondTool (though Frescobaldi’s may be a little more newbie-oriented).

• • Text editing

As we’ve seen, Frescobaldi relies on KDE’s Katepart component, and therefore has a smooth and pleasant look-and-feel when it comes to source-code editing. Blocks folding/nesting is beautifully indicated with a color gradient:

Unlike in LilyPondTool, not only { ... } blocks are indented, but << ... >> blocks as well:

Context-sensitive autocompletion and highlighting is well supported: here are a few examples...

UPDATE — In LilyPondTool the autompletion is actually more fine-grained, since it will only show the possible properties in an override. However, syntax-highlighting looks better in Frescobaldi for now.

Scheme syntax-highlighting is simpler, but better-handled than in LilyPondTool (where, for instance, Scheme keywords aren’t highlighted only in Scheme blocks). Still, I somehow prefer LilyPondTool’s indenting and folding when it comes to Scheme code (but it’s probably a matter of habit — and taste: Kate’s brownish coloring of Scheme isn’t very pleasant).

Like LilyPondTool, Frescobaldi features customizable code expansions:

• • Wizards

Frescobaldi includes a Score Creation Wizard, that very much resembles LilyPondTool’s... but with a twist.

The first window looks exactly like LilyPondTool’s... but if you look closely you’ll notice that the preview "image" (that is precisely not an image, in Frescobaldi’s case) is better centered... and even localized! How nice.

The usual list of instruments (aka "let’s pretend we’re Sibelius for a while"). Where LilyPondTool sports a three-pane interface, Fresco only uses two (with submenus), and adds specific options on the left.

Here’s the twist: once you have chosen your options, you are presented with a preview of your settings! I have to confess that at this point, my jaw dropped and the only thing I could say for a while was :

woooooooow...

• • Gizmos

We already mentioned the "Insertion" panel that allows to quickly add articulations to your music. This certainly looks nice, but one could argue that having to use the mouse to add articulations is hardly quicker than using the keyboard. Most users would probably prefer to assign keyboard shortcuts to these functions. LilyPondTool has also such buttons, but in a drop-down submenus, which is less convenient but preferable from a screen-real-estate point of view.

In this "quick insertion" panel, I was surprised not to find a way to quickly add slurs, phrasing slurs, or manual beams. This seems way more useful than adding \rheel or \lheel indications — but perhaps it’s because the author is an organist

Finally, let’s note that this feature is not context-sensitive. It is smart enough to leave rests alone and deal with compound durations such as cis2*5/8, but doesn’t identify comments or \lyricmode blocks, nor does it take the notenames language into account.

There are a couple of nice and convenient unique tools. For instance, in the "Pitch" submenu, an option allows you to change the language used throughout your source code. Nothing extraordinary, but it’s welcome nevertheless.

Another one, possibly my favorite: a well thought-out wizard allows you to easily create blank staff paper!

Once again, there’s even a preview:

• • Conclusion

Such features make Frescobaldi not just a nice toy to play with, but a considerate editor that has obviously been designed by someone who actually writes music. Wilbert has cleverly used all the power and flexibility of KDE4, and that amounts to a very slick software with an irresistible "wow" effect. I did have seen some screenshots on the website, I had even contributed to Frescobaldi translation, and as someone who’s generally used to testing bleeding-edge software, I really wasn’t expecting to be impressed. Yet here I am.

One can but regret that this beautiful software actually targets a very narrow range of users: people who run KDE4 (that’s between a third and a half of all GNU/Linux users). For these users, Frescobaldi is a treat already; for example, I could perfectly imagine a classroom full of Free-Software-driven laptops running Frescobaldi. Unfortunately it’s a far cry from supporting people who need such software most: that is, Microsoft Windows hostages users.

KDE4 is known to be theoretically portable to this system, so one could imagine building Frescobaldi for Windows. Unfortunately things are a bit complex: from QT4 that run natively without a glitch on Windows (SMPlayer), to KDE4-tied apps that require hundreds of megabytes of dependencies (Amarok), I’m afraid we’re not there yet.

One last word about Frescobaldi compared to jEdit/LilyPondTool. As you may have noted, I’ve been familiar for a long time with this later environment. Does this review of Frescobaldi make me want to switch? Well, although I do have considered it at some point, I think I am going to stay faithful to my ugly/bloated/Java editor of choice.

Not because of the numerous features it has, which Frescobaldi does not (reverse point-and-click, real-time syntax parsing, virtual piano, MIDI player, offline docs, PDF ruler, etc.) — I have hardly ever used these features, and do not see the need for them. Not because it’s multi-platform: from now on I won’t bother running anything else than KDE4 GNU/Linux. Not even because I designed its new icons

But more for a sentimental reason: LilyPondTool and I go way back, and I have seen its progress, I have seen Java become Free, I have seen Bertalan add new features one after another, fixing bugs, in a much less developer-friendly context than what KDE4 provides. I have taught generations of students how to install and use it, I’ve even made video tutorials about it.

Just like the old laptop I’m using to write this review: it’s ugly, tired, I’ve changed almost every parts of it myself over the years. But while I can appreciate a beautiful and powerful computer whenever I see one, it’s the story behind it that counts. That being said, I hope this review will give some readers the curiosity to give Frescobaldi a try, and, who knows, perhaps they’ll make their own story with it — and if you do, please do tell us: we all love stories!

— Valentin.