diff --git a/Makefile b/Makefile
index 17fc54f..ba5bf86 100644
--- a/Makefile
+++ b/Makefile
@@ -85,6 +85,10 @@ ifeq ($(shell pkg-config --atleast-version=1.9.0 jack && echo true), true)
 INCS += -DHAVE_JACK2
 endif
 
+ifeq ($(shell pkg-config --atleast-version=1.9.23 jack && echo true), true)
+INCS += -DHAVE_JACK2_1_9_23
+endif
+
 ifeq ($(HAVE_NE10),true)
 LIBS += -lNE10
 INCS += -DHAVE_NE10
diff --git a/README.md b/README.md
index 42b7f2a..6729642 100644
--- a/README.md
+++ b/README.md
@@ -91,7 +91,7 @@ Options
     -i, --interactive
         interactive shell mode
 
-    -n, --nofork 
+    -n, --nofork
         run in non-forking mode
 
     -V, --version
@@ -107,15 +107,26 @@ Commands (or Protocol)
 The commands supported by mod-host are:
 
     add <lv2_uri> <instance_number>
-        * add an LV2 plugin encapsulated as a jack client
+        * add an LV2 plugin encapsulated as a jack client, in activated state
         e.g.: add "http://lv2plug.in/plugins/eg-amp" 0
         instance_number must be any value between 0 ~ 9990, inclusively
 
     remove <instance_number>
-        * remove an LV2 plugin instance (and also the jack client)
+        * remove an LV2 plugin instance, and also the jack client
         e.g.: remove 0
         when instance_number is -1 all plugins will be removed
 
+    activate <instance_number> <activate_value>
+        * toggle effect activated state
+        e.g.: activate 0 1
+        if activate_value = 1 activate effect
+        if activate_value = 0 deactivate effect
+
+    preload <lv2_uri> <instance_number>
+        * add an LV2 plugin encapsulated as a jack client, in deactivated state
+        e.g.: preload "http://lv2plug.in/plugins/eg-amp" 0
+        instance_number must be any value between 0 ~ 9990, inclusively
+
     preset_load <instance_number> <preset_uri>
         * load a preset state of an effect instance
         e.g.: preset_load 0 "http://drobilla.net/plugins/mda/presets#JX10-moogcury-lite"
@@ -132,10 +143,26 @@ The commands supported by mod-host are:
         * connect two jack ports
         e.g.: connect "system:capture_1" "effect_0:in"
 
+    connect_matching <matching_port> <destination_port>
+        * connect the same connected ports of a port to another, so they match.
+        e.g.: connect "effect_0:in" "effect_1:in"
+
+    connect_safe <origin_port> <destination_port>
+        * safely connect two jack ports, verifying that they exist beforehand
+        e.g.: connect_safe "system:capture_1" "effect_0:in"
+
     disconnect <origin_port> <destination_port>
         * disconnect two jack ports
         e.g.: disconnect "system:capture_1" "effect_0:in"
 
+    disconnect_all <origin_port>
+        * disconnect all connections of a jack port
+        e.g.: disconnect_all "effect_0:in"
+
+    disconnect_safe <origin_port> <destination_port>
+        * safely disconnect two jack ports, verifying that they exist and have connections beforehand
+        e.g.: disconnect_safe "system:capture_1" "effect_0:in"
+
     bypass <instance_number> <bypass_value>
         * toggle effect processing
         e.g.: bypass 0 1
@@ -154,6 +181,17 @@ The commands supported by mod-host are:
         * monitor a control port according to a condition
         e.g: param_monitor 0 "gain" ">" 2.5
 
+    params_flush <instance_number> <reset_value> <param_count> <params...>
+        * flush several param values at once and trigger reset if available
+        * reset value must be according to reset property spec
+        e.g.: params_flush 0 1 2 "gain" 0.0 "distortion" 0.5
+
+    pre_run <instance_number> <reset_value> <param_count> <params...>
+        * pre-run and flush several param values at once and trigger reset if available
+        * reset value must be according to reset property spec
+        * instance must be in deactivated state or global processing disabled (and plugin does not have isLive flag)
+        e.g.: pre_run 0 1 2 "gain" 0.0 "distortion" 0.5
+
     patch_set <instance_number> <property_uri> <value>
         * set the value of a control port
         e.g.: patch_set 0 "gain" 2.5
@@ -176,6 +214,10 @@ The commands supported by mod-host are:
         * request monitoring of an output control port (on the feedback port)
         e.g.: monitor_output 0 "meter"
 
+    monitor_output_off <instance_number> <param_symbol>
+        * turn off monitoring of an output control port (on the feedback port)
+        e.g.: monitor_output_off 0 "meter"
+
     midi_learn <instance_number> <param_symbol> <minimum> <maximum>
         * start MIDI learn for a control port
         e.g.: midi_learn 0 "gain" 0.0 1.0
@@ -189,21 +231,25 @@ The commands supported by mod-host are:
         * unmap the MIDI controller from a control port
         e.g.: midi_unmap 0 "gain"
 
+    monitor_audio_levels <source_port_name> <enable>
+        * monitor audio levels for a specific jack port (on the feedback port)
+        e.g.: monitor_audio_levels "system:capture_1" 1
+
+    monitor_cpu_load <enable> <instance_count> <instance_number...>
+        * monitor cpu load for specific instances
+        e.g.: monitor_cpu_load 1 2 0 1
+
+    monitor_midi_control <midi_channel> <enable>
+        * listen to MIDI control change messages (on the feedback port)
+        e.g.: monitor_midi_control 7 1
+
     monitor_midi_program <midi_channel> <enable>
         * listen to MIDI program change messages (on the feedback port)
         e.g.: monitor_midi_program 0 1
 
-    set_midi_program_change_pedalboard_bank_channel <enable> <midi_channel>
-        * set the MIDI channel which changes pedalboard banks on MIDI program change. <midi_channel> is in the range of [0,15].
-        e.g.: set_midi_program_change_pedalboard_bank_channel 1 5 to enable listening for bank changes on channel 6
-
-    set_midi_program_change_pedalboard_snapshot_channel <enable> <midi_channel>
-        * set the MIDI channel which changes pedalboard snapshots on MIDI program change. <midi_channel> is in the range of [0,15].
-        e.g.: set_midi_program_change_pedalboard_snapshot_channel 1 4 to enable listening for preset changes on channel 5
-
-    cc_map <instance_number> <param_symbol> <device_id> <actuator_id> <label> <value> <minimum> <maximum> <steps> <unit> <scalepoints_count> <scalepoints...>
+    cc_map <instance_number> <param_symbol> <device_id> <actuator_id> <label> <value> <minimum> <maximum> <steps> <extraflags> <unit> <scalepoints_count> <scalepoints...>
         * map a Control Chain actuator to a control port
-        e.g.: cc_map 0 "gain" 0 1 "Gain" 0.0 -24.0 3.0 33 "dB" 0
+        e.g.: cc_map 0 "gain" 0 1 "Gain" 0.0 -24.0 3.0 33 0 "dB" 0
 
     cc_unmap <instance_number> <param_symbol>
         * unmap the Control Chain actuator from a control port
@@ -222,7 +268,10 @@ The commands supported by mod-host are:
         e.g.: cv_unmap 0 "gain"
 
     cpu_load
-        * return current jack cpu load
+        * return current average jack cpu load
+
+    max_cpu_load
+        * return current maximum jack cpu load
 
     load <file_name>
         * load a history command file
@@ -268,6 +317,52 @@ The commands supported by mod-host are:
     output_data_ready
         * report feedback port ready for more messages
 
+    multi_add <instance_count> <lv2_uri,instance_number...>
+        * add an LV2 plugin encapsulated as a jack client, in activated state (multiple instance variant)
+        e.g.: multi_add 2 "http://lv2plug.in/plugins/eg-amp" 0 "http://lv2plug.in/plugins/eg-amp" 1
+        instance_number must be any value between 0 ~ 9990, inclusively
+
+    multi_remove <instance_count> <instance_number...>
+        * remove an LV2 plugin instance, and also the jack client (multiple instance variant)
+        e.g.: multi_remove 2 0 1
+
+    multi_activate <activate_value> <instance_count> <instance_number...>
+        * toggle effect activated state (multiple instance variant)
+        e.g.: multi_activate 0 2 0 1
+        if activate_value = 1 activate effect
+        if activate_value = 0 deactivate effect
+
+    multi_preload <instance_count> <lv2_uri,instance_number...>
+        * add an LV2 plugin encapsulated as a jack client, in deactivated state (multiple instance variant)
+        e.g.: multi_preload 2 "http://lv2plug.in/plugins/eg-amp" 0 "http://lv2plug.in/plugins/eg-amp" 1
+        instance_number must be any value between 0 ~ 9990, inclusively
+
+    multi_bypass <bypass_value> <instance_count> <instance_number...>
+        * toggle effect processing (multiple instance variant)
+        e.g.: multi_bypass 0 2 0 1
+        if bypass_value = 1 bypass effect
+        if bypass_value = 0 process effect
+
+    multi_param_set <param_symbol> <param_value> <instance_count> <instance_number...>
+        * set the value of a control port (multiple instance variant)
+        * must be instances of the same plugin
+        e.g.: multi_param_set "gain" 2.5 2 0 1
+
+    multi_params_flush <reset_value> <instance_count> <instance_number...> <param_count> <params...>
+        * flush several param values at once and trigger reset if available (multiple instance variant)
+        * reset value must be according to reset property spec
+        * all instances must be in activated state
+        e.g.: multi_params_flush 1 2 0 1 2 "gain" 0.0 "distortion" 0.5
+
+    multi_pre_run <reset_value> <instance_count> <instance_number...> <param_count> <params...>
+        * pre-run and flush several param values at once and trigger reset if available (multiple instance variant)
+        * reset value must be according to reset property spec
+        * all instances must be in deactivated state or global processing disabled (and plugins do not have isLive flag)
+        e.g.: multi_pre_run 1 2 0 1 2 "gain" 0.0 "distortion" 0.5
+
+    wait_audio_cycle
+        * wait for at least 1 audio cycle to pass
+
     help
         * show a help message
 
@@ -300,12 +395,16 @@ If status is a negative number an error has occurred. The table below shows the
 | -204    | ERR\_JACK\_PORT\_REGISTER        |
 | -205    | ERR\_JACK\_PORT\_CONNECTION      |
 | -206    | ERR\_JACK\_PORT\_DISCONNECTION   |
+| -207    | ERR\_JACK\_VALUE\_OUT\_OF\_RANGE |
 | -301    | ERR\_ASSIGNMENT\_ALREADY\_EXISTS |
 | -302    | ERR\_ASSIGNMENT\_INVALID\_OP     |
 | -303    | ERR\_ASSIGNMENT\_LIST\_FULL      |
 | -304    | ERR\_ASSIGNMENT\_FAILED          |
+| -304    | ERR\_ASSIGNMENT\_UNUSED          |
 | -401    | ERR\_CONTROL\_CHAIN\_UNAVAILABLE |
 | -402    | ERR\_LINK\_UNAVAILABLE           |
+| -403    | ERR\_HMI\_UNAVAILABLE            |
+| -404    | ERR\_EXTERNAL\_UI\_UNAVAILABLE   |
 | -901    | ERR\_MEMORY\_ALLOCATION          |
 | -902    | ERR\_INVALID\_OPERATION          |
 
diff --git a/src/effects.c b/src/effects.c
index 5281193..b6049f7 100644
--- a/src/effects.c
+++ b/src/effects.c
@@ -55,6 +55,14 @@ typedef unsigned int uint;
 #include <dlfcn.h>
 #endif
 
+#if defined(_MOD_DEVICE_RK358x)
+#include <sys/resource.h>
+#elif defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+#include <sys/resource.h>
+#include <syscall.h>
+#include <unistd.h>
+#endif
+
 /* Jack */
 #include <jack/jack.h>
 #include <jack/intclient.h>
@@ -84,11 +92,13 @@ typedef unsigned int uint;
 #include <lv2/uri-map/uri-map.h>
 #include <lv2/worker/worker.h>
 #include "lv2/control-input-port-change-request.h"
+#include "lv2/control-port-state-update.h"
+#include "lv2/kxstudio-properties.h"
 #include "lv2/lv2-hmi.h"
 #include "lv2/mod-license.h"
 
 // do not enable external-ui support in embed targets
-#if !(defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF))
+#if !(defined(_MOD_DEVICE_RK358x) || defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF))
 #define WITH_EXTERNAL_UI_SUPPORT
 #endif
 
@@ -109,10 +119,6 @@ typedef unsigned int uint;
 #endif
 
 #include "mod-host.h"
-#ifdef __MOD_DEVICES__
-#include "sys_host.h"
-#include "dsp/gate_core.h"
-#endif
 
 #ifndef HAVE_NEW_LILV
 #define lilv_free(x) free(x)
