215 files changed, 7906 insertions, 44 deletions

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..f063da3
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+waf binary
\ No newline at end of file
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..d72aad1
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,14 @@
+Author:
+	David Robillard <d@drobilla.net>
+
+Original GTK2 Generic Plugin UI:
+	Nick Lanham <nick@afternight.org>
+
+Various UI improvements:
+	Robin Gareus <robin@gareus.org>
+
+Preset menu support for Qt:
+	Timo Westkämper <timo.westkamper@gmail.com>
+
+Qt4 Generic Plugin UI:
+	Amadeus Folego <amadeusfolego@gmail.com>
diff --git a/COPYING b/COPYING
index a4147d2..cf8477f 100644
--- a/COPYING
+++ b/COPYING
@@ -1,25 +1,13 @@
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-3. The name of the author may not be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
-IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
+Copyright 2011-2017 David Robillard <http://drobilla.net>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..623cddd
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,59 @@
+Installation Instructions
+=========================
+
+Basic Installation
+------------------
+
+Building this software requires only Python.  To install with default options:
+
+    ./waf configure
+    ./waf
+    ./waf install
+
+You may need to become root for the install stage, for example:
+
+    sudo ./waf install
+
+Configuration Options
+---------------------
+
+All supported options can be viewed using the command:
+
+    ./waf --help
+
+Most options only need to be passed during the configure stage, for example:
+
+    ./waf configure --prefix=/usr
+    ./waf
+    ./waf install
+
+Compiler Configuration
+----------------------
+
+Several standard environment variables can be used to control how compilers are
+invoked:
+
+ * CC:        Path to C compiler
+ * CFLAGS:    C compiler options
+ * CXX:       Path to C++ compiler
+ * CXXFLAGS:  C++ compiler options
+ * CPPFLAGS:  C preprocessor options
+ * LINKFLAGS: Linker options
+
+Installation Directories
+------------------------
+
+The --prefix option (or the PREFIX environment variable) can be used to change
+the prefix which all files are installed under.  There are also several options
+allowing for more fine-tuned control, see the --help output for details.
+
+Packaging
+---------
+
+Everything can be installed to a specific root directory by passing a --destdir
+option to the install stage (or setting the DESTDIR environment variable),
+which adds a prefix to all install paths.  For example:
+
+    ./waf configure --prefix=/usr
+    ./waf
+    ./waf install --destdir=/tmp/package
diff --git a/NEWS b/NEWS
new file mode 100644
index 0000000..74e7a67
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,119 @@
+jalv (1.6.1) unstable;
+
+  * Fix compilation with recent Gtkmm versions that require C++11
+  * Add jalv -i option to ignore stdin for background use
+  * Add several commands to console interface
+  * Add support for running as an internal Jack client (thanks Timo Wischer)
+  * Make Suil dependency optional
+  * Remove support for deprecated event and uri-map extensions
+  * Fix Jack deactivation
+  * Fix potential crash when closed with worker (thanks JP Cimalando)
+  * Fix potential hang after Ctrl-c in console interface (thanks Laxmi Devi)
+  * Add support for underscore in port names on command line
+    (thanks Jośe Fernando Moyano)
+
+ -- David Robillard <d@drobilla.net>  Sat, 29 Sep 2018 14:16:07 +0200
+
+jalv (1.6.0) stable;
+
+  * Support CV ports if Jack metadata is enabled (patch from Hanspeter Portner)
+  * Fix unreliable UI state initialization (patch from Hanspeter Portner)
+  * Fix memory error on preset save resulting in odd bundle names
+  * Improve preset support
+  * Support numeric and string plugin properties (event-based control)
+  * Support thread-safe state restoration
+  * Update UI when internal plugin state is changed during preset load
+  * Add generic Qt control UI from Amadeus Folego
+  * Add PortAudio backend (compile time option, audio only)
+  * Set Jack port order metadata
+  * Allow Jack client name to be set from command line (thanks Adam Avramov)
+  * Add command prompt to console version for changing controls
+  * Add option to print plugin trace messages
+  * Print colorful log if output is a terminal
+  * Exit on Jack shutdown (patch from Robin Gareus)
+  * Report Jack latency (patch from Robin Gareus)
+  * Exit GUI versions on interrupt
+  * Fix semaphore correctness issues
+  * Use moc-qt4 if present for systems with multiple Qt versions
+  * Add Qt5 version
+
+ -- David Robillard <d@drobilla.net>  Wed, 04 Jan 2017 12:24:58 -0500
+
+jalv (1.4.6) stable;
+
+  * Show newly saved presets in the preset menu
+  * Generate Qt moc nonsense at build time for broader compatibility
+  * Update for latest LV2 Atom Object simplifications
+  * Set port pretty names via new Jack metadata API
+  * Add support for data-access extension (based on patch by Filipe Coelho)
+  * Support new UI show/hide interface in console version
+  * Add option to print control output changes to stdout
+  * Support saving the same preset several times
+  * Update man pages and console jalv help output for new options
+  * Upgrade to waf 1.7.16
+
+ -- David Robillard <d@drobilla.net>  Fri, 08 Aug 2014 18:30:28 -0400
+
+jalv (1.4.4) stable;
+
+  * Add -c option for setting controls from the command line
+  * Add --no-menu option for jalv.gtk
+  * Don't expose non-MIDI event ports to Jack
+  * Hide controls for ports with notOnGUI property in generic UI
+    (based on patch from Robin Gareus)
+  * Support ui:portMap feature to allow UIs to avoid hard-coded port indices
+    (useful for compatibility and separately distributed UIs)
+  * Preset menu support for Qt (patch from Timo Westkämper)
+
+ -- David Robillard <d@drobilla.net>  Sat, 04 Jan 2014 16:11:45 -0500
+
+jalv (1.4.2) stable;
+
+  * Fix crash when running "jalv" with bad command line arguments
+  * Fix potential crash with UIs and debug printing
+  * Fix parameter changes with Qt UI
+  * Nicer printing of atom messages with -d
+  * Add command-line option to control UI update frequency
+  * Support rsz:minimumSize for atom and event ports
+  * Fix default setting for non-sequential enumeration ports
+    (patch from Robin Gareus)
+  * Work around Gtk bug for labels on sliders (patch from Robin Gareus)
+  * Upgrade to waf 1.7.11
+
+ -- David Robillard <d@drobilla.net>  Fri, 09 Aug 2013 10:40:20 -0400
+
+jalv (1.4.0) stable;
+
+  * Send time information to plugin when Jack tempo changes
+  * Group controls under headings if port group information is available
+  * Add spinbuttons for precisely setting control values
+  * Use a more efficient dense layout for controls
+  * Make URI map thread-safe, fixing occasional crashes for plugins with UIs
+  * Add menu bar and pass parent widget in Qt version for true UI embedding
+  * Support state:loadDefaultState
+  * Update to waf 1.7.8 and autowaf r90
+
+ -- David Robillard <d@drobilla.net>  Fri, 22 Feb 2013 22:35:22 -0500
+
+jalv (1.2.0) stable;
+
+  * Tune UI update rate and ring size based on JACK rate and MIDI buffer size
+    to handle the handle the maximum message rate the plugin can send.
+  * Support lv2:sampleRate control ports.
+  * Tolerate loading presets with port values that aren't xsd:decimal
+  * Notify plugins of Jack transport changes by sending events (an atom:Blank
+    with properties from the LV2 time extension)
+  * Refuse to instantiate plugins which require unsupported features
+  * Support LV2 buf-size extension (with all features)
+  * Add Gtk3 UI
+  * Port to MinGW
+  * Fix Jack Session support
+
+ -- David Robillard <d@drobilla.net>  Sun, 14 Oct 2012 18:38:53 -0400
+
+jalv (1.0.0) stable;
+
+  * Initial release
+
+ -- David Robillard <d@drobilla.net>  Thu, 19 Apr 2012 18:42:42 -0400
+
diff --git a/README.md b/README.md
index c5361b9..430175a 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,19 @@
-Autowaf
-=======
+Jalv
+====
 
-This is autowaf, a bundle of waf and a few extensions intended to be easy to
-use directly as source code in a project.  Using this as a submodule or subtree
-named `waflib` in a project allows waf to be used without including binary
-encoded data in the waf script.  This gets along with revision control and
-distributions better, among other advantages, without losing
-self-containedness.
+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 <http://drobilla.net/software/jalv>.
 
-To use this in a project, add this repository as a directory named `waflib` in
-the top level of the project, and link or copy `waf` to the top level.
+Jalv is a small program which is useful, but also intended to be an appropriate
+test host for plugin development.  It runs plugins from the command line with
+no user interaction, is light enough to run in valgrind, and is capable of
+dumping all communication between the plugin and its UI in a human readable
+format.
 
-Two waf extras are also included: `autowaf.py` and `lv2.py`.
-
-The `autowaf.py` module is a kitchen sink of Python utilities for building
-consistent packages, and can be imported in a wcript as
-`waflib.extras.autowaf`.
-
-The `lv2.py` extra defines options for LV2 plugin installation paths.  It can
-be used by calling `opt.load('lv2')` and `conf.load('lv2')` in the appropriate
-locations in a wscript.
+To make it simple to test plugins in hosts that use different toolkits, there
+are several Jalv executables: jalv, jalv.gtk, jalv.gtk3, jalv.gtkmm, jalv.qt4,
+and jalv.qt5.
 
  -- David Robillard <d@drobilla.net>
