drobilla.net - Lilv

Lilv 0.26.4

2026-02-10T18:47:00-05:00

Lilv 0.26.4 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications.

Changes:

Add clang nullability annotations
Address new warnings in clang and clang-tidy 21
Fix default LV2 path on cross-compiled Windows builds
Fix loading of duplicate bundles with equivalent versions
Fix potential crash when UIs have multiple types or binaries
Use consistent quoting and punctuation in log messages

Lilv 0.26.2

2025-11-25T19:49:00-05:00

Lilv 0.26.2 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications.

Changes:

Actually reload files if bundles are unloaded then reloaded
Add support for loading xsd:float literals, "INF", and "NaN"
Avoid warning about non-existent entries in LV2_PATH
Fix crash when duplicate plugins are discovered
Fix lilv_node_is_literal() with booleans
Refine command line tool interfaces and documentation
lv2bench: Add support for common features and options
lv2bench: Use more realistic real-time scheduling

Lilv 0.26.0

2025-11-12T19:15:00-05:00

Lilv 0.26.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications.

Changes:

Add header warnings test
Add option to control indexing overhead for subject queries
Avoid over-use of yielding meson options
Cache LANG value and add option to override it
Fix Python tests
Fix build with dynmanifest support
Fix loading plugins that haven't been loaded yet as state
Fix loading plugins with invalid lv2:appliesTo properties as state
Fix potential memory leak in lilv_world_load_plugin_classes()
Fix potential memory leak in lilv_world_set_option()
Gracefully ignore and warn about non-directories in LV2_PATH
Improve loading performance when many plugin versions are found
Improve performance when loading and deleting state
Only consider manifest data when discovering related presets/etc
Print a warning when a property unexpectedly has several values
Reduce temporary node allocations during query operations

Lilv “Object Index” Option Revised

2025-11-12T13:58:00-05:00

My previous post, “Improving LV2 Discovery Performance”, described adding an option to lilv that controls whether an additional index is maintained for loaded LV2 data. While testing those changes for release, I discovered a few things (like lv2lint) that break without the index, which convinced me that disabling it by default wasn't the right decision.

So, I'm instead enabling it by default, which avoids this “break by default” situation. The downside is that hosts will need to add code in order to enjoy the performance improvements. To make this change as simple as possible, I also made lilv_world_set_option accept a null value to disable boolean options, so most hosts can simply add this line:

lilv_world_set_option(world, LILV_OPTION_OBJECT_INDEX, NULL);

This requires the new version, but the same change can be made without bumping the required version by avoiding the niceties:

LilvNode* false_node = lilv_new_bool(world, false);

lilv_world_set_option(
  world,
  "http://drobilla.net/ns/lilv#object-index",
  false_node);

lilv_node_free(false_node);

This will log a warning about the unsupported option on older versions, but otherwise have no effect.

Improving LV2 Discovery Performance

2025-09-29T10:25:00-04:00

