Sratom 0.4.0

sratom 0.4.0 has been released. Sratom is a library for serialising LV2 atoms to/from RDF, particularly the Turtle syntax. For more information, see


  • Correctly read objects with several rdf:type properties
  • Support writing Object Atoms as top level descriptions if subject and predicate are not given.
  • Fix various hyper-strict warnings
  • Upgrade to waf 1.7.2

Sord 0.10.0

sord 0.10.0 has been released. Sord is a lightweight C library for storing RDF statements in memory. For more information, see


  • Add error callback to world for custom error reporting
  • Performance and space (per node) improvements
  • SSE4.2 accelerated hashing for node interning, where available
  • Make all 'zix' symbols private to avoid symbol clashes in static builds
  • Remove problematic "Loaded n statements" output from serdi
  • Strip down API documentation to a single clean page
  • Fix various hyper-strict warnings
  • Do not require a C++ compiler to build
  • Add option to build utilities as static binaries
  • Upgrade to waf 1.7.2
  • sordmm.hpp: Add indices and graphs parameters to Model constructor
  • sordmm.hpp: Remove overzealous URI scheme assertion
  • sordmm.hpp: Correctly handle Sord::Node self-assignment

Serd 0.18.0

serd 0.18.0 has been released. Serd is a lightweight C library for RDF syntax which supports reading and writing Turtle and NTriples. For more information, see


  • Support digits at start of local names as per new Turtle grammar
  • Add incremental read interface suitable for reading from infinite streams
  • Add -e option to serdi to use incremental reading
  • Add error callback to reader and writer for custom error reporting
  • Add -q option to serdi to suppress all non-data output, e.g. errors
  • Reset indent when finishing a write
  • Report write size correctly when invalid UTF-8 is encountered and a replacement character is written
  • Strip down API documentation to a single clean page
  • Fix various hyper-strict warnings
  • Do not require a C++ compiler to build
  • Add option to build utilities as static binaries
  • Upgrade to waf 1.7.2

Benchmarking LV2 plugins

A new utility has been added to Lilv for benchmarking LV2 plugins. As you might expect, it is called lv2bench.

Simple, but useful, lv2bench runs all discovered plugins for a specified number of frames split into a specified block size, and records the time each plugin took to execute. It prints a simple table like this:

Block Samples Time Plugin
512 524288 0.005872
512 524288 0.006461
512 524288 0.008772
512 524288 0.008959

This makes it easy to get a good overall feel for how expensive plugins on the system are relative to each other. Of course, a more expressive view of this information with several parameters would be useful... Robin Gareus to the rescue! Robin made a script currently called lilvplot which does several runs with various parameters and plots the data, which makes the relative performance more clear and shows the variance of a plugin's run time with error bars. This is important information because run-time variance is a good indicator of how real-time appropriate a plugin is.

Here is an example of lilvplot output generated from lv2bench data (as a massive SVG, you may want to open this image in a separate window and zoom in to see the plugin labels): LV2 Benchmark

Both of these tools are very fresh and there are certainly improvements to be made (normalizing the y-axis so it showed where real-time is would be more informative, and lv2bench currently supports very few features), but they already make a useful addition to the LV2 developer's toolkit. I found them useful for evaluating the improvements had by vectorizing the arithmetic plugins in my soon-to-be-released port of blop. It will be interesting to see how things stack up in more thorough runs that include more plugins.

LV2 OpenGL UIs on Windows

I have been working on Suil support for wrapping native Windows plugin UIs in Gtk. Here is a plugin with a Pugl UI embedded in the Gtk version of Jalv:

LV2 OpenGL UI in Windows

Very fresh work, but the basics (display, and mouse/keyboard input) are working well. This work is not actually OpenGL specific, any native Windows UI will work equally well. Apologies for the boring screenshot, this is just my test GL plugin that does nothing. However, it is a working example of a plugin with a portable custom UI; hopefully we'll soon see production plugins with UIs that work equally well across toolkits and platforms.

Suil 0.6.4

suil 0.6.4 has been released. Suil is a library for loading and wrapping LV2 plugin UIs. For more information, see


  • Correctly handle resizing for Gtk2 in Qt4
  • Improve documentation

Suil 0.6.2

suil 0.6.2 has been released. Suil is a library for loading and wrapping LV2 plugin UIs. For more information, see


  • Fix crashes when wrapper widget is destroyed by toolkit before suil cleanup function is called
  • Link Gtk wrappers with 'nodelete' to avoid Glib type errors
  • Allow run-time configuration of module directory via environment variable SUIL_MODULE_DIR

Portable OpenGL Plugin UIs

LV2 allows plugins to implement UIs in any toolkit. This has led to UIs being implemented in several (which is a Good Thing, and works fine in all hosts via Suil), but mostly Gtk.

Unfortunately, Gtk is not really suitable for use in plugins on platforms where a "system Gtk" can't be relied on. Some toolkits are suitable for static linking, but personally, I am somewhat disillusioned with "toolkits" lately, and massive libraries in general. Sometimes all you want or need is a straightforward standard graphics API and some keyboard/mouse events.

When it comes to standard cross-platform graphics APIs, the undisputed heavyweight king is OpenGL. While not perfect (what is?), no other API is already there on almost any platform you'd care about (heck, most modern phones have hardware accelerated OpenGL). Unfortunately, OpenGL deals only with rendering, and not user input or windowing issues. What is needed is a minimal framework to get an OpenGL view to draw to, and receive keyboard and mouse events. Enter Pugl.

Pugl handles all the platform specific business behind an API very similar to GLUT, but much smaller and appropriate for plugins (which GLUT unfortunately is not). In terms of size, this is a few hundred lines of C per platform (on a personal note, this fits in well with my ever-increasing distaste in dealing with bloated junk with tons of dependencies... give me a Couple Hundred Lines of C™ any day). The breakdown on Pugl is on its homepage, but suffice to say after a few days' work it does the job it was designed to do on X11, Mac OS X, and Windows. Since embedding X11 works in LV2 land, that means an OpenGL plugin UI can be embedded in the host, and I have the pretty pictures to prove it:

Pugl embedded in Ardour

Pugl embedded in Ingen

This is a simple test plugin (complete with gratuitous use of 3D) embedded in Ingen and Ardour. Both are Gtk based programs, but this works in Qt as well. Testing so far on other platforms has only been top-level since I have no programs to embed in, but the bulk of the work is done. This includes full keyboard and mouse support, with significantly more complete keyboard support than GLUT.

Naturally I can't predict the future, so it remains to be seen how much OpenGL UI action we'll see for plugins. Being just a low level drawing API and not a set of boxed widgets, it's a bit open ended with a bit of a learning curve, but on the other hand there is lots of existing OpenGL code out there. Perhaps someone will throw together a library of audio appropriate widgets, if one doesn't already exist. Either way, I think an easy to use API for writing truly portable LV2 plugin UIs is a very good thing, which hopefully eliminates a barrier for some plugin developers and helps LV2 invade the territory of its proprietary adversaries... or, at the very least, makes for a really cool 3D panner GUI :)

MDA.LV2 1.0.0

mda-lv2 1.0.0 has been released. This is a port of the MDA VST plugins to LV2.

Jalv 1.0.0

jalv 1.0.0 has been released. Jalv is a simple but fully featured LV2 host for Jack which exposes plugin ports to Jack, essentially making any LV2 plugin function as a Jack application. For more information, see

« Page 7 / 12 »