@@ -147,16 +153,19 @@ typedef struct {
 
 #define LILV_NS_MOD "http://moddevices.com/ns/mod#"
 
-#define KX_TIME__TicksPerBeat "http://kxstudio.sf.net/ns/lv2ext/props#TimePositionTicksPerBeat"
-
 // custom jack flag used for cv
 // needed because we prefer jack2 which doesn't have metadata yet
 #define JackPortIsControlVoltage 0x100
 
 #if defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+#define MOD_HMI_CONTROL_ENABLED
 #define MOD_IO_PROCESSING_ENABLED
 #endif
 
+#ifdef _DARKGLASS_DEVICE_PABLITO
+#define _DARKGLASS_PABLITO
+#endif
+
 /* Local */
 #include "effects.h"
 #include "monitor.h"
@@ -173,6 +182,14 @@ typedef struct {
 #include "filter.h"
 #include "mod-memset.h"
 
+#ifdef MOD_HMI_CONTROL_ENABLED
+#include "sys_host.h"
+#endif
+
+#ifdef __MOD_DEVICES__
+#include "dsp/gate_core.h"
+#endif
+
 /*
 ************************************************************************************************************************
 *           LOCAL DEFINES
@@ -220,20 +237,22 @@ enum PortType {
 
 enum PortHints {
     // controls
-    HINT_ENUMERATION   = 1 << 0,
-    HINT_INTEGER       = 1 << 1,
-    HINT_TOGGLE        = 1 << 2,
-    HINT_TRIGGER       = 1 << 3,
-    HINT_LOGARITHMIC   = 1 << 4,
-    HINT_MONITORED     = 1 << 5, // outputs only
-    HINT_SHOULD_UPDATE = 1 << 6, // inputs only, for external UIs
+    HINT_ENUMERATION    = 1 << 0,
+    HINT_INTEGER        = 1 << 1,
+    HINT_TOGGLE         = 1 << 2,
+    HINT_TRIGGER        = 1 << 3,
+    HINT_LOGARITHMIC    = 1 << 4,
+    HINT_MONITORED      = 1 << 5, // outputs only
+    HINT_SHOULD_UPDATE  = 1 << 6, // inputs only, for external UIs
+    HINT_STATE_INACTIVE = 1 << 7,
+    HINT_STATE_BLOCKED  = 1 << 8,
     // cv
-    HINT_CV_MOD        = 1 << 0, // uses mod cvport
-    HINT_CV_RANGES     = 1 << 1, // port info includes ranges
+    HINT_CV_MOD         = 1 << 0, // uses mod cvport
+    HINT_CV_RANGES      = 1 << 1, // port info includes ranges
     // events
-    HINT_TRANSPORT     = 1 << 0,
-    HINT_MIDI_EVENT    = 1 << 1,
-    HINT_OLD_EVENT_API = 1 << 2,
+    HINT_TRANSPORT      = 1 << 0,
+    HINT_MIDI_EVENT     = 1 << 1,
+    HINT_OLD_EVENT_API  = 1 << 2,
 };
 
 enum PluginHints {
@@ -243,6 +262,8 @@ enum PluginHints {
     HINT_HAS_MIDI_INPUT  = 1 << 3,
     HINT_HAS_STATE       = 1 << 4,
     HINT_STATE_UNSAFE    = 1 << 5, // state restore needs mutex protection
+    HINT_IS_LIVE         = 1 << 6, // needs to be always running, cannot have processing disabled
+    HINT_NO_PRE_RUN      = 1 << 7, // do not keep plugin active for pre-run
 };
 
 enum TransportSyncMode {
@@ -256,7 +277,7 @@ enum {
     URID_MAP_FEATURE,
     URID_UNMAP_FEATURE,
     OPTIONS_FEATURE,
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
     HMI_WC_FEATURE,
 #endif
     LICENSE_FEATURE,
@@ -267,6 +288,7 @@ enum {
     STATE_FREE_PATH_FEATURE,
     STATE_MAKE_PATH_FEATURE,
     CTRLPORT_REQUEST_FEATURE,
+    CTRLPORT_STATE_FEATURE,
     WORKER_FEATURE,
 #ifdef WITH_EXTERNAL_UI_SUPPORT
     UI_DATA_ACCESS,
@@ -277,7 +299,11 @@ enum {
 
 enum PostPonedEventType {
     POSTPONED_PARAM_SET,
+    POSTPONED_PARAM_STATE,
+    POSTPONED_AUDIO_MONITOR,
+    POSTPONED_CPU_MONITOR,
     POSTPONED_OUTPUT_MONITOR,
+    POSTPONED_MIDI_CONTROL_CHANGE,
     POSTPONED_MIDI_PROGRAM_CHANGE,
     POSTPONED_MIDI_MAP,
     POSTPONED_TRANSPORT,
@@ -300,11 +326,17 @@ enum UpdatePositionFlag {
 ************************************************************************************************************************
 */
 
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 typedef struct HMI_ADDRESSING_T hmi_addressing_t;
 #endif
 typedef struct PORT_T port_t;
 
+typedef struct AUDIO_MONITOR_T {
+    jack_port_t *port;
+    char *source_port_name;
+    float value;
+} audio_monitor_t;
+
 typedef struct CV_SOURCE_T {
     port_t *port;
     jack_port_t *jack_port;
@@ -334,7 +366,7 @@ typedef struct PORT_T {
     LilvScalePoints* scale_points;
     cv_source_t* cv_source;
     pthread_mutex_t cv_source_mutex;
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
     hmi_addressing_t* hmi_addressing;
 #endif
 } port_t;
@@ -406,6 +438,7 @@ typedef struct EFFECT_T {
     int32_t control_index; // control/event input
     int32_t enabled_index;
     int32_t freewheel_index;
+    int32_t reset_index;
     int32_t bpb_index;
     int32_t bpm_index;
     int32_t speed_index;
@@ -428,6 +461,13 @@ typedef struct EFFECT_T {
     jack_ringbuffer_t *events_out_buffer;
     char *events_in_buffer_helper;
 
+    bool jack_activated;
+    bool lv2_activated;
+
+    bool monitor_cpu;
+    bool monitor_cpu_reset;
+    float cpu_load;
+
     // previous transport state
     bool transport_rolling;
     uint32_t transport_frame;
@@ -475,6 +515,7 @@ typedef struct LILV_NODES_T {
     LilvNode *hmi_interface;
     LilvNode *input;
     LilvNode *integer;
+    LilvNode *is_live;
     LilvNode *license_interface;
     LilvNode *logarithmic;
     LilvNode *maximum;
@@ -486,6 +527,7 @@ typedef struct LILV_NODES_T {
     LilvNode *mod_default_custom;
     LilvNode *mod_maximum;
     LilvNode *mod_minimum;
+    LilvNode *noPreRun;
     LilvNode *options_interface;
     LilvNode *output;
     LilvNode *patch_readable;
@@ -495,6 +537,7 @@ typedef struct LILV_NODES_T {
     LilvNode *preset;
     LilvNode *rawMIDIClockAccess;
     LilvNode *rdfs_range;
+    LilvNode *reset;
     LilvNode *sample_rate;
     LilvNode *state_interface;
     LilvNode *state_load_default_state;
@@ -525,6 +568,7 @@ typedef struct URIDS_T {
     LV2_URID bufsz_minBlockLength;
     LV2_URID bufsz_nomimalBlockLength;
     LV2_URID bufsz_sequenceSize;
+    LV2_URID jack_client;
     LV2_URID log_Error;
     LV2_URID log_Note;
     LV2_URID log_Trace;
@@ -571,11 +615,18 @@ typedef struct ASSIGNMENT_T {
     bool supports_set_value;
 } assignment_t;
 
+#ifdef MOD_HMI_CONTROL_ENABLED
 typedef struct HMI_ADDRESSING_T {
     int actuator_id;
     uint8_t page;
     uint8_t subpage;
 } hmi_addressing_t;
+#endif
+
+typedef struct SYNC_SCHEDULED_PARAM_T {
+    port_t *port;
+    float value;
+} sync_scheduled_param_t;
 
 typedef struct POSTPONED_PARAMETER_EVENT_T {
     int effect_id;
@@ -583,6 +634,28 @@ typedef struct POSTPONED_PARAMETER_EVENT_T {
     float value;
 } postponed_parameter_event_t;
 
+typedef struct POSTPONED_PARAMETER_STATE_T {
+    int effect_id;
+    const char* symbol;
+    int state;
+} postponed_parameter_state_t;
+
+typedef struct POSTPONED_AUDIO_MONITOR_EVENT_T {
+    int index;
+    float value;
+} postponed_audio_monitor_event_t;
+
+typedef struct POSTPONED_CPU_MONITOR_EVENT_T {
+    int effect_id;
+    float cpu_load;
+} postponed_cpu_monitor_event_t;
+
+typedef struct POSTPONED_MIDI_CONTROL_CHANGE_EVENT_T {
+    int8_t channel;
+    int8_t control;
+    int16_t value;
+} postponed_midi_control_change_event_t;
+
 typedef struct POSTPONED_MIDI_PROGRAM_CHANGE_EVENT_T {
     int8_t program;
     int8_t channel;
@@ -625,6 +698,10 @@ typedef struct POSTPONED_EVENT_T {
     enum PostPonedEventType type;
     union {
         postponed_parameter_event_t parameter;
+        postponed_parameter_state_t state;
+        postponed_audio_monitor_event_t audio_monitor;
+        postponed_cpu_monitor_event_t cpu_monitor;
+        postponed_midi_control_change_event_t control_change;
         postponed_midi_program_change_event_t program_change;
         postponed_midi_map_event_t midi_map;
         postponed_transport_event_t transport;
@@ -668,6 +745,12 @@ typedef struct RAW_MIDI_PORT_ITEM {
     struct list_head siblings;
 } raw_midi_port_item;
 
+typedef struct CACHED_EFFECT_FLUSH_T {
+    effect_t *effect;
+    port_t **ports;
+    int num_ports;
+} cached_effect_flush_t;
+
 
 /*
 ************************************************************************************************************************
@@ -703,7 +786,7 @@ static pthread_mutex_t  g_rtsafe_mutex;
 static volatile int  g_postevents_running; // 0: stopped, 1: running, -1: stopped & about to close mod-host
 static volatile bool g_postevents_ready;
 static sem_t         g_postevents_semaphore;
-static pthread_t     g_postevents_thread;
+static ZixThread     g_postevents_thread;
 
 /* raw-midi-clock-access ports */
 static struct list_head g_raw_midi_port_list;
@@ -714,7 +797,7 @@ static jack_client_t *g_jack_global_client;
 static jack_nframes_t g_sample_rate, g_max_allowed_midi_delta;
 static float g_sample_rate_f;
 static const char **g_capture_ports, **g_playback_ports;
-static int32_t g_midi_buffer_size, g_block_length;
+static int32_t g_midi_buffer_size, g_block_length, g_block_time_us;
 static int32_t g_thread_policy, g_thread_priority;
 #ifdef MOD_IO_PROCESSING_ENABLED
 static jack_port_t *g_audio_in1_port;
@@ -722,16 +805,22 @@ static jack_port_t *g_audio_in2_port;
 static jack_port_t *g_audio_out1_port;
 static jack_port_t *g_audio_out2_port;
 #endif
+static audio_monitor_t *g_audio_monitors;
+static pthread_mutex_t g_audio_monitor_mutex;
+static int g_audio_monitor_count;
 static jack_port_t *g_midi_in_port;
 static jack_position_t g_jack_pos;
 static bool g_jack_rolling;
+static uint32_t g_jack_xruns;
 static volatile double g_transport_bpb;
 static volatile double g_transport_bpm;
 static volatile bool g_transport_reset;
 static volatile enum TransportSyncMode g_transport_sync_mode;
 static bool g_aggregated_midi_enabled;
-static bool g_processing_enabled;
 static bool g_verbose_debug;
+static bool g_cpu_load_enabled;
+static volatile bool g_processing_enabled;
+static volatile bool g_cpu_load_trigger;
 
 // Wall clock time since program startup
 static uint64_t g_monotonic_frame_count = 0;
@@ -748,24 +837,37 @@ static char *g_lv2_scratch_dir;
 static Symap* g_symap;
 static lilv_nodes_t g_lilv_nodes;
 static urids_t g_urids;
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 static LV2_HMI_WidgetControl g_hmi_wc;
 #endif
 static MOD_License_Feature g_license;
 static LV2_Atom_Forge g_lv2_atom_forge;
 static LV2_Log_Log g_lv2_log;
-static LV2_Options_Option g_options[8];
+static LV2_Options_Option g_options[9];
 static LV2_State_Free_Path g_state_freePath;
-static LV2_URI_Map_Feature g_uri_map;
 static LV2_URID_Map g_urid_map;
 static LV2_URID_Unmap g_urid_unmap;
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+static LV2_URI_Map_Feature g_uri_map;
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#pragma GCC diagnostic pop
+#endif
+
 static LV2_Feature g_buf_size_features[3] = {
     { LV2_BUF_SIZE__powerOf2BlockLength, NULL },
     { LV2_BUF_SIZE__fixedBlockLength, NULL },
     { LV2_BUF_SIZE__boundedBlockLength, NULL }
 };
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 static LV2_Feature g_hmi_wc_feature = { LV2_HMI__WidgetControl, &g_hmi_wc };
 #endif
 static LV2_Feature g_license_feature = { MOD_LICENSE__feature, &g_license };
@@ -779,32 +881,40 @@ static LV2_Feature g_urid_unmap_feature = { LV2_URID__unmap, &g_urid_unmap };
 /* MIDI Learn */
 static pthread_mutex_t g_midi_learning_mutex;
 
-/* MIDI program monitoring */
+/* MIDI control and program monitoring */
+static bool g_monitored_midi_controls[16];
 static bool g_monitored_midi_programs[16];
 
+/* Postponed port updates */
+static sync_scheduled_param_t g_sync_scheduled_params[MAX_SYNC_SCHEDULED_PARAMS];
+static pthread_mutex_t g_sync_scheduled_params_mutex;
+static unsigned int g_sync_scheduled_param_count;
+
 #ifdef HAVE_HYLIA
 static hylia_t* g_hylia_instance;
 static hylia_time_info_t g_hylia_timeinfo;
 #endif
 
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 /* HMI integration */
 static int g_hmi_shmfd;
 static sys_serial_shm_data* g_hmi_data;
-static pthread_t g_hmi_client_thread;
+static ZixThread g_hmi_client_thread;
 static pthread_mutex_t g_hmi_mutex;
 static hmi_addressing_t g_hmi_addressings[MAX_HMI_ADDRESSINGS];
+#endif
 
 /* internal processing */
+#ifdef MOD_HMI_CONTROL_ENABLED
 static int g_compressor_mode = 0;
 static int g_compressor_release = 100;
+#endif
 #ifdef MOD_IO_PROCESSING_ENABLED
 static int g_noisegate_channel = 0;
 static int g_noisegate_decay = 10;
 static int g_noisegate_threshold = -60;
 static gate_t g_noisegate;
 #endif
-#endif
 
 static const char* const g_bypass_port_symbol = BYPASS_PORT_SYMBOL;
 static const char* const g_presets_port_symbol = PRESETS_PORT_SYMBOL;
@@ -824,11 +934,13 @@ static void AllocatePortBuffers(effect_t* effect, int in_size, int out_size);
 static int BufferSize(jack_nframes_t nframes, void* data);
 static void FreeWheelMode(int starting, void* data);
 static void PortRegistration(jack_port_id_t port_id, int reg, void* data);
+static int XRun(void* data);
 static void RunPostPonedEvents(int ignored_effect_id);
 static void* PostPonedEventsThread(void* arg);
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 static void* HMIClientThread(void* arg);
 #endif
+static void PreRunPlugin(effect_t *effect);
 static int ProcessPlugin(jack_nframes_t nframes, void *arg);
 static bool SetPortValue(port_t *port, float value, int effect_id, bool is_bypass, bool from_ui);
 static float UpdateValueFromMidi(midi_cc_t* mcc, uint16_t mvalue, bool highres);
@@ -844,12 +956,12 @@ static property_t *FindEffectPropertyByURI(effect_t *effect, const char *uri);
 static port_t *FindEffectInputPortBySymbol(effect_t *effect, const char *control_symbol);
 static port_t *FindEffectOutputPortBySymbol(effect_t *effect, const char *control_symbol);
 static const void *GetPortValueForState(const char* symbol, void* user_data, uint32_t* size, uint32_t* type);
-static int LoadPresets(effect_t *effect);
+static void LoadPresets(effect_t *effect);
 static void FreeFeatures(effect_t *effect);
 static void FreePluginString(void* handle, char *str);
 static void ConnectToAllHardwareMIDIPorts(void);
 static void ConnectToMIDIThroughPorts(void);
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 static void HMIWidgetsSetLedWithBlink(LV2_HMI_WidgetControl_Handle handle,
                                       LV2_HMI_Addressing addressing,
                                       LV2_HMI_LED_Colour led_color,
@@ -881,7 +993,11 @@ static char *GetLicenseFile(MOD_License_Handle handle, const char *license_uri);
 static int LogPrintf(LV2_Log_Handle handle, LV2_URID type, const char *fmt, ...);
 static int LogVPrintf(LV2_Log_Handle handle, LV2_URID type, const char *fmt, va_list ap);
 static LV2_ControlInputPort_Change_Status RequestControlPortChange(LV2_ControlInputPort_Change_Request_Handle handle,
-                                                                   uint32_t index, float value);
+                                                                   uint32_t index,
+                                                                   float value);
+static LV2_Control_Port_State_Update_Status UpdateControlPortState(LV2_Control_Port_State_Update_Handle handle,
+                                                                   uint32_t index,
+                                                                   LV2_Control_Port_State state);
 static char* MakePluginStatePathFromSratchDir(LV2_State_Make_Path_Handle handle, const char *path);
 static char* MakePluginStatePathDuringLoadSave(LV2_State_Make_Path_Handle handle, const char *path);
 #ifdef HAVE_CONTROLCHAIN
@@ -900,6 +1016,9 @@ static void ExternalControllerWriteFunction(LV2UI_Controller controller,
                                             const void *buffer);
 #endif
 
+static void* effects_activate_thread(void* arg);
+static void* effects_deactivate_thread(void* arg);
+
 /*
 ************************************************************************************************************************
 *           LOCAL CONFIGURATION ERRORS
@@ -916,7 +1035,7 @@ static void ExternalControllerWriteFunction(LV2UI_Controller controller,
 
 #if defined(__APPLE__) || defined(_WIN32)
 // FIXME missing on macOS and Windows
-static char* strchrnul(const char *s, int c)
+static char* _strchrnul(const char *s, int c)
 {
     char *r = strchr(s, c);
 
@@ -925,11 +1044,12 @@ static char* strchrnul(const char *s, int c)
 
     return r;
 }
+#define strchrnul _strchrnul
 #endif
 
 #ifdef _WIN32
 // missing on Windows
-static char* realpath(const char *name, char *resolved)
+static char* _realpath(const char *name, char *resolved)
 {
     if (name == NULL)
         return NULL;
@@ -947,6 +1067,7 @@ static char* realpath(const char *name, char *resolved)
 
     return _fullpath(retname, name, PATH_MAX);
 }
+#define realpath _realpath
 #endif
 
 static void InstanceDelete(int effect_id)
@@ -990,6 +1111,7 @@ static void AllocatePortBuffers(effect_t* effect, int in_size, int out_size)
 static int BufferSize(jack_nframes_t nframes, void* data)
 {
     g_block_length = nframes;
+    g_block_time_us = nframes * 1e6 / g_sample_rate;
     g_midi_buffer_size = jack_port_type_get_buffer_size(g_jack_global_client, JACK_DEFAULT_MIDI_TYPE);
 
     if (data)
@@ -1040,7 +1162,13 @@ static int BufferSize(jack_nframes_t nframes, void* data)
             options[4].type = 0;
             options[4].value = NULL;
 
+            if (effect->lv2_activated)
+                lilv_instance_deactivate(effect->lilv_instance);
+
             effect->options_interface->set(effect->lilv_instance->lv2_handle, options);
+
+            if (effect->lv2_activated)
+                lilv_instance_activate(effect->lilv_instance);
         }
     }
 #ifdef HAVE_HYLIA
@@ -1095,6 +1223,15 @@ static void PortRegistration(jack_port_id_t port_id, int reg, void* data)
     UNUSED_PARAM(data);
 }
 
+static int XRun(void *data)
+{
+    ++g_jack_xruns;
+
+    return 0;
+
+    UNUSED_PARAM(data);
+}
+
 static bool ShouldIgnorePostPonedEffectEvent(int effect_id, postponed_cached_effect_events* cached_events)
 {
     if (effect_id == cached_events->last_effect_id)
@@ -1130,15 +1267,16 @@ static bool ShouldIgnorePostPonedEffectEvent(int effect_id, postponed_cached_eff
     return false;
 }
 
-static bool ShouldIgnorePostPonedSymbolEvent(postponed_parameter_event_t* ev,
+static bool ShouldIgnorePostPonedSymbolEvent(int effect_id,
+                                             const char* symbol,
                                              postponed_cached_symbol_events* cached_events)
 {
     // symbol must not be null
-    if (ev->symbol == NULL)
+    if (symbol == NULL)
         return false;
 
-    if (ev->effect_id == cached_events->last_effect_id &&
-        strncmp(ev->symbol, cached_events->last_symbol, MAX_CHAR_BUF_SIZE) == 0)
+    if (effect_id == cached_events->last_effect_id &&
+        strncmp(symbol, cached_events->last_symbol, MAX_CHAR_BUF_SIZE) == 0)
     {
         // already received this event, like just now
         return true;
@@ -1151,8 +1289,8 @@ static bool ShouldIgnorePostPonedSymbolEvent(postponed_parameter_event_t* ev,
     {
         postponed_cached_symbol_list_data* const psymbol = list_entry(it, postponed_cached_symbol_list_data, siblings);
 
-        if (ev->effect_id == psymbol->effect_id &&
-            strncmp(ev->symbol, psymbol->symbol, MAX_CHAR_BUF_SIZE) == 0)
+        if (effect_id == psymbol->effect_id &&
+            strncmp(symbol, psymbol->symbol, MAX_CHAR_BUF_SIZE) == 0)
         {
             // haha! found you little bastard!
             return true;
@@ -1165,8 +1303,8 @@ static bool ShouldIgnorePostPonedSymbolEvent(postponed_parameter_event_t* ev,
 
     if (psymbol)
     {
-        psymbol->effect_id = ev->effect_id;
-        strncpy(psymbol->symbol, ev->symbol, MAX_CHAR_BUF_SIZE);
+        psymbol->effect_id = effect_id;
+        strncpy(psymbol->symbol, symbol, MAX_CHAR_BUF_SIZE);
         psymbol->symbol[MAX_CHAR_BUF_SIZE] = '\0';
         list_add_tail(&psymbol->siblings, &cached_events->symbols.siblings);
     }
@@ -1199,7 +1337,14 @@ static void RunPostPonedEvents(int ignored_effect_id)
     list_splice_init(&g_rtsafe_list, &queue);
     pthread_mutex_unlock(&g_rtsafe_mutex);
 
-    if (list_empty(&queue))
+    // fetch this value only once per run
+    const bool cpu_load_trigger = g_jack_global_client != NULL && g_cpu_load_trigger;
+
+    if (cpu_load_trigger)
+    {
+        g_cpu_load_trigger = false;
+    }
+    else if (list_empty(&queue))
     {
         // nothing to do
         if (g_verbose_debug) {
@@ -1217,22 +1362,30 @@ static void RunPostPonedEvents(int ignored_effect_id)
     // cached data, to make sure we only handle similar events once
     bool got_midi_program = false;
     bool got_transport = false;
-    postponed_cached_effect_events cached_process_out_buf;
-    postponed_cached_symbol_events cached_param_set, cached_output_mon;
+    postponed_cached_effect_events cached_audio_monitor, cached_cpu_monitor, cached_process_out_buf;
+    postponed_cached_symbol_events cached_param_set, cached_param_state, cached_output_mon;
 
+    cached_audio_monitor.last_effect_id = -1;
+    cached_cpu_monitor.last_effect_id = -1;
     cached_process_out_buf.last_effect_id = -1;
     cached_param_set.last_effect_id = -1;
-    cached_output_mon.last_effect_id = -1;
     cached_param_set.last_symbol[0] = '\0';
     cached_param_set.last_symbol[MAX_CHAR_BUF_SIZE] = '\0';
+    cached_param_state.last_effect_id = -1;
+    cached_param_state.last_symbol[0] = '\0';
+    cached_param_state.last_symbol[MAX_CHAR_BUF_SIZE] = '\0';
+    cached_output_mon.last_effect_id = -1;
     cached_output_mon.last_symbol[0] = '\0';
     cached_output_mon.last_symbol[MAX_CHAR_BUF_SIZE] = '\0';
+    INIT_LIST_HEAD(&cached_audio_monitor.effects.siblings);
+    INIT_LIST_HEAD(&cached_cpu_monitor.effects.siblings);
     INIT_LIST_HEAD(&cached_process_out_buf.effects.siblings);
     INIT_LIST_HEAD(&cached_param_set.symbols.siblings);
+    INIT_LIST_HEAD(&cached_param_state.symbols.siblings);
     INIT_LIST_HEAD(&cached_output_mon.symbols.siblings);
 
     // if all we have are jack_midi_connect requests, do not send feedback to server
-    bool got_only_jack_midi_requests = true;
+    bool got_only_jack_midi_requests = !cpu_load_trigger;
 
     if (g_verbose_debug) {
         puts("DEBUG: RunPostPonedEvents() Before the queue iteration");
@@ -1262,7 +1415,9 @@ static void RunPostPonedEvents(int ignored_effect_id)
         case POSTPONED_PARAM_SET:
             if (eventptr->event.parameter.effect_id == ignored_effect_id)
                 continue;
-            if (ShouldIgnorePostPonedSymbolEvent(&eventptr->event.parameter, &cached_param_set))
+            if (ShouldIgnorePostPonedSymbolEvent(eventptr->event.parameter.effect_id,
+                                                 eventptr->event.parameter.symbol,
+                                                 &cached_param_set))
                 continue;
 
             snprintf(buf, FEEDBACK_BUF_SIZE, "param_set %i %s %f", eventptr->event.parameter.effect_id,
@@ -1275,10 +1430,61 @@ static void RunPostPonedEvents(int ignored_effect_id)
             strncpy(cached_param_set.last_symbol, eventptr->event.parameter.symbol, MAX_CHAR_BUF_SIZE);
             break;
 
+        case POSTPONED_PARAM_STATE:
+            if (eventptr->event.state.effect_id == ignored_effect_id)
+                continue;
+            if (ShouldIgnorePostPonedSymbolEvent(eventptr->event.state.effect_id,
+                                                 eventptr->event.state.symbol,
+                                                 &cached_param_state))
+                continue;
+
+            snprintf(buf, FEEDBACK_BUF_SIZE, "param_state %i %s %i", eventptr->event.state.effect_id,
+                                                                     eventptr->event.state.symbol,
+                                                                     eventptr->event.state.state);
+            socket_send_feedback_debug(buf);
+
+            // save for fast checkup next time
+            cached_param_state.last_effect_id = eventptr->event.state.effect_id;
+            strncpy(cached_param_state.last_symbol, eventptr->event.state.symbol, MAX_CHAR_BUF_SIZE);
+            break;
+
+        case POSTPONED_AUDIO_MONITOR:
+            if (ShouldIgnorePostPonedEffectEvent(eventptr->event.audio_monitor.index, &cached_audio_monitor))
+                continue;
+
+            pthread_mutex_lock(&g_audio_monitor_mutex);
+            if (eventptr->event.audio_monitor.index < g_audio_monitor_count)
+                g_audio_monitors[eventptr->event.audio_monitor.index].value = 0.f;
+            pthread_mutex_unlock(&g_audio_monitor_mutex);
+
+            snprintf(buf, FEEDBACK_BUF_SIZE, "audio_monitor %i %f", eventptr->event.audio_monitor.index,
+                                                                    eventptr->event.audio_monitor.value);
+            socket_send_feedback_debug(buf);
+
+            // save for fast checkup next time
+            cached_audio_monitor.last_effect_id = eventptr->event.audio_monitor.index;
+            break;
+
+        case POSTPONED_CPU_MONITOR:
+            if (eventptr->event.cpu_monitor.effect_id == ignored_effect_id)
+                continue;
+            if (ShouldIgnorePostPonedEffectEvent(eventptr->event.cpu_monitor.effect_id, &cached_cpu_monitor))
+                continue;
+
+            snprintf(buf, FEEDBACK_BUF_SIZE, "cpu_monitor %i %f", eventptr->event.cpu_monitor.effect_id,
+                                                                  eventptr->event.cpu_monitor.cpu_load);
+            socket_send_feedback_debug(buf);
+
+            // save for fast checkup next time
+            cached_cpu_monitor.last_effect_id = eventptr->event.cpu_monitor.effect_id;
+            break;
+
         case POSTPONED_OUTPUT_MONITOR:
             if (eventptr->event.parameter.effect_id == ignored_effect_id)
                 continue;
-            if (ShouldIgnorePostPonedSymbolEvent(&eventptr->event.parameter, &cached_output_mon))
+            if (ShouldIgnorePostPonedSymbolEvent(eventptr->event.parameter.effect_id,
+                                                 eventptr->event.parameter.symbol,
+                                                 &cached_output_mon))
                 continue;
 
             snprintf(buf, FEEDBACK_BUF_SIZE, "output_set %i %s %f", eventptr->event.parameter.effect_id,
@@ -1304,6 +1510,14 @@ static void RunPostPonedEvents(int ignored_effect_id)
             socket_send_feedback_debug(buf);
             break;
 
+        case POSTPONED_MIDI_CONTROL_CHANGE:
+            snprintf(buf, FEEDBACK_BUF_SIZE, "midi_control_change %i %i %i",
+                     eventptr->event.control_change.channel,
+                     eventptr->event.control_change.control,
+                     eventptr->event.control_change.value);
+            socket_send_feedback_debug(buf);
+            break;
+
         case POSTPONED_MIDI_PROGRAM_CHANGE:
             if (got_midi_program)
             {
@@ -1535,6 +1749,18 @@ static void RunPostPonedEvents(int ignored_effect_id)
         }
     }
 
+    if (cpu_load_trigger)
+    {
+        snprintf(buf, FEEDBACK_BUF_SIZE, "cpu_load %f %f %d", jack_cpu_load(g_jack_global_client),
+                                                             #ifdef HAVE_JACK2_1_9_23
+                                                              jack_max_cpu_load(g_jack_global_client),
+                                                             #else
+                                                              0.f,
+                                                             #endif
+                                                              g_jack_xruns);
+        socket_send_feedback_debug(buf);
+    }
+
     if (g_verbose_debug) {
         puts("DEBUG: RunPostPonedEvents() After the queue iteration");
         fflush(stdout);
@@ -1544,6 +1770,16 @@ static void RunPostPonedEvents(int ignored_effect_id)
     postponed_cached_effect_list_data *peffect;
     postponed_cached_symbol_list_data *psymbol;
 
+    list_for_each_safe(it, it2, &cached_audio_monitor.effects.siblings)
+    {
+        peffect = list_entry(it, postponed_cached_effect_list_data, siblings);
+        free(peffect);
+    }
+    list_for_each_safe(it, it2, &cached_cpu_monitor.effects.siblings)
+    {
+        peffect = list_entry(it, postponed_cached_effect_list_data, siblings);
+        free(peffect);
+    }
     list_for_each_safe(it, it2, &cached_process_out_buf.effects.siblings)
     {
         peffect = list_entry(it, postponed_cached_effect_list_data, siblings);
@@ -1554,6 +1790,11 @@ static void RunPostPonedEvents(int ignored_effect_id)
         psymbol = list_entry(it, postponed_cached_symbol_list_data, siblings);
         free(psymbol);
     }
+    list_for_each_safe(it, it2, &cached_param_state.symbols.siblings)
+    {
+        psymbol = list_entry(it, postponed_cached_symbol_list_data, siblings);
+        free(psymbol);
+    }
     list_for_each_safe(it, it2, &cached_output_mon.symbols.siblings)
     {
         psymbol = list_entry(it, postponed_cached_symbol_list_data, siblings);
@@ -1613,6 +1854,14 @@ static void RunPostPonedEvents(int ignored_effect_id)
 
 static void* PostPonedEventsThread(void* arg)
 {
+#if defined(_MOD_DEVICE_RK358x)
+    setpriority(PRIO_PROCESS, gettid(), -18);
+#elif defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+    const pid_t tid = syscall(SYS_gettid);
+    if (tid > 0)
+        setpriority(PRIO_PROCESS, tid, -18);
+#endif
+
     while (g_postevents_running == 1)
     {
         if (sem_timedwait_secs(&g_postevents_semaphore, 1) != 0)
@@ -1638,7 +1887,7 @@ static void* PostPonedEventsThread(void* arg)
     UNUSED_PARAM(arg);
 }
 
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 static void* HMIClientThread(void* arg)
 {
     sys_serial_shm_data_channel* const data = (sys_serial_shm_data_channel*)arg;
@@ -1692,7 +1941,7 @@ static void* HMIClientThread(void* arg)
                 break;
 #endif
             case sys_serial_event_type_pedalboard_gain:
-                monitor_client_setup_volume(clampf(atof(msg), -30.0f, 20.0f));
+                monitor_client_setup_volume(clampf(atof(msg), MOD_MONITOR_VOLUME_MUTE, 20.0f));
                 break;
             default:
                 break;
@@ -1704,6 +1953,122 @@ static void* HMIClientThread(void* arg)
 }
 #endif
 
+static void PreRunPlugin(effect_t *effect)
+{
+    if (effect->hints & HINT_STATE_UNSAFE)
+        pthread_mutex_lock(&effect->state_restore_mutex);
+
+    /* common variables */
+    port_t *port;
+    unsigned int i;
+    float value;
+    bool needs_post = false;
+
+    if (effect->hints & HINT_TRANSPORT)
+    {
+        effect->transport_rolling = g_jack_rolling;
+        // effect->transport_frame = pos.frame;
+        effect->transport_bpb = g_transport_bpb;
+        effect->transport_bpm = g_transport_bpm;
+    }
+    if (effect->bpb_index >= 0)
+    {
+        *(effect->ports[effect->bpb_index]->buffer) = g_transport_bpb;
+    }
+    if (effect->bpm_index >= 0)
+    {
+        *(effect->ports[effect->bpm_index]->buffer) = g_transport_bpm;
+    }
+    if (effect->speed_index >= 0)
+    {
+        *(effect->ports[effect->speed_index]->buffer) = g_jack_rolling ? 1.0f : 0.0f;
+    }
+
+    /* Prepare midi/event ports */
+    for (i = 0; i < effect->input_event_ports_count; i++)
+    {
+        port = effect->input_event_ports[i];
+        lv2_evbuf_reset(port->evbuf, true);
+    }
+
+    for (i = 0; i < effect->output_event_ports_count; i++)
+        lv2_evbuf_reset(effect->output_event_ports[i]->evbuf, false);
+
+    /* Bypass */
+    if (effect->bypass > 0.5f && effect->enabled_index < 0)
+    {
+        lilv_instance_run(effect->lilv_instance, 0);
+    }
+    /* Effect process */
+    else
+    {
+        /* Run the effect */
+        lilv_instance_run(effect->lilv_instance, 0);
+
+        /* Notify the plugin the run() cycle is finished */
+        if (effect->worker.iface)
+        {
+            /* Process any replies from the worker. */
+            worker_emit_responses(&effect->worker);
+            if (effect->worker.iface->end_run)
+            {
+                effect->worker.iface->end_run(effect->lilv_instance->lv2_handle);
+            }
+        }
+    }
+
+    if (effect->hints & HINT_TRIGGERS)
+    {
+        for (i = 0; i < effect->input_control_ports_count; i++)
+        {
+            port = effect->input_control_ports[i];
+
+            if ((port->hints & HINT_TRIGGER) && floats_differ_enough(port->prev_value, port->def_value))
+                port->prev_value = *(port->buffer) = port->def_value;
+        }
+    }
+
+    if (effect->hints & HINT_OUTPUT_MONITORS)
+    {
+        for (i = 0; i < effect->output_control_ports_count; i++)
+        {
+            port = effect->output_control_ports[i];
+
+            if ((port->hints & HINT_MONITORED) == 0)
+                continue;
+
+            value = *(port->buffer);
+
+            if (! floats_differ_enough(port->prev_value, value))
+                continue;
+
+            postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+            if (posteventptr == NULL)
+                continue;
+
+            port->prev_value = value;
+
+            posteventptr->event.type = POSTPONED_OUTPUT_MONITOR;
+            posteventptr->event.parameter.effect_id = effect->instance;
+            posteventptr->event.parameter.symbol    = port->symbol;
+            posteventptr->event.parameter.value     = value;
+
+            pthread_mutex_lock(&g_rtsafe_mutex);
+            list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+            pthread_mutex_unlock(&g_rtsafe_mutex);
+
+            needs_post = true;
+        }
+    }
+
+    if (effect->hints & HINT_STATE_UNSAFE)
+        pthread_mutex_unlock(&effect->state_restore_mutex);
+
+    if (needs_post)
+        sem_post(&g_postevents_semaphore);
+}
+
 static int ProcessPlugin(jack_nframes_t nframes, void *arg)
 {
     effect_t *effect;
@@ -1713,8 +2078,9 @@ static int ProcessPlugin(jack_nframes_t nframes, void *arg)
     if (arg == NULL) return 0;
     effect = arg;
 
-    if (!g_processing_enabled || (
-        (effect->hints & HINT_STATE_UNSAFE) && pthread_mutex_trylock(&effect->state_restore_mutex) != 0))
+    if ((effect->hints & HINT_IS_LIVE) == 0 &&
+        (!g_processing_enabled || (
+         (effect->hints & HINT_STATE_UNSAFE) && pthread_mutex_trylock(&effect->state_restore_mutex) != 0)))
     {
         for (i = 0; i < effect->output_audio_ports_count; i++)
         {
@@ -1736,10 +2102,15 @@ static int ProcessPlugin(jack_nframes_t nframes, void *arg)
     }
 
     /* common variables */
+    const bool monitor_cpu = effect->monitor_cpu;
     bool needs_post = false;
     const float *buffer_in;
     float *buffer_out;
     float value;
+    uint64_t time_start;
+
+    if (monitor_cpu)
+        time_start = time_ns_get();
 
     /* transport */
     uint8_t stack_buf[MAX_CHAR_BUF_SIZE+1];
@@ -2281,6 +2652,37 @@ static int ProcessPlugin(jack_nframes_t nframes, void *arg)
     if (effect->hints & HINT_STATE_UNSAFE)
         pthread_mutex_unlock(&effect->state_restore_mutex);
 
+    if (monitor_cpu)
+    {
+        if (effect->monitor_cpu_reset)
+        {
+            effect->cpu_load = 0.f;
+            effect->monitor_cpu_reset = false;
+        }
+
+        float cpu_load = ((int32_t)(time_ns_get() - time_start) / g_block_time_us) * 0.001f;
+
+        if (cpu_load > effect->cpu_load)
+        {
+            effect->cpu_load = cpu_load;
+
+            postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+            if (posteventptr != NULL)
+            {
+                posteventptr->event.type = POSTPONED_CPU_MONITOR;
+                posteventptr->event.cpu_monitor.effect_id = effect->instance;
+                posteventptr->event.cpu_monitor.cpu_load  = cpu_load;
+
+                pthread_mutex_lock(&g_rtsafe_mutex);
+                list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+                pthread_mutex_unlock(&g_rtsafe_mutex);
+
+                needs_post = true;
+            }
+        }
+    }
+
     if (needs_post)
         sem_post(&g_postevents_semaphore);
 
@@ -2501,7 +2903,7 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
 {
     jack_midi_event_t event;
     uint8_t channel, controller;
-    uint8_t status_nibble, channel_nibble;
+    uint8_t status_nibble;
     uint16_t mvalue;
     float value;
     double dvalue;
@@ -2567,9 +2969,9 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
                             // set a sane low limit
                             if (dvalue <= 20.0)
                                 g_transport_bpm = 20;
-                            // >280 BPM over MIDI is unreasonable
-                            else if (dvalue >= 280.0)
-                                g_transport_bpm = 280.0;
+                            // >300 BPM over MIDI is unreasonable
+                            else if (dvalue >= 300.0)
+                                g_transport_bpm = 300.0;
                             // we are good!
                             else
                                 g_transport_bpm = dvalue;
@@ -2609,10 +3011,14 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
         // Handle MIDI program change
         if (status_nibble == 0xC0)
         {
-            channel_nibble = (event.buffer[0] & 0x0F);
+            channel = (event.buffer[0] & 0x0F);
 
-            if (g_monitored_midi_programs[channel_nibble] && event.size == 2)
+            if (g_monitored_midi_programs[channel] && event.size == 2)
             {
+#ifdef _DARKGLASS_PABLITO
+                if (event.buffer[1] == 0 || event.buffer[1] == 127)
+                    continue;
+#endif
                 // Append to the queue
                 postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
 
@@ -2620,7 +3026,7 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
                   {
                       posteventptr->event.type = POSTPONED_MIDI_PROGRAM_CHANGE;
                       posteventptr->event.program_change.program = event.buffer[1];
-                      posteventptr->event.program_change.channel = channel_nibble;
+                      posteventptr->event.program_change.channel = channel;
 
                       pthread_mutex_lock(&g_rtsafe_mutex);
                       list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
@@ -2645,17 +3051,91 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
             controller = event.buffer[1];
             mvalue     = event.buffer[2];
             highres    = false;
-        }
-        else if (status_nibble == 0xE0)
-        {
-            controller = MIDI_PITCHBEND_AS_CC;
-            mvalue     = (event.buffer[2] << 7) | event.buffer[1];
-            highres    = true;
-        }
-        else
-        {
-            continue;
-        }
+#ifdef _DARKGLASS_PABLITO
+            channel    = (event.buffer[0] & 0x0F);
+            switch (controller)
+            {
+            // these can be assigned to parameters, handle them first
+            case 17 ... 32:
+            case 89:
+                if (! g_monitored_midi_programs[channel])
+                    continue;
+
+                for (int j = 0; j < MAX_MIDI_CC_ASSIGN; j++)
+                {
+                    if (g_midi_cc_list[j].effect_id == ASSIGNMENT_NULL)
+                        break;
+                    if (g_midi_cc_list[j].effect_id == ASSIGNMENT_UNUSED)
+                        continue;
+
+                    if (g_midi_cc_list[j].controller == controller)
+                    {
+                        handled = true;
+                        value = UpdateValueFromMidi(&g_midi_cc_list[j], mvalue, highres);
+
+                        postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+                        if (posteventptr)
+                        {
+                            posteventptr->event.type = POSTPONED_PARAM_SET;
+                            posteventptr->event.parameter.effect_id = g_midi_cc_list[j].effect_id;
+                            posteventptr->event.parameter.symbol    = g_midi_cc_list[j].symbol;
+                            posteventptr->event.parameter.value     = value;
+
+                            pthread_mutex_lock(&g_rtsafe_mutex);
+                            list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+                            pthread_mutex_unlock(&g_rtsafe_mutex);
+
+                            needs_post = true;
+                        }
+
+                        break;
+                    }
+                }
+
+                if (needs_post)
+                    continue;
+
+            // fall-through
+            // if the special parameter CCs are not handled, report up as regular MIDI CC
+            case 0:
+            case 7:
+            case 14 ... 16:
+            case 85 ... 87:
+            case 102 ... 119:
+                if (g_monitored_midi_programs[channel])
+                {
+                    postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+                    if (posteventptr)
+                    {
+                        posteventptr->event.type = POSTPONED_MIDI_CONTROL_CHANGE;
+                        posteventptr->event.control_change.channel = channel;
+                        posteventptr->event.control_change.control = controller;
+                        posteventptr->event.control_change.value = mvalue;
+
+                        pthread_mutex_lock(&g_rtsafe_mutex);
+                        list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+                        pthread_mutex_unlock(&g_rtsafe_mutex);
+
+                        needs_post = true;
+                    }
+                }
+                continue;
+            }
+#else
+        }
+        else if (status_nibble == 0xE0)
+        {
+            controller = MIDI_PITCHBEND_AS_CC;
+            mvalue     = (event.buffer[2] << 7) | event.buffer[1];
+            highres    = true;
+#endif
+        }
+        else
+        {
+            continue;
+        }
 
         handled = false;
         channel = (event.buffer[0] & 0x0F);
@@ -2667,9 +3147,16 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
             if (g_midi_cc_list[j].effect_id == ASSIGNMENT_UNUSED)
                 continue;
 
+#ifdef _DARKGLASS_PABLITO
+            if (! g_monitored_midi_programs[channel])
+                continue;
+#else
+            if (g_midi_cc_list[j].channel != channel)
+                continue;
+#endif
+
             // TODO: avoid race condition against effects_midi_unmap
-            if (g_midi_cc_list[j].channel    == channel &&
-                g_midi_cc_list[j].controller == controller)
+            if (g_midi_cc_list[j].controller == controller)
             {
                 handled = true;
                 value = UpdateValueFromMidi(&g_midi_cc_list[j], mvalue, highres);
@@ -2737,6 +3224,24 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
                     list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
                     pthread_mutex_unlock(&g_rtsafe_mutex);
 
+                    needs_post = true;
+                }
+            }
+            else if (g_monitored_midi_programs[channel])
+            {
+                postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+                if (posteventptr)
+                {
+                    posteventptr->event.type = POSTPONED_MIDI_CONTROL_CHANGE;
+                    posteventptr->event.control_change.channel = channel;
+                    posteventptr->event.control_change.control = controller;
+                    posteventptr->event.control_change.value = mvalue;
+
+                    pthread_mutex_lock(&g_rtsafe_mutex);
+                    list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+                    pthread_mutex_unlock(&g_rtsafe_mutex);
+
                     needs_post = true;
                 }
             }
@@ -2781,9 +3286,64 @@ static int ProcessGlobalClient(jack_nframes_t nframes, void *arg)
     }
 #endif
 
+    // Handle audio monitors
+    if (pthread_mutex_trylock(&g_audio_monitor_mutex) == 0)
+    {
+        float *monitorbuf;
+        float absvalue, oldvalue;
+
+        for (int i = 0; i < g_audio_monitor_count; ++i)
+        {
+            monitorbuf = (float*)jack_port_get_buffer(g_audio_monitors[i].port, nframes);
+            oldvalue = value = g_audio_monitors[i].value;
+
+            for (jack_nframes_t i = 0 ; i < nframes; i++)
+            {
+                absvalue = fabsf(monitorbuf[i]);
+
+                if (absvalue > value)
+                    value = absvalue;
+            }
+
+            if (oldvalue < value)
+            {
+                g_audio_monitors[i].value = value;
+
+                postponed_event_list_data* const posteventptr = rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+                if (posteventptr)
+                {
+                    posteventptr->event.type = POSTPONED_AUDIO_MONITOR;
+                    posteventptr->event.audio_monitor.index = i;
+                    posteventptr->event.audio_monitor.value = value;
+
+                    pthread_mutex_lock(&g_rtsafe_mutex);
+                    list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+                    pthread_mutex_unlock(&g_rtsafe_mutex);
+
+                    needs_post = true;
+                }
+            }
+        }
+
+        pthread_mutex_unlock(&g_audio_monitor_mutex);
+    }
+
     if (UpdateGlobalJackPosition(pos_flag, false))
         needs_post = true;
 
+    if (g_cpu_load_enabled)
+    {
+        const uint32_t cpu_update_rate = g_sample_rate / 2;
+        const uint32_t frame_check = g_monotonic_frame_count % cpu_update_rate;
+
+        if (frame_check + nframes >= cpu_update_rate)
+        {
+            g_cpu_load_trigger = true;
+            needs_post = true;
+        }
+    }
+
     if (needs_post)
         sem_post(&g_postevents_semaphore);
 
@@ -2960,6 +3520,16 @@ static void GetFeatures(effect_t *effect)
     ctrlportReqChange_feature->URI = LV2_CONTROL_INPUT_PORT_CHANGE_REQUEST_URI;
     ctrlportReqChange_feature->data = ctrlportReqChange;
 
+    /* Control Port state update feature, includes custom pointer */
+    LV2_Control_Port_State_Update *ctrlportStateUpdate
+        = (LV2_Control_Port_State_Update*) malloc(sizeof(LV2_Control_Port_State_Update));
+    ctrlportStateUpdate->handle = effect;
+    ctrlportStateUpdate->update_state = UpdateControlPortState;
+
+    LV2_Feature *ctrlportStateUpdate_feature = (LV2_Feature*) malloc(sizeof(LV2_Feature));
+    ctrlportStateUpdate_feature->URI = LV2_CONTROL_PORT_STATE_UPDATE_URI;
+    ctrlportStateUpdate_feature->data = ctrlportStateUpdate;
+
     /* Worker Feature, must be last as it can be null */
     LV2_Feature *work_schedule_feature = NULL;
 
@@ -2981,7 +3551,7 @@ static void GetFeatures(effect_t *effect)
     features[URID_MAP_FEATURE]          = &g_urid_map_feature;
     features[URID_UNMAP_FEATURE]        = &g_urid_unmap_feature;
     features[OPTIONS_FEATURE]           = &g_options_feature;
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
     features[HMI_WC_FEATURE]            = &g_hmi_wc_feature;
 #endif
     features[LICENSE_FEATURE]           = &g_license_feature;
@@ -2992,6 +3562,7 @@ static void GetFeatures(effect_t *effect)
     features[STATE_FREE_PATH_FEATURE]   = &g_state_freePath_feature;
     features[STATE_MAKE_PATH_FEATURE]   = state_make_path_feature;
     features[CTRLPORT_REQUEST_FEATURE]  = ctrlportReqChange_feature;
+    features[CTRLPORT_STATE_FEATURE]    = ctrlportStateUpdate_feature;
     features[WORKER_FEATURE]            = work_schedule_feature;
 #ifdef WITH_EXTERNAL_UI_SUPPORT
     features[UI_DATA_ACCESS]            = NULL;
@@ -3000,6 +3571,9 @@ static void GetFeatures(effect_t *effect)
     features[FEATURE_TERMINATOR]        = NULL;
 
     effect->features = features;
+
+    /* also update jack client option value */
+    g_options[7].value = effect->jack_client;
 }
 
 /**
@@ -3110,7 +3684,7 @@ static const void* GetPortValueForState(const char* symbol, void* user_data, uin
     return NULL;
 }
 
-static int LoadPresets(effect_t *effect)
+static void LoadPresets(effect_t *effect)
 {
     LilvNodes* presets = lilv_plugin_get_related(effect->lilv_plugin, g_lilv_nodes.preset);
     uint32_t presets_count = lilv_nodes_size(presets);
@@ -3118,8 +3692,6 @@ static int LoadPresets(effect_t *effect)
     // allocate for presets
     effect->presets = (preset_t **) mod_calloc(presets_count, sizeof(preset_t *));
     uint32_t j = 0;
-    for (j = 0; j < presets_count; j++) effect->presets[j] = NULL;
-    j = 0;
     LILV_FOREACH(nodes, i, presets)
     {
         const LilvNode* preset = lilv_nodes_get(presets, i);
@@ -3128,8 +3700,6 @@ static int LoadPresets(effect_t *effect)
         j++;
     }
     lilv_nodes_free(presets);
-
-    return 0;
 }
 
 // ignore const cast for this function, need to free const features array
@@ -3159,6 +3729,11 @@ static void FreeFeatures(effect_t *effect)
             free(effect->features[CTRLPORT_REQUEST_FEATURE]->data);
             free((void*)effect->features[CTRLPORT_REQUEST_FEATURE]);
         }
+        if (effect->features[CTRLPORT_STATE_FEATURE])
+        {
+            free(effect->features[CTRLPORT_STATE_FEATURE]->data);
+            free((void*)effect->features[CTRLPORT_STATE_FEATURE]);
+        }
         if (effect->features[WORKER_FEATURE])
         {
             free(effect->features[WORKER_FEATURE]->data);
@@ -3245,7 +3820,7 @@ static void ConnectToMIDIThroughPorts(void)
     }
 }
 
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
 static void HMIWidgetsSetLedWithBlink(LV2_HMI_WidgetControl_Handle handle,
                                       LV2_HMI_Addressing addressing_ptr,
                                       LV2_HMI_LED_Colour led_color,
@@ -3665,7 +4240,8 @@ static int LogVPrintf(LV2_Log_Handle handle, LV2_URID type, const char* fmt, va_
 }
 
 static LV2_ControlInputPort_Change_Status RequestControlPortChange(LV2_ControlInputPort_Change_Request_Handle handle,
-                                                                   uint32_t index, float value)
+                                                                   uint32_t index,
+                                                                   float value)
 {
     effect_t *effect = (effect_t*)handle;
 
@@ -3687,6 +4263,65 @@ static LV2_ControlInputPort_Change_Status RequestControlPortChange(LV2_ControlIn
     return LV2_CONTROL_INPUT_PORT_CHANGE_SUCCESS;
 }
 
+static LV2_Control_Port_State_Update_Status UpdateControlPortState(LV2_Control_Port_State_Update_Handle handle,
+                                                                   uint32_t index,
+                                                                   LV2_Control_Port_State state)
+{
+    effect_t *effect = (effect_t*)handle;
+
+    if (index >= effect->ports_count)
+        return LV2_CONTROL_PORT_STATE_UPDATE_ERR_INVALID_INDEX;
+
+    port_t *port = effect->ports[index];
+
+    if (port->type != TYPE_CONTROL)
+        return LV2_CONTROL_PORT_STATE_UPDATE_ERR_INVALID_INDEX;
+
+    LV2_Control_Port_State curstate;
+    if (port->hints & HINT_STATE_BLOCKED)
+        curstate = LV2_CONTROL_PORT_STATE_BLOCKED;
+    else if (port->hints & HINT_STATE_INACTIVE)
+        curstate = LV2_CONTROL_PORT_STATE_INACTIVE;
+    else
+        curstate = LV2_CONTROL_PORT_STATE_NONE;
+
+    if (curstate == state)
+        return LV2_CONTROL_PORT_STATE_UPDATE_SUCCESS;
+
+    postponed_event_list_data* const posteventptr =
+        rtsafe_memory_pool_allocate_atomic(g_rtsafe_mem_pool);
+
+    if (posteventptr == NULL)
+        return LV2_CONTROL_PORT_STATE_UPDATE_ERR_UNKNOWN;
+
+    switch (state)
+    {
+    case LV2_CONTROL_PORT_STATE_NONE:
+        port->hints &= ~(HINT_STATE_INACTIVE|HINT_STATE_BLOCKED);
+        break;
+    case LV2_CONTROL_PORT_STATE_INACTIVE:
+        port->hints |= HINT_STATE_INACTIVE;
+        port->hints &= ~HINT_STATE_BLOCKED;
+        break;
+    case LV2_CONTROL_PORT_STATE_BLOCKED:
+        port->hints |= HINT_STATE_INACTIVE|HINT_STATE_BLOCKED;
+        break;
+    }
+
+    posteventptr->event.type = POSTPONED_PARAM_STATE;
+    posteventptr->event.state.effect_id = effect->instance;
+    posteventptr->event.state.symbol    = port->symbol;
+    posteventptr->event.state.state     = state;
+
+    pthread_mutex_lock(&g_rtsafe_mutex);
+    list_add_tail(&posteventptr->siblings, &g_rtsafe_list);
+    pthread_mutex_unlock(&g_rtsafe_mutex);
+
+    sem_post(&g_postevents_semaphore);
+
+    return LV2_CONTROL_PORT_STATE_UPDATE_SUCCESS;
+}
+
 static char* MakePluginStatePathFromSratchDir(LV2_State_Make_Path_Handle handle, const char *path)
 {
     effect_t *effect = (effect_t*)handle;
@@ -3890,6 +4525,8 @@ int effects_init(void* client)
         return ERR_JACK_CLIENT_CREATION;
     }
 
+    time_ns_init();
+
     /* Register jack ports */
     g_midi_in_port = jack_port_register(g_jack_global_client, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 
@@ -3929,8 +4566,7 @@ int effects_init(void* client)
     INIT_LIST_HEAD(&g_rtsafe_list);
     INIT_LIST_HEAD(&g_raw_midi_port_list);
 
-    if (!rtsafe_memory_pool_create(&g_rtsafe_mem_pool, "mod-host", sizeof(postponed_event_list_data),
-                                   MAX_POSTPONED_EVENTS))
+    if (!rtsafe_memory_pool_create(&g_rtsafe_mem_pool, sizeof(postponed_event_list_data), MAX_POSTPONED_EVENTS))
     {
         fprintf(stderr, "can't allocate realtime-safe memory pool\n");
         if (client == NULL)
@@ -3946,8 +4582,10 @@ int effects_init(void* client)
 
     pthread_mutex_init(&g_rtsafe_mutex, &mutex_atts);
     pthread_mutex_init(&g_raw_midi_port_mutex, &mutex_atts);
+    pthread_mutex_init(&g_audio_monitor_mutex, &mutex_atts);
     pthread_mutex_init(&g_midi_learning_mutex, &mutex_atts);
-#ifdef __MOD_DEVICES__
+    pthread_mutex_init(&g_sync_scheduled_params_mutex, &mutex_atts);
+#ifdef MOD_HMI_CONTROL_ENABLED
     pthread_mutex_init(&g_hmi_mutex, &mutex_atts);
 #endif
 
@@ -3960,6 +4598,7 @@ int effects_init(void* client)
     /* Get buffers size */
     g_block_length = jack_get_buffer_size(g_jack_global_client);
     g_sample_rate = jack_get_sample_rate(g_jack_global_client);
+    g_block_time_us = g_block_length * 1e6 / g_sample_rate;
     g_sample_rate_f = g_sample_rate;
     g_midi_buffer_size = jack_port_type_get_buffer_size(g_jack_global_client, JACK_DEFAULT_MIDI_TYPE);
     g_max_allowed_midi_delta = (jack_nframes_t)(g_sample_rate * 0.2); // max 200ms of allowed delta
@@ -4053,6 +4692,7 @@ int effects_init(void* client)
         effect->control_index = -1;
         effect->enabled_index = -1;
         effect->freewheel_index = -1;
+        effect->reset_index = -1;
         effect->bpb_index = -1;
         effect->bpm_index = -1;
         effect->speed_index = -1;
@@ -4096,6 +4736,7 @@ int effects_init(void* client)
     jack_set_process_callback(g_jack_global_client, ProcessGlobalClient, NULL);
     jack_set_buffer_size_callback(g_jack_global_client, BufferSize, NULL);
     jack_set_port_registration_callback(g_jack_global_client, PortRegistration, NULL);
+    jack_set_xrun_callback(g_jack_global_client, XRun, NULL);
 
 #ifdef HAVE_HYLIA
     /* Init hylia */
@@ -4112,6 +4753,9 @@ int effects_init(void* client)
 
     /* Load all LV2 data */
     g_lv2_data = lilv_world_new();
+#ifdef LILV_OPTION_OBJECT_INDEX
+    lilv_world_set_option(g_lv2_data, LILV_OPTION_OBJECT_INDEX, NULL);
+#endif
     lilv_world_load_all(g_lv2_data);
     g_plugins = lilv_world_get_all_plugins(g_lv2_data);
 
@@ -4130,6 +4774,7 @@ int effects_init(void* client)
     g_lilv_nodes.input = lilv_new_uri(g_lv2_data, LILV_URI_INPUT_PORT);
     g_lilv_nodes.integer = lilv_new_uri(g_lv2_data, LV2_CORE__integer);
     g_lilv_nodes.license_interface = lilv_new_uri(g_lv2_data, MOD_LICENSE__interface);
+    g_lilv_nodes.is_live = lilv_new_uri(g_lv2_data, LV2_CORE__isLive);
     g_lilv_nodes.logarithmic = lilv_new_uri(g_lv2_data, LV2_PORT_PROPS__logarithmic);
     g_lilv_nodes.maximum = lilv_new_uri(g_lv2_data, LV2_CORE__maximum);
     g_lilv_nodes.midiEvent = lilv_new_uri(g_lv2_data, LV2_MIDI__MidiEvent);
@@ -4150,6 +4795,7 @@ int effects_init(void* client)
 #endif
     g_lilv_nodes.mod_maximum = lilv_new_uri(g_lv2_data, LILV_NS_MOD "maximum");
     g_lilv_nodes.mod_minimum = lilv_new_uri(g_lv2_data, LILV_NS_MOD "minimum");
+    g_lilv_nodes.noPreRun = lilv_new_uri(g_lv2_data, "http://www.darkglass.com/lv2/ns#noPreRun");
     g_lilv_nodes.options_interface = lilv_new_uri(g_lv2_data, LV2_OPTIONS__interface);
     g_lilv_nodes.output = lilv_new_uri(g_lv2_data, LILV_URI_OUTPUT_PORT);
     g_lilv_nodes.patch_writable = lilv_new_uri(g_lv2_data, LV2_PATCH__writable);
@@ -4159,6 +4805,7 @@ int effects_init(void* client)
     g_lilv_nodes.preset = lilv_new_uri(g_lv2_data, LV2_PRESETS__Preset);
     g_lilv_nodes.rawMIDIClockAccess = lilv_new_uri(g_lv2_data, LILV_NS_MOD "rawMIDIClockAccess");
     g_lilv_nodes.rdfs_range = lilv_new_uri(g_lv2_data, LILV_NS_RDFS "range");
+    g_lilv_nodes.reset = lilv_new_uri(g_lv2_data, LV2_KXSTUDIO_PROPERTIES__Reset);
     g_lilv_nodes.sample_rate = lilv_new_uri(g_lv2_data, LV2_CORE__sampleRate);
     g_lilv_nodes.state_interface = lilv_new_uri(g_lv2_data, LV2_STATE__interface);
     g_lilv_nodes.state_load_default_state = lilv_new_uri(g_lv2_data, LV2_STATE__loadDefaultState);
@@ -4201,6 +4848,8 @@ int effects_init(void* client)
     g_urids.bufsz_nomimalBlockLength = urid_to_id(g_symap, LV2_BUF_SIZE__nominalBlockLength);
     g_urids.bufsz_sequenceSize   = urid_to_id(g_symap, LV2_BUF_SIZE__sequenceSize);
 
+    g_urids.jack_client          = urid_to_id(g_symap, "http://jackaudio.org/metadata/client");
+
     g_urids.log_Error            = urid_to_id(g_symap, LV2_LOG__Error);
     g_urids.log_Note             = urid_to_id(g_symap, LV2_LOG__Note);
     g_urids.log_Trace            = urid_to_id(g_symap, LV2_LOG__Trace);
@@ -4222,7 +4871,7 @@ int effects_init(void* client)
     g_urids.time_beatUnit        = urid_to_id(g_symap, LV2_TIME__beatUnit);
     g_urids.time_beatsPerBar     = urid_to_id(g_symap, LV2_TIME__beatsPerBar);
     g_urids.time_beatsPerMinute  = urid_to_id(g_symap, LV2_TIME__beatsPerMinute);
-    g_urids.time_ticksPerBeat    = urid_to_id(g_symap, KX_TIME__TicksPerBeat);
+    g_urids.time_ticksPerBeat    = urid_to_id(g_symap, LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat);
     g_urids.time_frame           = urid_to_id(g_symap, LV2_TIME__frame);
     g_urids.time_speed           = urid_to_id(g_symap, LV2_TIME__speed);
 
@@ -4281,12 +4930,19 @@ int effects_init(void* client)
 
     g_options[7].context = LV2_OPTIONS_INSTANCE;
     g_options[7].subject = 0;
-    g_options[7].key = 0;
-    g_options[7].size = 0;
-    g_options[7].type = 0;
+    g_options[7].key = g_urids.jack_client;
+    g_options[7].size = sizeof(jack_client_t*);
+    g_options[7].type = g_urids.jack_client;
     g_options[7].value = NULL;
 
-#ifdef __MOD_DEVICES__
+    g_options[8].context = LV2_OPTIONS_INSTANCE;
+    g_options[8].subject = 0;
+    g_options[8].key = 0;
+    g_options[8].size = 0;
+    g_options[8].type = 0;
+    g_options[8].value = NULL;
+
+#ifdef MOD_HMI_CONTROL_ENABLED
     g_hmi_wc.size                    = sizeof(g_hmi_wc);
     g_hmi_wc.set_led_with_blink      = HMIWidgetsSetLedWithBlink;
     g_hmi_wc.set_led_with_brightness = HMIWidgetsSetLedWithBrightness;
@@ -4303,7 +4959,7 @@ int effects_init(void* client)
         {
             g_hmi_wc.handle = g_hmi_data;
             sys_serial_write(&g_hmi_data->server, sys_serial_event_type_special_req, 0, 0, "restart");
-            pthread_create(&g_hmi_client_thread, NULL, HMIClientThread, &g_hmi_data->client);
+            zix_thread_create(&g_hmi_client_thread, 0, HMIClientThread, &g_hmi_data->client);
         }
         else
         {
@@ -4314,10 +4970,10 @@ int effects_init(void* client)
 
     for (int i = 0; i < MAX_HMI_ADDRESSINGS; i++)
         g_hmi_addressings[i].actuator_id = -1;
+#endif
 
 #ifdef MOD_IO_PROCESSING_ENABLED
     gate_init(&g_noisegate);
-#endif
 #endif
 
     g_license.handle = NULL;
@@ -4348,6 +5004,7 @@ int effects_init(void* client)
     }
     g_midi_learning = NULL;
 
+    memset(g_monitored_midi_controls, 0, sizeof(g_monitored_midi_controls));
     memset(g_monitored_midi_programs, 0, sizeof(g_monitored_midi_programs));
 
 #ifdef HAVE_CONTROLCHAIN
@@ -4367,7 +5024,7 @@ int effects_init(void* client)
     /* Start the thread that consumes from the event queue */
     g_postevents_running = 1;
     g_postevents_ready = true;
-    pthread_create(&g_postevents_thread, NULL, PostPonedEventsThread, NULL);
+    zix_thread_create(&g_postevents_thread, 0, PostPonedEventsThread, NULL);
 
     /* get transport state */
     UpdateGlobalJackPosition(UPDATE_POSITION_SKIP, false);
@@ -4432,21 +5089,21 @@ int effects_finish(int close_client)
 {
     g_postevents_running = -1;
     sem_post(&g_postevents_semaphore);
-    pthread_join(g_postevents_thread, NULL);
+    zix_thread_join(g_postevents_thread, NULL);
 
-    if (close_client)
+    if (close_client && g_jack_global_client != NULL && strcmp(jack_get_client_name(g_jack_global_client), "mod-host") == 0)
         monitor_client_stop();
 
     effects_remove(REMOVE_ALL);
 
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
     if (g_hmi_data != NULL)
     {
         sys_serial_shm_data* hmi_data = g_hmi_data;
         g_hmi_data = NULL;
 
         sem_post(&hmi_data->client.sem);
-        pthread_join(g_hmi_client_thread, NULL);
+        zix_thread_join(g_hmi_client_thread, NULL);
 
         sys_serial_close(g_hmi_shmfd, hmi_data);
     }
@@ -4479,6 +5136,7 @@ int effects_finish(int close_client)
     lilv_node_free(g_lilv_nodes.integer);
     lilv_node_free(g_lilv_nodes.license_interface);
     lilv_node_free(g_lilv_nodes.logarithmic);
+    lilv_node_free(g_lilv_nodes.is_live);
     lilv_node_free(g_lilv_nodes.maximum);
     lilv_node_free(g_lilv_nodes.midiEvent);
     lilv_node_free(g_lilv_nodes.minimum);
@@ -4488,6 +5146,7 @@ int effects_finish(int close_client)
     lilv_node_free(g_lilv_nodes.mod_default_custom);
     lilv_node_free(g_lilv_nodes.mod_maximum);
     lilv_node_free(g_lilv_nodes.mod_minimum);
+    lilv_node_free(g_lilv_nodes.noPreRun);
     lilv_node_free(g_lilv_nodes.output);
     lilv_node_free(g_lilv_nodes.patch_readable);
     lilv_node_free(g_lilv_nodes.patch_writable);
@@ -4496,6 +5155,7 @@ int effects_finish(int close_client)
     lilv_node_free(g_lilv_nodes.preset);
     lilv_node_free(g_lilv_nodes.rawMIDIClockAccess);
     lilv_node_free(g_lilv_nodes.rdfs_range);
+    lilv_node_free(g_lilv_nodes.reset);
     lilv_node_free(g_lilv_nodes.sample_rate);
     lilv_node_free(g_lilv_nodes.state_interface);
     lilv_node_free(g_lilv_nodes.state_load_default_state);
@@ -4512,8 +5172,10 @@ int effects_finish(int close_client)
     sem_destroy(&g_postevents_semaphore);
     pthread_mutex_destroy(&g_rtsafe_mutex);
     pthread_mutex_destroy(&g_raw_midi_port_mutex);
+    pthread_mutex_destroy(&g_audio_monitor_mutex);
     pthread_mutex_destroy(&g_midi_learning_mutex);
-#ifdef __MOD_DEVICES__
+    pthread_mutex_destroy(&g_sync_scheduled_params_mutex);
+#ifdef MOD_HMI_CONTROL_ENABLED
     pthread_mutex_destroy(&g_hmi_mutex);
 #endif
 
@@ -4538,7 +5200,7 @@ int effects_finish(int close_client)
     return SUCCESS;
 }
 
-int effects_add(const char *uri, int instance)
+int effects_add(const char *uri, int instance, int activate)
 {
     unsigned int ports_count;
     char effect_name[32], port_name[MAX_CHAR_BUF_SIZE+1];
@@ -4579,6 +5241,8 @@ int effects_add(const char *uri, int instance)
     /* Init the struct */
     mod_memset(effect, 0, sizeof(effect_t));
     effect->instance = instance;
+    effect->jack_activated = activate;
+    effect->lv2_activated = true;
 
     /* Init the pointers */
     plugin_uri = NULL;
@@ -4666,11 +5330,18 @@ int effects_add(const char *uri, int instance)
         effect->control_index = -1;
     }
 
+    /* Query plugin features */
+    if (lilv_plugin_has_feature(effect->lilv_plugin, g_lilv_nodes.is_live))
+        effect->hints |= HINT_IS_LIVE;
+
+    if (lilv_plugin_has_feature(effect->lilv_plugin, g_lilv_nodes.noPreRun))
+        effect->hints |= HINT_NO_PRE_RUN;
+
     /* Query plugin extensions/interfaces */
     if (lilv_plugin_has_extension_data(effect->lilv_plugin, g_lilv_nodes.worker_interface))
     {
         const LV2_Worker_Interface *worker_interface =
-            (const LV2_Worker_Interface*) lilv_instance_get_extension_data(effect->lilv_instance,
+            (const LV2_Worker_Interface*) lilv_instance_get_extension_data(lilv_instance,
                                                                            LV2_WORKER__interface);
 
         worker_init(&effect->worker, lilv_instance, worker_interface, worker_buf_size);
@@ -4679,21 +5350,21 @@ int effects_add(const char *uri, int instance)
     if (lilv_plugin_has_extension_data(effect->lilv_plugin, g_lilv_nodes.options_interface))
     {
         effect->options_interface =
-            (const LV2_Options_Interface*) lilv_instance_get_extension_data(effect->lilv_instance,
+            (const LV2_Options_Interface*) lilv_instance_get_extension_data(lilv_instance,
                                                                             LV2_OPTIONS__interface);
     }
 
     if (lilv_plugin_has_extension_data(effect->lilv_plugin, g_lilv_nodes.license_interface))
     {
         effect->license_iface =
-            (const MOD_License_Interface*) lilv_instance_get_extension_data(effect->lilv_instance,
+            (const MOD_License_Interface*) lilv_instance_get_extension_data(lilv_instance,
                                                                             MOD_LICENSE__interface);
     }
 
     if (lilv_plugin_has_extension_data(effect->lilv_plugin, g_lilv_nodes.state_interface))
     {
         effect->state_iface =
-            (const LV2_State_Interface*) lilv_instance_get_extension_data(effect->lilv_instance,
+            (const LV2_State_Interface*) lilv_instance_get_extension_data(lilv_instance,
                                                                           LV2_STATE__interface);
         effect->hints |= HINT_HAS_STATE;
 
@@ -4708,7 +5379,7 @@ int effects_add(const char *uri, int instance)
             LilvState *state = lilv_state_new_from_world(g_lv2_data, &g_urid_map, plugin_uri);
 
             if (state != NULL) {
-                lilv_state_restore(state, effect->lilv_instance, NULL, NULL,
+                lilv_state_restore(state, lilv_instance, NULL, NULL,
                                    LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, effect->features);
                 lilv_state_free(state);
             }
@@ -4719,7 +5390,7 @@ int effects_add(const char *uri, int instance)
     if (lilv_plugin_has_extension_data(effect->lilv_plugin, g_lilv_nodes.hmi_interface))
     {
         effect->hmi_notif =
-            (const LV2_HMI_PluginNotification*) lilv_instance_get_extension_data(effect->lilv_instance,
+            (const LV2_HMI_PluginNotification*) lilv_instance_get_extension_data(lilv_instance,
                                                                                  LV2_HMI__PluginNotification);
     }
 #endif
@@ -4740,7 +5411,6 @@ int effects_add(const char *uri, int instance)
     event_ports_count = 0;
     input_event_ports_count = 0;
     output_event_ports_count = 0;
-    worker_buf_size = 0;
     effect->presets_count = 0;
     effect->presets = NULL;
     effect->monitors_count = 0;
@@ -4805,8 +5475,8 @@ int effects_add(const char *uri, int instance)
                 goto error;
             }
             port->jack_port = jack_port;
-
             audio_ports_count++;
+
             if (lilv_port_is_a(plugin, lilv_port, g_lilv_nodes.input)) input_audio_ports_count++;
             else if (lilv_port_is_a(plugin, lilv_port, g_lilv_nodes.output)) output_audio_ports_count++;
         }
@@ -4864,7 +5534,6 @@ int effects_add(const char *uri, int instance)
             /* Set the default value of control */
             float def_value;
 
-
             if (lilv_port_has_property(plugin, lilv_port, g_lilv_nodes.preferMomentaryOff))
             {
                 def_value = max_value;
@@ -4945,9 +5614,6 @@ int effects_add(const char *uri, int instance)
                 goto error;
             }
 
-            if (lilv_port_is_a(plugin, lilv_port, g_lilv_nodes.mod_cvport))
-                port->hints |= HINT_CV_MOD;
-
             port->buffer = cv_buffer;
             port->buffer_count = g_sample_rate;
             lilv_instance_connect_port(lilv_instance, i, cv_buffer);
@@ -4962,6 +5628,9 @@ int effects_add(const char *uri, int instance)
                 goto error;
             }
 
+            if (lilv_port_is_a(plugin, lilv_port, g_lilv_nodes.mod_cvport))
+                port->hints |= HINT_CV_MOD;
+
             /* Set the minimum value of control */
             float min_value;
             LilvNodes* lilvvalue_minimum = lilv_port_get_value(plugin, lilv_port, g_lilv_nodes.mod_minimum);
@@ -5091,7 +5760,9 @@ int effects_add(const char *uri, int instance)
                     portitemptr->jack_port = jack_port;
 
                     pthread_mutex_lock(&g_raw_midi_port_mutex);
+
                     list_add_tail(&portitemptr->siblings, &g_raw_midi_port_list);
+
                     pthread_mutex_unlock(&g_raw_midi_port_mutex);
                 }
             }
@@ -5100,7 +5771,9 @@ int effects_add(const char *uri, int instance)
 
     // special ports
     {
-        const LilvPort* enabled_port = lilv_plugin_get_port_by_designation(plugin, g_lilv_nodes.input, g_lilv_nodes.enabled);
+        const LilvPort* enabled_port = lilv_plugin_get_port_by_designation(plugin,
+                                                                           g_lilv_nodes.input,
+                                                                           g_lilv_nodes.enabled);
         if (enabled_port)
         {
             effect->enabled_index = lilv_port_get_index(plugin, enabled_port);
@@ -5111,7 +5784,9 @@ int effects_add(const char *uri, int instance)
             effect->enabled_index = -1;
         }
 
-        const LilvPort* freewheel_port = lilv_plugin_get_port_by_designation(plugin, g_lilv_nodes.input, g_lilv_nodes.freeWheeling);
+        const LilvPort* freewheel_port = lilv_plugin_get_port_by_designation(plugin,
+                                                                             g_lilv_nodes.input,
+                                                                             g_lilv_nodes.freeWheeling);
         if (freewheel_port)
         {
             effect->freewheel_index = lilv_port_get_index(plugin, freewheel_port);
@@ -5122,7 +5797,22 @@ int effects_add(const char *uri, int instance)
             effect->freewheel_index = -1;
         }
 
-        const LilvPort* bpb_port = lilv_plugin_get_port_by_designation(plugin, g_lilv_nodes.input, g_lilv_nodes.timeBeatsPerBar);
+        const LilvPort* reset_port = lilv_plugin_get_port_by_designation(plugin,
+                                                                         g_lilv_nodes.input,
+                                                                         g_lilv_nodes.reset);
+        if (reset_port)
+        {
+            effect->reset_index = lilv_port_get_index(plugin, reset_port);
+            *(effect->ports[effect->reset_index]->buffer) = 0.0f;
+        }
+        else
+        {
+            effect->reset_index = -1;
+        }
+
+        const LilvPort* bpb_port = lilv_plugin_get_port_by_designation(plugin,
+                                                                       g_lilv_nodes.input,
+                                                                       g_lilv_nodes.timeBeatsPerBar);
         if (bpb_port)
         {
             effect->bpb_index = lilv_port_get_index(plugin, bpb_port);
@@ -5133,7 +5823,9 @@ int effects_add(const char *uri, int instance)
             effect->bpb_index = -1;
         }
 
-        const LilvPort* bpm_port = lilv_plugin_get_port_by_designation(plugin, g_lilv_nodes.input, g_lilv_nodes.timeBeatsPerMinute);
+        const LilvPort* bpm_port = lilv_plugin_get_port_by_designation(plugin,
+                                                                       g_lilv_nodes.input,
+                                                                       g_lilv_nodes.timeBeatsPerMinute);
         if (bpm_port)
         {
             effect->bpm_index = lilv_port_get_index(plugin, bpm_port);
@@ -5144,7 +5836,9 @@ int effects_add(const char *uri, int instance)
             effect->bpm_index = -1;
         }
 
-        const LilvPort* speed_port = lilv_plugin_get_port_by_designation(plugin, g_lilv_nodes.input, g_lilv_nodes.timeSpeed);
+        const LilvPort* speed_port = lilv_plugin_get_port_by_designation(plugin,
+                                                                         g_lilv_nodes.input,
+                                                                         g_lilv_nodes.timeSpeed);
         if (speed_port)
         {
             effect->speed_index = lilv_port_get_index(plugin, speed_port);
@@ -5359,6 +6053,8 @@ int effects_add(const char *uri, int instance)
         lilv_nodes_free(readable_properties);
     }
 
+    lilv_node_free(plugin_uri);
+
     /* create ring buffer for events from socket/commandline */
     if (control_in_size != 0)
     {
@@ -5404,8 +6100,6 @@ int effects_add(const char *uri, int instance)
 
     pthread_mutexattr_destroy(&mutex_atts);
 
-    lilv_node_free(plugin_uri);
-
     /* Jack callbacks */
     jack_set_thread_init_callback(jack_client, JackThreadInit, effect);
     jack_set_process_callback(jack_client, ProcessPlugin, effect);
@@ -5414,12 +6108,15 @@ int effects_add(const char *uri, int instance)
 
     lilv_instance_activate(lilv_instance);
 
-    /* Try activate the Jack client */
-    if (jack_activate(jack_client) != 0)
+    if (activate)
     {
-        fprintf(stderr, "can't activate jack_client\n");
-        error = ERR_JACK_CLIENT_ACTIVATION;
-        goto error;
+        /* Try activate the Jack client */
+        if (jack_activate(jack_client) != 0)
+        {
+            fprintf(stderr, "can't activate jack_client\n");
+            error = ERR_JACK_CLIENT_ACTIVATION;
+            goto error;
+        }
     }
 
     if (raw_midi_port != NULL)
@@ -5450,10 +6147,25 @@ int effects_add(const char *uri, int instance)
 
 error:
     lilv_node_free(plugin_uri);
+
     effects_remove(instance);
     return error;
 }
 
+int effects_add_multi(int activate, int num_effects, int *effects, const char *const *uris)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    if (num_effects == 1)
+        return effects_add(*uris, *effects, activate);
+
+    for (int i = 0; i < num_effects; ++i)
+        effects_add(uris[i], effects[i], activate);
+
+    return SUCCESS;
+}
+
 int effects_preset_load(int effect_id, const char *uri)
 {
     effect_t *effect;
@@ -5486,6 +6198,10 @@ int effects_preset_load(int effect_id, const char *uri)
             {
                 *(effect->ports[effect->freewheel_index]->buffer) = 0.0f;
             }
+            if (effect->reset_index >= 0)
+            {
+                *(effect->ports[effect->reset_index]->buffer) = 0.0f;
+            }
             if (effect->bpb_index >= 0)
             {
                 *(effect->ports[effect->bpb_index]->buffer) = g_transport_bpb;
@@ -5577,81 +6293,27 @@ int effects_preset_show(const char *uri, char **state_str)
     return ERR_LV2_INVALID_PRESET_URI;
 }
 
-int effects_remove(int effect_id)
+// remove addressings, midi learn and other stuff related to a plugin
+static void effects_remove_inner_pre(int effect_id)
 {
-    int start, end;
-    effect_t *effect;
-    char state_filename[g_lv2_scratch_dir != NULL ? PATH_MAX : 1];
-
-    // stop postpone events thread
-    if (g_postevents_running == 1)
-    {
-        g_postevents_running = 0;
-        sem_post(&g_postevents_semaphore);
-        pthread_join(g_postevents_thread, NULL);
-    }
-
-    // disconnect system ports
-    if (effect_id == REMOVE_ALL)
-    {
-        /* Disconnect the system connections */
-        if (g_capture_ports != NULL)
-        {
-            for (int i = 0; g_capture_ports[i]; i++)
-            {
-                jack_port_t *port = jack_port_by_name(g_jack_global_client, g_capture_ports[i]);
-                if (! port)
-                    continue;
-
-                const char **capture_connections = jack_port_get_connections(port);
-                if (capture_connections)
-                {
-                    for (int j = 0; capture_connections[j]; j++)
-                    {
-                        if (strstr(capture_connections[j], "system"))
-                            jack_disconnect(g_jack_global_client, g_capture_ports[i], capture_connections[j]);
-                    }
-
-                    jack_free(capture_connections);
-                }
-            }
-        }
-
-        start = 0;
-        end = MAX_PLUGIN_INSTANCES;
-    }
-    else
-    {
-        start = effect_id;
-        end = start + 1;
-    }
-
-    // stop plugins processing
-    for (int j = start; j < end; j++)
-    {
-        if (InstanceExist(j))
-        {
-            effect = &g_effects[j];
-
-            if (jack_deactivate(effect->jack_client) != 0)
-                return ERR_JACK_CLIENT_DEACTIVATION;
-        }
-    }
-
-    // remove addressings, midi learn and other stuff related to plugins
     if (effect_id == REMOVE_ALL)
     {
         pthread_mutex_lock(&g_midi_learning_mutex);
         g_midi_learning = NULL;
         pthread_mutex_unlock(&g_midi_learning_mutex);
 
-        for (int j = 0; j < MAX_MIDI_CC_ASSIGN; j++)
+        for (int j = MAX_MIDI_CC_ASSIGN, unused = ASSIGNMENT_NULL; --j >= 0;)
         {
+            if (g_midi_cc_list[j].effect_id >= MAX_PLUGIN_INSTANCES && g_midi_cc_list[j].effect_id < MAX_INSTANCES)
+            {
+                unused = ASSIGNMENT_UNUSED;
+                continue;
+            }
             g_midi_cc_list[j].channel = -1;
             g_midi_cc_list[j].controller = 0;
             g_midi_cc_list[j].minimum = 0.0f;
             g_midi_cc_list[j].maximum = 1.0f;
-            g_midi_cc_list[j].effect_id = ASSIGNMENT_NULL;
+            g_midi_cc_list[j].effect_id = unused;
             g_midi_cc_list[j].symbol = NULL;
             g_midi_cc_list[j].port = NULL;
         }
@@ -5691,7 +6353,7 @@ int effects_remove(int effect_id)
         }
 #endif
 
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
         for (int i = 0; i < MAX_HMI_ADDRESSINGS; i++)
             g_hmi_addressings[i].actuator_id = -1;
 
@@ -5701,10 +6363,10 @@ int effects_remove(int effect_id)
             sys_serial_write(&g_hmi_data->server, sys_serial_event_type_special_req, 0, 0, "pages");
             pthread_mutex_unlock(&g_hmi_mutex);
         }
+#endif
 
         // this resets volume back 0dB if needed
         // monitor_client_setup_volume(0.0f);
-#endif
 
         // reset all events
         struct list_head queue, *it, *it2;
@@ -5807,147 +6469,233 @@ int effects_remove(int effect_id)
             }
         }
 #endif
-
-        // flush events for all effects except this one
-        RunPostPonedEvents(effect_id);
     }
+}
 
-    // now finally cleanup the plugin(s)
-    for (int j = start; j < end; j++)
-    {
-        if (InstanceExist(j))
-        {
-            effect = &g_effects[j];
+// cleanup the plugin (inner loop)
+static void effects_remove_inner_loop(int effect_id)
+{
+    effect_t *effect = &g_effects[effect_id];
 
 #ifdef WITH_EXTERNAL_UI_SUPPORT
-            if (effect->ui_libhandle != NULL)
-            {
-                if (effect->ui_desc != NULL && effect->ui_handle != NULL && effect->ui_desc->cleanup != NULL)
-                    effect->ui_desc->cleanup(effect->ui_handle);
+    if (effect->ui_libhandle != NULL)
+    {
+        if (effect->ui_desc != NULL && effect->ui_handle != NULL && effect->ui_desc->cleanup != NULL)
+            effect->ui_desc->cleanup(effect->ui_handle);
 
-                dlclose(effect->ui_libhandle);
-            }
+        dlclose(effect->ui_libhandle);
+    }
 #endif
 
-            FreeFeatures(effect);
+    FreeFeatures(effect);
 
-            if (effect->event_ports)
-            {
-                for (uint32_t i = 0; i < effect->event_ports_count; i++)
-                {
-                    lv2_evbuf_free(effect->event_ports[i]->evbuf);
-                }
-            }
+    if (effect->event_ports)
+    {
+        for (uint32_t i = 0; i < effect->event_ports_count; i++)
+        {
+            lv2_evbuf_free(effect->event_ports[i]->evbuf);
+        }
+    }
 
-            if (effect->ports)
+    if (effect->ports)
+    {
+        for (uint32_t i = 0; i < effect->ports_count; i++)
+        {
+            if (effect->ports[i])
             {
-                for (uint32_t i = 0; i < effect->ports_count; i++)
+#ifdef MOD_HMI_CONTROL_ENABLED
+                if (effect->ports[i]->hmi_addressing != NULL)
                 {
-                    if (effect->ports[i])
+                    if (g_hmi_data != NULL)
                     {
-#ifdef __MOD_DEVICES__
-                        if (effect->ports[i]->hmi_addressing != NULL)
-                        {
-                            if (g_hmi_data != NULL)
-                            {
-                                char msg[24];
-                                snprintf(msg, sizeof(msg), "%i", effect->ports[i]->hmi_addressing->actuator_id);
-                                msg[sizeof(msg)-1] = '\0';
-
-                                pthread_mutex_lock(&g_hmi_mutex);
-                                sys_serial_write(&g_hmi_data->server,
-                                                 sys_serial_event_type_unassign,
-                                                 effect->ports[i]->hmi_addressing->page,
-                                                 effect->ports[i]->hmi_addressing->subpage, msg);
-                                pthread_mutex_unlock(&g_hmi_mutex);
-                            }
+                        char msg[24];
+                        snprintf(msg, sizeof(msg), "%i", effect->ports[i]->hmi_addressing->actuator_id);
+                        msg[sizeof(msg)-1] = '\0';
+
+                        pthread_mutex_lock(&g_hmi_mutex);
+                        sys_serial_write(&g_hmi_data->server,
+                                          sys_serial_event_type_unassign,
+                                          effect->ports[i]->hmi_addressing->page,
+                                          effect->ports[i]->hmi_addressing->subpage, msg);
+                        pthread_mutex_unlock(&g_hmi_mutex);
+                    }
 
-                            effect->ports[i]->hmi_addressing->actuator_id = -1;
-                        }
+                    effect->ports[i]->hmi_addressing->actuator_id = -1;
+                }
 #endif
 
-                        // TODO destroy port mutexes
-                        free(effect->ports[i]->buffer);
-                        lilv_scale_points_free(effect->ports[i]->scale_points);
-                        free(effect->ports[i]);
-                    }
-                }
-                free(effect->ports);
+                // TODO destroy port mutexes
+                free(effect->ports[i]->buffer);
+
+                lilv_scale_points_free(effect->ports[i]->scale_points);
+
+                free(effect->ports[i]);
             }
+        }
+        free(effect->ports);
+    }
 
-            if (effect->properties)
+    if (effect->properties)
+    {
+        for (uint32_t i = 0; i < effect->properties_count; i++)
+        {
+            if (effect->properties[i])
             {
-                for (uint32_t i = 0; i < effect->properties_count; i++)
-                {
-                    if (effect->properties[i])
-                    {
-                        lilv_node_free(effect->properties[i]->uri);
-                        lilv_node_free(effect->properties[i]->type);
-                        free(effect->properties[i]);
-                    }
-                }
-                free(effect->properties);
+                lilv_node_free(effect->properties[i]->uri);
+                lilv_node_free(effect->properties[i]->type);
             }
+        }
 
-            if (effect->lilv_instance)
-                lilv_instance_deactivate(effect->lilv_instance);
-            lilv_instance_free(effect->lilv_instance);
+        for (uint32_t i = 0; i < effect->properties_count; i++)
+            free(effect->properties[i]);
+        free(effect->properties);
+    }
+
+    if (effect->lilv_instance)
+    {
+        if (effect->lv2_activated)
+            lilv_instance_deactivate(effect->lilv_instance);
+
+        lilv_instance_free(effect->lilv_instance);
+    }
 
-            if (effect->jack_client)
-                jack_client_close(effect->jack_client);
+    if (effect->jack_client)
+        jack_client_close(effect->jack_client);
 
-            free(effect->audio_ports);
-            free(effect->input_audio_ports);
-            free(effect->output_audio_ports);
+    free(effect->audio_ports);
+    free(effect->input_audio_ports);
+    free(effect->output_audio_ports);
 
-            free(effect->control_ports);
-            free(effect->input_control_ports);
-            free(effect->output_control_ports);
+    free(effect->control_ports);
+    free(effect->input_control_ports);
+    free(effect->output_control_ports);
 
-            free(effect->cv_ports);
-            free(effect->input_cv_ports);
-            free(effect->output_cv_ports);
+    free(effect->cv_ports);
+    free(effect->input_cv_ports);
+    free(effect->output_cv_ports);
 
-            free(effect->event_ports);
-            free(effect->input_event_ports);
-            free(effect->output_event_ports);
+    free(effect->event_ports);
+    free(effect->input_event_ports);
+    free(effect->output_event_ports);
 
-            if (effect->events_in_buffer)
-                jack_ringbuffer_free(effect->events_in_buffer);
-            if (effect->events_in_buffer_helper)
-                free(effect->events_in_buffer_helper);
-            if (effect->events_out_buffer)
-                jack_ringbuffer_free(effect->events_out_buffer);
+    if (effect->events_in_buffer)
+        jack_ringbuffer_free(effect->events_in_buffer);
+    if (effect->events_in_buffer_helper)
+        free(effect->events_in_buffer_helper);
+    if (effect->events_out_buffer)
+        jack_ringbuffer_free(effect->events_out_buffer);
 
-            if (effect->presets)
+    if (effect->presets)
+    {
+        for (uint32_t i = 0; i < effect->presets_count; i++)
+            lilv_free(effect->presets[i]->uri);
+
+        for (uint32_t i = 0; i < effect->presets_count; i++)
+            free(effect->presets[i]);
+        free(effect->presets);
+    }
+
+    if (effect->hints & HINT_HAS_STATE)
+    {
+        if (g_lv2_scratch_dir != NULL)
+        {
+            // recursively delete state folder
+            char state_filename[g_lv2_scratch_dir != NULL ? PATH_MAX : 1];
+            memset(state_filename, 0, sizeof(state_filename));
+            snprintf(state_filename, PATH_MAX-1, "%s/effect-%d",
+                     g_lv2_scratch_dir, effect->instance);
+            RecursivelyRemovePluginPath(state_filename);
+        }
+
+        if (effect->hints & HINT_STATE_UNSAFE)
+            pthread_mutex_destroy(&effect->state_restore_mutex);
+    }
+
+    InstanceDelete(effect_id);
+}
+
+int effects_remove(int effect_id)
+{
+    int start, end;
+    effect_t *effect;
+
+    // stop postpone events thread
+    if (g_postevents_running == 1)
+    {
+        g_postevents_running = 0;
+        sem_post(&g_postevents_semaphore);
+        zix_thread_join(g_postevents_thread, NULL);
+    }
+
+    // disconnect system ports
+    if (effect_id == REMOVE_ALL)
+    {
+        /* Disconnect the system connections */
+        if (g_capture_ports != NULL)
+        {
+            for (int i = 0; g_capture_ports[i]; i++)
             {
-                for (uint32_t i = 0; i < effect->presets_count; i++)
+                jack_port_t *port = jack_port_by_name(g_jack_global_client, g_capture_ports[i]);
+                if (! port)
+                    continue;
+
+                const char **capture_connections = jack_port_get_connections(port);
+                if (capture_connections)
                 {
-                    lilv_free(effect->presets[i]->uri);
-                    free(effect->presets[i]);
+                    for (int j = 0; capture_connections[j]; j++)
+                    {
+                        if (strstr(capture_connections[j], "system"))
+                            jack_disconnect(g_jack_global_client, g_capture_ports[i], capture_connections[j]);
+                    }
+
+                    jack_free(capture_connections);
                 }
-                free(effect->presets);
             }
+        }
 
-            if (effect->hints & HINT_HAS_STATE)
-            {
-                if (g_lv2_scratch_dir != NULL)
-                {
-                    // recursively delete state folder
-                    memset(state_filename, 0, sizeof(state_filename));
-                    snprintf(state_filename, PATH_MAX-1, "%s/effect-%d",
-                             g_lv2_scratch_dir, effect->instance);
-                    RecursivelyRemovePluginPath(state_filename);
-                }
+        start = 0;
+        end = MAX_PLUGIN_INSTANCES;
 
-                if (effect->hints & HINT_STATE_UNSAFE)
-                    pthread_mutex_destroy(&effect->state_restore_mutex);
-            }
+        // clear all sync scheduled params if removing all plugins
+        pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+        g_sync_scheduled_param_count = 0;
+        pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
+    }
+    else
+    {
+        start = effect_id;
+        end = start + 1;
+
+        // trigger sync scheduled params now for no dangling pointers
+        effect_sync_scheduled_params(false);
+    }
+
+    // stop plugins processing
+    for (int j = start; j < end; j++)
+    {
+        if (InstanceExist(j))
+        {
+            effect = &g_effects[j];
 
-            InstanceDelete(j);
+            if (jack_deactivate(effect->jack_client) != 0)
+                return ERR_JACK_CLIENT_DEACTIVATION;
         }
     }
 
+    // remove addressings, midi learn and other stuff related to plugins
+    effects_remove_inner_pre(effect_id);
+
+    // flush events for all effects except this one
+    if (effect_id != REMOVE_ALL)
+        RunPostPonedEvents(effect_id);
+
+    // now finally cleanup the plugin(s)
+    for (int j = start; j < end; j++)
+    {
+        if (InstanceExist(j))
+            effects_remove_inner_loop(j);
+    }
+
     // clear param_set cache
     effects_set_parameter(-1, NULL, 0.f);
 
@@ -5961,16 +6709,250 @@ int effects_remove(int effect_id)
         }
 
         g_postevents_running = 1;
-        pthread_create(&g_postevents_thread, NULL, PostPonedEventsThread, NULL);
+        zix_thread_create(&g_postevents_thread, 0, PostPonedEventsThread, NULL);
     }
 
     return SUCCESS;
 }
 
-int effects_connect(const char *portA, const char *portB)
+int effects_remove_multi(int num_effects, int *effects)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    if (num_effects == 1)
+        return effects_remove(*effects);
+
+    int num_threads = 0;
+    ZixThread *threads = malloc(sizeof(ZixThread) * num_effects);
+    effect_t *effect;
+
+    if (!threads)
+        return ERR_MEMORY_ALLOCATION;
+
+    // stop postpone events thread
+    if (g_postevents_running == 1)
+    {
+        g_postevents_running = 0;
+        sem_post(&g_postevents_semaphore);
+        zix_thread_join(g_postevents_thread, NULL);
+    }
+
+    // stop plugins processing
+    for (int i = 0, effect_id; i < num_effects; ++i)
+    {
+        effect_id = effects[i];
+        effect = &g_effects[effect_id];
+
+        if (effect->jack_client == NULL)
+            continue;
+
+        if (effect->jack_activated)
+        {
+            if (zix_thread_create(&threads[num_threads], sizeof(void*), effects_deactivate_thread, effect) == 0)
+                ++num_threads;
+            else
+                effects_deactivate_thread(effect);
+        }
+    }
+
+    for (int i = 0; i < num_threads; ++i)
+        zix_thread_join(threads[i], NULL);
+
+    // remove addressings, midi learn and other stuff related to plugins
+    for (int i = 0, effect_id; i < num_effects; ++i)
+    {
+        effect_id = effects[i];
+        if (InstanceExist(effect_id))
+            effects_remove_inner_pre(effect_id);
+    }
+
+    // flush events for all effects
+    RunPostPonedEvents(-3);
+
+    // cleanup the plugins
+    for (int i = 0, effect_id; i < num_effects; ++i)
+    {
+        effect_id = effects[i];
+        if (!InstanceExist(effect_id))
+            continue;
+
+        effects_remove_inner_loop(effect_id);
+    }
+
+    // start thread again
+    if (g_postevents_running == 0)
+    {
+        if (g_verbose_debug)
+        {
+            puts("DEBUG: effects_remove restarted RunPostPonedEvents thread");
+            fflush(stdout);
+        }
+
+        g_postevents_running = 1;
+        zix_thread_create(&g_postevents_thread, 0, PostPonedEventsThread, NULL);
+    }
+
+    free(threads);
+
+    return SUCCESS;
+}
+
+int effects_activate(int effect_id, int value)
+{
+    if (!InstanceExist(effect_id))
+    {
+        return ERR_INSTANCE_NON_EXISTS;
+    }
+
+    effect_t *effect = &g_effects[effect_id];
+
+    if (value)
+    {
+        if (! effect->lv2_activated)
+        {
+            effect->lv2_activated = true;
+            lilv_instance_activate(effect->lilv_instance);
+        }
+
+        if (! effect->jack_activated)
+        {
+            effect->jack_activated = true;
+
+            if (jack_activate(effect->jack_client) != 0)
+            {
+                fprintf(stderr, "can't activate jack_client\n");
+                return ERR_JACK_CLIENT_ACTIVATION;
+            }
+        }
+    }
+    else
+    {
+        if (effect->jack_activated)
+        {
+            effect->jack_activated = false;
+
+            if (jack_deactivate(effect->jack_client) != 0)
+            {
+                fprintf(stderr, "can't deactivate jack_client\n");
+                return ERR_JACK_CLIENT_DEACTIVATION;
+            }
+        }
+
+        if (effect->lv2_activated && ((effect->hints & HINT_NO_PRE_RUN) != 0))
+        {
+            effect->lv2_activated = false;
+            lilv_instance_deactivate(effect->lilv_instance);
+        }
+    }
+
+    return SUCCESS;
+}
+
+static void* effects_activate_thread(void* arg)
+{
+    effect_t *effect = arg;
+
+    if (! effect->lv2_activated)
+    {
+        effect->lv2_activated = true;
+        lilv_instance_activate(effect->lilv_instance);
+    }
+
+    effect->jack_activated = true;
+
+    if (jack_activate(effect->jack_client) != 0)
+        fprintf(stderr, "can't activate jack_client\n");
+
+    return NULL;
+}
+
+static void* effects_deactivate_thread(void* arg)
+{
+    effect_t *effect = arg;
+
+    if (jack_deactivate(effect->jack_client) != 0)
+        fprintf(stderr, "can't deactivate jack_client\n");
+
+    if (effect->lv2_activated && ((effect->hints & HINT_NO_PRE_RUN) != 0))
+    {
+        effect->lv2_activated = false;
+        lilv_instance_deactivate(effect->lilv_instance);
+    }
+
+    effect->jack_activated = false;
+
+    return NULL;
+}
+
+int effects_activate_multi(int value, int num_effects, int *effects)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    if (num_effects == 1)
+        return effects_activate(*effects, value);
+
+    int num_threads = 0;
+    ZixThread *threads = malloc(sizeof(ZixThread) * num_effects);
+
+    if (!threads)
+        return ERR_MEMORY_ALLOCATION;
+
+    effect_t *effect;
+
+    // create threads to activate all clients
+    // reduces time spent waiting for plugin and jack operations to complete, triggering in parallel
+    for (int i = 0, effect_id; i < num_effects; ++i)
+    {
+        effect_id = effects[i];
+        effect = &g_effects[effect_id];
+
+        if (effect->jack_client == NULL)
+            continue;
+
+        if (value)
+        {
+            if (! effect->jack_activated)
+            {
+                if (zix_thread_create(&threads[num_threads], sizeof(void*), effects_activate_thread, effect) == 0)
+                    ++num_threads;
+                else
+                    effects_activate_thread(effect);
+            }
+        }
+        else
+        {
+            if (effect->jack_activated)
+            {
+                if (zix_thread_create(&threads[num_threads], sizeof(void*), effects_deactivate_thread, effect) == 0)
+                    ++num_threads;
+                else
+                    effects_deactivate_thread(effect);
+            }
+        }
+    }
+
+    // wait for all threads to be done
+    for (int i = 0; i < num_threads; ++i)
+        zix_thread_join(threads[i], NULL);
+
+    free(threads);
+
+    return SUCCESS;
+}
+
+int effects_connect(const char *portA, const char *portB, int check)
 {
     int ret;
 
+    if (check != 0)
+    {
+        if (jack_port_by_name(g_jack_global_client, portA) == NULL ||
+            jack_port_by_name(g_jack_global_client, portB) == NULL)
+            return ERR_JACK_PORT_CONNECTION;
+    }
+
     ret = jack_connect(g_jack_global_client, portA, portB);
     if (ret != 0 && ret != EEXIST) ret = jack_connect(g_jack_global_client, portB, portA);
     if (ret == EEXIST) ret = 0;
@@ -5980,10 +6962,38 @@ int effects_connect(const char *portA, const char *portB)
     return ret;
 }
 
-int effects_disconnect(const char *portA, const char *portB)
+int effects_connect_matching(const char *matching, const char *port)
+{
+    const jack_port_t *jport = jack_port_by_name(g_jack_global_client, matching);
+    if (!jport)
+        return ERR_JACK_PORT_CONNECTION;
+
+    const char **jports = jack_port_get_connections(jport);
+    if (jports)
+    {
+        for (int i = 0; jports[i]; ++i)
+            jack_connect(g_jack_global_client, jports[i], port);
+        jack_free(jports);
+    }
+
+    return SUCCESS;
+}
+
+int effects_disconnect(const char *portA, const char *portB, int check)
 {
     int ret;
 
+    if (check != 0)
+    {
+        const jack_port_t *jportA = jack_port_by_name(g_jack_global_client, portA);
+        const jack_port_t *jportB = jack_port_by_name(g_jack_global_client, portB);
+        if (jportA == NULL || jportB == NULL)
+            return ERR_JACK_PORT_CONNECTION;
+
+        if (jack_port_connected(jportA) == 0 || jack_port_connected(jportB) == 0)
+            return ERR_JACK_PORT_CONNECTION;
+    }
+
     ret = jack_disconnect(g_jack_global_client, portA, portB);
     if (ret != 0) ret = jack_disconnect(g_jack_global_client, portB, portA);
     if (ret != 0) return ERR_JACK_PORT_DISCONNECTION;
@@ -5991,6 +7001,16 @@ int effects_disconnect(const char *portA, const char *portB)
     return ret;
 }
 
+int effects_disconnect_all(const char *port)
+{
+    int ret;
+
+    ret = jack_port_disconnect(g_jack_global_client, jack_port_by_name(g_jack_global_client, port));
+    if (ret != 0) return ERR_JACK_PORT_DISCONNECTION;
+
+    return ret;
+}
+
 int effects_set_parameter(int effect_id, const char *control_symbol, float value)
 {
     port_t *port;
@@ -6002,76 +7022,381 @@ int effects_set_parameter(int effect_id, const char *control_symbol, float value
     static enum PortHints *last_hints;
 #endif
 
-    if (InstanceExist(effect_id))
+    if (InstanceExist(effect_id))
+    {
+        // check whether is setting the same parameter
+        if (last_effect_id == effect_id)
+        {
+            if (last_symbol && strcmp(last_symbol, control_symbol) == 0)
+            {
+                if (value < last_min)
+                    value = last_min;
+                else if (value > last_max)
+                    value = last_max;
+
+                *last_buffer = *last_prev = value;
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+                *last_hints |= HINT_SHOULD_UPDATE;
+#endif
+                return SUCCESS;
+            }
+        }
+
+        port = FindEffectInputPortBySymbol(&(g_effects[effect_id]), control_symbol);
+        if (port)
+        {
+            // stores the data of the current control
+            last_effect_id = effect_id;
+            last_min = port->min_value;
+            last_max = port->max_value;
+            last_buffer = port->buffer;
+            last_prev   = &port->prev_value;
+            last_symbol = port->symbol;
+
+            if (value < last_min)
+                value = last_min;
+            else if (value > last_max)
+                value = last_max;
+
+            *last_prev = *last_buffer = value;
+
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+            last_hints = &port->hints;
+            port->hints |= HINT_SHOULD_UPDATE;
+#endif
+            return SUCCESS;
+        }
+
+        last_effect_id = -1;
+        return ERR_LV2_INVALID_PARAM_SYMBOL;
+    }
+
+    last_effect_id = -1;
+    return ERR_INSTANCE_NON_EXISTS;
+}
+
+int effects_set_parameter_multi(const char *control_symbol, float value, int num_effects, int *effects)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    if (num_effects == 1)
+        return effects_set_parameter(*effects, control_symbol, value);
+
+    port_t **ports = malloc(sizeof(port_t*) * num_effects);
+
+    if (ports == NULL)
+        return ERR_MEMORY_ALLOCATION;
+
+    int num_ports = 0;
+    for (int i = 0, effect_id; i < num_effects; i++)
+    {
+        effect_id = effects[i];
+        if (InstanceExist(effect_id))
+        {
+            if ((ports[num_ports] = FindEffectInputPortBySymbol(&(g_effects[effect_id]), control_symbol)))
+                ++num_ports;
+        }
+    }
+
+    // the critical loop, must be as fast and small as possible
+    bool scheduled = true;
+    pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+    if (g_sync_scheduled_param_count + num_ports <= MAX_SYNC_SCHEDULED_PARAMS)
+    {
+        int p = g_sync_scheduled_param_count;
+        for (int i = 0; i < num_ports; i++, p++)
+        {
+            g_sync_scheduled_params[p].port = ports[i];
+            g_sync_scheduled_params[p].value = value;
+        }
+        g_sync_scheduled_param_count = p;
+    }
+    else
+    {
+        scheduled = false;
+    }
+    pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
+
+    if (! scheduled)
+    {
+        // no space to schedule events, trigger param changes now
+        for (int i = 0; i < num_ports; i++)
+        {
+            port_t *port = ports[i];
+            port->prev_value = *port->buffer = value;
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+            port->hints |= HINT_SHOULD_UPDATE;
+#endif
+        }
+    }
+
+    free(ports);
+
+    return SUCCESS;
+}
+
+int effects_get_parameter(int effect_id, const char *control_symbol, float *value)
+{
+    const port_t *port;
+
+    if (InstanceExist(effect_id))
+    {
+        port = FindEffectInputPortBySymbol(&(g_effects[effect_id]), control_symbol);
+        if (port)
+        {
+           *value = *(port->buffer);
+           return SUCCESS;
+        }
+
+        return ERR_LV2_INVALID_PARAM_SYMBOL;
+    }
+
+    return ERR_INSTANCE_NON_EXISTS;
+}
+
+int effects_flush_parameters(int effect_id, int reset, int param_count, const flushed_param_t *params)
+{
+    if (!InstanceExist(effect_id))
+        return ERR_INSTANCE_NON_EXISTS;
+
+    effect_t *effect = &(g_effects[effect_id]);
+    port_t *port;
+
+    if (effect->reset_index >= 0 && reset != 0)
+    {
+        port = effect->ports[effect->reset_index];
+        port->prev_value = *(port->buffer) = reset;
+    }
+
+    for (int i = 0; i < param_count; i++)
+    {
+        port = FindEffectInputPortBySymbol(effect, params[i].symbol);
+        if (port)
+        {
+            port->prev_value = *(port->buffer) = params[i].value;
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+            port->hints |= HINT_SHOULD_UPDATE;
+#endif
+        }
+    }
+
+    // reset a 2nd time in case plugin was processing while we changed parameters
+    if (effect->reset_index >= 0 && reset != 0)
+    {
+        port = effect->ports[effect->reset_index];
+        port->prev_value = *(port->buffer) = reset;
+    }
+
+    return SUCCESS;
+}
+
+int effects_flush_parameters_multi(int reset, int param_count, const flushed_param_t *params, int num_effects, int *effects)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    if (num_effects == 1)
+        return effects_flush_parameters(*effects, reset, param_count, params);
+
+    cached_effect_flush_t *cached_effect;
+    effect_t *effect;
+    port_t *port;
+
+    int num_cached_effects = 0;
+    cached_effect_flush_t *cached_effects = malloc(sizeof(cached_effect_flush_t) * num_effects);
+
+    if (cached_effects == NULL)
+        return ERR_MEMORY_ALLOCATION;
+
+    for (int i = 0, effect_id; i < num_effects; i++)
+    {
+        effect_id = effects[i];
+        if (InstanceExist(effect_id))
+        {
+            effect = &(g_effects[effect_id]);
+
+            if (! effect->lv2_activated)
+            {
+                fprintf(stderr, "multi-param-flush attempted on non-activated plugin #%d\n", effect->instance);
+                continue;
+            }
+
+            cached_effect = &cached_effects[num_cached_effects++];
+            cached_effect->effect = effect;
+            cached_effect->ports = malloc(sizeof(port_t*) * param_count);
+            cached_effect->num_ports = 0;
+
+            for (int j = 0; j < param_count; j++)
+            {
+                if ((cached_effect->ports[cached_effect->num_ports] = FindEffectInputPortBySymbol(effect, params[j].symbol)))
+                    ++cached_effect->num_ports;
+            }
+        }
+    }
+
+    // the critical loop, must be as fast and small as possible
+    bool scheduled = true;
+    const int resetb = reset != 0 ? 1 : 0;
+    pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+    if (g_sync_scheduled_param_count + (param_count + resetb) * num_cached_effects <= MAX_SYNC_SCHEDULED_PARAMS)
+    {
+        int p = g_sync_scheduled_param_count;
+        for (int i = 0; i < num_cached_effects; i++)
+        {
+            cached_effect = &cached_effects[i];
+            effect = cached_effect->effect;
+            for (int j = 0; j < cached_effect->num_ports; j++, p++)
+            {
+                g_sync_scheduled_params[p].port = cached_effect->ports[j];
+                g_sync_scheduled_params[p].value = params[j].value;
+            }
+            if (effect->reset_index >= 0 && reset != 0)
+            {
+                g_sync_scheduled_params[p].port = effect->ports[effect->reset_index];
+                g_sync_scheduled_params[p].value = reset;
+                ++p;
+            }
+        }
+        g_sync_scheduled_param_count = p;
+    }
+    else
+    {
+        scheduled = false;
+    }
+    pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
+
+    if (! scheduled)
     {
-        // check whether is setting the same parameter
-        if (last_effect_id == effect_id)
+        // no space to schedule events, trigger param changes now
+        for (int i = 0; i < num_cached_effects; i++)
         {
-            if (last_symbol && strcmp(last_symbol, control_symbol) == 0)
+            cached_effect = &cached_effects[i];
+            effect = cached_effect->effect;
+            for (int j = 0; j < cached_effect->num_ports; j++)
             {
-                if (value < last_min)
-                    value = last_min;
-                else if (value > last_max)
-                    value = last_max;
-
-                *last_buffer = *last_prev = value;
+                port = cached_effect->ports[j];
+                port->prev_value = *(port->buffer) = params[j].value;
 #ifdef WITH_EXTERNAL_UI_SUPPORT
-                *last_hints |= HINT_SHOULD_UPDATE;
+                port->hints |= HINT_SHOULD_UPDATE;
 #endif
-                return SUCCESS;
+            }
+            if (effect->reset_index >= 0 && reset != 0)
+            {
+                port = effect->ports[effect->reset_index];
+                port->prev_value = *(port->buffer) = reset;
             }
         }
+    }
 
-        port = FindEffectInputPortBySymbol(&(g_effects[effect_id]), control_symbol);
-        if (port)
-        {
-            // stores the data of the current control
-            last_effect_id = effect_id;
-            last_min = port->min_value;
-            last_max = port->max_value;
-            last_buffer = port->buffer;
-            last_prev   = &port->prev_value;
-            last_symbol = port->symbol;
+    for (int i = 0; i < num_cached_effects; i++)
+        free(cached_effects[i].ports);
 
-            if (value < last_min)
-                value = last_min;
-            else if (value > last_max)
-                value = last_max;
+    free(cached_effects);
 
-            *last_prev = *last_buffer = value;
+    return SUCCESS;
+}
+
+int effects_pre_run(int effect_id, int reset, int param_count, const flushed_param_t *params)
+{
+    if (!InstanceExist(effect_id))
+        return ERR_INSTANCE_NON_EXISTS;
+
+    effect_t *effect = &(g_effects[effect_id]);
+    port_t *port;
 
+    for (int i = 0; i < param_count; i++)
+    {
+        port = FindEffectInputPortBySymbol(effect, params[i].symbol);
+        if (port)
+        {
+            port->prev_value = *(port->buffer) = params[i].value;
 #ifdef WITH_EXTERNAL_UI_SUPPORT
-            last_hints = &port->hints;
             port->hints |= HINT_SHOULD_UPDATE;
 #endif
-            return SUCCESS;
         }
+    }
 
-        last_effect_id = -1;
-        return ERR_LV2_INVALID_PARAM_SYMBOL;
+    if (effect->reset_index >= 0 && reset != 0)
+    {
+        port = effect->ports[effect->reset_index];
+        port->prev_value = *(port->buffer) = reset;
     }
 
-    last_effect_id = -1;
-    return ERR_INSTANCE_NON_EXISTS;
+    if ((effect->hints & HINT_NO_PRE_RUN) != 0)
+        return SUCCESS;
+
+    if (effect->jack_activated && ((effect->hints & HINT_IS_LIVE) != 0 || g_processing_enabled))
+    {
+        fprintf(stderr, "pre-run attempted on jack-activated instance #%d\n", effect_id);
+        return ERR_INVALID_OPERATION;
+    }
+    if (! effect->lv2_activated)
+    {
+        fprintf(stderr, "pre-run attempted on non lv2-activated instance #%d\n", effect_id);
+        return ERR_INVALID_OPERATION;
+    }
+
+    PreRunPlugin(effect);
+
+    return SUCCESS;
 }
 
-int effects_get_parameter(int effect_id, const char *control_symbol, float *value)
+int effects_pre_run_multi(int reset, int param_count, const flushed_param_t *params, int num_effects, int *effects)
 {
-    const port_t *port;
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
 
-    if (InstanceExist(effect_id))
+    if (num_effects == 1)
+        return effects_pre_run(*effects, reset, param_count, params);
+
+    effect_t *effect;
+    port_t *port;
+
+    for (int i = 0, effect_id; i < num_effects; i++)
     {
-        port = FindEffectInputPortBySymbol(&(g_effects[effect_id]), control_symbol);
-        if (port)
+        effect_id = effects[i];
+        if (InstanceExist(effect_id))
         {
-           (*value) = *(port->buffer);
-           return SUCCESS;
-        }
+            effect = &(g_effects[effect_id]);
 
-        return ERR_LV2_INVALID_PARAM_SYMBOL;
+            for (int j = 0; j < param_count; j++)
+            {
+                port = FindEffectInputPortBySymbol(effect, params[j].symbol);
+
+                if (port)
+                {
+                    port->prev_value = *(port->buffer) = params[j].value;
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+                    port->hints |= HINT_SHOULD_UPDATE;
+#endif
+                }
+                if (effect->reset_index >= 0 && reset != 0)
+                {
+                    port = effect->ports[effect->reset_index];
+                    port->prev_value = *(port->buffer) = reset;
+                }
+            }
+
+            if (effect->jack_activated && ((effect->hints & HINT_IS_LIVE) != 0 || g_processing_enabled))
+            {
+                fprintf(stderr, "multi-pre-run attempted on jack-activated instance #%d\n", effect->instance);
+                continue;
+            }
+            if (! effect->lv2_activated)
+            {
+                fprintf(stderr, "multi-pre-run attempted on non lv2-activated instance #%d\n", effect->instance);
+                continue;
+            }
+
+            if ((effect->hints & HINT_NO_PRE_RUN) != 0)
+                continue;
+
+            PreRunPlugin(effect);
+        }
     }
 
-    return ERR_INSTANCE_NON_EXISTS;
+    return SUCCESS;
 }
 
 static inline
@@ -6464,7 +7789,7 @@ int effects_monitor_parameter(int effect_id, const char *control_symbol, const c
     return SUCCESS;
 }
 
-int effects_monitor_output_parameter(int effect_id, const char *control_symbol_or_uri)
+int effects_monitor_output_parameter(int effect_id, const char *control_symbol_or_uri, int enable)
 {
     port_t *port;
 
@@ -6476,12 +7801,48 @@ int effects_monitor_output_parameter(int effect_id, const char *control_symbol_o
 
     if (port != NULL)
     {
+        if (enable == 0)
+        {
+            // check if not monitored
+            if ((port->hints & HINT_MONITORED) == 0)
+                return SUCCESS;
+
+            // remove monitored flag
+            port->hints &= ~HINT_MONITORED;
+
+            // stop postpone events thread
+            if (g_postevents_running == 1)
+            {
+                g_postevents_running = 0;
+                sem_post(&g_postevents_semaphore);
+                zix_thread_join(g_postevents_thread, NULL);
+            }
+
+            // flush events for all effects except this one
+            RunPostPonedEvents(effect_id);
+
+            // start thread again
+            if (g_postevents_running == 0)
+            {
+                if (g_verbose_debug)
+                {
+                    puts("DEBUG: effects_monitor_output_parameter restarted RunPostPonedEvents thread");
+                    fflush(stdout);
+                }
+
+                g_postevents_running = 1;
+                zix_thread_create(&g_postevents_thread, 0, PostPonedEventsThread, NULL);
+            }
+
+            return SUCCESS;
+        }
+
         // check if already monitored
         if (port->hints & HINT_MONITORED)
             return SUCCESS;
 
         // set prev_value
-        port->prev_value = (*port->buffer);
+        port->prev_value = *(port->buffer);
         port->hints |= HINT_MONITORED;
 
         // simulate an output monitor event here, to report current value
@@ -6508,7 +7869,7 @@ int effects_monitor_output_parameter(int effect_id, const char *control_symbol_o
         if (property == NULL)
             return ERR_LV2_INVALID_PARAM_SYMBOL;
 
-        property->monitored = true;
+        property->monitored = enable != 0;
     }
 
     // activate output monitor
@@ -6529,7 +7890,37 @@ int effects_bypass(int effect_id, int value)
 
     if (effect->enabled_index >= 0)
     {
-        *(effect->ports[effect->enabled_index]->buffer) = value ? 0.0f : 1.0f;
+        port_t *port = effect->ports[effect->enabled_index];
+        port->prev_value = *port->buffer = value ? 0.0f : 1.0f;
+    }
+
+    return SUCCESS;
+}
+
+int effects_bypass_multi(int value, int num_effects, int *effects)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    effect_t *effect;
+    port_t *port;
+    float bypass_value = value ? 1.0f : 0.0f;
+    float enabled_value = value ? 0.0f : 1.0f;
+
+    for (int i = 0, effect_id; i < num_effects; i++)
+    {
+        effect_id = effects[i];
+        if (InstanceExist(effect_id))
+        {
+            effect = &g_effects[effect_id];
+            effect->bypass_port.prev_value = bypass_value;
+
+            if (effect->enabled_index >= 0)
+            {
+                port = effect->ports[effect->enabled_index];
+                port->prev_value = *port->buffer = enabled_value;
+            }
+        }
     }
 
     return SUCCESS;
@@ -6861,7 +8252,7 @@ int effects_licensee(int effect_id, char **licensee_ptr)
 int effects_set_beats_per_minute(double bpm)
 {
   int result = SUCCESS;
-  if ((20.0 <= bpm) && (bpm <= 280.0)) {
+  if ((20.0 <= bpm) && (bpm <= 300.0)) {
     // Change the current global value and set a flag that it was changed.
     g_transport_bpm = bpm;
     g_transport_reset = true;
@@ -7469,7 +8860,7 @@ int effects_cv_unmap(int effect_id, const char *control_symbol)
 int effects_hmi_map(int effect_id, const char *control_symbol, int hw_id, int page, int subpage,
                     int caps, int flags, const char *label, float minimum, float maximum, int steps)
 {
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
     if (!InstanceExist(effect_id))
         return ERR_INSTANCE_NON_EXISTS;
     if (effect_id >= MAX_PLUGIN_INSTANCES)
@@ -7561,7 +8952,7 @@ int effects_hmi_map(int effect_id, const char *control_symbol, int hw_id, int pa
 
 int effects_hmi_unmap(int effect_id, const char *control_symbol)
 {
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
     if (!InstanceExist(effect_id))
         return ERR_INSTANCE_NON_EXISTS;
 
@@ -7623,6 +9014,15 @@ float effects_jack_cpu_load(void)
     return jack_cpu_load(g_jack_global_client);
 }
 
+float effects_jack_max_cpu_load(void)
+{
+#ifdef HAVE_JACK2_1_9_23
+    return jack_max_cpu_load(g_jack_global_client);
+#else
+    return jack_cpu_load(g_jack_global_client);
+#endif
+}
+
 #define OS_SEP '/'
 
 void effects_bundle_add(const char* bpath)
@@ -7732,7 +9132,7 @@ int effects_state_load(const char *dir)
         &g_urid_map_feature,
         &g_urid_unmap_feature,
         &g_options_feature,
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
         &g_hmi_wc_feature,
 #endif
         &g_license_feature,
@@ -7743,6 +9143,7 @@ int effects_state_load(const char *dir)
         &g_state_freePath_feature,
         &feature_makePath,
         NULL, // ctrlPortReq
+        NULL, // ctrlPortStateUpdate
         NULL, // worker
         NULL
     };
@@ -7772,6 +9173,7 @@ int effects_state_load(const char *dir)
 
         makePath.handle = effect;
         features[CTRLPORT_REQUEST_FEATURE] = effect->features[CTRLPORT_REQUEST_FEATURE];
+        features[CTRLPORT_STATE_FEATURE] = effect->features[CTRLPORT_STATE_FEATURE];
         features[WORKER_FEATURE] = effect->features[WORKER_FEATURE];
 
         if (effect->hints & HINT_STATE_UNSAFE)
@@ -7825,7 +9227,7 @@ int effects_state_save(const char *dir)
         &g_urid_map_feature,
         &g_urid_unmap_feature,
         &g_options_feature,
-#ifdef __MOD_DEVICES__
+#ifdef MOD_HMI_CONTROL_ENABLED
         &g_hmi_wc_feature,
 #endif
         &g_license_feature,
@@ -7836,6 +9238,7 @@ int effects_state_save(const char *dir)
         &g_state_freePath_feature,
         &feature_makePath,
         NULL, // ctrlPortReq
+        NULL, // ctrlPortStateUpdate
         NULL, // worker
         NULL
     };
@@ -7859,6 +9262,7 @@ int effects_state_save(const char *dir)
 
             makePath.handle = effect;
             features[CTRLPORT_REQUEST_FEATURE] = effect->features[CTRLPORT_REQUEST_FEATURE];
+            features[CTRLPORT_STATE_FEATURE] = effect->features[CTRLPORT_STATE_FEATURE];
             features[WORKER_FEATURE] = effect->features[WORKER_FEATURE];
 
             effect->state_dir = dir;
@@ -8030,6 +9434,16 @@ int effects_aggregated_midi_enable(int enable)
     return SUCCESS;
 }
 
+int effects_cpu_load_enable(int enable)
+{
+    if (g_jack_global_client == NULL)
+        return ERR_INVALID_OPERATION;
+
+    g_cpu_load_enabled = enable != 0;
+    effects_output_data_ready();
+    return SUCCESS;
+}
+
 int effects_freewheeling_enable(int enable)
 {
     if (g_jack_global_client == NULL)
@@ -8043,15 +9457,162 @@ int effects_freewheeling_enable(int enable)
 
 int effects_processing_enable(int enable)
 {
-    g_processing_enabled = enable;
+    switch (enable)
+    {
+    // regular on/off
+    case 0:
+    case 1:
+        if (g_processing_enabled && enable == 0)
+        {
+            g_processing_enabled = false;
+            monitor_client_wait_proc();
+        }
+        else
+        {
+            g_processing_enabled = enable != 0;
+        }
+        break;
 
-    if (enable > 1) {
+    // turn on while reporting feedback data ready
+    case 2:
+        g_processing_enabled = true;
         effects_output_data_ready();
+        break;
+
+    // use fade-out while turning off
+    case -1:
+        monitor_client_setup_volume(MOD_MONITOR_VOLUME_MUTE);
+        if (g_processing_enabled)
+        {
+            monitor_client_wait_volume();
+            g_processing_enabled = false;
+            monitor_client_wait_proc();
+        }
+        break;
+
+    // don't use fade-out while turning off, mute right away
+    case -2:
+        monitor_client_setup_volume(MOD_MONITOR_VOLUME_MUTE);
+        monitor_client_flush_volume();
+        g_processing_enabled = false;
+        break;
+
+    // use fade-in while turning on
+    case 3:
+        g_processing_enabled = true;
+        monitor_client_setup_volume(0.f);
+        break;
+
+    default:
+        return ERR_INVALID_OPERATION;
+    }
+
+    return SUCCESS;
+}
+
+int effects_monitor_audio_levels(const char *source_port_name, int enable)
+{
+    if (g_jack_global_client == NULL)
+        return ERR_INVALID_OPERATION;
+
+    if (enable)
+    {
+        for (int i = 0; i < g_audio_monitor_count; ++i)
+        {
+            if (!strcmp(g_audio_monitors[i].source_port_name, source_port_name))
+                return SUCCESS;
+        }
+
+        pthread_mutex_lock(&g_audio_monitor_mutex);
+        g_audio_monitors = realloc(g_audio_monitors, sizeof(audio_monitor_t) * (g_audio_monitor_count + 1));
+        pthread_mutex_unlock(&g_audio_monitor_mutex);
+
+        if (g_audio_monitors == NULL)
+            return ERR_MEMORY_ALLOCATION;
+
+        audio_monitor_t *monitor = &g_audio_monitors[g_audio_monitor_count];
+
+        char port_name[0xff];
+        snprintf(port_name, sizeof(port_name) - 1, "monitor_%d", g_audio_monitor_count + 1);
+
+        jack_port_t *port = jack_port_register(g_jack_global_client,
+                                               port_name,
+                                               JACK_DEFAULT_AUDIO_TYPE,
+                                               JackPortIsInput,
+                                               0);
+        if (port == NULL)
+            return ERR_JACK_PORT_REGISTER;
+
+        snprintf(port_name, sizeof(port_name) - 1, "%s:monitor_%d",
+                 jack_get_client_name(g_jack_global_client), g_audio_monitor_count + 1);
+        jack_connect(g_jack_global_client, source_port_name, port_name);
+
+        monitor->port = port;
+        monitor->source_port_name = strdup(source_port_name);
+        monitor->value = 0.f;
+
+        ++g_audio_monitor_count;
+    }
+    else
+    {
+        if (g_audio_monitor_count == 0)
+            return ERR_INVALID_OPERATION;
+
+        audio_monitor_t *monitor = &g_audio_monitors[g_audio_monitor_count - 1];
+
+        if (strcmp(monitor->source_port_name, source_port_name))
+            return ERR_INVALID_OPERATION;
+
+        pthread_mutex_lock(&g_audio_monitor_mutex);
+        --g_audio_monitor_count;
+        pthread_mutex_unlock(&g_audio_monitor_mutex);
+
+        jack_port_unregister(g_jack_global_client, monitor->port);
+        free(monitor->source_port_name);
+
+        if (g_audio_monitor_count == 0)
+        {
+            free(g_audio_monitors);
+            g_audio_monitors = NULL;
+        }
+    }
+
+    return SUCCESS;
+}
+
+int effects_monitor_cpu_load(int enable, int num_effects, int *effects)
+{
+    if (num_effects <= 0)
+        return ERR_INVALID_OPERATION;
+
+    effect_t *effect;
+
+    for (int i = 0, effect_id; i < num_effects; i++)
+    {
+        effect_id = effects[i];
+        if (InstanceExist(effect_id))
+        {
+            effect = &g_effects[effect_id];
+
+            if (enable != 0)
+                effect->monitor_cpu_reset = true;
+
+            effect->monitor_cpu = enable != 0;
+        }
     }
 
     return SUCCESS;
 }
 
+int effects_monitor_midi_control(int channel, int enable)
+{
+    if (channel < 0 || channel > 15)
+        return ERR_INVALID_OPERATION;
+
+    g_monitored_midi_controls[channel] = enable != 0;
+    return SUCCESS;
+}
+
 int effects_monitor_midi_program(int channel, int enable)
 {
     if (channel < 0 || channel > 15)
@@ -8170,6 +9731,33 @@ int effects_transport_sync_mode(const char* mode)
     return SUCCESS;
 }
 
+void effect_sync_scheduled_params(int realtime)
+{
+    port_t *port;
+
+    if (realtime != 0)
+    {
+        if (pthread_mutex_trylock(&g_sync_scheduled_params_mutex) != 0)
+            return;
+    }
+    else
+    {
+        pthread_mutex_lock(&g_sync_scheduled_params_mutex);
+    }
+
+    for (unsigned int i = 0; i < g_sync_scheduled_param_count; i++)
+    {
+        port = g_sync_scheduled_params[i].port;
+        port->prev_value = *port->buffer = g_sync_scheduled_params[i].value;
+#ifdef WITH_EXTERNAL_UI_SUPPORT
+        port->hints |= HINT_SHOULD_UPDATE;
+#endif
+    }
+
+    g_sync_scheduled_param_count = 0;
+    pthread_mutex_unlock(&g_sync_scheduled_params_mutex);
+}
+
 void effects_output_data_ready(void)
 {
     if (g_verbose_debug) {
@@ -8180,6 +9768,20 @@ void effects_output_data_ready(void)
 
     if (! g_postevents_ready)
     {
+        // recalculate max cpu usage again
+        for (int i = 0; i < MAX_PLUGIN_INSTANCES; ++i)
+        {
+            effect_t *effect = &g_effects[i];
+
+            if (effect->lilv_instance == NULL)
+                continue;
+            if (effect->lilv_plugin == NULL)
+                continue;
+
+            if (effect->monitor_cpu)
+                effect->monitor_cpu_reset = true;
+        }
+
         g_postevents_ready = true;
         sem_post(&g_postevents_semaphore);
     }
@@ -8207,7 +9809,7 @@ int effects_show_external_ui(int effect_id)
         const LilvNode *binary_node = lilv_ui_get_binary_uri(ui);
         const LilvNode *bundle_node = lilv_ui_get_bundle_uri(ui);
 
-        void *libhandle = dlopen(lilv_uri_to_path(lilv_node_as_string(binary_node)), RTLD_NOW|RTLD_LOCAL);
+        void *libhandle = dlopen(lilv_file_uri_parse(lilv_node_as_string(binary_node), NULL), RTLD_NOW|RTLD_LOCAL);
         if (libhandle == NULL)
             continue;
 
@@ -8219,7 +9821,7 @@ int effects_show_external_ui(int effect_id)
         uint32_t index = 0;
 
         LV2UI_DescriptorFunction descfn;
-        if ((descfn = dlsym(libhandle, "lv2ui_descriptor")) == NULL)
+        if ((descfn = (LV2UI_DescriptorFunction)dlsym(libhandle, "lv2ui_descriptor")) == NULL)
             goto cleanup;
 
         while ((desc = descfn(index++)) != NULL)
@@ -8254,7 +9856,7 @@ int effects_show_external_ui(int effect_id)
             LV2UI_Widget widget;
             handle = desc->instantiate(desc,
                                        lilv_node_as_uri(lilv_plugin_get_uri(effect->lilv_plugin)),
-                                       lilv_uri_to_path(lilv_node_as_string(bundle_node)),
+                                       lilv_file_uri_parse(lilv_node_as_string(bundle_node), NULL),
                                        ExternalControllerWriteFunction,
                                        effect, &widget, features);
 
diff --git a/src/effects.h b/src/effects.h
index c0adebe..9cb4d2f 100644
--- a/src/effects.h
+++ b/src/effects.h
@@ -97,6 +97,8 @@ typedef enum {
 #define MAX_POSTPONED_EVENTS    8192
 #define MAX_HMI_ADDRESSINGS     128
 
+#define MAX_SYNC_SCHEDULED_PARAMS 512
+
 // used for local stack variables
 #define MAX_CHAR_BUF_SIZE       255
 
@@ -112,6 +114,11 @@ typedef struct {
     float value;
 } scalepoint_t;
 
+typedef struct {
+    const char *symbol;
+    float value;
+} flushed_param_t;
+
 
 /*
 ************************************************************************************************************************
@@ -135,20 +142,32 @@ typedef struct {
 
 int effects_init(void* client);
 int effects_finish(int close_client);
-int effects_add(const char *uri, int instance);
+int effects_add(const char *uri, int instance, int activate);
+int effects_add_multi(int activate, int num_effects, int *effects, const char *const *uris);
 int effects_remove(int effect_id);
+int effects_remove_multi(int num_effects, int *effects);
+int effects_activate(int effect_id, int value);
+int effects_activate_multi(int value, int num_effects, int *effects);
 int effects_preset_load(int effect_id, const char *uri);
 int effects_preset_save(int effect_id, const char *dir, const char *file_name, const char *label);
 int effects_preset_show(const char *uri, char **state_str);
-int effects_connect(const char *portA, const char *portB);
-int effects_disconnect(const char *portA, const char *portB);
+int effects_connect(const char *portA, const char *portB, int check);
+int effects_connect_matching(const char *matching, const char *port);
+int effects_disconnect(const char *portA, const char *portB, int check);
+int effects_disconnect_all(const char *port);
 int effects_set_parameter(int effect_id, const char *control_symbol, float value);
+int effects_set_parameter_multi(const char *control_symbol, float value, int num_effects, int *effects);
 int effects_get_parameter(int effect_id, const char *control_symbol, float *value);
+int effects_flush_parameters(int effect_id, int reset, int param_count, const flushed_param_t *params);
+int effects_flush_parameters_multi(int reset, int param_count, const flushed_param_t *params, int num_effects, int *effects);
+int effects_pre_run(int effect_id, int reset, int param_count, const flushed_param_t *params);
+int effects_pre_run_multi(int reset, int param_count, const flushed_param_t *params, int num_effects, int *effects);
 int effects_set_property(int effect_id, const char *uri, const char *value);
 int effects_get_property(int effect_id, const char *uri);
 int effects_monitor_parameter(int effect_id, const char *control_symbol, const char *op, float value);
-int effects_monitor_output_parameter(int effect_id, const char *control_symbol);
+int effects_monitor_output_parameter(int effect_id, const char *control_symbol, int enable);
 int effects_bypass(int effect_id, int value);
+int effects_bypass_multi(int value, int num_effects, int *effects);
 int effects_get_parameter_symbols(int effect_id, int output_ports, const char** symbols);
 int effects_get_presets_uris(int effect_id, const char **uris);
 int effects_get_parameter_info(int effect_id, const char *control_symbol, float **range, const char **scale_points);
@@ -173,17 +192,23 @@ int effects_hmi_map(int effect_id, const char *control_symbol, int hw_id, int pa
 int effects_hmi_unmap(int effect_id, const char *control_symbol);
 
 float effects_jack_cpu_load(void);
+float effects_jack_max_cpu_load(void);
 void effects_bundle_add(const char *bundlepath);
 void effects_bundle_remove(const char *bundlepath, const char *resource);
 int effects_state_load(const char *dir);
 int effects_state_save(const char *dir);
 int effects_state_set_tmpdir(const char *dir);
 int effects_aggregated_midi_enable(int enable);
+int effects_cpu_load_enable(int enable);
 int effects_freewheeling_enable(int enable);
 int effects_processing_enable(int enable);
+int effects_monitor_audio_levels(const char *source_port_name, int enable);
+int effects_monitor_cpu_load(int enable, int num_effects, int *effects);
+int effects_monitor_midi_control(int channel, int enable);
 int effects_monitor_midi_program(int channel, int enable);
 void effects_transport(int rolling, double beats_per_bar, double beats_per_minute);
 int effects_transport_sync_mode(const char *mode);
+void effect_sync_scheduled_params(int realtime);
 void effects_output_data_ready(void);
 int effects_show_external_ui(int effect_id);
 void effects_idle_external_uis(void);
diff --git a/src/lv2/control-port-state-update.h b/src/lv2/control-port-state-update.h
new file mode 100644
index 0000000..8c07b1e
--- /dev/null
+++ b/src/lv2/control-port-state-update.h
@@ -0,0 +1,90 @@
+/*
+  LV2 Control Port State Update extension
+  Copyright 2025 Darkglass Electronics
+
+  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 control-port-state-update.h
+   C header for the LV2 Control Port State Update extension <http://www.darkglass.com/lv2/ns/lv2ext/control-port-state-update>.
+*/
+
+#ifndef LV2_CONTROL_PORT_STATE_UPDATE_H
+#define LV2_CONTROL_PORT_STATE_UPDATE_H
+
+#include <lv2/core/lv2.h>
+
+#define LV2_CONTROL_PORT_STATE_UPDATE_URI    "http://www.darkglass.com/lv2/ns/lv2ext/control-port-state-update"
+#define LV2_CONTROL_PORT_STATE_UPDATE_PREFIX LV2_CONTROL_PORT_STATE_UPDATE_URI "#"
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+/** A status code for LV2_CONTROL_PORT_STATE_UPDATE_URI functions. */
+typedef enum {
+	LV2_CONTROL_PORT_STATE_UPDATE_SUCCESS           = 0,  /**< Completed successfully. */
+	LV2_CONTROL_PORT_STATE_UPDATE_ERR_UNKNOWN       = 1,  /**< Unknown error. */
+	LV2_CONTROL_PORT_STATE_UPDATE_ERR_INVALID_INDEX = 2   /**< Failed due to invalid port index. */
+} LV2_Control_Port_State_Update_Status;
+
+/** A control port state plugin can report to host. */
+typedef enum {
+	LV2_CONTROL_PORT_STATE_NONE     = 0,  /**< No special state / Remove any previously set states. */
+	LV2_CONTROL_PORT_STATE_INACTIVE = 1,  /**< Inactive state (updates to port value are inaudible / ineffective). */
+	LV2_CONTROL_PORT_STATE_BLOCKED  = 2   /**< Blocked state (updates to port value are ignored by the plugin and they should be blocked and ignored by the host). */
+} LV2_Control_Port_State;
+
+/**
+ *  Opaque handle for LV2_CONTROL_PORT_STATE_UPDATE_URI feature.
+ */
+typedef void* LV2_Control_Port_State_Update_Handle;
+
+/**
+ * On instantiation, host must supply LV2_CONTROL_PORT_STATE_UPDATE_URI feature.
+ * LV2_Feature::data must be pointer to LV2_Control_Port_State_Update.
+*/
+typedef struct _LV2_Control_Port_State_Update {
+    /**
+     *  Opaque host data.
+     */
+    LV2_Control_Port_State_Update_Handle handle;
+
+    /**
+     * update_state()
+     *
+     * Ask the host to change a plugin's control port's state.
+     * Parameter handle MUST be the 'handle' member of this struct.
+     * Parameter index is port index to change.
+     * Parameter state is the new state of the control port.
+     *
+     * Returns status of update.
+     *
+     * The plugin MUST call this function during run().
+     */
+    LV2_Control_Port_State_Update_Status (*update_state)(LV2_Control_Port_State_Update_Handle handle,
+                                                         uint32_t index,
+                                                         LV2_Control_Port_State state);
+
+} LV2_Control_Port_State_Update;
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LV2_CONTROL_PORT_STATE_UPDATE_H */
diff --git a/src/lv2/kxstudio-properties.h b/src/lv2/kxstudio-properties.h
new file mode 100644
index 0000000..68dbe66
--- /dev/null
+++ b/src/lv2/kxstudio-properties.h
@@ -0,0 +1,34 @@
+/*
+  LV2 KXStudio Properties Extension
+  Copyright 2014-2024 Filipe Coelho <falktx@falktx.com>
+
+  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 lv2_kxstudio_properties.h
+   C header for the LV2 KXStudio Properties extension <http://kxstudio.sf.net/ns/lv2ext/props>.
+*/
+
+#ifndef LV2_KXSTUDIO_PROPERTIES_H
+#define LV2_KXSTUDIO_PROPERTIES_H
+
+#define LV2_KXSTUDIO_PROPERTIES_URI    "http://kxstudio.sf.net/ns/lv2ext/props"
+#define LV2_KXSTUDIO_PROPERTIES_PREFIX LV2_KXSTUDIO_PROPERTIES_URI "#"
+
+#define LV2_KXSTUDIO_PROPERTIES__NonAutomatable           LV2_KXSTUDIO_PROPERTIES_PREFIX "NonAutomatable"
+#define LV2_KXSTUDIO_PROPERTIES__Reset                    LV2_KXSTUDIO_PROPERTIES_PREFIX "Reset"
+#define LV2_KXSTUDIO_PROPERTIES__TimePositionTicksPerBeat LV2_KXSTUDIO_PROPERTIES_PREFIX "TimePositionTicksPerBeat"
+#define LV2_KXSTUDIO_PROPERTIES__TransientWindowId        LV2_KXSTUDIO_PROPERTIES_PREFIX "TransientWindowId"
+
+#endif /* LV2_KXSTUDIO_PROPERTIES_H */
diff --git a/src/mod-host.c b/src/mod-host.c
index 4b4d5d9..e5bb514 100644
--- a/src/mod-host.c
+++ b/src/mod-host.c
@@ -33,12 +33,14 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <string.h>
-#include <unistd.h>
 #include <getopt.h>
 #include <jack/jack.h>
-#include <pthread.h>
 #include <signal.h>
 
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
 #ifndef SKIP_READLINE
 #include <readline/readline.h>
 #include <readline/history.h>
@@ -58,12 +60,22 @@
 #define lilv_free(x) free(x)
 #endif
 
+#if defined(_MOD_DEVICE_RK358x)
+#include <sys/resource.h>
+#elif defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+#include <sys/resource.h>
+#include <syscall.h>
+#include <unistd.h>
+#endif
+
 #include "mod-host.h"
 #include "effects.h"
 #include "socket.h"
 #include "protocol.h"
 #include "completer.h"
 #include "monitor.h"
+#include "monitor/monitor-client.h"
+#include "zix/thread.h"
 #include "info.h"
 
 
@@ -85,7 +97,7 @@
 /* Wherever we should be running */
 static volatile int running;
 /* Thread that calls socket_run() for the JACK internal client */
-static pthread_t intclient_socket_thread;
+static ZixThread intclient_socket_thread;
 
 /*
 ************************************************************************************************************************
@@ -131,7 +143,7 @@ static pthread_t intclient_socket_thread;
 static void effects_add_cb(proto_t *proto)
 {
     int resp;
-    resp = effects_add(proto->list[1], atoi(proto->list[2]));
+    resp = effects_add(proto->list[1], atoi(proto->list[2]), 1);
     protocol_response_int(resp, proto);
 }
 
@@ -142,6 +154,20 @@ static void effects_remove_cb(proto_t *proto)
     protocol_response_int(resp, proto);
 }
 
+static void effects_activate_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_activate(atoi(proto->list[1]), atoi(proto->list[2]));
+    protocol_response_int(resp, proto);
+}
+
+static void effects_preload_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_add(proto->list[1], atoi(proto->list[2]), 0);
+    protocol_response_int(resp, proto);
+}
+
 static void effects_preset_save_cb(proto_t *proto)
 {
     int resp;
@@ -174,14 +200,42 @@ static void effects_preset_show_cb(proto_t *proto)
 static void effects_connect_cb(proto_t *proto)
 {
     int resp;
-    resp = effects_connect(proto->list[1], proto->list[2]);
+    resp = effects_connect(proto->list[1], proto->list[2], 0);
+    protocol_response_int(resp, proto);
+}
+
+static void effects_connect_matching_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_connect_matching(proto->list[1], proto->list[2]);
+    protocol_response_int(resp, proto);
+}
+
+static void effects_connect_safe_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_connect(proto->list[1], proto->list[2], 1);
     protocol_response_int(resp, proto);
 }
 
 static void effects_disconnect_cb(proto_t *proto)
 {
     int resp;
-    resp = effects_disconnect(proto->list[1], proto->list[2]);
+    resp = effects_disconnect(proto->list[1], proto->list[2], 0);
+    protocol_response_int(resp, proto);
+}
+
+static void effects_disconnect_all_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_disconnect_all(proto->list[1]);
+    protocol_response_int(resp, proto);
+}
+
+static void effects_disconnect_safe_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_disconnect(proto->list[1], proto->list[2], 1);
     protocol_response_int(resp, proto);
 }
 
@@ -226,6 +280,72 @@ static void effects_monitor_param_cb(proto_t *proto)
     protocol_response_int(resp, proto);
 }
 
+static void effects_flush_params_cb(proto_t *proto)
+{
+    int resp;
+    int param_count = atoi(proto->list[3]);
+    flushed_param_t *params;
+
+    if (param_count != 0)
+    {
+        params = malloc(sizeof(flushed_param_t) * param_count);
+
+        if (params == NULL)
+        {
+            protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+            return;
+        }
+
+        for (int i = 0; i < param_count; i++)
+        {
+            params[i].symbol = proto->list[4 + i * 2];
+            params[i].value = atof(proto->list[5 + i * 2]);
+        }
+    }
+    else
+    {
+        params = NULL;
+    }
+
+    resp = effects_flush_parameters(atoi(proto->list[1]), atoi(proto->list[2]), param_count, params);
+    protocol_response_int(resp, proto);
+
+    free(params);
+}
+
+static void effects_pre_run_cb(proto_t *proto)
+{
+    int resp;
+    int param_count = atoi(proto->list[3]);
+    flushed_param_t *params;
+
+    if (param_count != 0)
+    {
+        params = malloc(sizeof(flushed_param_t) * param_count);
+
+        if (params == NULL)
+        {
+            protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+            return;
+        }
+
+        for (int i = 0; i < param_count; i++)
+        {
+            params[i].symbol = proto->list[4 + i * 2];
+            params[i].value = atof(proto->list[5 + i * 2]);
+        }
+    }
+    else
+    {
+        params = NULL;
+    }
+
+    resp = effects_pre_run(atoi(proto->list[1]), atoi(proto->list[2]), param_count, params);
+    protocol_response_int(resp, proto);
+
+    free(params);
+}
+
 static void effects_set_property_cb(proto_t *proto)
 {
     int resp;
@@ -293,7 +413,56 @@ static void monitor_addr_set_cb(proto_t *proto)
 static void monitor_output_cb(proto_t *proto)
 {
     int resp;
-    resp = !effects_monitor_output_parameter(atoi(proto->list[1]), proto->list[2]);
+    resp = !effects_monitor_output_parameter(atoi(proto->list[1]), proto->list[2], 1);
+    protocol_response_int(resp, proto);
+}
+
+static void monitor_output_off_cb(proto_t *proto)
+{
+    int resp;
+    resp = !effects_monitor_output_parameter(atoi(proto->list[1]), proto->list[2], 0);
+    protocol_response_int(resp, proto);
+}
+
+static void monitor_audio_levels_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_monitor_audio_levels(proto->list[1], atoi(proto->list[2]));
+    protocol_response_int(resp, proto);
+}
+
+static void monitor_cpu_load_cb(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[2]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[3 + i]);
+    }
+    else
+    {
+        free(instances);
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_monitor_cpu_load(atoi(proto->list[1]), instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+}
+
+static void monitor_midi_control_cb(proto_t *proto)
+{
+    int resp;
+    resp = effects_monitor_midi_control(atoi(proto->list[1]), atoi(proto->list[2]));
     protocol_response_int(resp, proto);
 }
 
@@ -359,6 +528,7 @@ static void cc_map_cb(proto_t *proto)
     }
     else
     {
+        scalepoints_count = 0;
         scalepoints = NULL;
     }
 
@@ -446,6 +616,15 @@ static void cpu_load_cb(proto_t *proto)
     protocol_response(buffer, proto);
 }
 
+static void max_cpu_load_cb(proto_t *proto)
+{
+    float value = effects_jack_max_cpu_load();
+    char buffer[128];
+    sprintf(buffer, "resp 0 %.04f", value);
+
+    protocol_response(buffer, proto);
+}
+
 #ifndef SKIP_READLINE
 static void load_cb(proto_t *proto)
 {
@@ -538,6 +717,8 @@ static void feature_enable(proto_t *proto)
 
     if (!strcmp(feature, "aggregated-midi"))
         resp = effects_aggregated_midi_enable(enabled);
+    else if (!strcmp(feature, "cpu-load"))
+        resp = effects_cpu_load_enable(enabled);
     else if (!strcmp(feature, "freewheeling"))
         resp = effects_freewheeling_enable(enabled);
     else if (!strcmp(feature, "processing"))
@@ -573,6 +754,298 @@ static void output_data_ready(proto_t *proto)
     protocol_response("resp 0", proto);
 }
 
+static void multi_add(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[1]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+    const char **uris = malloc(sizeof(const char *) * instance_count);
+    if (instances != NULL && uris != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+        {
+            uris[i] = proto->list[2 + i * 2];
+            instances[i] = atoi(proto->list[3 + i * 2]);
+        }
+    }
+    else
+    {
+        free(instances);
+        free(uris);
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_add_multi(1, instance_count, instances, uris);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+    free(uris);
+}
+
+static void multi_remove(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[1]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[2 + i]);
+    }
+    else
+    {
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_remove_multi(instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+}
+
+static void multi_activate(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[2]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[3 + i]);
+    }
+    else
+    {
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_activate_multi(atoi(proto->list[1]), instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+}
+
+static void multi_preload(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[1]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+    const char **uris = malloc(sizeof(const char *) * instance_count);
+    if (instances != NULL && uris != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+        {
+            uris[i] = proto->list[2 + i * 2];
+            instances[i] = atoi(proto->list[3 + i * 2]);
+        }
+    }
+    else
+    {
+        free(instances);
+        free(uris);
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_add_multi(0, instance_count, instances, uris);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+    free(uris);
+}
+
+static void multi_bypass(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[2]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[3 + i]);
+    }
+    else
+    {
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_bypass_multi(atoi(proto->list[1]), instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+}
+
+static void multi_param_set(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[3]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[4 + i]);
+    }
+    else
+    {
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int resp = effects_set_parameter_multi(proto->list[1], atof(proto->list[2]), instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+}
+
+static void multi_params_flush(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[2]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[3 + i]);
+    }
+    else
+    {
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int param_count = atoi(proto->list[3 + instance_count]);
+    flushed_param_t *params;
+
+    if (param_count != 0)
+    {
+        params = malloc(sizeof(flushed_param_t) * param_count);
+
+        if (params == NULL)
+        {
+            free(instances);
+            protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+            return;
+        }
+
+        for (int i = 0; i < param_count; i++)
+        {
+            params[i].symbol = proto->list[4 + instance_count + i * 2];
+            params[i].value = atof(proto->list[5 + instance_count + i * 2]);
+        }
+    }
+    else
+    {
+        params = NULL;
+    }
+
+    int resp = effects_flush_parameters_multi(atoi(proto->list[1]), param_count, params, instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+    free(params);
+}
+
+static void multi_pre_run(proto_t *proto)
+{
+    int instance_count = atoi(proto->list[2]);
+    if (instance_count == 0)
+    {
+        protocol_response_int(ERR_ASSIGNMENT_INVALID_OP, proto);
+        return;
+    }
+
+    int *instances = malloc(sizeof(int) * instance_count);
+
+    if (instances != NULL)
+    {
+        for (int i = 0; i < instance_count; i++)
+            instances[i] = atoi(proto->list[3 + i]);
+    }
+    else
+    {
+        protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+        return;
+    }
+
+    int param_count = atoi(proto->list[3 + instance_count]);
+    flushed_param_t *params;
+
+    if (param_count != 0)
+    {
+        params = malloc(sizeof(flushed_param_t) * param_count);
+
+        if (params == NULL)
+        {
+            free(instances);
+            protocol_response_int(ERR_MEMORY_ALLOCATION, proto);
+            return;
+        }
+
+        for (int i = 0; i < param_count; i++)
+        {
+            params[i].symbol = proto->list[4 + instance_count + i * 2];
+            params[i].value = atof(proto->list[5 + instance_count + i * 2]);
+        }
+    }
+    else
+    {
+        params = NULL;
+    }
+
+    int resp = effects_pre_run_multi(atoi(proto->list[1]), param_count, params, instance_count, instances);
+    protocol_response_int(resp, proto);
+
+    free(instances);
+    free(params);
+}
+
+static void wait_audio_cycle(proto_t *proto)
+{
+    int resp = monitor_client_wait_proc() ? 0 : ERR_INVALID_OPERATION;
+    protocol_response_int(resp, proto);
+}
+
 static void help_cb(proto_t *proto)
 {
     proto->response = 0;
@@ -656,6 +1129,18 @@ static void term_signal(int sig)
     return; (void)sig;
 }
 
+#ifdef _WIN32
+static BOOL WINAPI win32_signal(DWORD type)
+{
+    if (type == CTRL_C_EVENT)
+    {
+        term_signal(0);
+        return TRUE;
+    }
+    return FALSE;
+}
+#endif
+
 static int mod_host_init(jack_client_t* client, int socket_port, int feedback_port)
 {
 #ifdef HAVE_FFTW335
@@ -674,15 +1159,23 @@ static int mod_host_init(jack_client_t* client, int socket_port, int feedback_po
     /* Setup the protocol */
     protocol_add_command(EFFECT_ADD, effects_add_cb);
     protocol_add_command(EFFECT_REMOVE, effects_remove_cb);
+    protocol_add_command(EFFECT_ACTIVATE, effects_activate_cb);
+    protocol_add_command(EFFECT_PRELOAD, effects_preload_cb);
     protocol_add_command(EFFECT_PRESET_LOAD, effects_preset_load_cb);
     protocol_add_command(EFFECT_PRESET_SAVE, effects_preset_save_cb);
     protocol_add_command(EFFECT_PRESET_SHOW, effects_preset_show_cb);
     protocol_add_command(EFFECT_CONNECT, effects_connect_cb);
+    protocol_add_command(EFFECT_CONNECT_MATCHING, effects_connect_matching_cb);
+    protocol_add_command(EFFECT_CONNECT_SAFE, effects_connect_safe_cb);
     protocol_add_command(EFFECT_DISCONNECT, effects_disconnect_cb);
+    protocol_add_command(EFFECT_DISCONNECT_ALL, effects_disconnect_all_cb);
+    protocol_add_command(EFFECT_DISCONNECT_SAFE, effects_disconnect_safe_cb);
     protocol_add_command(EFFECT_BYPASS, effects_bypass_cb);
     protocol_add_command(EFFECT_PARAM_SET, effects_set_param_cb);
     protocol_add_command(EFFECT_PARAM_GET, effects_get_param_cb);
     protocol_add_command(EFFECT_PARAM_MON, effects_monitor_param_cb);
+    protocol_add_command(EFFECT_PARAMS_FLUSH, effects_flush_params_cb);
+    protocol_add_command(EFFECT_PRE_RUN, effects_pre_run_cb);
     protocol_add_command(EFFECT_PATCH_GET, effects_get_property_cb);
     protocol_add_command(EFFECT_PATCH_SET, effects_set_property_cb);
     protocol_add_command(EFFECT_LICENSEE, effects_licensee_cb);
@@ -690,6 +1183,10 @@ static int mod_host_init(jack_client_t* client, int socket_port, int feedback_po
     protocol_add_command(EFFECT_SET_BPB, effects_set_beats_per_bar_cb);
     protocol_add_command(MONITOR_ADDR_SET, monitor_addr_set_cb);
     protocol_add_command(MONITOR_OUTPUT, monitor_output_cb);
+    protocol_add_command(MONITOR_OUTPUT_OFF, monitor_output_off_cb);
+    protocol_add_command(MONITOR_AUDIO_LEVELS, monitor_audio_levels_cb);
+    protocol_add_command(MONITOR_CPU_LOAD, monitor_cpu_load_cb);
+    protocol_add_command(MONITOR_MIDI_CONTROL, monitor_midi_control_cb);
     protocol_add_command(MONITOR_MIDI_PROGRAM, monitor_midi_program_cb);
     protocol_add_command(MIDI_LEARN, midi_learn_cb);
     protocol_add_command(MIDI_MAP, midi_map_cb);
@@ -702,6 +1199,7 @@ static int mod_host_init(jack_client_t* client, int socket_port, int feedback_po
     protocol_add_command(HMI_MAP, hmi_map_cb);
     protocol_add_command(HMI_UNMAP, hmi_unmap_cb);
     protocol_add_command(CPU_LOAD, cpu_load_cb);
+    protocol_add_command(MAX_CPU_LOAD, max_cpu_load_cb);
 #ifndef SKIP_READLINE
     protocol_add_command(LOAD_COMMANDS, load_cb);
     protocol_add_command(SAVE_COMMANDS, save_cb);
@@ -716,6 +1214,15 @@ static int mod_host_init(jack_client_t* client, int socket_port, int feedback_po
     protocol_add_command(TRANSPORT_SYNC, transport_sync);
     protocol_add_command(SHOW_EXTERNAL_UI, show_external_ui);
     protocol_add_command(OUTPUT_DATA_READY, output_data_ready);
+    protocol_add_command(MULTI_ADD, multi_add);
+    protocol_add_command(MULTI_REMOVE, multi_remove);
+    protocol_add_command(MULTI_ACTIVATE, multi_activate);
+    protocol_add_command(MULTI_PRELOAD, multi_preload);
+    protocol_add_command(MULTI_BYPASS, multi_bypass);
+    protocol_add_command(MULTI_PARAM_SET, multi_param_set);
+    protocol_add_command(MULTI_PARAMS_FLUSH, multi_params_flush);
+    protocol_add_command(MULTI_PRE_RUN, multi_pre_run);
+    protocol_add_command(WAIT_AUDIO_CYCLE, wait_audio_cycle);
 
     /* skip help and quit for internal client */
     if (client == NULL)
@@ -739,6 +1246,14 @@ static int mod_host_init(jack_client_t* client, int socket_port, int feedback_po
 
 static void* intclient_socket_run(void* ptr)
 {
+#if defined(_MOD_DEVICE_RK358x)
+    setpriority(PRIO_PROCESS, gettid(), -19);
+#elif defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+    const pid_t tid = syscall(SYS_gettid);
+    if (tid > 0)
+        setpriority(PRIO_PROCESS, tid, -19);
+#endif
+
     while (running)
         socket_run(0);
 
@@ -897,6 +1412,7 @@ int main(int argc, char **argv)
 #endif
     {
 #ifdef _WIN32
+        SetConsoleCtrlHandler(win32_signal, TRUE);
 #else
         struct sigaction sig;
         memset(&sig, 0, sizeof(sig));
@@ -951,7 +1467,7 @@ int jack_initialize(jack_client_t* client, const char* load_init)
         return 1;
 
     running = 1;
-    pthread_create(&intclient_socket_thread, NULL, intclient_socket_run, NULL);
+    zix_thread_create(&intclient_socket_thread, 0, intclient_socket_run, NULL);
 
     return 0;
 }
@@ -963,7 +1479,7 @@ void jack_finish(void* arg)
 {
     running = 0;
     socket_finish();
-    pthread_join(intclient_socket_thread, NULL);
+    zix_thread_join(intclient_socket_thread, NULL);
     effects_finish(0);
     protocol_remove_commands();
 
diff --git a/src/mod-host.h b/src/mod-host.h
index 3ded3d2..3ceef4a 100644
--- a/src/mod-host.h
+++ b/src/mod-host.h
@@ -51,50 +51,72 @@
 #define SOCKET_MSG_BUFFER_SIZE  1024
 
 /* Protocol commands definition */
-#define EFFECT_ADD           "add %s %i"
-#define EFFECT_REMOVE        "remove %i"
-#define EFFECT_PRESET_LOAD   "preset_load %i %s"
-#define EFFECT_PRESET_SAVE   "preset_save %i %s %s %s"
-#define EFFECT_PRESET_SHOW   "preset_show %s"
-#define EFFECT_CONNECT       "connect %s %s"
-#define EFFECT_DISCONNECT    "disconnect %s %s"
-#define EFFECT_BYPASS        "bypass %i %i"
-#define EFFECT_PARAM_SET     "param_set %i %s %s"
-#define EFFECT_PARAM_GET     "param_get %i %s"
-#define EFFECT_PARAM_MON     "param_monitor %i %s %s %f"
-#define EFFECT_PATCH_GET     "patch_get %i %s"
-#define EFFECT_PATCH_SET     "patch_set %i %s %s"
-#define EFFECT_LICENSEE      "licensee %i"
-#define EFFECT_SET_BPM       "set_bpm %f"
-#define EFFECT_SET_BPB       "set_bpb %f"
-#define MONITOR_ADDR_SET     "monitor %s %i %i"
-#define MONITOR_OUTPUT       "monitor_output %i %s"
-#define MONITOR_MIDI_PROGRAM "monitor_midi_program %i %i"
-#define MIDI_LEARN           "midi_learn %i %s %f %f"
-#define MIDI_MAP             "midi_map %i %s %i %i %f %f"
-#define MIDI_UNMAP           "midi_unmap %i %s"
-#define CC_MAP               "cc_map %i %s %i %i %s %f %f %f %i %i %s %i ..."
-#define CC_VALUE_SET         "cc_value_set %i %s %f"
-#define CC_UNMAP             "cc_unmap %i %s"
-#define CV_MAP               "cv_map %i %s %s %f %f %s"
-#define CV_UNMAP             "cv_unmap %i %s"
-#define HMI_MAP              "hmi_map %i %s %i %i %i %i %i %s %f %f %i"
-#define HMI_UNMAP            "hmi_unmap %i %s"
-#define CPU_LOAD             "cpu_load"
-#define LOAD_COMMANDS        "load %s"
-#define SAVE_COMMANDS        "save %s"
-#define BUNDLE_ADD           "bundle_add %s"
-#define BUNDLE_REMOVE        "bundle_remove %s %s"
-#define STATE_LOAD           "state_load %s"
-#define STATE_SAVE           "state_save %s"
-#define STATE_TMPDIR         "state_tmpdir %s"
-#define FEATURE_ENABLE       "feature_enable %s %i"
-#define TRANSPORT            "transport %i %f %f"
-#define TRANSPORT_SYNC       "transport_sync %s"
-#define SHOW_EXTERNAL_UI     "show_external_ui %i"
-#define OUTPUT_DATA_READY    "output_data_ready"
-#define HELP                 "help"
-#define QUIT                 "quit"
+#define EFFECT_ADD              "add %s %i"
+#define EFFECT_REMOVE           "remove %i"
+#define EFFECT_ACTIVATE         "activate %i %i"
+#define EFFECT_PRELOAD          "preload %s %i"
+#define EFFECT_PRESET_LOAD      "preset_load %i %s"
+#define EFFECT_PRESET_SAVE      "preset_save %i %s %s %s"
+#define EFFECT_PRESET_SHOW      "preset_show %s"
+#define EFFECT_CONNECT          "connect %s %s"
+#define EFFECT_CONNECT_MATCHING "connect_matching %s %s"
+#define EFFECT_CONNECT_SAFE     "connect_safe %s %s"
+#define EFFECT_DISCONNECT       "disconnect %s %s"
+#define EFFECT_DISCONNECT_ALL   "disconnect_all %s"
+#define EFFECT_DISCONNECT_SAFE  "disconnect_safe %s %s"
+#define EFFECT_BYPASS           "bypass %i %i"
+#define EFFECT_PARAM_SET        "param_set %i %s %f"
+#define EFFECT_PARAM_GET        "param_get %i %s"
+#define EFFECT_PARAM_MON        "param_monitor %i %s %s %f"
+#define EFFECT_PARAMS_FLUSH     "params_flush %i %i %i ..."
+#define EFFECT_PRE_RUN          "pre_run %i %i %i ..."
+#define EFFECT_PATCH_GET        "patch_get %i %s"
+#define EFFECT_PATCH_SET        "patch_set %i %s %s"
+#define EFFECT_LICENSEE         "licensee %i"
+#define EFFECT_SET_BPM          "set_bpm %f"
+#define EFFECT_SET_BPB          "set_bpb %f"
+#define MONITOR_ADDR_SET        "monitor %s %i %i"
+#define MONITOR_OUTPUT          "monitor_output %i %s"
+#define MONITOR_OUTPUT_OFF      "monitor_output_off %i %s"
+#define MONITOR_AUDIO_LEVELS    "monitor_audio_levels %i %s"
+#define MONITOR_CPU_LOAD        "monitor_cpu_load %i %i ..."
+#define MONITOR_MIDI_CONTROL    "monitor_midi_control %i %i"
+#define MONITOR_MIDI_PROGRAM    "monitor_midi_program %i %i"
+#define MIDI_LEARN              "midi_learn %i %s %f %f"
+#define MIDI_MAP                "midi_map %i %s %i %i %f %f"
+#define MIDI_UNMAP              "midi_unmap %i %s"
+#define CC_MAP                  "cc_map %i %s %i %i %s %f %f %f %i %i %s %i ..."
+#define CC_VALUE_SET            "cc_value_set %i %s %f"
+#define CC_UNMAP                "cc_unmap %i %s"
+#define CV_MAP                  "cv_map %i %s %s %f %f %s"
+#define CV_UNMAP                "cv_unmap %i %s"
+#define HMI_MAP                 "hmi_map %i %s %i %i %i %i %i %s %f %f %i"
+#define HMI_UNMAP               "hmi_unmap %i %s"
+#define CPU_LOAD                "cpu_load"
+#define MAX_CPU_LOAD            "max_cpu_load"
+#define LOAD_COMMANDS           "load %s"
+#define SAVE_COMMANDS           "save %s"
+#define BUNDLE_ADD              "bundle_add %s"
+#define BUNDLE_REMOVE           "bundle_remove %s %s"
+#define STATE_LOAD              "state_load %s"
+#define STATE_SAVE              "state_save %s"
+#define STATE_TMPDIR            "state_tmpdir %s"
+#define FEATURE_ENABLE          "feature_enable %s %i"
+#define TRANSPORT               "transport %i %f %f"
+#define TRANSPORT_SYNC          "transport_sync %s"
+#define SHOW_EXTERNAL_UI        "show_external_ui %i"
+#define OUTPUT_DATA_READY       "output_data_ready"
+#define MULTI_ADD               "multi_add %i ..."
+#define MULTI_REMOVE            "multi_remove %i ..."
+#define MULTI_ACTIVATE          "multi_activate %i %i ..."
+#define MULTI_PRELOAD           "multi_preload %i ..."
+#define MULTI_BYPASS            "multi_bypass %i %i ..."
+#define MULTI_PARAM_SET         "multi_param_set %s %f %i ..."
+#define MULTI_PARAMS_FLUSH      "multi_params_flush %i %i ... %i ..."
+#define MULTI_PRE_RUN           "multi_pre_run %i %i ... %i ..."
+#define WAIT_AUDIO_CYCLE        "wait_audio_cycle"
+#define HELP                    "help"
+#define QUIT                    "quit"
 
 
 /*
diff --git a/src/mod-semaphore.h b/src/mod-semaphore.h
index f99403a..ca3caf9 100644
--- a/src/mod-semaphore.h
+++ b/src/mod-semaphore.h
@@ -15,9 +15,9 @@
 #include <syscall.h>
 #include <unistd.h>
 #else
-#include <semaphore.h>
 #include <time.h>
 #include <sys/time.h>
+#include <semaphore.h>
 #endif
 
 #ifdef __APPLE__
diff --git a/src/monitor/monitor-client.c b/src/monitor/monitor-client.c
index cc68a99..536c197 100644
--- a/src/monitor/monitor-client.c
+++ b/src/monitor/monitor-client.c
@@ -22,6 +22,7 @@
 ************************************************************************************************************************
 */
 
+#include <stdatomic.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -31,15 +32,28 @@
 #include <jack/jack.h>
 
 #include "monitor-client.h"
+#include "../mod-semaphore.h"
 #include "../utils.h"
 #include "../dsp/compressor_core.h"
 
+#ifndef STANDALONE_MONITOR_CLIENT
+#include "../effects.h"
+#endif
+
 /*
 ************************************************************************************************************************
 *           LOCAL DEFINES
 ************************************************************************************************************************
 */
 
+#if defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+#define MOD_MONITOR_STEREO_HANDLING
+#endif
+
+#if defined(_MOD_DEVICE_DUOX) || defined(_MOD_DEVICE_DWARF)
+#define MOD_IO_PROCESSING_ENABLED
+#endif
+
 // used for local stack variables
 #define MAX_CHAR_BUF_SIZE 255
 
@@ -49,23 +63,6 @@
 ************************************************************************************************************************
 */
 
-enum Ports {
-    PORT_IN1,
-    PORT_IN2,
-    PORT_OUT1,
-    PORT_OUT2,
-    PORT_COUNT,
-#ifdef _MOD_DEVICE_DUOX
-    PORT_EXTRA_IN3 = PORT_COUNT,
-    PORT_EXTRA_IN4,
-    PORT_EXTRA_OUT3,
-    PORT_EXTRA_OUT4,
-    PORT_EXTRA_COUNT
-#else
-    PORT_EXTRA_COUNT = PORT_COUNT
-#endif
-};
-
 /*
 ************************************************************************************************************************
 *           LOCAL DATA TYPES
@@ -74,23 +71,27 @@ enum Ports {
 
 typedef struct MONITOR_CLIENT_T {
     jack_client_t *client;
-    jack_port_t *ports[PORT_EXTRA_COUNT];
-    bool mono_copy;
-    bool in1_connected;
-    bool in2_connected;
-#ifdef _MOD_DEVICE_DUOX
+    jack_port_t **in_ports;
+    jack_port_t **out_ports;
+    sem_t wait_proc_sem;
+    sem_t wait_volume_sem;
+    uint64_t connected;
+    uint32_t numports;
+    float volume, smooth_volume, step_volume;
+   #ifdef MOD_IO_PROCESSING_ENABLED
+    sf_compressor_state_st compressor;
+   #endif
+   #ifdef _MOD_DEVICE_DUOX
+    sf_compressor_state_st compressor2;
     bool extra_active;
-    bool in3_connected;
-    bool in4_connected;
-#endif
+   #endif
+   #ifdef MOD_MONITOR_STEREO_HANDLING
+    bool mono_copy;
+   #endif
     bool apply_compressor;
     bool apply_volume, apply_smoothing;
     bool muted;
-    sf_compressor_state_st compressor;
-#ifdef _MOD_DEVICE_DUOX
-    sf_compressor_state_st compressor2;
-#endif
-    float volume, smooth_volume;
+    atomic_bool wait_proc, wait_volume;
 } monitor_client_t;
 
 /*
@@ -99,6 +100,8 @@ typedef struct MONITOR_CLIENT_T {
 ************************************************************************************************************************
 */
 
+#define UNUSED_PARAM(var)           do { (void)(var); } while (0)
+
 /*
 ************************************************************************************************************************
 *           LOCAL GLOBAL VARIABLES
@@ -137,268 +140,268 @@ static inline float db2lin(const float db)
     return powf(10.0f, 0.05f * db);
 }
 
-#ifdef _MOD_DEVICE_DUOX
-static void ProcessMonitorExtra(monitor_client_t *const mon, jack_nframes_t nframes);
-#endif
-
-static int ProcessMonitor(jack_nframes_t nframes, void *arg)
+#ifdef MOD_MONITOR_STEREO_HANDLING
+static float ProcessMonitorLoopStereo(monitor_client_t *const mon, jack_nframes_t nframes, uint32_t offset)
 {
-    monitor_client_t *const mon = arg;
-    const float *const bufIn1  = jack_port_get_buffer(mon->ports[PORT_IN1], nframes);
-    const float *const bufIn2  = jack_port_get_buffer(mon->ports[PORT_IN2], nframes);
-    /* */ float *const bufOut1 = jack_port_get_buffer(mon->ports[PORT_OUT1], nframes);
-    /* */ float *const bufOut2 = jack_port_get_buffer(mon->ports[PORT_OUT2], nframes);
+    const float *const bufIn1  = jack_port_get_buffer(mon->in_ports[offset], nframes);
+    const float *const bufIn2  = jack_port_get_buffer(mon->in_ports[offset + 1], nframes);
+    /* */ float *const bufOut1 = jack_port_get_buffer(mon->out_ports[offset], nframes);
+    /* */ float *const bufOut2 = jack_port_get_buffer(mon->out_ports[offset + 1], nframes);
 
-    if (mon->muted)
-    {
-        memset(bufOut1, 0, sizeof(float)*nframes);
-        memset(bufOut2, 0, sizeof(float)*nframes);
-#ifdef _MOD_DEVICE_DUOX
-        if (mon->extra_active)
-        {
-            float *const bufOut3 = jack_port_get_buffer(mon->ports[PORT_EXTRA_OUT3], nframes);
-            float *const bufOut4 = jack_port_get_buffer(mon->ports[PORT_EXTRA_OUT4], nframes);
-            memset(bufOut3, 0, sizeof(float)*nframes);
-            memset(bufOut4, 0, sizeof(float)*nframes);
-        }
-#endif
-        return 0;
-    }
-
-    const float new_volume_weight = 0.001f;
-    const float old_volume_weight = 1.f - new_volume_weight;
+   #ifdef MOD_IO_PROCESSING_ENABLED
+    const bool apply_compressor = mon->apply_compressor;
+   #endif
+    const bool apply_smoothing = mon->apply_smoothing;
+    const bool apply_volume = mon->apply_volume;
 
     const float volume = mon->volume;
-
+    const float step_volume = mon->step_volume;
     float smooth_volume = mon->smooth_volume;
 
-    if (floats_differ_enough(volume, smooth_volume)) {
-        mon->apply_volume = true;
-        mon->apply_smoothing = true;
-    }
-
-    const bool apply_compressor = mon->apply_compressor;
-    const bool apply_smoothing = mon->apply_smoothing;
-    const bool apply_volume = mon->apply_volume;
+    const bool in1_connected = mon->connected & (1 << offset);
+    const bool in2_connected = mon->connected & (1 << (offset + 1));
 
-#ifdef _MOD_DEVICE_DUOX
-    if (mon->extra_active)
-        ProcessMonitorExtra(mon, nframes);
-#endif
+   #if defined(_MOD_DEVICE_DUOX)
+    sf_compressor_state_st* const compressor = offset == 2 ? &mon->compressor2 : &mon->compressor;
+   #elif defined(MOD_IO_PROCESSING_ENABLED)
+    sf_compressor_state_st* const compressor = &mon->compressor;
+   #endif
 
-    if (mon->in1_connected && mon->in2_connected)
+    if (in1_connected && in2_connected)
     {
         if (bufOut1 != bufIn1)
             memcpy(bufOut1, bufIn1, sizeof(float)*nframes);
         if (bufOut2 != bufIn2)
             memcpy(bufOut2, bufIn2, sizeof(float)*nframes);
 
+       #ifdef MOD_IO_PROCESSING_ENABLED
         // input1 and input2 have connections
         if (apply_compressor)
         {
-            compressor_process(&mon->compressor, nframes, bufOut1, bufOut2);
+            compressor_process(compressor, nframes, bufOut1, bufOut2);
 
             if (apply_volume)
             {
+                float dy;
+
                 for (jack_nframes_t i=0; i<nframes; ++i)
                 {
                     if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
+                    {
+                        dy = volume - smooth_volume;
+                        smooth_volume += copysignf(fminf(fabsf(dy), step_volume), dy);
+                    }
+
                     bufOut1[i] *= smooth_volume;
                     bufOut2[i] *= smooth_volume;
                 }
             }
         }
         else
+       #endif
         {
             if (apply_volume)
             {
+                float dy;
+
                 for (jack_nframes_t i=0; i<nframes; ++i)
                 {
                     if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
+                    {
+                        dy = volume - smooth_volume;
+                        smooth_volume += copysignf(fminf(fabsf(dy), step_volume), dy);
+                    }
+
                     bufOut1[i] *= smooth_volume;
                     bufOut2[i] *= smooth_volume;
                 }
             }
         }
-
-        mon->apply_volume = floats_differ_enough(smooth_volume, 1.0f);
-        mon->smooth_volume = smooth_volume;
-        return 0;
     }
-
-    if (mon->in1_connected || mon->in2_connected)
+    else if (in1_connected || in2_connected)
     {
         // only one input has connections
-        const float *const bufInR  = mon->in1_connected ? bufIn1 : bufIn2;
-        /* */ float *const bufOutR = mon->in1_connected ? bufOut1 : bufOut2;
-        /* */ float *const bufOutC = mon->in1_connected ? bufOut2 : bufOut1;
+        const float *const bufInR  = in1_connected ? bufIn1 : bufIn2;
+        /* */ float *const bufOutR = in1_connected ? bufOut1 : bufOut2;
+        /* */ float *const bufOutC = in1_connected ? bufOut2 : bufOut1;
 
         if (bufOutR != bufInR)
             memcpy(bufOutR, bufInR, sizeof(float)*nframes);
 
+       #ifdef MOD_IO_PROCESSING_ENABLED
         if (apply_compressor)
         {
-            compressor_process_mono(&mon->compressor, nframes, bufOutR);
+            compressor_process_mono(compressor, nframes, bufOutR);
 
             if (apply_volume)
             {
+                float dy;
+
                 for (jack_nframes_t i=0; i<nframes; ++i)
                 {
                     if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
+                    {
+                        dy = volume - smooth_volume;
+                        smooth_volume += copysignf(fminf(fabsf(dy), step_volume), dy);
+                    }
+
                     bufOutR[i] *= smooth_volume;
                 }
             }
         }
         else
+       #endif
         {
             if (apply_volume)
             {
+                float dy;
+
                 for (jack_nframes_t i=0; i<nframes; ++i)
                 {
                     if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
+                    {
+                        dy = volume - smooth_volume;
+                        smooth_volume += copysignf(fminf(fabsf(dy), step_volume), dy);
+                    }
+
                     bufOutR[i] *= smooth_volume;
                 }
             }
         }
 
-        if (mon->mono_copy)
+        if (offset == 0 && mon->mono_copy)
             memcpy(bufOutC, bufInR, sizeof(float)*nframes);
         else
             memset(bufOutC, 0, sizeof(float)*nframes);
-
-        mon->apply_volume = floats_differ_enough(smooth_volume, 1.0f);
-        mon->smooth_volume = smooth_volume;
-        return 0;
+    }
+    else
+    {
+        // nothing connected in input1 or input2
+        memset(bufOut1, 0, sizeof(float)*nframes);
+        memset(bufOut2, 0, sizeof(float)*nframes);
     }
 
-    // nothing connected in input1 or input2
-    memset(bufOut1, 0, sizeof(float)*nframes);
-    memset(bufOut2, 0, sizeof(float)*nframes);
-    return 0;
+    return smooth_volume;
 }
+#endif
 
-#ifdef _MOD_DEVICE_DUOX
-static void ProcessMonitorExtra(monitor_client_t *const mon, jack_nframes_t nframes)
+static int ProcessMonitor(jack_nframes_t nframes, void *arg)
 {
-    const float *const bufIn3  = jack_port_get_buffer(mon->ports[PORT_EXTRA_IN3], nframes);
-    const float *const bufIn4  = jack_port_get_buffer(mon->ports[PORT_EXTRA_IN4], nframes);
-    /* */ float *const bufOut3 = jack_port_get_buffer(mon->ports[PORT_EXTRA_OUT3], nframes);
-    /* */ float *const bufOut4 = jack_port_get_buffer(mon->ports[PORT_EXTRA_OUT4], nframes);
+    monitor_client_t *const mon = arg;
+
+   #ifndef STANDALONE_MONITOR_CLIENT
+    effect_sync_scheduled_params(true);
+   #endif
+
+    if (mon->muted)
+    {
+        for (uint32_t i=0; i < mon->numports; ++i)
+            memset(jack_port_get_buffer(mon->out_ports[i], nframes), 0, sizeof(float)*nframes);
+
+        if (atomic_exchange(&mon->wait_proc, false))
+            sem_post(&mon->wait_proc_sem);
 
-    const float new_volume_weight = 0.001f;
-    const float old_volume_weight = 1.f - new_volume_weight;
+        if (atomic_exchange(&mon->wait_volume, false))
+            sem_post(&mon->wait_volume_sem);
 
+        return 0;
+    }
+
+   #ifndef MOD_MONITOR_STEREO_HANDLING
+    const float step_volume = mon->step_volume;
+   #endif
     const float volume = mon->volume;
+    float smooth_volume = mon->smooth_volume;
+
+    if (floats_differ_enough(volume, smooth_volume))
+    {
+        mon->apply_volume = true;
+        mon->apply_smoothing = true;
+    }
+
+  #ifdef MOD_MONITOR_STEREO_HANDLING
+    smooth_volume = ProcessMonitorLoopStereo(mon, nframes, 0);
+
+   #ifdef _MOD_DEVICE_DUOX
+    if (mon->extra_active)
+        ProcessMonitorLoopStereo(mon, nframes, 2);
+   #endif
+  #else
+    const float* bufIn[mon->numports];
+    /* */ float* bufOut[mon->numports];
 
-    const bool apply_compressor = mon->apply_compressor;
     const bool apply_smoothing = mon->apply_smoothing;
     const bool apply_volume = mon->apply_volume;
+    const uint64_t connected = mon->connected;
 
-    float smooth_volume = mon->smooth_volume;
-
-    if (mon->in3_connected && mon->in4_connected)
+    for (uint32_t i=0; i < mon->numports; ++i)
     {
-        if (bufOut3 != bufIn3)
-            memcpy(bufOut3, bufIn3, sizeof(float)*nframes);
-        if (bufOut4 != bufIn4)
-            memcpy(bufOut4, bufIn4, sizeof(float)*nframes);
+        bufIn[i] = jack_port_get_buffer(mon->in_ports[i], nframes);
+        bufOut[i] = jack_port_get_buffer(mon->out_ports[i], nframes);
 
-        // input3 and input4 have connections
-        if (apply_compressor)
+        if (connected & (1 << i))
         {
-            compressor_process(&mon->compressor2, nframes, bufOut3, bufOut4);
-
-            if (apply_volume)
-            {
-                for (jack_nframes_t i=0; i<nframes; ++i)
-                {
-                    if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
-                    bufOut3[i] *= smooth_volume;
-                    bufOut4[i] *= smooth_volume;
-                }
-            }
+            if (bufOut[i] != bufIn[i])
+                memcpy(bufOut[i], bufIn[i], sizeof(float)*nframes);
         }
         else
         {
-            if (apply_volume)
-            {
-                for (jack_nframes_t i=0; i<nframes; ++i)
-                {
-                    if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
-                    bufOut3[i] *= smooth_volume;
-                    bufOut4[i] *= smooth_volume;
-                }
-            }
+            memset(bufOut[i], 0, sizeof(float)*nframes);
         }
-        return;
     }
 
-    if (mon->in3_connected || mon->in4_connected)
+    if (apply_volume)
     {
-        // only one input has connections
-        const float *const bufInR  = mon->in3_connected ? bufIn3 : bufIn4;
-        /* */ float *const bufOutR = mon->in3_connected ? bufOut3 : bufOut4;
-        /* */ float *const bufOutC = mon->in3_connected ? bufOut4 : bufOut3;
-
-        if (bufOutR != bufInR)
-            memcpy(bufOutR, bufInR, sizeof(float)*nframes);
-
-        if (apply_compressor)
-        {
-            compressor_process_mono(&mon->compressor2, nframes, bufOutR);
+        float dy;
 
-            if (apply_volume)
-            {
-                for (jack_nframes_t i=0; i<nframes; ++i)
-                {
-                    if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
-                    bufOutR[i] *= smooth_volume;
-                }
-            }
-        }
-        else
+        for (jack_nframes_t i=0; i<nframes; ++i)
         {
-            if (apply_volume)
+            if (apply_smoothing)
             {
-                for (jack_nframes_t i=0; i<nframes; ++i)
-                {
-                    if (apply_smoothing)
-                        smooth_volume = new_volume_weight * volume + old_volume_weight * smooth_volume;
-                    bufOutR[i] *= smooth_volume;
-                }
+                dy = volume - smooth_volume;
+                smooth_volume += copysignf(fminf(fabsf(dy), step_volume), dy);
             }
+
+            for (uint32_t j=0; j<mon->numports; ++j)
+                bufOut[j][i] *= smooth_volume;
         }
-        memset(bufOutC, 0, sizeof(float)*nframes);
-        return;
     }
+  #endif
+
+    // we use `floats_differ_enough` here as a safe `!=` float value comparison
+    mon->apply_volume = floats_differ_enough(smooth_volume, 1.0f);
+    mon->smooth_volume = smooth_volume;
+    mon->muted = smooth_volume <= db2lin(MOD_MONITOR_VOLUME_MUTE) ||
+               ! floats_differ_enough(smooth_volume, db2lin(MOD_MONITOR_VOLUME_MUTE));
+
+    if (atomic_exchange(&mon->wait_proc, false))
+        sem_post(&mon->wait_proc_sem);
 
-    // nothing connected in input3 or input4
-    memset(bufOut3, 0, sizeof(float)*nframes);
-    memset(bufOut4, 0, sizeof(float)*nframes);
+    // now we manually specify a very low value instead of using `floats_differ_enough`
+    // due to smooth filtering the final value is never reached
+    if (atomic_load(&mon->wait_volume) && fabsf(volume - smooth_volume) < 0.000001f)
+    {
+        atomic_store(&mon->wait_volume, false);
+        sem_post(&mon->wait_volume_sem);
+    }
+
+    return 0;
 }
-#endif
 
 static int GraphOrder(void* arg)
 {
     monitor_client_t *const mon = arg;
 
-    mon->in1_connected = jack_port_connected(mon->ports[PORT_IN1]) > 0;
-    mon->in2_connected = jack_port_connected(mon->ports[PORT_IN2]) > 0;
-
-#ifdef _MOD_DEVICE_DUOX
-    if (mon->extra_active)
+    for (uint32_t i=0; i<mon->numports; ++i)
     {
-        mon->in3_connected = jack_port_connected(mon->ports[PORT_EXTRA_IN3]) > 0;
-        mon->in4_connected = jack_port_connected(mon->ports[PORT_EXTRA_IN4]) > 0;
+        const uint64_t flag = 1 << i;
+
+        if (jack_port_connected(mon->in_ports[i]) > 0)
+            mon->connected |= flag;
+        else
+            mon->connected &= ~flag;
     }
-#endif
+
     return 0;
 }
 
@@ -418,7 +421,7 @@ int jack_initialize(jack_client_t* client, const char* load_init)
     }
 
     /* allocate monitor client */
-    monitor_client_t *const mon = calloc(sizeof(monitor_client_t), 1);
+    monitor_client_t *const mon = calloc(1, sizeof(monitor_client_t));
 
     if (!mon)
     {
@@ -427,66 +430,93 @@ int jack_initialize(jack_client_t* client, const char* load_init)
     }
 
     mon->client = client;
-    mon->in1_connected = false;
-    mon->in2_connected = false;
-    mon->mono_copy = (load_init && !strcmp(load_init, "1")) || access("/data/jack-mono-copy", F_OK) != -1;
-#ifdef _MOD_DEVICE_DUOX
-    mon->extra_active = access("/data/separate-spdif-outs", F_OK) != -1;
-#endif
+    mon->connected = 0;
 
+   #ifdef MOD_IO_PROCESSING_ENABLED
     mon->apply_compressor = false;
-    mon->apply_volume = false;
-    mon->muted = false;
-    mon->volume = 1.0f;
-
     compressor_init(&mon->compressor, jack_get_sample_rate(client));
-#ifdef _MOD_DEVICE_DUOX
+   #endif
+
+   #ifdef _MOD_DEVICE_DUOX
+    mon->extra_active = access("/data/separate-spdif-outs", F_OK) != -1;
+
     if (mon->extra_active)
         compressor_init(&mon->compressor2, jack_get_sample_rate(client));
-#endif
+   #endif
+
+   #ifdef MOD_MONITOR_STEREO_HANDLING
+    mon->mono_copy = (load_init && !strcmp(load_init, "1")) || access("/data/jack-mono-copy", F_OK) != -1;
+   #endif
+
+    mon->apply_volume = false;
+    mon->muted = false;
+    mon->wait_volume = false;
+    mon->volume = mon->smooth_volume = 1.0f;
+    mon->step_volume = 0.f;
 
     /* Register jack ports */
-    mon->ports[PORT_IN1 ] = jack_port_register(client, "in_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
-    mon->ports[PORT_IN2 ] = jack_port_register(client, "in_2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
-    mon->ports[PORT_OUT1] = jack_port_register(client, "out_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
-    mon->ports[PORT_OUT2] = jack_port_register(client, "out_2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+   #if defined(_MOD_DEVICE_DUO) || defined(_MOD_DEVICE_DWARF)
+    const uint32_t numports = 2;
+   #elif defined(_MOD_DEVICE_DUOX)
+    const uint32_t numports = mon->extra_active ? 4 : 2;
+   #elif defined(_DARKGLASS_DEVICE_PABLITO)
+    const uint32_t numports = 10;
+   #else
+    uint32_t numports = 0;
+
+    const char** const sysports = jack_get_ports(client, "system:playback_", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput);
+    if (sysports != NULL)
+    {
+        while (sysports[numports])
+            ++numports;
+        jack_free(sysports);
+    }
 
-    jack_port_tie(mon->ports[PORT_IN1], mon->ports[PORT_OUT1]);
-    jack_port_tie(mon->ports[PORT_IN2], mon->ports[PORT_OUT2]);
+    if (numports == 0)
+    {
+        fprintf(stderr, "no jack playback ports\n");
+        free(mon);
+        return 1;
+    }
+   #endif
 
-    for (int i=0; i<PORT_COUNT; ++i)
+    mon->numports = numports;
+    mon->in_ports = malloc(sizeof(jack_port_t*) * numports);
+    mon->out_ports = malloc(sizeof(jack_port_t*) * numports);
+
+    if (!mon->in_ports || !mon->out_ports)
     {
-        if (! mon->ports[i])
-        {
-            fprintf(stderr, "can't register jack ports\n");
-            free(mon);
-            return 1;
-        }
+        fprintf(stderr, "out of memory\n");
+        free(mon);
+        return 1;
     }
 
-#ifdef _MOD_DEVICE_DUOX
-    if (mon->extra_active)
+    char portname[MAX_CHAR_BUF_SIZE+1];
+    portname[MAX_CHAR_BUF_SIZE] = '\0';
+
+    for (uint32_t i=0; i<numports; ++i)
     {
-        /* Register extra jack ports */
-        mon->ports[PORT_EXTRA_IN3 ] = jack_port_register(client, "in_3", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
-        mon->ports[PORT_EXTRA_IN4 ] = jack_port_register(client, "in_4", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
-        mon->ports[PORT_EXTRA_OUT3] = jack_port_register(client, "out_3", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
-        mon->ports[PORT_EXTRA_OUT4] = jack_port_register(client, "out_4", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+        snprintf(portname, MAX_CHAR_BUF_SIZE, "in_%d", i + 1);
+        mon->in_ports[i] = jack_port_register(client, portname, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 
-        jack_port_tie(mon->ports[PORT_EXTRA_IN3], mon->ports[PORT_EXTRA_OUT3]);
-        jack_port_tie(mon->ports[PORT_EXTRA_IN4], mon->ports[PORT_EXTRA_OUT4]);
+        snprintf(portname, MAX_CHAR_BUF_SIZE, "out_%d", i + 1);
+        mon->out_ports[i] = jack_port_register(client, portname, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 
-        for (int i=PORT_COUNT; i<PORT_EXTRA_COUNT; ++i)
+        if (!mon->in_ports[i] || !mon->out_ports[i])
         {
-            if (! mon->ports[i])
-            {
-                fprintf(stderr, "can't register jack ports\n");
-                free(mon);
-                return 1;
-            }
+            fprintf(stderr, "can't register jack ports\n");
+            free(mon);
+            return 1;
         }
+
+        jack_port_tie(mon->in_ports[i], mon->out_ports[i]);
     }
-#endif
+
+    atomic_init(&mon->wait_proc, false);
+    atomic_init(&mon->wait_volume, false);
+
+    sem_init(&mon->wait_proc_sem, 0, 0);
+    sem_init(&mon->wait_volume_sem, 0, 0);
 
     /* Set jack callbacks */
     jack_set_graph_order_callback(client, GraphOrder, mon);
@@ -496,6 +526,8 @@ int jack_initialize(jack_client_t* client, const char* load_init)
     if (jack_activate(client) != 0)
     {
         fprintf(stderr, "can't activate jack client\n");
+        sem_destroy(&mon->wait_proc_sem);
+        sem_destroy(&mon->wait_volume_sem);
         free(mon);
         return 1;
     }
@@ -509,41 +541,49 @@ int jack_initialize(jack_client_t* client, const char* load_init)
 
     const char* const ourclientname = jack_get_client_name(client);
 
-    if (jack_port_by_name(client, "system:playback_1") != NULL)
-    {
-       #ifndef _MOD_DEVICE_DWARF
-        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_1", ourclientname);
-       #else
-        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_2", ourclientname);
-       #endif
-        jack_connect(client, ourportname, "system:playback_1");
-    }
+   #if defined(_DARKGLASS_DEVICE_PABLITO)
+    snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:in_9", ourclientname);
+    jack_connect(client, "anagram-output:out1", ourportname);
+
+    snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:in_10", ourclientname);
+    jack_connect(client, "anagram-output:out2", ourportname);
+
+    snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_5", ourclientname);
+    jack_connect(client, ourportname, "system:playback_5");
 
-    if (jack_port_by_name(client, "system:playback_2") != NULL)
+    snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_6", ourclientname);
+    jack_connect(client, ourportname, "system:playback_6");
+   #elif defined(_MOD_DEVICE_DWARF)
+    snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_2", ourclientname);
+    jack_connect(client, ourportname, "system:playback_1");
+
+    snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_1", ourclientname);
+    jack_connect(client, ourportname, "system:playback_2");
+   #else
+    for (uint32_t i=0; i<numports; ++i)
     {
-       #ifndef _MOD_DEVICE_DWARF
-        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_2", ourclientname);
-       #else
-        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_1", ourclientname);
-       #endif
-        jack_connect(client, ourportname, "system:playback_2");
+        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_%d", ourclientname, i + 1);
+        snprintf(portname, MAX_CHAR_BUF_SIZE, "system:playback_%d", i + 1);
+        jack_connect(client, ourportname, portname);
     }
+   #endif
 
    #ifdef _MOD_DEVICE_DUOX
-    if (jack_port_by_name(client, "system:playback_3") != NULL)
+    if (!mon->extra_active)
     {
-        snprintf(ourportname, MAX_CHAR_BUF_SIZE, mon->extra_active ? "%s:out_3" : "%s:out_1", ourclientname);
+        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_1", ourclientname);
         jack_connect(client, ourportname, "system:playback_3");
-    }
 
-    if (jack_port_by_name(client, "system:playback_4") != NULL)
-    {
-        snprintf(ourportname, MAX_CHAR_BUF_SIZE, mon->extra_active ? "%s:out_4" : "%s:out_2", ourclientname);
+        snprintf(ourportname, MAX_CHAR_BUF_SIZE, "%s:out_2", ourclientname);
         jack_connect(client, ourportname, "system:playback_4");
     }
    #endif
 
     return 0;
+
+   #ifndef MOD_MONITOR_STEREO_HANDLING
+    UNUSED_PARAM(load_init);
+   #endif
 }
 
 #ifdef STANDALONE_MONITOR_CLIENT
@@ -557,13 +597,20 @@ void jack_finish(void* arg)
     monitor_client_t *const mon = arg;
 
     jack_deactivate(mon->client);
+    sem_destroy(&mon->wait_proc_sem);
+    sem_destroy(&mon->wait_volume_sem);
 
     g_monitor_handle = NULL;
     g_active = false;
 
-    for (int i=0; i<PORT_COUNT; ++i)
-        jack_port_unregister(mon->client, mon->ports[i]);
+    for (uint32_t i=0; i<mon->numports; ++i)
+    {
+        jack_port_unregister(mon->client, mon->in_ports[i]);
+        jack_port_unregister(mon->client, mon->out_ports[i]);
+    }
 
+    free(mon->in_ports);
+    free(mon->out_ports);
     free(mon);
 }
 
@@ -586,8 +633,25 @@ bool monitor_client_init(void)
     return true;
 }
 
+void monitor_client_stop(void)
+{
+    monitor_client_t *const mon = g_monitor_handle;
+
+    if (!mon)
+    {
+        fprintf(stderr, "failed to close mod-monitor client\n");
+        return;
+    }
+
+    jack_client_t *const client = mon->client;
+
+    jack_finish(mon);
+    jack_client_close(client);
+}
+
 bool monitor_client_setup_compressor(int mode, float release)
 {
+   #ifdef MOD_IO_PROCESSING_ENABLED
     monitor_client_t *const mon = g_monitor_handle;
 
     if (!mon)
@@ -600,36 +664,43 @@ bool monitor_client_setup_compressor(int mode, float release)
     {
     case 1:
         compressor_set_params(&mon->compressor, -12.f, 12.f, 2.f, 0.0001f, release / 1000, -3.f);
-#ifdef _MOD_DEVICE_DUOX
+       #ifdef _MOD_DEVICE_DUOX
         if (mon->extra_active)
             compressor_set_params(&mon->compressor2, -12.f, 12.f, 2.f, 0.0001f, release / 1000, -3.f);
-#endif
+       #endif
         break;
     case 2:
         compressor_set_params(&mon->compressor, -12.f, 12.f, 3.f, 0.0001f, release / 1000, -3.f);
-#ifdef _MOD_DEVICE_DUOX
+       #ifdef _MOD_DEVICE_DUOX
         if (mon->extra_active)
             compressor_set_params(&mon->compressor2, -12.f, 12.f, 3.f, 0.0001f, release / 1000, -3.f);
-#endif
+       #endif
         break;
     case 3:
         compressor_set_params(&mon->compressor, -15.f, 15.f, 4.f, 0.0001f, release / 1000, -3.f);
-#ifdef _MOD_DEVICE_DUOX
+       #ifdef _MOD_DEVICE_DUOX
         if (mon->extra_active)
             compressor_set_params(&mon->compressor2, -15.f, 15.f, 4.f, 0.0001f, release / 1000, -3.f);
-#endif
+       #endif
         break;
     case 4:
         compressor_set_params(&mon->compressor, -25.f, 15.f, 10.f, 0.0001f, release / 1000, -6.f);
-#ifdef _MOD_DEVICE_DUOX
+       #ifdef _MOD_DEVICE_DUOX
         if (mon->extra_active)
             compressor_set_params(&mon->compressor2, -25.f, 15.f, 10.f, 0.0001f, release / 1000, -6.f);
-#endif
+       #endif
         break;
     }
 
     mon->apply_compressor = mode != 0;
     return true;
+   #else
+    fprintf(stderr, "asked to setup compressor while IO processing is not enabled\n");
+    return false;
+
+    UNUSED_PARAM(mode);
+    UNUSED_PARAM(release);
+   #endif
 }
 
 bool monitor_client_setup_volume(float volume)
@@ -644,27 +715,61 @@ bool monitor_client_setup_volume(float volume)
 
     // local variables for calculations before changing the real struct values
     const float final_volume = db2lin(volume);
+    const float step_volume = fabsf(final_volume - mon->smooth_volume)
+                            / (MOD_MONITOR_VOLUME_WAIT * jack_get_sample_rate(mon->client));
     const bool apply_volume = floats_differ_enough(final_volume, 1.0f);
-    const bool muted = !floats_differ_enough(volume, -30.0f);
+    const bool unmute = volume > MOD_MONITOR_VOLUME_MUTE;
 
     mon->volume = final_volume;
+    mon->step_volume = step_volume;
     mon->apply_volume = apply_volume;
-    mon->muted = muted;
+
+    atomic_thread_fence(memory_order_seq_cst);
+
+    if (unmute)
+        mon->muted = false;
+
     return true;
 }
 
-void monitor_client_stop(void)
+bool monitor_client_flush_volume(void)
 {
     monitor_client_t *const mon = g_monitor_handle;
 
     if (!mon)
     {
-        fprintf(stderr, "failed to close mod-monitor client\n");
-        return;
+        fprintf(stderr, "asked to flush volume while monitor client is not active\n");
+        return false;
     }
 
-    jack_client_t *const client = mon->client;
+    mon->smooth_volume = mon->volume;
+    return true;
+}
 
-    jack_finish(mon);
-    jack_client_close(client);
+bool monitor_client_wait_proc(void)
+{
+    monitor_client_t *const mon = g_monitor_handle;
+
+    if (!mon)
+    {
+        fprintf(stderr, "asked to wait for proc while monitor client is not active\n");
+        return false;
+    }
+
+    atomic_store(&mon->wait_proc, true);
+    return sem_timedwait_secs(&mon->wait_proc_sem, 1) == 0;
+}
+
+bool monitor_client_wait_volume(void)
+{
+    monitor_client_t *const mon = g_monitor_handle;
+
+    if (!mon)
+    {
+        fprintf(stderr, "asked to wait for volume while monitor client is not active\n");
+        return false;
+    }
+
+    atomic_store(&mon->wait_volume, true);
+    return sem_timedwait_secs(&mon->wait_volume_sem, 1) == 0;
 }
diff --git a/src/monitor/monitor-client.h b/src/monitor/monitor-client.h
index c97ad3c..c6d706d 100644
--- a/src/monitor/monitor-client.h
+++ b/src/monitor/monitor-client.h
@@ -46,6 +46,14 @@
 ************************************************************************************************************************
 */
 
+#if defined(_DARKGLASS_DEVICE_PABLITO)
+#define MOD_MONITOR_VOLUME_MUTE -60.f
+#define MOD_MONITOR_VOLUME_WAIT 0.02f
+#else
+#define MOD_MONITOR_VOLUME_MUTE -30.f
+#define MOD_MONITOR_VOLUME_WAIT 0.03f
+#endif
+
 
 /*
 ************************************************************************************************************************
@@ -79,6 +87,9 @@ void monitor_client_stop(void);
 
 bool monitor_client_setup_compressor(int mode, float release);
 bool monitor_client_setup_volume(float volume);
+bool monitor_client_flush_volume(void);
+bool monitor_client_wait_proc(void);
+bool monitor_client_wait_volume(void);
 
 
 /*
diff --git a/src/protocol.c b/src/protocol.c
index d26a22d..3316d39 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -25,6 +25,10 @@
 #include <stdio.h>
 #include <string.h>
 
+#ifndef SKIP_READLINE
+#include <unistd.h>
+#endif
+
 #include "protocol.h"
 #include "utils.h"
 
@@ -216,7 +220,12 @@ void protocol_parse(msg_t *msg)
             g_commands[index].callback(&proto);
             if (proto.response)
             {
-                SEND_TO_SENDER(msg->sender_id, proto.response, proto.response_size);
+#ifndef SKIP_READLINE
+                if (msg->sender_id == STDOUT_FILENO)
+                    write(msg->sender_id, proto.response, proto.response_size+1);
+                else
+#endif
+                    socket_send(msg->sender_id, proto.response, proto.response_size+1);
                 if (g_verbose) printf("PROTOCOL: response '%s'\n", proto.response);
 
                 FREE(proto.response);
@@ -226,7 +235,12 @@ void protocol_parse(msg_t *msg)
     // Protocol error
     else
     {
-        SEND_TO_SENDER(msg->sender_id, g_error_messages[-index-1], strlen(g_error_messages[-index-1]));
+#ifndef SKIP_READLINE
+        if (msg->sender_id == STDOUT_FILENO)
+            write(msg->sender_id, g_error_messages[-index-1], strlen(g_error_messages[-index-1])+1);
+        else
+#endif
+            socket_send(msg->sender_id, g_error_messages[-index-1], strlen(g_error_messages[-index-1])+1);
         if (g_verbose) printf("PROTOCOL: error '%s'\n", g_error_messages[-index-1]);
     }
 
diff --git a/src/protocol.h b/src/protocol.h
index 346aa95..81604b6 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -48,7 +48,7 @@
 ************************************************************************************************************************
 */
 
-#define PROTOCOL_MAX_COMMANDS       64
+#define PROTOCOL_MAX_COMMANDS       80
 
 // error messages configuration
 #define MESSAGE_COMMAND_NOT_FOUND   "not found"
@@ -56,9 +56,6 @@
 #define MESSAGE_FEW_ARGUMENTS       "few arguments"
 #define MESSAGE_INVALID_ARGUMENT    "invalid argument"
 
-// defines the function to send responses to sender
-#define SEND_TO_SENDER(id,msg,len)  socket_send((id),(msg),(len)+1)
-
 
 /*
 ************************************************************************************************************************
diff --git a/src/rtmempool/rtmempool.c b/src/rtmempool/rtmempool.c
index aef9b70..1ff3376 100644
--- a/src/rtmempool/rtmempool.c
+++ b/src/rtmempool/rtmempool.c
@@ -1,7 +1,7 @@
 /*
  * RealTime Memory Pool, heavily based on work by Nedko Arnaudov
  * Copyright (C) 2006-2009 Nedko Arnaudov <nedko@arnaudov.name>
- * Copyright (C) 2013-2016 Filipe Coelho <falktx@falktx.com>
+ * Copyright (C) 2013-2025 Filipe Coelho <falktx@falktx.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -33,30 +33,17 @@ typedef struct list_head k_list_head;
 
 typedef struct _RtMemPool
 {
-    char name[RTSAFE_MEMORY_POOL_NAME_MAX];
-
-    size_t dataSize;
-    size_t maxPreallocated;
-
     k_list_head used;
-    unsigned int usedCount;
-
     k_list_head unused;
-    unsigned int unusedCount;
-
     pthread_mutex_t mutex;
-
 } RtMemPool;
 
 // ------------------------------------------------------------------------------------------------
 
 bool rtsafe_memory_pool_create(RtMemPool_Handle* handlePtr,
-                               const char* poolName,
                                size_t dataSize,
                                size_t maxPreallocated)
 {
-    assert(poolName == NULL || strlen(poolName) < RTSAFE_MEMORY_POOL_NAME_MAX);
-
     k_list_head* nodePtr;
     RtMemPool* poolPtr;
 
@@ -67,35 +54,20 @@ bool rtsafe_memory_pool_create(RtMemPool_Handle* handlePtr,
         return false;
     }
 
-    if (poolName != NULL)
-    {
-        strcpy(poolPtr->name, poolName);
-    }
-    else
-    {
-        sprintf(poolPtr->name, "%p", poolPtr);
-    }
-
-    poolPtr->dataSize = dataSize;
-    poolPtr->maxPreallocated = maxPreallocated;
-
     INIT_LIST_HEAD(&poolPtr->used);
-    poolPtr->usedCount = 0;
-
     INIT_LIST_HEAD(&poolPtr->unused);
-    poolPtr->unusedCount = 0;
 
     pthread_mutexattr_t atts;
     pthread_mutexattr_init(&atts);
-#ifdef __ARM_ARCH_7A__
+#ifdef __MOD_DEVICES__
     pthread_mutexattr_setprotocol(&atts, PTHREAD_PRIO_INHERIT);
 #endif
     pthread_mutex_init(&poolPtr->mutex, &atts);
     pthread_mutexattr_destroy(&atts);
 
-    while (poolPtr->unusedCount < poolPtr->maxPreallocated)
+    for (unsigned int unusedCount = 0; unusedCount < maxPreallocated; unusedCount++)
     {
-        nodePtr = malloc(sizeof(k_list_head) + poolPtr->dataSize);
+        nodePtr = malloc(sizeof(k_list_head) + dataSize);
 
         if (nodePtr == NULL)
         {
@@ -103,7 +75,6 @@ bool rtsafe_memory_pool_create(RtMemPool_Handle* handlePtr,
         }
 
         list_add_tail(nodePtr, &poolPtr->unused);
-        poolPtr->unusedCount++;
     }
 
     *handlePtr = (RtMemPool_Handle)poolPtr;
@@ -120,21 +91,10 @@ void rtsafe_memory_pool_destroy(RtMemPool_Handle handle)
     k_list_head* nodePtr;
     RtMemPool* poolPtr = (RtMemPool*)handle;
 
-    // caller should deallocate all chunks prior releasing pool itself
-    if (poolPtr->usedCount != 0)
-    {
-        assert(0);
-    }
-
-    while (poolPtr->unusedCount != 0)
+    while (! list_empty(&poolPtr->unused))
     {
-        assert(! list_empty(&poolPtr->unused));
-
         nodePtr = poolPtr->unused.next;
-
         list_del(nodePtr);
-        poolPtr->unusedCount--;
-
         free(nodePtr);
     }
 
@@ -166,9 +126,6 @@ void* rtsafe_memory_pool_allocate_atomic(RtMemPool_Handle handle)
     nodePtr = poolPtr->unused.next;
     list_del(nodePtr);
 
-    poolPtr->unusedCount--;
-    poolPtr->usedCount++;
-
     list_add_tail(nodePtr, &poolPtr->used);
 
     pthread_mutex_unlock(&poolPtr->mutex);
@@ -189,8 +146,6 @@ void rtsafe_memory_pool_deallocate(RtMemPool_Handle handle, void* memoryPtr)
 
     list_del((k_list_head*)memoryPtr - 1);
     list_add_tail((k_list_head*)memoryPtr - 1, &poolPtr->unused);
-    poolPtr->usedCount--;
-    poolPtr->unusedCount++;
 
     pthread_mutex_unlock(&poolPtr->mutex);
 }
diff --git a/src/rtmempool/rtmempool.h b/src/rtmempool/rtmempool.h
index 20d6824..0311db3 100644
--- a/src/rtmempool/rtmempool.h
+++ b/src/rtmempool/rtmempool.h
@@ -39,14 +39,12 @@ typedef void* RtMemPool_Handle;
  *
  * <b>may/will sleep</b>
  *
- * @param poolName pool name, for debug purposes, max RTSAFE_MEMORY_POOL_NAME_MAX chars, including terminating zero char. May be NULL.
  * @param dataSize memory chunk size
  * @param maxPreallocated max chunks preallocated
  *
  * @return Success status, true if successful
  */
 bool rtsafe_memory_pool_create(RtMemPool_Handle* handlePtr,
-                               const char* poolName,
                                size_t dataSize,
                                size_t maxPreallocated);
 
diff --git a/src/socket.c b/src/socket.c
index b21afae..3ffdba6 100644
--- a/src/socket.c
+++ b/src/socket.c
@@ -32,6 +32,7 @@
 #else
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <netinet/tcp.h>
 #define closesocket close
 #define INVALID_SOCKET -1
 typedef int SOCKET;
@@ -160,11 +161,16 @@ int socket_start(int socket_port, int feedback_port, int buffer_size)
     if (feedback_port != 0)
         setsockopt(g_fbserverfd, SOL_SOCKET, SO_REUSEPORT, &value, sizeof(value));
 
-    /* increase socket size */
+    /* Increase socket size */
     value = 131071;
     setsockopt(g_serverfd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
     if (feedback_port != 0)
         setsockopt(g_fbserverfd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
+
+    /* Set TCP_NODELAY */
+    setsockopt(g_serverfd, IPPROTO_TCP, TCP_NODELAY, &value, sizeof(value));
+    if (feedback_port != 0)
+        setsockopt(g_fbserverfd, IPPROTO_TCP, TCP_NODELAY, &value, sizeof(value));
 #endif
 
     /* Startup the socket struct */
@@ -342,7 +348,7 @@ void socket_run(int exit_on_failure)
 
         if (count > 0) /* Data received */
         {
-            if (count == g_buffer_size)
+            if (count == g_buffer_size && buffer[count - 1] != '\0')
             {
                 /* if message is bigger than our buffer, dynamically allocate more data until we receive it all */
                 int new_count, new_buffer_size;
@@ -371,6 +377,9 @@ void socket_run(int exit_on_failure)
                     if (new_count > 0) /* Data received */
                     {
                         count += new_count;
+
+                        if (msgbuffer[count - 1] == '\0')
+                            break;
                     }
                     else if (new_count < 0) /* Error */
                     {
@@ -391,10 +400,34 @@ void socket_run(int exit_on_failure)
                 msgbuffer = buffer;
             }
 
-            msg.sender_id = clientfd;
-            msg.data = msgbuffer;
-            msg.data_size = count;
-            if (g_receive_cb) g_receive_cb(&msg);
+            if (g_receive_cb)
+            {
+                // ignore leftover null bytes
+                while (count > 1 && msgbuffer[count - 1] == '\0')
+                    --count;
+
+                // make sure to keep 1 null byte at the end of the string
+                ++count;
+
+                msg.data = msgbuffer;
+
+                while (count > 0)
+                {
+                    if (*msg.data == '\0')
+                    {
+                        --count;
+                        ++msg.data;
+                        continue;
+                    }
+
+                    msg.sender_id = clientfd;
+                    msg.data_size = strlen(msg.data) + 1;
+                    g_receive_cb(&msg);
+
+                    count -= msg.data_size;
+                    msg.data += msg.data_size;
+                }
+            }
 
             if (msgbuffer != buffer)
                 free(msgbuffer);
diff --git a/src/uridmap.c b/src/uridmap.c
index c360e93..c9eb6d5 100644
--- a/src/uridmap.c
+++ b/src/uridmap.c
@@ -46,12 +46,6 @@ const char* unmap_urid(LV2_URID_Unmap_Handle handle, LV2_URID urid)
     return uri;
 }
 
-uint32_t uri_to_id(LV2_URI_Map_Callback_Data callback_data, const char* map, const char* uri)
-{
-    UNUSED_PARAM(map);
-    return map_urid(callback_data, uri);
-}
-
 LV2_URID urid_to_id(LV2_URID_Map_Handle handle, const char* uri)
 {
     return map_urid(handle, uri);
@@ -61,3 +55,23 @@ const char* id_to_urid(LV2_URID_Unmap_Handle handle, LV2_URID urid)
 {
     return unmap_urid(handle, urid);
 }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+uint32_t uri_to_id(LV2_URI_Map_Callback_Data callback_data, const char* map, const char* uri)
+{
+    UNUSED_PARAM(map);
+    return map_urid(callback_data, uri);
+}
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#pragma GCC diagnostic pop
+#endif
diff --git a/src/uridmap.h b/src/uridmap.h
index 013cd9f..e7a9543 100644
--- a/src/uridmap.h
+++ b/src/uridmap.h
@@ -27,8 +27,23 @@ void urid_sem_init(void);
 LV2_URID map_urid(LV2_URID_Map_Handle handle, const char* uri);
 const char* unmap_urid(LV2_URID_Unmap_Handle handle, LV2_URID urid);
 
-uint32_t uri_to_id(LV2_URI_Map_Callback_Data callback_data, const char* map, const char* uri);
 LV2_URID urid_to_id(LV2_URID_Map_Handle handle, const char* uri);
 const char* id_to_urid(LV2_URID_Unmap_Handle handle, LV2_URID urid);
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+uint32_t uri_to_id(LV2_URI_Map_Callback_Data callback_data, const char* map, const char* uri);
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#pragma GCC diagnostic pop
+#endif
+
 #endif
diff --git a/src/utils.c b/src/utils.c
index 46674e7..787731d 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -25,6 +25,7 @@
 #include "utils.h"
 #include <math.h>
 #include <string.h>
+#include <time.h>
 
 
 /*
@@ -244,3 +245,32 @@ char *str_duplicate(const char *str)
     strcpy(copy, str);
     return copy;
 }
+
+
+#if defined(__ARM_ARCH_8A) && !defined(_MOD_DEVICE_DUOX)
+static uint64_t _cntfrq_ratio = 0;
+#endif
+
+void time_ns_init()
+{
+#if defined(__ARM_ARCH_8A) && !defined(_MOD_DEVICE_DUOX)
+    uint64_t r;
+    asm volatile("mrs %0, CNTFRQ_EL0" : "=r"(r));
+    // 1e6 for MHz clock speed, then converted to nano-seconds ratio
+    _cntfrq_ratio = 1000 / (r / 1e6);
+#endif
+}
+
+
+uint64_t time_ns_get()
+{
+#if defined(__ARM_ARCH_8A) && !defined(_MOD_DEVICE_DUOX)
+    uint64_t r;
+    asm volatile("mrs %0, CNTVCT_EL0" : "=r"(r));
+    return r * _cntfrq_ratio;
+#else
+    struct timespec time;
+    clock_gettime(CLOCK_MONOTONIC_RAW, &time);
+    return (uint64_t) time.tv_sec * 1e9 + (uint64_t) time.tv_nsec;
+#endif
+}
diff --git a/src/utils.h b/src/utils.h
index 2e50905..ba6ba7a 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -130,6 +130,10 @@ float clampf(float value, float min, float max)
     return value < min ? min : (value > max ? max : value);
 }
 
+// get time in nanoseconds
+void time_ns_init();
+uint64_t time_ns_get();
+
 
 /*
 ************************************************************************************************************************
diff --git a/src/worker.c b/src/worker.c
index 6159d6c..5ed0e38 100644
--- a/src/worker.c
+++ b/src/worker.c
@@ -1,5 +1,6 @@
 /*
   Copyright 2007-2012 David Robillard <http://drobilla.net>
+  Copyright 2016-2026 Filipe Coelho <falktx@falktx.com>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
@@ -14,9 +15,16 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
+#include "worker.h"
+
+#include <sched.h>
 #include <stdlib.h>
 
-#include "worker.h"
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
 
 static LV2_Worker_Status worker_respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void* data)
 {
@@ -32,22 +40,30 @@ static void* worker_func(void* data)
 {
     worker_t* worker = (worker_t*)data;
     void* buf = NULL;
+    uint32_t size;
     while (true) {
         sem_wait(&worker->sem);
         if (worker->exit) break;
 
         while (jack_ringbuffer_read_space(worker->requests) != 0) {
-            uint32_t size = 0;
-            jack_ringbuffer_read(worker->requests, (char*)&size, sizeof(size));
+            size = 0;
+            jack_ringbuffer_peek(worker->requests, (char*)&size, sizeof(size));
 
-            if (!(buf = realloc(buf, size))) {
-                fprintf(stderr, "worker_func: realloc() failed\n");
-                free(buf);
-                return NULL;
+            if (jack_ringbuffer_read_space(worker->requests) < sizeof(size) + size) {
+                sched_yield();
+                continue;
             }
 
-            jack_ringbuffer_read(worker->requests, (char*)buf, size);
-            worker->iface->work(worker->instance->lv2_handle, worker_respond, worker, size, buf);
+            jack_ringbuffer_read_advance(worker->requests, sizeof(size));
+
+            void *const new_buf = realloc(buf, size);
+            if (new_buf) {
+                buf = new_buf;
+                jack_ringbuffer_read(worker->requests, (char*)buf, size);
+                worker->iface->work(worker->instance->lv2_handle, worker_respond, worker, size, buf);
+            } else {
+                jack_ringbuffer_read_advance(worker->requests, size);
+            }
         }
     }
 
@@ -64,9 +80,18 @@ void worker_init(worker_t *worker, LilvInstance *instance, const LV2_Worker_Inte
     zix_thread_create(&worker->thread, size + sizeof(void*) * 4, worker_func, worker);
     worker->requests  = jack_ringbuffer_create(size);
     worker->responses = jack_ringbuffer_create(size);
-    worker->response  = malloc(size);
     jack_ringbuffer_mlock(worker->requests);
     jack_ringbuffer_mlock(worker->responses);
+
+    const uint32_t max_response_size = jack_ringbuffer_write_space(worker->responses);
+    worker->response = malloc(max_response_size);
+#ifdef _WIN32
+    VirtualLock(worker, sizeof(max_response_size));
+    VirtualLock(worker->response, max_response_size);
+#else
+    mlock(worker, sizeof(*worker));
+    mlock(worker->response, max_response_size);
+#endif
 }
 
 void worker_finish(worker_t *worker)
@@ -95,14 +120,19 @@ LV2_Worker_Status worker_schedule(LV2_Worker_Schedule_Handle handle, uint32_t si
 void worker_emit_responses(worker_t *worker)
 {
     if (worker->responses) {
-        uint32_t read_space = jack_ringbuffer_read_space(worker->responses);
-        while (read_space) {
-            uint32_t size = 0;
-            jack_ringbuffer_read(worker->responses, (char*)&size, sizeof(size));
+        uint32_t size;
+        while (jack_ringbuffer_read_space(worker->responses) != 0) {
+            size = 0;
+            jack_ringbuffer_peek(worker->responses, (char*)&size, sizeof(size));
+
+            if (jack_ringbuffer_read_space(worker->responses) < sizeof(size) + size) {
+                break;
+            }
+
+            jack_ringbuffer_read_advance(worker->responses, sizeof(size));
             jack_ringbuffer_read(worker->responses, (char*)worker->response, size);
 
             worker->iface->work_response(worker->instance->lv2_handle, size, worker->response);
-            read_space -= sizeof(size) + size;
         }
     }
 }
diff --git a/src/worker.h b/src/worker.h
index 65401fa..62335b9 100644
--- a/src/worker.h
+++ b/src/worker.h
@@ -1,5 +1,6 @@
 /*
   Copyright 2007-2012 David Robillard <http://drobilla.net>
+  Copyright 2016-2026 Filipe Coelho <falktx@falktx.com>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
diff --git a/src/zix/thread.h b/src/zix/thread.h
index 2c5bd14..f7e8dd5 100644
--- a/src/zix/thread.h
+++ b/src/zix/thread.h
@@ -94,7 +94,18 @@ zix_thread_create(ZixThread* thread,
 {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
-    pthread_attr_setstacksize(&attr, stack_size);
+
+    if (stack_size != 0)
+        pthread_attr_setstacksize(&attr, stack_size);
+
+#ifdef _MOD_DEVICE_RK358x
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    for (int i = 0; i < 4; ++i)
+        CPU_SET(i, &cpuset);
+
+    pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset);
+#endif
 
     const int ret = pthread_create(thread, &attr, function, arg);
     pthread_attr_destroy(&attr);