LV2 plugins (and other data, like presets) are discovered by parsing Turtle files installed in various bundle directories. If the host only needs to know which things are installed, then only manifest.ttl files need to be loaded. That takes only a fraction of a second (60 ms on this machine, which has 897 plugins installed), but if the host needs more information (like the plugin's label or what ports it has), then the data files need to be loaded as well, which can take several seconds. The parser (from serd) is very fast, so the overwhelming majority of this time is spent inserting data into a model.

I was recently doing some work on lilv related to discovery, and got sidetracked into investigating how much of this overhead could be eliminated. Quite a bit, as it turns out, but before explaining how, I'll give a brief summary of the relevant fundamentals so people who don't spend their days in the triple mines can understand what I'm talking about.

LV2 data is written in the Turtle syntax, which can have a lot of structure, but is ultimately just a shorthand for data that is simply a “flat” series of triples. For example, the abbreviated Turtle

<http://example.org/amp>
    a lv2:Plugin ;
    doap:name "Amplifier" .

represents the two triples

<http://example.org/amp> rdf:type  lv2:Plugin .
<http://example.org/amp> doap:name "Amplifier" .

which describe a plugin with the name “Amplifier”.

Two implications of this format are important to understand here:

All data is a set of triples which can be stored in some lexicographical order to be quickly searchable (for example, a set ordered subject-first can be used to quickly find triples that start with a given subject).
All data can be streamed via a simple “flat” interface (for example a function with three parameters), and is trivial to inspect and/or filter on the fly (much like line-based text in POSIX pipelines).

The data may not be stored as a “literal” ordered set of triples (they're actually quads in memory for one thing), but this simplified way of thinking about it is good enough for this explanation.

Which order is best depends on the query. For example (borrowing a bit of syntax from SPARQL where ?name represents a query variable), if the host asks something like “what's the name of this plugin” or

<http://example.org/amp> doap:name ?name .

then it needs to find triples that start with the given subject and predicate (<http://example.org/amp> and doap:name) to see what object (?name) they have. So, a subject-predicate-object or “SPO” index will work well. If, however, the host asks something like “which things are plugins” or

?plugin rdf:type lv2:Plugin .

then an SPO index doesn't help because there's no known subject to search for. Most queries are like this, with either a subject or object wildcard (querying relatively “fixed” predicates is rare), so lilv has always had both an SPO and OPS index to support them.

This is convenient, but twice the indexing means roughly twice the overhead. The SPO index is the natural order used in the syntax, and supports most code (which mainly looks up properties of known things), but the OPS index isn't used so much. Can it be removed entirely to speed things up? It is used for many important things, but conveniently, there's only a few fixed cases of those (like finding plugins as above). So, we can take advantage of the streaming nature of the data to record this information while it's being read, instead of inserting it into an index only to query it out later.

To do this in the implementation, I introduced the concept of a “skimmer”. A skimmer inserts triples into a model as usual, but first “skims” them and records items of interest for later use. For example, a skimmer checks whether a triple has rdf:type lv2:Plugin, and if so, records the subject in a result set that stores only plugin URIs. Some cases are a bit trickier, and actually pulling this off cleanly took quite an overhaul, but details aside, it turns out that this approach can be used to eliminate the OPS index entirely without losing any functionality.

How much of an improvement does this make? On this machine, using lv2ls -n as a crude benchmark, the time goes from 3.11 to 1.72 seconds, or about a 45% improvement. The memory consumption goes down a bit as well, from (even more crudely) a max-RSS of about 138 to 112 MiB, or about a 19% improvement (everything here is an average of three runs). The improvement will vary dramatically based on what's installed, for example in some earlier tests with a different configuration I saw drops from around 7 to 4 seconds, but in general, not bad!

Are there any downsides to this? Yes, primarily two:

As with any significant change, there is the possibility of regression. Discovery is a little more restricted than before, so although I've done my best to test things, there is a possibility of things not being discovered anymore. Usually the fix for this is adding information to the manifest that should have been there anyway.
Though the implementation itself doesn't make queries that require the OPS index, hosts themselves can since lilv provides generic query functions. To support this, there's a new boolean option, LILV_OPTION_OBJECT_INDEX, which can be used to enable or disable the OPS index. Since most hosts don't need it, I decided to disable this by default. That will be a regression for hosts that do, however, who need to explicitly opt in to the old behaviour by enabling this option. A warning is printed if a query will be slow because of the missing index, so it should at least be obvious if this happens.

These changes are now in the main branch in git, which will be released soon, probably as version 0.26.0.

Lilv 0.24.26

2025-01-19T13:53:00-05:00

Lilv 0.24.26 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications.

Changes:

Add lint option with project metadata and code quality tests
Avoid use of VLAs in lv2apply
Clean up and isolate platform-specific code
Fix C++ test build on MacOS
Fix library current_version on MacOS
Fix test suite when TMPDIR has no trailing slash
Fully separate library code from programs
Improve const correctness
Replace more platform-specific code with use of zix

Lilv 0.24.24

2024-01-23T19:39:00-05:00

Lilv 0.24.24 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Avoid overriding state features passed by the host
Fix null dereference when trying to load state from a missing file
Fix potential null dereferences and conversion warnings

Lilv 0.24.22

2023-10-22T20:14:00-04:00

Lilv 0.24.22 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Allow LILV_API to be defined by the user
Clean up code
Clean up inconsistent tool command line interfaces
Convert man pages to mdoc
Fix crash when plugins pass NULL to the LV2_State_Retrieve_Function
Fix dependencies in pkg-config file
Fix potential crash when writing state files fails
Order plugin classes by URI
Override pkg-config dependency within meson
Remove junk files from documentation install
Replace duplicated dox_to_sphinx script with sphinxygen dependency
Switch to external zix dependency

Lilv 0.24.20

2022-09-09T17:28:00-04:00

Lilv 0.24.20 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Adopt REUSE machine-readable licensing standard
Update project metadata

Lilv 0.24.18

2022-08-12T22:15:00-04:00

Lilv 0.24.18 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Allow programs to be used from subproject
Fix default LV2_PATH

Lilv 0.24.16

2022-07-19T01:16:00-04:00

Lilv 0.24.16 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix fallback flock() detection on MacOS
Switch to meson build system

Lilv 0.24.14

2022-05-27T01:38:00-04:00

Lilv 0.24.14 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix build issues with newer toolchains
Fix unused parameter warnings
Update zix tree

Lilv 0.24.12

2021-01-07T21:46:00-05:00

Lilv 0.24.12 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Allow connecting ports to structures in Python
Fix potential memory error when joining filesystem paths
Fix saving state with files on Windows
Fix unlikely undefined behavior when saving state
Fix writing state manifests on Windows
Remove the need for a generated configuration header

Lilv 0.24.10

2020-09-27T12:17:00-04:00

Lilv 0.24.10 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix memory leaks in lv2bench
Fix various minor warnings and other code quality issues
Make lilv_world_get() use translations
Split and clean up test suite

Lilv 0.24.8

2020-04-26T15:55:00-04:00

Lilv 0.24.8 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Allow passing strings for URIs in Python API when unambiguous
Fix cases where incorrect translation is used
Fix deleting state bundles loaded from the model
Fix memory leak when dyn-manifest has no plugins (thanks Michael Fisher)
Implement state:freePath feature

Lilv 0.24.6

2019-11-10T21:39:00-05:00

Lilv 0.24.6 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add more strict error detection when storing plugin state properties
Add option to override LV2_PATH in applications
Don't print errors when saving state if correct links already exist
Fix GCC8 warnings
Fix creating directories across drives on Windows
Fix issues with loading state with saved files from the model
Fix memory errors and Python 3.4+ compatibility in Python bindings
Fix unit tests on Windows
Make Python bindings more Pythonic

Lilv 0.24.4

2018-07-22T18:42:00-04:00

Lilv 0.24.4 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Don't attempt to load remote or non-Turtle files
Fix saving state when broken links are encountered
Gracefully handle plugins with missing binary URIs
Install Python bindings when configured without tests (thanks Clement Skau)
Remove use of deprecated readdir_r
lv2apply: Activate plugin before running
lv2apply: Use default values when they are not nan
lv2bench: Improve support for plugins with sequence ports
lv2bench: Support running a single plugin given on the command line

Lilv 0.24.2

2017-01-04T16:48:00-05:00

Lilv 0.24.2 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix comparison of restored states with paths
Fix saving state to paths that contain URI delimiters (#, ?, etc)

Lilv 0.24.0

2016-09-20T02:24:00-04:00

Lilv 0.24.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add LILV_URI_ATOM_PORT and LILV_URI_CV_PORT defines
Add lilv_state_set_metadata() for adding state banks/comments/etc (based on patch from Hanspeter Portner)
Add lilv_world_get_symbol()
Add lv2apply utility for applying plugins to audio files
Add new hand-crafted Pythonic bindings with full test coverage
Check lv2:binary predicate for UIs
Do not instantiate plugin when data fails to parse
Fix crash when NULL predicate is passed to lilv_world_find_nodes()
Fix crash when state contains non-POD properties
Fix documentation installation
Fix loading dyn-manifest from bundles with spaces in their path
Fix outdated comment references to lilv_uri_to_path()
Fix state file versioning
Replace bundles if bundle with newer plugin version is loaded (based on patch from Robin Gareus)
Support re-loading plugins
Unload contained resources when bundle is unloaded

Lilv 0.22.0

2015-10-08T19:39:00-04:00

Lilv 0.22.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add lilv_file_uri_parse() for correct URI to path conversion
Add lilv_free() for systems picky about such things
Add lilv_node_get_path() for convenient file URI path access
Add lilv_state_delete() for deleting user saved presets
Add lilv_state_emit_port_values() for special port value handling
Add lilv_state_get_uri()
Configure based on compiler target OS for cross-compilation
Expose lilv_world_load_specifications() and lilv_world_load_plugin_classes()
Fix a few minor/unlikely memory errors
Fix bindings for Python 3
Fix creation of duplicate manifest entries when saving state
Fix directory walking on some systems (thanks Matt Fischer)
Fix lilv_realpath() on pre-POSIX-2008 systems
Fix lilv_world_ask() to work with wildcards
Fix loading files with spaces in their path
Load discovered owl ontologies as specifications
Minor documentation improvements
Preserve absolute paths in state if no link directory is given
Tolerate passing NULL to lilv_state_restore()
Upgrade to waf 1.8.14
Windows fixes (thanks John Emmas)

Lilv 0.20.0

2014-08-08T22:21:00-04:00

Lilv 0.20.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add convenient lilv_new_file_uri for creating file URIs
Add lilv_world_unload_bundle() and lilv_world_unload_resource()
Call lv2_lib_descriptor separately for different bundle paths (fix loading several dynamic plugins like Ingen at once)
Don't load files multiple times if they are listed as rdfs:seeAlso for several plugins
Fix issues with lilv_plugin_get_author_name and friends (thanks Filipe Coelho)
Fix several minor memory leaks
Fix use of lv2info -m and -p options to write plugin data (useful for porting plugins bridges with NASPRO)
Improve test coverage
Improved/working lv2_apply.py to apply plugin to a .wav (thanks Joe Button)
Tolerate calling lilv_node_as_uri or lilv_node_as_blank on NULL
Upgrade to waf 1.7.16

Lilv 0.18.0

2014-01-04T21:06:00-05:00

Lilv 0.18.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add lilv_port_get_node() for using world query functions with ports
Add support for running plugins from Python by Kaspar Emanuel
Allow lilv_state_restore() to be used without passing an instance, for restoring port values via a callback only
Allow passing NULL port_class to lilv_plugin_get_port_by_designation
Call GetProcAddress with correct calling convention on Windows
Clean up after test suite so multiple runs are successful
Fix unlikely memory leak in lilv_plugin_instantiate()
Support denoting latency ports with lv2:designation lv2:latency
lilvmm.hpp: Add wrappers for UI API
lv2info: Don't display invalid control maxes and defaults (patch from Robin Gareus)

Lilv 0.16.0

2013-02-18T21:43:00-05:00

Lilv 0.16.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add lilv_nodes_merge()
Add lilv_world_ask() for easily checking if a statement exists
Add lilv_world_get() and lilv_port_get() for easily getting one value
Add va_list variant of lilv_plugin_get_num_ports_of_class()
Correctly depend on serd at build time (fix compilation in odd cases)
Disable timestamps in HTML documentation for reproducible build
Fail gracefully when lilv_state_new_from_string() is called on NULL
Fix several plugin functions that failed to load data if called first
Ignore state ports with no value instead of printing an error
Make lilv_plugin_get_port_by_designation() return a const pointer
Make state loading functions fall back to lv2:default for port values, so a plugin description can be loaded as default state
Require a URI for lilv_state_to_string() and fail gracefully otherwise
Support atom:supports in lilv_port_supports_event()
Update to waf 1.7.8 and autowaf r90 (install docs to versioned directory)
lilvmm.hpp: Add several missing methods
lilvmm.hpp: Support varargs for Plugin::get_num_ports_of_class()

Lilv 0.14.4

2012-08-23T05:38:00-04:00

Lilv 0.14.4 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add lv2bench utility
Add option to build utilities as static binaries
Deprecate old flawed Lilv::Instance constructors
Do not require a C++ compiler to build
Fix crash when lv2info is run with an invalid URI argument
Fix documentation for ui_type parameter of lilv_ui_is_supported()
Fix various hyper-strict warnings
Gracefully handle failure to save plugin state and print error message
Make all 'zix' symbols private to avoid symbol clashes in static builds
Reduce memory usage (per node)
Simpler node implementation always backed by a SordNode
Upgrade to waf 1.7.2
lilvmm.hpp: Add Lilv::Instance::get_extension_data()
lilvmm.hpp: Add Lilv::Instance::get_handle()
lilvmm.hpp: Make Lilv::Instance handle features and failed instantiations

Lilv 0.14.2

2012-04-19T20:11:00-04:00

Lilv 0.14.2 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix dynmanifest support

Lilv 0.14.0

2012-04-19T00:06:00-04:00

Lilv 0.14.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add LilvState API for handling plugin state. This makes it simple to save and restore plugin state both in memory and on disk, as well as save presets in a host-sharable way since the disk format is identical to the LV2 presets format.
Add lilv_plugin_get_extension_data
Add lilv_plugin_get_port_by_designation() and lilv_port_get_index() as an improved generic alternative to lilv_plugin_get_latency_port_index().
Add lilv_plugin_get_project() and get author information from project if it is not given directly on the plugin.
Add lilv_plugin_get_related to get resources related to plugins that are not directly rdfs:seeAlso linked (e.g. presets)
Add lilv_world_load_resource for related resources (e.g. presets)
Fix compilation on BSD
Fix lilv_world_find_nodes to work with wildcard subjects
Install man page to DATADIR (e.g. PREFIX/share/man, not PREFIX/man)
Make Lilv::uri_to_path static inline (fix linking errors)
Only load dynmanifest libraries once per bundle, not once per plugin
Print presets in lv2info
Remove locale smashing kludges and use new serd functions for converting nodes to/from numbers.
Remove use of wordexp.
Support compilation as C++ under MSVC++.
Update old references to lv2_list (now lv2ls)
Use correct URI for dcterms:replaces (for hiding old plugins): "http://purl.org/dc/terms/replaces"
Use path variables in pkgconfig files

Lilv 0.5.0

2011-09-29T04:00:00-04:00

Lilv 0.5.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Add ability to build static library
Add lv2core as a pkg-config dependency (for lv2.h header include)
Obey prefix when installing bash completion script
Remove glib dependency
Support integer minimum, maximum, and default port values in lilv_plugin_get_port_ranges_float

Lilv 0.4.4

2011-06-11T15:20:00-04:00

Lilv 0.4.4 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix building python bindings
Fix lilv_ui_is_supported when Lilv is built independently
Fix parsing extra plugin data files in other bundles
Make free methods tolerate being called on NULL
Remove lv2jack (replaced by jalv)

Lilv 0.4.2

2011-05-25T23:00:00-04:00

Lilv 0.4.2 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Fix build system Python 3 compatibility
Fix compilation issues on some systems

Lilv 0.4.0

2011-05-25T03:00:00-04:00

Lilv 0.4.0 has been released. Lilv is a C library to make the use of LV2 plugins as simple as possible for applications. For more information, see http://drobilla.net/software/lilv.

Changes:

Initial version (forked from SLV2)