diff --git a/doc/jalv.1 b/doc/jalv.1
new file mode 100644
index 0000000..9f65001
--- /dev/null
+++ b/doc/jalv.1
@@ -0,0 +1,85 @@
+.TH JALV 1 "18 Feb 2017"
+
+.SH NAME
+.B jalv \- Run an LV2 plugin as a JACK application (console version).
+
+.SH SYNOPSIS
+.B jalv [OPTION]... PLUGIN_URI
+
+.SH OPTIONS
+
+.TP
+\fB\-b SIZE\fR
+Buffer size for plugin <=> UI communication.
+
+.TP
+\fB\-c SYM=VAL\fR
+Set control value (e.g. "vol=1.4").
+
+.TP
+\fB\-d\fR
+Dump plugin <=> UI communication.
+
+.TP
+\fB\-h\fR
+Print the command line options.
+
+.TP
+\fB\-i\fR
+Ignore input on stdin (for background use).
+
+.TP
+\fB\-l DIR\fR
+Load state from state directory.
+
+.TP
+\fB\-n NAME\fR
+Jack client name
+
+.TP
+\fB\-p\fR
+Print control output changes to stdout.
+
+.TP
+\fB\-s\fR
+Show plugin UI if possible.
+
+This option only works when plugins provide a UI that is usable via the non-embeddable showHide interface.  For other, embeddable UIs, use jalv.gtk(1) or jalv.qt(1).
+
+.TP
+\fB\-t\fR
+Print trace messages from plugin
+
+.TP
+\fB\-u UUID\fR
+UUID for Jack session restoration.
+
+.TP
+\fB\-x\fR
+Use only exact Jack client name, and exit if it is taken
+
+.SH COMMANDS
+
+The Jalv prompt supports several commands for interactive control:
+
+  \fBhelp\fR              Display help message
+  \fBcontrols\fR          Print settable control values
+  \fBmonitors\fR          Print output control values
+  \fBpresets\fR           Print available presets
+  \fBpreset URI\fR        Set preset
+  \fBset INDEX VALUE\fR   Set control value by port index
+  \fBset SYMBOL VALUE\fR  Set control value by symbol
+  \fBSYMBOL = VALUE\fR    Set control value by symbol
+
+.SH "SEE ALSO"
+.BR jalv.gtk(1),
+.BR jalv.gtkmm(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/doc/jalv.gtk.1 b/doc/jalv.gtk.1
new file mode 100644
index 0000000..5177e1d
--- /dev/null
+++ b/doc/jalv.gtk.1
@@ -0,0 +1,58 @@
+.TH JALV.GTK "18 Feb 2017"
+
+.SH NAME
+.B jalv.gtk \- Run an LV2 plugin as a JACK application (Gtk version).
+
+.SH SYNOPSIS
+.B jalv.gtk [OPTION]... PLUGIN_URI
+
+.SH OPTIONS
+
+.TP
+\fB\-b SIZE\fR
+Buffer size for plugin <=> UI communication.
+
+.TP
+\fB\-c SYM=VAL\fR
+Set control value (e.g. "vol=1.4").
+
+.TP
+\fB\-d\fR, \fB\-\-dump\fR
+Dump plugin <=> UI communication.
+
+.TP
+\fB\-g\fR, \fB\-\-generic\-ui\fR
+Use Jalv generic UI and not the plugin UI.
+
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+Print the command line options.
+
+.TP
+\fB\-l DIR\fR, \fB\-\-load DIR\fR
+Load state from state directory.
+
+.TP
+\fB\-p\fR, \fB\-\-print\-controls\fR
+Print control output changes to stdout.
+
+.TP
+\fB\-t\fR, \fB\-\-trace\fR
+Print trace messages from plugin.
+
+.TP
+\fB\-u UUID\fR, \fB\-\-uuid UUID\fR
+UUID for Jack session restoration.
+
+.SH "SEE ALSO"
+.BR jalv(1),
+.BR jalv.gtkmm(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/doc/jalv.gtkmm.1 b/doc/jalv.gtkmm.1
new file mode 100644
index 0000000..2a6ce01
--- /dev/null
+++ b/doc/jalv.gtkmm.1
@@ -0,0 +1,25 @@
+.TH JALV.GTKMM 1 "19 Apr 2012"
+
+.SH NAME
+.B jalv.gtkmm \- Run an LV2 plugin as a JACK application (Gtkmm version).
+
+.SH SYNOPSIS
+.B jalv.gtkmm PLUGIN_URI
+
+.SH DESCRIPTION
+
+This is a version of Jalv with a GUI implemented in Gtkmm.  It is mainly for
+developer testing purposes, for a production ready program use jalv.gtk.
+
+.SH "SEE ALSO"
+.BR jalv(1),
+.BR jalv.gtk(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/doc/jalv.qt.1 b/doc/jalv.qt.1
new file mode 100644
index 0000000..352835d
--- /dev/null
+++ b/doc/jalv.qt.1
@@ -0,0 +1,25 @@
+.TH JALV.QT 1 "19 Apr 2012"
+
+.SH NAME
+.B jalv.qt \- Run an LV2 plugin as a JACK application (Qt version).
+
+.SH SYNOPSIS
+.B jalv.qt PLUGIN_URI
+
+.SH DESCRIPTION
+
+This is a version of Jalv with a GUI implemented in Qt.  It is mainly for
+developer testing purposes, for a production ready program use jalv.gtk.
+
+.SH "SEE ALSO"
+.BR jalv(1),
+.BR jalv.gtkmm(1),
+.BR jalv.qt(2),
+.BR lv2ls(1),
+.BR jackd(1)
+
+.SH AUTHOR
+jalv was written by David Robillard <d@drobilla.net>
+.PP
+This manual page was written by Jaromír Mikes <mira.mikes@seznam.cz>
+and David Robillard <d@drobilla.net>
diff --git a/src/control.c b/src/control.c
new file mode 100644
index 0000000..2326280
--- /dev/null
+++ b/src/control.c
@@ -0,0 +1,165 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "jalv_internal.h"
+
+int
+scale_point_cmp(const ScalePoint* a, const ScalePoint* b)
+{
+	if (a->value < b->value) {
+		return -1;
+	} else if (a->value == b->value) {
+		return 0;
+	}
+	return 1;
+}
+
+ControlID*
+new_port_control(Jalv* jalv, uint32_t index)
+{
+	struct Port*      port  = &jalv->ports[index];
+	const LilvPort*   lport = port->lilv_port;
+	const LilvPlugin* plug  = jalv->plugin;
+	const JalvNodes*  nodes = &jalv->nodes;
+
+	ControlID* id = (ControlID*)calloc(1, sizeof(ControlID));
+	id->jalv           = jalv;
+	id->type           = PORT;
+	id->node           = lilv_node_duplicate(lilv_port_get_node(plug, lport));
+	id->symbol         = lilv_node_duplicate(lilv_port_get_symbol(plug, lport));
+	id->label          = lilv_port_get_name(plug, lport);
+	id->index          = index;
+	id->group          = lilv_port_get(plug, lport, jalv->nodes.pg_group);
+	id->value_type     = jalv->forge.Float;
+	id->is_writable    = lilv_port_is_a(plug, lport, nodes->lv2_InputPort);
+	id->is_readable    = lilv_port_is_a(plug, lport, nodes->lv2_OutputPort);
+	id->is_toggle      = lilv_port_has_property(plug, lport, nodes->lv2_toggled);
+	id->is_integer     = lilv_port_has_property(plug, lport, nodes->lv2_integer);
+	id->is_enumeration = lilv_port_has_property(plug, lport, nodes->lv2_enumeration);
+	id->is_logarithmic = lilv_port_has_property(plug, lport, nodes->pprops_logarithmic);
+
+	lilv_port_get_range(plug, lport, &id->def, &id->min, &id->max);
+	if (lilv_port_has_property(plug, lport, jalv->nodes.lv2_sampleRate)) {
+		/* Adjust range for lv2:sampleRate controls */
+		if (lilv_node_is_float(id->min) || lilv_node_is_int(id->min)) {
+			const float min = lilv_node_as_float(id->min) * jalv->sample_rate;
+			lilv_node_free(id->min);
+			id->min = lilv_new_float(jalv->world, min);
+		}
+		if (lilv_node_is_float(id->max) || lilv_node_is_int(id->max)) {
+			const float max = lilv_node_as_float(id->max) * jalv->sample_rate;
+			lilv_node_free(id->max);
+			id->max = lilv_new_float(jalv->world, max);
+		}
+	}
+
+	/* Get scale points */
+	LilvScalePoints* sp = lilv_port_get_scale_points(plug, lport);
+	if (sp) {
+		id->points = (ScalePoint*)malloc(
+			lilv_scale_points_size(sp) * sizeof(ScalePoint));
+		size_t np = 0;
+		LILV_FOREACH(scale_points, s, sp) {
+			const LilvScalePoint* p = lilv_scale_points_get(sp, s);
+			if (lilv_node_is_float(lilv_scale_point_get_value(p)) ||
+			    lilv_node_is_int(lilv_scale_point_get_value(p))) {
+				id->points[np].value = lilv_node_as_float(
+					lilv_scale_point_get_value(p));
+				id->points[np].label = strdup(
+					lilv_node_as_string(lilv_scale_point_get_label(p)));
+				++np;
+			}
+			/* TODO: Non-float scale points? */
+		}
+
+		qsort(id->points, np, sizeof(ScalePoint),
+		      (int (*)(const void*, const void*))scale_point_cmp);
+		id->n_points = np;
+
+		lilv_scale_points_free(sp);
+	}
+
+	return id;
+}
+
+static bool
+has_range(Jalv* jalv, const LilvNode* subject, const char* range_uri)
+{
+	LilvNode*  range  = lilv_new_uri(jalv->world, range_uri);
+	const bool result = lilv_world_ask(
+		jalv->world, subject, jalv->nodes.rdfs_range, range);
+	lilv_node_free(range);
+	return result;
+}
+
+ControlID*
+new_property_control(Jalv* jalv, const LilvNode* property)
+{
+	ControlID* id = (ControlID*)calloc(1, sizeof(ControlID));
+	id->jalv     = jalv;
+	id->type     = PROPERTY;
+	id->node     = lilv_node_duplicate(property);
+	id->symbol   = lilv_world_get_symbol(jalv->world, property);
+	id->label    = lilv_world_get(jalv->world, property, jalv->nodes.rdfs_label, NULL);
+	id->property = jalv->map.map(jalv, lilv_node_as_uri(property));
+
+	id->min = lilv_world_get(jalv->world, property, jalv->nodes.lv2_minimum, NULL);
+	id->max = lilv_world_get(jalv->world, property, jalv->nodes.lv2_maximum, NULL);
+	id->def = lilv_world_get(jalv->world, property, jalv->nodes.lv2_default, NULL);
+
+	const char* const types[] = {
+		LV2_ATOM__Int, LV2_ATOM__Long, LV2_ATOM__Float, LV2_ATOM__Double,
+		LV2_ATOM__Bool, LV2_ATOM__String, LV2_ATOM__Path, NULL
+	};
+
+	for (const char*const* t = types; *t; ++t) {
+		if (has_range(jalv, property, *t)) {
+			id->value_type = jalv->map.map(jalv, *t);
+			break;
+		}
+	}
+
+	id->is_toggle  = (id->value_type == jalv->forge.Bool);
+	id->is_integer = (id->value_type == jalv->forge.Int ||
+	                  id->value_type == jalv->forge.Long);
+
+	if (!id->value_type) {
+		fprintf(stderr, "Unknown value type for property <%s>\n",
+		        lilv_node_as_string(property));
+	}
+
+	return id;
+}
+
+void
+add_control(Controls* controls, ControlID* control)
+{
+	controls->controls = (ControlID**)realloc(
+		controls->controls, (controls->n_controls + 1) * sizeof(ControlID*));
+	controls->controls[controls->n_controls++] = control;
+}
+
+ControlID*
+get_property_control(const Controls* controls, LV2_URID property)
+{
+	for (size_t i = 0; i < controls->n_controls; ++i) {
+		if (controls->controls[i]->property == property) {
+			return controls->controls[i];
+		}
+	}
+
+	return NULL;
+}
diff --git a/src/jack.c b/src/jack.c
new file mode 100644
index 0000000..a98963a
--- /dev/null
+++ b/src/jack.c
@@ -0,0 +1,577 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <ctype.h>
+
+#include <jack/jack.h>
+#include <jack/midiport.h>
+#ifdef JALV_JACK_SESSION
+#    include <jack/session.h>
+#endif
+#ifdef HAVE_JACK_METADATA
+#    include <jack/metadata.h>
+#endif
+
+#include "jalv_internal.h"
+#include "worker.h"
+
+struct JalvBackend {
+	jack_client_t* client;             ///< Jack client
+	bool           is_internal_client; ///< Running inside jackd
+};
+
+/** Internal Jack client initialization entry point */
+int jack_initialize(jack_client_t* client, const char* load_init);
+
+/** Internal Jack client finalization entry point */
+void jack_finish(void* arg);
+
+/** Jack buffer size callback. */
+static int
+jack_buffer_size_cb(jack_nframes_t nframes, void* data)
+{
+	Jalv* const jalv = (Jalv*)data;
+	jalv->block_length = nframes;
+	jalv->buf_size_set = true;
+#ifdef HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE
+	jalv->midi_buf_size = jack_port_type_get_buffer_size(
+		jalv->backend->client, JACK_DEFAULT_MIDI_TYPE);
+#endif
+	jalv_allocate_port_buffers(jalv);
+	return 0;
+}
+
+/** Jack shutdown callback. */
+static void
+jack_shutdown_cb(void* data)
+{
+	Jalv* const jalv = (Jalv*)data;
+	jalv_close_ui(jalv);
+	zix_sem_post(&jalv->done);
+}
+
+/** Jack process callback. */
+static REALTIME int
+jack_process_cb(jack_nframes_t nframes, void* data)
+{
+	Jalv* const    jalv   = (Jalv*)data;
+	jack_client_t* client = jalv->backend->client;
+
+	/* Get Jack transport position */
+	jack_position_t pos;
+	const bool rolling = (jack_transport_query(client, &pos)
+	                      == JackTransportRolling);
+
+	/* If transport state is not as expected, then something has changed */
+	const bool xport_changed = (rolling != jalv->rolling ||
+	                            pos.frame != jalv->position ||
+	                            pos.beats_per_minute != jalv->bpm);
+
+	uint8_t   pos_buf[256];
+	LV2_Atom* lv2_pos = (LV2_Atom*)pos_buf;
+	if (xport_changed) {
+		/* Build an LV2 position object to report change to plugin */
+		lv2_atom_forge_set_buffer(&jalv->forge, pos_buf, sizeof(pos_buf));
+		LV2_Atom_Forge*      forge = &jalv->forge;
+		LV2_Atom_Forge_Frame frame;
+		lv2_atom_forge_object(forge, &frame, 0, jalv->urids.time_Position);
+		lv2_atom_forge_key(forge, jalv->urids.time_frame);
+		lv2_atom_forge_long(forge, pos.frame);
+		lv2_atom_forge_key(forge, jalv->urids.time_speed);
+		lv2_atom_forge_float(forge, rolling ? 1.0 : 0.0);
+		if (pos.valid & JackPositionBBT) {
+			lv2_atom_forge_key(forge, jalv->urids.time_barBeat);
+			lv2_atom_forge_float(
+				forge, pos.beat - 1 + (pos.tick / pos.ticks_per_beat));
+			lv2_atom_forge_key(forge, jalv->urids.time_bar);
+			lv2_atom_forge_long(forge, pos.bar - 1);
+			lv2_atom_forge_key(forge, jalv->urids.time_beatUnit);
+			lv2_atom_forge_int(forge, pos.beat_type);
+			lv2_atom_forge_key(forge, jalv->urids.time_beatsPerBar);
+			lv2_atom_forge_float(forge, pos.beats_per_bar);
+			lv2_atom_forge_key(forge, jalv->urids.time_beatsPerMinute);
+			lv2_atom_forge_float(forge, pos.beats_per_minute);
+		}
+
+		if (jalv->opts.dump) {
+			char* str = sratom_to_turtle(
+				jalv->sratom, &jalv->unmap, "time:", NULL, NULL,
+				lv2_pos->type, lv2_pos->size, LV2_ATOM_BODY(lv2_pos));
+			jalv_ansi_start(stdout, 36);
+			printf("\n## Position ##\n%s\n", str);
+			jalv_ansi_reset(stdout);
+			free(str);
+		}
+	}
+
+	/* Update transport state to expected values for next cycle */
+	jalv->position = rolling ? pos.frame + nframes : pos.frame;
+	jalv->bpm      = pos.beats_per_minute;
+	jalv->rolling  = rolling;
+
+	switch (jalv->play_state) {
+	case JALV_PAUSE_REQUESTED:
+		jalv->play_state = JALV_PAUSED;
+		zix_sem_post(&jalv->paused);
+		break;
+	case JALV_PAUSED:
+		for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+			jack_port_t* jport = jalv->ports[p].sys_port;
+			if (jport && jalv->ports[p].flow == FLOW_OUTPUT) {
+				void* buf = jack_port_get_buffer(jport, nframes);
+				if (jalv->ports[p].type == TYPE_EVENT) {
+					jack_midi_clear_buffer(buf);
+				} else {
+					memset(buf, '\0', nframes * sizeof(float));
+				}
+			}
+		}
+		return 0;
+	default:
+		break;
+	}
+
+	/* Prepare port buffers */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* port = &jalv->ports[p];
+		if (port->type == TYPE_AUDIO && port->sys_port) {
+			/* Connect plugin port directly to Jack port buffer */
+			lilv_instance_connect_port(
+				jalv->instance, p,
+				jack_port_get_buffer(port->sys_port, nframes));
+#ifdef HAVE_JACK_METADATA
+		} else if (port->type == TYPE_CV && port->sys_port) {
+			/* Connect plugin port directly to Jack port buffer */
+			lilv_instance_connect_port(
+				jalv->instance, p,
+				jack_port_get_buffer(port->sys_port, nframes));
+#endif
+		} else if (port->type == TYPE_EVENT && port->flow == FLOW_INPUT) {
+			lv2_evbuf_reset(port->evbuf, true);
+
+			/* Write transport change event if applicable */
+			LV2_Evbuf_Iterator iter = lv2_evbuf_begin(port->evbuf);
+			if (xport_changed) {
+				lv2_evbuf_write(&iter, 0, 0,
+				                lv2_pos->type, lv2_pos->size,
+				                (const uint8_t*)LV2_ATOM_BODY(lv2_pos));
+			}
+
+			if (jalv->request_update) {
+				/* Plugin state has changed, request an update */
+				const LV2_Atom_Object get = {
+					{ sizeof(LV2_Atom_Object_Body), jalv->urids.atom_Object },
+					{ 0, jalv->urids.patch_Get } };
+				lv2_evbuf_write(&iter, 0, 0,
+				                get.atom.type, get.atom.size,
+				                (const uint8_t*)LV2_ATOM_BODY(&get));
+			}
+
+			if (port->sys_port) {
+				/* Write Jack MIDI input */
+				void* buf = jack_port_get_buffer(port->sys_port, nframes);
+				for (uint32_t i = 0; i < jack_midi_get_event_count(buf); ++i) {
+					jack_midi_event_t ev;
+					jack_midi_event_get(&ev, buf, i);
+					lv2_evbuf_write(&iter,
+					                ev.time, 0,
+					                jalv->urids.midi_MidiEvent,
+					                ev.size, ev.buffer);
+				}
+			}
+		} else if (port->type == TYPE_EVENT) {
+			/* Clear event output for plugin to write to */
+			lv2_evbuf_reset(port->evbuf, false);
+		}
+	}
+	jalv->request_update = false;
+
+	/* Run plugin for this cycle */
+	const bool send_ui_updates = jalv_run(jalv, nframes);
+
+	/* Deliver MIDI output and UI events */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* const port = &jalv->ports[p];
+		if (port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL &&
+		    lilv_port_has_property(jalv->plugin, port->lilv_port,
+		                           jalv->nodes.lv2_reportsLatency)) {
+			if (jalv->plugin_latency != port->control) {
+				jalv->plugin_latency = port->control;
+				jack_recompute_total_latencies(client);
+			}
+		} else if (port->flow == FLOW_OUTPUT && port->type == TYPE_EVENT) {
+			void* buf = NULL;
+			if (port->sys_port) {
+				buf = jack_port_get_buffer(port->sys_port, nframes);
+				jack_midi_clear_buffer(buf);
+			}
+
+			for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf);
+			     lv2_evbuf_is_valid(i);
+			     i = lv2_evbuf_next(i)) {
+				// Get event from LV2 buffer
+				uint32_t frames, subframes, type, size;
+				uint8_t* body;
+				lv2_evbuf_get(i, &frames, &subframes, &type, &size, &body);
+
+				if (buf && type == jalv->urids.midi_MidiEvent) {
+					// Write MIDI event to Jack output
+					jack_midi_event_write(buf, frames, body, size);
+				}
+
+				if (jalv->has_ui) {
+					// Forward event to UI
+					jalv_send_to_ui(jalv, p, type, size, body);
+				}
+			}
+		} else if (send_ui_updates &&
+		           port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL) {
+			char buf[sizeof(ControlChange) + sizeof(float)];
+			ControlChange* ev = (ControlChange*)buf;
+			ev->index    = p;
+			ev->protocol = 0;
+			ev->size     = sizeof(float);
+			*(float*)ev->body = port->control;
+			if (zix_ring_write(jalv->plugin_events, buf, sizeof(buf))
+			    < sizeof(buf)) {
+				fprintf(stderr, "Plugin => UI buffer overflow!\n");
+			}
+		}
+	}
+
+	return 0;
+}
+
+/** Calculate latency assuming all ports depend on each other. */
+static void
+jack_latency_cb(jack_latency_callback_mode_t mode, void* data)
+{
+	Jalv* const         jalv = (Jalv*)data;
+	const enum PortFlow flow = ((mode == JackCaptureLatency)
+	                            ? FLOW_INPUT : FLOW_OUTPUT);
+
+	/* First calculate the min/max latency of all feeding ports */
+	uint32_t             ports_found = 0;
+	jack_latency_range_t range       = { UINT32_MAX, 0 };
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* port = &jalv->ports[p];
+		if (port->sys_port && port->flow == flow) {
+			jack_latency_range_t r;
+			jack_port_get_latency_range(port->sys_port, mode, &r);
+			if (r.min < range.min) { range.min = r.min; }
+			if (r.max > range.max) { range.max = r.max; }
+			++ports_found;
+		}
+	}
+
+	if (ports_found == 0) {
+		range.min = 0;
+	}
+
+	/* Add the plugin's own latency */
+	range.min += jalv->plugin_latency;
+	range.max += jalv->plugin_latency;
+
+	/* Tell Jack about it */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* port = &jalv->ports[p];
+		if (port->sys_port && port->flow == flow) {
+			jack_port_set_latency_range(port->sys_port, mode, &range);
+		}
+	}
+}
+
+#ifdef JALV_JACK_SESSION
+static void
+jack_session_cb(jack_session_event_t* event, void* arg)
+{
+	Jalv* const jalv = (Jalv*)arg;
+
+	#define MAX_CMD_LEN 256
+	event->command_line = (char*)malloc(MAX_CMD_LEN);
+	snprintf(event->command_line, MAX_CMD_LEN, "%s -u %s -l \"${SESSION_DIR}\"",
+	         jalv->prog_name,
+	         event->client_uuid);
+
+	switch (event->type) {
+	case JackSessionSave:
+	case JackSessionSaveTemplate:
+		jalv_save(jalv, event->session_dir);
+		break;
+	case JackSessionSaveAndQuit:
+		jalv_save(jalv, event->session_dir);
+		jalv_close_ui(jalv);
+		break;
+	}
+
+	jack_session_reply(jalv->backend->client, event);
+	jack_session_event_free(event);
+}
+#endif /* JALV_JACK_SESSION */
+
+static jack_client_t*
+jack_create_client(Jalv* jalv)
+{
+	jack_client_t* client = NULL;
+
+	/* Determine the name of the JACK client */
+	char* jack_name = NULL;
+	if (jalv->opts.name) {
+		/* Name given on command line */
+		jack_name = jalv_strdup(jalv->opts.name);
+	} else {
+		/* Use plugin name */
+		LilvNode* name = lilv_plugin_get_name(jalv->plugin);
+		jack_name = jalv_strdup(lilv_node_as_string(name));
+		lilv_node_free(name);
+	}
+
+	/* Truncate client name to suit JACK if necessary */
+	if (strlen(jack_name) >= (unsigned)jack_client_name_size() - 1) {
+		jack_name[jack_client_name_size() - 1] = '\0';
+	}
+
+	/* Connect to JACK */
+#ifdef JALV_JACK_SESSION
+	if (jalv->opts.uuid) {
+		client = jack_client_open(
+			jack_name,
+			(jack_options_t)(JackSessionID |
+			                 (jalv->opts.name_exact ? JackUseExactName : 0)),
+			NULL,
+			jalv->opts.uuid);
+	}
+#endif
+
+	if (!client) {
+		client = jack_client_open(
+			jack_name,
+			(jalv->opts.name_exact ? JackUseExactName : JackNullOption),
+			NULL);
+	}
+
+	free(jack_name);
+
+	return client;
+}
+
+JalvBackend*
+jalv_backend_init(Jalv* jalv)
+{
+	jack_client_t* const client =
+		jalv->backend ? jalv->backend->client : jack_create_client(jalv);
+
+	if (!client) {
+		return NULL;
+	}
+
+	printf("JACK Name:    %s\n", jack_get_client_name(client));
+
+	/* Set audio engine properties */
+	jalv->sample_rate   = jack_get_sample_rate(client);
+	jalv->block_length  = jack_get_buffer_size(client);
+	jalv->midi_buf_size = 4096;
+#ifdef HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE
+	jalv->midi_buf_size = jack_port_type_get_buffer_size(
+		client, JACK_DEFAULT_MIDI_TYPE);
+#endif
+
+	/* Set JACK callbacks */
+	void* const arg = (void*)jalv;
+	jack_set_process_callback(client, &jack_process_cb, arg);
+	jack_set_buffer_size_callback(client, &jack_buffer_size_cb, arg);
+	jack_on_shutdown(client, &jack_shutdown_cb, arg);
+	jack_set_latency_callback(client, &jack_latency_cb, arg);
+#ifdef JALV_JACK_SESSION
+	jack_set_session_callback(client, &jack_session_cb, arg);
+#endif
+
+	if (jalv->backend) {
+		/* Internal JACK client, jalv->backend->is_internal_client was already
+		   set in jack_initialize() when allocating the backend */
+		return jalv->backend;
+	}
+
+	/* External JACK client, allocate and return opaque backend */
+	JalvBackend* backend = (JalvBackend*)calloc(1, sizeof(JalvBackend));
+	backend->client             = client;
+	backend->is_internal_client = false;
+	return backend;
+}
+
+void
+jalv_backend_close(Jalv* jalv)
+{
+	if (jalv->backend) {
+		if (!jalv->backend->is_internal_client) {
+			jack_client_close(jalv->backend->client);
+		}
+
+		free(jalv->backend);
+		jalv->backend = NULL;
+	}
+}
+
+void
+jalv_backend_activate(Jalv* jalv)
+{
+	jack_activate(jalv->backend->client);
+}
+
+void
+jalv_backend_deactivate(Jalv* jalv)
+{
+	if (jalv->backend && !jalv->backend->is_internal_client) {
+		jack_deactivate(jalv->backend->client);
+	}
+}
+
+void
+jalv_backend_activate_port(Jalv* jalv, uint32_t port_index)
+{
+	jack_client_t*     client = jalv->backend->client;
+	struct Port* const port   = &jalv->ports[port_index];
+
+	const LilvNode* sym = lilv_port_get_symbol(jalv->plugin, port->lilv_port);
+
+	/* Connect unsupported ports to NULL (known to be optional by this point) */
+	if (port->flow == FLOW_UNKNOWN || port->type == TYPE_UNKNOWN) {
+		lilv_instance_connect_port(jalv->instance, port_index, NULL);
+		return;
+	}
+
+	/* Build Jack flags for port */
+	enum JackPortFlags jack_flags = (port->flow == FLOW_INPUT)
+		? JackPortIsInput
+		: JackPortIsOutput;
+
+	/* Connect the port based on its type */
+	switch (port->type) {
+	case TYPE_CONTROL:
+		lilv_instance_connect_port(jalv->instance, port_index, &port->control);
+		break;
+	case TYPE_AUDIO:
+		port->sys_port = jack_port_register(
+			client, lilv_node_as_string(sym),
+			JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0);
+		break;
+#ifdef HAVE_JACK_METADATA
+	case TYPE_CV:
+		port->sys_port = jack_port_register(
+			client, lilv_node_as_string(sym),
+			JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0);
+		if (port->sys_port) {
+			jack_set_property(client, jack_port_uuid(port->sys_port),
+			                  "http://jackaudio.org/metadata/signal-type", "CV",
+			                  "text/plain");
+		}
+		break;
+#endif
+	case TYPE_EVENT:
+		if (lilv_port_supports_event(
+			    jalv->plugin, port->lilv_port, jalv->nodes.midi_MidiEvent)) {
+			port->sys_port = jack_port_register(
+				client, lilv_node_as_string(sym),
+				JACK_DEFAULT_MIDI_TYPE, jack_flags, 0);
+		}
+		break;
+	default:
+		break;
+	}
+
+#ifdef HAVE_JACK_METADATA
+	if (port->sys_port) {
+		// Set port order to index
+		char index_str[16];
+		snprintf(index_str, sizeof(index_str), "%d", port_index);
+		jack_set_property(client, jack_port_uuid(port->sys_port),
+		                  "http://jackaudio.org/metadata/order", index_str,
+		                  "http://www.w3.org/2001/XMLSchema#integer");
+
+		// Set port pretty name to label
+		LilvNode* name = lilv_port_get_name(jalv->plugin, port->lilv_port);
+		jack_set_property(client, jack_port_uuid(port->sys_port),
+		                  JACK_METADATA_PRETTY_NAME, lilv_node_as_string(name),
+		                  "text/plain");
+		lilv_node_free(name);
+	}
+#endif
+}
+
+int
+jack_initialize(jack_client_t* const client, const char* const load_init)
+{
+	const size_t args_len = strlen(load_init);
+	if (args_len > JACK_LOAD_INIT_LIMIT) {
+		fprintf(stderr, "error: Too many arguments given\n");
+		return -1;
+	}
+
+	Jalv* const jalv = (Jalv*)calloc(1, sizeof(Jalv));
+	if (!jalv) {
+		return -1;
+	}
+
+	if (!(jalv->backend = (JalvBackend*)calloc(1, sizeof(JalvBackend)))) {
+		free(jalv);
+		return -1;
+	}
+
+	jalv->backend->client             = client;
+	jalv->backend->is_internal_client = true;
+
+	/* Build full command line with "program" name for building argv */
+	const size_t cmd_len = strlen("jalv ") + args_len;
+	char* const  cmd     = (char*)calloc(cmd_len + 1, 1);
+	strcat(cmd, "jalv ");
+	strcat(cmd, load_init);
+
+	/* Build argv */
+	int         argc = 0;
+	char**      argv = NULL;
+	char*       tok  = cmd;
+	for (size_t i = 0; i <= cmd_len; ++i) {
+		if (isspace(cmd[i]) || !cmd[i]) {
+			argv = (char**)realloc(argv, sizeof(char*) * ++argc);
+			cmd[i] = '\0';
+			argv[argc - 1] = tok;
+			tok = cmd + i + 1;
+		}
+	}
+
+	const int err = jalv_open(jalv, argc, argv);
+	if (err) {
+		jalv_backend_close(jalv);
+		free(jalv);
+	}
+
+	free(argv);
+	free(cmd);
+	return err;
+}
+
+void
+jack_finish(void* const arg)
+{
+	Jalv* const jalv = (Jalv*)arg;
+	if (jalv) {
+		if (jalv_close(jalv)) {
+			fprintf(stderr, "Failed to close Jalv\n");
+		}
+
+		free(jalv);
+	}
+}
diff --git a/src/jalv.c b/src/jalv.c
new file mode 100644
index 0000000..df7c779
--- /dev/null
+++ b/src/jalv.c
@@ -0,0 +1,1272 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#define _POSIX_C_SOURCE 200809L /* for mkdtemp */
+#define _DARWIN_C_SOURCE        /* for mkdtemp on OSX */
+
+#include <assert.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifndef __cplusplus
+#    include <stdbool.h>
+#endif
+
+#ifdef _WIN32
+#    include <io.h>  /* for _mktemp */
+#    define snprintf _snprintf
+#else
+#    include <unistd.h>
+#endif
+
+#include "jalv_config.h"
+#include "jalv_internal.h"
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+#include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
+#include "lv2/lv2plug.in/ns/ext/data-access/data-access.h"
+#include "lv2/lv2plug.in/ns/ext/options/options.h"
+#include "lv2/lv2plug.in/ns/ext/parameters/parameters.h"
+#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
+#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
+#include "lv2/lv2plug.in/ns/ext/presets/presets.h"
+#include "lv2/lv2plug.in/ns/ext/state/state.h"
+#include "lv2/lv2plug.in/ns/ext/time/time.h"
+#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+#include "lv2/lv2plug.in/ns/ext/worker/worker.h"
+#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
+
+#include "lilv/lilv.h"
+
+#ifdef HAVE_SUIL
+#include "suil/suil.h"
+#endif
+
+#include "lv2_evbuf.h"
+#include "worker.h"
+
+#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_XSD "http://www.w3.org/2001/XMLSchema#"
+
+#ifndef MIN
+#    define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef MAX
+#    define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+
+#ifndef ARRAY_SIZE
+#    define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
+#endif
+
+/* Size factor for UI ring buffers.  The ring size is a few times the size of
+   an event output to give the UI a chance to keep up.  Experiments with Ingen,
+   which can highly saturate its event output, led me to this value.  It
+   really ought to be enough for anybody(TM).
+*/
+#define N_BUFFER_CYCLES 16
+
+static ZixSem* exit_sem = NULL;  /**< Exit semaphore used by signal handler*/
+
+static LV2_URID
+map_uri(LV2_URID_Map_Handle handle,
+        const char*         uri)
+{
+	Jalv* jalv = (Jalv*)handle;
+	zix_sem_wait(&jalv->symap_lock);
+	const LV2_URID id = symap_map(jalv->symap, uri);
+	zix_sem_post(&jalv->symap_lock);
+	return id;
+}
+
+static const char*
+unmap_uri(LV2_URID_Unmap_Handle handle,
+          LV2_URID              urid)
+{
+	Jalv* jalv = (Jalv*)handle;
+	zix_sem_wait(&jalv->symap_lock);
+	const char* uri = symap_unmap(jalv->symap, urid);
+	zix_sem_post(&jalv->symap_lock);
+	return uri;
+}
+
+#define NS_EXT "http://lv2plug.in/ns/ext/"
+
+/** These features have no data */
+static const LV2_Feature static_features[] = {
+	{ LV2_STATE__loadDefaultState, NULL },
+	{ LV2_BUF_SIZE__powerOf2BlockLength, NULL },
+	{ LV2_BUF_SIZE__fixedBlockLength, NULL },
+	{ LV2_BUF_SIZE__boundedBlockLength, NULL } };
+
+/** Return true iff Jalv supports the given feature. */
+static bool
+feature_is_supported(Jalv* jalv, const char* uri)
+{
+	if (!strcmp(uri, "http://lv2plug.in/ns/lv2core#isLive")) {
+		return true;
+	}
+
+	for (const LV2_Feature*const* f = jalv->feature_list; *f; ++f) {
+		if (!strcmp(uri, (*f)->URI)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/** Abort and exit on error */
+static void
+die(const char* msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(EXIT_FAILURE);
+}
+
+/**
+   Create a port structure from data description.  This is called before plugin
+   and Jack instantiation.  The remaining instance-specific setup
+   (e.g. buffers) is done later in activate_port().
+*/
+static void
+create_port(Jalv*    jalv,
+            uint32_t port_index,
+            float    default_value)
+{
+	struct Port* const port = &jalv->ports[port_index];
+
+	port->lilv_port = lilv_plugin_get_port_by_index(jalv->plugin, port_index);
+	port->sys_port  = NULL;
+	port->evbuf     = NULL;
+	port->buf_size  = 0;
+	port->index     = port_index;
+	port->control   = 0.0f;
+	port->flow      = FLOW_UNKNOWN;
+
+	const bool optional = lilv_port_has_property(
+		jalv->plugin, port->lilv_port, jalv->nodes.lv2_connectionOptional);
+
+	/* Set the port flow (input or output) */
+	if (lilv_port_is_a(jalv->plugin, port->lilv_port, jalv->nodes.lv2_InputPort)) {
+		port->flow = FLOW_INPUT;
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.lv2_OutputPort)) {
+		port->flow = FLOW_OUTPUT;
+	} else if (!optional) {
+		die("Mandatory port has unknown type (neither input nor output)");
+	}
+
+	const bool hidden = !jalv->opts.show_hidden &&
+	                    lilv_port_has_property(jalv->plugin,
+	                                           port->lilv_port,
+	                                           jalv->nodes.pprops_notOnGUI);
+
+	/* Set control values */
+	if (lilv_port_is_a(jalv->plugin, port->lilv_port, jalv->nodes.lv2_ControlPort)) {
+		port->type    = TYPE_CONTROL;
+		port->control = isnan(default_value) ? 0.0f : default_value;
+		if (!hidden) {
+			add_control(&jalv->controls, new_port_control(jalv, port->index));
+		}
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.lv2_AudioPort)) {
+		port->type = TYPE_AUDIO;
+#ifdef HAVE_JACK_METADATA
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.lv2_CVPort)) {
+		port->type = TYPE_CV;
+#endif
+	} else if (lilv_port_is_a(jalv->plugin, port->lilv_port,
+	                          jalv->nodes.atom_AtomPort)) {
+		port->type = TYPE_EVENT;
+	} else if (!optional) {
+		die("Mandatory port has unknown data type");
+	}
+
+	LilvNode* min_size = lilv_port_get(
+		jalv->plugin, port->lilv_port, jalv->nodes.rsz_minimumSize);
+	if (min_size && lilv_node_is_int(min_size)) {
+		port->buf_size = lilv_node_as_int(min_size);
+		jalv->opts.buffer_size = MAX(
+			jalv->opts.buffer_size, port->buf_size * N_BUFFER_CYCLES);
+	}
+	lilv_node_free(min_size);
+}
+
+/**
+   Create port structures from data (via create_port()) for all ports.
+*/
+void
+jalv_create_ports(Jalv* jalv)
+{
+	jalv->num_ports = lilv_plugin_get_num_ports(jalv->plugin);
+	jalv->ports     = (struct Port*)calloc(jalv->num_ports, sizeof(struct Port));
+	float* default_values = (float*)calloc(
+		lilv_plugin_get_num_ports(jalv->plugin), sizeof(float));
+	lilv_plugin_get_port_ranges_float(jalv->plugin, NULL, NULL, default_values);
+
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		create_port(jalv, i, default_values[i]);
+	}
+
+	const LilvPort* control_input = lilv_plugin_get_port_by_designation(
+		jalv->plugin, jalv->nodes.lv2_InputPort, jalv->nodes.lv2_control);
+	if (control_input) {
+		jalv->control_in = lilv_port_get_index(jalv->plugin, control_input);
+	}
+
+	free(default_values);
+}
+
+/**
+   Allocate port buffers (only necessary for MIDI).
+*/
+void
+jalv_allocate_port_buffers(Jalv* jalv)
+{
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		struct Port* const port     = &jalv->ports[i];
+		switch (port->type) {
+		case TYPE_EVENT: {
+			lv2_evbuf_free(port->evbuf);
+			const size_t buf_size = (port->buf_size > 0)
+				? port->buf_size
+				: jalv->midi_buf_size;
+			port->evbuf = lv2_evbuf_new(
+				buf_size,
+				jalv->map.map(jalv->map.handle,
+				              lilv_node_as_string(jalv->nodes.atom_Chunk)),
+				jalv->map.map(jalv->map.handle,
+				              lilv_node_as_string(jalv->nodes.atom_Sequence)));
+			lilv_instance_connect_port(
+				jalv->instance, i, lv2_evbuf_get_buffer(port->evbuf));
+		}
+		default: break;
+		}
+	}
+}
+
+/**
+   Get a port structure by symbol.
+
+   TODO: Build an index to make this faster, currently O(n) which may be
+   a problem when restoring the state of plugins with many ports.
+*/
+struct Port*
+jalv_port_by_symbol(Jalv* jalv, const char* sym)
+{
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		struct Port* const port     = &jalv->ports[i];
+		const LilvNode*    port_sym = lilv_port_get_symbol(jalv->plugin,
+		                                                   port->lilv_port);
+
+		if (!strcmp(lilv_node_as_string(port_sym), sym)) {
+			return port;
+		}
+	}
+
+	return NULL;
+}
+
+ControlID*
+jalv_control_by_symbol(Jalv* jalv, const char* sym)
+{
+	for (size_t i = 0; i < jalv->controls.n_controls; ++i) {
+		if (!strcmp(lilv_node_as_string(jalv->controls.controls[i]->symbol),
+		            sym)) {
+			return jalv->controls.controls[i];
+		}
+	}
+	return NULL;
+}
+
+void
+jalv_create_controls(Jalv* jalv, bool writable)
+{
+	const LilvPlugin* plugin         = jalv->plugin;
+	LilvWorld*        world          = jalv->world;
+	LilvNode*         patch_writable = lilv_new_uri(world, LV2_PATCH__writable);
+	LilvNode*         patch_readable = lilv_new_uri(world, LV2_PATCH__readable);
+
+	LilvNodes* properties = lilv_world_find_nodes(
+		world,
+		lilv_plugin_get_uri(plugin),
+		writable ? patch_writable : patch_readable,
+		NULL);
+	LILV_FOREACH(nodes, p, properties) {
+		const LilvNode* property = lilv_nodes_get(properties, p);
+		ControlID*      record   = NULL;
+
+		if (!writable && lilv_world_ask(world,
+		                                lilv_plugin_get_uri(plugin),
+		                                patch_writable,
+		                                property)) {
+			// Find existing writable control
+			for (size_t i = 0; i < jalv->controls.n_controls; ++i) {
+				if (lilv_node_equals(jalv->controls.controls[i]->node, property)) {
+					record              = jalv->controls.controls[i];
+					record->is_readable = true;
+					break;
+				}
+			}
+
+			if (record) {
+				continue;
+			}
+		}
+
+		record = new_property_control(jalv, property);
+		if (writable) {
+			record->is_writable = true;
+		} else {
+			record->is_readable = true;
+		}
+
+		if (record->value_type) {
+			add_control(&jalv->controls, record);
+		} else {
+			fprintf(stderr, "Parameter <%s> has unknown value type, ignored\n",
+			        lilv_node_as_string(record->node));
+			free(record);
+		}
+	}
+	lilv_nodes_free(properties);
+
+	lilv_node_free(patch_readable);
+	lilv_node_free(patch_writable);
+}
+
+void
+jalv_set_control(const ControlID* control,
+                 uint32_t         size,
+                 LV2_URID         type,
+                 const void*      body)
+{
+	Jalv* jalv = control->jalv;
+	if (control->type == PORT && type == jalv->forge.Float) {
+		struct Port* port = &control->jalv->ports[control->index];
+		port->control = *(const float*)body;
+	} else if (control->type == PROPERTY) {
+		// Copy forge since it is used by process thread
+		LV2_Atom_Forge       forge = jalv->forge;
+		LV2_Atom_Forge_Frame frame;
+		uint8_t              buf[1024];
+		lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf));
+
+		lv2_atom_forge_object(&forge, &frame, 0, jalv->urids.patch_Set);
+		lv2_atom_forge_key(&forge, jalv->urids.patch_property);
+		lv2_atom_forge_urid(&forge, control->property);
+		lv2_atom_forge_key(&forge, jalv->urids.patch_value);
+		lv2_atom_forge_atom(&forge, size, type);
+		lv2_atom_forge_write(&forge, body, size);
+
+		const LV2_Atom* atom = lv2_atom_forge_deref(&forge, frame.ref);
+		jalv_ui_write(jalv,
+		              jalv->control_in,
+		              lv2_atom_total_size(atom),
+		              jalv->urids.atom_eventTransfer,
+		              atom);
+	}
+}
+
+void
+jalv_ui_instantiate(Jalv* jalv, const char* native_ui_type, void* parent)
+{
+#ifdef HAVE_SUIL
+	jalv->ui_host = suil_host_new(jalv_ui_write, jalv_ui_port_index, NULL, NULL);
+
+	const LV2_Feature parent_feature = {
+		LV2_UI__parent, parent
+	};
+	const LV2_Feature instance_feature = {
+		NS_EXT "instance-access", lilv_instance_get_handle(jalv->instance)
+	};
+	const LV2_Feature data_feature = {
+		LV2_DATA_ACCESS_URI, &jalv->features.ext_data
+	};
+	const LV2_Feature idle_feature = {
+		LV2_UI__idleInterface, NULL
+	};
+	const LV2_Feature* ui_features[] = {
+		&jalv->features.map_feature,
+		&jalv->features.unmap_feature,
+		&instance_feature,
+		&data_feature,
+		&jalv->features.log_feature,
+		&parent_feature,
+		&jalv->features.options_feature,
+		&idle_feature,
+		NULL
+	};
+
+	const char* bundle_uri  = lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui));
+	const char* binary_uri  = lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui));
+	char*       bundle_path = lilv_file_uri_parse(bundle_uri, NULL);
+	char*       binary_path = lilv_file_uri_parse(binary_uri, NULL);
+
+	jalv->ui_instance = suil_instance_new(
+		jalv->ui_host,
+		jalv,
+		native_ui_type,
+		lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)),
+		lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)),
+		lilv_node_as_uri(jalv->ui_type),
+		bundle_path,
+		binary_path,
+		ui_features);
+
+	lilv_free(binary_path);
+	lilv_free(bundle_path);
+#endif
+}
+
+bool
+jalv_ui_is_resizable(Jalv* jalv)
+{
+	if (!jalv->ui) {
+		return false;
+	}
+
+	const LilvNode* s   = lilv_ui_get_uri(jalv->ui);
+	LilvNode*       p   = lilv_new_uri(jalv->world, LV2_CORE__optionalFeature);
+	LilvNode*       fs  = lilv_new_uri(jalv->world, LV2_UI__fixedSize);
+	LilvNode*       nrs = lilv_new_uri(jalv->world, LV2_UI__noUserResize);
+
+	LilvNodes* fs_matches = lilv_world_find_nodes(jalv->world, s, p, fs);
+	LilvNodes* nrs_matches = lilv_world_find_nodes(jalv->world, s, p, nrs);
+
+	lilv_nodes_free(nrs_matches);
+	lilv_nodes_free(fs_matches);
+	lilv_node_free(nrs);
+	lilv_node_free(fs);
+	lilv_node_free(p);
+
+	return !fs_matches && !nrs_matches;
+}
+
+void
+jalv_ui_write(void* const    jalv_handle,
+              uint32_t       port_index,
+              uint32_t       buffer_size,
+              uint32_t       protocol,
+              const void*    buffer)
+{
+	Jalv* const jalv = (Jalv*)jalv_handle;
+
+	if (protocol != 0 && protocol != jalv->urids.atom_eventTransfer) {
+		fprintf(stderr, "UI write with unsupported protocol %d (%s)\n",
+		        protocol, unmap_uri(jalv, protocol));
+		return;
+	}
+
+	if (port_index >= jalv->num_ports) {
+		fprintf(stderr, "UI write to out of range port index %d\n",
+		        port_index);
+		return;
+	}
+
+	if (jalv->opts.dump && protocol == jalv->urids.atom_eventTransfer) {
+		const LV2_Atom* atom = (const LV2_Atom*)buffer;
+		char*           str  = sratom_to_turtle(
+			jalv->sratom, &jalv->unmap, "jalv:", NULL, NULL,
+			atom->type, atom->size, LV2_ATOM_BODY_CONST(atom));
+		jalv_ansi_start(stdout, 36);
+		printf("\n## UI => Plugin (%u bytes) ##\n%s\n", atom->size, str);
+		jalv_ansi_reset(stdout);
+		free(str);
+	}
+
+	char buf[sizeof(ControlChange) + buffer_size];
+	ControlChange* ev = (ControlChange*)buf;
+	ev->index    = port_index;
+	ev->protocol = protocol;
+	ev->size     = buffer_size;
+	memcpy(ev->body, buffer, buffer_size);
+	zix_ring_write(jalv->ui_events, buf, sizeof(buf));
+}
+
+void
+jalv_apply_ui_events(Jalv* jalv, uint32_t nframes)
+{
+	if (!jalv->has_ui) {
+		return;
+	}
+
+	ControlChange ev;
+	const size_t  space = zix_ring_read_space(jalv->ui_events);
+	for (size_t i = 0; i < space; i += sizeof(ev) + ev.size) {
+		zix_ring_read(jalv->ui_events, (char*)&ev, sizeof(ev));
+		char body[ev.size];
+		if (zix_ring_read(jalv->ui_events, body, ev.size) != ev.size) {
+			fprintf(stderr, "error: Error reading from UI ring buffer\n");
+			break;
+		}
+		assert(ev.index < jalv->num_ports);
+		struct Port* const port = &jalv->ports[ev.index];
+		if (ev.protocol == 0) {
+			assert(ev.size == sizeof(float));
+			port->control = *(float*)body;
+		} else if (ev.protocol == jalv->urids.atom_eventTransfer) {
+			LV2_Evbuf_Iterator    e    = lv2_evbuf_end(port->evbuf);
+			const LV2_Atom* const atom = (const LV2_Atom*)body;
+			lv2_evbuf_write(&e, nframes, 0, atom->type, atom->size,
+			                (const uint8_t*)LV2_ATOM_BODY_CONST(atom));
+		} else {
+			fprintf(stderr, "error: Unknown control change protocol %d\n",
+			        ev.protocol);
+		}
+	}
+}
+
+uint32_t
+jalv_ui_port_index(void* const controller, const char* symbol)
+{
+	Jalv* const  jalv = (Jalv*)controller;
+	struct Port* port = jalv_port_by_symbol(jalv, symbol);
+
+	return port ? port->index : LV2UI_INVALID_PORT_INDEX;
+}
+
+void
+jalv_init_ui(Jalv* jalv)
+{
+	// Set initial control port values
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		if (jalv->ports[i].type == TYPE_CONTROL) {
+			jalv_ui_port_event(jalv, i,
+			                   sizeof(float), 0,
+			                   &jalv->ports[i].control);
+		}
+	}
+
+	if (jalv->control_in != (uint32_t)-1) {
+		// Send patch:Get message for initial parameters/etc
+		LV2_Atom_Forge       forge = jalv->forge;
+		LV2_Atom_Forge_Frame frame;
+		uint8_t              buf[1024];
+		lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf));
+		lv2_atom_forge_object(&forge, &frame, 0, jalv->urids.patch_Get);
+
+		const LV2_Atom* atom = lv2_atom_forge_deref(&forge, frame.ref);
+		jalv_ui_write(jalv,
+		              jalv->control_in,
+		              lv2_atom_total_size(atom),
+		              jalv->urids.atom_eventTransfer,
+		              atom);
+		lv2_atom_forge_pop(&forge, &frame);
+	}
+}
+
+bool
+jalv_send_to_ui(Jalv*       jalv,
+                uint32_t    port_index,
+                uint32_t    type,
+                uint32_t    size,
+                const void* body)
+{
+	/* TODO: Be more disciminate about what to send */
+	char evbuf[sizeof(ControlChange) + sizeof(LV2_Atom)];
+	ControlChange* ev = (ControlChange*)evbuf;
+	ev->index    = port_index;
+	ev->protocol = jalv->urids.atom_eventTransfer;
+	ev->size     = sizeof(LV2_Atom) + size;
+
+	LV2_Atom* atom = (LV2_Atom*)ev->body;
+	atom->type = type;
+	atom->size = size;
+
+	if (zix_ring_write_space(jalv->plugin_events) >= sizeof(evbuf) + size) {
+		zix_ring_write(jalv->plugin_events, evbuf, sizeof(evbuf));
+		zix_ring_write(jalv->plugin_events, (const char*)body, size);
+		return true;
+	} else {
+		fprintf(stderr, "Plugin => UI buffer overflow!\n");
+		return false;
+	}
+}
+
+bool
+jalv_run(Jalv* jalv, uint32_t nframes)
+{
+	/* Read and apply control change events from UI */
+	jalv_apply_ui_events(jalv, nframes);
+
+	/* Run plugin for this cycle */
+	lilv_instance_run(jalv->instance, nframes);
+
+	/* Process any worker replies. */
+	jalv_worker_emit_responses(&jalv->state_worker, jalv->instance);
+	jalv_worker_emit_responses(&jalv->worker, jalv->instance);
+
+	/* Notify the plugin the run() cycle is finished */
+	if (jalv->worker.iface && jalv->worker.iface->end_run) {
+		jalv->worker.iface->end_run(jalv->instance->lv2_handle);
+	}
+
+	/* Check if it's time to send updates to the UI */
+	jalv->event_delta_t += nframes;
+	bool     send_ui_updates = false;
+	uint32_t update_frames   = jalv->sample_rate / jalv->ui_update_hz;
+	if (jalv->has_ui && (jalv->event_delta_t > update_frames)) {
+		send_ui_updates = true;
+		jalv->event_delta_t = 0;
+	}
+
+	return send_ui_updates;
+}
+
+bool
+jalv_update(Jalv* jalv)
+{
+	/* Check quit flag and close if set. */
+	if (zix_sem_try_wait(&jalv->done)) {
+		jalv_close_ui(jalv);
+		return false;
+	}
+
+	/* Emit UI events. */
+	ControlChange ev;
+	const size_t  space = zix_ring_read_space(jalv->plugin_events);
+	for (size_t i = 0;
+	     i + sizeof(ev) < space;
+	     i += sizeof(ev) + ev.size) {
+		/* Read event header to get the size */
+		zix_ring_read(jalv->plugin_events, (char*)&ev, sizeof(ev));
+
+		/* Resize read buffer if necessary */
+		jalv->ui_event_buf = realloc(jalv->ui_event_buf, ev.size);
+		void* const buf = jalv->ui_event_buf;
+
+		/* Read event body */
+		zix_ring_read(jalv->plugin_events, (char*)buf, ev.size);
+
+		if (jalv->opts.dump && ev.protocol == jalv->urids.atom_eventTransfer) {
+			/* Dump event in Turtle to the console */
+			LV2_Atom* atom = (LV2_Atom*)buf;
+			char*     str  = sratom_to_turtle(
+				jalv->ui_sratom, &jalv->unmap, "jalv:", NULL, NULL,
+				atom->type, atom->size, LV2_ATOM_BODY(atom));
+			jalv_ansi_start(stdout, 35);
+			printf("\n## Plugin => UI (%u bytes) ##\n%s\n", atom->size, str);
+			jalv_ansi_reset(stdout);
+			free(str);
+		}
+
+		jalv_ui_port_event(jalv, ev.index, ev.size, ev.protocol, buf);
+
+		if (ev.protocol == 0 && jalv->opts.print_controls) {
+			jalv_print_control(jalv, &jalv->ports[ev.index], *(float*)buf);
+		}
+	}
+
+	return true;
+}
+
+static bool
+jalv_apply_control_arg(Jalv* jalv, const char* s)
+{
+	char  sym[256];
+	float val = 0.0f;
+	if (sscanf(s, "%[^=]=%f", sym, &val) != 2) {
+		fprintf(stderr, "warning: Ignoring invalid value `%s'\n", s);
+		return false;
+	}
+
+	ControlID* control = jalv_control_by_symbol(jalv, sym);
+	if (!control) {
+		fprintf(stderr, "warning: Ignoring value for unknown control `%s'\n", sym);
+		return false;
+	}
+
+	jalv_set_control(control, sizeof(float), jalv->urids.atom_Float, &val);
+	printf("%s = %f\n", sym, val);
+
+	return true;
+}
+
+static void
+signal_handler(ZIX_UNUSED int sig)
+{
+	zix_sem_post(exit_sem);
+}
+
+static void
+init_feature(LV2_Feature* const dest, const char* const URI, void* data)
+{
+	dest->URI = URI;
+	dest->data = data;
+}
+
+static void
+setup_signals(Jalv* const jalv)
+{
+	exit_sem = &jalv->done;
+
+#ifdef HAVE_SIGACTION
+	struct sigaction action;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags   = 0;
+	action.sa_handler = signal_handler;
+	sigaction(SIGINT, &action, NULL);
+	sigaction(SIGTERM, &action, NULL);
+#else
+	/* May not work in combination with fgets in the console interface */
+	signal(SIGINT, signal_handler);
+	signal(SIGTERM, signal_handler);
+#endif
+}
+
+int
+jalv_open(Jalv* const jalv, int argc, char** argv)
+{
+	jalv->prog_name     = argv[0];
+	jalv->block_length  = 4096;  /* Should be set by backend */
+	jalv->midi_buf_size = 1024;  /* Should be set by backend */
+	jalv->play_state    = JALV_PAUSED;
+	jalv->bpm           = 120.0f;
+	jalv->control_in    = (uint32_t)-1;
+
+#ifdef HAVE_SUIL
+	suil_init(&argc, &argv, SUIL_ARG_NONE);
+#endif
+
+	if (jalv_init(&argc, &argv, &jalv->opts)) {
+		jalv_close(jalv);
+		return -1;
+	}
+
+	if (jalv->opts.uuid) {
+		printf("UUID: %s\n", jalv->opts.uuid);
+	}
+
+	jalv->symap = symap_new();
+	zix_sem_init(&jalv->symap_lock, 1);
+	zix_sem_init(&jalv->work_lock, 1);
+
+	jalv->map.handle  = jalv;
+	jalv->map.map     = map_uri;
+	init_feature(&jalv->features.map_feature, LV2_URID__map, &jalv->map);
+
+	jalv->worker.jalv       = jalv;
+	jalv->state_worker.jalv = jalv;
+
+	jalv->unmap.handle  = jalv;
+	jalv->unmap.unmap   = unmap_uri;
+	init_feature(&jalv->features.unmap_feature, LV2_URID__unmap, &jalv->unmap);
+
+	lv2_atom_forge_init(&jalv->forge, &jalv->map);
+
+	jalv->env = serd_env_new(NULL);
+	serd_env_set_prefix_from_strings(
+		jalv->env, (const uint8_t*)"patch", (const uint8_t*)LV2_PATCH_PREFIX);
+	serd_env_set_prefix_from_strings(
+		jalv->env, (const uint8_t*)"time", (const uint8_t*)LV2_TIME_PREFIX);
+	serd_env_set_prefix_from_strings(
+		jalv->env, (const uint8_t*)"xsd", (const uint8_t*)NS_XSD);
+
+	jalv->sratom    = sratom_new(&jalv->map);
+	jalv->ui_sratom = sratom_new(&jalv->map);
+	sratom_set_env(jalv->sratom, jalv->env);
+	sratom_set_env(jalv->ui_sratom, jalv->env);
+
+	jalv->urids.atom_Float           = symap_map(jalv->symap, LV2_ATOM__Float);
+	jalv->urids.atom_Int             = symap_map(jalv->symap, LV2_ATOM__Int);
+	jalv->urids.atom_Object          = symap_map(jalv->symap, LV2_ATOM__Object);
+	jalv->urids.atom_Path            = symap_map(jalv->symap, LV2_ATOM__Path);
+	jalv->urids.atom_String          = symap_map(jalv->symap, LV2_ATOM__String);
+	jalv->urids.atom_eventTransfer   = symap_map(jalv->symap, LV2_ATOM__eventTransfer);
+	jalv->urids.bufsz_maxBlockLength = symap_map(jalv->symap, LV2_BUF_SIZE__maxBlockLength);
+	jalv->urids.bufsz_minBlockLength = symap_map(jalv->symap, LV2_BUF_SIZE__minBlockLength);
+	jalv->urids.bufsz_sequenceSize   = symap_map(jalv->symap, LV2_BUF_SIZE__sequenceSize);
+	jalv->urids.log_Error            = symap_map(jalv->symap, LV2_LOG__Error);
+	jalv->urids.log_Trace            = symap_map(jalv->symap, LV2_LOG__Trace);
+	jalv->urids.log_Warning          = symap_map(jalv->symap, LV2_LOG__Warning);
+	jalv->urids.midi_MidiEvent       = symap_map(jalv->symap, LV2_MIDI__MidiEvent);
+	jalv->urids.param_sampleRate     = symap_map(jalv->symap, LV2_PARAMETERS__sampleRate);
+	jalv->urids.patch_Get            = symap_map(jalv->symap, LV2_PATCH__Get);
+	jalv->urids.patch_Put            = symap_map(jalv->symap, LV2_PATCH__Put);
+	jalv->urids.patch_Set            = symap_map(jalv->symap, LV2_PATCH__Set);
+	jalv->urids.patch_body           = symap_map(jalv->symap, LV2_PATCH__body);
+	jalv->urids.patch_property       = symap_map(jalv->symap, LV2_PATCH__property);
+	jalv->urids.patch_value          = symap_map(jalv->symap, LV2_PATCH__value);
+	jalv->urids.time_Position        = symap_map(jalv->symap, LV2_TIME__Position);
+	jalv->urids.time_bar             = symap_map(jalv->symap, LV2_TIME__bar);
+	jalv->urids.time_barBeat         = symap_map(jalv->symap, LV2_TIME__barBeat);
+	jalv->urids.time_beatUnit        = symap_map(jalv->symap, LV2_TIME__beatUnit);
+	jalv->urids.time_beatsPerBar     = symap_map(jalv->symap, LV2_TIME__beatsPerBar);
+	jalv->urids.time_beatsPerMinute  = symap_map(jalv->symap, LV2_TIME__beatsPerMinute);
+	jalv->urids.time_frame           = symap_map(jalv->symap, LV2_TIME__frame);
+	jalv->urids.time_speed           = symap_map(jalv->symap, LV2_TIME__speed);
+	jalv->urids.ui_updateRate        = symap_map(jalv->symap, LV2_UI__updateRate);
+
+#ifdef _WIN32
+	jalv->temp_dir = jalv_strdup("jalvXXXXXX");
+	_mktemp(jalv->temp_dir);
+#else
+	char* templ = jalv_strdup("/tmp/jalv-XXXXXX");
+	jalv->temp_dir = jalv_strjoin(mkdtemp(templ), "/");
+	free(templ);
+#endif
+
+	jalv->features.make_path.handle = jalv;
+	jalv->features.make_path.path = jalv_make_path;
+	init_feature(&jalv->features.make_path_feature,
+	             LV2_STATE__makePath, &jalv->features.make_path);
+
+	jalv->features.sched.handle = &jalv->worker;
+	jalv->features.sched.schedule_work = jalv_worker_schedule;
+	init_feature(&jalv->features.sched_feature,
+	             LV2_WORKER__schedule, &jalv->features.sched);
+
+	jalv->features.ssched.handle = &jalv->state_worker;
+	jalv->features.ssched.schedule_work = jalv_worker_schedule;
+	init_feature(&jalv->features.state_sched_feature,
+	             LV2_WORKER__schedule, &jalv->features.ssched);
+
+	jalv->features.llog.handle  = jalv;
+	jalv->features.llog.printf  = jalv_printf;
+	jalv->features.llog.vprintf = jalv_vprintf;
+	init_feature(&jalv->features.log_feature,
+	             LV2_LOG__log, &jalv->features.llog);
+
+	zix_sem_init(&jalv->done, 0);
+
+	zix_sem_init(&jalv->paused, 0);
+	zix_sem_init(&jalv->worker.sem, 0);
+
+	/* Find all installed plugins */
+	LilvWorld* world = lilv_world_new();
+	lilv_world_load_all(world);
+	jalv->world = world;
+	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+
+	/* Cache URIs for concepts we'll use */
+	jalv->nodes.atom_AtomPort          = lilv_new_uri(world, LV2_ATOM__AtomPort);
+	jalv->nodes.atom_Chunk             = lilv_new_uri(world, LV2_ATOM__Chunk);
+	jalv->nodes.atom_Float             = lilv_new_uri(world, LV2_ATOM__Float);
+	jalv->nodes.atom_Path              = lilv_new_uri(world, LV2_ATOM__Path);
+	jalv->nodes.atom_Sequence          = lilv_new_uri(world, LV2_ATOM__Sequence);
+	jalv->nodes.lv2_AudioPort          = lilv_new_uri(world, LV2_CORE__AudioPort);
+	jalv->nodes.lv2_CVPort             = lilv_new_uri(world, LV2_CORE__CVPort);
+	jalv->nodes.lv2_ControlPort        = lilv_new_uri(world, LV2_CORE__ControlPort);
+	jalv->nodes.lv2_InputPort          = lilv_new_uri(world, LV2_CORE__InputPort);
+	jalv->nodes.lv2_OutputPort         = lilv_new_uri(world, LV2_CORE__OutputPort);
+	jalv->nodes.lv2_connectionOptional = lilv_new_uri(world, LV2_CORE__connectionOptional);
+	jalv->nodes.lv2_control            = lilv_new_uri(world, LV2_CORE__control);
+	jalv->nodes.lv2_default            = lilv_new_uri(world, LV2_CORE__default);
+	jalv->nodes.lv2_enumeration        = lilv_new_uri(world, LV2_CORE__enumeration);
+	jalv->nodes.lv2_integer            = lilv_new_uri(world, LV2_CORE__integer);
+	jalv->nodes.lv2_maximum            = lilv_new_uri(world, LV2_CORE__maximum);
+	jalv->nodes.lv2_minimum            = lilv_new_uri(world, LV2_CORE__minimum);
+	jalv->nodes.lv2_name               = lilv_new_uri(world, LV2_CORE__name);
+	jalv->nodes.lv2_reportsLatency     = lilv_new_uri(world, LV2_CORE__reportsLatency);
+	jalv->nodes.lv2_sampleRate         = lilv_new_uri(world, LV2_CORE__sampleRate);
+	jalv->nodes.lv2_symbol             = lilv_new_uri(world, LV2_CORE__symbol);
+	jalv->nodes.lv2_toggled            = lilv_new_uri(world, LV2_CORE__toggled);
+	jalv->nodes.midi_MidiEvent         = lilv_new_uri(world, LV2_MIDI__MidiEvent);
+	jalv->nodes.pg_group               = lilv_new_uri(world, LV2_PORT_GROUPS__group);
+	jalv->nodes.pprops_logarithmic     = lilv_new_uri(world, LV2_PORT_PROPS__logarithmic);
+	jalv->nodes.pprops_notOnGUI        = lilv_new_uri(world, LV2_PORT_PROPS__notOnGUI);
+	jalv->nodes.pprops_rangeSteps      = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
+	jalv->nodes.pset_Preset            = lilv_new_uri(world, LV2_PRESETS__Preset);
+	jalv->nodes.pset_bank              = lilv_new_uri(world, LV2_PRESETS__bank);
+	jalv->nodes.rdfs_comment           = lilv_new_uri(world, LILV_NS_RDFS "comment");
+	jalv->nodes.rdfs_label             = lilv_new_uri(world, LILV_NS_RDFS "label");
+	jalv->nodes.rdfs_range             = lilv_new_uri(world, LILV_NS_RDFS "range");
+	jalv->nodes.rsz_minimumSize        = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);
+	jalv->nodes.work_interface         = lilv_new_uri(world, LV2_WORKER__interface);
+	jalv->nodes.work_schedule          = lilv_new_uri(world, LV2_WORKER__schedule);
+	jalv->nodes.end                    = NULL;
+
+	/* Get plugin URI from loaded state or command line */
+	LilvState* state      = NULL;
+	LilvNode*  plugin_uri = NULL;
+	if (jalv->opts.load) {
+		struct stat info;
+		stat(jalv->opts.load, &info);
+		if (S_ISDIR(info.st_mode)) {
+			char* path = jalv_strjoin(jalv->opts.load, "/state.ttl");
+			state = lilv_state_new_from_file(jalv->world, &jalv->map, NULL, path);
+			free(path);
+		} else {
+			state = lilv_state_new_from_file(jalv->world, &jalv->map, NULL,
+			                                 jalv->opts.load);
+		}
+		if (!state) {
+			fprintf(stderr, "Failed to load state from %s\n", jalv->opts.load);
+			jalv_close(jalv);
+			return -2;
+		}
+		plugin_uri = lilv_node_duplicate(lilv_state_get_plugin_uri(state));
+	} else if (argc > 1) {
+		plugin_uri = lilv_new_uri(world, argv[argc - 1]);
+	}
+
+	if (!plugin_uri) {
+		fprintf(stderr, "Missing plugin URI, try lv2ls to list plugins\n");
+		jalv_close(jalv);
+		return -3;
+	}
+
+	/* Find plugin */
+	printf("Plugin:       %s\n", lilv_node_as_string(plugin_uri));
+	jalv->plugin = lilv_plugins_get_by_uri(plugins, plugin_uri);
+	lilv_node_free(plugin_uri);
+	if (!jalv->plugin) {
+		fprintf(stderr, "Failed to find plugin\n");
+		jalv_close(jalv);
+		return -4;
+	}
+
+	/* Load preset, if specified */
+	if (jalv->opts.preset) {
+		LilvNode* preset = lilv_new_uri(jalv->world, jalv->opts.preset);
+
+		jalv_load_presets(jalv, NULL, NULL);
+		state = lilv_state_new_from_world(jalv->world, &jalv->map, preset);
+		jalv->preset = state;
+		lilv_node_free(preset);
+		if (!state) {
+			fprintf(stderr, "Failed to find preset <%s>\n", jalv->opts.preset);
+			jalv_close(jalv);
+			return -5;
+		}
+	}
+
+	/* Check for thread-safe state restore() method. */
+	LilvNode* state_threadSafeRestore = lilv_new_uri(
+		jalv->world, LV2_STATE__threadSafeRestore);
+	if (lilv_plugin_has_feature(jalv->plugin, state_threadSafeRestore)) {
+		jalv->safe_restore = true;
+	}
+	lilv_node_free(state_threadSafeRestore);
+
+	if (!state) {
+		/* Not restoring state, load the plugin as a preset to get default */
+		state = lilv_state_new_from_world(
+			jalv->world, &jalv->map, lilv_plugin_get_uri(jalv->plugin));
+	}
+
+	/* Get a plugin UI */
+	const char* native_ui_type_uri = jalv_native_ui_type();
+	jalv->uis = lilv_plugin_get_uis(jalv->plugin);
+	if (!jalv->opts.generic_ui && native_ui_type_uri) {
+#ifdef HAVE_SUIL
+		const LilvNode* native_ui_type = lilv_new_uri(jalv->world, native_ui_type_uri);
+		LILV_FOREACH(uis, u, jalv->uis) {
+			const LilvUI* this_ui = lilv_uis_get(jalv->uis, u);
+			if (lilv_ui_is_supported(this_ui,
+			                         suil_ui_supported,
+			                         native_ui_type,
+			                         &jalv->ui_type)) {
+				/* TODO: Multiple UI support */
+				jalv->ui = this_ui;
+				break;
+			}
+		}
+#endif
+	} else if (!jalv->opts.generic_ui && jalv->opts.show_ui) {
+		jalv->ui = lilv_uis_get(jalv->uis, lilv_uis_begin(jalv->uis));
+	}
+
+	/* Create ringbuffers for UI if necessary */
+	if (jalv->ui) {
+		fprintf(stderr, "UI:           %s\n",
+		        lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)));
+	} else {
+		fprintf(stderr, "UI:           None\n");
+	}
+
+	/* Create port and control structures */
+	jalv_create_ports(jalv);
+	jalv_create_controls(jalv, true);
+	jalv_create_controls(jalv, false);
+
+	if (!(jalv->backend = jalv_backend_init(jalv))) {
+		fprintf(stderr, "Failed to connect to audio system\n");
+		jalv_close(jalv);
+		return -6;
+	}
+
+	printf("Sample rate:  %u Hz\n", jalv->sample_rate);
+	printf("Block length: %u frames\n", jalv->block_length);
+	printf("MIDI buffers: %zu bytes\n", jalv->midi_buf_size);
+
+	if (jalv->opts.buffer_size == 0) {
+		/* The UI ring is fed by plugin output ports (usually one), and the UI
+		   updates roughly once per cycle.  The ring size is a few times the
+		   size of the MIDI output to give the UI a chance to keep up.  The UI
+		   should be able to keep up with 4 cycles, and tests show this works
+		   for me, but this value might need increasing to avoid overflows.
+		*/
+		jalv->opts.buffer_size = jalv->midi_buf_size * N_BUFFER_CYCLES;
+	}
+
+	if (jalv->opts.update_rate == 0.0) {
+		/* Calculate a reasonable UI update frequency. */
+		jalv->ui_update_hz = (float)jalv->sample_rate / jalv->midi_buf_size * 2.0f;
+		jalv->ui_update_hz = MAX(25.0f, jalv->ui_update_hz);
+	} else {
+		/* Use user-specified UI update rate. */
+		jalv->ui_update_hz = jalv->opts.update_rate;
+		jalv->ui_update_hz = MAX(1.0f, jalv->ui_update_hz);
+	}
+
+	/* The UI can only go so fast, clamp to reasonable limits */
+	jalv->ui_update_hz     = MIN(60, jalv->ui_update_hz);
+	jalv->opts.buffer_size = MAX(4096, jalv->opts.buffer_size);
+	fprintf(stderr, "Comm buffers: %d bytes\n", jalv->opts.buffer_size);
+	fprintf(stderr, "Update rate:  %.01f Hz\n", jalv->ui_update_hz);
+
+	/* Build options array to pass to plugin */
+	const LV2_Options_Option options[ARRAY_SIZE(jalv->features.options)] = {
+		{ LV2_OPTIONS_INSTANCE, 0, jalv->urids.param_sampleRate,
+		  sizeof(float), jalv->urids.atom_Float, &jalv->sample_rate },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv->urids.bufsz_minBlockLength,
+		  sizeof(int32_t), jalv->urids.atom_Int, &jalv->block_length },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv->urids.bufsz_maxBlockLength,
+		  sizeof(int32_t), jalv->urids.atom_Int, &jalv->block_length },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv->urids.bufsz_sequenceSize,
+		  sizeof(int32_t), jalv->urids.atom_Int, &jalv->midi_buf_size },
+		{ LV2_OPTIONS_INSTANCE, 0, jalv->urids.ui_updateRate,
+		  sizeof(float), jalv->urids.atom_Float, &jalv->ui_update_hz },
+		{ LV2_OPTIONS_INSTANCE, 0, 0, 0, 0, NULL }
+	};
+	memcpy(jalv->features.options, options, sizeof(jalv->features.options));
+
+	init_feature(&jalv->features.options_feature,
+	             LV2_OPTIONS__options,
+	             (void*)jalv->features.options);
+
+	init_feature(&jalv->features.safe_restore_feature,
+	             LV2_STATE__threadSafeRestore,
+	             NULL);
+
+	/* Create Plugin <=> UI communication buffers */
+	jalv->ui_events     = zix_ring_new(jalv->opts.buffer_size);
+	jalv->plugin_events = zix_ring_new(jalv->opts.buffer_size);
+	zix_ring_mlock(jalv->ui_events);
+	zix_ring_mlock(jalv->plugin_events);
+
+	/* Build feature list for passing to plugins */
+	const LV2_Feature* const features[] = {
+		&jalv->features.map_feature,
+		&jalv->features.unmap_feature,
+		&jalv->features.sched_feature,
+		&jalv->features.log_feature,
+		&jalv->features.options_feature,
+		&static_features[0],
+		&static_features[1],
+		&static_features[2],
+		&static_features[3],
+		&static_features[4],
+		NULL
+	};
+	jalv->feature_list = calloc(1, sizeof(features));
+	if (!jalv->feature_list) {
+		fprintf(stderr, "Failed to allocate feature list\n");
+		jalv_close(jalv);
+		return -7;
+	}
+	memcpy(jalv->feature_list, features, sizeof(features));
+
+	/* Check that any required features are supported */
+	LilvNodes* req_feats = lilv_plugin_get_required_features(jalv->plugin);
+	LILV_FOREACH(nodes, f, req_feats) {
+		const char* uri = lilv_node_as_uri(lilv_nodes_get(req_feats, f));
+		if (!feature_is_supported(jalv, uri)) {
+			fprintf(stderr, "Feature %s is not supported\n", uri);
+			jalv_close(jalv);
+			return -8;
+		}
+	}
+	lilv_nodes_free(req_feats);
+
+	/* Instantiate the plugin */
+	jalv->instance = lilv_plugin_instantiate(
+		jalv->plugin, jalv->sample_rate, jalv->feature_list);
+	if (!jalv->instance) {
+		fprintf(stderr, "Failed to instantiate plugin.\n");
+		jalv_close(jalv);
+		return -9;
+	}
+
+	jalv->features.ext_data.data_access =
+		lilv_instance_get_descriptor(jalv->instance)->extension_data;
+
+	fprintf(stderr, "\n");
+	if (!jalv->buf_size_set) {
+		jalv_allocate_port_buffers(jalv);
+	}
+
+	/* Create workers if necessary */
+	if (lilv_plugin_has_extension_data(jalv->plugin, jalv->nodes.work_interface)) {
+		const LV2_Worker_Interface* iface = (const LV2_Worker_Interface*)
+			lilv_instance_get_extension_data(jalv->instance, LV2_WORKER__interface);
+
+		jalv_worker_init(jalv, &jalv->worker, iface, true);
+		if (jalv->safe_restore) {
+			jalv_worker_init(jalv, &jalv->state_worker, iface, false);
+		}
+	}
+
+	/* Apply loaded state to plugin instance if necessary */
+	if (state) {
+		jalv_apply_state(jalv, state);
+	}
+
+	if (jalv->opts.controls) {
+		for (char** c = jalv->opts.controls; *c; ++c) {
+			jalv_apply_control_arg(jalv, *c);
+		}
+	}
+
+	/* Create Jack ports and connect plugin ports to buffers */
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		jalv_backend_activate_port(jalv, i);
+	}
+
+	/* Print initial control values */
+	for (size_t i = 0; i < jalv->controls.n_controls; ++i) {
+		ControlID* control = jalv->controls.controls[i];
+		if (control->type == PORT && control->is_writable) {
+			struct Port* port = &jalv->ports[control->index];
+			jalv_print_control(jalv, port, port->control);
+		}
+	}
+
+	/* Activate plugin */
+	lilv_instance_activate(jalv->instance);
+
+	/* Discover UI */
+	jalv->has_ui = jalv_discover_ui(jalv);
+
+	/* Activate Jack */
+	jalv_backend_activate(jalv);
+	jalv->play_state = JALV_RUNNING;
+
+	return 0;
+}
+
+int
+jalv_close(Jalv* const jalv)
+{
+	jalv->exit = true;
+
+	fprintf(stderr, "Exiting...\n");
+
+	/* Terminate the worker */
+	jalv_worker_finish(&jalv->worker);
+
+	/* Deactivate audio */
+	jalv_backend_deactivate(jalv);
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		if (jalv->ports[i].evbuf) {
+			lv2_evbuf_free(jalv->ports[i].evbuf);
+		}
+	}
+	jalv_backend_close(jalv);
+
+	/* Destroy the worker */
+	jalv_worker_destroy(&jalv->worker);
+
+	/* Deactivate plugin */
+#ifdef HAVE_SUIL
+	suil_instance_free(jalv->ui_instance);
+#endif
+	if (jalv->instance) {
+		lilv_instance_deactivate(jalv->instance);
+		lilv_instance_free(jalv->instance);
+	}
+
+	/* Clean up */
+	free(jalv->ports);
+	zix_ring_free(jalv->ui_events);
+	zix_ring_free(jalv->plugin_events);
+	for (LilvNode** n = (LilvNode**)&jalv->nodes; *n; ++n) {
+		lilv_node_free(*n);
+	}
+	symap_free(jalv->symap);
+	zix_sem_destroy(&jalv->symap_lock);
+#ifdef HAVE_SUIL
+	suil_host_free(jalv->ui_host);
+#endif
+
+	for (unsigned i = 0; i < jalv->controls.n_controls; ++i) {
+		ControlID* const control = jalv->controls.controls[i];
+		lilv_node_free(control->node);
+		lilv_node_free(control->symbol);
+		lilv_node_free(control->label);
+		lilv_node_free(control->group);
+		lilv_node_free(control->min);
+		lilv_node_free(control->max);
+		lilv_node_free(control->def);
+		free(control);
+	}
+	free(jalv->controls.controls);
+
+	if (jalv->sratom) {
+		sratom_free(jalv->sratom);
+	}
+	if (jalv->ui_sratom) {
+		sratom_free(jalv->ui_sratom);
+	}
+	lilv_uis_free(jalv->uis);
+	lilv_world_free(jalv->world);
+
+	zix_sem_destroy(&jalv->done);
+
+	remove(jalv->temp_dir);
+	free(jalv->temp_dir);
+	free(jalv->ui_event_buf);
+	free(jalv->feature_list);
+
+	free(jalv->opts.name);
+	free(jalv->opts.uuid);
+	free(jalv->opts.load);
+	free(jalv->opts.controls);
+
+	return 0;
+}
+
+int
+main(int argc, char** argv)
+{
+	Jalv jalv;
+	memset(&jalv, '\0', sizeof(Jalv));
+
+	if (jalv_open(&jalv, argc, argv)) {
+		return EXIT_FAILURE;
+	}
+
+	/* Set up signal handlers */
+	setup_signals(&jalv);
+
+	/* Run UI (or prompt at console) */
+	jalv_open_ui(&jalv);
+
+	/* Wait for finish signal from UI or signal handler */
+	zix_sem_wait(&jalv.done);
+
+	return jalv_close(&jalv);
+}
diff --git a/src/jalv_console.c b/src/jalv_console.c
new file mode 100644
index 0000000..07e97c6
--- /dev/null
+++ b/src/jalv_console.c
@@ -0,0 +1,290 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE   600
+#define _BSD_SOURCE     1
+#define _DEFAULT_SOURCE 1
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "jalv_config.h"
+#include "jalv_internal.h"
+
+#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
+
+static int
+print_usage(const char* name, bool error)
+{
+	FILE* const os = error ? stderr : stdout;
+	fprintf(os, "Usage: %s [OPTION...] PLUGIN_URI\n", name);
+	fprintf(os, "Run an LV2 plugin as a Jack application.\n");
+	fprintf(os, "  -b SIZE      Buffer size for plugin <=> UI communication\n");
+	fprintf(os, "  -c SYM=VAL   Set control value (e.g. \"vol=1.4\")\n");
+	fprintf(os, "  -d           Dump plugin <=> UI communication\n");
+	fprintf(os, "  -h           Display this help and exit\n");
+	fprintf(os, "  -l DIR       Load state from save directory\n");
+	fprintf(os, "  -n NAME      JACK client name\n");
+	fprintf(os, "  -p           Print control output changes to stdout\n");
+	fprintf(os, "  -s           Show plugin UI if possible\n");
+	fprintf(os, "  -t           Print trace messages from plugin\n");
+	fprintf(os, "  -u UUID      UUID for Jack session restoration\n");
+	fprintf(os, "  -x           Exact JACK client name (exit if taken)\n");
+	return error ? 1 : 0;
+}
+
+int
+jalv_ui_resize(ZIX_UNUSED Jalv* jalv,
+               ZIX_UNUSED int   width,
+               ZIX_UNUSED int   height)
+{
+	return height;
+}
+
+void
+jalv_ui_port_event(ZIX_UNUSED Jalv*       jalv,
+                   ZIX_UNUSED uint32_t    port_index,
+                   ZIX_UNUSED uint32_t    buffer_size,
+                   ZIX_UNUSED uint32_t    protocol,
+                   ZIX_UNUSED const void* buffer)
+{
+}
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	int n_controls = 0;
+	int a          = 1;
+	for (; a < *argc && (*argv)[a][0] == '-'; ++a) {
+		if ((*argv)[a][1] == 'h') {
+			return print_usage((*argv)[0], true);
+		} else if ((*argv)[a][1] == 's') {
+			opts->show_ui = true;
+		} else if ((*argv)[a][1] == 'p') {
+			opts->print_controls = true;
+		} else if ((*argv)[a][1] == 'u') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -u\n");
+				return 1;
+			}
+			opts->uuid = jalv_strdup((*argv)[a]);
+		} else if ((*argv)[a][1] == 'l') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -l\n");
+				return 1;
+			}
+			opts->load = jalv_strdup((*argv)[a]);
+		} else if ((*argv)[a][1] == 'b') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -b\n");
+				return 1;
+			}
+			opts->buffer_size = atoi((*argv)[a]);
+		} else if ((*argv)[a][1] == 'c') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -c\n");
+				return 1;
+			}
+			opts->controls = (char**)realloc(
+				opts->controls, (++n_controls + 1) * sizeof(char*));
+			opts->controls[n_controls - 1] = (*argv)[a];
+			opts->controls[n_controls]     = NULL;
+		} else if ((*argv)[a][1] == 'i') {
+			opts->non_interactive = true;
+		} else if ((*argv)[a][1] == 'd') {
+			opts->dump = true;
+		} else if ((*argv)[a][1] == 't') {
+			opts->trace = true;
+		} else if ((*argv)[a][1] == 'n') {
+			if (++a == *argc) {
+				fprintf(stderr, "Missing argument for -n\n");
+				return 1;
+			}
+			free(opts->name);
+			opts->name = jalv_strdup((*argv)[a]);
+		} else if ((*argv)[a][1] == 'x') {
+			opts->name_exact = 1;
+		} else {
+			fprintf(stderr, "Unknown option %s\n", (*argv)[a]);
+			return print_usage((*argv)[0], true);
+		}
+	}
+
+	return 0;
+}
+
+const char*
+jalv_native_ui_type(void)
+{
+	return NULL;
+}
+
+static void
+jalv_print_controls(Jalv* jalv, bool writable, bool readable)
+{
+	for (size_t i = 0; i < jalv->controls.n_controls; ++i) {
+		ControlID* const control = jalv->controls.controls[i];
+		if ((control->is_writable && writable) ||
+		    (control->is_readable && readable)) {
+			struct Port* const port = &jalv->ports[control->index];
+			printf("%s = %f\n",
+			       lilv_node_as_string(control->symbol),
+			       port->control);
+		}
+	}
+}
+
+static int
+jalv_print_preset(Jalv*           jalv,
+                  const LilvNode* node,
+                  const LilvNode* title,
+                  void*           data)
+{
+	printf("%s (%s)\n", lilv_node_as_string(node), lilv_node_as_string(title));
+	return 0;
+}
+
+static void
+jalv_process_command(Jalv* jalv, const char* cmd)
+{
+	char     sym[64];
+	uint32_t index;
+	float    value;
+	if (!strncmp(cmd, "help", 4)) {
+		fprintf(stderr,
+		        "Commands:\n"
+		        "  help              Display this help message\n"
+		        "  controls          Print settable control values\n"
+		        "  monitors          Print output control values\n"
+		        "  presets           Print available presets\n"
+		        "  preset URI        Set preset\n"
+		        "  set INDEX VALUE   Set control value by port index\n"
+		        "  set SYMBOL VALUE  Set control value by symbol\n"
+		        "  SYMBOL = VALUE    Set control value by symbol\n");
+	} else if (strcmp(cmd, "presets\n") == 0) {
+		jalv_unload_presets(jalv);
+		jalv_load_presets(jalv, jalv_print_preset, NULL);
+	} else if (sscanf(cmd, "preset %[a-zA-Z0-9_:/-.#]\n", sym) == 1) {
+		LilvNode* preset = lilv_new_uri(jalv->world, sym);
+		jalv_apply_preset(jalv, preset);
+		lilv_node_free(preset);
+		jalv_print_controls(jalv, true, false);
+	} else if (strcmp(cmd, "controls\n") == 0) {
+		jalv_print_controls(jalv, true, false);
+	} else if (strcmp(cmd, "monitors\n") == 0) {
+		jalv_print_controls(jalv, false, true);
+	} else if (sscanf(cmd, "set %u %f", &index, &value) == 2) {
+		if (index < jalv->num_ports) {
+			jalv->ports[index].control = value;
+			jalv_print_control(jalv, &jalv->ports[index], value);
+		} else {
+			fprintf(stderr, "error: port index out of range\n");
+		}
+	} else if (sscanf(cmd, "set %[a-zA-Z0-9_] %f", sym, &value) == 2 ||
+	           sscanf(cmd, "%[a-zA-Z0-9_] = %f", sym, &value) == 2) {
+		struct Port* port = NULL;
+		for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+			struct Port* p = &jalv->ports[i];
+			const LilvNode* s = lilv_port_get_symbol(jalv->plugin, p->lilv_port);
+			if (!strcmp(lilv_node_as_string(s), sym)) {
+				port = p;
+				break;
+			}
+		}
+		if (port) {
+			port->control = value;
+			jalv_print_control(jalv, port, value);
+		} else {
+			fprintf(stderr, "error: no control named `%s'\n", sym);
+		}
+	} else {
+		fprintf(stderr, "error: invalid command (try `help')\n");
+	}
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return jalv->opts.show_ui;
+}
+
+static bool
+jalv_run_custom_ui(Jalv* jalv)
+{
+#ifdef HAVE_SUIL
+	const LV2UI_Idle_Interface* idle_iface = NULL;
+	const LV2UI_Show_Interface* show_iface = NULL;
+	if (jalv->ui && jalv->opts.show_ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(), NULL);
+		idle_iface = (const LV2UI_Idle_Interface*)
+			suil_instance_extension_data(jalv->ui_instance, LV2_UI__idleInterface);
+		show_iface = (const LV2UI_Show_Interface*)
+			suil_instance_extension_data(jalv->ui_instance, LV2_UI__showInterface);
+	}
+
+	if (show_iface && idle_iface) {
+		show_iface->show(suil_instance_get_handle(jalv->ui_instance));
+
+		// Drive idle interface until interrupted
+		while (!zix_sem_try_wait(&jalv->done)) {
+			jalv_update(jalv);
+			if (idle_iface->idle(suil_instance_get_handle(jalv->ui_instance))) {
+				break;
+			}
+			usleep(33333);
+		}
+
+		show_iface->hide(suil_instance_get_handle(jalv->ui_instance));
+		return true;
+	}
+#endif
+
+	return false;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	if (!jalv_run_custom_ui(jalv) && !jalv->opts.non_interactive) {
+		// Primitive command prompt for setting control values
+		while (!zix_sem_try_wait(&jalv->done)) {
+			char line[128];
+			printf("> ");
+			if (fgets(line, sizeof(line), stdin)) {
+				jalv_process_command(jalv, line);
+			} else {
+				break;
+			}
+		}
+	} else {
+		zix_sem_wait(&jalv->done);
+	}
+
+	// Caller waits on the done sem, so increment it again to exit
+	zix_sem_post(&jalv->done);
+
+	return 0;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	zix_sem_post(&jalv->done);
+	return 0;
+}
diff --git a/src/jalv_gtk.c b/src/jalv_gtk.c
new file mode 100644
index 0000000..a27a8df
--- /dev/null
+++ b/src/jalv_gtk.c
@@ -0,0 +1,1248 @@
+/*
+  Copyright 2007-2017 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <math.h>
+
+#include <gtk/gtk.h>
+
+#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
+
+#include "jalv_internal.h"
+
+#if GTK_MAJOR_VERSION == 3
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#endif
+
+static GtkCheckMenuItem* active_preset_item = NULL;
+static bool              updating           = false;
+
+/** Widget for a control. */
+typedef struct {
+	GtkSpinButton* spin;
+	GtkWidget*     control;
+} Controller;
+
+static float
+get_float(const LilvNode* node, float fallback)
+{
+	if (lilv_node_is_float(node) || lilv_node_is_int(node)) {
+		return lilv_node_as_float(node);
+	}
+
+	return fallback;
+}
+
+static GtkWidget*
+new_box(gboolean horizontal, gint spacing)
+{
+	#if GTK_MAJOR_VERSION == 3
+	return gtk_box_new(
+		horizontal ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL,
+		spacing);
+	#else
+	return (horizontal
+	        ? gtk_hbox_new(FALSE, spacing)
+	        : gtk_vbox_new(FALSE, spacing));
+	#endif
+}
+
+static GtkWidget*
+new_hscale(gdouble min, gdouble max, gdouble step)
+{
+	#if GTK_MAJOR_VERSION == 3
+	return gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, min, max, step);
+	#else
+	return gtk_hscale_new_with_range(min, max, step);
+	#endif
+}
+
+static void
+size_request(GtkWidget* widget, GtkRequisition* req)
+{
+	#if GTK_MAJOR_VERSION == 3
+	gtk_widget_get_preferred_size(widget, NULL, req);
+	#else
+	gtk_widget_size_request(widget, req);
+	#endif
+}
+
+static void
+on_window_destroy(ZIX_UNUSED GtkWidget* widget, ZIX_UNUSED gpointer data)
+{
+	gtk_main_quit();
+}
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	GOptionEntry entries[] = {
+		{ "uuid", 'u', 0, G_OPTION_ARG_STRING, &opts->uuid,
+		  "UUID for Jack session restoration", "UUID" },
+		{ "load", 'l', 0, G_OPTION_ARG_STRING, &opts->load,
+		  "Load state from save directory", "DIR" },
+		{ "preset", 'p', 0, G_OPTION_ARG_STRING, &opts->preset,
+		  "Load state from preset", "URI" },
+		{ "dump", 'd', 0, G_OPTION_ARG_NONE, &opts->dump,
+		  "Dump plugin <=> UI communication", NULL },
+		{ "trace", 't', 0, G_OPTION_ARG_NONE, &opts->trace,
+		  "Print trace messages from plugin", NULL },
+		{ "show-hidden", 's', 0, G_OPTION_ARG_NONE, &opts->show_hidden,
+		  "Show controls for ports with notOnGUI property on generic UI", NULL },
+		{ "no-menu", 'n', 0, G_OPTION_ARG_NONE, &opts->no_menu,
+		  "Do not show Jalv menu on window", NULL },
+		{ "generic-ui", 'g', 0, G_OPTION_ARG_NONE, &opts->generic_ui,
+		  "Use Jalv generic UI and not the plugin UI", NULL},
+		{ "buffer-size", 'b', 0, G_OPTION_ARG_INT, &opts->buffer_size,
+		  "Buffer size for plugin <=> UI communication", "SIZE"},
+		{ "update-frequency", 'r', 0, G_OPTION_ARG_DOUBLE, &opts->update_rate,
+		  "UI update frequency", NULL},
+		{ "control", 'c', 0, G_OPTION_ARG_STRING_ARRAY, &opts->controls,
+		  "Set control value (e.g. \"vol=1.4\")", NULL},
+		{ "print-controls", 'p', 0, G_OPTION_ARG_NONE, &opts->print_controls,
+		  "Print control output changes to stdout", NULL},
+		{ "jack-name", 'n', 0, G_OPTION_ARG_STRING, &opts->name,
+		  "JACK client name", NULL},
+		{ "exact-jack-name", 'x', 0, G_OPTION_ARG_NONE, &opts->name_exact,
+		  "Exact JACK client name (exit if taken)", NULL },
+		{ 0, 0, 0, G_OPTION_ARG_NONE, 0, 0, 0 } };
+	GError* error = NULL;
+	const int err = gtk_init_with_args(
+		argc, argv,
+		"PLUGIN_URI - Run an LV2 plugin as a Jack application",
+		entries, NULL, &error);
+
+	if (!err) {
+		fprintf(stderr, "%s\n", error->message);
+	}
+
+	return !err;
+}
+
+const char*
+jalv_native_ui_type(void)
+{
+#if GTK_MAJOR_VERSION == 2
+	return "http://lv2plug.in/ns/extensions/ui#GtkUI";
+#elif GTK_MAJOR_VERSION == 3
+	return "http://lv2plug.in/ns/extensions/ui#Gtk3UI";
+#else
+	return NULL;
+#endif
+}
+
+static void
+on_save_activate(ZIX_UNUSED GtkWidget* widget, void* ptr)
+{
+	Jalv* jalv = (Jalv*)ptr;
+	GtkWidget* dialog = gtk_file_chooser_dialog_new(
+		"Save State",
+		(GtkWindow*)jalv->window,
+		GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
+		"_Cancel", GTK_RESPONSE_CANCEL,
+		"_Save", GTK_RESPONSE_ACCEPT,
+		NULL);
+
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		char* path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+		char* base = g_build_filename(path, "/", NULL);
+		jalv_save(jalv, base);
+		g_free(path);
+		g_free(base);
+	}
+
+	gtk_widget_destroy(dialog);
+}
+
+static void
+on_quit_activate(ZIX_UNUSED GtkWidget* widget, gpointer data)
+{
+	GtkWidget* window = (GtkWidget*)data;
+	gtk_widget_destroy(window);
+}
+
+typedef struct {
+	Jalv*     jalv;
+	LilvNode* preset;
+} PresetRecord;
+
+static char*
+symbolify(const char* in)
+{
+	const size_t len = strlen(in);
+	char*        out = (char*)calloc(len + 1, 1);
+	for (size_t i = 0; i < len; ++i) {
+		if (g_ascii_isalnum(in[i])) {
+			out[i] = in[i];
+		} else {
+			out[i] = '_';
+		}
+	}
+	return out;
+}
+
+static void
+set_window_title(Jalv* jalv)
+{
+	LilvNode*   name   = lilv_plugin_get_name(jalv->plugin);
+	const char* plugin = lilv_node_as_string(name);
+	if (jalv->preset) {
+		const char* preset_label = lilv_state_get_label(jalv->preset);
+		char* title = g_strdup_printf("%s - %s", plugin, preset_label);
+		gtk_window_set_title(GTK_WINDOW(jalv->window), title);
+		free(title);
+	} else {
+		gtk_window_set_title(GTK_WINDOW(jalv->window), plugin);
+	}
+	lilv_node_free(name);
+}
+
+static void
+on_preset_activate(GtkWidget* widget, gpointer data)
+{
+	if (GTK_CHECK_MENU_ITEM(widget) != active_preset_item) {
+		PresetRecord* record = (PresetRecord*)data;
+		jalv_apply_preset(record->jalv, record->preset);
+		if (active_preset_item) {
+			gtk_check_menu_item_set_active(active_preset_item, FALSE);
+		}
+
+		active_preset_item = GTK_CHECK_MENU_ITEM(widget);
+		gtk_check_menu_item_set_active(active_preset_item, TRUE);
+		set_window_title(record->jalv);
+	}
+}
+
+static void
+on_preset_destroy(gpointer data, ZIX_UNUSED GClosure* closure)
+{
+	PresetRecord* record = (PresetRecord*)data;
+	lilv_node_free(record->preset);
+	free(record);
+}
+
+typedef struct {
+	GtkMenuItem* item;
+	char*        label;
+	GtkMenu*     menu;
+	GSequence*   banks;
+} PresetMenu;
+
+static PresetMenu*
+pset_menu_new(const char* label)
+{
+	PresetMenu* menu = (PresetMenu*)malloc(sizeof(PresetMenu));
+	menu->label = g_strdup(label);
+	menu->item  = GTK_MENU_ITEM(gtk_menu_item_new_with_label(menu->label));
+	menu->menu  = GTK_MENU(gtk_menu_new());
+	menu->banks = NULL;
+	return menu;
+}
+
+static void
+pset_menu_free(PresetMenu* menu)
+{
+	if (menu->banks) {
+		for (GSequenceIter* i = g_sequence_get_begin_iter(menu->banks);
+		     !g_sequence_iter_is_end(i);
+		     i = g_sequence_iter_next(i)) {
+			PresetMenu* bank_menu = (PresetMenu*)g_sequence_get(i);
+			pset_menu_free(bank_menu);
+		}
+		g_sequence_free(menu->banks);
+	}
+
+	free(menu->label);
+	free(menu);
+}
+
+static gint
+menu_cmp(gconstpointer a, gconstpointer b, ZIX_UNUSED gpointer data)
+{
+	return strcmp(((const PresetMenu*)a)->label, ((const PresetMenu*)b)->label);
+}
+
+static PresetMenu*
+get_bank_menu(Jalv* jalv, PresetMenu* menu, const LilvNode* bank)
+{
+	LilvNode* label = lilv_world_get(
+		jalv->world, bank, jalv->nodes.rdfs_label, NULL);
+
+	const char*    uri = lilv_node_as_string(bank);
+	const char*    str = label ? lilv_node_as_string(label) : uri;
+	PresetMenu     key = { NULL, (char*)str, NULL, NULL };
+	GSequenceIter* i   = g_sequence_lookup(menu->banks, &key, menu_cmp, NULL);
+	if (!i) {
+		PresetMenu* bank_menu = pset_menu_new(str);
+		gtk_menu_item_set_submenu(bank_menu->item, GTK_WIDGET(bank_menu->menu));
+		g_sequence_insert_sorted(menu->banks, bank_menu, menu_cmp, NULL);
+		return bank_menu;
+	}
+	return (PresetMenu*)g_sequence_get(i);
+}
+
+static int
+add_preset_to_menu(Jalv*           jalv,
+                   const LilvNode* node,
+                   const LilvNode* title,
+                   void*           data)
+{
+	PresetMenu* menu  = (PresetMenu*)data;
+	const char* label = lilv_node_as_string(title);
+	GtkWidget*  item  = gtk_check_menu_item_new_with_label(label);
+	gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE);
+	if (jalv->preset &&
+	    lilv_node_equals(lilv_state_get_uri(jalv->preset), node)) {
+		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+		active_preset_item = GTK_CHECK_MENU_ITEM(item);
+	}
+
+	LilvNode* bank = lilv_world_get(
+		jalv->world, node, jalv->nodes.pset_bank, NULL);
+
+	if (bank) {
+		PresetMenu* bank_menu = get_bank_menu(jalv, menu, bank);
+		gtk_menu_shell_append(GTK_MENU_SHELL(bank_menu->menu), item);
+	} else {
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu->menu), item);
+	}
+
+	PresetRecord* record = (PresetRecord*)malloc(sizeof(PresetRecord));
+	record->jalv   = jalv;
+	record->preset = lilv_node_duplicate(node);
+
+	g_signal_connect_data(G_OBJECT(item), "activate",
+	                      G_CALLBACK(on_preset_activate),
+	                      record, on_preset_destroy,
+	                      (GConnectFlags)0);
+
+	return 0;
+}
+
+static void
+finish_menu(PresetMenu* menu)
+{
+	for (GSequenceIter* i = g_sequence_get_begin_iter(menu->banks);
+	     !g_sequence_iter_is_end(i);
+	     i = g_sequence_iter_next(i)) {
+		PresetMenu* bank_menu = (PresetMenu*)g_sequence_get(i);
+		gtk_menu_shell_append(GTK_MENU_SHELL(menu->menu),
+		                      GTK_WIDGET(bank_menu->item));
+	}
+	g_sequence_free(menu->banks);
+}
+
+static void
+rebuild_preset_menu(Jalv* jalv, GtkContainer* pset_menu)
+{
+	// Clear current menu
+	active_preset_item = NULL;
+	for (GList* items = g_list_nth(gtk_container_get_children(pset_menu), 3);
+	     items;
+	     items = items->next) {
+		gtk_container_remove(pset_menu, GTK_WIDGET(items->data));
+	}
+
+	// Load presets and build new menu
+	PresetMenu menu = {
+		NULL, NULL, GTK_MENU(pset_menu),
+		g_sequence_new((GDestroyNotify)pset_menu_free)
+	};
+	jalv_load_presets(jalv, add_preset_to_menu, &menu);
+	finish_menu(&menu);
+	gtk_widget_show_all(GTK_WIDGET(pset_menu));
+}
+
+static void
+on_save_preset_activate(GtkWidget* widget, void* ptr)
+{
+	Jalv* jalv = (Jalv*)ptr;
+
+	GtkWidget* dialog = gtk_file_chooser_dialog_new(
+		"Save Preset",
+		(GtkWindow*)jalv->window,
+		GTK_FILE_CHOOSER_ACTION_SAVE,
+		"_Cancel", GTK_RESPONSE_REJECT,
+		"_Save", GTK_RESPONSE_ACCEPT,
+		NULL);
+
+	char* dot_lv2 = g_build_filename(g_get_home_dir(), ".lv2", NULL);
+	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), dot_lv2);
+	free(dot_lv2);
+
+	GtkWidget* content    = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+	GtkBox*    box        = GTK_BOX(new_box(true, 8));
+	GtkWidget* uri_label  = gtk_label_new("URI (Optional):");
+	GtkWidget* uri_entry  = gtk_entry_new();
+	GtkWidget* add_prefix = gtk_check_button_new_with_mnemonic(
+		"_Prefix plugin name");
+
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(add_prefix), TRUE);
+	gtk_box_pack_start(box, uri_label, FALSE, TRUE, 2);
+	gtk_box_pack_start(box, uri_entry, TRUE, TRUE, 2);
+	gtk_box_pack_start(GTK_BOX(content), GTK_WIDGET(box), FALSE, FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(content), add_prefix, FALSE, FALSE, 6);
+
+	gtk_widget_show_all(GTK_WIDGET(dialog));
+	gtk_entry_set_activates_default(GTK_ENTRY(uri_entry), TRUE);
+	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		LilvNode*   plug_name = lilv_plugin_get_name(jalv->plugin);
+		const char* path      = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
+		const char* uri       = gtk_entry_get_text(GTK_ENTRY(uri_entry));
+		const char* prefix    = "";
+		const char* sep       = "";
+		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(add_prefix))) {
+			prefix = lilv_node_as_string(plug_name);
+			sep    = "_";
+		}
+
+		char* dirname  = g_path_get_dirname(path);
+		char* basename = g_path_get_basename(path);
+		char* sym      = symbolify(basename);
+		char* sprefix  = symbolify(prefix);
+		char* bundle   = g_strjoin(NULL, sprefix, sep, sym, ".preset.lv2/", NULL);
+		char* file     = g_strjoin(NULL, sym, ".ttl", NULL);
+		char* dir      = g_build_filename(dirname, bundle, NULL);
+
+		jalv_save_preset(jalv, dir, (strlen(uri) ? uri : NULL), basename, file);
+
+		// Reload bundle into the world
+		LilvNode* ldir = lilv_new_file_uri(jalv->world, NULL, dir);
+		lilv_world_unload_bundle(jalv->world, ldir);
+		lilv_world_load_bundle(jalv->world, ldir);
+		lilv_node_free(ldir);
+
+		// Rebuild preset menu and update window title
+		rebuild_preset_menu(jalv, GTK_CONTAINER(gtk_widget_get_parent(widget)));
+		set_window_title(jalv);
+
+		g_free(dir);
+		g_free(file);
+		g_free(bundle);
+		free(sprefix);
+		free(sym);
+		g_free(basename);
+		g_free(dirname);
+		lilv_node_free(plug_name);
+	}
+
+	gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+static void
+on_delete_preset_activate(GtkWidget* widget, void* ptr)
+{
+	Jalv* jalv = (Jalv*)ptr;
+	if (!jalv->preset) {
+		return;
+	}
+
+	GtkWidget* dialog = gtk_dialog_new_with_buttons(
+		"Delete Preset?",
+		(GtkWindow*)jalv->window,
+		(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+		"_Cancel", GTK_RESPONSE_REJECT,
+		"_OK", GTK_RESPONSE_ACCEPT,
+		NULL);
+
+	char* msg = g_strdup_printf("Delete preset \"%s\" from the file system?",
+	                            lilv_state_get_label(jalv->preset));
+
+	GtkWidget* content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+	GtkWidget* text    = gtk_label_new(msg);
+	gtk_box_pack_start(GTK_BOX(content), text, TRUE, TRUE, 4);
+
+	gtk_widget_show_all(dialog);
+	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
+		jalv_delete_current_preset(jalv);
+		rebuild_preset_menu(jalv, GTK_CONTAINER(gtk_widget_get_parent(widget)));
+	}
+
+	lilv_state_free(jalv->preset);
+	jalv->preset = NULL;
+	set_window_title(jalv);
+
+	g_free(msg);
+	gtk_widget_destroy(text);
+	gtk_widget_destroy(dialog);
+}
+
+static void
+set_control(const ControlID* control,
+            uint32_t         size,
+            LV2_URID         type,
+            const void*      body)
+{
+	if (!updating) {
+		jalv_set_control(control, size, type, body);
+	}
+}
+
+static bool
+differ_enough(float a, float b)
+{
+	return fabsf(a - b) >= FLT_EPSILON;
+}
+
+static void
+set_float_control(const ControlID* control, float value)
+{
+	if (control->value_type == control->jalv->forge.Int) {
+		const int32_t ival = lrint(value);
+		set_control(control, sizeof(ival), control->jalv->forge.Int, &ival);
+	} else if (control->value_type == control->jalv->forge.Long) {
+		const int64_t lval = lrint(value);
+		set_control(control, sizeof(lval), control->jalv->forge.Long, &lval);
+	} else if (control->value_type == control->jalv->forge.Float) {
+		set_control(control, sizeof(value), control->jalv->forge.Float, &value);
+	} else if (control->value_type == control->jalv->forge.Double) {
+		const double dval = value;
+		set_control(control, sizeof(dval), control->jalv->forge.Double, &dval);
+	} else if (control->value_type == control->jalv->forge.Bool) {
+		const int32_t ival = value;
+		set_control(control, sizeof(ival), control->jalv->forge.Bool, &ival);
+	}
+
+	Controller* controller = (Controller*)control->widget;
+	if (controller && controller->spin &&
+	    differ_enough(gtk_spin_button_get_value(controller->spin), value)) {
+		gtk_spin_button_set_value(controller->spin, value);
+	}
+}
+
+static double
+get_atom_double(Jalv*               jalv,
+                ZIX_UNUSED uint32_t size,
+                LV2_URID            type,
+                const void*         body)
+{
+	if (type == jalv->forge.Int || type == jalv->forge.Bool) {
+		return *(const int32_t*)body;
+	} else if (type == jalv->forge.Long) {
+		return *(const int64_t*)body;
+	} else if (type == jalv->forge.Float) {
+		return *(const float*)body;
+	} else if (type == jalv->forge.Double) {
+		return *(const double*)body;
+	}
+	return NAN;
+}
+
+static void
+control_changed(Jalv*       jalv,
+                Controller* controller,
+                uint32_t    size,
+                LV2_URID    type,
+                const void* body)
+{
+	GtkWidget*   widget = controller->control;
+	const double fvalue = get_atom_double(jalv, size, type, body);
+
+	if (!isnan(fvalue)) {
+		if (GTK_IS_COMBO_BOX(widget)) {
+			GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
+			GValue        value = { 0, { { 0 } } };
+			GtkTreeIter   i;
+			bool          valid = gtk_tree_model_get_iter_first(model, &i);
+			while (valid) {
+				gtk_tree_model_get_value(model, &i, 0, &value);
+				const double v = g_value_get_float(&value);
+				g_value_unset(&value);
+				if (fabs(v - fvalue) < FLT_EPSILON) {
+					gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), &i);
+					return;
+				}
+				valid = gtk_tree_model_iter_next(model, &i);
+			}
+		} else if (GTK_IS_TOGGLE_BUTTON(widget)) {
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
+			                             fvalue > 0.0f);
+		} else if (GTK_IS_RANGE(widget)) {
+			gtk_range_set_value(GTK_RANGE(widget), fvalue);
+		} else {
+			fprintf(stderr, "Unknown widget type for value\n");
+		}
+
+		if (controller->spin) {
+			// Update spinner for numeric control
+			gtk_spin_button_set_value(GTK_SPIN_BUTTON(controller->spin),
+			                          fvalue);
+		}
+	} else if (GTK_IS_ENTRY(widget) && type == jalv->urids.atom_String) {
+		gtk_entry_set_text(GTK_ENTRY(widget), (const char*)body);
+	} else if (GTK_IS_FILE_CHOOSER(widget) && type == jalv->urids.atom_Path) {
+		gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(widget), (const char*)body);
+	} else {
+		fprintf(stderr, "Unknown widget type for value\n");
+	}
+}
+
+static int
+patch_set_get(Jalv*                  jalv,
+              const LV2_Atom_Object* obj,
+              const LV2_Atom_URID**  property,
+              const LV2_Atom**       value)
+{
+	lv2_atom_object_get(obj,
+	                    jalv->urids.patch_property, (const LV2_Atom*)property,
+	                    jalv->urids.patch_value,    value,
+	                    0);
+	if (!*property) {
+		fprintf(stderr, "patch:Set message with no property\n");
+		return 1;
+	} else if ((*property)->atom.type != jalv->forge.URID) {
+		fprintf(stderr, "patch:Set property is not a URID\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+static int
+patch_put_get(Jalv*                   jalv,
+              const LV2_Atom_Object*  obj,
+              const LV2_Atom_Object** body)
+{
+	lv2_atom_object_get(obj,
+	                    jalv->urids.patch_body, (const LV2_Atom*)body,
+	                    0);
+	if (!*body) {
+		fprintf(stderr, "patch:Put message with no body\n");
+		return 1;
+	} else if (!lv2_atom_forge_is_object_type(&jalv->forge, (*body)->atom.type)) {
+		fprintf(stderr, "patch:Put body is not an object\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+static void
+property_changed(Jalv* jalv, LV2_URID key, const LV2_Atom* value)
+{
+	ControlID* control = get_property_control(&jalv->controls, key);
+	if (control) {
+		control_changed(jalv,
+		                (Controller*)control->widget,
+		                value->size,
+		                value->type,
+		                value + 1);
+	}
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+	if (jalv->ui_instance) {
+		suil_instance_port_event(jalv->ui_instance, port_index,
+		                         buffer_size, protocol, buffer);
+		return;
+	} else if (protocol == 0 && (Controller*)jalv->ports[port_index].widget) {
+		control_changed(jalv,
+		                (Controller*)jalv->ports[port_index].widget,
+		                buffer_size,
+		                jalv->forge.Float,
+		                buffer);
+		return;
+	} else if (protocol == 0) {
+		return;  // No widget (probably notOnGUI)
+	} else if (protocol != jalv->urids.atom_eventTransfer) {
+		fprintf(stderr, "Unknown port event protocol\n");
+		return;
+	}
+
+	const LV2_Atom* atom = (const LV2_Atom*)buffer;
+	if (lv2_atom_forge_is_object_type(&jalv->forge, atom->type)) {
+		updating = true;
+		const LV2_Atom_Object* obj = (const LV2_Atom_Object*)buffer;
+		if (obj->body.otype == jalv->urids.patch_Set) {
+			const LV2_Atom_URID* property = NULL;
+			const LV2_Atom*      value    = NULL;
+			if (!patch_set_get(jalv, obj, &property, &value)) {
+				property_changed(jalv, property->body, value);
+			}
+		} else if (obj->body.otype == jalv->urids.patch_Put) {
+			const LV2_Atom_Object* body = NULL;
+			if (!patch_put_get(jalv, obj, &body)) {
+				LV2_ATOM_OBJECT_FOREACH(body, prop) {
+					property_changed(jalv, prop->key, &prop->value);
+				}
+			}
+		} else {
+			printf("Unknown object type?\n");
+		}
+		updating = false;
+	}
+}
+
+static gboolean
+scale_changed(GtkRange* range, gpointer data)
+{
+	set_float_control((const ControlID*)data, gtk_range_get_value(range));
+	return FALSE;
+}
+
+static gboolean
+spin_changed(GtkSpinButton* spin, gpointer data)
+{
+	const ControlID* control    = (const ControlID*)data;
+	Controller*      controller = (Controller*)control->widget;
+	GtkRange*        range      = GTK_RANGE(controller->control);
+	const double     value      = gtk_spin_button_get_value(spin);
+	if (differ_enough(gtk_range_get_value(range), value)) {
+		gtk_range_set_value(range, value);
+	}
+	return FALSE;
+}
+
+static gboolean
+log_scale_changed(GtkRange* range, gpointer data)
+{
+	set_float_control((const ControlID*)data, expf(gtk_range_get_value(range)));
+	return FALSE;
+}
+
+static gboolean
+log_spin_changed(GtkSpinButton* spin, gpointer data)
+{
+	const ControlID* control    = (const ControlID*)data;
+	Controller*      controller = (Controller*)control->widget;
+	GtkRange*        range      = GTK_RANGE(controller->control);
+	const double     value      = gtk_spin_button_get_value(spin);
+	if (differ_enough(gtk_range_get_value(range), logf(value))) {
+		gtk_range_set_value(range, logf(value));
+	}
+	return FALSE;
+}
+
+static void
+combo_changed(GtkComboBox* box, gpointer data)
+{
+	const ControlID* control = (const ControlID*)data;
+
+	GtkTreeIter iter;
+	if (gtk_combo_box_get_active_iter(box, &iter)) {
+		GtkTreeModel* model = gtk_combo_box_get_model(box);
+		GValue        value = { 0, { { 0 } } };
+
+		gtk_tree_model_get_value(model, &iter, 0, &value);
+		const double v = g_value_get_float(&value);
+		g_value_unset(&value);
+
+		set_float_control(control, v);
+	}
+}
+
+static gboolean
+toggle_changed(GtkToggleButton* button, gpointer data)
+{
+	set_float_control((const ControlID*)data,
+	                  gtk_toggle_button_get_active(button) ? 1.0f : 0.0f);
+	return FALSE;
+}
+
+static void
+string_changed(GtkEntry* widget, gpointer data)
+{
+	ControlID*  control = (ControlID*)data;
+	const char* string  = gtk_entry_get_text(widget);
+
+	set_control(control, strlen(string) + 1, control->jalv->forge.String, string);
+}
+
+static void
+file_changed(GtkFileChooserButton* widget,
+             gpointer              data)
+{
+	ControlID*  control   = (ControlID*)data;
+	Jalv*       jalv     = control->jalv;
+	const char* filename = gtk_file_chooser_get_filename(
+		GTK_FILE_CHOOSER(widget));
+
+	set_control(control, strlen(filename), jalv->forge.Path, filename);
+}
+
+static Controller*
+new_controller(GtkSpinButton* spin, GtkWidget* control)
+{
+	Controller* controller = (Controller*)malloc(sizeof(Controller));
+	controller->spin    = spin;
+	controller->control = control;
+	return controller;
+}
+
+static Controller*
+make_combo(ControlID* record, float value)
+{
+	GtkListStore* list_store = gtk_list_store_new(
+		2, G_TYPE_FLOAT, G_TYPE_STRING);
+	int active = -1;
+	for (size_t i = 0; i < record->n_points; ++i) {
+		const ScalePoint* point = &record->points[i];
+		GtkTreeIter       iter;
+		gtk_list_store_append(list_store, &iter);
+		gtk_list_store_set(list_store, &iter,
+		                   0, point->value,
+		                   1, point->label,
+		                   -1);
+		if (fabs(value - point->value) < FLT_EPSILON) {
+			active = i;
+		}
+	}
+
+	GtkWidget* combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list_store));
+	gtk_combo_box_set_active(GTK_COMBO_BOX(combo), active);
+	g_object_unref(list_store);
+
+	gtk_widget_set_sensitive(combo, record->is_writable);
+
+	GtkCellRenderer* cell = gtk_cell_renderer_text_new();
+	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE);
+	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, "text", 1, NULL);
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(combo), "changed",
+		                 G_CALLBACK(combo_changed), record);
+	}
+
+	return new_controller(NULL, combo);
+}
+
+static Controller*
+make_log_slider(ControlID* record, float value)
+{
+	const float min   = get_float(record->min, 0.0f);
+	const float max   = get_float(record->max, 1.0f);
+	const float lmin  = logf(min);
+	const float lmax  = logf(max);
+	const float ldft  = logf(value);
+	GtkWidget*  scale = new_hscale(lmin, lmax, 0.001);
+	GtkWidget*  spin  = gtk_spin_button_new_with_range(min, max, 0.000001);
+
+	gtk_widget_set_sensitive(scale, record->is_writable);
+	gtk_widget_set_sensitive(spin, record->is_writable);
+
+	gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
+	gtk_range_set_value(GTK_RANGE(scale), ldft);
+	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(scale), "value-changed",
+		                 G_CALLBACK(log_scale_changed), record);
+		g_signal_connect(G_OBJECT(spin), "value-changed",
+		                 G_CALLBACK(log_spin_changed), record);
+	}
+
+	return new_controller(GTK_SPIN_BUTTON(spin), scale);
+}
+
+static Controller*
+make_slider(ControlID* record, float value)
+{
+	const float  min   = get_float(record->min, 0.0f);
+	const float  max   = get_float(record->max, 1.0f);
+	const double step  = record->is_integer ? 1.0 : ((max - min) / 100.0);
+	GtkWidget*   scale = new_hscale(min, max, step);
+	GtkWidget*   spin  = gtk_spin_button_new_with_range(min, max, step);
+
+	gtk_widget_set_sensitive(scale, record->is_writable);
+	gtk_widget_set_sensitive(spin, record->is_writable);
+
+	if (record->is_integer) {
+		gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 0);
+	} else {
+		gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 7);
+	}
+
+	gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
+	gtk_range_set_value(GTK_RANGE(scale), value);
+	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), value);
+	if (record->points) {
+		for (size_t i = 0; i < record->n_points; ++i) {
+			const ScalePoint* point = &record->points[i];
+
+			gchar* str = g_markup_printf_escaped(
+				"<span font_size=\"small\">%s</span>", point->label);
+			gtk_scale_add_mark(
+				GTK_SCALE(scale), point->value, GTK_POS_TOP, str);
+		}
+	}
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(scale), "value-changed",
+		                 G_CALLBACK(scale_changed), record);
+		g_signal_connect(G_OBJECT(spin), "value-changed",
+		                 G_CALLBACK(spin_changed), record);
+	}
+
+	return new_controller(GTK_SPIN_BUTTON(spin), scale);
+}
+
+static Controller*
+make_toggle(ControlID* record, float value)
+{
+	GtkWidget* check = gtk_check_button_new();
+
+	gtk_widget_set_sensitive(check, record->is_writable);
+
+	if (value) {
+		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
+	}
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(check), "toggled",
+		                 G_CALLBACK(toggle_changed), record);
+	}
+
+	return new_controller(NULL, check);
+}
+
+static Controller*
+make_entry(ControlID* control)
+{
+	GtkWidget* entry = gtk_entry_new();
+
+	gtk_widget_set_sensitive(entry, control->is_writable);
+	if (control->is_writable) {
+		g_signal_connect(G_OBJECT(entry), "activate",
+		                 G_CALLBACK(string_changed), control);
+	}
+
+	return new_controller(NULL, entry);
+}
+
+static Controller*
+make_file_chooser(ControlID* record)
+{
+	GtkWidget* button = gtk_file_chooser_button_new(
+		"Open File", GTK_FILE_CHOOSER_ACTION_OPEN);
+
+	gtk_widget_set_sensitive(button, record->is_writable);
+
+	if (record->is_writable) {
+		g_signal_connect(G_OBJECT(button), "file-set",
+		                 G_CALLBACK(file_changed), record);
+	}
+
+	return new_controller(NULL, button);
+}
+
+static Controller*
+make_controller(ControlID* control, float value)
+{
+	Controller* controller = NULL;
+
+	if (control->is_toggle) {
+		controller = make_toggle(control, value);
+	} else if (control->is_enumeration) {
+		controller = make_combo(control, value);
+	} else if (control->is_logarithmic) {
+		controller = make_log_slider(control, value);
+	} else {
+		controller = make_slider(control, value);
+	}
+
+	return controller;
+}
+
+static GtkWidget*
+new_label(const char* text, bool title, float xalign, float yalign)
+{
+	GtkWidget*  label = gtk_label_new(NULL);
+	const char* fmt   = title ? "<span font_weight=\"bold\">%s</span>" : "%s:";
+	gchar*      str   = g_markup_printf_escaped(fmt, text);
+	gtk_label_set_markup(GTK_LABEL(label), str);
+	g_free(str);
+	gtk_misc_set_alignment(GTK_MISC(label), xalign, yalign);
+	return label;
+}
+
+static void
+add_control_row(GtkWidget*  table,
+                int         row,
+                const char* name,
+                Controller* controller)
+{
+	GtkWidget* label = new_label(name, false, 1.0, 0.5);
+	gtk_table_attach(GTK_TABLE(table),
+	                 label,
+	                 0, 1, row, row + 1,
+	                 GTK_FILL, (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 8, 1);
+	int control_left_attach = 1;
+	if (controller->spin) {
+		control_left_attach = 2;
+		gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(controller->spin),
+		                 1, 2, row, row + 1,
+		                 GTK_FILL, GTK_FILL, 2, 1);
+	}
+	gtk_table_attach(GTK_TABLE(table), controller->control,
+	                 control_left_attach, 3, row, row + 1,
+	                 (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), GTK_FILL, 2, 1);
+}
+
+static int
+control_group_cmp(const void* p1, const void* p2, ZIX_UNUSED void* data)
+{
+	const ControlID* control1 = *(const ControlID*const*)p1;
+	const ControlID* control2 = *(const ControlID*const*)p2;
+
+	const int cmp = (control1->group && control2->group)
+		? strcmp(lilv_node_as_string(control1->group),
+		         lilv_node_as_string(control2->group))
+		: ((intptr_t)control1->group - (intptr_t)control2->group);
+
+	return cmp;
+}
+
+static GtkWidget*
+build_control_widget(Jalv* jalv, GtkWidget* window)
+{
+	GtkWidget* port_table = gtk_table_new(jalv->num_ports, 3, false);
+
+	/* Make an array of controls sorted by group */
+	GArray* controls = g_array_new(FALSE, TRUE, sizeof(ControlID*));
+	for (unsigned i = 0; i < jalv->controls.n_controls; ++i) {
+		g_array_append_vals(controls, &jalv->controls.controls[i], 1);
+	}
+	g_array_sort_with_data(controls, control_group_cmp, jalv);
+
+	/* Add controls in group order */
+	LilvNode* last_group = NULL;
+	int       n_rows     = 0;
+	for (size_t i = 0; i < controls->len; ++i) {
+		ControlID*  record     = g_array_index(controls, ControlID*, i);
+		Controller* controller = NULL;
+		LilvNode*   group      = record->group;
+
+		/* Check group and add new heading if necessary */
+		if (group && !lilv_node_equals(group, last_group)) {
+			LilvNode* group_name = lilv_world_get(
+				jalv->world, group, jalv->nodes.lv2_name, NULL);
+			GtkWidget* group_label = new_label(
+				lilv_node_as_string(group_name), true, 0.0f, 1.0f);
+			gtk_table_attach(GTK_TABLE(port_table), group_label,
+			                 0, 2, n_rows, n_rows + 1,
+			                 GTK_FILL, GTK_FILL, 0, 6);
+			++n_rows;
+		}
+		last_group = group;
+
+		/* Make control widget */
+		if (record->value_type == jalv->forge.String) {
+			controller = make_entry(record);
+		} else if (record->value_type == jalv->forge.Path) {
+			controller = make_file_chooser(record);
+		} else {
+			const float val = get_float(record->def, 0.0f);
+			controller = make_controller(record, val);
+		}
+
+		record->widget = controller;
+		if (record->type == PORT) {
+			jalv->ports[record->index].widget = controller;
+		}
+		if (controller) {
+			/* Add row to table for this controller */
+			add_control_row(
+				port_table, n_rows++,
+				(record->label
+				 ? lilv_node_as_string(record->label)
+				 : lilv_node_as_uri(record->node)),
+				controller);
+
+			/* Set tooltip text from comment, if available */
+			LilvNode* comment = lilv_world_get(
+				jalv->world, record->node, jalv->nodes.rdfs_comment, NULL);
+			if (comment) {
+				gtk_widget_set_tooltip_text(controller->control,
+				                            lilv_node_as_string(comment));
+			}
+			lilv_node_free(comment);
+		}
+	}
+
+	if (n_rows > 0) {
+		gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
+		GtkWidget* alignment = gtk_alignment_new(0.5, 0.0, 1.0, 0.0);
+		gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 8, 8);
+		gtk_container_add(GTK_CONTAINER(alignment), port_table);
+		return alignment;
+	} else {
+		gtk_widget_destroy(port_table);
+		GtkWidget* button = gtk_button_new_with_label("Close");
+		g_signal_connect_swapped(button, "clicked",
+		                         G_CALLBACK(gtk_widget_destroy), window);
+		gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
+		return button;
+	}
+}
+
+static void
+build_menu(Jalv* jalv, GtkWidget* window, GtkWidget* vbox)
+{
+	GtkWidget* menu_bar  = gtk_menu_bar_new();
+	GtkWidget* file      = gtk_menu_item_new_with_mnemonic("_File");
+	GtkWidget* file_menu = gtk_menu_new();
+
+	GtkAccelGroup* ag = gtk_accel_group_new();
+	gtk_window_add_accel_group(GTK_WINDOW(window), ag);
+
+	GtkWidget* save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, ag);
+	GtkWidget* quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, ag);
+
+	gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), file_menu);
+	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save);
+	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
+
+	GtkWidget* pset_item   = gtk_menu_item_new_with_mnemonic("_Presets");
+	GtkWidget* pset_menu   = gtk_menu_new();
+	GtkWidget* save_preset = gtk_menu_item_new_with_mnemonic(
+		"_Save Preset...");
+	GtkWidget* delete_preset = gtk_menu_item_new_with_mnemonic(
+		"_Delete Current Preset...");
+	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pset_item), pset_menu);
+	gtk_menu_shell_append(GTK_MENU_SHELL(pset_menu), save_preset);
+	gtk_menu_shell_append(GTK_MENU_SHELL(pset_menu), delete_preset);
+	gtk_menu_shell_append(GTK_MENU_SHELL(pset_menu),
+	                      gtk_separator_menu_item_new());
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), pset_item);
+
+	PresetMenu menu = {
+		NULL, NULL, GTK_MENU(pset_menu),
+		g_sequence_new((GDestroyNotify)pset_menu_free)
+	};
+	jalv_load_presets(jalv, add_preset_to_menu, &menu);
+	finish_menu(&menu);
+
+	g_signal_connect(G_OBJECT(quit), "activate",
+	                 G_CALLBACK(on_quit_activate), window);
+
+	g_signal_connect(G_OBJECT(save), "activate",
+	                 G_CALLBACK(on_save_activate), jalv);
+
+	g_signal_connect(G_OBJECT(save_preset), "activate",
+	                 G_CALLBACK(on_save_preset_activate), jalv);
+
+	g_signal_connect(G_OBJECT(delete_preset), "activate",
+	                 G_CALLBACK(on_delete_preset_activate), jalv);
+
+	gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);
+}
+
+bool
+jalv_discover_ui(ZIX_UNUSED Jalv* jalv)
+{
+	return TRUE;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	jalv->window = window;
+
+	g_signal_connect(window, "destroy",
+	                 G_CALLBACK(on_window_destroy), jalv);
+
+	set_window_title(jalv);
+
+	GtkWidget* vbox = new_box(false, 0);
+	gtk_window_set_role(GTK_WINDOW(window), "plugin_ui");
+	gtk_container_add(GTK_CONTAINER(window), vbox);
+
+	if (!jalv->opts.no_menu) {
+		build_menu(jalv, window, vbox);
+	}
+
+	/* Create/show alignment to contain UI (whether custom or generic) */
+	GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
+	gtk_box_pack_start(GTK_BOX(vbox), alignment, TRUE, TRUE, 0);
+	gtk_widget_show(alignment);
+
+	/* Attempt to instantiate custom UI if necessary */
+	if (jalv->ui && !jalv->opts.generic_ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(), alignment);
+	}
+
+	if (jalv->ui_instance) {
+		GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(
+			jalv->ui_instance);
+
+		gtk_container_add(GTK_CONTAINER(alignment), widget);
+		gtk_window_set_resizable(GTK_WINDOW(window), jalv_ui_is_resizable(jalv));
+		gtk_widget_show_all(vbox);
+		gtk_widget_grab_focus(widget);
+	} else {
+		GtkWidget* controls   = build_control_widget(jalv, window);
+		GtkWidget* scroll_win = gtk_scrolled_window_new(NULL, NULL);
+		gtk_scrolled_window_add_with_viewport(
+			GTK_SCROLLED_WINDOW(scroll_win), controls);
+		gtk_scrolled_window_set_policy(
+			GTK_SCROLLED_WINDOW(scroll_win),
+			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+		gtk_container_add(GTK_CONTAINER(alignment), scroll_win);
+		gtk_widget_show_all(vbox);
+
+		GtkRequisition controls_size, box_size;
+		size_request(GTK_WIDGET(controls), &controls_size);
+		size_request(GTK_WIDGET(vbox), &box_size);
+
+		gtk_window_set_default_size(
+			GTK_WINDOW(window),
+			MAX(MAX(box_size.width, controls_size.width) + 24, 640),
+			box_size.height + controls_size.height);
+	}
+
+	jalv_init_ui(jalv);
+
+	g_timeout_add(1000 / jalv->ui_update_hz, (GSourceFunc)jalv_update, jalv);
+
+	gtk_window_present(GTK_WINDOW(window));
+
+	gtk_main();
+	suil_instance_free(jalv->ui_instance);
+	jalv->ui_instance = NULL;
+	zix_sem_post(&jalv->done);
+	return 0;
+}
+
+int
+jalv_close_ui(ZIX_UNUSED Jalv* jalv)
+{
+	gtk_main_quit();
+	return 0;
+}
+
+#if GTK_MAJOR_VERSION == 3
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+#    pragma GCC diagnostic pop
+#endif
+#endif
+
diff --git a/src/jalv_gtkmm2.cpp b/src/jalv_gtkmm2.cpp
new file mode 100644
index 0000000..ae0ac96
--- /dev/null
+++ b/src/jalv_gtkmm2.cpp
@@ -0,0 +1,110 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <gtkmm/button.h>
+#include <gtkmm/main.h>
+#include <gtkmm/window.h>
+
+#include "jalv_internal.h"
+
+Gtk::Main* jalv_gtk_main = NULL;
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	jalv_gtk_main = new Gtk::Main(*argc, *argv);
+	return 0;
+}
+
+const char*
+jalv_native_ui_type(void)
+{
+	return "http://lv2plug.in/ns/extensions/ui#GtkUI";
+}
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height)
+{
+	if (jalv->ui_instance) {
+		GtkWidget* widget = GTK_WIDGET(
+			suil_instance_get_widget(jalv->ui_instance));
+		if (widget) {
+			gtk_widget_set_size_request(GTK_WIDGET(widget), width, height);
+		}
+	}
+	return 0;
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+	if (jalv->ui_instance) {
+		suil_instance_port_event(jalv->ui_instance, port_index,
+		                         buffer_size, protocol, buffer);
+	}
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return true;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	Gtk::Window* window = new Gtk::Window();
+
+	if (jalv->ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(), NULL);
+	}
+
+	if (jalv->ui_instance) {
+		GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(
+			jalv->ui_instance);
+		Gtk::Widget* widgetmm = Glib::wrap(widget);
+		window->add(*Gtk::manage(widgetmm));
+		widgetmm->show_all();
+
+		g_timeout_add(1000 / jalv->ui_update_hz,
+		              (GSourceFunc)jalv_update, jalv);
+	} else {
+		Gtk::Button* button = Gtk::manage(new Gtk::Button("Close"));
+		window->add(*Gtk::manage(button));
+	}
+
+	window->set_resizable(jalv_ui_is_resizable(jalv));
+	window->show_all();
+
+	Gtk::Main::run(*window);
+
+	delete window;
+	delete jalv_gtk_main;
+	zix_sem_post(&jalv->done);
+
+	return 0;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	Gtk::Main::quit();
+	return 0;
+}
diff --git a/src/jalv_internal.h b/src/jalv_internal.h
new file mode 100644
index 0000000..9ee880c
--- /dev/null
+++ b/src/jalv_internal.h
@@ -0,0 +1,559 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef JALV_INTERNAL_H
+#define JALV_INTERNAL_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_ISATTY
+#    include <unistd.h>
+#endif
+
+#include "lilv/lilv.h"
+#include "serd/serd.h"
+#ifdef HAVE_SUIL
+#include "suil/suil.h"
+#endif
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
+#include "lv2/lv2plug.in/ns/ext/data-access/data-access.h"
+#include "lv2/lv2plug.in/ns/ext/log/log.h"
+#include "lv2/lv2plug.in/ns/ext/midi/midi.h"
+#include "lv2/lv2plug.in/ns/ext/resize-port/resize-port.h"
+#include "lv2/lv2plug.in/ns/ext/state/state.h"
+#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+#include "lv2/lv2plug.in/ns/ext/worker/worker.h"
+#include "lv2/lv2plug.in/ns/ext/options/options.h"
+
+#include "zix/ring.h"
+#include "zix/sem.h"
+#include "zix/thread.h"
+
+#include "sratom/sratom.h"
+
+#include "lv2_evbuf.h"
+#include "symap.h"
+
+#ifdef __clang__
+#    define REALTIME __attribute__((annotate("realtime")))
+#else
+#    define REALTIME
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct JalvBackend JalvBackend;
+
+typedef struct Jalv Jalv;
+
+enum PortFlow {
+	FLOW_UNKNOWN,
+	FLOW_INPUT,
+	FLOW_OUTPUT
+};
+
+enum PortType {
+	TYPE_UNKNOWN,
+	TYPE_CONTROL,
+	TYPE_AUDIO,
+	TYPE_EVENT,
+	TYPE_CV
+};
+
+struct Port {
+	const LilvPort* lilv_port;  ///< LV2 port
+	enum PortType   type;       ///< Data type
+	enum PortFlow   flow;       ///< Data flow direction
+	void*           sys_port;   ///< For audio/MIDI ports, otherwise NULL
+	LV2_Evbuf*      evbuf;      ///< For MIDI ports, otherwise NULL
+	void*           widget;     ///< Control widget, if applicable
+	size_t          buf_size;   ///< Custom buffer size, or 0
+	uint32_t        index;      ///< Port index
+	float           control;    ///< For control ports, otherwise 0.0f
+};
+
+/* Controls */
+
+/** Type of plugin control. */
+typedef enum {
+	PORT,     ///< Control port
+	PROPERTY  ///< Property (set via atom message)
+} ControlType;
+
+typedef struct {
+	float value;
+	char* label;
+} ScalePoint;
+
+/** Order scale points by value. */
+int scale_point_cmp(const ScalePoint* a, const ScalePoint* b);
+
+/** Plugin control. */
+typedef struct {
+	Jalv*       jalv;
+	ControlType type;
+	LilvNode*   node;
+	LilvNode*   symbol;          ///< Symbol
+	LilvNode*   label;           ///< Human readable label
+	LV2_URID    property;        ///< Iff type == PROPERTY
+	uint32_t    index;           ///< Iff type == PORT
+	LilvNode*   group;           ///< Port/control group, or NULL
+	void*       widget;          ///< Control Widget
+	size_t      n_points;        ///< Number of scale points
+	ScalePoint* points;          ///< Scale points
+	LV2_URID    value_type;      ///< Type of control value
+	LilvNode*   min;             ///< Minimum value
+	LilvNode*   max;             ///< Maximum value
+	LilvNode*   def;             ///< Default value
+	bool        is_toggle;       ///< Boolean (0 and 1 only)
+	bool        is_integer;      ///< Integer values only
+	bool        is_enumeration;  ///< Point values only
+	bool        is_logarithmic;  ///< Logarithmic scale
+	bool        is_writable;     ///< Writable (input)
+	bool        is_readable;     ///< Readable (output)
+} ControlID;
+
+ControlID*
+new_port_control(Jalv* jalv, uint32_t index);
+
+ControlID*
+new_property_control(Jalv* jalv, const LilvNode* property);
+
+typedef struct {
+	size_t      n_controls;
+	ControlID** controls;
+} Controls;
+
+void
+add_control(Controls* controls, ControlID* control);
+
+ControlID*
+get_property_control(const Controls* controls, LV2_URID property);
+
+/**
+   Control change event, sent through ring buffers for UI updates.
+*/
+typedef struct {
+	uint32_t index;
+	uint32_t protocol;
+	uint32_t size;
+	uint8_t  body[];
+} ControlChange;
+
+typedef struct {
+	char*    name;              ///< Client name
+	int      name_exact;        ///< Exit if name is taken
+	char*    uuid;              ///< Session UUID
+	char*    load;              ///< Path for state to load
+	char*    preset;            ///< URI of preset to load
+	char**   controls;          ///< Control values
+	uint32_t buffer_size;       ///< Plugin <= >UI communication buffer size
+	double   update_rate;       ///< UI update rate in Hz
+	int      dump;              ///< Dump communication iff true
+	int      trace;             ///< Print trace log iff true
+	int      generic_ui;        ///< Use generic UI iff true
+	int      show_hidden;       ///< Show controls for notOnGUI ports
+	int      no_menu;           ///< Hide menu iff true
+	int      show_ui;           ///< Show non-embedded UI
+	int      print_controls;    ///< Print control changes to stdout
+	int      non_interactive;   ///< Do not listen for commands on stdin
+} JalvOptions;
+
+typedef struct {
+	LV2_URID atom_Float;
+	LV2_URID atom_Int;
+	LV2_URID atom_Object;
+	LV2_URID atom_Path;
+	LV2_URID atom_String;
+	LV2_URID atom_eventTransfer;
+	LV2_URID bufsz_maxBlockLength;
+	LV2_URID bufsz_minBlockLength;
+	LV2_URID bufsz_sequenceSize;
+	LV2_URID log_Error;
+	LV2_URID log_Trace;
+	LV2_URID log_Warning;
+	LV2_URID midi_MidiEvent;
+	LV2_URID param_sampleRate;
+	LV2_URID patch_Get;
+	LV2_URID patch_Put;
+	LV2_URID patch_Set;
+	LV2_URID patch_body;
+	LV2_URID patch_property;
+	LV2_URID patch_value;
+	LV2_URID time_Position;
+	LV2_URID time_bar;
+	LV2_URID time_barBeat;
+	LV2_URID time_beatUnit;
+	LV2_URID time_beatsPerBar;
+	LV2_URID time_beatsPerMinute;
+	LV2_URID time_frame;
+	LV2_URID time_speed;
+	LV2_URID ui_updateRate;
+} JalvURIDs;
+
+typedef struct {
+	LilvNode* atom_AtomPort;
+	LilvNode* atom_Chunk;
+	LilvNode* atom_Float;
+	LilvNode* atom_Path;
+	LilvNode* atom_Sequence;
+	LilvNode* lv2_AudioPort;
+	LilvNode* lv2_CVPort;
+	LilvNode* lv2_ControlPort;
+	LilvNode* lv2_InputPort;
+	LilvNode* lv2_OutputPort;
+	LilvNode* lv2_connectionOptional;
+	LilvNode* lv2_control;
+	LilvNode* lv2_default;
+	LilvNode* lv2_enumeration;
+	LilvNode* lv2_integer;
+	LilvNode* lv2_maximum;
+	LilvNode* lv2_minimum;
+	LilvNode* lv2_name;
+	LilvNode* lv2_reportsLatency;
+	LilvNode* lv2_sampleRate;
+	LilvNode* lv2_symbol;
+	LilvNode* lv2_toggled;
+	LilvNode* midi_MidiEvent;
+	LilvNode* pg_group;
+	LilvNode* pprops_logarithmic;
+	LilvNode* pprops_notOnGUI;
+	LilvNode* pprops_rangeSteps;
+	LilvNode* pset_Preset;
+	LilvNode* pset_bank;
+	LilvNode* rdfs_comment;
+	LilvNode* rdfs_label;
+	LilvNode* rdfs_range;
+	LilvNode* rsz_minimumSize;
+	LilvNode* work_interface;
+	LilvNode* work_schedule;
+	LilvNode* end;  ///< NULL terminator for easy freeing of entire structure
+} JalvNodes;
+
+typedef enum {
+	JALV_RUNNING,
+	JALV_PAUSE_REQUESTED,
+	JALV_PAUSED
+} JalvPlayState;
+
+typedef struct {
+	Jalv*                       jalv;       ///< Pointer back to Jalv
+	ZixRing*                    requests;   ///< Requests to the worker
+	ZixRing*                    responses;  ///< Responses from the worker
+	void*                       response;   ///< Worker response buffer
+	ZixSem                      sem;        ///< Worker semaphore
+	ZixThread                   thread;     ///< Worker thread
+	const LV2_Worker_Interface* iface;      ///< Plugin worker interface
+	bool                        threaded;   ///< Run work in another thread
+} JalvWorker;
+
+typedef struct {
+	LV2_Feature                map_feature;
+	LV2_Feature                unmap_feature;
+	LV2_State_Make_Path        make_path;
+	LV2_Feature                make_path_feature;
+	LV2_Worker_Schedule        sched;
+	LV2_Feature                sched_feature;
+	LV2_Worker_Schedule        ssched;
+	LV2_Feature                state_sched_feature;
+	LV2_Log_Log                llog;
+	LV2_Feature                log_feature;
+	LV2_Options_Option         options[6];
+	LV2_Feature                options_feature;
+	LV2_Feature                safe_restore_feature;
+	LV2_Extension_Data_Feature ext_data;
+} JalvFeatures;
+
+struct Jalv {
+	JalvOptions        opts;           ///< Command-line options
+	JalvURIDs          urids;          ///< URIDs
+	JalvNodes          nodes;          ///< Nodes
+	LV2_Atom_Forge     forge;          ///< Atom forge
+	const char*        prog_name;      ///< Program name (argv[0])
+	LilvWorld*         world;          ///< Lilv World
+	LV2_URID_Map       map;            ///< URI => Int map
+	LV2_URID_Unmap     unmap;          ///< Int => URI map
+	SerdEnv*           env;            ///< Environment for RDF printing
+	Sratom*            sratom;         ///< Atom serialiser
+	Sratom*            ui_sratom;      ///< Atom serialiser for UI thread
+	Symap*             symap;          ///< URI map
+	ZixSem             symap_lock;     ///< Lock for URI map
+	JalvBackend*       backend;        ///< Audio system backend
+	ZixRing*           ui_events;      ///< Port events from UI
+	ZixRing*           plugin_events;  ///< Port events from plugin
+	void*              ui_event_buf;   ///< Buffer for reading UI port events
+	JalvWorker         worker;         ///< Worker thread implementation
+	JalvWorker         state_worker;   ///< Synchronous worker for state restore
+	ZixSem             work_lock;      ///< Lock for plugin work() method
+	ZixSem             done;           ///< Exit semaphore
+	ZixSem             paused;         ///< Paused signal from process thread
+	JalvPlayState      play_state;     ///< Current play state
+	char*              temp_dir;       ///< Temporary plugin state directory
+	char*              save_dir;       ///< Plugin save directory
+	const LilvPlugin*  plugin;         ///< Plugin class (RDF data)
+	LilvState*         preset;         ///< Current preset
+	LilvUIs*           uis;            ///< All plugin UIs (RDF data)
+	const LilvUI*      ui;             ///< Plugin UI (RDF data)
+	const LilvNode*    ui_type;        ///< Plugin UI type (unwrapped)
+	LilvInstance*      instance;       ///< Plugin instance (shared library)
+#ifdef HAVE_SUIL
+	SuilHost*          ui_host;        ///< Plugin UI host support
+	SuilInstance*      ui_instance;    ///< Plugin UI instance (shared library)
+#endif
+	void*              window;         ///< Window (if applicable)
+	struct Port*       ports;          ///< Port array of size num_ports
+	Controls           controls;       ///< Available plugin controls
+	uint32_t           block_length;   ///< Audio buffer size (block length)
+	size_t             midi_buf_size;  ///< Size of MIDI port buffers
+	uint32_t           control_in;     ///< Index of control input port
+	uint32_t           num_ports;      ///< Size of the two following arrays:
+	uint32_t           plugin_latency; ///< Latency reported by plugin (if any)
+	float              ui_update_hz;   ///< Frequency of UI updates
+	uint32_t           sample_rate;    ///< Sample rate
+	uint32_t           event_delta_t;  ///< Frames since last update sent to UI
+	uint32_t           position;       ///< Transport position in frames
+	float              bpm;            ///< Transport tempo in beats per minute
+	bool               rolling;        ///< Transport speed (0=stop, 1=play)
+	bool               buf_size_set;   ///< True iff buffer size callback fired
+	bool               exit;           ///< True iff execution is finished
+	bool               has_ui;         ///< True iff a control UI is present
+	bool               request_update; ///< True iff a plugin update is needed
+	bool               safe_restore;   ///< Plugin restore() is thread-safe
+	JalvFeatures       features;
+	const LV2_Feature** feature_list;
+};
+
+int
+jalv_open(Jalv* jalv, int argc, char** argv);
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts);
+
+int
+jalv_close(Jalv* jalv);
+
+JalvBackend*
+jalv_backend_init(Jalv* jalv);
+
+void
+jalv_backend_activate(Jalv* jalv);
+
+void
+jalv_backend_deactivate(Jalv* jalv);
+
+void
+jalv_backend_close(Jalv* jalv);
+
+/** Expose a port to the system (if applicable) and connect it to its buffer. */
+void
+jalv_backend_activate_port(Jalv* jalv, uint32_t port_index);
+
+void
+jalv_create_ports(Jalv* jalv);
+
+void
+jalv_allocate_port_buffers(Jalv* jalv);
+
+struct Port*
+jalv_port_by_symbol(Jalv* jalv, const char* sym);
+
+void
+jalv_create_controls(Jalv* jalv, bool writable);
+
+ControlID*
+jalv_control_by_symbol(Jalv* jalv, const char* sym);
+
+void
+jalv_set_control(const ControlID* control,
+                 uint32_t         size,
+                 LV2_URID         type,
+                 const void*      body);
+
+const char*
+jalv_native_ui_type(void);
+
+bool
+jalv_discover_ui(Jalv* jalv);
+
+int
+jalv_open_ui(Jalv* jalv);
+
+void
+jalv_init_ui(Jalv* jalv);
+
+int
+jalv_close_ui(Jalv* jalv);
+
+void
+jalv_ui_instantiate(Jalv*       jalv,
+                    const char* native_ui_type,
+                    void*       parent);
+
+bool
+jalv_ui_is_resizable(Jalv* jalv);
+
+void
+jalv_ui_write(void* const    controller,
+              uint32_t       port_index,
+              uint32_t       buffer_size,
+              uint32_t       protocol,
+              const void*    buffer);
+
+void
+jalv_apply_ui_events(Jalv* jalv, uint32_t nframes);
+
+uint32_t
+jalv_ui_port_index(void* const controller, const char* symbol);
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer);
+
+bool
+jalv_send_to_ui(Jalv*       jalv,
+                uint32_t    port_index,
+                uint32_t    type,
+                uint32_t    size,
+                const void* body);
+bool
+jalv_run(Jalv* jalv, uint32_t nframes);
+
+bool
+jalv_update(Jalv* jalv);
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height);
+
+typedef int (*PresetSink)(Jalv*           jalv,
+                          const LilvNode* node,
+                          const LilvNode* title,
+                          void*           data);
+
+int
+jalv_load_presets(Jalv* jalv, PresetSink sink, void* data);
+
+int
+jalv_unload_presets(Jalv* jalv);
+
+int
+jalv_apply_preset(Jalv* jalv, const LilvNode* preset);
+
+int
+jalv_delete_current_preset(Jalv* jalv);
+
+int
+jalv_save_preset(Jalv*       jalv,
+                 const char* dir,
+                 const char* uri,
+                 const char* label,
+                 const char* filename);
+
+void
+jalv_save(Jalv* jalv, const char* dir);
+
+void
+jalv_save_port_values(Jalv*           jalv,
+                      SerdWriter*     writer,
+                      const SerdNode* subject);
+char*
+jalv_make_path(LV2_State_Make_Path_Handle handle,
+               const char*                path);
+
+void
+jalv_apply_state(Jalv* jalv, LilvState* state);
+
+char*
+atom_to_turtle(LV2_URID_Unmap* unmap,
+               const SerdNode* subject,
+               const SerdNode* predicate,
+               const LV2_Atom* atom);
+
+static inline void
+jalv_print_control(Jalv* jalv, const struct Port* port, float value)
+{
+	const LilvNode* sym = lilv_port_get_symbol(jalv->plugin, port->lilv_port);
+	printf("%s = %f\n", lilv_node_as_string(sym), value);
+}
+
+static inline char*
+jalv_strdup(const char* str)
+{
+	const size_t len  = strlen(str);
+	char*        copy = (char*)malloc(len + 1);
+	memcpy(copy, str, len + 1);
+	return copy;
+}
+
+static inline char*
+jalv_strjoin(const char* a, const char* b)
+{
+	const size_t a_len = strlen(a);
+	const size_t b_len = strlen(b);
+	char* const  out   = (char*)malloc(a_len + b_len + 1);
+
+	memcpy(out,         a, a_len);
+	memcpy(out + a_len, b, b_len);
+	out[a_len + b_len] = '\0';
+
+	return out;
+}
+
+int
+jalv_printf(LV2_Log_Handle handle,
+            LV2_URID       type,
+            const char*    fmt, ...);
+
+int
+jalv_vprintf(LV2_Log_Handle handle,
+             LV2_URID       type,
+             const char*    fmt,
+             va_list        ap);
+
+static inline bool
+jalv_ansi_start(FILE* stream, int color)
+{
+#ifdef HAVE_ISATTY
+	if (isatty(fileno(stream))) {
+		return fprintf(stream, "\033[0;%dm", color);
+	}
+#endif
+	return 0;
+}
+
+static inline void
+jalv_ansi_reset(FILE* stream)
+{
+#ifdef HAVE_ISATTY
+	if (isatty(fileno(stream))) {
+		fprintf(stream, "\033[0m");
+		fflush(stream);
+	}
+#endif
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // JALV_INTERNAL_H
diff --git a/src/jalv_qt.cpp b/src/jalv_qt.cpp
new file mode 100644
index 0000000..582361f
--- /dev/null
+++ b/src/jalv_qt.cpp
@@ -0,0 +1,742 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+
+#include "jalv_internal.h"
+
+#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h"
+
+#include <qglobal.h>
+
+#if QT_VERSION >= 0x050000
+#    include <QAction>
+#    include <QApplication>
+#    include <QDial>
+#    include <QGroupBox>
+#    include <QLabel>
+#    include <QLayout>
+#    include <QMainWindow>
+#    include <QMenu>
+#    include <QMenuBar>
+#    include <QScrollArea>
+#    include <QStyle>
+#    include <QTimer>
+#    include <QWidget>
+#    include <QWindow>
+#else
+#    include <QtGui>
+#endif
+
+#define CONTROL_WIDTH 150
+#define DIAL_STEPS    10000
+
+static QApplication* app = NULL;
+
+class FlowLayout : public QLayout
+{
+public:
+	FlowLayout(QWidget* parent,
+	           int      margin   = -1,
+	           int      hSpacing = -1,
+	           int      vSpacing = -1);
+
+	FlowLayout(int margin = -1, int hSpacing = -1, int vSpacing = -1);
+
+	~FlowLayout();
+
+	void             addItem(QLayoutItem* item);
+	int              horizontalSpacing() const;
+	int              verticalSpacing() const;
+	Qt::Orientations expandingDirections() const;
+	bool             hasHeightForWidth() const;
+	int              heightForWidth(int) const;
+	int              count() const;
+	QLayoutItem*     itemAt(int index) const;
+	QSize            minimumSize() const;
+	void             setGeometry(const QRect &rect);
+	QSize            sizeHint() const;
+	QLayoutItem*     takeAt(int index);
+
+private:
+	int doLayout(const QRect &rect, bool testOnly) const;
+	int smartSpacing(QStyle::PixelMetric pm) const;
+
+	QList<QLayoutItem*> itemList;
+	int m_hSpace;
+	int m_vSpace;
+};
+
+FlowLayout::FlowLayout(QWidget* parent, int margin, int hSpacing, int vSpacing)
+	: QLayout(parent), m_hSpace(hSpacing), m_vSpace(vSpacing)
+{
+	setContentsMargins(margin, margin, margin, margin);
+}
+
+FlowLayout::FlowLayout(int margin, int hSpacing, int vSpacing)
+	: m_hSpace(hSpacing), m_vSpace(vSpacing)
+{
+	setContentsMargins(margin, margin, margin, margin);
+}
+
+FlowLayout::~FlowLayout()
+{
+	QLayoutItem* item;
+	while ((item = takeAt(0))) {
+		delete item;
+	}
+}
+
+void
+FlowLayout::addItem(QLayoutItem* item)
+{
+	itemList.append(item);
+}
+
+int
+FlowLayout::horizontalSpacing() const
+{
+	if (m_hSpace >= 0) {
+		return m_hSpace;
+	} else {
+		return smartSpacing(QStyle::PM_LayoutHorizontalSpacing);
+	}
+}
+
+int
+FlowLayout::verticalSpacing() const
+{
+	if (m_vSpace >= 0) {
+		return m_vSpace;
+	} else {
+		return smartSpacing(QStyle::PM_LayoutVerticalSpacing);
+	}
+}
+
+int
+FlowLayout::count() const
+{
+	return itemList.size();
+}
+
+QLayoutItem*
+FlowLayout::itemAt(int index) const
+{
+	return itemList.value(index);
+}
+
+QLayoutItem*
+FlowLayout::takeAt(int index)
+{
+	if (index >= 0 && index < itemList.size()) {
+		return itemList.takeAt(index);
+	} else {
+		return 0;
+	}
+}
+
+Qt::Orientations
+FlowLayout::expandingDirections() const
+{
+	return 0;
+}
+
+bool
+FlowLayout::hasHeightForWidth() const
+{
+	return true;
+}
+
+int
+FlowLayout::heightForWidth(int width) const
+{
+	return doLayout(QRect(0, 0, width, 0), true);
+}
+
+void
+FlowLayout::setGeometry(const QRect &rect)
+{
+	QLayout::setGeometry(rect);
+	doLayout(rect, false);
+}
+
+QSize
+FlowLayout::sizeHint() const
+{
+	return minimumSize();
+}
+
+QSize
+FlowLayout::minimumSize() const
+{
+	QSize        size;
+	QLayoutItem* item;
+	foreach (item, itemList) {
+		size = size.expandedTo(item->minimumSize());
+	}
+
+	return size + QSize(2 * margin(), 2 * margin());
+}
+
+int
+FlowLayout::doLayout(const QRect &rect, bool testOnly) const
+{
+	int left, top, right, bottom;
+	getContentsMargins(&left, &top, &right, &bottom);
+
+	QRect effectiveRect = rect.adjusted(+left, +top, -right, -bottom);
+	int   x             = effectiveRect.x();
+	int   y             = effectiveRect.y();
+	int   lineHeight    = 0;
+
+	QLayoutItem* item;
+	foreach (item, itemList) {
+		QWidget* wid = item->widget();
+
+		int spaceX = horizontalSpacing();
+		if (spaceX == -1) {
+			spaceX = wid->style()->layoutSpacing(QSizePolicy::PushButton,
+			                                     QSizePolicy::PushButton,
+			                                     Qt::Horizontal);
+		}
+		int spaceY = verticalSpacing();
+		if (spaceY == -1) {
+			spaceY = wid->style()->layoutSpacing(QSizePolicy::PushButton,
+			                                     QSizePolicy::PushButton,
+			                                     Qt::Vertical);
+		}
+
+		int nextX = x + item->sizeHint().width() + spaceX;
+		if (nextX - spaceX > effectiveRect.right() && lineHeight > 0) {
+			x          = effectiveRect.x();
+			y          = y + lineHeight + spaceY;
+			nextX      = x + item->sizeHint().width() + spaceX;
+			lineHeight = 0;
+		}
+
+		if (!testOnly) {
+			item->setGeometry(QRect(QPoint(x, y), item->sizeHint()));
+		}
+
+		x          = nextX;
+		lineHeight = qMax(lineHeight, item->sizeHint().height());
+	}
+	return y + lineHeight - rect.y() + bottom;
+}
+
+int
+FlowLayout::smartSpacing(QStyle::PixelMetric pm) const
+{
+	QObject* parent = this->parent();
+	if (!parent) {
+		return -1;
+	} else if (parent->isWidgetType()) {
+		QWidget* pw = static_cast<QWidget*>(parent);
+		return pw->style()->pixelMetric(pm, 0, pw);
+	} else {
+		return static_cast<QLayout*>(parent)->spacing();
+	}
+}
+
+class PresetAction : public QAction
+{
+	Q_OBJECT
+
+public:
+	PresetAction(QObject* parent, Jalv* jalv, LilvNode* preset)
+		: QAction(parent)
+		, _jalv(jalv)
+		, _preset(preset)
+	{
+		connect(this, SIGNAL(triggered()),
+		        this, SLOT(presetChosen()));
+	}
+
+	Q_SLOT void presetChosen() {
+		jalv_apply_preset(_jalv, _preset);
+	}
+
+private:
+	Jalv*     _jalv;
+	LilvNode* _preset;
+};
+
+typedef struct {
+	Jalv*        jalv;
+	struct Port* port;
+} PortContainer;
+
+class Control : public QGroupBox
+{
+	Q_OBJECT
+
+public:
+	Control(PortContainer portContainer, QWidget* parent = 0);
+
+	Q_SLOT void dialChanged(int value);
+
+	void setValue(float value);
+
+	QDial* dial;
+
+private:
+	void    setRange(float min, float max);
+	QString getValueLabel(float value);
+	float   getValue();
+
+	const LilvPlugin* plugin;
+	struct Port*      port;
+
+	QLabel* label;
+	QString name;
+	int     steps;
+	float   max;
+	float   min;
+	bool    isInteger;
+	bool    isEnum;
+	bool    isLogarithmic;
+
+	std::vector<float>           scalePoints;
+	std::map<float, const char*> scaleMap;
+};
+
+#if QT_VERSION >= 0x050000
+#    include "jalv_qt5_meta.hpp"
+#else
+#    include "jalv_qt4_meta.hpp"
+#endif
+
+extern "C" {
+
+int
+jalv_init(int* argc, char*** argv, JalvOptions* opts)
+{
+	app = new QApplication(*argc, *argv, true);
+	app->setStyleSheet("QGroupBox::title { subcontrol-position: top center }");
+
+	return 0;
+}
+
+const char*
+jalv_native_ui_type(void)
+{
+#if QT_VERSION >= 0x050000
+	return "http://lv2plug.in/ns/extensions/ui#Qt5UI";
+#else
+	return "http://lv2plug.in/ns/extensions/ui#Qt4UI";
+#endif
+}
+
+int
+jalv_ui_resize(Jalv* jalv, int width, int height)
+{
+	if (jalv->ui_instance && width > 0 && height > 0) {
+		QWidget* widget = (QWidget*)suil_instance_get_widget(jalv->ui_instance);
+		if (widget) {
+			widget->resize(width, height);
+		}
+	}
+	return 0;
+}
+
+void
+jalv_ui_port_event(Jalv*       jalv,
+                   uint32_t    port_index,
+                   uint32_t    buffer_size,
+                   uint32_t    protocol,
+                   const void* buffer)
+{
+	if (jalv->ui_instance) {
+		suil_instance_port_event(jalv->ui_instance, port_index,
+		                         buffer_size, protocol, buffer);
+	} else {
+		Control* control = (Control*)jalv->ports[port_index].widget;
+		if (control) {
+			control->setValue(*(const float*)buffer);
+		}
+	}
+}
+
+class Timer : public QTimer
+{
+public:
+	explicit Timer(Jalv* jalv) : _jalv(jalv) {}
+
+	void timerEvent(QTimerEvent* e) {
+		jalv_update(_jalv);
+	}
+
+private:
+	Jalv* _jalv;
+};
+
+static int
+add_preset_to_menu(Jalv*           jalv,
+                   const LilvNode* node,
+                   const LilvNode* title,
+                   void*           data)
+{
+	QMenu*      menu  = (QMenu*)data;
+	const char* label = lilv_node_as_string(title);
+
+	QAction* action = new PresetAction(menu, jalv, lilv_node_duplicate(node));
+	action->setText(label);
+	menu->addAction(action);
+	return 0;
+}
+
+Control::Control(PortContainer portContainer, QWidget* parent)
+	: QGroupBox(parent)
+	, dial(new QDial())
+	, plugin(portContainer.jalv->plugin)
+	, port(portContainer.port)
+	, label(new QLabel())
+{
+	JalvNodes*      nodes    = &portContainer.jalv->nodes;
+	const LilvPort* lilvPort = port->lilv_port;
+
+	LilvNode* nmin;
+	LilvNode* nmax;
+	LilvNode* ndef;
+	lilv_port_get_range(plugin, lilvPort, &ndef, &nmin, &nmax);
+
+	LilvNode* stepsNode = lilv_port_get(plugin, lilvPort, nodes->pprops_rangeSteps);
+	if (lilv_node_is_int(stepsNode)) {
+		steps = std::max(lilv_node_as_int(stepsNode), 2);
+	} else {
+		steps = DIAL_STEPS;
+	}
+	lilv_node_free(stepsNode);
+
+	// Fill scalePoints Map
+	LilvScalePoints* sp = lilv_port_get_scale_points(plugin, lilvPort);
+	if (sp) {
+		LILV_FOREACH(scale_points, s, sp) {
+			const LilvScalePoint* p   = lilv_scale_points_get(sp, s);
+			const LilvNode*       val = lilv_scale_point_get_value(p);
+			if (!lilv_node_is_float(val) && !lilv_node_is_int(val)) {
+				continue;
+			}
+
+			const float f = lilv_node_as_float(val);
+			scalePoints.push_back(f);
+			scaleMap[f] = lilv_node_as_string(lilv_scale_point_get_label(p));
+		}
+
+		lilv_scale_points_free(sp);
+	}
+
+	// Check port properties
+	isLogarithmic = lilv_port_has_property(plugin, lilvPort, nodes->pprops_logarithmic);
+	isInteger     = lilv_port_has_property(plugin, lilvPort, nodes->lv2_integer);
+	isEnum        = lilv_port_has_property(plugin, lilvPort, nodes->lv2_enumeration);
+
+	if (lilv_port_has_property(plugin, lilvPort, nodes->lv2_toggled)) {
+		isInteger = true;
+
+		if (!scaleMap[0]) {
+			scaleMap[0] = "Off";
+		}
+		if (!scaleMap[1]) {
+			scaleMap[1] = "On" ;
+		}
+	}
+
+	// Find and set min, max and default values for port
+	float defaultValue = ndef ? lilv_node_as_float(ndef) : port->control;
+	setRange(lilv_node_as_float(nmin), lilv_node_as_float(nmax));
+	setValue(defaultValue);
+
+	// Fill layout
+	QVBoxLayout* layout = new QVBoxLayout();
+	layout->addWidget(label, 0, Qt::AlignHCenter);
+	layout->addWidget(dial, 0, Qt::AlignHCenter);
+	setLayout(layout);
+
+	setMinimumWidth(CONTROL_WIDTH);
+	setMaximumWidth(CONTROL_WIDTH);
+
+	LilvNode* nname = lilv_port_get_name(plugin, lilvPort);
+	name = QString("%1").arg(lilv_node_as_string(nname));
+
+	// Handle long names
+	if (fontMetrics().width(name) > CONTROL_WIDTH) {
+		setTitle(fontMetrics().elidedText(name, Qt::ElideRight, CONTROL_WIDTH));
+	} else {
+		setTitle(name);
+	}
+
+	// Set tooltip if comment is available
+	LilvNode* comment = lilv_port_get(plugin, lilvPort, nodes->rdfs_comment);
+	if (comment) {
+		QString* tooltip = new QString();
+		tooltip->append(lilv_node_as_string(comment));
+		setToolTip(*tooltip);
+	}
+
+	setFlat(true);
+
+	connect(dial, SIGNAL(valueChanged(int)), this, SLOT(dialChanged(int)));
+
+	lilv_node_free(nmin);
+	lilv_node_free(nmax);
+	lilv_node_free(ndef);
+	lilv_node_free(nname);
+	lilv_node_free(comment);
+}
+
+void
+Control::setValue(float value)
+{
+	float step;
+
+	if (isInteger) {
+		step = value;
+	} else if (isEnum) {
+		step = (std::find(scalePoints.begin(), scalePoints.end(), value)
+		        - scalePoints.begin());
+	} else if (isLogarithmic) {
+		step = steps * log(value / min) / log(max / min);
+	} else {
+		step = value * steps;
+	}
+
+	dial->setValue(step);
+	label->setText(getValueLabel(value));
+}
+
+QString
+Control::getValueLabel(float value)
+{
+	if (scaleMap[value]) {
+		if (fontMetrics().width(scaleMap[value]) > CONTROL_WIDTH) {
+			label->setToolTip(scaleMap[value]);
+			return fontMetrics().elidedText(QString(scaleMap[value]),
+			                                Qt::ElideRight,
+			                                CONTROL_WIDTH);
+		}
+		return scaleMap[value];
+	}
+
+	return QString("%1").arg(value);
+}
+
+void
+Control::setRange(float minRange, float maxRange)
+{
+	min = minRange;
+	max = maxRange;
+
+	if (isLogarithmic) {
+		minRange = 1;
+		maxRange = steps;
+	} else if (isEnum) {
+		minRange = 0;
+		maxRange = scalePoints.size() - 1;
+	} else if (!isInteger) {
+		minRange *= steps;
+		maxRange *= steps;
+	}
+
+	dial->setRange(minRange, maxRange);
+}
+
+float
+Control::getValue()
+{
+	if (isEnum) {
+		return scalePoints[dial->value()];
+	} else if (isInteger) {
+		return dial->value();
+	} else if (isLogarithmic) {
+		return min * pow(max / min, (float)dial->value() / (steps - 1));
+	} else {
+		return (float)dial->value() / steps;
+	}
+}
+
+void
+Control::dialChanged(int dialValue)
+{
+	float value = getValue();
+
+	label->setText(getValueLabel(value));
+	port->control = value;
+}
+
+static bool
+portGroupLessThan(const PortContainer &p1, const PortContainer &p2)
+{
+	Jalv*           jalv  = p1.jalv;
+	const LilvPort* port1 = p1.port->lilv_port;
+	const LilvPort* port2 = p2.port->lilv_port;
+
+	LilvNode* group1 = lilv_port_get(
+		jalv->plugin, port1, jalv->nodes.pg_group);
+	LilvNode* group2 = lilv_port_get(
+		jalv->plugin, port2, jalv->nodes.pg_group);
+
+	const int cmp = (group1 && group2)
+		? strcmp(lilv_node_as_string(group1), lilv_node_as_string(group2))
+		: ((intptr_t)group1 - (intptr_t)group2);
+
+	lilv_node_free(group2);
+	lilv_node_free(group1);
+
+	return cmp < 0;
+}
+
+static QWidget*
+build_control_widget(Jalv* jalv)
+{
+	const LilvPlugin* plugin = jalv->plugin;
+	LilvWorld*        world  = jalv->world;
+
+	QList<PortContainer> portContainers;
+	for (unsigned i = 0; i < jalv->num_ports; ++i) {
+		if (!jalv->opts.show_hidden &&
+		    lilv_port_has_property(plugin, jalv->ports[i].lilv_port,
+		                           jalv->nodes.pprops_notOnGUI)) {
+			continue;
+		}
+
+		if (jalv->ports[i].type == TYPE_CONTROL) {
+			PortContainer portContainer;
+			portContainer.jalv = jalv;
+			portContainer.port = &jalv->ports[i];
+			portContainers.append(portContainer);
+		}
+	}
+
+	qSort(portContainers.begin(), portContainers.end(), portGroupLessThan);
+
+	QWidget*    grid       = new QWidget();
+	FlowLayout* flowLayout = new FlowLayout();
+	QLayout*    layout     = flowLayout;
+
+	LilvNode*    lastGroup   = NULL;
+	QHBoxLayout* groupLayout = NULL;
+	for (int i = 0; i < portContainers.count(); ++i) {
+		PortContainer portContainer = portContainers[i];
+		Port*         port          = portContainer.port;
+
+		Control*  control = new Control(portContainer);
+		LilvNode* group   = lilv_port_get(
+			plugin, port->lilv_port, jalv->nodes.pg_group);
+		if (group) {
+			if (!lilv_node_equals(group, lastGroup)) {
+				/* Group has changed */
+				LilvNode* groupName = lilv_world_get(
+					world, group, jalv->nodes.lv2_name, NULL);
+				QGroupBox* groupBox = new QGroupBox(lilv_node_as_string(groupName));
+
+				groupLayout = new QHBoxLayout();
+				groupBox->setLayout(groupLayout);
+				layout->addWidget(groupBox);
+			}
+
+			groupLayout->addWidget(control);
+		} else {
+			layout->addWidget(control);
+		}
+		lilv_node_free(lastGroup);
+		lastGroup = group;
+
+		uint32_t index = lilv_port_get_index(plugin, port->lilv_port);
+		jalv->ports[index].widget = control;
+	}
+	lilv_node_free(lastGroup);
+
+	grid->setLayout(layout);
+
+	return grid;
+}
+
+bool
+jalv_discover_ui(Jalv* jalv)
+{
+	return true;
+}
+
+int
+jalv_open_ui(Jalv* jalv)
+{
+	QMainWindow* win          = new QMainWindow();
+	QMenu*       file_menu    = win->menuBar()->addMenu("&File");
+	QMenu*       presets_menu = win->menuBar()->addMenu("&Presets");
+	QAction*     quit_action  = new QAction("&Quit", win);
+
+	QObject::connect(quit_action, SIGNAL(triggered()), win, SLOT(close()));
+	quit_action->setShortcuts(QKeySequence::Quit);
+	quit_action->setStatusTip("Quit Jalv");
+	file_menu->addAction(quit_action);
+
+	jalv_load_presets(jalv, add_preset_to_menu, presets_menu);
+
+	if (jalv->ui && !jalv->opts.generic_ui) {
+		jalv_ui_instantiate(jalv, jalv_native_ui_type(), win);
+	}
+
+	QWidget* widget;
+	if (jalv->ui_instance) {
+		widget = (QWidget*)suil_instance_get_widget(jalv->ui_instance);
+	} else {
+		QWidget* controlWidget = build_control_widget(jalv);
+
+		widget = new QScrollArea();
+		((QScrollArea*)widget)->setWidget(controlWidget);
+		((QScrollArea*)widget)->setWidgetResizable(true);
+		widget->setMinimumWidth(800);
+		widget->setMinimumHeight(600);
+	}
+
+	LilvNode* name = lilv_plugin_get_name(jalv->plugin);
+	win->setWindowTitle(lilv_node_as_string(name));
+	lilv_node_free(name);
+
+	win->setCentralWidget(widget);
+	app->connect(app, SIGNAL(lastWindowClosed()), app, SLOT(quit()));
+
+	win->show();
+	if (jalv->ui_instance && !jalv_ui_is_resizable(jalv)) {
+		widget->setMinimumSize(widget->width(), widget->height());
+		widget->setMaximumSize(widget->width(), widget->height());
+		win->adjustSize();
+		win->setFixedSize(win->width(), win->height());
+	} else {
+		win->resize(widget->width(),
+		            widget->height() + win->menuBar()->height());
+	}
+
+	Timer* timer = new Timer(jalv);
+	timer->start(1000 / jalv->ui_update_hz);
+
+	int ret = app->exec();
+	zix_sem_post(&jalv->done);
+	return ret;
+}
+
+int
+jalv_close_ui(Jalv* jalv)
+{
+	app->quit();
+	return 0;
+}
+
+}  // extern "C"
diff --git a/src/log.c b/src/log.c
new file mode 100644
index 0000000..45a8f59
--- /dev/null
+++ b/src/log.c
@@ -0,0 +1,60 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "jalv_internal.h"
+
+int
+jalv_printf(LV2_Log_Handle handle,
+            LV2_URID       type,
+            const char*    fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	const int ret = jalv_vprintf(handle, type, fmt, args);
+	va_end(args);
+	return ret;
+}
+
+int
+jalv_vprintf(LV2_Log_Handle handle,
+             LV2_URID       type,
+             const char*    fmt,
+             va_list        ap)
+{
+	// TODO: Lock
+	Jalv* jalv  = (Jalv*)handle;
+	bool  fancy = true;
+	if (type == jalv->urids.log_Trace && jalv->opts.trace) {
+		jalv_ansi_start(stderr, 32);
+		fprintf(stderr, "trace: ");
+	} else if (type == jalv->urids.log_Error) {
+		jalv_ansi_start(stderr, 31);
+		fprintf(stderr, "error: ");
+	} else if (type == jalv->urids.log_Warning) {
+		jalv_ansi_start(stderr, 33);
+		fprintf(stderr, "warning: ");
+	} else {
+		fancy = false;
+	}
+
+	const int st = vfprintf(stderr, fmt, ap);
+
+	if (fancy) {
+		jalv_ansi_reset(stderr);
+	}
+
+	return st;
+}
diff --git a/src/lv2_evbuf.c b/src/lv2_evbuf.c
new file mode 100644
index 0000000..d7012c7
--- /dev/null
+++ b/src/lv2_evbuf.c
@@ -0,0 +1,180 @@
+/*
+  Copyright 2008-2018 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+
+#include "lv2_evbuf.h"
+
+struct LV2_Evbuf_Impl {
+	uint32_t          capacity;
+	uint32_t          atom_Chunk;
+	uint32_t          atom_Sequence;
+	LV2_Atom_Sequence buf;
+};
+
+static inline uint32_t
+lv2_evbuf_pad_size(uint32_t size)
+{
+	return (size + 7) & (~7);
+}
+
+LV2_Evbuf*
+lv2_evbuf_new(uint32_t capacity, uint32_t atom_Chunk, uint32_t atom_Sequence)
+{
+	// FIXME: memory must be 64-bit aligned
+	LV2_Evbuf* evbuf = (LV2_Evbuf*)malloc(
+		sizeof(LV2_Evbuf) + sizeof(LV2_Atom_Sequence) + capacity);
+	evbuf->capacity      = capacity;
+	evbuf->atom_Chunk    = atom_Chunk;
+	evbuf->atom_Sequence = atom_Sequence;
+	lv2_evbuf_reset(evbuf, true);
+	return evbuf;
+}
+
+void
+lv2_evbuf_free(LV2_Evbuf* evbuf)
+{
+	free(evbuf);
+}
+
+void
+lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input)
+{
+	if (input) {
+		evbuf->buf.atom.size = sizeof(LV2_Atom_Sequence_Body);
+		evbuf->buf.atom.type = evbuf->atom_Sequence;
+	} else {
+		evbuf->buf.atom.size = evbuf->capacity;
+		evbuf->buf.atom.type = evbuf->atom_Chunk;
+	}
+}
+
+uint32_t
+lv2_evbuf_get_size(LV2_Evbuf* evbuf)
+{
+	assert(evbuf->buf.atom.type != evbuf->atom_Sequence
+	       || evbuf->buf.atom.size >= sizeof(LV2_Atom_Sequence_Body));
+	return evbuf->buf.atom.type == evbuf->atom_Sequence
+		? evbuf->buf.atom.size - sizeof(LV2_Atom_Sequence_Body)
+		: 0;
+}
+
+void*
+lv2_evbuf_get_buffer(LV2_Evbuf* evbuf)
+{
+	return &evbuf->buf;
+}
+
+LV2_Evbuf_Iterator
+lv2_evbuf_begin(LV2_Evbuf* evbuf)
+{
+	LV2_Evbuf_Iterator iter = { evbuf, 0 };
+	return iter;
+}
+
+LV2_Evbuf_Iterator
+lv2_evbuf_end(LV2_Evbuf* evbuf)
+{
+	const uint32_t           size = lv2_evbuf_get_size(evbuf);
+	const LV2_Evbuf_Iterator iter = { evbuf, lv2_evbuf_pad_size(size) };
+	return iter;
+}
+
+bool
+lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter)
+{
+	return iter.offset < lv2_evbuf_get_size(iter.evbuf);
+}
+
+LV2_Evbuf_Iterator
+lv2_evbuf_next(LV2_Evbuf_Iterator iter)
+{
+	if (!lv2_evbuf_is_valid(iter)) {
+		return iter;
+	}
+
+	LV2_Evbuf* evbuf  = iter.evbuf;
+	uint32_t   offset = iter.offset;
+	uint32_t   size;
+	size = ((LV2_Atom_Event*)
+	        ((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &evbuf->buf.atom)
+	         + offset))->body.size;
+	offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size);
+
+	LV2_Evbuf_Iterator next = { evbuf, offset };
+	return next;
+}
+
+bool
+lv2_evbuf_get(LV2_Evbuf_Iterator iter,
+              uint32_t*          frames,
+              uint32_t*          subframes,
+              uint32_t*          type,
+              uint32_t*          size,
+              uint8_t**          data)
+{
+	*frames = *subframes = *type = *size = 0;
+	*data = NULL;
+
+	if (!lv2_evbuf_is_valid(iter)) {
+		return false;
+	}
+
+	LV2_Atom_Sequence* aseq = &iter.evbuf->buf;
+	LV2_Atom_Event*    aev  = (LV2_Atom_Event*)(
+		(char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) + iter.offset);
+
+	*frames    = aev->time.frames;
+	*subframes = 0;
+	*type      = aev->body.type;
+	*size      = aev->body.size;
+	*data      = (uint8_t*)LV2_ATOM_BODY(&aev->body);
+
+	return true;
+}
+
+bool
+lv2_evbuf_write(LV2_Evbuf_Iterator* iter,
+                uint32_t            frames,
+                uint32_t            subframes,
+                uint32_t            type,
+                uint32_t            size,
+                const uint8_t*      data)
+{
+	LV2_Atom_Sequence* aseq = &iter->evbuf->buf;
+	if (iter->evbuf->capacity - sizeof(LV2_Atom) - aseq->atom.size <
+	    sizeof(LV2_Atom_Event) + size) {
+		return false;
+	}
+
+	LV2_Atom_Event* aev = (LV2_Atom_Event*)(
+		(char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) + iter->offset);
+
+	aev->time.frames    = frames;
+	aev->body.type      = type;
+	aev->body.size      = size;
+	memcpy(LV2_ATOM_BODY(&aev->body), data, size);
+
+	size = lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size);
+	aseq->atom.size += size;
+	iter->offset += size;
+
+	return true;
+}
diff --git a/src/lv2_evbuf.h b/src/lv2_evbuf.h
new file mode 100644
index 0000000..fad1006
--- /dev/null
+++ b/src/lv2_evbuf.h
@@ -0,0 +1,139 @@
+/*
+  Copyright 2008-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef LV2_EVBUF_H
+#define LV2_EVBUF_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+/**
+   An abstract/opaque LV2 event buffer.
+*/
+typedef struct LV2_Evbuf_Impl LV2_Evbuf;
+
+/**
+   An iterator over an LV2_Evbuf.
+*/
+typedef struct {
+	LV2_Evbuf* evbuf;
+	uint32_t   offset;
+} LV2_Evbuf_Iterator;
+
+/**
+   Allocate a new, empty event buffer.
+   URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM.
+*/
+LV2_Evbuf*
+lv2_evbuf_new(uint32_t capacity, uint32_t atom_Chunk, uint32_t atom_Sequence);
+
+/**
+   Free an event buffer allocated with lv2_evbuf_new.
+*/
+void
+lv2_evbuf_free(LV2_Evbuf* evbuf);
+
+/**
+   Clear and initialize an existing event buffer.
+   The contents of buf are ignored entirely and overwritten, except capacity
+   which is unmodified.
+   If input is false and this is an atom buffer, the buffer will be prepared
+   for writing by the plugin.  This MUST be called before every run cycle.
+*/
+void
+lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input);
+
+/**
+   Return the total padded size of the events stored in the buffer.
+*/
+uint32_t
+lv2_evbuf_get_size(LV2_Evbuf* evbuf);
+
+/**
+   Return the actual buffer implementation.
+   The format of the buffer returned depends on the buffer type.
+*/
+void*
+lv2_evbuf_get_buffer(LV2_Evbuf* evbuf);
+
+/**
+   Return an iterator to the start of `evbuf`.
+*/
+LV2_Evbuf_Iterator
+lv2_evbuf_begin(LV2_Evbuf* evbuf);
+
+/**
+   Return an iterator to the end of `evbuf`.
+*/
+LV2_Evbuf_Iterator
+lv2_evbuf_end(LV2_Evbuf* evbuf);
+
+/**
+   Check if `iter` is valid.
+   @return True if `iter` is valid, otherwise false (past end of buffer)
+*/
+bool
+lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter);
+
+/**
+   Advance `iter` forward one event.
+   `iter` must be valid.
+   @return True if `iter` is valid, otherwise false (reached end of buffer)
+*/
+LV2_Evbuf_Iterator
+lv2_evbuf_next(LV2_Evbuf_Iterator iter);
+
+/**
+   Dereference an event iterator (i.e. get the event currently pointed to).
+   `iter` must be valid.
+   `type` Set to the type of the event.
+   `size` Set to the size of the event.
+   `data` Set to the contents of the event.
+   @return True on success.
+*/
+bool
+lv2_evbuf_get(LV2_Evbuf_Iterator iter,
+              uint32_t*          frames,
+              uint32_t*          subframes,
+              uint32_t*          type,
+              uint32_t*          size,
+              uint8_t**          data);
+
+/**
+   Write an event at `iter`.
+   The event (if any) pointed to by `iter` will be overwritten, and `iter`
+   incremented to point to the following event (i.e. several calls to this
+   function can be done in sequence without twiddling iter in-between).
+   @return True if event was written, otherwise false (buffer is full).
+*/
+bool
+lv2_evbuf_write(LV2_Evbuf_Iterator* iter,
+                uint32_t            frames,
+                uint32_t            subframes,
+                uint32_t            type,
+                uint32_t            size,
+                const uint8_t*      data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LV2_EVBUF_H */
diff --git a/src/portaudio.c b/src/portaudio.c
new file mode 100644
index 0000000..1425e4d
--- /dev/null
+++ b/src/portaudio.c
@@ -0,0 +1,223 @@
+/*
+   Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+   Permission to use, copy, modify, and/or distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <math.h>
+#include <portaudio.h>
+
+#include "jalv_internal.h"
+#include "worker.h"
+
+struct JalvBackend {
+	PaStream* stream;
+};
+
+static int
+pa_process_cb(const void*                     inputs,
+              void*                           outputs,
+              unsigned long                   nframes,
+              const PaStreamCallbackTimeInfo* time,
+              PaStreamCallbackFlags           flags,
+              void*                           handle)
+{
+	Jalv* jalv = (Jalv*)handle;
+
+	/* Prepare port buffers */
+	uint32_t in_index  = 0;
+	uint32_t out_index = 0;
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		struct Port* port = &jalv->ports[i];
+		if (port->type == TYPE_AUDIO) {
+			if (port->flow == FLOW_INPUT) {
+				lilv_instance_connect_port(jalv->instance, i, ((float**)inputs)[in_index++]);
+			} else if (port->flow == FLOW_OUTPUT) {
+				lilv_instance_connect_port(jalv->instance, i, ((float**)outputs)[out_index++]);
+			}
+		} else if (port->type == TYPE_EVENT && port->flow == FLOW_INPUT) {
+			lv2_evbuf_reset(port->evbuf, true);
+
+			if (jalv->request_update) {
+				/* Plugin state has changed, request an update */
+				const LV2_Atom_Object get = {
+					{ sizeof(LV2_Atom_Object_Body), jalv->urids.atom_Object },
+					{ 0, jalv->urids.patch_Get } };
+				LV2_Evbuf_Iterator iter = lv2_evbuf_begin(port->evbuf);
+				lv2_evbuf_write(&iter, 0, 0,
+				                get.atom.type, get.atom.size,
+				                (const uint8_t*)LV2_ATOM_BODY(&get));
+			}
+		} else if (port->type == TYPE_EVENT) {
+			/* Clear event output for plugin to write to */
+			lv2_evbuf_reset(port->evbuf, false);
+		}
+	}
+	jalv->request_update = false;
+
+	/* Run plugin for this cycle */
+	const bool send_ui_updates = jalv_run(jalv, nframes);
+
+	/* Deliver UI events */
+	for (uint32_t p = 0; p < jalv->num_ports; ++p) {
+		struct Port* const port = &jalv->ports[p];
+		if (port->flow == FLOW_OUTPUT && port->type == TYPE_EVENT) {
+			for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf);
+			     lv2_evbuf_is_valid(i);
+			     i = lv2_evbuf_next(i)) {
+				// Get event from LV2 buffer
+				uint32_t frames, subframes, type, size;
+				uint8_t* body;
+				lv2_evbuf_get(i, &frames, &subframes, &type, &size, &body);
+
+				if (jalv->has_ui) {
+					// Forward event to UI
+					jalv_send_to_ui(jalv, p, type, size, body);
+				}
+			}
+		} else if (send_ui_updates &&
+		           port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL) {
+			char buf[sizeof(ControlChange) + sizeof(float)];
+			ControlChange* ev = (ControlChange*)buf;
+			ev->index    = p;
+			ev->protocol = 0;
+			ev->size     = sizeof(float);
+			*(float*)ev->body = port->control;
+			if (zix_ring_write(jalv->plugin_events, buf, sizeof(buf))
+			    < sizeof(buf)) {
+				fprintf(stderr, "Plugin => UI buffer overflow!\n");
+			}
+		}
+	}
+
+	return paContinue;
+}
+
+static JalvBackend*
+pa_error(const char* msg, PaError err)
+{
+	fprintf(stderr, "error: %s (%s)\n", msg, Pa_GetErrorText(err));
+	Pa_Terminate();
+	return NULL;
+}
+
+JalvBackend*
+jalv_backend_init(Jalv* jalv)
+{
+	PaStreamParameters inputParameters;
+	PaStreamParameters outputParameters;
+	PaStream*          stream = NULL;
+	PaError            st     = paNoError;
+
+	if ((st = Pa_Initialize())) {
+		return pa_error("Failed to initialize audio system", st);
+	}
+
+	// Get default input and output devices
+	inputParameters.device  = Pa_GetDefaultInputDevice();
+	outputParameters.device = Pa_GetDefaultOutputDevice();
+	if (inputParameters.device == paNoDevice) {
+		return pa_error("No default input device", paDeviceUnavailable);
+	} else if (outputParameters.device == paNoDevice) {
+		return pa_error("No default output device", paDeviceUnavailable);
+	}
+
+	const PaDeviceInfo* in_dev  = Pa_GetDeviceInfo(inputParameters.device);
+	const PaDeviceInfo* out_dev = Pa_GetDeviceInfo(outputParameters.device);
+
+	// Count number of input and output audio ports/channels
+	inputParameters.channelCount  = 0;
+	outputParameters.channelCount = 0;
+	for (uint32_t i = 0; i < jalv->num_ports; ++i) {
+		if (jalv->ports[i].type == TYPE_AUDIO) {
+			if (jalv->ports[i].flow == FLOW_INPUT) {
+				++inputParameters.channelCount;
+			} else if (jalv->ports[i].flow == FLOW_OUTPUT) {
+				++outputParameters.channelCount;
+			}
+		}
+	}
+
+	// Configure audio format
+	inputParameters.sampleFormat               = paFloat32|paNonInterleaved;
+	inputParameters.suggestedLatency           = in_dev->defaultLowInputLatency;
+	inputParameters.hostApiSpecificStreamInfo  = NULL;
+	outputParameters.sampleFormat              = paFloat32|paNonInterleaved;
+	outputParameters.suggestedLatency          = out_dev->defaultLowOutputLatency;
+	outputParameters.hostApiSpecificStreamInfo = NULL;
+
+	// Open stream
+	if ((st = Pa_OpenStream(
+		     &stream,
+		     inputParameters.channelCount ? &inputParameters : NULL,
+		     outputParameters.channelCount ? &outputParameters : NULL,
+		     in_dev->defaultSampleRate,
+		     paFramesPerBufferUnspecified,
+		     0,
+		     pa_process_cb,
+		     jalv))) {
+		return pa_error("Failed to open audio stream", st);
+	}
+
+	// Set audio parameters
+	jalv->sample_rate   = in_dev->defaultSampleRate;
+	// jalv->block_length  = FIXME
+	jalv->midi_buf_size = 4096;
+
+	// Allocate and return opaque backend
+	JalvBackend* backend = (JalvBackend*)calloc(1, sizeof(JalvBackend));
+	backend->stream = stream;
+	return backend;
+}
+
+void
+jalv_backend_close(Jalv* jalv)
+{
+	Pa_Terminate();
+	free(jalv->backend);
+	jalv->backend = NULL;
+}
+
+void
+jalv_backend_activate(Jalv* jalv)
+{
+	const int st = Pa_StartStream(jalv->backend->stream);
+	if (st != paNoError) {
+		fprintf(stderr, "error: Error starting audio stream (%s)\n",
+		        Pa_GetErrorText(st));
+	}
+}
+
+void
+jalv_backend_deactivate(Jalv* jalv)
+{
+	const int st = Pa_CloseStream(jalv->backend->stream);
+	if (st != paNoError) {
+		fprintf(stderr, "error: Error closing audio stream (%s)\n",
+		        Pa_GetErrorText(st));
+	}
+}
+
+void
+jalv_backend_activate_port(Jalv* jalv, uint32_t port_index)
+{
+	struct Port* const port = &jalv->ports[port_index];
+	switch (port->type) {
+	case TYPE_CONTROL:
+		lilv_instance_connect_port(jalv->instance, port_index, &port->control);
+		break;
+	default:
+		break;
+	}
+}
diff --git a/src/state.c b/src/state.c
new file mode 100644
index 0000000..899e61f
--- /dev/null
+++ b/src/state.c
@@ -0,0 +1,255 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef HAVE_LV2_STATE
+#    include "lv2/lv2plug.in/ns/ext/state/state.h"
+#endif
+
+#include "lilv/lilv.h"
+
+#include "jalv_config.h"
+#include "jalv_internal.h"
+
+#define NS_JALV "http://drobilla.net/ns/jalv#"
+#define NS_RDF  "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_RDFS "http://www.w3.org/2000/01/rdf-schema#"
+#define NS_XSD  "http://www.w3.org/2001/XMLSchema#"
+
+char*
+jalv_make_path(LV2_State_Make_Path_Handle handle,
+               const char*                path)
+{
+	Jalv* jalv = (Jalv*)handle;
+
+	// Create in save directory if saving, otherwise use temp directory
+	return jalv_strjoin(jalv->save_dir ? jalv->save_dir : jalv->temp_dir, path);
+}
+
+static const void*
+get_port_value(const char* port_symbol,
+               void*       user_data,
+               uint32_t*   size,
+               uint32_t*   type)
+{
+	Jalv*        jalv = (Jalv*)user_data;
+	struct Port* port = jalv_port_by_symbol(jalv, port_symbol);
+	if (port && port->flow == FLOW_INPUT && port->type == TYPE_CONTROL) {
+		*size = sizeof(float);
+		*type = jalv->forge.Float;
+		return &port->control;
+	}
+	*size = *type = 0;
+	return NULL;
+}
+
+void
+jalv_save(Jalv* jalv, const char* dir)
+{
+	jalv->save_dir = jalv_strjoin(dir, "/");
+
+	LilvState* const state = lilv_state_new_from_instance(
+		jalv->plugin, jalv->instance, &jalv->map,
+		jalv->temp_dir, dir, dir, dir,
+		get_port_value, jalv,
+		LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, NULL);
+
+	lilv_state_save(jalv->world, &jalv->map, &jalv->unmap, state, NULL,
+	                dir, "state.ttl");
+
+	lilv_state_free(state);
+
+	free(jalv->save_dir);
+	jalv->save_dir = NULL;
+}
+
+int
+jalv_load_presets(Jalv* jalv, PresetSink sink, void* data)
+{
+	LilvNodes* presets = lilv_plugin_get_related(jalv->plugin,
+	                                             jalv->nodes.pset_Preset);
+	LILV_FOREACH(nodes, i, presets) {
+		const LilvNode* preset = lilv_nodes_get(presets, i);
+		lilv_world_load_resource(jalv->world, preset);
+		if (!sink) {
+			continue;
+		}
+
+		LilvNodes* labels = lilv_world_find_nodes(
+			jalv->world, preset, jalv->nodes.rdfs_label, NULL);
+		if (labels) {
+			const LilvNode* label = lilv_nodes_get_first(labels);
+			sink(jalv, preset, label, data);
+			lilv_nodes_free(labels);
+		} else {
+			fprintf(stderr, "Preset <%s> has no rdfs:label\n",
+			        lilv_node_as_string(lilv_nodes_get(presets, i)));
+		}
+	}
+	lilv_nodes_free(presets);
+
+	return 0;
+}
+
+int
+jalv_unload_presets(Jalv* jalv)
+{
+	LilvNodes* presets = lilv_plugin_get_related(jalv->plugin,
+	                                             jalv->nodes.pset_Preset);
+	LILV_FOREACH(nodes, i, presets) {
+		const LilvNode* preset = lilv_nodes_get(presets, i);
+		lilv_world_unload_resource(jalv->world, preset);
+	}
+	lilv_nodes_free(presets);
+
+	return 0;
+}
+
+static void
+set_port_value(const char*         port_symbol,
+               void*               user_data,
+               const void*         value,
+               ZIX_UNUSED uint32_t size,
+               uint32_t            type)
+{
+	Jalv*        jalv = (Jalv*)user_data;
+	struct Port* port = jalv_port_by_symbol(jalv, port_symbol);
+	if (!port) {
+		fprintf(stderr, "error: Preset port `%s' is missing\n", port_symbol);
+		return;
+	}
+
+	float fvalue;
+	if (type == jalv->forge.Float) {
+		fvalue = *(const float*)value;
+	} else if (type == jalv->forge.Double) {
+		fvalue = *(const double*)value;
+	} else if (type == jalv->forge.Int) {
+		fvalue = *(const int32_t*)value;
+	} else if (type == jalv->forge.Long) {
+		fvalue = *(const int64_t*)value;
+	} else {
+		fprintf(stderr, "error: Preset `%s' value has bad type <%s>\n",
+		        port_symbol, jalv->unmap.unmap(jalv->unmap.handle, type));
+		return;
+	}
+
+	if (jalv->play_state != JALV_RUNNING) {
+		// Set value on port struct directly
+		port->control = fvalue;
+	} else {
+		// Send value to running plugin
+		jalv_ui_write(jalv, port->index, sizeof(fvalue), 0, &fvalue);
+	}
+
+	if (jalv->has_ui) {
+		// Update UI
+		char buf[sizeof(ControlChange) + sizeof(fvalue)];
+		ControlChange* ev = (ControlChange*)buf;
+		ev->index    = port->index;
+		ev->protocol = 0;
+		ev->size     = sizeof(fvalue);
+		*(float*)ev->body = fvalue;
+		zix_ring_write(jalv->plugin_events, buf, sizeof(buf));
+	}
+}
+
+void
+jalv_apply_state(Jalv* jalv, LilvState* state)
+{
+	bool must_pause = !jalv->safe_restore && jalv->play_state == JALV_RUNNING;
+	if (state) {
+		if (must_pause) {
+			jalv->play_state = JALV_PAUSE_REQUESTED;
+			zix_sem_wait(&jalv->paused);
+		}
+
+		const LV2_Feature* state_features[9] = {
+			&jalv->features.map_feature,
+			&jalv->features.unmap_feature,
+			&jalv->features.make_path_feature,
+			&jalv->features.state_sched_feature,
+			&jalv->features.safe_restore_feature,
+			&jalv->features.log_feature,
+			&jalv->features.options_feature,
+			NULL
+		};
+
+		lilv_state_restore(
+			state, jalv->instance, set_port_value, jalv, 0, state_features);
+
+		if (must_pause) {
+			jalv->request_update = true;
+			jalv->play_state     = JALV_RUNNING;
+		}
+	}
+}
+
+int
+jalv_apply_preset(Jalv* jalv, const LilvNode* preset)
+{
+	lilv_state_free(jalv->preset);
+	jalv->preset = lilv_state_new_from_world(jalv->world, &jalv->map, preset);
+	jalv_apply_state(jalv, jalv->preset);
+	return 0;
+}
+
+int
+jalv_save_preset(Jalv*       jalv,
+                 const char* dir,
+                 const char* uri,
+                 const char* label,
+                 const char* filename)
+{
+	LilvState* const state = lilv_state_new_from_instance(
+		jalv->plugin, jalv->instance, &jalv->map,
+		jalv->temp_dir, dir, dir, dir,
+		get_port_value, jalv,
+		LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, NULL);
+
+	if (label) {
+		lilv_state_set_label(state, label);
+	}
+
+	int ret = lilv_state_save(
+		jalv->world, &jalv->map, &jalv->unmap, state, uri, dir, filename);
+
+	lilv_state_free(jalv->preset);
+	jalv->preset = state;
+
+	return ret;
+}
+
+int
+jalv_delete_current_preset(Jalv* jalv)
+{
+	if (!jalv->preset) {
+		return 1;
+	}
+
+	lilv_world_unload_resource(jalv->world, lilv_state_get_uri(jalv->preset));
+	lilv_state_delete(jalv->world, jalv->preset);
+	lilv_state_free(jalv->preset);
+	jalv->preset = NULL;
+	return 0;
+}
diff --git a/src/symap.c b/src/symap.c
new file mode 100644
index 0000000..0b567e8
--- /dev/null
+++ b/src/symap.c
@@ -0,0 +1,235 @@
+/*
+  Copyright 2011-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "symap.h"
+
+/**
+  @file symap.c Implementation of Symap, a basic symbol map (string interner).
+
+  This implementation is primitive, but has some desirable qualities: good
+  (O(lg(n)) lookup performance for already-mapped symbols, minimal space
+  overhead, extremely fast (O(1)) reverse mapping (ID to string), simple code,
+  no dependencies.
+
+  The tradeoff is that mapping new symbols may be quite slow.  In other words,
+  this implementation is ideal for use cases with a relatively limited set of
+  symbols, or where most symbols are mapped early.  It will not fare so well
+  with very dynamic sets of symbols.  For that, you're better off with a
+  tree-based implementation (and the associated space cost, especially if you
+  need reverse mapping).
+*/
+
+struct SymapImpl {
+	/**
+	   Unsorted array of strings, such that the symbol for ID i is found
+	   at symbols[i - 1].
+	*/
+	char** symbols;
+
+	/**
+	   Array of IDs, sorted by corresponding string in `symbols`.
+	*/
+	uint32_t* index;
+
+	/**
+	   Number of symbols (number of items in `symbols` and `index`).
+	*/
+	uint32_t size;
+};
+
+Symap*
+symap_new(void)
+{
+	Symap* map = (Symap*)malloc(sizeof(Symap));
+	map->symbols = NULL;
+	map->index   = NULL;
+	map->size    = 0;
+	return map;
+}
+
+void
+symap_free(Symap* map)
+{
+	if (!map) {
+		return;
+	}
+
+	for (uint32_t i = 0; i < map->size; ++i) {
+		free(map->symbols[i]);
+	}
+
+	free(map->symbols);
+	free(map->index);
+	free(map);
+}
+
+static char*
+symap_strdup(const char* str)
+{
+	const size_t len  = strlen(str);
+	char*        copy = (char*)malloc(len + 1);
+	memcpy(copy, str, len + 1);
+	return copy;
+}
+
+/**
+   Return the index into map->index (not the ID) corresponding to `sym`,
+   or the index where a new entry for `sym` should be inserted.
+*/
+static uint32_t
+symap_search(const Symap* map, const char* sym, bool* exact)
+{
+	*exact = false;
+	if (map->size == 0) {
+		return 0;  // Empty map, insert at 0
+	} else if (strcmp(map->symbols[map->index[map->size - 1] - 1], sym) < 0) {
+		return map->size;  // Greater than last element, append
+	}
+
+	uint32_t lower = 0;
+	uint32_t upper = map->size - 1;
+	uint32_t i     = upper;
+	int      cmp;
+
+	while (upper >= lower) {
+		i   = lower + ((upper - lower) / 2);
+		cmp = strcmp(map->symbols[map->index[i] - 1], sym);
+
+		if (cmp == 0) {
+			*exact = true;
+			return i;
+		} else if (cmp > 0) {
+			if (i == 0) {
+				break;  // Avoid underflow
+			}
+			upper = i - 1;
+		} else {
+			lower = ++i;
+		}
+	}
+
+	assert(!*exact || strcmp(map->symbols[map->index[i] - 1], sym) > 0);
+	return i;
+}
+
+uint32_t
+symap_try_map(Symap* map, const char* sym)
+{
+	bool           exact;
+	const uint32_t index = symap_search(map, sym, &exact);
+	if (exact) {
+		assert(!strcmp(map->symbols[map->index[index]], sym));
+		return map->index[index];
+	}
+
+	return 0;
+}
+
+uint32_t
+symap_map(Symap* map, const char* sym)
+{
+	bool           exact;
+	const uint32_t index = symap_search(map, sym, &exact);
+	if (exact) {
+		assert(!strcmp(map->symbols[map->index[index] - 1], sym));
+		return map->index[index];
+	}
+
+	const uint32_t id  = ++map->size;
+	char* const    str = symap_strdup(sym);
+
+	/* Append new symbol to symbols array */
+	map->symbols = (char**)realloc(map->symbols, map->size * sizeof(str));
+	map->symbols[id - 1] = str;
+
+	/* Insert new index element into sorted index */
+	map->index = (uint32_t*)realloc(map->index, map->size * sizeof(uint32_t));
+	if (index < map->size - 1) {
+		memmove(map->index + index + 1,
+		        map->index + index,
+		        (map->size - index - 1) * sizeof(uint32_t));
+	}
+
+	map->index[index] = id;
+
+	return id;
+}
+
+const char*
+symap_unmap(Symap* map, uint32_t id)
+{
+	if (id == 0) {
+		return NULL;
+	} else if (id <= map->size) {
+		return map->symbols[id - 1];
+	}
+	return NULL;
+}
+
+#ifdef STANDALONE
+
+#include <stdio.h>
+
+static void
+symap_dump(Symap* map)
+{
+	fprintf(stderr, "{\n");
+	for (uint32_t i = 0; i < map->size; ++i) {
+		fprintf(stderr, "\t%u = %s\n",
+		        map->index[i], map->symbols[map->index[i] - 1]);
+	}
+	fprintf(stderr, "}\n");
+}
+
+int
+main()
+{
+	#define N_SYMS 5
+	char* syms[N_SYMS] = {
+		"hello", "bonjour", "goodbye", "aloha", "salut"
+	};
+
+	Symap* map = symap_new();
+	for (int i = 0; i < N_SYMS; ++i) {
+		if (symap_try_map(map, syms[i])) {
+			fprintf(stderr, "error: Symbol already mapped\n");
+			return 1;
+		}
+
+		const uint32_t id = symap_map(map, syms[i]);
+		if (strcmp(map->symbols[id - 1], syms[i])) {
+			fprintf(stderr, "error: Corrupt symbol table\n");
+			return 1;
+		}
+
+		if (symap_map(map, syms[i]) != id) {
+			fprintf(stderr, "error: Remapped symbol to a different ID\n");
+			return 1;
+		}
+
+		symap_dump(map);
+	}
+
+	symap_free(map);
+	return 0;
+}
+
+#endif /* STANDALONE */
diff --git a/src/symap.h b/src/symap.h
new file mode 100644
index 0000000..918d914
--- /dev/null
+++ b/src/symap.h
@@ -0,0 +1,68 @@
+/*
+  Copyright 2011-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/**
+   @file symap.h API for Symap, a basic symbol map (string interner).
+
+   Particularly useful for implementing LV2 URI mapping.
+
+   @see <a href="http://lv2plug.in/ns/ext/urid">LV2 URID</a>
+*/
+
+#ifndef SYMAP_H
+#define SYMAP_H
+
+#include <stdint.h>
+
+struct SymapImpl;
+
+typedef struct SymapImpl Symap;
+
+/**
+   Create a new symbol map.
+*/
+Symap*
+symap_new(void);
+
+/**
+   Free a symbol map.
+*/
+void
+symap_free(Symap* map);
+
+/**
+   Map a string to a symbol ID if it is already mapped, otherwise return 0.
+*/
+uint32_t
+symap_try_map(Symap* map, const char* sym);
+
+/**
+   Map a string to a symbol ID.
+
+   Note that 0 is never a valid symbol ID.
+*/
+uint32_t
+symap_map(Symap* map, const char* sym);
+
+/**
+   Unmap a symbol ID back to a symbol, or NULL if no such ID exists.
+
+   Note that 0 is never a valid symbol ID.
+*/
+const char*
+symap_unmap(Symap* map, uint32_t id);
+
+#endif /* SYMAP_H */
diff --git a/src/worker.c b/src/worker.c
new file mode 100644
index 0000000..79bb7b7
--- /dev/null
+++ b/src/worker.c
@@ -0,0 +1,141 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "worker.h"
+
+static LV2_Worker_Status
+jalv_worker_respond(LV2_Worker_Respond_Handle handle,
+                    uint32_t                  size,
+                    const void*               data)
+{
+	JalvWorker* worker = (JalvWorker*)handle;
+	zix_ring_write(worker->responses, (const char*)&size, sizeof(size));
+	zix_ring_write(worker->responses, (const char*)data, size);
+	return LV2_WORKER_SUCCESS;
+}
+
+static void*
+worker_func(void* data)
+{
+	JalvWorker* worker = (JalvWorker*)data;
+	Jalv*       jalv   = worker->jalv;
+	void*       buf    = NULL;
+	while (true) {
+		zix_sem_wait(&worker->sem);
+		if (jalv->exit) {
+			break;
+		}
+
+		uint32_t size = 0;
+		zix_ring_read(worker->requests, (char*)&size, sizeof(size));
+
+		if (!(buf = realloc(buf, size))) {
+			fprintf(stderr, "error: realloc() failed\n");
+			free(buf);
+			return NULL;
+		}
+
+		zix_ring_read(worker->requests, (char*)buf, size);
+
+		zix_sem_wait(&jalv->work_lock);
+		worker->iface->work(
+			jalv->instance->lv2_handle, jalv_worker_respond, worker, size, buf);
+		zix_sem_post(&jalv->work_lock);
+	}
+
+	free(buf);
+	return NULL;
+}
+
+void
+jalv_worker_init(ZIX_UNUSED Jalv*            jalv,
+                 JalvWorker*                 worker,
+                 const LV2_Worker_Interface* iface,
+                 bool                        threaded)
+{
+	worker->iface = iface;
+	worker->threaded = threaded;
+	if (threaded) {
+		zix_thread_create(&worker->thread, 4096, worker_func, worker);
+		worker->requests = zix_ring_new(4096);
+		zix_ring_mlock(worker->requests);
+	}
+	worker->responses = zix_ring_new(4096);
+	worker->response  = malloc(4096);
+	zix_ring_mlock(worker->responses);
+}
+
+void
+jalv_worker_finish(JalvWorker* worker)
+{
+	if (worker->threaded) {
+		zix_sem_post(&worker->sem);
+		zix_thread_join(worker->thread, NULL);
+	}
+}
+
+void
+jalv_worker_destroy(JalvWorker* worker)
+{
+	if (worker->requests) {
+		if (worker->threaded) {
+			zix_ring_free(worker->requests);
+		}
+		zix_ring_free(worker->responses);
+		free(worker->response);
+	}
+}
+
+LV2_Worker_Status
+jalv_worker_schedule(LV2_Worker_Schedule_Handle handle,
+                     uint32_t                   size,
+                     const void*                data)
+{
+	JalvWorker* worker = (JalvWorker*)handle;
+	Jalv*       jalv   = worker->jalv;
+	if (worker->threaded) {
+		// Schedule a request to be executed by the worker thread
+		zix_ring_write(worker->requests, (const char*)&size, sizeof(size));
+		zix_ring_write(worker->requests, (const char*)data, size);
+		zix_sem_post(&worker->sem);
+	} else {
+		// Execute work immediately in this thread
+		zix_sem_wait(&jalv->work_lock);
+		worker->iface->work(
+			jalv->instance->lv2_handle, jalv_worker_respond, worker, size, data);
+		zix_sem_post(&jalv->work_lock);
+	}
+	return LV2_WORKER_SUCCESS;
+}
+
+void
+jalv_worker_emit_responses(JalvWorker* worker, LilvInstance* instance)
+{
+	if (worker->responses) {
+		uint32_t read_space = zix_ring_read_space(worker->responses);
+		while (read_space) {
+			uint32_t size = 0;
+			zix_ring_read(worker->responses, (char*)&size, sizeof(size));
+
+			zix_ring_read(worker->responses, (char*)worker->response, size);
+
+			worker->iface->work_response(
+				instance->lv2_handle, size, worker->response);
+
+			read_space -= sizeof(size) + size;
+		}
+	}
+}
diff --git a/src/worker.h b/src/worker.h
new file mode 100644
index 0000000..a437fe7
--- /dev/null
+++ b/src/worker.h
@@ -0,0 +1,39 @@
+/*
+  Copyright 2007-2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "lv2/lv2plug.in/ns/ext/worker/worker.h"
+
+#include "jalv_internal.h"
+
+void
+jalv_worker_init(Jalv*                       jalv,
+                 JalvWorker*                 worker,
+                 const LV2_Worker_Interface* iface,
+                 bool                        threaded);
+
+void
+jalv_worker_finish(JalvWorker* worker);
+
+void
+jalv_worker_destroy(JalvWorker* worker);
+
+LV2_Worker_Status
+jalv_worker_schedule(LV2_Worker_Schedule_Handle handle,
+                     uint32_t                   size,
+                     const void*                data);
+
+void
+jalv_worker_emit_responses(JalvWorker* worker, LilvInstance* instance);
diff --git a/src/zix/common.h b/src/zix/common.h
new file mode 100644
index 0000000..9318d0e
--- /dev/null
+++ b/src/zix/common.h
@@ -0,0 +1,116 @@
+/*
+  Copyright 2016 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_COMMON_H
+#define ZIX_COMMON_H
+
+/**
+   @addtogroup zix
+   @{
+*/
+
+/** @cond */
+#ifdef ZIX_SHARED
+#    ifdef _WIN32
+#        define ZIX_LIB_IMPORT __declspec(dllimport)
+#        define ZIX_LIB_EXPORT __declspec(dllexport)
+#    else
+#        define ZIX_LIB_IMPORT __attribute__((visibility("default")))
+#        define ZIX_LIB_EXPORT __attribute__((visibility("default")))
+#    endif
+#    ifdef ZIX_INTERNAL
+#        define ZIX_API ZIX_LIB_EXPORT
+#    else
+#        define ZIX_API ZIX_LIB_IMPORT
+#    endif
+#    define ZIX_PRIVATE static
+#elif defined(ZIX_INLINE)
+#    define ZIX_API     static inline
+#    define ZIX_PRIVATE static inline
+#else
+#    define ZIX_API
+#    define ZIX_PRIVATE static
+#endif
+/** @endcond */
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#    include <stdbool.h>
+#endif
+
+#ifdef __GNUC__
+#define ZIX_UNUSED  __attribute__((__unused__))
+#else
+#define ZIX_UNUSED
+#endif
+
+typedef enum {
+	ZIX_STATUS_SUCCESS,
+	ZIX_STATUS_ERROR,
+	ZIX_STATUS_NO_MEM,
+	ZIX_STATUS_NOT_FOUND,
+	ZIX_STATUS_EXISTS,
+	ZIX_STATUS_BAD_ARG,
+	ZIX_STATUS_BAD_PERMS
+} ZixStatus;
+
+static inline const char*
+zix_strerror(const ZixStatus status)
+{
+	switch (status) {
+	case ZIX_STATUS_SUCCESS:
+		return "Success";
+	case ZIX_STATUS_ERROR:
+		return "Unknown error";
+	case ZIX_STATUS_NO_MEM:
+		return "Out of memory";
+	case ZIX_STATUS_NOT_FOUND:
+		return "Not found";
+	case ZIX_STATUS_EXISTS:
+		return "Exists";
+	case ZIX_STATUS_BAD_ARG:
+		return "Bad argument";
+	case ZIX_STATUS_BAD_PERMS:
+		return "Bad permissions";
+	}
+	return "Unknown error";
+}
+
+/**
+   Function for comparing two elements.
+*/
+typedef int (*ZixComparator)(const void* a, const void* b, void* user_data);
+
+/**
+   Function for testing equality of two elements.
+*/
+typedef bool (*ZixEqualFunc)(const void* a, const void* b);
+
+/**
+   Function to destroy an element.
+*/
+typedef void (*ZixDestroyFunc)(void* ptr);
+
+/**
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_COMMON_H */
diff --git a/src/zix/ring.c b/src/zix/ring.c
new file mode 100644
index 0000000..a76b4ea
--- /dev/null
+++ b/src/zix/ring.c
@@ -0,0 +1,228 @@
+/*
+  Copyright 2011-2017 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_MLOCK
+#    include <sys/mman.h>
+#    define ZIX_MLOCK(ptr, size) mlock((ptr), (size))
+#elif defined(_WIN32)
+#    include <windows.h>
+#    define ZIX_MLOCK(ptr, size) VirtualLock((ptr), (size))
+#else
+#    pragma message("warning: No memory locking, possible RT violations")
+#    define ZIX_MLOCK(ptr, size)
+#endif
+
+#if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__)
+#    include <stdatomic.h>
+#    define ZIX_WRITE_BARRIER() atomic_thread_fence(memory_order_release)
+#    define ZIX_READ_BARRIER() atomic_thread_fence(memory_order_acquire)
+#elif defined(__APPLE__) /* Pre 10.12 */
+#    include <libkern/OSAtomic.h>
+#    define ZIX_WRITE_BARRIER() OSMemoryBarrier()
+#    define ZIX_READ_BARRIER() OSMemoryBarrier()
+#elif defined(_WIN32)
+#    include <windows.h>
+#    define ZIX_WRITE_BARRIER() MemoryBarrier()
+#    define ZIX_READ_BARRIER() MemoryBarrier()
+#elif (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
+#    define ZIX_WRITE_BARRIER() __sync_synchronize()
+#    define ZIX_READ_BARRIER() __sync_synchronize()
+#else
+#    pragma message("warning: No memory barriers, possible SMP bugs")
+#    define ZIX_WRITE_BARRIER()
+#    define ZIX_READ_BARRIER()
+#endif
+
+#include "zix/ring.h"
+
+struct ZixRingImpl {
+	uint32_t write_head;  ///< Read index into buf
+	uint32_t read_head;   ///< Write index into buf
+	uint32_t size;        ///< Size (capacity) in bytes
+	uint32_t size_mask;   ///< Mask for fast modulo
+	char*    buf;         ///< Contents
+};
+
+static inline uint32_t
+next_power_of_two(uint32_t size)
+{
+	// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+	size--;
+	size |= size >> 1;
+	size |= size >> 2;
+	size |= size >> 4;
+	size |= size >> 8;
+	size |= size >> 16;
+	size++;
+	return size;
+}
+
+ZixRing*
+zix_ring_new(uint32_t size)
+{
+	ZixRing* ring = (ZixRing*)malloc(sizeof(ZixRing));
+	ring->write_head = 0;
+	ring->read_head  = 0;
+	ring->size       = next_power_of_two(size);
+	ring->size_mask  = ring->size - 1;
+	ring->buf        = (char*)malloc(ring->size);
+	return ring;
+}
+
+void
+zix_ring_free(ZixRing* ring)
+{
+	if (ring) {
+		free(ring->buf);
+		free(ring);
+	}
+}
+
+void
+zix_ring_mlock(ZixRing* ring)
+{
+	ZIX_MLOCK(ring, sizeof(ZixRing));
+	ZIX_MLOCK(ring->buf, ring->size);
+}
+
+void
+zix_ring_reset(ZixRing* ring)
+{
+	ring->write_head = 0;
+	ring->read_head  = 0;
+}
+
+static inline uint32_t
+read_space_internal(const ZixRing* ring, uint32_t r, uint32_t w)
+{
+	if (r < w) {
+		return w - r;
+	} else {
+		return (w - r + ring->size) & ring->size_mask;
+	}
+}
+
+uint32_t
+zix_ring_read_space(const ZixRing* ring)
+{
+	return read_space_internal(ring, ring->read_head, ring->write_head);
+}
+
+static inline uint32_t
+write_space_internal(const ZixRing* ring, uint32_t r, uint32_t w)
+{
+	if (r == w) {
+		return ring->size - 1;
+	} else if (r < w) {
+		return ((r - w + ring->size) & ring->size_mask) - 1;
+	} else {
+		return (r - w) - 1;
+	}
+}
+
+uint32_t
+zix_ring_write_space(const ZixRing* ring)
+{
+	return write_space_internal(ring, ring->read_head, ring->write_head);
+}
+
+uint32_t
+zix_ring_capacity(const ZixRing* ring)
+{
+	return ring->size - 1;
+}
+
+static inline uint32_t
+peek_internal(const ZixRing* ring, uint32_t r, uint32_t w,
+              uint32_t size, void* dst)
+{
+	if (read_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	if (r + size < ring->size) {
+		memcpy(dst, &ring->buf[r], size);
+	} else {
+		const uint32_t first_size = ring->size - r;
+		memcpy(dst, &ring->buf[r], first_size);
+		memcpy((char*)dst + first_size, &ring->buf[0], size - first_size);
+	}
+
+	return size;
+}
+
+uint32_t
+zix_ring_peek(ZixRing* ring, void* dst, uint32_t size)
+{
+	return peek_internal(ring, ring->read_head, ring->write_head, size, dst);
+}
+
+uint32_t
+zix_ring_read(ZixRing* ring, void* dst, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+
+	if (peek_internal(ring, r, w, size, dst)) {
+		ZIX_READ_BARRIER();
+		ring->read_head = (r + size) & ring->size_mask;
+		return size;
+	} else {
+		return 0;
+	}
+}
+
+uint32_t
+zix_ring_skip(ZixRing* ring, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+	if (read_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	ZIX_READ_BARRIER();
+	ring->read_head = (r + size) & ring->size_mask;
+	return size;
+}
+
+uint32_t
+zix_ring_write(ZixRing* ring, const void* src, uint32_t size)
+{
+	const uint32_t r = ring->read_head;
+	const uint32_t w = ring->write_head;
+	if (write_space_internal(ring, r, w) < size) {
+		return 0;
+	}
+
+	if (w + size <= ring->size) {
+		memcpy(&ring->buf[w], src, size);
+		ZIX_WRITE_BARRIER();
+		ring->write_head = (w + size) & ring->size_mask;
+	} else {
+		const uint32_t this_size = ring->size - w;
+		memcpy(&ring->buf[w], src, this_size);
+		memcpy(&ring->buf[0], (const char*)src + this_size, size - this_size);
+		ZIX_WRITE_BARRIER();
+		ring->write_head = size - this_size;
+	}
+
+	return size;
+}
diff --git a/src/zix/ring.h b/src/zix/ring.h
new file mode 100644
index 0000000..f7f1893
--- /dev/null
+++ b/src/zix/ring.h
@@ -0,0 +1,130 @@
+/*
+  Copyright 2011-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_RING_H
+#define ZIX_RING_H
+
+#include <stdint.h>
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Ring
+   @{
+*/
+
+/**
+   A lock-free ring buffer.
+
+   Thread-safe with a single reader and single writer, and realtime safe
+   on both ends.
+*/
+typedef struct ZixRingImpl ZixRing;
+
+/**
+   Create a new ring.
+   @param size Size in bytes (note this may be rounded up).
+
+   At most `size` - 1 bytes may be stored in the ring at once.
+*/
+ZixRing*
+zix_ring_new(uint32_t size);
+
+/**
+   Destroy a ring.
+*/
+void
+zix_ring_free(ZixRing* ring);
+
+/**
+   Lock the ring data into physical memory.
+
+   This function is NOT thread safe or real-time safe, but it should be called
+   after zix_ring_new() to lock all ring memory to avoid page faults while
+   using the ring (i.e. this function MUST be called first in order for the
+   ring to be truly real-time safe).
+
+*/
+void
+zix_ring_mlock(ZixRing* ring);
+
+/**
+   Reset (empty) a ring.
+
+   This function is NOT thread-safe, it may only be called when there are no
+   readers or writers.
+*/
+void
+zix_ring_reset(ZixRing* ring);
+
+/**
+   Return the number of bytes of space available for reading.
+*/
+uint32_t
+zix_ring_read_space(const ZixRing* ring);
+
+/**
+   Return the number of bytes of space available for writing.
+*/
+uint32_t
+zix_ring_write_space(const ZixRing* ring);
+
+/**
+   Return the capacity (i.e. total write space when empty).
+*/
+uint32_t
+zix_ring_capacity(const ZixRing* ring);
+
+/**
+   Read from the ring without advancing the read head.
+*/
+uint32_t
+zix_ring_peek(ZixRing* ring, void* dst, uint32_t size);
+
+/**
+   Read from the ring and advance the read head.
+*/
+uint32_t
+zix_ring_read(ZixRing* ring, void* dst, uint32_t size);
+
+/**
+   Skip data in the ring (advance read head without reading).
+*/
+uint32_t
+zix_ring_skip(ZixRing* ring, uint32_t size);
+
+/**
+   Write data to the ring.
+*/
+uint32_t
+zix_ring_write(ZixRing* ring, const void* src, uint32_t size);
+
+/**
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_RING_H */
diff --git a/src/zix/sem.h b/src/zix/sem.h
new file mode 100644
index 0000000..1fea796
--- /dev/null
+++ b/src/zix/sem.h
@@ -0,0 +1,237 @@
+/*
+  Copyright 2012-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_SEM_H
+#define ZIX_SEM_H
+
+#ifdef __APPLE__
+#    include <mach/mach.h>
+#elif defined(_WIN32)
+#    include <limits.h>
+#    include <windows.h>
+#else
+#    include <semaphore.h>
+#    include <errno.h>
+#endif
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Semaphore
+   @{
+*/
+
+/**
+   A counting semaphore.
+
+   This is an integer that is always positive, and has two main operations:
+   increment (post) and decrement (wait).  If a decrement can not be performed
+   (i.e. the value is 0) the caller will be blocked until another thread posts
+   and the operation can succeed.
+
+   Semaphores can be created with any starting value, but typically this will
+   be 0 so the semaphore can be used as a simple signal where each post
+   corresponds to one wait.
+
+   Semaphores are very efficient (much moreso than a mutex/cond pair).  In
+   particular, at least on Linux, post is async-signal-safe, which means it
+   does not block and will not be interrupted.  If you need to signal from
+   a realtime thread, this is the most appropriate primitive to use.
+*/
+typedef struct ZixSemImpl ZixSem;
+
+/**
+   Create and initialize `sem` to `initial`.
+*/
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned initial);
+
+/**
+   Destroy `sem`.
+*/
+static inline void
+zix_sem_destroy(ZixSem* sem);
+
+/**
+   Increment (and signal any waiters).
+   Realtime safe.
+*/
+static inline void
+zix_sem_post(ZixSem* sem);
+
+/**
+   Wait until count is > 0, then decrement.
+   Obviously not realtime safe.
+*/
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem);
+
+/**
+   Non-blocking version of wait().
+
+   @return true if decrement was successful (lock was acquired).
+*/
+static inline bool
+zix_sem_try_wait(ZixSem* sem);
+
+/**
+   @cond
+*/
+
+#ifdef __APPLE__
+
+struct ZixSemImpl {
+	semaphore_t sem;
+};
+
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned val)
+{
+	return semaphore_create(mach_task_self(), &sem->sem, SYNC_POLICY_FIFO, val)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+static inline void
+zix_sem_destroy(ZixSem* sem)
+{
+	semaphore_destroy(mach_task_self(), sem->sem);
+}
+
+static inline void
+zix_sem_post(ZixSem* sem)
+{
+	semaphore_signal(sem->sem);
+}
+
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem)
+{
+	if (semaphore_wait(sem->sem) != KERN_SUCCESS) {
+		return ZIX_STATUS_ERROR;
+	}
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline bool
+zix_sem_try_wait(ZixSem* sem)
+{
+	const mach_timespec_t zero = { 0, 0 };
+	return semaphore_timedwait(sem->sem, zero) == KERN_SUCCESS;
+}
+
+#elif defined(_WIN32)
+
+struct ZixSemImpl {
+	HANDLE sem;
+};
+
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned initial)
+{
+	sem->sem = CreateSemaphore(NULL, initial, LONG_MAX, NULL);
+	return (sem->sem) ? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+static inline void
+zix_sem_destroy(ZixSem* sem)
+{
+	CloseHandle(sem->sem);
+}
+
+static inline void
+zix_sem_post(ZixSem* sem)
+{
+	ReleaseSemaphore(sem->sem, 1, NULL);
+}
+
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem)
+{
+	if (WaitForSingleObject(sem->sem, INFINITE) != WAIT_OBJECT_0) {
+		return ZIX_STATUS_ERROR;
+	}
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline bool
+zix_sem_try_wait(ZixSem* sem)
+{
+	return WaitForSingleObject(sem->sem, 0) == WAIT_OBJECT_0;
+}
+
+#else  /* !defined(__APPLE__) && !defined(_WIN32) */
+
+struct ZixSemImpl {
+	sem_t sem;
+};
+
+static inline ZixStatus
+zix_sem_init(ZixSem* sem, unsigned initial)
+{
+	return sem_init(&sem->sem, 0, initial)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+static inline void
+zix_sem_destroy(ZixSem* sem)
+{
+	sem_destroy(&sem->sem);
+}
+
+static inline void
+zix_sem_post(ZixSem* sem)
+{
+	sem_post(&sem->sem);
+}
+
+static inline ZixStatus
+zix_sem_wait(ZixSem* sem)
+{
+	while (sem_wait(&sem->sem)) {
+		if (errno != EINTR) {
+			return ZIX_STATUS_ERROR;
+		}
+		/* Otherwise, interrupted, so try again. */
+	}
+
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline bool
+zix_sem_try_wait(ZixSem* sem)
+{
+	return (sem_trywait(&sem->sem) == 0);
+}
+
+#endif
+
+/**
+   @endcond
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_SEM_H */
diff --git a/src/zix/thread.h b/src/zix/thread.h
new file mode 100644
index 0000000..b007efa
--- /dev/null
+++ b/src/zix/thread.h
@@ -0,0 +1,133 @@
+/*
+  Copyright 2012-2014 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef ZIX_THREAD_H
+#define ZIX_THREAD_H
+
+#ifdef _WIN32
+#    include <windows.h>
+#else
+#    include <errno.h>
+#    include <pthread.h>
+#endif
+
+#include "zix/common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#    include <stdbool.h>
+#endif
+
+/**
+   @addtogroup zix
+   @{
+   @name Thread
+   @{
+*/
+
+#ifdef _WIN32
+typedef HANDLE ZixThread;
+#else
+typedef pthread_t ZixThread;
+#endif
+
+/**
+   Initialize `thread` to a new thread.
+
+   The thread will immediately be launched, calling `function` with `arg`
+   as the only parameter.
+*/
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg);
+
+/**
+   Join `thread` (block until `thread` exits).
+*/
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval);
+
+#ifdef _WIN32
+
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg)
+{
+	*thread = CreateThread(NULL, stack_size,
+	                       (LPTHREAD_START_ROUTINE)function, arg,
+	                       0, NULL);
+	return *thread ? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR;
+}
+
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval)
+{
+	return WaitForSingleObject(thread, INFINITE)
+		? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR;
+}
+
+#else  /* !defined(_WIN32) */
+
+static inline ZixStatus
+zix_thread_create(ZixThread* thread,
+                  size_t     stack_size,
+                  void*      (*function)(void*),
+                  void*      arg)
+{
+	pthread_attr_t attr;
+	pthread_attr_init(&attr);
+	pthread_attr_setstacksize(&attr, stack_size);
+
+	const int ret = pthread_create(thread, NULL, function, arg);
+	pthread_attr_destroy(&attr);
+
+	if (ret == EAGAIN) {
+		return ZIX_STATUS_NO_MEM;
+	} else if (ret == EINVAL) {
+		return ZIX_STATUS_BAD_ARG;
+	} else if (ret == EPERM) {
+		return ZIX_STATUS_BAD_PERMS;
+	} else if (ret) {
+		return ZIX_STATUS_ERROR;
+	}
+
+	return ZIX_STATUS_SUCCESS;
+}
+
+static inline ZixStatus
+zix_thread_join(ZixThread thread, void** retval)
+{
+	return pthread_join(thread, retval)
+		? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS;
+}
+
+#endif
+
+/**
+   @}
+   @}
+*/
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif  /* ZIX_THREAD_H */
diff --git a/.gitignore b/waflib/.gitignore
index 8d35cb3..8d35cb3 100644
--- a/.gitignore
+++ b/waflib/.gitignore
diff --git a/Build.py b/waflib/Build.py
index 1afcba6..1afcba6 100644
--- a/Build.py
+++ b/waflib/Build.py
diff --git a/waflib/COPYING b/waflib/COPYING
new file mode 100644
index 0000000..a4147d2
--- /dev/null
+++ b/waflib/COPYING
@@ -0,0 +1,25 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/ConfigSet.py b/waflib/ConfigSet.py
index b300bb5..b300bb5 100644
--- a/ConfigSet.py
+++ b/waflib/ConfigSet.py
diff --git a/Configure.py b/waflib/Configure.py
index d0a4793..d0a4793 100644
--- a/Configure.py
+++ b/waflib/Configure.py
diff --git a/Context.py b/waflib/Context.py
index bb47c92..bb47c92 100644
--- a/Context.py
+++ b/waflib/Context.py
diff --git a/Errors.py b/waflib/Errors.py
index bf75c1b..bf75c1b 100644
--- a/Errors.py
+++ b/waflib/Errors.py
diff --git a/Logs.py b/waflib/Logs.py
index 2a47516..2a47516 100644
--- a/Logs.py
+++ b/waflib/Logs.py
diff --git a/Node.py b/waflib/Node.py
index 4ac1ea8..4ac1ea8 100644
--- a/Node.py
+++ b/waflib/Node.py
diff --git a/Options.py b/waflib/Options.py
index ad802d4..ad802d4 100644
--- a/Options.py
+++ b/waflib/Options.py
diff --git a/waflib/README.md b/waflib/README.md
new file mode 100644
index 0000000..c5361b9
--- /dev/null
+++ b/waflib/README.md
@@ -0,0 +1,24 @@
+Autowaf
+=======
+
+This is autowaf, a bundle of waf and a few extensions intended to be easy to
+use directly as source code in a project.  Using this as a submodule or subtree
+named `waflib` in a project allows waf to be used without including binary
+encoded data in the waf script.  This gets along with revision control and
+distributions better, among other advantages, without losing
+self-containedness.
+
+To use this in a project, add this repository as a directory named `waflib` in
+the top level of the project, and link or copy `waf` to the top level.
+
+Two waf extras are also included: `autowaf.py` and `lv2.py`.
+
+The `autowaf.py` module is a kitchen sink of Python utilities for building
+consistent packages, and can be imported in a wcript as
+`waflib.extras.autowaf`.
+
+The `lv2.py` extra defines options for LV2 plugin installation paths.  It can
+be used by calling `opt.load('lv2')` and `conf.load('lv2')` in the appropriate
+locations in a wscript.
+
+ -- David Robillard <d@drobilla.net>
diff --git a/Runner.py b/waflib/Runner.py
index 261084d..261084d 100644
--- a/Runner.py
+++ b/waflib/Runner.py
diff --git a/Scripting.py b/waflib/Scripting.py
index 749d4f2..749d4f2 100644
--- a/Scripting.py
+++ b/waflib/Scripting.py
diff --git a/Task.py b/waflib/Task.py
index 0fc449d..0fc449d 100644
--- a/Task.py
+++ b/waflib/Task.py
diff --git a/TaskGen.py b/waflib/TaskGen.py
index a74e643..a74e643 100644
--- a/TaskGen.py
+++ b/waflib/TaskGen.py
diff --git a/Tools/__init__.py b/waflib/Tools/__init__.py
index 079df35..079df35 100644
--- a/Tools/__init__.py
+++ b/waflib/Tools/__init__.py
diff --git a/Tools/ar.py b/waflib/Tools/ar.py
index b39b645..b39b645 100644
--- a/Tools/ar.py
+++ b/waflib/Tools/ar.py
diff --git a/Tools/asm.py b/waflib/Tools/asm.py
index b6f26fb..b6f26fb 100644
--- a/Tools/asm.py
+++ b/waflib/Tools/asm.py
diff --git a/Tools/bison.py b/waflib/Tools/bison.py
index eef56dc..eef56dc 100644
--- a/Tools/bison.py
+++ b/waflib/Tools/bison.py
diff --git a/Tools/c.py b/waflib/Tools/c.py
index effd6b6..effd6b6 100644
--- a/Tools/c.py
+++ b/waflib/Tools/c.py
diff --git a/Tools/c_aliases.py b/waflib/Tools/c_aliases.py
index c9d5369..c9d5369 100644
--- a/Tools/c_aliases.py
+++ b/waflib/Tools/c_aliases.py
diff --git a/Tools/c_config.py b/waflib/Tools/c_config.py
index d2b3c0d..d2b3c0d 100644
--- a/Tools/c_config.py
+++ b/waflib/Tools/c_config.py
diff --git a/Tools/c_osx.py b/waflib/Tools/c_osx.py
index f70b128..f70b128 100644
--- a/Tools/c_osx.py
+++ b/waflib/Tools/c_osx.py
diff --git a/Tools/c_preproc.py b/waflib/Tools/c_preproc.py
index 7e04b4a..7e04b4a 100644
--- a/Tools/c_preproc.py
+++ b/waflib/Tools/c_preproc.py
diff --git a/Tools/c_tests.py b/waflib/Tools/c_tests.py
index f858df5..f858df5 100644
--- a/Tools/c_tests.py
+++ b/waflib/Tools/c_tests.py
diff --git a/Tools/ccroot.py b/waflib/Tools/ccroot.py
index cfef8bf..cfef8bf 100644
--- a/Tools/ccroot.py
+++ b/waflib/Tools/ccroot.py
diff --git a/Tools/clang.py b/waflib/Tools/clang.py
index 3828e39..3828e39 100644
--- a/Tools/clang.py
+++ b/waflib/Tools/clang.py
diff --git a/Tools/clangxx.py b/waflib/Tools/clangxx.py
index 152013c..152013c 100644
--- a/Tools/clangxx.py
+++ b/waflib/Tools/clangxx.py
diff --git a/Tools/compiler_c.py b/waflib/Tools/compiler_c.py
index 2dba3f8..2dba3f8 100644
--- a/Tools/compiler_c.py
+++ b/waflib/Tools/compiler_c.py
diff --git a/Tools/compiler_cxx.py b/waflib/Tools/compiler_cxx.py
index 1af65a2..1af65a2 100644
--- a/Tools/compiler_cxx.py
+++ b/waflib/Tools/compiler_cxx.py
diff --git a/Tools/compiler_d.py b/waflib/Tools/compiler_d.py
index 43bb1f6..43bb1f6 100644
--- a/Tools/compiler_d.py
+++ b/waflib/Tools/compiler_d.py
diff --git a/Tools/compiler_fc.py b/waflib/Tools/compiler_fc.py
index 96b58e7..96b58e7 100644
--- a/Tools/compiler_fc.py
+++ b/waflib/Tools/compiler_fc.py
diff --git a/Tools/cs.py b/waflib/Tools/cs.py
index aecca6d..aecca6d 100644
--- a/Tools/cs.py
+++ b/waflib/Tools/cs.py
diff --git a/Tools/cxx.py b/waflib/Tools/cxx.py
index 194fad7..194fad7 100644
--- a/Tools/cxx.py
+++ b/waflib/Tools/cxx.py
diff --git a/Tools/d.py b/waflib/Tools/d.py
index e4cf73b..e4cf73b 100644
--- a/Tools/d.py
+++ b/waflib/Tools/d.py
diff --git a/Tools/d_config.py b/waflib/Tools/d_config.py
index 6637556..6637556 100644
--- a/Tools/d_config.py
+++ b/waflib/Tools/d_config.py
diff --git a/Tools/d_scan.py b/waflib/Tools/d_scan.py
index 14c6c31..14c6c31 100644
--- a/Tools/d_scan.py
+++ b/waflib/Tools/d_scan.py
diff --git a/Tools/dbus.py b/waflib/Tools/dbus.py
index d520f1c..d520f1c 100644
--- a/Tools/dbus.py
+++ b/waflib/Tools/dbus.py
diff --git a/Tools/dmd.py b/waflib/Tools/dmd.py
index 8917ca1..8917ca1 100644
--- a/Tools/dmd.py
+++ b/waflib/Tools/dmd.py
diff --git a/Tools/errcheck.py b/waflib/Tools/errcheck.py
index de8d75a..de8d75a 100644
--- a/Tools/errcheck.py
+++ b/waflib/Tools/errcheck.py
diff --git a/Tools/fc.py b/waflib/Tools/fc.py
index d9e8d8c..d9e8d8c 100644
--- a/Tools/fc.py
+++ b/waflib/Tools/fc.py
diff --git a/Tools/fc_config.py b/waflib/Tools/fc_config.py
index 222f3a5..222f3a5 100644
--- a/Tools/fc_config.py
+++ b/waflib/Tools/fc_config.py
diff --git a/Tools/fc_scan.py b/waflib/Tools/fc_scan.py
index 12cb0fc..12cb0fc 100644
--- a/Tools/fc_scan.py
+++ b/waflib/Tools/fc_scan.py
diff --git a/Tools/flex.py b/waflib/Tools/flex.py
index 2256657..2256657 100644
--- a/Tools/flex.py
+++ b/waflib/Tools/flex.py
diff --git a/Tools/g95.py b/waflib/Tools/g95.py
index f69ba4f..f69ba4f 100644
--- a/Tools/g95.py
+++ b/waflib/Tools/g95.py
diff --git a/Tools/gas.py b/waflib/Tools/gas.py
index 77afed7..77afed7 100644
--- a/Tools/gas.py
+++ b/waflib/Tools/gas.py
diff --git a/Tools/gcc.py b/waflib/Tools/gcc.py
index acdd473..acdd473 100644
--- a/Tools/gcc.py
+++ b/waflib/Tools/gcc.py
diff --git a/Tools/gdc.py b/waflib/Tools/gdc.py
index d89a66d..d89a66d 100644
--- a/Tools/gdc.py
+++ b/waflib/Tools/gdc.py
diff --git a/Tools/gfortran.py b/waflib/Tools/gfortran.py
index 1050667..1050667 100644
--- a/Tools/gfortran.py
+++ b/waflib/Tools/gfortran.py
diff --git a/Tools/glib2.py b/waflib/Tools/glib2.py
index 949fe37..949fe37 100644
--- a/Tools/glib2.py
+++ b/waflib/Tools/glib2.py
diff --git a/Tools/gnu_dirs.py b/waflib/Tools/gnu_dirs.py
index 2847071..2847071 100644
--- a/Tools/gnu_dirs.py
+++ b/waflib/Tools/gnu_dirs.py
diff --git a/Tools/gxx.py b/waflib/Tools/gxx.py
index 22c5d26..22c5d26 100644
--- a/Tools/gxx.py
+++ b/waflib/Tools/gxx.py
diff --git a/Tools/icc.py b/waflib/Tools/icc.py
index b6492c8..b6492c8 100644
--- a/Tools/icc.py
+++ b/waflib/Tools/icc.py
diff --git a/Tools/icpc.py b/waflib/Tools/icpc.py
index 8a6cc6c..8a6cc6c 100644
--- a/Tools/icpc.py
+++ b/waflib/Tools/icpc.py
diff --git a/Tools/ifort.py b/waflib/Tools/ifort.py
index 74934f3..74934f3 100644
--- a/Tools/ifort.py
+++ b/waflib/Tools/ifort.py
diff --git a/Tools/intltool.py b/waflib/Tools/intltool.py
index af95ba8..af95ba8 100644
--- a/Tools/intltool.py
+++ b/waflib/Tools/intltool.py
diff --git a/Tools/irixcc.py b/waflib/Tools/irixcc.py
index c3ae1ac..c3ae1ac 100644
--- a/Tools/irixcc.py
+++ b/waflib/Tools/irixcc.py
diff --git a/Tools/javaw.py b/waflib/Tools/javaw.py
index f6fd20c..f6fd20c 100644
--- a/Tools/javaw.py
+++ b/waflib/Tools/javaw.py
diff --git a/Tools/ldc2.py b/waflib/Tools/ldc2.py
index a51c344..a51c344 100644
--- a/Tools/ldc2.py
+++ b/waflib/Tools/ldc2.py
diff --git a/Tools/lua.py b/waflib/Tools/lua.py
index 15a333a..15a333a 100644
--- a/Tools/lua.py
+++ b/waflib/Tools/lua.py
diff --git a/Tools/md5_tstamp.py b/waflib/Tools/md5_tstamp.py
index 6428e46..6428e46 100644
--- a/Tools/md5_tstamp.py
+++ b/waflib/Tools/md5_tstamp.py
diff --git a/Tools/msvc.py b/waflib/Tools/msvc.py
index 17b347d..17b347d 100644
--- a/Tools/msvc.py
+++ b/waflib/Tools/msvc.py
diff --git a/Tools/nasm.py b/waflib/Tools/nasm.py
index 411d582..411d582 100644
--- a/Tools/nasm.py
+++ b/waflib/Tools/nasm.py
diff --git a/Tools/nobuild.py b/waflib/Tools/nobuild.py
index 2e4b055..2e4b055 100644
--- a/Tools/nobuild.py
+++ b/waflib/Tools/nobuild.py
diff --git a/Tools/perl.py b/waflib/Tools/perl.py
index 32b03fb..32b03fb 100644
--- a/Tools/perl.py
+++ b/waflib/Tools/perl.py
diff --git a/Tools/python.py b/waflib/Tools/python.py
index 25841d0..25841d0 100644
--- a/Tools/python.py
+++ b/waflib/Tools/python.py
diff --git a/Tools/qt5.py b/waflib/Tools/qt5.py
index 4f9c690..4f9c690 100644
--- a/Tools/qt5.py
+++ b/waflib/Tools/qt5.py
diff --git a/Tools/ruby.py b/waflib/Tools/ruby.py
index 8d92a79..8d92a79 100644
--- a/Tools/ruby.py
+++ b/waflib/Tools/ruby.py
diff --git a/Tools/suncc.py b/waflib/Tools/suncc.py
index 33d34fc..33d34fc 100644
--- a/Tools/suncc.py
+++ b/waflib/Tools/suncc.py
diff --git a/Tools/suncxx.py b/waflib/Tools/suncxx.py
index 3b384f6..3b384f6 100644
--- a/Tools/suncxx.py
+++ b/waflib/Tools/suncxx.py
diff --git a/Tools/tex.py b/waflib/Tools/tex.py
index eaf9fdb..eaf9fdb 100644
--- a/Tools/tex.py
+++ b/waflib/Tools/tex.py
diff --git a/Tools/vala.py b/waflib/Tools/vala.py
index 822ec50..822ec50 100644
--- a/Tools/vala.py
+++ b/waflib/Tools/vala.py
diff --git a/Tools/waf_unit_test.py b/waflib/Tools/waf_unit_test.py
index a71ed1c..a71ed1c 100644
--- a/Tools/waf_unit_test.py
+++ b/waflib/Tools/waf_unit_test.py
diff --git a/Tools/winres.py b/waflib/Tools/winres.py
index 586c596..586c596 100644
--- a/Tools/winres.py
+++ b/waflib/Tools/winres.py
diff --git a/Tools/xlc.py b/waflib/Tools/xlc.py
index 134dd41..134dd41 100644
--- a/Tools/xlc.py
+++ b/waflib/Tools/xlc.py
diff --git a/Tools/xlcxx.py b/waflib/Tools/xlcxx.py
index 76aa59b..76aa59b 100644
--- a/Tools/xlcxx.py
+++ b/waflib/Tools/xlcxx.py
diff --git a/Utils.py b/waflib/Utils.py
index b4665c4..b4665c4 100644
--- a/Utils.py
+++ b/waflib/Utils.py
diff --git a/__init__.py b/waflib/__init__.py
index 079df35..079df35 100644
--- a/__init__.py
+++ b/waflib/__init__.py
diff --git a/ansiterm.py b/waflib/ansiterm.py
index 0d20c63..0d20c63 100644
--- a/ansiterm.py
+++ b/waflib/ansiterm.py
diff --git a/extras/__init__.py b/waflib/extras/__init__.py
index c8a3c34..c8a3c34 100644
--- a/extras/__init__.py
+++ b/waflib/extras/__init__.py
diff --git a/extras/autowaf.py b/waflib/extras/autowaf.py
index feaae3c..feaae3c 100644
--- a/extras/autowaf.py
+++ b/waflib/extras/autowaf.py
diff --git a/extras/batched_cc.py b/waflib/extras/batched_cc.py
index aad2872..aad2872 100644
--- a/extras/batched_cc.py
+++ b/waflib/extras/batched_cc.py
diff --git a/extras/biber.py b/waflib/extras/biber.py
index fd9db4e..fd9db4e 100644
--- a/extras/biber.py
+++ b/waflib/extras/biber.py
diff --git a/extras/bjam.py b/waflib/extras/bjam.py
index 8e04d3a..8e04d3a 100644
--- a/extras/bjam.py
+++ b/waflib/extras/bjam.py
diff --git a/extras/blender.py b/waflib/extras/blender.py
index e5efc28..e5efc28 100644
--- a/extras/blender.py
+++ b/waflib/extras/blender.py
diff --git a/extras/boo.py b/waflib/extras/boo.py
index 06623d4..06623d4 100644
--- a/extras/boo.py
+++ b/waflib/extras/boo.py
diff --git a/extras/boost.py b/waflib/extras/boost.py
index c2aaaa9..c2aaaa9 100644
--- a/extras/boost.py
+++ b/waflib/extras/boost.py
diff --git a/extras/build_file_tracker.py b/waflib/extras/build_file_tracker.py
index c4f26fd..c4f26fd 100644
--- a/extras/build_file_tracker.py
+++ b/waflib/extras/build_file_tracker.py
diff --git a/extras/build_logs.py b/waflib/extras/build_logs.py
index cdf8ed0..cdf8ed0 100644
--- a/extras/build_logs.py
+++ b/waflib/extras/build_logs.py
diff --git a/extras/buildcopy.py b/waflib/extras/buildcopy.py
index a6d9ac8..a6d9ac8 100644
--- a/extras/buildcopy.py
+++ b/waflib/extras/buildcopy.py
diff --git a/extras/c_bgxlc.py b/waflib/extras/c_bgxlc.py
index 6e3eaf7..6e3eaf7 100644
--- a/extras/c_bgxlc.py
+++ b/waflib/extras/c_bgxlc.py
diff --git a/extras/c_dumbpreproc.py b/waflib/extras/c_dumbpreproc.py
index ce9e1a4..ce9e1a4 100644
--- a/extras/c_dumbpreproc.py
+++ b/waflib/extras/c_dumbpreproc.py
diff --git a/extras/c_emscripten.py b/waflib/extras/c_emscripten.py
index e1ac494..e1ac494 100644
--- a/extras/c_emscripten.py
+++ b/waflib/extras/c_emscripten.py
diff --git a/extras/c_nec.py b/waflib/extras/c_nec.py
index 96bfae4..96bfae4 100644
--- a/extras/c_nec.py
+++ b/waflib/extras/c_nec.py
diff --git a/extras/cabal.py b/waflib/extras/cabal.py
index e10a0d1..e10a0d1 100644
--- a/extras/cabal.py
+++ b/waflib/extras/cabal.py
diff --git a/extras/cfg_altoptions.py b/waflib/extras/cfg_altoptions.py
index 47b1189..47b1189 100644
--- a/extras/cfg_altoptions.py
+++ b/waflib/extras/cfg_altoptions.py
diff --git a/extras/clang_compilation_database.py b/waflib/extras/clang_compilation_database.py
index 4d9b5e2..4d9b5e2 100644
--- a/extras/clang_compilation_database.py
+++ b/waflib/extras/clang_compilation_database.py
diff --git a/extras/codelite.py b/waflib/extras/codelite.py
index 523302c..523302c 100644
--- a/extras/codelite.py
+++ b/waflib/extras/codelite.py
diff --git a/extras/color_gcc.py b/waflib/extras/color_gcc.py
index b68c5eb..b68c5eb 100644
--- a/extras/color_gcc.py
+++ b/waflib/extras/color_gcc.py
diff --git a/extras/color_rvct.py b/waflib/extras/color_rvct.py
index f89ccbd..f89ccbd 100644
--- a/extras/color_rvct.py
+++ b/waflib/extras/color_rvct.py
diff --git a/extras/compat15.py b/waflib/extras/compat15.py
index 0e74df8..0e74df8 100644
--- a/extras/compat15.py
+++ b/waflib/extras/compat15.py
diff --git a/extras/cppcheck.py b/waflib/extras/cppcheck.py
index 13ff424..13ff424 100644
--- a/extras/cppcheck.py
+++ b/waflib/extras/cppcheck.py
diff --git a/extras/cpplint.py b/waflib/extras/cpplint.py
index e3302e5..e3302e5 100644
--- a/extras/cpplint.py
+++ b/waflib/extras/cpplint.py
diff --git a/extras/cross_gnu.py b/waflib/extras/cross_gnu.py
index 309f53b..309f53b 100644
--- a/extras/cross_gnu.py
+++ b/waflib/extras/cross_gnu.py
diff --git a/extras/cython.py b/waflib/extras/cython.py
index 481d6f4..481d6f4 100644
--- a/extras/cython.py
+++ b/waflib/extras/cython.py
diff --git a/extras/dcc.py b/waflib/extras/dcc.py
index c1a57c0..c1a57c0 100644
--- a/extras/dcc.py
+++ b/waflib/extras/dcc.py
diff --git a/extras/distnet.py b/waflib/extras/distnet.py
index 09a31a6..09a31a6 100644
--- a/extras/distnet.py
+++ b/waflib/extras/distnet.py
diff --git a/extras/doxygen.py b/waflib/extras/doxygen.py
index 28f56e9..28f56e9 100644
--- a/extras/doxygen.py
+++ b/waflib/extras/doxygen.py
diff --git a/extras/dpapi.py b/waflib/extras/dpapi.py
index b94d482..b94d482 100644
--- a/extras/dpapi.py
+++ b/waflib/extras/dpapi.py
diff --git a/extras/eclipse.py b/waflib/extras/eclipse.py
index bb78741..bb78741 100644
--- a/extras/eclipse.py
+++ b/waflib/extras/eclipse.py
diff --git a/extras/erlang.py b/waflib/extras/erlang.py
index 49f6d5b..49f6d5b 100644
--- a/extras/erlang.py
+++ b/waflib/extras/erlang.py
diff --git a/extras/fast_partial.py b/waflib/extras/fast_partial.py
index b3af513..b3af513 100644
--- a/extras/fast_partial.py
+++ b/waflib/extras/fast_partial.py
diff --git a/extras/fc_bgxlf.py b/waflib/extras/fc_bgxlf.py
index cca1810..cca1810 100644
--- a/extras/fc_bgxlf.py
+++ b/waflib/extras/fc_bgxlf.py
diff --git a/extras/fc_cray.py b/waflib/extras/fc_cray.py
index da733fa..da733fa 100644
--- a/extras/fc_cray.py
+++ b/waflib/extras/fc_cray.py
diff --git a/extras/fc_nag.py b/waflib/extras/fc_nag.py
index edcb218..edcb218 100644
--- a/extras/fc_nag.py
+++ b/waflib/extras/fc_nag.py
diff --git a/extras/fc_nec.py b/waflib/extras/fc_nec.py
index 67c8680..67c8680 100644
--- a/extras/fc_nec.py
+++ b/waflib/extras/fc_nec.py
diff --git a/extras/fc_open64.py b/waflib/extras/fc_open64.py
index 413719f..413719f 100644
--- a/extras/fc_open64.py
+++ b/waflib/extras/fc_open64.py
diff --git a/extras/fc_pgfortran.py b/waflib/extras/fc_pgfortran.py
index afb2817..afb2817 100644
--- a/extras/fc_pgfortran.py
+++ b/waflib/extras/fc_pgfortran.py
diff --git a/extras/fc_solstudio.py b/waflib/extras/fc_solstudio.py
index 53766df..53766df 100644
--- a/extras/fc_solstudio.py
+++ b/waflib/extras/fc_solstudio.py
diff --git a/extras/fc_xlf.py b/waflib/extras/fc_xlf.py
index 5a3da03..5a3da03 100644
--- a/extras/fc_xlf.py
+++ b/waflib/extras/fc_xlf.py
diff --git a/extras/file_to_object.py b/waflib/extras/file_to_object.py
index 1393b51..1393b51 100644
--- a/extras/file_to_object.py
+++ b/waflib/extras/file_to_object.py
diff --git a/extras/fluid.py b/waflib/extras/fluid.py
index 4814a35..4814a35 100644
--- a/extras/fluid.py
+++ b/waflib/extras/fluid.py
diff --git a/extras/freeimage.py b/waflib/extras/freeimage.py
index f27e525..f27e525 100644
--- a/extras/freeimage.py
+++ b/waflib/extras/freeimage.py
diff --git a/extras/fsb.py b/waflib/extras/fsb.py
index 1b8f398..1b8f398 100644
--- a/extras/fsb.py
+++ b/waflib/extras/fsb.py
diff --git a/extras/fsc.py b/waflib/extras/fsc.py
index c67e70b..c67e70b 100644
--- a/extras/fsc.py
+++ b/waflib/extras/fsc.py
diff --git a/extras/gccdeps.py b/waflib/extras/gccdeps.py
index d9758ab..d9758ab 100644
--- a/extras/gccdeps.py
+++ b/waflib/extras/gccdeps.py
diff --git a/extras/gdbus.py b/waflib/extras/gdbus.py
index 0e0476e..0e0476e 100644
--- a/extras/gdbus.py
+++ b/waflib/extras/gdbus.py
diff --git a/extras/gob2.py b/waflib/extras/gob2.py
index b4fa3b9..b4fa3b9 100644
--- a/extras/gob2.py
+++ b/waflib/extras/gob2.py
diff --git a/extras/halide.py b/waflib/extras/halide.py
index 6078e38..6078e38 100644
--- a/extras/halide.py
+++ b/waflib/extras/halide.py
diff --git a/extras/javatest.py b/waflib/extras/javatest.py
index 979b8d8..979b8d8 100755
--- a/extras/javatest.py
+++ b/waflib/extras/javatest.py
diff --git a/extras/kde4.py b/waflib/extras/kde4.py
index e49a9ec..e49a9ec 100644
--- a/extras/kde4.py
+++ b/waflib/extras/kde4.py
diff --git a/extras/local_rpath.py b/waflib/extras/local_rpath.py
index b2507e1..b2507e1 100644
--- a/extras/local_rpath.py
+++ b/waflib/extras/local_rpath.py
diff --git a/extras/lv2.py b/waflib/extras/lv2.py
index 815987f..815987f 100644
--- a/extras/lv2.py
+++ b/waflib/extras/lv2.py
diff --git a/extras/make.py b/waflib/extras/make.py
index 933d9ca..933d9ca 100644
--- a/extras/make.py
+++ b/waflib/extras/make.py
diff --git a/extras/midl.py b/waflib/extras/midl.py
index 43e6cf9..43e6cf9 100644
--- a/extras/midl.py
+++ b/waflib/extras/midl.py
diff --git a/extras/msvcdeps.py b/waflib/extras/msvcdeps.py
index fc1ecd4..fc1ecd4 100644
--- a/extras/msvcdeps.py
+++ b/waflib/extras/msvcdeps.py
diff --git a/extras/msvs.py b/waflib/extras/msvs.py
index 8aa2db0..8aa2db0 100644
--- a/extras/msvs.py
+++ b/waflib/extras/msvs.py
diff --git a/extras/netcache_client.py b/waflib/extras/netcache_client.py
index dc49048..dc49048 100644
--- a/extras/netcache_client.py
+++ b/waflib/extras/netcache_client.py
diff --git a/extras/objcopy.py b/waflib/extras/objcopy.py
index 82d8359..82d8359 100644
--- a/extras/objcopy.py
+++ b/waflib/extras/objcopy.py
diff --git a/extras/ocaml.py b/waflib/extras/ocaml.py
index afe73c0..afe73c0 100644
--- a/extras/ocaml.py
+++ b/waflib/extras/ocaml.py
diff --git a/extras/package.py b/waflib/extras/package.py
index c06498e..c06498e 100644
--- a/extras/package.py
+++ b/waflib/extras/package.py
diff --git a/extras/parallel_debug.py b/waflib/extras/parallel_debug.py
index 35883a3..35883a3 100644
--- a/extras/parallel_debug.py
+++ b/waflib/extras/parallel_debug.py
diff --git a/extras/pch.py b/waflib/extras/pch.py
index 103e752..103e752 100644
--- a/extras/pch.py
+++ b/waflib/extras/pch.py
diff --git a/extras/pep8.py b/waflib/extras/pep8.py
index 676beed..676beed 100644
--- a/extras/pep8.py
+++ b/waflib/extras/pep8.py
diff --git a/extras/pgicc.py b/waflib/extras/pgicc.py
index 9790b9c..9790b9c 100644
--- a/extras/pgicc.py
+++ b/waflib/extras/pgicc.py
diff --git a/extras/pgicxx.py b/waflib/extras/pgicxx.py
index eae121c..eae121c 100644
--- a/extras/pgicxx.py
+++ b/waflib/extras/pgicxx.py
diff --git a/extras/proc.py b/waflib/extras/proc.py
index 764abec..764abec 100644
--- a/extras/proc.py
+++ b/waflib/extras/proc.py
diff --git a/extras/protoc.py b/waflib/extras/protoc.py
index f3cb4d8..f3cb4d8 100644
--- a/extras/protoc.py
+++ b/waflib/extras/protoc.py
diff --git a/extras/pyqt5.py b/waflib/extras/pyqt5.py
index c21dfa7..c21dfa7 100644
--- a/extras/pyqt5.py
+++ b/waflib/extras/pyqt5.py
diff --git a/extras/pytest.py b/waflib/extras/pytest.py
index 7dd5a1a..7dd5a1a 100644
--- a/extras/pytest.py
+++ b/waflib/extras/pytest.py
diff --git a/extras/qnxnto.py b/waflib/extras/qnxnto.py
index 1158124..1158124 100644
--- a/extras/qnxnto.py
+++ b/waflib/extras/qnxnto.py
diff --git a/extras/qt4.py b/waflib/extras/qt4.py
index 90cae7e..90cae7e 100644
--- a/extras/qt4.py
+++ b/waflib/extras/qt4.py
diff --git a/extras/relocation.py b/waflib/extras/relocation.py
index 7e821f4..7e821f4 100644
--- a/extras/relocation.py
+++ b/waflib/extras/relocation.py
diff --git a/extras/remote.py b/waflib/extras/remote.py
index 3b038f7..3b038f7 100644
--- a/extras/remote.py
+++ b/waflib/extras/remote.py
diff --git a/extras/resx.py b/waflib/extras/resx.py
index caf4d31..caf4d31 100644
--- a/extras/resx.py
+++ b/waflib/extras/resx.py
diff --git a/extras/review.py b/waflib/extras/review.py
index 561e062..561e062 100644
--- a/extras/review.py
+++ b/waflib/extras/review.py
diff --git a/extras/rst.py b/waflib/extras/rst.py
index f3c3a5e..f3c3a5e 100644
--- a/extras/rst.py
+++ b/waflib/extras/rst.py
diff --git a/extras/run_do_script.py b/waflib/extras/run_do_script.py
index f3c5812..f3c5812 100644
--- a/extras/run_do_script.py
+++ b/waflib/extras/run_do_script.py
diff --git a/extras/run_m_script.py b/waflib/extras/run_m_script.py
index b5f27eb..b5f27eb 100644
--- a/extras/run_m_script.py
+++ b/waflib/extras/run_m_script.py
diff --git a/extras/run_py_script.py b/waflib/extras/run_py_script.py
index 3670381..3670381 100644
--- a/extras/run_py_script.py
+++ b/waflib/extras/run_py_script.py
diff --git a/extras/run_r_script.py b/waflib/extras/run_r_script.py
index b0d8f2b..b0d8f2b 100644
--- a/extras/run_r_script.py
+++ b/waflib/extras/run_r_script.py
diff --git a/extras/sas.py b/waflib/extras/sas.py
index 754c614..754c614 100644
--- a/extras/sas.py
+++ b/waflib/extras/sas.py
diff --git a/extras/satellite_assembly.py b/waflib/extras/satellite_assembly.py
index 005eb07..005eb07 100644
--- a/extras/satellite_assembly.py
+++ b/waflib/extras/satellite_assembly.py
diff --git a/extras/scala.py b/waflib/extras/scala.py
index a9880f0..a9880f0 100644
--- a/extras/scala.py
+++ b/waflib/extras/scala.py
diff --git a/extras/slow_qt4.py b/waflib/extras/slow_qt4.py
index ec7880b..ec7880b 100644
--- a/extras/slow_qt4.py
+++ b/waflib/extras/slow_qt4.py
diff --git a/extras/softlink_libs.py b/waflib/extras/softlink_libs.py
index 50c777f..50c777f 100644
--- a/extras/softlink_libs.py
+++ b/waflib/extras/softlink_libs.py
diff --git a/extras/stale.py b/waflib/extras/stale.py
index cac3f46..cac3f46 100644
--- a/extras/stale.py
+++ b/waflib/extras/stale.py
diff --git a/extras/stracedeps.py b/waflib/extras/stracedeps.py
index 37d82cb..37d82cb 100644
--- a/extras/stracedeps.py
+++ b/waflib/extras/stracedeps.py
diff --git a/extras/swig.py b/waflib/extras/swig.py
index fd3d6d2..fd3d6d2 100644
--- a/extras/swig.py
+++ b/waflib/extras/swig.py
diff --git a/extras/syms.py b/waflib/extras/syms.py
index dfa0059..dfa0059 100644
--- a/extras/syms.py
+++ b/waflib/extras/syms.py
diff --git a/extras/ticgt.py b/waflib/extras/ticgt.py
index f43a7ea..f43a7ea 100644
--- a/extras/ticgt.py
+++ b/waflib/extras/ticgt.py
diff --git a/extras/unity.py b/waflib/extras/unity.py
index 78128ed..78128ed 100644
--- a/extras/unity.py
+++ b/waflib/extras/unity.py
diff --git a/extras/use_config.py b/waflib/extras/use_config.py
index ef5129f..ef5129f 100644
--- a/extras/use_config.py
+++ b/waflib/extras/use_config.py
diff --git a/extras/valadoc.py b/waflib/extras/valadoc.py
index c50f69e..c50f69e 100644
--- a/extras/valadoc.py
+++ b/waflib/extras/valadoc.py
diff --git a/extras/waf_xattr.py b/waflib/extras/waf_xattr.py
index 351dd63..351dd63 100644
--- a/extras/waf_xattr.py
+++ b/waflib/extras/waf_xattr.py
diff --git a/extras/why.py b/waflib/extras/why.py
index 1bb941f..1bb941f 100644
--- a/extras/why.py
+++ b/waflib/extras/why.py
diff --git a/extras/win32_opts.py b/waflib/extras/win32_opts.py
index 9f7443c..9f7443c 100644
--- a/extras/win32_opts.py
+++ b/waflib/extras/win32_opts.py
diff --git a/extras/wix.py b/waflib/extras/wix.py
index d87bfbb..d87bfbb 100644
--- a/extras/wix.py
+++ b/waflib/extras/wix.py
diff --git a/extras/xcode6.py b/waflib/extras/xcode6.py
index 91bbff1..91bbff1 100644
--- a/extras/xcode6.py
+++ b/waflib/extras/xcode6.py
diff --git a/fixpy2.py b/waflib/fixpy2.py
index 24176e0..24176e0 100644
--- a/fixpy2.py
+++ b/waflib/fixpy2.py
diff --git a/processor.py b/waflib/processor.py
index 2eecf3b..2eecf3b 100755
--- a/processor.py
+++ b/waflib/processor.py
diff --git a/waflib/waf b/waflib/waf
new file mode 100755
index 0000000..e22930a
--- /dev/null
+++ b/waflib/waf
@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+
+# Minimal waf script for projects that include waflib directly
+
+from waflib import Context, Scripting
+
+import inspect
+import os
+
+def main():
+    script_path = os.path.abspath(inspect.getfile(inspect.getmodule(main)))
+    project_path = os.path.dirname(script_path)
+    Scripting.waf_entry_point(os.getcwd(), Context.WAFVERSION, project_path)
+
+if __name__ == '__main__':
+    main()
diff --git a/wscript b/wscript
new file mode 100644
index 0000000..758678f
--- /dev/null
+++ b/wscript
@@ -0,0 +1,281 @@
+#!/usr/bin/env python
+
+import os
+import subprocess
+
+from waflib import Options
+from waflib.extras import autowaf as autowaf
+
+# Version of this package (even if built as a child)
+JALV_VERSION = '1.6.1'
+
+# Variables for 'waf dist'
+APPNAME = 'jalv'
+VERSION = JALV_VERSION
+
+# Mandatory variables
+top = '.'
+out = 'build'
+
+def options(ctx):
+    ctx.load('compiler_c')
+    ctx.load('compiler_cxx')
+    autowaf.set_options(ctx)
+    opt = ctx.get_option_group('Configuration options')
+    autowaf.add_flags(
+        opt,
+        {'portaudio':       'use PortAudio backend, not JACK',
+         'no-jack-session': 'do not build JACK session support',
+         'no-gui':          'do not build any GUIs',
+         'no-gtk':          'do not build Gtk GUI',
+         'no-gtkmm':        'do not build Gtkmm GUI',
+         'no-gtk2':         'do not build Gtk2 GUI',
+         'no-gtk3':         'do not build Gtk3 GUI',
+         'no-qt':           'do not build Qt GUI',
+         'no-qt4':          'do not build Qt4 GUI',
+         'no-qt5':          'do not build Qt5 GUI'})
+
+def configure(conf):
+    autowaf.display_header('Jalv Configuration')
+    autowaf.set_line_just(conf, 45)
+    conf.load('compiler_c', cache=True)
+    conf.load('compiler_cxx', cache=True)
+    conf.load('autowaf', cache=True)
+    autowaf.set_c_lang(conf, 'c99')
+
+    autowaf.check_pkg(conf, 'lv2', atleast_version='1.14.0', uselib_store='LV2')
+    autowaf.check_pkg(conf, 'lilv-0', uselib_store='LILV',
+                      atleast_version='0.24.0', mandatory=True)
+    autowaf.check_pkg(conf, 'serd-0', uselib_store='SERD',
+                      atleast_version='0.14.0', mandatory=True)
+    autowaf.check_pkg(conf, 'sord-0', uselib_store='SORD',
+                      atleast_version='0.12.0', mandatory=True)
+    autowaf.check_pkg(conf, 'sratom-0', uselib_store='SRATOM',
+                      atleast_version='0.6.0', mandatory=True)
+    if Options.options.portaudio:
+        autowaf.check_pkg(conf, 'portaudio-2.0', uselib_store='PORTAUDIO',
+                          atleast_version='2.0.0', mandatory=False)
+    else:
+        autowaf.check_pkg(conf, 'jack', uselib_store='JACK',
+                          atleast_version='0.120.0', mandatory=True)
+
+    if not Options.options.no_gui and not Options.options.no_gtk:
+        if not Options.options.no_gtk2:
+            autowaf.check_pkg(conf, 'gtk+-2.0', uselib_store='GTK2',
+                              atleast_version='2.18.0', mandatory=False)
+        if not Options.options.no_gtkmm:
+            autowaf.check_pkg(conf, 'gtkmm-2.4', uselib_store='GTKMM2',
+                              atleast_version='2.20.0', mandatory=False)
+        if not Options.options.no_gtk3:
+            autowaf.check_pkg(conf, 'gtk+-3.0', uselib_store='GTK3',
+                              atleast_version='3.0.0', mandatory=False)
+
+    if not Options.options.no_gui and not Options.options.no_qt:
+        if not Options.options.no_qt4:
+            autowaf.check_pkg(conf, 'QtGui', uselib_store='QT4',
+                              atleast_version='4.0.0', mandatory=False)
+            if conf.env.HAVE_QT4:
+                if not conf.find_program('moc-qt4', var='MOC4', mandatory=False):
+                    conf.find_program('moc', var='MOC4')
+
+        if not Options.options.no_qt5:
+            autowaf.check_pkg(conf, 'Qt5Widgets', uselib_store='QT5',
+                              atleast_version='5.1.0', mandatory=False)
+            if conf.env.HAVE_QT5:
+                if not conf.find_program('moc-qt5', var='MOC5', mandatory=False):
+                    conf.find_program('moc', var='MOC5')
+
+    have_gui = (conf.env.HAVE_GTK2 or conf.env.HAVE_GTKMM2 or conf.env.HAVE_GTK3 or
+                conf.env.HAVE_QT4 or conf.env.HAVE_QT5)
+    if have_gui:
+        autowaf.check_pkg(conf, 'suil-0', uselib_store='SUIL',
+                          atleast_version='0.8.7')
+
+    if conf.env.HAVE_JACK:
+        autowaf.check_function(
+            conf, 'c', 'jack_port_type_get_buffer_size',
+            header_name = 'jack/jack.h',
+            define_name = 'HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE',
+            uselib      = 'JACK',
+            mandatory   = False)
+
+        autowaf.check_function(conf, 'c', 'jack_set_property',
+                               header_name = 'jack/metadata.h',
+                               define_name = 'HAVE_JACK_METADATA',
+                               uselib      = 'JACK',
+                               mandatory   = False)
+
+    defines = ['_POSIX_C_SOURCE=200809L']
+
+    autowaf.check_function(conf, 'c', 'isatty',
+                           header_name = 'unistd.h',
+                           defines     = defines,
+                           define_name = 'HAVE_ISATTY',
+                           mandatory   = False)
+
+    autowaf.check_function(conf, 'c', 'fileno',
+                           header_name = 'stdio.h',
+                           defines     = defines,
+                           define_name = 'HAVE_FILENO',
+                           mandatory   = False)
+
+    autowaf.check_function(conf, 'c', 'mlock',
+                           header_name = 'sys/mman.h',
+                           defines     = defines,
+                           define_name = 'HAVE_MLOCK',
+                           mandatory   = False)
+
+    autowaf.check_function(conf, 'c', 'sigaction',
+                           header_name = 'signal.h',
+                           defines     = defines,
+                           define_name = 'HAVE_SIGACTION',
+                           mandatory   = False)
+
+    if conf.is_defined('HAVE_ISATTY') and conf.is_defined('HAVE_FILENO'):
+        autowaf.define(conf, 'JALV_WITH_COLOR', 1)
+        conf.env.append_unique('CFLAGS', ['-D_POSIX_C_SOURCE=200809L'])
+
+    if not Options.options.no_jack_session:
+        autowaf.define(conf, 'JALV_JACK_SESSION', 1)
+
+    conf.write_config_header('jalv_config.h', remove=False)
+
+    autowaf.display_summary(
+        conf,
+        {'Backend': 'Jack' if conf.env.HAVE_JACK else 'PortAudio',
+         'Jack metadata support': conf.is_defined('HAVE_JACK_METADATA'),
+         'Gtk 2.0 support': bool(conf.env.HAVE_GTK2),
+         'Gtk 3.0 support': bool(conf.env.HAVE_GTK3),
+         'Gtkmm 2.0 support': bool(conf.env.HAVE_GTKMM2),
+         'Qt 4.0 support': bool(conf.env.HAVE_QT4),
+         'Qt 5.0 support': bool(conf.env.HAVE_QT5),
+         'Color output': bool(conf.env.JALV_WITH_COLOR)})
+
+def build(bld):
+    libs   = 'LILV SUIL JACK SERD SORD SRATOM LV2 PORTAUDIO'
+    source = '''
+    src/control.c
+    src/jalv.c
+    src/log.c
+    src/lv2_evbuf.c
+    src/state.c
+    src/symap.c
+    src/worker.c
+    src/zix/ring.c
+    '''
+
+    if bld.env.HAVE_JACK:
+        source += 'src/jack.c'
+
+        # Non-GUI internal JACK client library
+        obj = bld(features     = 'c cshlib',
+                  source       = source + ' src/jalv_console.c',
+                  target       = 'jalv',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${LIBDIR}/jack')
+        autowaf.use_lib(bld, obj, libs)
+        obj.env.cshlib_PATTERN = '%s.so'
+    elif bld.env.HAVE_PORTAUDIO:
+        source += 'src/portaudio.c'
+
+    # Non-GUI version
+    obj = bld(features     = 'c cprogram',
+              source       = source + ' src/jalv_console.c',
+              target       = 'jalv',
+              includes     = ['.', 'src'],
+              lib          = ['pthread'],
+              install_path = '${BINDIR}')
+    autowaf.use_lib(bld, obj, libs)
+
+    # Gtk2 version
+    if bld.env.HAVE_GTK2:
+        obj = bld(features     = 'c cprogram',
+                  source       = source + ' src/jalv_gtk.c',
+                  target       = 'jalv.gtk',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread', 'm'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTK2')
+
+    # Gtk3 version
+    if bld.env.HAVE_GTK3:
+        obj = bld(features     = 'c cprogram',
+                  source       = source + ' src/jalv_gtk.c',
+                  target       = 'jalv.gtk3',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread', 'm'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTK3')
+
+    # Gtkmm version
+    if bld.env.HAVE_GTKMM2:
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = source + ' src/jalv_gtkmm2.cpp',
+                  target       = 'jalv.gtkmm',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' GTKMM2')
+
+    # Qt4 version
+    if bld.env.HAVE_QT4:
+        obj = bld(rule = '${MOC4} ${SRC} > ${TGT}',
+                  source = 'src/jalv_qt.cpp',
+                  target = 'jalv_qt4_meta.hpp')
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = source + ' src/jalv_qt.cpp',
+                  target       = 'jalv.qt4',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${BINDIR}')
+        autowaf.use_lib(bld, obj, libs + ' QT4')
+
+    # Qt5 version
+    if bld.env.HAVE_QT5:
+        obj = bld(rule = '${MOC5} ${SRC} > ${TGT}',
+                  source = 'src/jalv_qt.cpp',
+                  target = 'jalv_qt5_meta.hpp')
+        obj = bld(features     = 'c cxx cxxprogram',
+                  source       = source + ' src/jalv_qt.cpp',
+                  target       = 'jalv.qt5',
+                  includes     = ['.', 'src'],
+                  lib          = ['pthread'],
+                  install_path = '${BINDIR}',
+                  cxxflags     = ['-fPIC'])
+        autowaf.use_lib(bld, obj, libs + ' QT5')
+
+    # Man pages
+    bld.install_files('${MANDIR}/man1', bld.path.ant_glob('doc/*.1'))
+
+def upload_docs(ctx):
+    import glob
+    import os
+    for page in glob.glob('doc/*.[1-8]'):
+        os.system('mkdir -p build/doc')
+        os.system('soelim %s | pre-grohtml troff -man -wall -Thtml | post-grohtml > build/%s.html' % (page, page))
+        os.system('rsync -avz --delete -e ssh build/%s.html drobilla@drobilla.net:~/drobilla.net/man/' % page)
+
+def lint(ctx):
+    "checks code for style issues"
+    import subprocess
+    cmd = ("clang-tidy -p=. -header-filter=src/ -checks=\"*," +
+           "-clang-analyzer-alpha.*," +
+           "-google-readability-todo," +
+           "-llvm-header-guard," +
+           "-llvm-include-order," +
+           "-misc-unused-parameters," +
+           "-readability-else-after-return\" " +
+           "$(find .. -name '*.c')")
+    subprocess.call(cmd, cwd='build', shell=True)
+
+def posts(ctx):
+    path = str(ctx.path.abspath())
+    autowaf.news_to_posts(
+        os.path.join(path, 'NEWS'),
+        {'title'        : 'Jalv',
+         'description'  : autowaf.get_blurb(os.path.join(path, 'README')),
+         'dist_pattern' : 'http://download.drobilla.net/jalv-%s.tar.bz2'},
+        { 'Author' : 'drobilla',
+          'Tags'   : 'Hacking, LAD, LV2, Jalv' },
+        os.path.join(out, 'posts'))