diff --git a/components/bl00mbox/bl00mbox.c b/components/bl00mbox/bl00mbox.c
index ade8e30295642a7b1d6ad5bc34a333924b62683b..a31700e299c7c67e0d8bf84f79a81c81e13f3801 100644
--- a/components/bl00mbox/bl00mbox.c
+++ b/components/bl00mbox/bl00mbox.c
@@ -1,10 +1,10 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox.h"
-#include "bl00mbox_audio.h"
 #include "bl00mbox_plugin_registry.h"
+#include "bl00mbox_audio.h"
 #include "st3m_audio.h"
 
-void bl00mbox_init() {
+void bl00mbox_init(){
     bl00mbox_plugin_registry_init();
     st3m_audio_set_player_function(bl00mbox_audio_render);
     bl00mbox_channels_init();
diff --git a/components/bl00mbox/bl00mbox_audio.c b/components/bl00mbox/bl00mbox_audio.c
index ba19f3d2186e23b738ef1f6d69381ec8ef38b1d4..deaca35dba952234438adb1dc22c52787f457e03 100644
--- a/components/bl00mbox/bl00mbox_audio.c
+++ b/components/bl00mbox/bl00mbox_audio.c
@@ -1,10 +1,10 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox_audio.h"
 
 static bool is_initialized = false;
 static bool bl00mbox_audio_run = true;
-void bl00mbox_audio_enable() { bl00mbox_audio_run = true; }
-void bl00mbox_audio_disable() { bl00mbox_audio_run = false; }
+void bl00mbox_audio_enable(){ bl00mbox_audio_run = true; }
+void bl00mbox_audio_disable(){ bl00mbox_audio_run = false; }
 
 static uint32_t render_pass_id;
 
@@ -15,14 +15,11 @@ static int8_t last_chan_event = 0;
 // note: regardless of settings the system channel 0 is always rendered
 static uint8_t bl00mbox_channel_foreground = 0;
 // channels may request being active while not being in foreground
-static bool bl00mbox_channel_background_mute_override[BL00MBOX_CHANNELS] = {
-    false,
-};
+static bool bl00mbox_channel_background_mute_override[BL00MBOX_CHANNELS] = {false,};
 
-bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index,
-                                                   bool enable) {
+bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, bool enable){
 #ifdef BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE
-    if (channel_index >= BL00MBOX_CHANNELS) return false;
+    if(channel_index >= BL00MBOX_CHANNELS) return false;
     bl00mbox_channel_background_mute_override[channel_index] = enable;
     return true;
 #else
@@ -30,39 +27,38 @@ bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index,
 #endif
 }
 
-bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index) {
-    if (channel_index >= BL00MBOX_CHANNELS) return false;
+bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index){
+    if(channel_index >= BL00MBOX_CHANNELS) return false;
     return bl00mbox_channel_background_mute_override[channel_index];
 }
 
-static void** ptr_to_be_set_by_audio_task = NULL;
-static void* ptr_to_be_set_by_audio_task_target = NULL;
+static void ** ptr_to_be_set_by_audio_task = NULL;
+static void * ptr_to_be_set_by_audio_task_target = NULL;
 // TODO: multicore thread safety on this boi
 static volatile bool ptr_set_request_pending = false;
 static uint64_t bl00mbox_audio_waitfor_timeout = 0ULL;
 
-bool bl00mbox_audio_waitfor_pointer_change(void** ptr, void* new_val) {
-    if (!is_initialized) return false;
+bool bl00mbox_audio_waitfor_pointer_change(void ** ptr, void * new_val){
     /// takes pointer to pointer that is to be set null
+    if(!is_initialized) return false;
     ptr_to_be_set_by_audio_task = ptr;
     ptr_to_be_set_by_audio_task_target = new_val;
     ptr_set_request_pending = true;
 
-    volatile uint64_t timeout = 0;  // cute
-    while (ptr_set_request_pending) {
+    volatile uint64_t timeout = 0; // cute
+    while(ptr_set_request_pending){
         timeout++;
         // TODO: nop
-        if (bl00mbox_audio_waitfor_timeout &&
-            (timeout = bl00mbox_audio_waitfor_timeout)) {
+        if(bl00mbox_audio_waitfor_timeout && (timeout = bl00mbox_audio_waitfor_timeout)){
             return false;
         }
     }
     return true;
 }
 
-bool bl00mbox_audio_do_pointer_change() {
-    if (ptr_set_request_pending) {
-        (*ptr_to_be_set_by_audio_task) = ptr_to_be_set_by_audio_task_target;
+bool bl00mbox_audio_do_pointer_change(){
+    if(ptr_set_request_pending){
+        (* ptr_to_be_set_by_audio_task) = ptr_to_be_set_by_audio_task_target;
         ptr_to_be_set_by_audio_task_target = NULL;
         ptr_to_be_set_by_audio_task = NULL;
         ptr_set_request_pending = false;
@@ -71,26 +67,28 @@ bool bl00mbox_audio_do_pointer_change() {
     return false;
 }
 
-void bl00mbox_channel_event(uint8_t chan) { last_chan_event = chan; }
+void bl00mbox_channel_event(uint8_t chan){
+    last_chan_event = chan;
+}
 
-bl00mbox_channel_t* bl00mbox_get_channel(uint8_t index) {
-    if (index >= BL00MBOX_CHANNELS) return NULL;
+bl00mbox_channel_t * bl00mbox_get_channel(uint8_t index){
+    if(index >= BL00MBOX_CHANNELS) return NULL;
     return &(channels[index]);
 }
 
-uint8_t bl00mbox_channel_get_foreground_index() {
+uint8_t bl00mbox_channel_get_foreground_index(){
     return bl00mbox_channel_foreground;
 }
 
-void bl00mbox_channel_set_foreground_index(uint8_t index) {
-    if (index >= BL00MBOX_CHANNELS) return;
+void bl00mbox_channel_set_foreground_index(uint8_t index){
+    if(index >= BL00MBOX_CHANNELS) return;
     bl00mbox_channel_foreground = index;
 }
 
-uint8_t bl00mbox_channel_get_free_index() {
+uint8_t bl00mbox_channel_get_free_index(){
     uint8_t ret = 1;
-    for (; ret < BL00MBOX_CHANNELS; ret++) {
-        if (bl00mbox_get_channel(ret)->is_free) {
+    for(; ret < BL00MBOX_CHANNELS; ret++){
+        if(bl00mbox_get_channel(ret)->is_free){
             bl00mbox_get_channel(ret)->is_free = false;
             break;
         }
@@ -99,9 +97,9 @@ uint8_t bl00mbox_channel_get_free_index() {
     return ret;
 }
 
-void bl00mbox_channels_init() {
-    for (uint8_t i = 0; i < BL00MBOX_CHANNELS; i++) {
-        bl00mbox_channel_t* chan = bl00mbox_get_channel(i);
+void bl00mbox_channels_init(){
+    for(uint8_t i = 0; i < BL00MBOX_CHANNELS; i++){
+        bl00mbox_channel_t * chan = bl00mbox_get_channel(i);
         chan->volume = BL00MBOX_DEFAULT_CHANNEL_VOLUME;
         chan->root_list = NULL;
         chan->buds = NULL;
@@ -112,69 +110,66 @@ void bl00mbox_channels_init() {
     is_initialized = true;
 }
 
-void bl00mbox_channel_enable(uint8_t chan) {
-    if (chan >= (BL00MBOX_CHANNELS)) return;
-    bl00mbox_channel_t* ch = bl00mbox_get_channel(chan);
+void bl00mbox_channel_enable(uint8_t chan){
+    if(chan >= (BL00MBOX_CHANNELS)) return;
+    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
     ch->is_active = true;
 }
 
-void bl00mbox_channel_disable(uint8_t chan) {
-    if (chan >= (BL00MBOX_CHANNELS)) return;
-    bl00mbox_channel_t* ch = bl00mbox_get_channel(chan);
+void bl00mbox_channel_disable(uint8_t chan){
+    if(chan >= (BL00MBOX_CHANNELS)) return;
+    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
     ch->is_active = false;
 }
 
-void bl00mbox_channel_set_volume(uint8_t chan, uint16_t volume) {
-    if (chan >= (BL00MBOX_CHANNELS)) return;
-    bl00mbox_channel_t* ch = bl00mbox_get_channel(chan);
+void bl00mbox_channel_set_volume(uint8_t chan, uint16_t volume){
+    if(chan >= (BL00MBOX_CHANNELS)) return;
+    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
     ch->volume = volume < 32767 ? volume : 32767;
 }
 
-int16_t bl00mbox_channel_get_volume(uint8_t chan) {
-    if (chan >= (BL00MBOX_CHANNELS)) return 0;
-    bl00mbox_channel_t* ch = bl00mbox_get_channel(chan);
+int16_t bl00mbox_channel_get_volume(uint8_t chan){
+    if(chan >= (BL00MBOX_CHANNELS)) return 0;
+    bl00mbox_channel_t * ch = bl00mbox_get_channel(chan);
     return ch->volume;
 }
 
-void bl00mbox_audio_bud_render(bl00mbox_bud_t* bud, uint16_t num_samples) {
-    if (bud->render_pass_id == render_pass_id) return;
+void bl00mbox_audio_bud_render(bl00mbox_bud_t * bud, uint16_t num_samples){
+    if(bud->render_pass_id == render_pass_id) return;
     bud->plugin->render(bud->plugin, num_samples, render_pass_id);
     bud->render_pass_id = render_pass_id;
 }
 
-static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan,
-                                          int16_t* out, uint16_t len,
-                                          bool adding) {
-    if (adding) {
+static void bl00mbox_audio_channel_render(bl00mbox_channel_t * chan, int16_t * out, uint16_t len, bool adding){
+    if(adding){
         // ^ to make clang-tidy happy
-        if (render_pass_id == chan->render_pass_id) return;
+        // only to pass flow3r ci, omit before compliling
+        if(render_pass_id == chan->render_pass_id) return;
     }
 
     chan->render_pass_id = render_pass_id;
 
-    bl00mbox_channel_root_t* root = chan->root_list;
+    bl00mbox_channel_root_t * root = chan->root_list;
 
     // early exit when no sources:
-    if ((root == NULL) || (!chan->is_active)) {
-        if (adding) return;                     // nothing to do
-        memset(out, 0, len * sizeof(int16_t));  // mute
+    if((root == NULL) || (!chan->is_active)){
+        if(adding) return; // nothing to do
+        memset(out, 0, len*sizeof(int16_t)); // mute
         return;
     }
-    if (root == NULL) return;  // clang garbage, undo asap
+    if(root == NULL) return; // more clang garbage, undo before compliling
 
     int32_t acc[256];
     bool first = true;
 
-    while (root != NULL) {
+    while(root != NULL){
         bl00mbox_audio_bud_render(root->con->source_bud, len);
-        if (first) {
-            for (uint16_t i = 0; i < len; i++) {
+        if(first){
+            for(uint16_t i = 0; i < len; i++){
                 acc[i] = root->con->buffer[i];
             }
         } else {
-            for (uint16_t i = 0; i < len;
-                 i++) {  // replace this with proper ladspa-style adding
-                         // function someday
+            for(uint16_t i = 0; i < len; i++){ // replace this with proper ladspa-style adding function someday
                 acc[i] += root->con->buffer[i];
             }
         }
@@ -182,59 +177,56 @@ static void bl00mbox_audio_channel_render(bl00mbox_channel_t* chan,
         root = root->next;
     }
 
-    for (uint16_t i = 0; i < len; i++) {
-        if (adding) {
-            out[i] =
-                radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]);
+    for(uint16_t i = 0; i < len; i++){
+        if(adding){
+            out[i] = radspa_add_sat(radspa_mult_shift(acc[i], chan->volume), out[i]);
         } else {
             out[i] = radspa_mult_shift(acc[i], chan->volume);
         }
     }
 }
 
-void bl00mbox_audio_render(int16_t* rx, int16_t* tx, uint16_t len) {
-    if (!is_initialized) {
-        memset(tx, 0, len * sizeof(int16_t));  // mute
+void bl00mbox_audio_render(int16_t * rx, int16_t * tx, uint16_t len){
+    if(!is_initialized){
+        memset(tx, 0, len*sizeof(int16_t)); // mute
         return;
     }
 
     bl00mbox_audio_do_pointer_change();
     bl00mbox_channel_foreground = last_chan_event;
 
-    if (!bl00mbox_audio_run) {
-        memset(tx, 0, len * sizeof(int16_t));  // mute
+    if(!bl00mbox_audio_run){
+        memset(tx, 0, len*sizeof(int16_t)); // mute
         return;
     }
 
-    render_pass_id++;  // fresh pass, all relevant sources must be recomputed
-    uint16_t mono_len = len / 2;
+    render_pass_id++; // fresh pass, all relevant sources must be recomputed
+    uint16_t mono_len = len/2;
     int16_t acc[mono_len];
     // system channel always runs non-adding
     bl00mbox_audio_channel_render(&(channels[0]), acc, mono_len, 0);
 
-    // re-rendering channels is ok, if render_pass_id didn't change it will just
-    // exit
-    bl00mbox_audio_channel_render(&(channels[bl00mbox_channel_foreground]), acc,
-                                  mono_len, 1);
+    // re-rendering channels is ok, if render_pass_id didn't change it will just exit
+    bl00mbox_audio_channel_render(&(channels[bl00mbox_channel_foreground]), acc, mono_len, 1);
 
     // TODO: scales poorly if there's many channels
 #ifdef BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE
-    for (uint8_t i = 1; i < (BL00MBOX_CHANNELS); i++) {
-        if (bl00mbox_channel_background_mute_override[i]) {
+    for(uint8_t i = 1; i < (BL00MBOX_CHANNELS); i++){
+        if(bl00mbox_channel_background_mute_override[i]){
             bl00mbox_audio_channel_render(&(channels[i]), acc, mono_len, 1);
         }
     }
 #endif
 
-    for (uint16_t i = 0; i < mono_len; i++) {
-        st3m_scope_write((acc[i]) >> 4);
+    for(uint16_t i = 0; i < mono_len; i++){
+        st3m_scope_write((acc[i])>>4);
 
-        tx[2 * i] = acc[i];
-        tx[2 * i + 1] = acc[i];
+        tx[2*i] = acc[i];
+        tx[2*i+1] = acc[i];
     }
 }
 
 // TEMP
-void bl00mbox_player_function(int16_t* rx, int16_t* tx, uint16_t len) {
+void bl00mbox_player_function(int16_t * rx, int16_t * tx, uint16_t len){
     bl00mbox_audio_render(rx, tx, len);
 }
diff --git a/components/bl00mbox/bl00mbox_plugin_registry.c b/components/bl00mbox/bl00mbox_plugin_registry.c
index f0e0734572c2664142c7def4283dcb806bef5b90..66d4dd4ce81aa766b5ea4598b871037432073c6d 100644
--- a/components/bl00mbox/bl00mbox_plugin_registry.c
+++ b/components/bl00mbox/bl00mbox_plugin_registry.c
@@ -1,64 +1,57 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox_plugin_registry.h"
 
-bl00mbox_plugin_registry_t* bl00mbox_plugin_registry = NULL;
+bl00mbox_plugin_registry_t * bl00mbox_plugin_registry = NULL;
 uint16_t bl00mbox_plugin_registry_len = 0;
 bool bl00mbox_plugin_registry_is_initialized = false;
 
-static void plugin_add(radspa_descriptor_t* descriptor) {
-    if (bl00mbox_plugin_registry_len == 65535) {
+static void plugin_add(radspa_descriptor_t * descriptor){
+    if(bl00mbox_plugin_registry_len == 65535){
         printf("too many plugins registered");
         abort();
     }
 
     // create plugin registry entry
-    bl00mbox_plugin_registry_t* p = malloc(sizeof(bl00mbox_plugin_registry_t));
-    if (p == NULL) {
-        printf("bl00mbox: no memory for plugin list");
-        abort();
-    }
+    bl00mbox_plugin_registry_t * p = malloc(sizeof(bl00mbox_plugin_registry_t));
+    if(p == NULL){ printf("bl00mbox: no memory for plugin list"); abort(); }
     p->descriptor = descriptor;
     p->next = NULL;
 
     // go to end of list
-    bl00mbox_plugin_registry_t* plast = bl00mbox_plugin_registry;
-    if (plast == NULL) {
+    bl00mbox_plugin_registry_t * plast = bl00mbox_plugin_registry;
+    if(plast == NULL){
         bl00mbox_plugin_registry = p;
     } else {
-        while (plast->next != NULL) {
-            plast = plast->next;
-        }
+        while(plast->next != NULL){ plast = plast->next; }
         plast->next = p;
     }
     bl00mbox_plugin_registry_len++;
 }
 
-uint16_t bl00mbox_plugin_registry_get_plugin_num(void) {
+uint16_t bl00mbox_plugin_registry_get_plugin_num(void){
     return bl00mbox_plugin_registry_len;
 }
 
-radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_id(
-    uint32_t id) {
+radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_id(uint32_t id){
     /// searches plugin registry for first descriptor with given id number
     /// and returns pointer to it. returns NULL if no match is found.
-    bl00mbox_plugin_registry_t* p = bl00mbox_plugin_registry;
-    while (p != NULL) {
-        if (p->descriptor->id == id) break;
+    bl00mbox_plugin_registry_t * p = bl00mbox_plugin_registry;
+    while(p != NULL){
+        if(p->descriptor->id == id) break;
         p = p->next;
     }
-    if (p != NULL) return p->descriptor;
+    if(p != NULL) return p->descriptor;
     return NULL;
 }
 
-radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_index(
-    uint32_t index) {
+radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_index(uint32_t index){
     /// returns pointer to descriptor of registry entry at given index.
     /// returns NULL if out of range.
-    if (index >= bl00mbox_plugin_registry_len) return NULL;
-    bl00mbox_plugin_registry_t* p = bl00mbox_plugin_registry;
-    for (uint16_t i = 0; i < index; i++) {
+    if(index >= bl00mbox_plugin_registry_len) return NULL;
+    bl00mbox_plugin_registry_t * p = bl00mbox_plugin_registry;
+    for(uint16_t i = 0; i < index; i++){
         p = p->next;
-        if (p == NULL) {
+        if(p == NULL){
             printf("bl00mbox: plugin list length error");
             abort();
         }
@@ -66,15 +59,14 @@ radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_index(
     return p->descriptor;
 }
 
-radspa_descriptor_t* bl00mbox_plugin_registry_get_id_from_index(
-    uint32_t index) {
+radspa_descriptor_t * bl00mbox_plugin_registry_get_id_from_index(uint32_t index){
     /// returns pointer to descriptor of registry entry at given index.
     /// returns NULL if out of range.
-    if (index >= bl00mbox_plugin_registry_len) return NULL;
-    bl00mbox_plugin_registry_t* p = bl00mbox_plugin_registry;
-    for (uint16_t i = 0; i < index; i++) {
+    if(index >= bl00mbox_plugin_registry_len) return NULL;
+    bl00mbox_plugin_registry_t * p = bl00mbox_plugin_registry;
+    for(uint16_t i = 0; i < index; i++){
         p = p->next;
-        if (p == NULL) {
+        if(p == NULL){
             printf("bl00mbox: plugin list length error");
             abort();
         }
@@ -95,21 +87,21 @@ radspa_descriptor_t* bl00mbox_plugin_registry_get_id_from_index(
  * removing plugins from the registry at runtime is not intended.
  */
 
+#include "trad_synth.h"
 #include "ampliverter.h"
 #include "delay.h"
-#include "trad_synth.h"
-// #include "filter.h"
-// #include "sequence_timer.h"
-#include "sampler.h"
+//#include "filter.h"
+//#include "sequence_timer.h"
 #include "sequencer.h"
-void bl00mbox_plugin_registry_init(void) {
-    if (bl00mbox_plugin_registry_is_initialized) return;
+#include "sampler.h"
+void bl00mbox_plugin_registry_init(void){
+    if(bl00mbox_plugin_registry_is_initialized) return;
     plugin_add(&trad_osc_desc);
     plugin_add(&ampliverter_desc);
-    plugin_add(&trad_env_desc);
-    plugin_add(&delay_desc);
-    //    plugin_add(&filter_desc);
-    //    plugin_add(&sequence_timer_desc);
+    plugin_add(&trad_env_desc);   
+    plugin_add(&delay_desc);   
+//    plugin_add(&filter_desc);   
+//    plugin_add(&sequence_timer_desc);
     plugin_add(&sequencer_desc);
     plugin_add(&sampler_desc);
 }
diff --git a/components/bl00mbox/bl00mbox_radspa_requirements.c b/components/bl00mbox/bl00mbox_radspa_requirements.c
index 5a931e4949877e1ebcfe579f3f5cdfffd7d827c7..e24e9f6a650b2a4ff49be4980257e321e123c3fc 100644
--- a/components/bl00mbox/bl00mbox_radspa_requirements.c
+++ b/components/bl00mbox/bl00mbox_radspa_requirements.c
@@ -1,8 +1,8 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox_radspa_requirements.h"
 
-bool radspa_host_request_buffer_render(int16_t *buf, uint16_t num_samples) {
-    bl00mbox_bud_t *bud = ((bl00mbox_connection_t *)buf)->source_bud;
+bool radspa_host_request_buffer_render(int16_t * buf, uint16_t num_samples){
+    bl00mbox_bud_t * bud = ((bl00mbox_connection_t *) buf)->source_bud;
     bl00mbox_audio_bud_render(bud, num_samples);
     return 1;
 }
@@ -10,85 +10,86 @@ bool radspa_host_request_buffer_render(int16_t *buf, uint16_t num_samples) {
 // py: bigtable = [int(22/200*(2**(14-5+8+x*4096/2400/64))) for x in range(64)]
 // for 48kHz main sample rate
 static const uint16_t bigtable[64] = {
-    14417, 14686, 14960, 15240, 15524, 15813, 16108, 16409, 16715, 17027, 17345,
-    17668, 17998, 18334, 18676, 19024, 19379, 19741, 20109, 20484, 20866, 21255,
-    21652, 22056, 22467, 22887, 23313, 23748, 24191, 24643, 25103, 25571, 26048,
-    26534, 27029, 27533, 28047, 28570, 29103, 29646, 30199, 30763, 31336, 31921,
-    32517, 33123, 33741, 34371, 35012, 35665, 36330, 37008, 37699, 38402, 39118,
-    39848, 40592, 41349, 42120, 42906, 43706, 44522, 45352, 46199
+        14417, 14686, 14960, 15240, 15524, 15813, 16108, 16409, 
+        16715, 17027, 17345, 17668, 17998, 18334, 18676, 19024, 
+        19379, 19741, 20109, 20484, 20866, 21255, 21652, 22056, 
+        22467, 22887, 23313, 23748, 24191, 24643, 25103, 25571, 
+        26048, 26534, 27029, 27533, 28047, 28570, 29103, 29646, 
+        30199, 30763, 31336, 31921, 32517, 33123, 33741, 34371, 
+        35012, 35665, 36330, 37008, 37699, 38402, 39118, 39848, 
+        40592, 41349, 42120, 42906, 43706, 44522, 45352, 46199
 };
 
-// py: smoltable = [int(22/240*(2**(15-5+9+x*4096/2400/64/64))) for x in
-// range(64)] for 48kHz main sample rate
+// py: smoltable = [int(22/240*(2**(15-5+9+x*4096/2400/64/64))) for x in range(64)]
+// for 48kHz main sample rate
 static const uint16_t smoltable[64] = {
-    48059, 48073, 48087, 48101, 48115, 48129, 48143, 48156, 48170, 48184, 48198,
-    48212, 48226, 48240, 48254, 48268, 48282, 48296, 48310, 48324, 48338, 48352,
-    48366, 48380, 48394, 48407, 48421, 48435, 48449, 48463, 48477, 48491, 48505,
-    48519, 48533, 48548, 48562, 48576, 48590, 48604, 48618, 48632, 48646, 48660,
-    48674, 48688, 48702, 48716, 48730, 48744, 48758, 48772, 48786, 48801, 48815,
-    48829, 48843, 48857, 48871, 48885, 48899, 48913, 48928, 48942,
+        48059, 48073, 48087, 48101, 48115, 48129, 48143, 48156, 
+        48170, 48184, 48198, 48212, 48226, 48240, 48254, 48268, 
+        48282, 48296, 48310, 48324, 48338, 48352, 48366, 48380, 
+        48394, 48407, 48421, 48435, 48449, 48463, 48477, 48491, 
+        48505, 48519, 48533, 48548, 48562, 48576, 48590, 48604, 
+        48618, 48632, 48646, 48660, 48674, 48688, 48702, 48716, 
+        48730, 48744, 48758, 48772, 48786, 48801, 48815, 48829, 
+        48843, 48857, 48871, 48885, 48899, 48913, 48928, 48942,
 };
 
-uint32_t radspa_sct_to_rel_freq(int16_t sct, int16_t undersample_pow) {
-    /// returns approx. proportional to 2**((sct/2400) + undersample_pow) so
-    /// that a uint32_t accumulator overflows at 440Hz with sct = INT16_MAX -
-    /// 6*2400 when sampled at (48>>undersample_pow)kHz
+uint32_t radspa_sct_to_rel_freq(int16_t sct, int16_t undersample_pow){
+    /// returns approx. proportional to 2**((sct/2400) + undersample_pow) so that
+    /// a uint32_t accumulator overflows at 440Hz with sct = INT16_MAX - 6*2400
+    /// when sampled at (48>>undersample_pow)kHz
 
     // compiler explorer says this is 33 instructions with O2. might be alright?
     uint32_t a = sct;
-    a = sct + 28 * 2400 - 32767 - 330;
-    // at O2 u get free division for each modulo. still slow, 10 instructions or
-    // so.
+    a = sct + 28*2400 - 32767 - 330;
+    // at O2 u get free division for each modulo. still slow, 10 instructions or so.
     int16_t octa = a / 2400;
     a = a % 2400;
     uint8_t bigindex = a / 64;
     uint8_t smolindex = a % 64;
-
-    uint32_t ret = 2;  // weird but trust us
+    
+    uint32_t ret = 2; //weird but trust us
     ret *= bigtable[bigindex];
     ret *= smoltable[smolindex];
 
     int16_t shift = 27 - octa - undersample_pow;
-    if (shift > 0) {
+    if(shift > 0){
         ret = ret >> shift;
     }
     return ret;
 }
 
-int16_t radspa_clip(int32_t a) {
-    if (a > 32767) {
-        return 32767;
-    } else if (a < -32767) {
-        return -32767;
+int16_t radspa_clip(int32_t a){
+    if(a > 32767){
+         return 32767;
+    } else if(a < -32767){
+         return -32767;
     }
     return a;
 }
 
-int16_t radspa_add_sat(int32_t a, int32_t b) { return radspa_clip(a + b); }
-int16_t radspa_mult_shift(int32_t a, int32_t b) {
-    return radspa_clip((a * b) >> 15);
-}
+int16_t radspa_add_sat(int32_t a, int32_t b){ return radspa_clip(a+b); }
+int16_t radspa_mult_shift(int32_t a, int32_t b){ return radspa_clip((a*b)>>15); }
 
-int16_t radspa_trigger_start(int16_t velocity, int16_t *hist) {
-    int16_t ret = ((*hist) > 0) ? -velocity : velocity;
-    (*hist) = ret;
+int16_t radspa_trigger_start(int16_t velocity, int16_t * hist){
+    int16_t ret = ((* hist) > 0) ? -velocity : velocity;
+    (* hist) = ret;
     return ret;
 }
 
-int16_t radspa_trigger_stop(int16_t *hist) {
-    (*hist) = 0;
+int16_t radspa_trigger_stop(int16_t * hist){
+    (* hist) = 0;
     return 0;
 }
 
-int16_t radspa_trigger_get(int16_t trigger_signal, int16_t *hist) {
+int16_t radspa_trigger_get(int16_t trigger_signal, int16_t * hist){
     int16_t ret = 0;
-    if ((!trigger_signal) && (*hist)) {  // stop
+    if((!trigger_signal) && (* hist)){ //stop
         ret = -1;
-    } else if (trigger_signal > 0) {
-        if ((*hist) <= 0) ret = trigger_signal;
-    } else if (trigger_signal < 0) {
-        if ((*hist) >= 0) ret = -trigger_signal;
+    } else if(trigger_signal > 0 ){
+        if((* hist) <= 0) ret = trigger_signal;
+    } else if(trigger_signal < 0 ){
+        if((* hist) >= 0) ret = -trigger_signal;
     }
-    (*hist) = trigger_signal;
+    (* hist) = trigger_signal;
     return ret;
 }
diff --git a/components/bl00mbox/bl00mbox_user.c b/components/bl00mbox/bl00mbox_user.c
index 2e7afb9d894cec2be3ee491f3136c2fbb3c537e0..cf237406d04d35429ac92844c9daedd5f82055d4 100644
--- a/components/bl00mbox/bl00mbox_user.c
+++ b/components/bl00mbox/bl00mbox_user.c
@@ -1,224 +1,206 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #include "bl00mbox_user.h"
 
 static uint64_t bl00mbox_bud_index = 1;
-bl00mbox_bud_t *bl00mbox_channel_get_bud_by_index(uint8_t channel,
-                                                  uint32_t index);
+bl00mbox_bud_t * bl00mbox_channel_get_bud_by_index(uint8_t channel, uint32_t index);
 
-uint16_t bl00mbox_channel_buds_num(uint8_t channel) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+uint16_t bl00mbox_channel_buds_num(uint8_t channel){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     uint16_t ret = 0;
-    if (chan->buds != NULL) {
-        bl00mbox_bud_t *last = chan->buds;
+    if(chan->buds != NULL){
+        bl00mbox_bud_t * last = chan->buds;
         ret++;
-        while (last->chan_next != NULL) {
+        while(last->chan_next != NULL){
             last = last->chan_next;
             ret++;
-        }
+        } 
     }
     return ret;
 }
 
-uint64_t bl00mbox_channel_get_bud_by_list_pos(uint8_t channel, uint32_t pos) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+uint64_t bl00mbox_channel_get_bud_by_list_pos(uint8_t channel, uint32_t pos){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     uint16_t ret = 0;
-    if (chan->buds != NULL) {
-        bl00mbox_bud_t *last = chan->buds;
-        if (pos == ret) return last->index;
+    if(chan->buds != NULL){
+        bl00mbox_bud_t * last = chan->buds;
+        if(pos == ret) return last->index;
         ret++;
-        while (last->chan_next != NULL) {
+        while(last->chan_next != NULL){
             last = last->chan_next;
-            if (pos == ret) return last->index;
+            if(pos == ret) return last->index;
             ret++;
-        }
+        } 
     }
     return 0;
 }
 
-uint16_t bl00mbox_channel_conns_num(uint8_t channel) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+uint16_t bl00mbox_channel_conns_num(uint8_t channel){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     uint16_t ret = 0;
-    if (chan->connections != NULL) {
-        bl00mbox_connection_t *last = chan->connections;
+    if(chan->connections != NULL){
+        bl00mbox_connection_t * last = chan->connections;
         ret++;
-        while (last->chan_next != NULL) {
+        while(last->chan_next != NULL){
             last = last->chan_next;
             ret++;
-        }
+        } 
     }
     return ret;
 }
 
-uint16_t bl00mbox_channel_mixer_num(uint8_t channel) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+uint16_t bl00mbox_channel_mixer_num(uint8_t channel){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     uint16_t ret = 0;
-    if (chan->root_list != NULL) {
-        bl00mbox_channel_root_t *last = chan->root_list;
+    if(chan->root_list != NULL){
+        bl00mbox_channel_root_t * last = chan->root_list;
         ret++;
-        while (last->next != NULL) {
+        while(last->next != NULL){
             last = last->next;
             ret++;
-        }
+        } 
     }
     return ret;
 }
 
-uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel,
-                                                    uint32_t pos) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel, uint32_t pos){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     uint16_t ret = 0;
-    if (chan->buds != NULL) {
-        bl00mbox_channel_root_t *last = chan->root_list;
-        if (pos == ret) return last->con->source_bud->index;
+    if(chan->buds != NULL){
+        bl00mbox_channel_root_t * last = chan->root_list;
+        if(pos == ret) return last->con->source_bud->index;
         ret++;
-        while (last->next != NULL) {
+        while(last->next != NULL){
             last = last->next;
-            if (pos == ret) return last->con->source_bud->index;
+            if(pos == ret) return last->con->source_bud->index;
             ret++;
-        }
+        } 
     }
     return 0;
 }
 
-uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel,
-                                                       uint32_t pos) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel, uint32_t pos){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     uint16_t ret = 0;
-    if (chan->buds != NULL) {
-        bl00mbox_channel_root_t *last = chan->root_list;
-        if (pos == ret) return last->con->signal_index;
+    if(chan->buds != NULL){
+        bl00mbox_channel_root_t * last = chan->root_list;
+        if(pos == ret) return last->con->signal_index;
         ret++;
-        while (last->next != NULL) {
+        while(last->next != NULL){
             last = last->next;
-            if (pos == ret) return last->con->signal_index;
+            if(pos == ret) return last->con->signal_index;
             ret++;
-        }
+        } 
     }
     return 0;
 }
 
-uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index,
-                                         uint16_t signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return 0;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return 0;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, signal_index);
-    if (sig == NULL) return 0;
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)sig->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return 0;
+uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index, uint16_t signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return 0;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return 0;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index);
+    if(sig == NULL) return 0;
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct
+    if(conn == NULL) return 0;
 
     uint16_t ret = 0;
-    if (conn->subs != NULL) {
-        bl00mbox_connection_subscriber_t *last = conn->subs;
+    if(conn->subs != NULL){
+        bl00mbox_connection_subscriber_t * last = conn->subs;
         ret++;
-        while (last->next != NULL) {
+        while(last->next != NULL){
             last = last->next;
             ret++;
-        }
+        } 
     }
     return ret;
 }
 
-uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel,
-                                                         uint64_t bud_index,
-                                                         uint16_t signal_index,
-                                                         uint8_t pos) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return 0;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return 0;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, signal_index);
-    if (sig == NULL) return 0;
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)sig->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return 0;
+uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index,
+                uint16_t signal_index, uint8_t pos){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return 0;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return 0;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index);
+    if(sig == NULL) return 0;
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct
+    if(conn == NULL) return 0;
 
     uint16_t ret = 0;
-    if (conn->subs != NULL) {
-        bl00mbox_connection_subscriber_t *last = conn->subs;
-        if (pos == ret) return (last->type == 0) ? last->bud_index : 0;
+    if(conn->subs != NULL){
+        bl00mbox_connection_subscriber_t * last = conn->subs;
+        if(pos == ret) return (last->type == 0) ? last->bud_index : 0;
         ret++;
-        while (last->next != NULL) {
+        while(last->next != NULL){
             last = last->next;
-            if (pos == ret) return (last->type == 0) ? last->bud_index : 0;
+            if(pos == ret) return (last->type == 0) ? last->bud_index : 0;
             ret++;
-        }
+        } 
     }
     return 0;
 }
 
-int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos(
-    uint8_t channel, uint64_t bud_index, uint16_t signal_index, uint8_t pos) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return 0;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return 0;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, signal_index);
-    if (sig == NULL) return 0;
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)sig->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return 0;
+int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index,
+                uint16_t signal_index, uint8_t pos){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return 0;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return 0;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index);
+    if(sig == NULL) return 0;
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct
+    if(conn == NULL) return 0;
 
     uint16_t ret = 0;
-    if (conn->subs != NULL) {
-        bl00mbox_connection_subscriber_t *last = conn->subs;
-        if (pos == ret) return (last->type == 0) ? last->signal_index : -1;
+    if(conn->subs != NULL){
+        bl00mbox_connection_subscriber_t * last = conn->subs;
+        if(pos == ret) return (last->type == 0) ? last->signal_index : -1;
         ret++;
-        while (last->next != NULL) {
+        while(last->next != NULL){
             last = last->next;
-            if (pos == ret) return (last->type == 0) ? last->signal_index : -1;
+            if(pos == ret) return (last->type == 0) ? last->signal_index : -1;
             ret++;
-        }
+        } 
     }
     return 0;
 }
 
-uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index,
-                                         uint16_t signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return 0;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return 0;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, signal_index);
-    if (sig == NULL) return 0;
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)sig->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return 0;
+uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index, uint16_t signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return 0;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return 0;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index);
+    if(sig == NULL) return 0;
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct
+    if(conn == NULL) return 0;
     return conn->source_bud->index;
 }
 
-uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index,
-                                            uint16_t signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return 0;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return 0;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, signal_index);
-    if (sig == NULL) return 0;
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)sig->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return 0;
+uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index, uint16_t signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return 0;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return 0;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index);
+    if(sig == NULL) return 0;
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) sig->buffer; // buffer sits on top of struct
+    if(conn == NULL) return 0;
     return conn->signal_index;
 }
 
-static bl00mbox_connection_t *create_connection(uint8_t channel) {
-    bl00mbox_connection_t *ret = malloc(sizeof(bl00mbox_connection_t));
-    if (ret == NULL) return NULL;
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
+static bl00mbox_connection_t * create_connection(uint8_t channel){
+    bl00mbox_connection_t * ret = malloc(sizeof(bl00mbox_connection_t));
+    if(ret == NULL) return NULL;
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
     ret->chan_next = NULL;
     ret->subs = NULL;
     ret->channel = channel;
 
-    if (chan->connections != NULL) {
-        bl00mbox_connection_t *last = chan->connections;
-        while (last->chan_next != NULL) {
+    if(chan->connections != NULL){
+        bl00mbox_connection_t * last = chan->connections;
+        while(last->chan_next != NULL){
             last = last->chan_next;
         }
         last->chan_next = ret;
@@ -228,36 +210,32 @@ static bl00mbox_connection_t *create_connection(uint8_t channel) {
     return ret;
 }
 
-static bool weak_delete_connection(bl00mbox_connection_t *conn) {
-    if (conn->subs != NULL) return false;
+static bool weak_delete_connection(bl00mbox_connection_t * conn){
+    if(conn->subs != NULL) return false;
 
     // nullify source bud connection;
-    bl00mbox_bud_t *bud = conn->source_bud;
-    if (bud != NULL) {
-        radspa_signal_t *tx =
-            radspa_signal_get_by_index(bud->plugin, conn->signal_index);
-        if (tx != NULL) {
+    bl00mbox_bud_t * bud = conn->source_bud;
+    if(bud != NULL){
+        radspa_signal_t * tx = radspa_signal_get_by_index(bud->plugin, conn->signal_index);
+        if(tx != NULL){
             bl00mbox_audio_waitfor_pointer_change(&(tx->buffer), NULL);
         }
     }
 
     // pop from channel list
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(conn->channel);
-    if (chan->connections != NULL) {
-        if (chan->connections != conn) {
-            bl00mbox_connection_t *prev = chan->connections;
-            while (prev->chan_next != conn) {
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(conn->channel);
+    if(chan->connections != NULL){
+        if(chan->connections != conn){
+            bl00mbox_connection_t * prev = chan->connections;
+            while(prev->chan_next != conn){
                 prev = prev->chan_next;
-                if (prev->chan_next == NULL) {
+                if(prev->chan_next == NULL){
                     break;
                 }
             }
-            if (prev->chan_next != NULL)
-                bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next),
-                                                      conn->chan_next);
+            if(prev->chan_next != NULL) bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next), conn->chan_next);
         } else {
-            bl00mbox_audio_waitfor_pointer_change(&(chan->connections),
-                                                  conn->chan_next);
+            bl00mbox_audio_waitfor_pointer_change(&(chan->connections), conn->chan_next);
         }
     }
 
@@ -265,138 +243,120 @@ static bool weak_delete_connection(bl00mbox_connection_t *conn) {
     return true;
 }
 
-bl00mbox_bud_t *bl00mbox_channel_get_bud_by_index(uint8_t channel,
-                                                  uint32_t index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return NULL;
-    if (chan->buds == NULL) return NULL;
-    bl00mbox_bud_t *bud = chan->buds;
-    while (true) {
-        if (bud->index == index) break;
+bl00mbox_bud_t * bl00mbox_channel_get_bud_by_index(uint8_t channel, uint32_t index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return NULL;
+    if(chan->buds == NULL) return NULL;
+    bl00mbox_bud_t * bud = chan->buds;
+    while(true){
+        if(bud->index == index) break;
         bud = bud->chan_next;
-        if (bud == NULL) break;
+        if(bud == NULL) break;
     }
     return bud;
 }
 
-bl00mbox_bud_t *bl00mbox_channel_new_bud(uint8_t channel, uint32_t id,
-                                         uint32_t init_var) {
-    /// creates a new bud instance of the plugin with descriptor id "id" and the
-    /// initialization variable "init_var" and appends it to the plugin list of
-    /// the corresponding channel. returns pointer to the bud if successfull,
-    /// else NULL.
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return NULL;
-    radspa_descriptor_t *desc =
-        bl00mbox_plugin_registry_get_descriptor_from_id(id);
-    if (desc == NULL) return NULL;
-    bl00mbox_bud_t *bud = malloc(sizeof(bl00mbox_bud_t));
-    if (bud == NULL) return NULL;
-    radspa_t *plugin = desc->create_plugin_instance(init_var);
-    if (plugin == NULL) {
-        free(bud);
-        return NULL;
-    }
+bl00mbox_bud_t * bl00mbox_channel_new_bud(uint8_t channel, uint32_t id, uint32_t init_var){
+    /// creates a new bud instance of the plugin with descriptor id "id" and the initialization variable
+    /// "init_var" and appends it to the plugin list of the corresponding channel. returns pointer to
+    /// the bud if successfull, else NULL.
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return NULL;
+    radspa_descriptor_t * desc = bl00mbox_plugin_registry_get_descriptor_from_id(id);
+    if(desc == NULL) return NULL;
+    bl00mbox_bud_t * bud = malloc(sizeof(bl00mbox_bud_t));
+    if(bud == NULL) return NULL;
+    radspa_t * plugin = desc->create_plugin_instance(init_var);
+    if(plugin == NULL){ free(bud); return NULL; }
 
     bud->plugin = plugin;
     bud->channel = channel;
-    // TODO: look for empty indices
+    //TODO: look for empty indices
     bud->index = bl00mbox_bud_index;
     bl00mbox_bud_index++;
     bud->chan_next = NULL;
 
     // append to channel bud list
-    if (chan->buds == NULL) {
+    if(chan->buds == NULL){
         chan->buds = bud;
     } else {
-        bl00mbox_bud_t *last = chan->buds;
-        while (last->chan_next != NULL) {
-            last = last->chan_next;
-        }
+        bl00mbox_bud_t * last = chan->buds;
+        while(last->chan_next != NULL){ last = last->chan_next; } 
         last->chan_next = bud;
     }
     bl00mbox_channel_event(channel);
     return bud;
 }
 
-bool bl00mbox_channel_delete_bud(uint8_t channel, uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
+bool bl00mbox_channel_delete_bud(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
 
     // disconnect all signals
-    uint16_t num_signals =
-        bl00mbox_channel_bud_get_num_signals(channel, bud_index);
-    for (uint16_t i = 0; i < num_signals; i++) {
+    uint16_t num_signals = bl00mbox_channel_bud_get_num_signals(channel, bud_index);
+    for(uint16_t i = 0; i < num_signals; i++){
         bl00mbox_channel_disconnect_signal(channel, bud_index, i);
     }
 
     // pop from channel bud list
-    bl00mbox_bud_t *seek = chan->buds;
+    bl00mbox_bud_t * seek = chan->buds;
     bool free_later = false;
-    if (chan->buds != NULL) {
-        bl00mbox_bud_t *prev = NULL;
-        while (seek != NULL) {
-            if (seek->index == bud_index) {
+    if(chan->buds != NULL){
+        bl00mbox_bud_t * prev = NULL;
+        while(seek != NULL){
+            if(seek->index == bud_index){
                 break;
             }
             prev = seek;
             seek = seek->chan_next;
         }
-        if (seek != NULL) {
-            if (prev != NULL) {
-                bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next),
-                                                      seek->chan_next);
+        if(seek != NULL){
+            if(prev != NULL){
+                bl00mbox_audio_waitfor_pointer_change(&(prev->chan_next), seek->chan_next);
             } else {
-                bl00mbox_audio_waitfor_pointer_change(&(chan->buds),
-                                                      seek->chan_next);
+                bl00mbox_audio_waitfor_pointer_change(&(chan->buds), seek->chan_next);
             }
             free_later = true;
         }
     }
 
     bud->plugin->descriptor->destroy_plugin_instance(bud->plugin);
-    if (free_later) free(seek);
+    if(free_later) free(seek);
     return true;
 }
 
-bool bl00mbox_channel_clear(uint8_t channel) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = chan->buds;
-    while (bud != NULL) {
-        bl00mbox_bud_t *bud_next = bud->chan_next;
+bool bl00mbox_channel_clear(uint8_t channel){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = chan->buds;
+    while(bud != NULL){
+        bl00mbox_bud_t * bud_next = bud->chan_next;
         bl00mbox_channel_delete_bud(channel, bud->index);
         bud = bud_next;
     }
     return true;
 }
 
-bool bl00mbox_channel_connect_signal_to_output_mixer(
-    uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *tx =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (tx == NULL) return false;
-    if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
-
-    bl00mbox_channel_root_t *root = malloc(sizeof(bl00mbox_channel_root_t));
-    if (root == NULL) return false;
-    bl00mbox_connection_subscriber_t *sub =
-        malloc(sizeof(bl00mbox_connection_subscriber_t));
-    if (sub == NULL) {
-        free(root);
-        return false;
-    }
+bool bl00mbox_channel_connect_signal_to_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * tx = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(tx == NULL) return false;
+    if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
+
+    bl00mbox_channel_root_t * root = malloc(sizeof(bl00mbox_channel_root_t));
+    if(root == NULL) return false;
+    bl00mbox_connection_subscriber_t * sub = malloc(sizeof(bl00mbox_connection_subscriber_t));
+    if(sub == NULL){ free(root); return false; }
 
-    bl00mbox_connection_t *conn;
-    if (tx->buffer == NULL) {  // doesn't feed a buffer yet
+    bl00mbox_connection_t * conn;
+    if(tx->buffer == NULL){ // doesn't feed a buffer yet
         conn = create_connection(channel);
-        if (conn == NULL) {
+        if(conn == NULL){
             free(sub);
             free(root);
             return false;
@@ -406,12 +366,11 @@ bool bl00mbox_channel_connect_signal_to_output_mixer(
         conn->source_bud = bud;
         tx->buffer = conn->buffer;
     } else {
-        conn = (bl00mbox_connection_t *)
-                   tx->buffer;  // buffer sits on top of struct
-        if (conn->subs != NULL) {
-            bl00mbox_connection_subscriber_t *seek = conn->subs;
-            while (seek != NULL) {
-                if (seek->type == 1) {
+        conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct
+        if(conn->subs != NULL){
+            bl00mbox_connection_subscriber_t * seek = conn->subs;
+            while(seek != NULL){
+                if(seek->type == 1){
                     free(root);
                     free(sub);
                     return false;  // already connected
@@ -425,26 +384,22 @@ bool bl00mbox_channel_connect_signal_to_output_mixer(
     sub->bud_index = bud_index;
     sub->signal_index = bud_signal_index;
     sub->next = NULL;
-    if (conn->subs == NULL) {
+    if(conn->subs == NULL){
         conn->subs = sub;
     } else {
-        bl00mbox_connection_subscriber_t *seek = conn->subs;
-        while (seek->next != NULL) {
-            seek = seek->next;
-        }
+        bl00mbox_connection_subscriber_t * seek = conn->subs;
+        while(seek->next != NULL){ seek = seek->next; }
         seek->next = sub;
     }
 
     root->con = conn;
     root->next = NULL;
 
-    if (chan->root_list == NULL) {
+    if(chan->root_list == NULL){
         chan->root_list = root;
     } else {
-        bl00mbox_channel_root_t *last_root = chan->root_list;
-        while (last_root->next != NULL) {
-            last_root = last_root->next;
-        }
+        bl00mbox_channel_root_t * last_root = chan->root_list;
+        while(last_root->next != NULL){ last_root = last_root->next; }
         last_root->next = root;
     }
 
@@ -452,33 +407,30 @@ bool bl00mbox_channel_connect_signal_to_output_mixer(
     return true;
 }
 
-bool bl00mbox_channel_disconnect_signal_from_output_mixer(
-    uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index) {
-    // TODO
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *tx =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (tx == NULL) return false;
-    if (tx->buffer == NULL) return false;
-    if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
-
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)tx->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return false;           // not connected
-
-    bl00mbox_channel_root_t *rt = chan->root_list;
-    bl00mbox_channel_root_t *rt_prev = NULL;
-
-    while (rt != NULL) {
-        if (rt->con == conn) break;
+bool bl00mbox_channel_disconnect_signal_from_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    //TODO
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * tx = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(tx == NULL) return false;
+    if(tx->buffer == NULL) return false;
+    if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
+
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct
+    if(conn == NULL) return false; //not connected
+
+    bl00mbox_channel_root_t * rt = chan->root_list;
+    bl00mbox_channel_root_t * rt_prev = NULL;
+
+    while(rt != NULL){
+        if(rt->con == conn) break;
         rt_prev = rt;
         rt = rt->next;
     }
-    if (rt != NULL) {
-        if (rt_prev == NULL) {
+    if(rt != NULL){
+        if(rt_prev == NULL){
             bl00mbox_audio_waitfor_pointer_change(&(chan->root_list), rt->next);
         } else {
             bl00mbox_audio_waitfor_pointer_change(&(rt_prev->next), rt->next);
@@ -486,23 +438,21 @@ bool bl00mbox_channel_disconnect_signal_from_output_mixer(
         free(rt);
     }
 
-    if (conn->subs != NULL) {
-        bl00mbox_connection_subscriber_t *seek = conn->subs;
-        bl00mbox_connection_subscriber_t *prev = NULL;
-        while (seek != NULL) {
-            if (seek->type == 1) {
+    if(conn->subs != NULL){
+        bl00mbox_connection_subscriber_t * seek = conn->subs;
+        bl00mbox_connection_subscriber_t * prev = NULL;
+        while(seek != NULL){
+            if(seek->type == 1){
                 break;
             }
             prev = seek;
             seek = seek->next;
         }
-        if (seek != NULL) {
-            if (prev != NULL) {
-                bl00mbox_audio_waitfor_pointer_change(&(prev->next),
-                                                      seek->next);
+        if(seek != NULL){
+            if(prev != NULL){
+                bl00mbox_audio_waitfor_pointer_change(&(prev->next), seek->next);
             } else {
-                bl00mbox_audio_waitfor_pointer_change(&(conn->subs),
-                                                      seek->next);
+                bl00mbox_audio_waitfor_pointer_change(&(conn->subs), seek->next);
             }
             free(seek);
         }
@@ -513,49 +463,42 @@ bool bl00mbox_channel_disconnect_signal_from_output_mixer(
     return true;
 }
 
-bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel,
-                                           uint32_t bud_rx_index,
-                                           uint32_t bud_rx_signal_index) {
-    bl00mbox_bud_t *bud_rx =
-        bl00mbox_channel_get_bud_by_index(channel, bud_rx_index);
-    if (bud_rx == NULL) return false;  // bud index doesn't exist
+bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index){
+    bl00mbox_bud_t * bud_rx = bl00mbox_channel_get_bud_by_index(channel, bud_rx_index);
+    if(bud_rx == NULL) return false; // bud index doesn't exist
 
-    radspa_signal_t *rx =
-        radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index);
-    if (rx == NULL) return false;  // signal index doesn't exist
-    if (rx->buffer == NULL) return false;
-    if (!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false;
+    radspa_signal_t * rx = radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index);
+    if(rx == NULL) return false; // signal index doesn't exist
+    if(rx->buffer ==  NULL) return false;
+    if(!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false;
 
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)rx->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return false;           // not connected
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) rx->buffer; // buffer sits on top of struct
+    if(conn == NULL) return false; //not connected
 
-    bl00mbox_bud_t *bud_tx = conn->source_bud;
-    if (bud_tx == NULL) return false;  // bud index doesn't exist
-    radspa_signal_t *tx =
-        radspa_signal_get_by_index(bud_tx->plugin, conn->signal_index);
-    if (tx == NULL) return false;  // signal index doesn't exist
+    bl00mbox_bud_t * bud_tx = conn->source_bud;
+    if(bud_tx == NULL) return false; // bud index doesn't exist
+    radspa_signal_t * tx = radspa_signal_get_by_index(bud_tx->plugin, conn->signal_index);
+    if(tx == NULL) return false; // signal index doesn't exist
 
     bl00mbox_audio_waitfor_pointer_change(&(rx->buffer), NULL);
 
-    if (conn->subs != NULL) {
-        bl00mbox_connection_subscriber_t *seek = conn->subs;
-        bl00mbox_connection_subscriber_t *prev = NULL;
-        while (seek != NULL) {
-            if ((seek->signal_index == bud_rx_signal_index) &&
-                (seek->bud_index == bud_rx_index) && (seek->type == 0)) {
+    if(conn->subs != NULL){
+        bl00mbox_connection_subscriber_t * seek = conn->subs;
+        bl00mbox_connection_subscriber_t * prev = NULL;
+        while(seek != NULL){
+            if( (seek->signal_index == bud_rx_signal_index) &&
+                (seek->bud_index == bud_rx_index) &&
+                (seek->type == 0)){
                 break;
             }
             prev = seek;
             seek = seek->next;
         }
-        if (seek != NULL) {
-            if (prev != NULL) {
-                bl00mbox_audio_waitfor_pointer_change(&(prev->next),
-                                                      seek->next);
+        if(seek != NULL){
+            if(prev != NULL){
+                bl00mbox_audio_waitfor_pointer_change(&(prev->next), seek->next);
             } else {
-                bl00mbox_audio_waitfor_pointer_change(&(conn->subs),
-                                                      seek->next);
+                bl00mbox_audio_waitfor_pointer_change(&(conn->subs), seek->next);
             }
             free(seek);
         }
@@ -566,32 +509,25 @@ bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel,
     return true;
 }
 
-bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel,
-                                           uint32_t bud_tx_index,
-                                           uint32_t bud_tx_signal_index) {
-    bl00mbox_bud_t *bud_tx =
-        bl00mbox_channel_get_bud_by_index(channel, bud_tx_index);
-    if (bud_tx == NULL) return false;  // bud index doesn't exist
+bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, uint32_t bud_tx_index, uint32_t bud_tx_signal_index){
+    bl00mbox_bud_t * bud_tx = bl00mbox_channel_get_bud_by_index(channel, bud_tx_index);
+    if(bud_tx == NULL) return false; // bud index doesn't exist
 
-    radspa_signal_t *tx =
-        radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index);
-    if (tx == NULL) return false;  // signal index doesn't exist
-    if (tx->buffer == NULL) return false;
-    if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
+    radspa_signal_t * tx = radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index);
+    if(tx == NULL) return false; // signal index doesn't exist
+    if(tx->buffer ==  NULL) return false;
+    if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
 
-    bl00mbox_connection_t *conn =
-        (bl00mbox_connection_t *)tx->buffer;  // buffer sits on top of struct
-    if (conn == NULL) return false;           // not connected
+    bl00mbox_connection_t * conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct
+    if(conn == NULL) return false; //not connected
 
-    while (conn->subs != NULL) {
-        switch (conn->subs->type) {
+    while(conn->subs != NULL){
+        switch(conn->subs->type){
             case 0:
-                bl00mbox_channel_disconnect_signal_rx(
-                    channel, conn->subs->bud_index, conn->subs->signal_index);
+                bl00mbox_channel_disconnect_signal_rx(channel, conn->subs->bud_index, conn->subs->signal_index);
                 break;
             case 1:
-                bl00mbox_channel_disconnect_signal_from_output_mixer(
-                    channel, conn->subs->bud_index, conn->subs->signal_index);
+                bl00mbox_channel_disconnect_signal_from_output_mixer(channel, conn->subs->bud_index, conn->subs->signal_index);
                 break;
         }
     }
@@ -599,62 +535,50 @@ bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel,
     return true;
 }
 
-bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_index,
-                                        uint32_t signal_index) {
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;  // bud index doesn't exist
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, signal_index);
-    if (sig == NULL) return false;  // signal index doesn't exist
-    if (sig->buffer == NULL) return false;
+bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_index, uint32_t signal_index){
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false; // bud index doesn't exist
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, signal_index);
+    if(sig == NULL) return false; // signal index doesn't exist
+    if(sig->buffer ==  NULL) return false;
 
     bl00mbox_channel_disconnect_signal_rx(channel, bud_index, signal_index);
     bl00mbox_channel_disconnect_signal_tx(channel, bud_index, signal_index);
-    bl00mbox_channel_disconnect_signal_from_output_mixer(channel, bud_index,
-                                                         signal_index);
-    if (sig->buffer == NULL) return true;
+    bl00mbox_channel_disconnect_signal_from_output_mixer(channel, bud_index, signal_index);
+    if(sig->buffer ==  NULL) return true;
     return false;
 }
 
-bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index,
-                                     uint32_t bud_rx_signal_index,
-                                     uint32_t bud_tx_index,
-                                     uint32_t bud_tx_signal_index) {
-    bl00mbox_bud_t *bud_rx =
-        bl00mbox_channel_get_bud_by_index(channel, bud_rx_index);
-    bl00mbox_bud_t *bud_tx =
-        bl00mbox_channel_get_bud_by_index(channel, bud_tx_index);
-    if (bud_tx == NULL || bud_rx == NULL)
-        return false;  // bud index doesn't exist
-
-    radspa_signal_t *rx =
-        radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index);
-    radspa_signal_t *tx =
-        radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index);
-    if (tx == NULL || rx == NULL) return false;  // signal index doesn't exist
-    if (!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false;
-    if (!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
-
-    bl00mbox_connection_t *conn;
-    bl00mbox_connection_subscriber_t *sub;
-    if (tx->buffer == NULL) {  // doesn't feed a buffer yet
+bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index,
+                                               uint32_t bud_tx_index, uint32_t bud_tx_signal_index){
+    bl00mbox_bud_t * bud_rx = bl00mbox_channel_get_bud_by_index(channel, bud_rx_index);
+    bl00mbox_bud_t * bud_tx = bl00mbox_channel_get_bud_by_index(channel, bud_tx_index);
+    if(bud_tx == NULL || bud_rx == NULL) return false; // bud index doesn't exist
+
+    radspa_signal_t * rx = radspa_signal_get_by_index(bud_rx->plugin, bud_rx_signal_index);
+    radspa_signal_t * tx = radspa_signal_get_by_index(bud_tx->plugin, bud_tx_signal_index);
+    if(tx == NULL || rx == NULL) return false; // signal index doesn't exist
+    if(!(rx->hints & RADSPA_SIGNAL_HINT_INPUT)) return false;
+    if(!(tx->hints & RADSPA_SIGNAL_HINT_OUTPUT)) return false;
+
+    bl00mbox_connection_t * conn;
+    bl00mbox_connection_subscriber_t * sub;
+    if(tx->buffer == NULL){ // doesn't feed a buffer yet
         conn = create_connection(channel);
-        if (conn == NULL) return false;  // no ram for connection
+        if(conn == NULL) return false; // no ram for connection
         // set up new connection
         conn->signal_index = bud_tx_signal_index;
         conn->source_bud = bud_tx;
         tx->buffer = conn->buffer;
     } else {
-        if (rx->buffer == tx->buffer) return false;  // already connected
-        conn = (bl00mbox_connection_t *)
-                   tx->buffer;  // buffer sits on top of struct
+        if(rx->buffer == tx->buffer) return false; // already connected
+        conn = (bl00mbox_connection_t *) tx->buffer; // buffer sits on top of struct
     }
 
-    bl00mbox_channel_disconnect_signal_rx(channel, bud_rx_index,
-                                          bud_rx_signal_index);
+    bl00mbox_channel_disconnect_signal_rx(channel, bud_rx_index, bud_rx_signal_index);
 
     sub = malloc(sizeof(bl00mbox_connection_subscriber_t));
-    if (sub == NULL) {
+    if(sub == NULL){
         weak_delete_connection(conn);
         return false;
     }
@@ -662,11 +586,11 @@ bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index,
     sub->bud_index = bud_rx_index;
     sub->signal_index = bud_rx_signal_index;
     sub->next = NULL;
-    if (conn->subs == NULL) {
+    if(conn->subs == NULL){
         conn->subs = sub;
     } else {
-        bl00mbox_connection_subscriber_t *seek = conn->subs;
-        while (seek->next != NULL) {
+        bl00mbox_connection_subscriber_t * seek = conn->subs;
+        while(seek->next != NULL){
             seek = seek->next;
         }
         seek->next = sub;
@@ -677,163 +601,140 @@ bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index,
     return true;
 }
 
-bool bl00mbox_channel_bud_exists(uint8_t channel, uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) {
+bool bl00mbox_channel_bud_exists(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL){
         return false;
     } else {
         return true;
     }
 }
 
-char *bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
+char * bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
     return bud->plugin->descriptor->name;
 }
 
-char *bl00mbox_channel_bud_get_description(uint8_t channel,
-                                           uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
+char * bl00mbox_channel_bud_get_description(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
     return bud->plugin->descriptor->description;
 }
 
-uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel,
-                                            uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
+uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
     return bud->plugin->descriptor->id;
 }
 
-uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel,
-                                              uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
+uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
     return bud->plugin->len_signals;
 }
 
-char *bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index,
-                                           uint32_t bud_signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (sig == NULL) return false;
+char * bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(sig == NULL) return false;
     return sig->name;
 }
 
-char *bl00mbox_channel_bud_get_signal_description(uint8_t channel,
-                                                  uint32_t bud_index,
-                                                  uint32_t bud_signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (sig == NULL) return false;
+char * bl00mbox_channel_bud_get_signal_description(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(sig == NULL) return false;
     return sig->description;
 }
 
-char *bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index,
-                                           uint32_t bud_signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (sig == NULL) return false;
+char * bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(sig == NULL) return false;
     return sig->unit;
 }
 
-bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index,
-                                           uint32_t bud_signal_index,
-                                           int16_t value) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (sig == NULL) return false;
+bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index, int16_t value){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(sig == NULL) return false;
 
     sig->value = value;
     bl00mbox_channel_event(channel);
     return true;
 }
 
-int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel,
-                                              uint32_t bud_index,
-                                              uint32_t bud_signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (sig == NULL) return false;
+int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(sig == NULL) return false;
 
     return sig->value;
 }
 
-uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel,
-                                               uint32_t bud_index,
-                                               uint32_t bud_signal_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    radspa_signal_t *sig =
-        radspa_signal_get_by_index(bud->plugin, bud_signal_index);
-    if (sig == NULL) return false;
+uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    radspa_signal_t * sig = radspa_signal_get_by_index(bud->plugin, bud_signal_index);
+    if(sig == NULL) return false;
 
     return sig->hints;
 }
 
-bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index,
-                                          uint32_t table_index, int16_t value) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    if (bud->plugin->plugin_table == NULL) return false;
-    if (table_index >= bud->plugin->plugin_table_len) return false;
+bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index, int16_t value){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    if(bud->plugin->plugin_table == NULL) return false;
+    if(table_index >= bud->plugin->plugin_table_len) return false;
     bud->plugin->plugin_table[table_index] = value;
     bl00mbox_channel_event(channel);
     return true;
 }
 
-int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel,
-                                             uint32_t bud_index,
-                                             uint32_t table_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
-    if (bud->plugin->plugin_table == NULL) return false;
-    if (table_index >= bud->plugin->plugin_table_len) return false;
+int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
+    if(bud->plugin->plugin_table == NULL) return false;
+    if(table_index >= bud->plugin->plugin_table_len) return false;
     return bud->plugin->plugin_table[table_index];
 }
 
-int16_t bl00mbox_channel_bud_get_table_len(uint8_t channel,
-                                           uint32_t bud_index) {
-    bl00mbox_channel_t *chan = bl00mbox_get_channel(channel);
-    if (chan == NULL) return false;
-    bl00mbox_bud_t *bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
-    if (bud == NULL) return false;
+int16_t bl00mbox_channel_bud_get_table_len(uint8_t channel, uint32_t bud_index){
+    bl00mbox_channel_t * chan = bl00mbox_get_channel(channel);
+    if(chan == NULL) return false;
+    bl00mbox_bud_t * bud = bl00mbox_channel_get_bud_by_index(channel, bud_index);
+    if(bud == NULL) return false;
     return bud->plugin->plugin_table_len;
 }
diff --git a/components/bl00mbox/include/bl00mbox.h b/components/bl00mbox/include/bl00mbox.h
index f73bf7c3d1498acd9edbe3438476fc137ab3a09e..9dd3f1c1ae442ad30f5ca9798f3c51d41b3d681e 100644
--- a/components/bl00mbox/include/bl00mbox.h
+++ b/components/bl00mbox/include/bl00mbox.h
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #pragma once
 #include <stdbool.h>
 #include <stdint.h>
@@ -8,9 +8,9 @@
 uint16_t bl00mbox_sources_count();
 uint16_t bl00mbox_source_add(void* render_data, void* render_function);
 void bl00mbox_source_remove(uint16_t index);
-void bl00mbox_audio_render(int16_t* rx, int16_t* tx, uint16_t len);
+void bl00mbox_audio_render(int16_t * rx, int16_t * tx, uint16_t len);
 
 // TEMP
-void bl00mbox_player_function(int16_t* rx, int16_t* tx, uint16_t len);
+void bl00mbox_player_function(int16_t * rx, int16_t * tx, uint16_t len);
 
 void bl00mbox_init(void);
diff --git a/components/bl00mbox/include/bl00mbox_audio.h b/components/bl00mbox/include/bl00mbox_audio.h
index 4fc5fbeadff5335d1b2e0746636eec38d8e8ea5a..2ac014280b01a1c41c9ff08656f41f3e0cce6eb1 100644
--- a/components/bl00mbox/include/bl00mbox_audio.h
+++ b/components/bl00mbox/include/bl00mbox_audio.h
@@ -1,18 +1,18 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #pragma once
 
-// TODO: move this to kconfig someday
+//TODO: move this to kconfig someday
 #define BL00MBOX_MAX_BUFFER_LEN 256
 #define BL00MBOX_DEFAULT_CHANNEL_VOLUME 3000
 #define BL00MBOX_CHANNELS 32
 #define BL00MBOX_BACKGROUND_MUTE_OVERRIDE_ENABLE
 
-// TODO: remove st3m scope dependency
+//TODO: remove st3m scope dependency
 #include "st3m_audio.h"
 #include "st3m_scope.h"
 
-#include <math.h>
 #include <stdio.h>
+#include <math.h>
 #include <string.h>
 #include "radspa.h"
 
@@ -21,53 +21,47 @@ struct _bl00mbox_connection_source_t;
 struct _bl00mbox_channel_root_t;
 struct _bl00mbox_channel_t;
 
-typedef struct _bl00mbox_bud_t {
-    radspa_t* plugin;         // plugin
-    uint64_t index;           // unique index number for bud
-    uint32_t render_pass_id;  // may be used by host to determine whether
-                              // recomputation is necessary
-    uint8_t channel;          // index of channel that owns the plugin
-    struct _bl00mbox_bud_t* chan_next;  // for linked list in bl00mbox_channel_t
+typedef struct _bl00mbox_bud_t{
+    radspa_t * plugin; // plugin
+    uint64_t index; // unique index number for bud
+    uint32_t render_pass_id; // may be used by host to determine whether recomputation is necessary
+    uint8_t channel; // index of channel that owns the plugin
+    struct _bl00mbox_bud_t * chan_next; //for linked list in bl00mbox_channel_t
 } bl00mbox_bud_t;
 
-typedef struct _bl00mbox_connection_subscriber_t {
-    uint8_t type;  // 0: standard signal input, 1: output mixer
+typedef struct _bl00mbox_connection_subscriber_t{
+    uint8_t type; // 0: standard signal input, 1: output mixer
     uint8_t channel;
     uint64_t bud_index;
     uint32_t signal_index;
-    struct _bl00mbox_connection_subscriber_t* next;
+    struct _bl00mbox_connection_subscriber_t * next;
 } bl00mbox_connection_subscriber_t;
 
-typedef struct _bl00mbox_connection_t {       // child of bl00mbox_ll_t
-    int16_t buffer[BL00MBOX_MAX_BUFFER_LEN];  // MUST stay on top of struct bc
-                                              // type casting!
-    struct _bl00mbox_bud_t* source_bud;
-    uint32_t signal_index;  // signal of source_bud that renders to buffer
-    struct _bl00mbox_connection_subscriber_t* subs;
+typedef struct _bl00mbox_connection_t{ //child of bl00mbox_ll_t
+    int16_t buffer[BL00MBOX_MAX_BUFFER_LEN]; // MUST stay on top of struct bc type casting!
+    struct _bl00mbox_bud_t * source_bud;
+    uint32_t signal_index; // signal of source_bud that renders to buffer
+    struct _bl00mbox_connection_subscriber_t * subs;
     uint8_t channel;
-    struct _bl00mbox_connection_t*
-        chan_next;  // for linked list in bl00mbox_channel_t;
+    struct _bl00mbox_connection_t * chan_next; //for linked list in bl00mbox_channel_t;
 } bl00mbox_connection_t;
 
-typedef struct _bl00mbox_channel_root_t {
-    struct _bl00mbox_connection_t* con;
-    struct _bl00mbox_channel_root_t* next;
+typedef struct _bl00mbox_channel_root_t{
+    struct _bl00mbox_connection_t * con;
+    struct _bl00mbox_channel_root_t * next;
 } bl00mbox_channel_root_t;
 
-typedef struct {
-    bool is_active;  // rendering can be skipped if false
+typedef struct{
+    bool is_active; // rendering can be skipped if false
     bool is_free;
     int32_t volume;
-    struct _bl00mbox_channel_root_t*
-        root_list;                 // list of all roots associated with channels
-    uint32_t render_pass_id;       // may be used by host to determine whether
-                                   // recomputation is necessary
-    struct _bl00mbox_bud_t* buds;  // linked list with all channel buds
-    struct _bl00mbox_connection_t*
-        connections;  // linked list with all channel connections
+    struct _bl00mbox_channel_root_t * root_list; // list of all roots associated with channels
+    uint32_t render_pass_id; // may be used by host to determine whether recomputation is necessary
+    struct _bl00mbox_bud_t * buds; // linked list with all channel buds
+    struct _bl00mbox_connection_t * connections; // linked list with all channel connections
 } bl00mbox_channel_t;
 
-bl00mbox_channel_t* bl00mbox_get_channel(uint8_t chan);
+bl00mbox_channel_t * bl00mbox_get_channel(uint8_t chan);
 void bl00mbox_channel_enable(uint8_t chan);
 
 void bl00mbox_channel_enable(uint8_t chan);
@@ -81,8 +75,7 @@ uint8_t bl00mbox_channel_get_foreground_index();
 void bl00mbox_channel_set_foreground_index(uint8_t index);
 
 bool bl00mbox_channel_get_background_mute_override(uint8_t channel_index);
-bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index,
-                                                   bool enable);
+bool bl00mbox_channel_set_background_mute_override(uint8_t channel_index, bool enable);
 
-bool bl00mbox_audio_waitfor_pointer_change(void** ptr, void* new_val);
-void bl00mbox_audio_bud_render(bl00mbox_bud_t* bud, uint16_t num_samples);
+bool bl00mbox_audio_waitfor_pointer_change(void ** ptr, void * new_val);
+void bl00mbox_audio_bud_render(bl00mbox_bud_t * bud, uint16_t num_samples);
diff --git a/components/bl00mbox/include/bl00mbox_plugin_registry.h b/components/bl00mbox/include/bl00mbox_plugin_registry.h
index 44141d5a1e7728a272b64986935bbc48c0f11dcc..077af6785752119e1b0f992fdce1e0d1c76e7a9a 100644
--- a/components/bl00mbox/include/bl00mbox_plugin_registry.h
+++ b/components/bl00mbox/include/bl00mbox_plugin_registry.h
@@ -1,16 +1,15 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #pragma once
-#include "radspa.h"
 #include "stdio.h"
+#include "radspa.h"
 
-typedef struct _bl00mbox_plugin_registry_t {
-    radspa_descriptor_t* descriptor;
-    struct _bl00mbox_plugin_registry_t* next;
+typedef struct _bl00mbox_plugin_registry_t{
+    radspa_descriptor_t * descriptor;
+    struct _bl00mbox_plugin_registry_t * next;
 } bl00mbox_plugin_registry_t;
 
-radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_id(
-    uint32_t id);
-radspa_descriptor_t* bl00mbox_plugin_registry_get_descriptor_from_index(
-    uint32_t index);
+radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_id(uint32_t id);
+radspa_descriptor_t * bl00mbox_plugin_registry_get_descriptor_from_index(uint32_t index);
 void bl00mbox_plugin_registry_init(void);
 uint16_t bl00mbox_plugin_registry_get_plugin_num(void);
+
diff --git a/components/bl00mbox/include/bl00mbox_radspa_requirements.h b/components/bl00mbox/include/bl00mbox_radspa_requirements.h
index 39813840438b0ddc26fce564de5a0c623c6652ac..142810dd5c07e7a1116b3208980117e2252df763 100644
--- a/components/bl00mbox/include/bl00mbox_radspa_requirements.h
+++ b/components/bl00mbox/include/bl00mbox_radspa_requirements.h
@@ -1,5 +1,6 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #pragma once
 #include "bl00mbox_audio.h"
 #include "radspa.h"
 #include "radspa_helpers.h"
+
diff --git a/components/bl00mbox/include/bl00mbox_user.h b/components/bl00mbox/include/bl00mbox_user.h
index 447e55c907b29dad13018757bb4353847c6677a4..9e5fe3fb039b602846d8e1d1a6867399f39eabf8 100644
--- a/components/bl00mbox/include/bl00mbox_user.h
+++ b/components/bl00mbox/include/bl00mbox_user.h
@@ -1,86 +1,54 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #pragma once
 
-#include <math.h>
 #include <stdio.h>
+#include <math.h>
 #include <string.h>
 
+#include "bl00mbox_plugin_registry.h"
+#include "bl00mbox_audio.h"
 #include <stdint.h>
 #include "bl00mbox_audio.h"
-#include "bl00mbox_plugin_registry.h"
 #include "radspa_helpers.h"
 
 uint16_t bl00mbox_channel_buds_num(uint8_t channel);
 uint64_t bl00mbox_channel_get_bud_by_list_pos(uint8_t channel, uint32_t pos);
 uint16_t bl00mbox_channel_conns_num(uint8_t channel);
 uint16_t bl00mbox_channel_mixer_num(uint8_t channel);
-uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel,
-                                                    uint32_t pos);
-uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel,
-                                                       uint32_t pos);
+uint64_t bl00mbox_channel_get_bud_by_mixer_list_pos(uint8_t channel, uint32_t pos);
+uint32_t bl00mbox_channel_get_signal_by_mixer_list_pos(uint8_t channel, uint32_t pos);
 bool bl00mbox_channel_clear(uint8_t channel);
 
-bool bl00mbox_channel_connect_signal_to_output_mixer(uint8_t channel,
-                                                     uint32_t bud_index,
-                                                     uint32_t bud_signal_index);
-bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index,
-                                     uint32_t bud_rx_signal_index,
-                                     uint32_t bud_tx_index,
-                                     uint32_t bud_tx_signal_index);
-bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel,
-                                           uint32_t bud_rx_index,
-                                           uint32_t bud_rx_signal_index);
-bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel,
-                                           uint32_t bud_tx_index,
-                                           uint32_t bud_tx_signal_index);
-bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_tx_index,
-                                        uint32_t bud_tx_signal_index);
-bool bl00mbox_channel_disconnect_signal_from_output_mixer(
-    uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+bool bl00mbox_channel_connect_signal_to_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+bool bl00mbox_channel_connect_signal(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index,
+                                               uint32_t bud_tx_index, uint32_t bud_tx_signal_index);
+bool bl00mbox_channel_disconnect_signal_rx(uint8_t channel, uint32_t bud_rx_index, uint32_t bud_rx_signal_index);
+bool bl00mbox_channel_disconnect_signal_tx(uint8_t channel, uint32_t bud_tx_index, uint32_t bud_tx_signal_index);
+bool bl00mbox_channel_disconnect_signal(uint8_t channel, uint32_t bud_tx_index, uint32_t bud_tx_signal_index);
+bool bl00mbox_channel_disconnect_signal_from_output_mixer(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
 
-bl00mbox_bud_t* bl00mbox_channel_new_bud(uint8_t channel, uint32_t id,
-                                         uint32_t init_var);
+bl00mbox_bud_t * bl00mbox_channel_new_bud(uint8_t channel, uint32_t id, uint32_t init_var);
 bool bl00mbox_channel_delete_bud(uint8_t channel, uint32_t bud_index);
 bool bl00mbox_channel_bud_exists(uint8_t channel, uint32_t bud_index);
-char* bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index);
-char* bl00mbox_channel_bud_get_description(uint8_t channel, uint32_t bud_index);
-uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel,
-                                            uint32_t bud_index);
-uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel,
-                                              uint32_t bud_index);
+char * bl00mbox_channel_bud_get_name(uint8_t channel, uint32_t bud_index);
+char * bl00mbox_channel_bud_get_description(uint8_t channel, uint32_t bud_index);
+uint32_t bl00mbox_channel_bud_get_plugin_id(uint8_t channel, uint32_t bud_index);
+uint16_t bl00mbox_channel_bud_get_num_signals(uint8_t channel, uint32_t bud_index);
 
-char* bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index,
-                                           uint32_t bud_signal_index);
-char* bl00mbox_channel_bud_get_signal_description(uint8_t channel,
-                                                  uint32_t bud_index,
-                                                  uint32_t bud_signal_index);
-char* bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index,
-                                           uint32_t bud_signal_index);
-bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index,
-                                           uint32_t bud_signal_index,
-                                           int16_t value);
-int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel,
-                                              uint32_t bud_index,
-                                              uint32_t bud_signal_index);
-uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel,
-                                               uint32_t bud_index,
-                                               uint32_t bud_signal_index);
-uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index,
-                                         uint16_t signal_index);
-uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel,
-                                                         uint64_t bud_index,
-                                                         uint16_t signal_index,
-                                                         uint8_t pos);
-int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos(
-    uint8_t channel, uint64_t bud_index, uint16_t signal_index, uint8_t pos);
-uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index,
-                                         uint16_t signal_index);
-uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index,
-                                            uint16_t signal_index);
+char * bl00mbox_channel_bud_get_signal_name(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+char * bl00mbox_channel_bud_get_signal_description(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+char * bl00mbox_channel_bud_get_signal_unit(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+bool bl00mbox_channel_bud_set_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index, int16_t value);
+int16_t bl00mbox_channel_bud_get_signal_value(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+uint32_t bl00mbox_channel_bud_get_signal_hints(uint8_t channel, uint32_t bud_index, uint32_t bud_signal_index);
+uint16_t bl00mbox_channel_subscriber_num(uint8_t channel, uint64_t bud_index, uint16_t signal_index);
+uint64_t bl00mbox_channel_get_bud_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index,
+                uint16_t signal_index, uint8_t pos);
+int32_t bl00mbox_channel_get_signal_by_subscriber_list_pos(uint8_t channel, uint64_t bud_index,
+                uint16_t signal_index, uint8_t pos);
+uint64_t bl00mbox_channel_get_source_bud(uint8_t channel, uint64_t bud_index, uint16_t signal_index);
+uint16_t bl00mbox_channel_get_source_signal(uint8_t channel, uint64_t bud_index, uint16_t signal_index);
 
-bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index,
-                                          uint32_t table_index, int16_t value);
-int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel,
-                                             uint32_t bud_index,
-                                             uint32_t table_index);
+bool bl00mbox_channel_bud_set_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index, int16_t value);
+int16_t bl00mbox_channel_bud_get_table_value(uint8_t channel, uint32_t bud_index, uint32_t table_index);
 int16_t bl00mbox_channel_bud_get_table_len(uint8_t channel, uint32_t bud_index);
diff --git a/components/bl00mbox/plugins/ampliverter.c b/components/bl00mbox/plugins/ampliverter.c
index e55685bd1ea1f9b31c70c0ffac54aa32cd6ea441..4dfdaf564fc68f7479b22c506fb401f979facc0e 100644
--- a/components/bl00mbox/plugins/ampliverter.c
+++ b/components/bl00mbox/plugins/ampliverter.c
@@ -2,16 +2,16 @@
 
 // we're defining a prototype for the create function because it has a circular
 // dependency with the descriptor
-radspa_t* ampliverter_create(uint32_t init_var);
+radspa_t * ampliverter_create(uint32_t init_var);
 radspa_descriptor_t ampliverter_desc = {
     .name = "ampliverter",
     .id = 69,
     .description = "saturating multiplication and addition",
     .create_plugin_instance = ampliverter_create,
-    // with this we can only use radspa_standard_plugin_create to allocate
-    // memory. this restricts data layout flexibility for large buffers, but in
-    // return it offers offers a bit of protection from double free/memory leak
-    // issues and makes plugins easier to write.
+    // with this we can only use radspa_standard_plugin_create to allocate memory.
+    // this restricts data layout flexibility for large buffers, but in return it offers
+    // offers a bit of protection from double free/memory leak issues and makes plugins
+    // easier to write.
     .destroy_plugin_instance = radspa_standard_plugin_destroy
 };
 
@@ -21,73 +21,59 @@ radspa_descriptor_t ampliverter_desc = {
 #define AMPLIVERTER_GAIN 2
 #define AMPLIVERTER_BIAS 3
 
-void ampliverter_run(radspa_t* ampliverter, uint16_t num_samples,
-                     uint32_t render_pass_id) {
-    // step 1: get signal pointers. since these are stored in a linked list this
-    // is a rather slow operation and should ideally be only be done once per
-    // call. if no signals with output hint are being read the run function may
-    // exit early.
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(ampliverter, AMPLIVERTER_OUTPUT);
-    if (output_sig->buffer == NULL) return;
-    radspa_signal_t* input_sig =
-        radspa_signal_get_by_index(ampliverter, AMPLIVERTER_INPUT);
-    radspa_signal_t* gain_sig =
-        radspa_signal_get_by_index(ampliverter, AMPLIVERTER_GAIN);
-    radspa_signal_t* bias_sig =
-        radspa_signal_get_by_index(ampliverter, AMPLIVERTER_BIAS);
+void ampliverter_run(radspa_t * ampliverter, uint16_t num_samples, uint32_t render_pass_id){
+    // step 1: get signal pointers. since these are stored in a linked list this is a rather
+    // slow operation and should ideally be only be done once per call.
+    // if no signals with output hint are being read the run function may exit early.
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_OUTPUT);
+    if(output_sig->buffer == NULL) return;
+    radspa_signal_t * input_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_INPUT);
+    radspa_signal_t * gain_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_GAIN);
+    radspa_signal_t * bias_sig = radspa_signal_get_by_index(ampliverter, AMPLIVERTER_BIAS);
+    
 
     static int16_t ret = 0;
-    for (uint16_t i = 0; i < num_samples; i++) {
-        // step 2: render the outputs. most of the time a simple for loop will
-        // be fine. using {*radspa_signal_t}->get_value is required to
-        // automatically switch between static values and streamed data at
-        // various sample rates, don't access the data directly
-        int16_t bias =
-            bias_sig->get_value(bias_sig, i, num_samples, render_pass_id);
-        int16_t gain =
-            gain_sig->get_value(gain_sig, i, num_samples, render_pass_id);
-        if (gain == 0) {
+    for(uint16_t i = 0; i < num_samples; i++){
+        // step 2: render the outputs. most of the time a simple for loop will be fine.
+        // using {*radspa_signal_t}->get_value is required to automatically switch between
+        // static values and streamed data at various sample rates, don't access the data directly
+        int16_t bias = bias_sig->get_value(bias_sig, i, num_samples, render_pass_id);
+        int16_t gain = gain_sig->get_value(gain_sig, i, num_samples, render_pass_id);
+        if(gain == 0){
             // make sure that the output buffer exists by comparing to NULL!
             // (here done earlier outside of the loop)
             ret = bias;
         } else {
-            ret =
-                input_sig->get_value(input_sig, i, num_samples, render_pass_id);
-            // the helper functions make sure that potential future float
-            // versions behave as intended
+            ret = input_sig->get_value(input_sig, i, num_samples, render_pass_id);
+            // the helper functions make sure that potential future float versions behave
+            // as intended
             ret = radspa_mult_shift(ret, gain);
             ret = radspa_add_sat(ret, bias);
         }
         (output_sig->buffer)[i] = ret;
+
     }
     output_sig->value = ret;
 }
 
-radspa_t* ampliverter_create(uint32_t init_var) {
+radspa_t * ampliverter_create(uint32_t init_var){
     // init_var is not used in this example
 
-    // step 1: try to allocate enough memory for a standard plugin with the
-    // given amount of signals and plugin data. there is no plugin data in this
-    // case, but sizeof(void) is invalid sooo we're taking the next smallest
-    // thing (char) ig? we're not good at C. providing the descriptor address is
-    // required to make sure it is not forgotten.
-    radspa_t* ampliverter = radspa_standard_plugin_create(
-        &ampliverter_desc, AMPLIVERTER_NUM_SIGNALS, sizeof(char), 0);
-    if (ampliverter == NULL) return NULL;
+    // step 1: try to allocate enough memory for a standard plugin with the given amount of signals
+    // and plugin data. there is no plugin data in this case, but sizeof(void) is invalid sooo we're
+    // taking the next smallest thing (char) ig? we're not good at C.
+    // providing the descriptor address is required to make sure it is not forgotten.
+    radspa_t * ampliverter = radspa_standard_plugin_create(&ampliverter_desc, AMPLIVERTER_NUM_SIGNALS, sizeof(char), 0);
+    if(ampliverter == NULL) return NULL;
 
     // step 2: define run function
     ampliverter->render = ampliverter_run;
-
-    // step 3: standard_plugin_create has already created dummy signals for us,
-    // we just need to fill them
-    radspa_signal_set(ampliverter, AMPLIVERTER_OUTPUT, "output",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(ampliverter, AMPLIVERTER_INPUT, "input",
-                      RADSPA_SIGNAL_HINT_INPUT, 0);
-    radspa_signal_set(ampliverter, AMPLIVERTER_GAIN, "gain",
-                      RADSPA_SIGNAL_HINT_INPUT, 32767);
-    radspa_signal_set(ampliverter, AMPLIVERTER_BIAS, "bias",
-                      RADSPA_SIGNAL_HINT_INPUT, 0);
+    
+    // step 3: standard_plugin_create has already created dummy signals for us, we just need to
+    // fill them
+    radspa_signal_set(ampliverter, AMPLIVERTER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(ampliverter, AMPLIVERTER_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 0);
+    radspa_signal_set(ampliverter, AMPLIVERTER_GAIN, "gain", RADSPA_SIGNAL_HINT_INPUT, 32767);
+    radspa_signal_set(ampliverter, AMPLIVERTER_BIAS, "bias", RADSPA_SIGNAL_HINT_INPUT, 0);
     return ampliverter;
 }
diff --git a/components/bl00mbox/plugins/ampliverter.h b/components/bl00mbox/plugins/ampliverter.h
index 990c36a49e42895eae7dbbbecc3f58abbe532701..4056316a25f9be994c20ebeb9ffd423ee3c03597 100644
--- a/components/bl00mbox/plugins/ampliverter.h
+++ b/components/bl00mbox/plugins/ampliverter.h
@@ -3,6 +3,6 @@
 #include <radspa_helpers.h>
 
 extern radspa_descriptor_t ampliverter_desc;
-radspa_t* ampliverter_create(uint32_t init_var);
-void ampliverter_run(radspa_t* osc, uint16_t num_samples,
-                     uint32_t render_pass_id);
+radspa_t * ampliverter_create(uint32_t init_var);
+void ampliverter_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
+
diff --git a/components/bl00mbox/plugins/brok3n/filter.c b/components/bl00mbox/plugins/brok3n/filter.c
index d15696d24bcdf11f48e643b78afff2a0be94dee6..d9cdd4ff830cc365cd72ab3e6620602db4ec7f1f 100644
--- a/components/bl00mbox/plugins/brok3n/filter.c
+++ b/components/bl00mbox/plugins/brok3n/filter.c
@@ -1,12 +1,13 @@
 #include "filter.h"
 
-radspa_t* filter_create(uint32_t init_var);
-radspa_descriptor_t filter_desc = { .name = "filter",
-                                    .id = 69420,
-                                    .description = "simple filter",
-                                    .create_plugin_instance = filter_create,
-                                    .destroy_plugin_instance =
-                                        radspa_standard_plugin_destroy };
+radspa_t * filter_create(uint32_t init_var);
+radspa_descriptor_t filter_desc = {
+    .name = "filter",
+    .id = 69420,
+    .description = "simple filter",
+    .create_plugin_instance = filter_create,
+    .destroy_plugin_instance = radspa_standard_plugin_destroy
+};
 
 #define FILTER_NUM_SIGNALS 5
 #define FILTER_OUTPUT 0
@@ -15,20 +16,21 @@ radspa_descriptor_t filter_desc = { .name = "filter",
 #define FILTER_Q 3
 #define FILTER_GAIN 4
 
-static int16_t apply_filter(filter_data_t* data, int32_t input, int32_t gain) {
+
+static int16_t apply_filter(filter_data_t * data, int32_t input, int32_t gain){
     data->pos++;
-    if (data->pos >= 3) data->pos = 0;
+    if(data->pos >= 3) data->pos = 0;
 
-    int64_t out = 0;
+	int64_t out = 0;
     int64_t in_acc = input;
 
-    for (int8_t i = 0; i < 2; i++) {
+	for(int8_t i=0; i<2; i++){
         int8_t pos = data->pos - i - 1;
-        if (pos < 0) pos += 3;
-        in_acc += (2 - i) * data->in_history[pos];
+        if(pos < 0) pos += 3;
+        in_acc += (2-i)*data->in_history[pos];
 
         int16_t shift = data->out_coeff_shift[i] - data->in_coeff_shift;
-        if (shift >= 0) {
+        if(shift >= 0){
             out -= (data->out_history[pos] * data->out_coeff[i]) >> shift;
         } else {
             out -= (data->out_history[pos] * data->out_coeff[i]) << (-shift);
@@ -40,38 +42,38 @@ static int16_t apply_filter(filter_data_t* data, int32_t input, int32_t gain) {
     data->in_history[data->pos] = input;
     data->out_history[data->pos] = out;
 
-    return radspa_mult_shift(out, gain);
+	return radspa_mult_shift(out, gain);
 }
 
 static uint8_t coeff_shift(float coeff) {
     int32_t ret = 16;
-    while (1) {
-        int32_t test_val = (1 << ret) * coeff;
-        if (test_val < 0) test_val = -test_val;
-        if (test_val > (1 << 12)) {
+    while(1){
+        int32_t test_val = (1<<ret) * coeff;
+        if(test_val < 0) test_val = -test_val;
+        if(test_val > (1<<12)){
             ret -= 3;
-        } else if (test_val < (1 << 8)) {
+        } else if (test_val < (1<<8)){
             ret += 3;
         } else {
             break;
         }
-        if (ret > 28) break;
-        if (ret < 4) break;
+        if(ret > 28) break;
+        if(ret < 4) break;
     }
     return ret;
 }
 
-static void set_filter_coeffs(filter_data_t* data, float freq, float q) {
-    // molasses, sorry
-    if (freq == 0) return;
-    if (q == 0) return;
-    float K = 2 * 48000;
+static void set_filter_coeffs(filter_data_t * data, float freq, float q){
+    //molasses, sorry
+    if(freq == 0) return;
+    if(q == 0) return;
+    float K = 2*48000;
     float omega = freq * 6.28;
     float A[3];
-    A[0] = K * K;
-    A[1] = K * omega / q;
-    A[2] = omega * omega;
-    float B = omega * omega;
+    A[0] = K*K;
+    A[1] = K*omega/q;
+    A[2] = omega*omega;
+    float B = omega*omega;
 
     float sum_a = A[0] + A[1] + A[2];
 
@@ -80,46 +82,39 @@ static void set_filter_coeffs(filter_data_t* data, float freq, float q) {
 
     round = B / sum_a;
     shift = coeff_shift(round);
-    data->in_coeff = round * (1 << shift);
+    data->in_coeff = round * (1<<shift);
     data->in_coeff_shift = shift;
 
-    round = 2. * (A[2] - A[0]) / sum_a;
+    round = 2.*(A[2]-A[0]) / sum_a;
     shift = coeff_shift(round);
-    data->out_coeff[0] = round * (1 << shift);
+    data->out_coeff[0] = round * (1<<shift);
     data->out_coeff_shift[0] = shift;
 
-    round = (A[0] - A[1] + A[2]) / sum_a;
+    round = (A[0]-A[1]+A[2]) / sum_a;
     shift = coeff_shift(round);
-    data->out_coeff[1] = round * (1 << shift);
+    data->out_coeff[1] = round * (1<<shift);
     data->out_coeff_shift[1] = shift;
 }
 
-void filter_run(radspa_t* filter, uint16_t num_samples,
-                uint32_t render_pass_id) {
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(filter, FILTER_OUTPUT);
-    if (output_sig->buffer == NULL) return;
-    filter_data_t* data = filter->plugin_data;
-    radspa_signal_t* input_sig =
-        radspa_signal_get_by_index(filter, FILTER_INPUT);
-    radspa_signal_t* freq_sig = radspa_signal_get_by_index(filter, FILTER_FREQ);
-    radspa_signal_t* q_sig = radspa_signal_get_by_index(filter, FILTER_Q);
-    radspa_signal_t* gain_sig = radspa_signal_get_by_index(filter, FILTER_GAIN);
+void filter_run(radspa_t * filter, uint16_t num_samples, uint32_t render_pass_id){
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(filter, FILTER_OUTPUT);
+    if(output_sig->buffer == NULL) return;
+    filter_data_t * data = filter->plugin_data;
+    radspa_signal_t * input_sig = radspa_signal_get_by_index(filter, FILTER_INPUT);
+    radspa_signal_t * freq_sig = radspa_signal_get_by_index(filter, FILTER_FREQ);
+    radspa_signal_t * q_sig = radspa_signal_get_by_index(filter, FILTER_Q);
+    radspa_signal_t * gain_sig = radspa_signal_get_by_index(filter, FILTER_GAIN);
 
     static int16_t ret = 0;
-
-    for (uint16_t i = 0; i < num_samples; i++) {
-        int16_t input =
-            radspa_signal_get_value(input_sig, i, num_samples, render_pass_id);
-        int32_t freq =
-            radspa_signal_get_value(freq_sig, i, num_samples, render_pass_id);
-        int16_t q =
-            radspa_signal_get_value(q_sig, i, num_samples, render_pass_id);
-        int16_t gain =
-            radspa_signal_get_value(gain_sig, i, num_samples, render_pass_id);
-
-        if ((freq != data->prev_freq) | (q != data->prev_q)) {
-            set_filter_coeffs(data, freq, ((float)q + 1.) / 1000.);
+    
+    for(uint16_t i = 0; i < num_samples; i++){
+        int16_t input = radspa_signal_get_value(input_sig, i, num_samples, render_pass_id);
+        int32_t freq = radspa_signal_get_value(freq_sig, i, num_samples, render_pass_id);
+        int16_t q = radspa_signal_get_value(q_sig, i, num_samples, render_pass_id);
+        int16_t gain = radspa_signal_get_value(gain_sig, i, num_samples, render_pass_id);
+
+        if((freq != data->prev_freq) | (q != data->prev_q)){
+            set_filter_coeffs(data, freq, ((float) q + 1.)/1000.);
             data->prev_freq = freq;
             data->prev_q = q;
         }
@@ -130,22 +125,17 @@ void filter_run(radspa_t* filter, uint16_t num_samples,
     output_sig->value = ret;
 }
 
-radspa_t* filter_create(uint32_t real_init_var) {
-    radspa_t* filter = radspa_standard_plugin_create(
-        &filter_desc, FILTER_NUM_SIGNALS, sizeof(filter_data_t), 0);
-    if (filter == NULL) return NULL;
+radspa_t * filter_create(uint32_t real_init_var){
+    radspa_t * filter = radspa_standard_plugin_create(&filter_desc, FILTER_NUM_SIGNALS, sizeof(filter_data_t), 0);
+    if(filter == NULL) return NULL;
     filter->render = filter_run;
-    radspa_signal_set(filter, FILTER_OUTPUT, "output",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(filter, FILTER_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT,
-                      0);
-    radspa_signal_set(filter, FILTER_FREQ, "freq", RADSPA_SIGNAL_HINT_INPUT,
-                      500);
+    radspa_signal_set(filter, FILTER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(filter, FILTER_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 0);
+    radspa_signal_set(filter, FILTER_FREQ, "freq", RADSPA_SIGNAL_HINT_INPUT, 500);
     radspa_signal_set(filter, FILTER_Q, "reso", RADSPA_SIGNAL_HINT_INPUT, 1000);
-    radspa_signal_set(filter, FILTER_GAIN, "gain", RADSPA_SIGNAL_HINT_INPUT,
-                      32760);
-    filter_data_t* data = filter->plugin_data;
+    radspa_signal_set(filter, FILTER_GAIN, "gain", RADSPA_SIGNAL_HINT_INPUT, 32760);
+    filter_data_t * data = filter->plugin_data;
     data->pos = 0;
-    data->prev_freq = 1 << 24;
+    data->prev_freq = 1<<24;
     return filter;
 }
diff --git a/components/bl00mbox/plugins/brok3n/filter.h b/components/bl00mbox/plugins/brok3n/filter.h
index e575e7daca36dee48d17ba3ac24f98a115317ed8..36e3d1e93c06e5b01ef76a9e76a9360be44aa07f 100644
--- a/components/bl00mbox/plugins/brok3n/filter.h
+++ b/components/bl00mbox/plugins/brok3n/filter.h
@@ -15,5 +15,5 @@ typedef struct {
 } filter_data_t;
 
 extern radspa_descriptor_t filter_desc;
-radspa_t* filter_create(uint32_t init_var);
-void filter_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id);
+radspa_t * filter_create(uint32_t init_var);
+void filter_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
diff --git a/components/bl00mbox/plugins/delay.c b/components/bl00mbox/plugins/delay.c
index ede1d95a490180c060ef9c1dc3355a79acf3c252..756e703d72df7d4228bc9f21632a1b839de702b3 100644
--- a/components/bl00mbox/plugins/delay.c
+++ b/components/bl00mbox/plugins/delay.c
@@ -1,6 +1,6 @@
 #include "delay.h"
 
-radspa_t* delay_create(uint32_t init_var);
+radspa_t * delay_create(uint32_t init_var);
 radspa_descriptor_t delay_desc = {
     .name = "delay",
     .id = 42069,
@@ -18,94 +18,73 @@ radspa_descriptor_t delay_desc = {
 #define DELAY_DRY_VOL 5
 #define DELAY_REC_VOL 6
 
-void delay_run(radspa_t* delay, uint16_t num_samples, uint32_t render_pass_id) {
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(delay, DELAY_OUTPUT);
-    if (output_sig->buffer == NULL) return;
-    delay_data_t* data = delay->plugin_data;
-    int16_t* buf = delay->plugin_table;
-    radspa_signal_t* input_sig = radspa_signal_get_by_index(delay, DELAY_INPUT);
-    radspa_signal_t* time_sig = radspa_signal_get_by_index(delay, DELAY_TIME);
-    radspa_signal_t* feedback_sig =
-        radspa_signal_get_by_index(delay, DELAY_FEEDBACK);
-    radspa_signal_t* level_sig = radspa_signal_get_by_index(delay, DELAY_LEVEL);
-    radspa_signal_t* dry_vol_sig =
-        radspa_signal_get_by_index(delay, DELAY_DRY_VOL);
-    radspa_signal_t* rec_vol_sig =
-        radspa_signal_get_by_index(delay, DELAY_REC_VOL);
+void delay_run(radspa_t * delay, uint16_t num_samples, uint32_t render_pass_id){
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(delay, DELAY_OUTPUT);
+    if(output_sig->buffer == NULL) return;
+    delay_data_t * data = delay->plugin_data;
+    int16_t * buf = delay->plugin_table;
+    radspa_signal_t * input_sig = radspa_signal_get_by_index(delay, DELAY_INPUT);
+    radspa_signal_t * time_sig = radspa_signal_get_by_index(delay, DELAY_TIME);
+    radspa_signal_t * feedback_sig = radspa_signal_get_by_index(delay, DELAY_FEEDBACK);
+    radspa_signal_t * level_sig = radspa_signal_get_by_index(delay, DELAY_LEVEL);
+    radspa_signal_t * dry_vol_sig = radspa_signal_get_by_index(delay, DELAY_DRY_VOL);
+    radspa_signal_t * rec_vol_sig = radspa_signal_get_by_index(delay, DELAY_REC_VOL);
 
     static int16_t ret = 0;
-
+    
     uint32_t buffer_size = delay->plugin_table_len;
-
-    for (uint16_t i = 0; i < num_samples; i++) {
-        uint32_t time =
-            time_sig->get_value(time_sig, i, num_samples, render_pass_id);
-        if (time > data->max_delay) time = data->max_delay;
+    
+    for(uint16_t i = 0; i < num_samples; i++){
+        uint32_t time = time_sig->get_value(time_sig, i, num_samples, render_pass_id);
+        if(time > data->max_delay) time = data->max_delay;
 
         data->write_head_position++;
-        while (data->write_head_position >= buffer_size)
-            data->write_head_position -= buffer_size;  // maybe faster than %
-        if (time != data->time_prev) {
-            data->read_head_position =
-                time * (48000 / 1000) + data->write_head_position;
+        while(data->write_head_position >= buffer_size) data->write_head_position -= buffer_size; // maybe faster than %
+        if(time != data->time_prev){
+            data->read_head_position = time * (48000/1000) + data->write_head_position;
             data->time_prev = time;
         } else {
             data->read_head_position++;
         }
-        while (data->read_head_position >= buffer_size)
-            data->read_head_position -= buffer_size;
+        while(data->read_head_position >= buffer_size) data->read_head_position -= buffer_size;
 
-        // int16_t * buf = &(data->buffer);
-
-        int16_t dry =
-            input_sig->get_value(input_sig, i, num_samples, render_pass_id);
+        //int16_t * buf = &(data->buffer);
+    
+        int16_t dry = input_sig->get_value(input_sig, i, num_samples, render_pass_id);
         int16_t wet = buf[data->read_head_position];
 
-        int16_t fb = feedback_sig->get_value(feedback_sig, i, num_samples,
-                                             render_pass_id);
-        int16_t level =
-            level_sig->get_value(level_sig, i, num_samples, render_pass_id);
+        int16_t fb = feedback_sig->get_value(feedback_sig, i, num_samples, render_pass_id);
+        int16_t level = level_sig->get_value(level_sig, i, num_samples, render_pass_id);
 
-        int16_t dry_vol =
-            dry_vol_sig->get_value(dry_vol_sig, i, num_samples, render_pass_id);
-        int16_t rec_vol =
-            rec_vol_sig->get_value(rec_vol_sig, i, num_samples, render_pass_id);
+        int16_t dry_vol = dry_vol_sig->get_value(dry_vol_sig, i, num_samples, render_pass_id);
+        int16_t rec_vol = rec_vol_sig->get_value(rec_vol_sig, i, num_samples, render_pass_id);
 
-        if (rec_vol) {
-            buf[data->write_head_position] = radspa_add_sat(
-                radspa_mult_shift(rec_vol, dry), radspa_mult_shift(wet, fb));
+        if(rec_vol){
+            buf[data->write_head_position] = radspa_add_sat(radspa_mult_shift(rec_vol, dry), radspa_mult_shift(wet,fb));
         }
-
-        ret = radspa_add_sat(radspa_mult_shift(dry_vol, dry),
-                             radspa_mult_shift(wet, level));
+        
+        ret = radspa_add_sat(radspa_mult_shift(dry_vol,dry), radspa_mult_shift(wet,level));
 
         (output_sig->buffer)[i] = ret;
     }
     output_sig->value = ret;
 }
 
-radspa_t* delay_create(uint32_t init_var) {
-    if (init_var == 0) init_var = 500;
-    uint32_t buffer_size = init_var * (48000 / 1000);
-    radspa_t* delay = radspa_standard_plugin_create(
-        &delay_desc, DELAY_NUM_SIGNALS, sizeof(delay_data_t), buffer_size);
+radspa_t * delay_create(uint32_t init_var){
+    if(init_var == 0) init_var = 500;
+    uint32_t buffer_size = init_var*(48000/1000);
+    radspa_t * delay = radspa_standard_plugin_create(&delay_desc, DELAY_NUM_SIGNALS, sizeof(delay_data_t), buffer_size);
 
-    if (delay == NULL) return NULL;
-    delay_data_t* plugin_data = delay->plugin_data;
+    if(delay == NULL) return NULL;
+    delay_data_t * plugin_data = delay->plugin_data;
     plugin_data->max_delay = init_var;
     delay->render = delay_run;
-    radspa_signal_set(delay, DELAY_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT,
-                      0);
+    radspa_signal_set(delay, DELAY_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
     radspa_signal_set(delay, DELAY_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 0);
     radspa_signal_set(delay, DELAY_TIME, "time", RADSPA_SIGNAL_HINT_INPUT, 200);
-    radspa_signal_set(delay, DELAY_FEEDBACK, "feedback",
-                      RADSPA_SIGNAL_HINT_INPUT, 16000);
-    radspa_signal_set(delay, DELAY_LEVEL, "level", RADSPA_SIGNAL_HINT_INPUT,
-                      16000);
-    radspa_signal_set(delay, DELAY_DRY_VOL, "dry_vol", RADSPA_SIGNAL_HINT_INPUT,
-                      32767);
-    radspa_signal_set(delay, DELAY_REC_VOL, "rec_vol", RADSPA_SIGNAL_HINT_INPUT,
-                      32767);
+    radspa_signal_set(delay, DELAY_FEEDBACK, "feedback", RADSPA_SIGNAL_HINT_INPUT, 16000);
+    radspa_signal_set(delay, DELAY_LEVEL, "level", RADSPA_SIGNAL_HINT_INPUT, 16000);
+    radspa_signal_set(delay, DELAY_DRY_VOL, "dry_vol", RADSPA_SIGNAL_HINT_INPUT, 32767);
+    radspa_signal_set(delay, DELAY_REC_VOL, "rec_vol", RADSPA_SIGNAL_HINT_INPUT, 32767);
     return delay;
 }
diff --git a/components/bl00mbox/plugins/delay.h b/components/bl00mbox/plugins/delay.h
index 040a5af2cc9a4a7990055fa7e4fbf03da07a4ce0..c0882a1085164432b99351c98871834d39e1ad94 100644
--- a/components/bl00mbox/plugins/delay.h
+++ b/components/bl00mbox/plugins/delay.h
@@ -10,5 +10,6 @@ typedef struct {
 } delay_data_t;
 
 extern radspa_descriptor_t delay_desc;
-radspa_t* delay_create(uint32_t init_var);
-void delay_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id);
+radspa_t * delay_create(uint32_t init_var);
+void delay_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
+
diff --git a/components/bl00mbox/plugins/sampler.c b/components/bl00mbox/plugins/sampler.c
index c00041c5da1372c075c7cbc74e18ec288e57c9b8..8c7d65711c87edb8d2e89adb662f0b13f6805e02 100644
--- a/components/bl00mbox/plugins/sampler.c
+++ b/components/bl00mbox/plugins/sampler.c
@@ -1,6 +1,6 @@
 #include "sampler.h"
 
-radspa_t* sampler_create(uint32_t init_var);
+radspa_t * sampler_create(uint32_t init_var);
 radspa_descriptor_t sampler_desc = {
     .name = "sampler_ram",
     .id = 696969,
@@ -13,39 +13,35 @@ radspa_descriptor_t sampler_desc = {
 #define SAMPLER_OUTPUT 0
 #define SAMPLER_TRIGGER 1
 
-void sampler_run(radspa_t* sampler, uint16_t num_samples,
-                 uint32_t render_pass_id) {
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(sampler, SAMPLER_OUTPUT);
-    if (output_sig->buffer == NULL) return;
-    sampler_data_t* data = sampler->plugin_data;
-    int16_t* buf = sampler->plugin_table;
-    radspa_signal_t* trigger_sig =
-        radspa_signal_get_by_index(sampler, SAMPLER_TRIGGER);
+void sampler_run(radspa_t * sampler, uint16_t num_samples, uint32_t render_pass_id){
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(sampler, SAMPLER_OUTPUT);
+    if(output_sig->buffer == NULL) return;
+    sampler_data_t * data = sampler->plugin_data;
+    int16_t * buf = sampler->plugin_table;
+    radspa_signal_t * trigger_sig = radspa_signal_get_by_index(sampler, SAMPLER_TRIGGER);
 
     static int32_t ret = 0;
-
+    
     uint32_t buffer_size = sampler->plugin_table_len;
+    
+    for(uint16_t i = 0; i < num_samples; i++){
 
-    for (uint16_t i = 0; i < num_samples; i++) {
-        int16_t trigger =
-            trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id);
-
+        int16_t trigger = trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id);
+        
         int16_t vel = radspa_trigger_get(trigger, &(data->trigger_prev));
 
-        if (vel > 0) {
+        if(vel > 0){
             data->read_head_position = 0;
             data->volume = vel;
-        } else if (vel < 0) {
+        } else if(vel < 0){
             data->read_head_position = buffer_size;
         }
 
-        if (data->read_head_position < buffer_size) {
-            ret =
-                radspa_mult_shift(buf[data->read_head_position], data->volume);
+        if(data->read_head_position < buffer_size){
+            ret = radspa_mult_shift(buf[data->read_head_position], data->volume);
             data->read_head_position++;
         } else {
-            // ret = (ret * 255)>>8; // avoid dc clicks with bad samples
+            //ret = (ret * 255)>>8; // avoid dc clicks with bad samples
             ret = 0;
         }
 
@@ -54,17 +50,13 @@ void sampler_run(radspa_t* sampler, uint16_t num_samples,
     output_sig->value = ret;
 }
 
-radspa_t* sampler_create(uint32_t init_var) {
-    if (init_var == 0) return NULL;  // doesn't make sense
+radspa_t * sampler_create(uint32_t init_var){
+    if(init_var == 0) return NULL; //doesn't make sense
     uint32_t buffer_size = init_var;
-    radspa_t* sampler =
-        radspa_standard_plugin_create(&sampler_desc, SAMPLER_NUM_SIGNALS,
-                                      sizeof(sampler_data_t), buffer_size);
-    if (sampler == NULL) return NULL;
+    radspa_t * sampler = radspa_standard_plugin_create(&sampler_desc, SAMPLER_NUM_SIGNALS, sizeof(sampler_data_t), buffer_size);
+    if(sampler == NULL) return NULL;
     sampler->render = sampler_run;
-    radspa_signal_set(sampler, SAMPLER_OUTPUT, "output",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(sampler, SAMPLER_TRIGGER, "trigger",
-                      RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
+    radspa_signal_set(sampler, SAMPLER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(sampler, SAMPLER_TRIGGER, "trigger", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
     return sampler;
 }
diff --git a/components/bl00mbox/plugins/sampler.h b/components/bl00mbox/plugins/sampler.h
index c9bfd8dd28acb401ffa7e3c958704b957d3b5c44..53bedfbacd9b77c84148b80ecfcc34c74040fb27 100644
--- a/components/bl00mbox/plugins/sampler.h
+++ b/components/bl00mbox/plugins/sampler.h
@@ -9,5 +9,6 @@ typedef struct {
 } sampler_data_t;
 
 extern radspa_descriptor_t sampler_desc;
-radspa_t* sampler_create(uint32_t init_var);
-void sampler_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id);
+radspa_t * sampler_create(uint32_t init_var);
+void sampler_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
+
diff --git a/components/bl00mbox/plugins/sequencer.c b/components/bl00mbox/plugins/sequencer.c
index 21187962e47cc948f1e993c371f0cbe68a98c5d6..0d13d377acf206de274d2c4db97a4d7411d4adb1 100644
--- a/components/bl00mbox/plugins/sequencer.c
+++ b/components/bl00mbox/plugins/sequencer.c
@@ -1,12 +1,12 @@
 #include "sequencer.h"
 
-radspa_descriptor_t sequencer_desc = { .name = "sequencer",
-                                       .id = 56709,
-                                       .description = "i.o.u.",
-                                       .create_plugin_instance =
-                                           sequencer_create,
-                                       .destroy_plugin_instance =
-                                           radspa_standard_plugin_destroy };
+radspa_descriptor_t sequencer_desc = {
+    .name = "sequencer",
+    .id = 56709,
+    .description = "i.o.u.",
+    .create_plugin_instance = sequencer_create,
+    .destroy_plugin_instance = radspa_standard_plugin_destroy
+};
 
 #define SEQUENCER_NUM_SIGNALS 6
 #define SEQUENCER_STEP 0
@@ -17,53 +17,42 @@ radspa_descriptor_t sequencer_desc = { .name = "sequencer",
 #define SEQUENCER_BEAT_DIV 5
 #define SEQUENCER_OUTPUT 6
 
-static uint64_t target(uint64_t step_len, uint64_t bpm, uint64_t beat_div) {
-    return (48000ULL * 60 * 4) / (bpm * beat_div);
+static uint64_t target(uint64_t step_len, uint64_t bpm, uint64_t beat_div){
+        return (48000ULL * 60 * 4) / (bpm * beat_div);
 }
 
-radspa_t* sequencer_create(uint32_t init_var) {
-    // init_var:
-    //  lsbyte: number of channels
-    //  lsbyte+1: number of pixels in channel (>= bars*beats_div)
+radspa_t * sequencer_create(uint32_t init_var){
+    //init_var:
+    // lsbyte: number of channels
+    // lsbyte+1: number of pixels in channel (>= bars*beats_div)
     uint32_t num_tracks = 1;
     uint32_t num_pixels = 16;
-    if (init_var) {
+    if(init_var){
         num_tracks = init_var & 0xFF;
-        num_pixels = (init_var >> 8) & 0xFF;
+        num_pixels = (init_var>>8) & 0xFF;
     }
     uint32_t table_size = num_tracks * (num_pixels + 1);
-    uint32_t num_signals =
-        num_tracks + SEQUENCER_NUM_SIGNALS;  // one for each channel output
-    radspa_t* sequencer = radspa_standard_plugin_create(
-        &sequencer_desc, num_signals, sizeof(sequencer_data_t), table_size);
+    uint32_t num_signals = num_tracks + SEQUENCER_NUM_SIGNALS; //one for each channel output
+    radspa_t * sequencer = radspa_standard_plugin_create(&sequencer_desc, num_signals, sizeof(sequencer_data_t), table_size);
     sequencer->render = sequencer_run;
 
-    sequencer_data_t* data = sequencer->plugin_data;
+    sequencer_data_t * data = sequencer->plugin_data;
     data->track_step_len = num_pixels;
     data->num_tracks = num_tracks;
     data->bpm_prev = 120;
     data->beat_div_prev = 16;
-    data->counter_target =
-        target(data->track_step_len, data->bpm_prev, data->beat_div_prev);
-    radspa_signal_set(sequencer, SEQUENCER_STEP, "step",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(sequencer, SEQUENCER_STEP_LEN, "step_len",
-                      RADSPA_SIGNAL_HINT_INPUT, num_pixels);
-    radspa_signal_set(sequencer, SEQUENCER_SYNC_OUT, "sync_out",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(sequencer, SEQUENCER_SYNC_IN, "sync_in",
-                      RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
-    radspa_signal_set(sequencer, SEQUENCER_BPM, "bpm", RADSPA_SIGNAL_HINT_INPUT,
-                      data->bpm_prev);
-    radspa_signal_set(sequencer, SEQUENCER_BEAT_DIV, "beat_div",
-                      RADSPA_SIGNAL_HINT_INPUT, data->beat_div_prev);
-    radspa_signal_set(sequencer, SEQUENCER_OUTPUT, "output",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    data->counter_target = target(data->track_step_len, data->bpm_prev, data->beat_div_prev);
+    radspa_signal_set(sequencer, SEQUENCER_STEP, "step", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(sequencer, SEQUENCER_STEP_LEN, "step_len", RADSPA_SIGNAL_HINT_INPUT, num_pixels);
+    radspa_signal_set(sequencer, SEQUENCER_SYNC_OUT, "sync_out", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(sequencer, SEQUENCER_SYNC_IN, "sync_in", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
+    radspa_signal_set(sequencer, SEQUENCER_BPM, "bpm", RADSPA_SIGNAL_HINT_INPUT, data->bpm_prev);
+    radspa_signal_set(sequencer, SEQUENCER_BEAT_DIV, "beat_div", RADSPA_SIGNAL_HINT_INPUT, data->beat_div_prev);
+    radspa_signal_set(sequencer, SEQUENCER_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
 
     /*
     for(uint8_t i = 0; i < num_signals; i++){
-        radspa_signal_set(sequencer, SEQUENCER_NUM_SIGNALS + i, "track",
-    RADSPA_SIGNAL_HINT_OUTPUT, 0);
+        radspa_signal_set(sequencer, SEQUENCER_NUM_SIGNALS + i, "track", RADSPA_SIGNAL_HINT_OUTPUT, 0);
     }
     */
 
@@ -71,6 +60,7 @@ radspa_t* sequencer_create(uint32_t init_var) {
     data->sync_in_prev = 0;
     data->sync_out = 32767;
 
+
     return sequencer;
 }
 
@@ -78,90 +68,70 @@ radspa_t* sequencer_create(uint32_t init_var) {
  * first int16_t: track type:
  * -32767 : trigger track
  * 32767 : direct track
- * in between: slew rate
+ * in between: slew rate 
  */
 
-void sequencer_run(radspa_t* sequencer, uint16_t num_samples,
-                   uint32_t render_pass_id) {
-    radspa_signal_t* step_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_STEP);
-    radspa_signal_t* sync_out_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_OUT);
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_OUTPUT);
-    if ((output_sig->buffer == NULL) && (sync_out_sig->buffer == NULL) &&
-        (step_sig->buffer == NULL))
-        return;
-
-    radspa_signal_t* step_len_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_STEP_LEN);
-    radspa_signal_t* sync_in_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_IN);
-    radspa_signal_t* bpm_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_BPM);
-    radspa_signal_t* beat_div_sig =
-        radspa_signal_get_by_index(sequencer, SEQUENCER_BEAT_DIV);
-    sequencer_data_t* data = sequencer->plugin_data;
-    int16_t* table = sequencer->plugin_table;
-
-    int16_t s1 =
-        radspa_signal_get_value(step_len_sig, 0, num_samples, render_pass_id);
+void sequencer_run(radspa_t * sequencer, uint16_t num_samples, uint32_t render_pass_id){
+    radspa_signal_t * step_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_STEP);
+    radspa_signal_t * sync_out_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_OUT);
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_OUTPUT);
+    if((output_sig->buffer == NULL) && (sync_out_sig->buffer == NULL) && (step_sig->buffer == NULL)) return;
+
+    radspa_signal_t * step_len_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_STEP_LEN);
+    radspa_signal_t * sync_in_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_SYNC_IN);
+    radspa_signal_t * bpm_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_BPM);
+    radspa_signal_t * beat_div_sig = radspa_signal_get_by_index(sequencer, SEQUENCER_BEAT_DIV);
+    sequencer_data_t * data = sequencer->plugin_data;
+    int16_t * table = sequencer->plugin_table;
+
+    int16_t s1 = radspa_signal_get_value(step_len_sig, 0, num_samples, render_pass_id);
     int16_t s2 = data->track_step_len;
     data->step_target = s1 > 0 ? (s1 > s2 ? s2 : s1) : 1;
 
     int16_t bpm = bpm_sig->get_value(bpm_sig, 0, num_samples, render_pass_id);
-    int16_t beat_div =
-        beat_div_sig->get_value(beat_div_sig, 0, num_samples, render_pass_id);
-    if ((bpm != data->bpm_prev) || (beat_div != data->beat_div_prev)) {
+    int16_t beat_div = beat_div_sig->get_value(beat_div_sig, 0, num_samples, render_pass_id);
+    if((bpm != data->bpm_prev) || (beat_div != data->beat_div_prev)){
         data->counter_target = target(data->track_step_len, bpm, beat_div);
         data->bpm_prev = bpm;
         data->beat_div_prev = beat_div;
     }
+    
+    for(uint16_t i = 0; i < num_samples; i++){
 
-    for (uint16_t i = 0; i < num_samples; i++) {
         data->counter++;
-        if (data->counter >= data->counter_target) {
+        if(data->counter >= data->counter_target){
             data->counter = 0;
             data->step++;
-            if (data->step >= data->step_target) {
+            if(data->step >= data->step_target){
                 data->step = 0;
                 data->sync_out = -data->sync_out;
             }
         }
 
-        int16_t sync_in =
-            sync_in_sig->get_value(sync_in_sig, i, num_samples, render_pass_id);
-        if (((sync_in > 0) && (data->sync_in_prev <= 0)) ||
-            ((sync_in > 0) && (data->sync_in_prev <= 0))) {
+        int16_t sync_in = sync_in_sig->get_value(sync_in_sig, i, num_samples, render_pass_id);
+        if(((sync_in > 0) && (data->sync_in_prev <= 0)) || ((sync_in > 0) && (data->sync_in_prev <= 0))){
             data->counter = 0;
             data->step = 0;
             data->sync_out = -data->sync_out;
         }
         data->sync_in_prev = sync_in;
-
-        if (!data->counter) {  // event just happened
-            for (uint8_t track = 0; track < data->num_tracks; track++) {
-                int16_t type = table[track * data->track_step_len];
-                int16_t stage_val =
-                    table[data->step + 1 + data->track_step_len * track];
-                if (type == 32767) {
+        
+        if(!data->counter){ //event just happened
+            for(uint8_t track = 0; track < data->num_tracks; track++){
+                int16_t type = table[track*data->track_step_len];
+                int16_t stage_val = table[data->step + 1 + data->track_step_len * track];
+                if(type == 32767){
                     data->track_fill[track] = stage_val;
-                } else if (type == -32767) {
-                    if (stage_val > 0)
-                        data->track_fill[track] = radspa_trigger_start(
-                            stage_val, &(data->trigger_hist[track]));
-                    if (stage_val < 0)
-                        data->track_fill[track] =
-                            radspa_trigger_stop(&(data->trigger_hist[track]));
+                } else if(type == -32767){
+                    if(stage_val > 0) data->track_fill[track] = radspa_trigger_start(stage_val, &(data->trigger_hist[track]));
+                    if(stage_val < 0) data->track_fill[track] = radspa_trigger_stop(&(data->trigger_hist[track]));
                 }
             }
         }
-
-        if (output_sig->buffer != NULL)
-            (output_sig->buffer)[i] = data->track_fill[0];
-        if (sync_out_sig->buffer != NULL)
-            (sync_out_sig->buffer)[i] = data->sync_out;
-        if (step_sig->buffer != NULL) (step_sig->buffer)[i] = data->step;
+      
+        if(output_sig->buffer != NULL) (output_sig->buffer)[i] = data->track_fill[0];
+        if(sync_out_sig->buffer != NULL) (sync_out_sig->buffer)[i] = data->sync_out;
+        if(step_sig->buffer != NULL) (step_sig->buffer)[i] = data->step;
     }
     sync_out_sig->value = data->sync_out;
     output_sig->value = data->track_fill[0];
diff --git a/components/bl00mbox/plugins/sequencer.h b/components/bl00mbox/plugins/sequencer.h
index f59a3c092c7c71344c3b32c0cde92bdf4f134575..a6b5748af15ae359ca111fc08feea3a9403792b8 100644
--- a/components/bl00mbox/plugins/sequencer.h
+++ b/components/bl00mbox/plugins/sequencer.h
@@ -19,6 +19,5 @@ typedef struct {
 } sequencer_data_t;
 
 extern radspa_descriptor_t sequencer_desc;
-radspa_t* sequencer_create(uint32_t init_var);
-void sequencer_run(radspa_t* osc, uint16_t num_samples,
-                   uint32_t render_pass_id);
+radspa_t * sequencer_create(uint32_t init_var);
+void sequencer_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
diff --git a/components/bl00mbox/plugins/trad_synth/trad_synth.c b/components/bl00mbox/plugins/trad_synth/trad_synth.c
index d913f4567fc933723cb6c3c0a720d59643245493..aa1032bf854b5d41d8c11b2ab345d54ee737d6ef 100644
--- a/components/bl00mbox/plugins/trad_synth/trad_synth.c
+++ b/components/bl00mbox/plugins/trad_synth/trad_synth.c
@@ -19,109 +19,97 @@ radspa_descriptor_t trad_osc_desc = {
 #define TRAD_OSC_WAVEFORM 2
 #define TRAD_OSC_LIN_FM 3
 
-radspa_t* trad_osc_create(uint32_t init_var) {
-    radspa_t* trad_osc = radspa_standard_plugin_create(
-        &trad_osc_desc, TRAD_OSC_NUM_SIGNALS, sizeof(trad_osc_data_t), 0);
+radspa_t * trad_osc_create(uint32_t init_var){
+    radspa_t * trad_osc = radspa_standard_plugin_create(&trad_osc_desc, TRAD_OSC_NUM_SIGNALS, sizeof(trad_osc_data_t), 0);
     trad_osc->render = trad_osc_run;
-    radspa_signal_set(trad_osc, TRAD_OSC_OUTPUT, "output",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(trad_osc, TRAD_OSC_PITCH, "pitch",
-                      RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_SCT, 18367);
-    radspa_signal_set(trad_osc, TRAD_OSC_WAVEFORM, "waveform",
-                      RADSPA_SIGNAL_HINT_INPUT, -16000);
-    radspa_signal_set(trad_osc, TRAD_OSC_LIN_FM, "lin_fm",
-                      RADSPA_SIGNAL_HINT_INPUT, 0);
+    radspa_signal_set(trad_osc, TRAD_OSC_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(trad_osc, TRAD_OSC_PITCH, "pitch", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_SCT, 18367);
+    radspa_signal_set(trad_osc, TRAD_OSC_WAVEFORM, "waveform", RADSPA_SIGNAL_HINT_INPUT, -16000);
+    radspa_signal_set(trad_osc, TRAD_OSC_LIN_FM, "lin_fm", RADSPA_SIGNAL_HINT_INPUT, 0);
     return trad_osc;
 }
 
-void trad_osc_run(radspa_t* trad_osc, uint16_t num_samples,
-                  uint32_t render_pass_id) {
-    trad_osc_data_t* plugin_data = trad_osc->plugin_data;
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(trad_osc, TRAD_OSC_OUTPUT);
-    radspa_signal_t* pitch_sig =
-        radspa_signal_get_by_index(trad_osc, TRAD_OSC_PITCH);
-    radspa_signal_t* waveform_sig =
-        radspa_signal_get_by_index(trad_osc, TRAD_OSC_WAVEFORM);
-    radspa_signal_t* lin_fm_sig =
-        radspa_signal_get_by_index(trad_osc, TRAD_OSC_LIN_FM);
-    if (output_sig->buffer == NULL) return;
+void trad_osc_run(radspa_t * trad_osc, uint16_t num_samples, uint32_t render_pass_id){
+    trad_osc_data_t * plugin_data = trad_osc->plugin_data;
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_OUTPUT);
+    radspa_signal_t * pitch_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_PITCH);
+    radspa_signal_t * waveform_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_WAVEFORM);
+    radspa_signal_t * lin_fm_sig = radspa_signal_get_by_index(trad_osc, TRAD_OSC_LIN_FM);
+    if(output_sig->buffer == NULL) return;
 
     int16_t ret = 0;
-    for (uint16_t i = 0; i < num_samples; i++) {
-        int16_t pitch =
-            pitch_sig->get_value(pitch_sig, i, num_samples, render_pass_id);
-        int16_t wave = waveform_sig->get_value(waveform_sig, i, num_samples,
-                                               render_pass_id);
-        int32_t lin_fm =
-            lin_fm_sig->get_value(lin_fm_sig, i, num_samples, render_pass_id);
-
-        if (pitch != plugin_data->prev_pitch) {
+    for(uint16_t i = 0; i < num_samples; i++){
+        int16_t pitch = pitch_sig->get_value(pitch_sig, i, num_samples, render_pass_id);
+        int16_t wave = waveform_sig->get_value(waveform_sig, i, num_samples, render_pass_id);
+        int32_t lin_fm = lin_fm_sig->get_value(lin_fm_sig, i, num_samples, render_pass_id);
+
+        if(pitch != plugin_data->prev_pitch){
             plugin_data->incr = radspa_sct_to_rel_freq(pitch, 0);
             plugin_data->prev_pitch = pitch;
         }
         plugin_data->counter += plugin_data->incr;
-        if (lin_fm) {
+        if(lin_fm){
             plugin_data->counter += lin_fm * (plugin_data->incr >> 15);
         }
 
         int32_t tmp = (plugin_data->counter) >> 17;
-        tmp = (tmp * 2) - 32767;
+        tmp = (tmp*2) - 32767;
         ret = waveshaper(tmp, wave);
         (output_sig->buffer)[i] = ret;
     }
     output_sig->value = ret;
 }
 
-static inline int16_t triangle(int16_t saw) {
+static inline int16_t triangle(int16_t saw){
     int32_t tmp = saw;
     tmp += 16384;
-    if (tmp > 32767) tmp -= 65535;
-    if (tmp > 0) tmp = -tmp;
+    if(tmp > 32767) tmp -= 65535;
+    if(tmp > 0) tmp = -tmp;
     tmp = (2 * tmp) + 32767;
     return tmp;
 }
 
-inline int16_t waveshaper(int16_t saw, int16_t shape) {
+inline int16_t waveshaper(int16_t saw, int16_t shape){
     int32_t tmp = saw;
-    uint8_t sh = ((uint16_t)shape) >> 14;
-    sh = (sh + 2) % 4;
-    switch (sh) {
-        case 0:  // sine
+    uint8_t sh = ((uint16_t) shape) >> 14;
+    sh = (sh + 2)%4;
+    switch(sh){
+        case 0: //sine
             tmp = triangle(tmp);
-            if (tmp > 0) {
+            if(tmp > 0){
                 tmp = 32767 - tmp;
-                tmp = (tmp * tmp) >> 15;
+                tmp = (tmp*tmp)>>15;
                 tmp = 32767. - tmp;
             } else {
                 tmp = 32767 + tmp;
-                tmp = (tmp * tmp) >> 15;
+                tmp = (tmp*tmp)>>15;
                 tmp = tmp - 32767.;
             }
             break;
-        case 1:  // tri
+        case 1: //tri
             tmp = triangle(tmp);
             break;
-        case 2:  // square:
-            if (tmp > 0) {
+        case 2: //square:
+            if(tmp > 0){
                 tmp = 32767;
             } else {
                 tmp = -32767;
             }
             break;
-        default:  // saw
+        default: //saw
             break;
     }
     return tmp;
 }
 
 // plugin: trad_env
-radspa_descriptor_t trad_env_desc = { .name = "env_adsr",
-                                      .id = 42,
-                                      .description = "simple ADSR envelope",
-                                      .create_plugin_instance = trad_env_create,
-                                      .destroy_plugin_instance =
-                                          radspa_standard_plugin_destroy };
+radspa_descriptor_t trad_env_desc = {
+    .name = "env_adsr",
+    .id = 42,
+    .description = "simple ADSR envelope",
+    .create_plugin_instance = trad_env_create,
+    .destroy_plugin_instance = radspa_standard_plugin_destroy
+};
 
 #define TRAD_ENV_NUM_SIGNALS 9
 #define TRAD_ENV_OUTPUT 0
@@ -140,77 +128,66 @@ radspa_descriptor_t trad_env_desc = { .name = "env_adsr",
 #define TRAD_ENV_PHASE_SUSTAIN 3
 #define TRAD_ENV_PHASE_RELEASE 4
 
-radspa_t* trad_env_create(uint32_t init_var) {
-    radspa_t* trad_env = radspa_standard_plugin_create(
-        &trad_env_desc, TRAD_ENV_NUM_SIGNALS, sizeof(trad_env_data_t), 0);
+radspa_t * trad_env_create(uint32_t init_var){
+    radspa_t * trad_env = radspa_standard_plugin_create(&trad_env_desc, TRAD_ENV_NUM_SIGNALS, sizeof(trad_env_data_t),0);
     trad_env->render = trad_env_run;
-    radspa_signal_set(trad_env, TRAD_ENV_OUTPUT, "output",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(trad_env, TRAD_ENV_PHASE, "phase",
-                      RADSPA_SIGNAL_HINT_OUTPUT, 0);
-    radspa_signal_set(trad_env, TRAD_ENV_INPUT, "input",
-                      RADSPA_SIGNAL_HINT_INPUT, 32767);
-    radspa_signal_set(trad_env, TRAD_ENV_TRIGGER, "trigger",
-                      RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
-    radspa_signal_set(trad_env, TRAD_ENV_ATTACK, "attack",
-                      RADSPA_SIGNAL_HINT_INPUT, 100);
-    radspa_signal_set(trad_env, TRAD_ENV_DECAY, "decay",
-                      RADSPA_SIGNAL_HINT_INPUT, 250);
-    radspa_signal_set(trad_env, TRAD_ENV_SUSTAIN, "sustain",
-                      RADSPA_SIGNAL_HINT_INPUT, 16000);
-    radspa_signal_set(trad_env, TRAD_ENV_RELEASE, "release",
-                      RADSPA_SIGNAL_HINT_INPUT, 50);
-    radspa_signal_set(trad_env, TRAD_ENV_GATE, "gate", RADSPA_SIGNAL_HINT_INPUT,
-                      0);
+    radspa_signal_set(trad_env, TRAD_ENV_OUTPUT, "output", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(trad_env, TRAD_ENV_PHASE, "phase", RADSPA_SIGNAL_HINT_OUTPUT, 0);
+    radspa_signal_set(trad_env, TRAD_ENV_INPUT, "input", RADSPA_SIGNAL_HINT_INPUT, 32767);
+    radspa_signal_set(trad_env, TRAD_ENV_TRIGGER, "trigger", RADSPA_SIGNAL_HINT_INPUT | RADSPA_SIGNAL_HINT_TRIGGER, 0);
+    radspa_signal_set(trad_env, TRAD_ENV_ATTACK, "attack", RADSPA_SIGNAL_HINT_INPUT, 100);
+    radspa_signal_set(trad_env, TRAD_ENV_DECAY, "decay", RADSPA_SIGNAL_HINT_INPUT, 250);
+    radspa_signal_set(trad_env, TRAD_ENV_SUSTAIN, "sustain", RADSPA_SIGNAL_HINT_INPUT, 16000);
+    radspa_signal_set(trad_env, TRAD_ENV_RELEASE, "release", RADSPA_SIGNAL_HINT_INPUT, 50);
+    radspa_signal_set(trad_env, TRAD_ENV_GATE, "gate", RADSPA_SIGNAL_HINT_INPUT,0);
     radspa_signal_get_by_index(trad_env, TRAD_ENV_ATTACK)->unit = "ms";
     radspa_signal_get_by_index(trad_env, TRAD_ENV_DECAY)->unit = "ms";
     radspa_signal_get_by_index(trad_env, TRAD_ENV_SUSTAIN)->unit = "ms";
 
-    trad_env_data_t* data = trad_env->plugin_data;
+    trad_env_data_t * data = trad_env->plugin_data;
     data->trigger_prev = 0;
     data->env_phase = TRAD_ENV_PHASE_OFF;
 
     return trad_env;
 }
 
-static int16_t trad_env_run_single(trad_env_data_t* env) {
+static int16_t trad_env_run_single(trad_env_data_t * env){
     uint32_t tmp;
-    switch (env->env_phase) {
+    switch(env->env_phase){
         case TRAD_ENV_PHASE_OFF:
-            env->env_counter = 0;
-            ;
+            env->env_counter = 0;;
             break;
         case TRAD_ENV_PHASE_ATTACK:
             tmp = env->env_counter + env->attack;
-            if (tmp < env->env_counter) {  // overflow
-                tmp = ~((uint32_t)0);      // max out
+            if(tmp < env->env_counter){ // overflow
+                tmp = ~((uint32_t) 0); // max out
                 env->env_phase = TRAD_ENV_PHASE_DECAY;
             }
             env->env_counter = tmp;
             break;
         case TRAD_ENV_PHASE_DECAY:
             tmp = env->env_counter - env->decay;
-            if (tmp > env->env_counter) {  // underflow
-                tmp = 0;                   // bottom out
+            if(tmp > env->env_counter){ // underflow
+                tmp = 0; //bottom out
             }
             env->env_counter = tmp;
 
-            if (env->env_counter <= env->sustain) {
+            if(env->env_counter <= env->sustain){
                 env->env_counter = env->sustain;
                 env->env_phase = TRAD_ENV_PHASE_SUSTAIN;
-            } else if (env->env_counter < env->gate) {
+            } else if(env->env_counter < env->gate){
                 env->env_counter = 0;
                 env->env_phase = TRAD_ENV_PHASE_OFF;
             }
             break;
         case TRAD_ENV_PHASE_SUSTAIN:
-            if (env->sustain == 0) env->env_phase = TRAD_ENV_PHASE_OFF;
+            if(env->sustain == 0) env->env_phase = TRAD_ENV_PHASE_OFF;
             env->env_counter = env->sustain;
             break;
         case TRAD_ENV_PHASE_RELEASE:
             tmp = env->env_counter - env->release;
-            if (tmp > env->env_counter) {  // underflow
-                tmp = 0;                   // bottom out
+            if(tmp > env->env_counter){ // underflow
+                tmp = 0; //bottom out
                 env->env_phase = TRAD_ENV_PHASE_OFF;
             }
             env->env_counter = tmp;
@@ -228,152 +205,123 @@ static int16_t trad_env_run_single(trad_env_data_t* env) {
 #define SAMPLE_RATE_SORRY 48000
 #define TRAD_ENV_UNDERSAMPLING 5
 
-static inline uint32_t trad_env_time_ms_to_val_rise(uint16_t time_ms,
-                                                    uint32_t val) {
-    if (!time_ms) return UINT32_MAX;
-    uint32_t div = time_ms * ((SAMPLE_RATE_SORRY) / 1000);
-    return val / div;
+
+static inline uint32_t trad_env_time_ms_to_val_rise(uint16_t time_ms, uint32_t val){
+    if(!time_ms) return UINT32_MAX;
+    uint32_t div = time_ms * ((SAMPLE_RATE_SORRY)/1000);
+    return val/div;
 }
 
-static inline uint32_t uint32_sat_leftshift(uint32_t input, uint16_t left) {
-    if (!left) return input;                      // nothing to do
-    if (input >> (32 - left)) return UINT32_MAX;  // sat
+static inline uint32_t uint32_sat_leftshift(uint32_t input, uint16_t left){
+    if(!left) return input; // nothing to do
+    if(input >> (32-left)) return UINT32_MAX; // sat
     return input << left;
 }
 
-void trad_env_run(radspa_t* trad_env, uint16_t num_samples,
-                  uint32_t render_pass_id) {
-    trad_env_data_t* plugin_data = trad_env->plugin_data;
-    radspa_signal_t* output_sig =
-        radspa_signal_get_by_index(trad_env, TRAD_ENV_OUTPUT);
-    radspa_signal_t* phase_sig =
-        radspa_signal_get_by_index(trad_env, TRAD_ENV_PHASE);
-    if ((output_sig->buffer == NULL) && (phase_sig->buffer == NULL)) return;
-    radspa_signal_t* trigger_sig =
-        radspa_signal_get_by_index(trad_env, TRAD_ENV_TRIGGER);
-    radspa_signal_t* input_sig =
-        radspa_signal_get_by_index(trad_env, TRAD_ENV_INPUT);
-    radspa_signal_t* attack_sig = NULL;
-    radspa_signal_t* decay_sig = NULL;
-    radspa_signal_t* sustain_sig = NULL;
-    radspa_signal_t* release_sig = NULL;
-    radspa_signal_t* gate_sig = NULL;
+
+void trad_env_run(radspa_t * trad_env, uint16_t num_samples, uint32_t render_pass_id){
+    trad_env_data_t * plugin_data = trad_env->plugin_data;
+    radspa_signal_t * output_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_OUTPUT);
+    radspa_signal_t * phase_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_PHASE);
+    if((output_sig->buffer == NULL) && (phase_sig->buffer == NULL)) return;
+    radspa_signal_t * trigger_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_TRIGGER);
+    radspa_signal_t * input_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_INPUT);
+    radspa_signal_t * attack_sig = NULL;
+    radspa_signal_t * decay_sig = NULL;
+    radspa_signal_t * sustain_sig = NULL;
+    radspa_signal_t * release_sig = NULL;
+    radspa_signal_t * gate_sig = NULL;
 
     int16_t ret = output_sig->value;
 
-    for (uint16_t i = 0; i < num_samples; i++) {
+    for(uint16_t i = 0; i < num_samples; i++){
         static int16_t env = 0;
 
-        int16_t trigger =
-            trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id);
+        int16_t trigger = trigger_sig->get_value(trigger_sig, i, num_samples, render_pass_id);
         int16_t vel = radspa_trigger_get(trigger, &(plugin_data->trigger_prev));
 
-        if (vel < 0) {  // stop
-            if (plugin_data->env_phase != TRAD_ENV_PHASE_OFF) {
+        if(vel < 0){ // stop
+            if(plugin_data->env_phase != TRAD_ENV_PHASE_OFF){
                 plugin_data->env_phase = TRAD_ENV_PHASE_RELEASE;
                 plugin_data->release_init_val = plugin_data->env_counter;
             }
-        } else if (vel > 0) {  // start
+        } else if(vel > 0 ){ // start
             plugin_data->env_phase = TRAD_ENV_PHASE_ATTACK;
-            plugin_data->velocity = ((uint32_t)vel) << 17;
+            plugin_data->velocity = ((uint32_t) vel) << 17;
         }
 
-        if (!(i % (1 << TRAD_ENV_UNDERSAMPLING))) {
+        if(!(i%(1<<TRAD_ENV_UNDERSAMPLING))){
             uint16_t time_ms;
             uint32_t sus;
-            switch (plugin_data->env_phase) {
+            switch(plugin_data->env_phase){
                 case TRAD_ENV_PHASE_OFF:
                     break;
                 case TRAD_ENV_PHASE_ATTACK:
-                    if (attack_sig == NULL) {
-                        attack_sig = radspa_signal_get_by_index(
-                            trad_env, TRAD_ENV_ATTACK);
+                    if(attack_sig == NULL){
+                        attack_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_ATTACK);
                     }
-                    time_ms = attack_sig->get_value(attack_sig, i, num_samples,
-                                                    render_pass_id);
-                    if (time_ms != plugin_data->attack_prev_ms) {
-                        plugin_data->attack = uint32_sat_leftshift(
-                            trad_env_time_ms_to_val_rise(time_ms, UINT32_MAX),
-                            TRAD_ENV_UNDERSAMPLING);
+                    time_ms = attack_sig->get_value(attack_sig, i, num_samples, render_pass_id);
+                    if(time_ms != plugin_data->attack_prev_ms){
+                        plugin_data->attack = uint32_sat_leftshift(trad_env_time_ms_to_val_rise(time_ms, UINT32_MAX), TRAD_ENV_UNDERSAMPLING);
                         plugin_data->attack_prev_ms = time_ms;
                     }
                     break;
                 case TRAD_ENV_PHASE_DECAY:
-                    if (sustain_sig == NULL) {
-                        sustain_sig = radspa_signal_get_by_index(
-                            trad_env, TRAD_ENV_SUSTAIN);
+                    if(sustain_sig == NULL){
+                        sustain_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_SUSTAIN);
                     }
-                    sus = sustain_sig->get_value(sustain_sig, i, num_samples,
-                                                 render_pass_id);
-                    plugin_data->sustain = sus << 17;
+                    sus = sustain_sig->get_value(sustain_sig, i, num_samples, render_pass_id);
+                    plugin_data->sustain = sus<<17;
 
-                    if (gate_sig == NULL) {
-                        gate_sig =
-                            radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE);
+                    if(gate_sig == NULL){
+                        gate_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE);
                     }
-                    sus = gate_sig->get_value(gate_sig, i, num_samples,
-                                              render_pass_id);
-                    plugin_data->gate = sus << 17;
+                    sus = gate_sig->get_value(gate_sig, i, num_samples, render_pass_id);
+                    plugin_data->gate = sus<<17;
 
-                    if (decay_sig == NULL) {
-                        decay_sig = radspa_signal_get_by_index(trad_env,
-                                                               TRAD_ENV_DECAY);
+                    if(decay_sig == NULL){
+                        decay_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_DECAY);
                     }
-                    time_ms = decay_sig->get_value(decay_sig, i, num_samples,
-                                                   render_pass_id);
-                    if (time_ms != plugin_data->decay_prev_ms) {
-                        plugin_data->decay = uint32_sat_leftshift(
-                            trad_env_time_ms_to_val_rise(
-                                time_ms, UINT32_MAX - plugin_data->sustain),
-                            TRAD_ENV_UNDERSAMPLING);
+                    time_ms = decay_sig->get_value(decay_sig, i, num_samples, render_pass_id);
+                    if(time_ms != plugin_data->decay_prev_ms){
+                        plugin_data->decay = uint32_sat_leftshift(trad_env_time_ms_to_val_rise(time_ms, UINT32_MAX-plugin_data->sustain), TRAD_ENV_UNDERSAMPLING);
                         plugin_data->decay_prev_ms = time_ms;
                     }
                     break;
                 case TRAD_ENV_PHASE_SUSTAIN:
-                    if (sustain_sig == NULL) {
-                        sustain_sig = radspa_signal_get_by_index(
-                            trad_env, TRAD_ENV_SUSTAIN);
+                    if(sustain_sig == NULL){
+                        sustain_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_SUSTAIN);
                     }
-                    sus = sustain_sig->get_value(sustain_sig, i, num_samples,
-                                                 render_pass_id);
-                    plugin_data->sustain = sus << 17;
+                    sus = sustain_sig->get_value(sustain_sig, i, num_samples, render_pass_id);
+                    plugin_data->sustain = sus<<17;
                     break;
                 case TRAD_ENV_PHASE_RELEASE:
-                    if (gate_sig == NULL) {
-                        gate_sig =
-                            radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE);
+                    if(gate_sig == NULL){
+                        gate_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_GATE);
                     }
-                    sus = gate_sig->get_value(gate_sig, i, num_samples,
-                                              render_pass_id);
-                    plugin_data->gate = sus << 17;
+                    sus = gate_sig->get_value(gate_sig, i, num_samples, render_pass_id);
+                    plugin_data->gate = sus<<17;
 
-                    if (release_sig == NULL) {
-                        release_sig = radspa_signal_get_by_index(
-                            trad_env, TRAD_ENV_RELEASE);
+                    if(release_sig == NULL){
+                        release_sig = radspa_signal_get_by_index(trad_env, TRAD_ENV_RELEASE);
                     }
-                    time_ms = release_sig->get_value(
-                        release_sig, i, num_samples, render_pass_id);
-                    if (time_ms != plugin_data->release_prev_ms) {
-                        plugin_data->release = uint32_sat_leftshift(
-                            trad_env_time_ms_to_val_rise(
-                                time_ms, plugin_data->release_init_val),
-                            TRAD_ENV_UNDERSAMPLING);
+                    time_ms = release_sig->get_value(release_sig, i, num_samples, render_pass_id);
+                    if(time_ms != plugin_data->release_prev_ms){
+                        plugin_data->release = uint32_sat_leftshift(trad_env_time_ms_to_val_rise(time_ms, plugin_data->release_init_val), TRAD_ENV_UNDERSAMPLING);
                         plugin_data->release_prev_ms = time_ms;
                     }
                     break;
             }
             env = trad_env_run_single(plugin_data);
         }
-        if (env) {
-            int16_t input =
-                input_sig->get_value(input_sig, i, num_samples, render_pass_id);
+        if(env){
+            int16_t input = input_sig->get_value(input_sig, i, num_samples, render_pass_id);
             ret = radspa_mult_shift(env, input);
         } else {
             ret = 0;
         }
-        if (phase_sig->buffer != NULL)
-            (phase_sig->buffer)[i] = plugin_data->env_phase;
-        if (output_sig->buffer != NULL) (output_sig->buffer)[i] = ret;
+        if(phase_sig->buffer != NULL) (phase_sig->buffer)[i] = plugin_data->env_phase;
+        if(output_sig->buffer != NULL) (output_sig->buffer)[i] = ret;
     }
     phase_sig->value = plugin_data->env_phase;
     output_sig->value = ret;
diff --git a/components/bl00mbox/plugins/trad_synth/trad_synth.h b/components/bl00mbox/plugins/trad_synth/trad_synth.h
index bb144d0faa01e39a4b67b891effff8f3112ce561..e186cc7d35560c6d89d2c77312944f94b0079730 100644
--- a/components/bl00mbox/plugins/trad_synth/trad_synth.h
+++ b/components/bl00mbox/plugins/trad_synth/trad_synth.h
@@ -3,13 +3,11 @@
 #include "radspa.h"
 #include "radspa_helpers.h"
 
-/* provides traditional synthesizer functionality distributed over several
- * plugins.
+/* provides traditional synthesizer functionality distributed over several plugins.
  */
 
 /* plugin: trad_osc
- * oscillator that can generate sine, square, saw and triangle waves in the
- * audio band. uses trad_wave.
+ * oscillator that can generate sine, square, saw and triangle waves in the audio band. uses trad_wave.
  */
 
 typedef struct {
@@ -19,26 +17,27 @@ typedef struct {
 } trad_osc_data_t;
 
 extern radspa_descriptor_t trad_osc_desc;
-radspa_t* trad_osc_create(uint32_t init_var);
-void trad_osc_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id);
+radspa_t * trad_osc_create(uint32_t init_var);
+void trad_osc_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
 
 typedef struct {
-    uint32_t env_counter;
-    uint32_t attack;
-    uint32_t decay;
-    uint32_t sustain;
-    uint32_t release;
-    uint32_t release_init_val;
-    uint16_t attack_prev_ms;
-    uint16_t decay_prev_ms;
-    uint16_t release_prev_ms;
-    uint32_t gate;
-    uint32_t velocity;
-    uint8_t env_phase;
-    uint8_t skip_hold;
-    int16_t trigger_prev;
+    uint32_t    env_counter;
+    uint32_t    attack;
+    uint32_t    decay;
+    uint32_t    sustain;
+    uint32_t    release;
+    uint32_t    release_init_val;
+    uint16_t    attack_prev_ms;
+    uint16_t    decay_prev_ms;
+    uint16_t    release_prev_ms;
+    uint32_t    gate;
+    uint32_t    velocity;
+    uint8_t     env_phase;
+    uint8_t     skip_hold;
+    int16_t     trigger_prev;
 } trad_env_data_t;
 
 extern radspa_descriptor_t trad_env_desc;
-radspa_t* trad_env_create(uint32_t init_var);
-void trad_env_run(radspa_t* osc, uint16_t num_samples, uint32_t render_pass_id);
+radspa_t * trad_env_create(uint32_t init_var);
+void trad_env_run(radspa_t * osc, uint16_t num_samples, uint32_t render_pass_id);
+
diff --git a/components/bl00mbox/radspa/radspa.h b/components/bl00mbox/radspa/radspa.h
index 759238c1843dc11553810cfe759d6e0d8c5eb2b0..8093a71d98cecd8d4238e9676c42fadb9302a09d 100644
--- a/components/bl00mbox/radspa/radspa.h
+++ b/components/bl00mbox/radspa/radspa.h
@@ -1,30 +1,29 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 
 // Version 0.1.0
 
 /* Realtime Audio Developer's Simple Plugin Api
  *
- * Written from scratch but largely inspired by faint memories of the excellent
- * ladspa.h For a simple plugin implementation example check ampliverter.c/.h :D
+ * Written from scratch but largely inspired by faint memories of the excellent ladspa.h
+ * For a simple plugin implementation example check ampliverter.c/.h :D
  */
 
 #pragma once
 
+#include <string.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <string.h>
 
 /* CONVENTIONS
  *
  * All plugins communicate all signals in int16_t data.
  *
- * SCT (semi-cent, 2/ct) is a mapping between int16_t pitch values and frequency
- * values comparable to 1V/oct. in analog music electronics. A cent is a common
- * unit in music theory and describes 1/100 of a semitone or 1/1200 of an
- * octave. Typically 1 cent is precise enough for synth applications, however
- * 1/2 cent is better and allows for a 27 octave range. INT16_MAX represents a
- * frequency of 28160Hz, 6 octaves above middle A (440Hz) which is represented
- * by INT16_MAX - 6 * 2400.
+ * SCT (semi-cent, 2/ct) is a mapping between int16_t pitch values and frequency values comparable
+ * to 1V/oct. in analog music electronics. A cent is a common unit in music theory and describes
+ * 1/100 of a semitone or 1/1200 of an octave. Typically 1 cent is precise enough for synth
+ * applications, however 1/2 cent is better and allows for a 27 octave range. INT16_MAX
+ * represents a frequency of 28160Hz, 6 octaves above middle A (440Hz) which is represented by
+ * INT16_MAX - 6 * 2400.
  */
 
 // signal hints
@@ -39,70 +38,64 @@ struct _radspa_descriptor_t;
 struct _radspa_signal_t;
 struct _radspa_t;
 
-typedef struct _radspa_descriptor_t {
-    char* name;
-    uint32_t id;  // unique id number
-    char* description;
-    struct _radspa_t* (*create_plugin_instance)(uint32_t init_var);
-    void (*destroy_plugin_instance)(
-        struct _radspa_t* plugin);  // point to radspa_t
+typedef struct _radspa_descriptor_t{
+    char * name;
+    uint32_t id; // unique id number
+    char * description;
+    struct _radspa_t * (* create_plugin_instance)(uint32_t init_var);
+    void (* destroy_plugin_instance)(struct _radspa_t * plugin); // point to radspa_t
 } radspa_descriptor_t;
 
-typedef struct _radspa_signal_t {
+typedef struct _radspa_signal_t{
     uint32_t hints;
-    char* name;
-    char* description;
-    char* unit;
+    char * name;
+    char * description;
+    char * unit;
     int8_t name_multiplex;
 
-    int16_t* buffer;  // full buffer of num_samples. may be NULL.
+    int16_t * buffer; // full buffer of num_samples. may be NULL.
 
     // used for input channels only
-    int16_t value;  // static value, should be used if buffer is NULL.
+    int16_t value;  //static value, should be used if buffer is NULL.
     uint32_t render_pass_id;
     // function to retrieve value. radspa_helpers provides an example.
-    int16_t (*get_value)(struct _radspa_signal_t* sig, int16_t index,
-                         uint16_t num_samples, uint32_t render_pass_id);
+    int16_t (* get_value)(struct _radspa_signal_t * sig, int16_t index, uint16_t num_samples, uint32_t render_pass_id);
 
-    struct _radspa_signal_t* next;  // signals are in a linked list
+    struct _radspa_signal_t * next; //signals are in a linked list
 } radspa_signal_t;
 
-typedef struct _radspa_t {
-    const radspa_descriptor_t* descriptor;
+typedef struct _radspa_t{
+    const radspa_descriptor_t * descriptor;
 
     // linked list of all i/o signals of the module and length of list
-    radspa_signal_t* signals;
+    radspa_signal_t * signals; 
     uint8_t len_signals;
-
+    
     // renders all signal outputs for num_samples if render_pass_id has changed
     // since the last call, else does nothing.
-    void (*render)(struct _radspa_t* plugin, uint16_t num_samples,
-                   uint32_t render_pass_id);
+    void (* render)(struct _radspa_t * plugin, uint16_t num_samples, uint32_t render_pass_id);
 
     // stores id number of render pass.
     uint32_t render_pass_id;
 
-    void* plugin_data;  // internal data for the plugin to use. should not be
-                        // accessed from outside.
+
+    void * plugin_data; // internal data for the plugin to use. should not be accessed from outside.
     uint32_t plugin_table_len;
-    int16_t* plugin_table;
+    int16_t * plugin_table;
 } radspa_t;
 
 /* REQUIREMENTS
  * Hosts must provide implementations for the following functions:
  */
 
-/* The return value should equal frequency(sct) * UINT32_MAX /
- * (sample_rate>>undersample_pow) with: frequency(sct) = pow(2, (sct +
- * 2708)/2400)
- * /!\ Performance critical, might be called on a per-sample basis, do _not_
- * just use pow()!
+/* The return value should equal frequency(sct) * UINT32_MAX / (sample_rate>>undersample_pow) with:
+ * frequency(sct) = pow(2, (sct + 2708)/2400)
+ * /!\ Performance critical, might be called on a per-sample basis, do _not_ just use pow()!
  */
 extern uint32_t radspa_sct_to_rel_freq(int16_t sct, int16_t undersample_pow);
 
 // Return 1 if the buffer wasn't rendered already, 0 otherwise.
-extern bool radspa_host_request_buffer_render(int16_t* buf,
-                                              uint16_t num_samples);
+extern bool radspa_host_request_buffer_render(int16_t * buf, uint16_t num_samples);
 
 // limit a to -32767..32767
 extern int16_t radspa_clip(int32_t a);
@@ -111,6 +104,6 @@ extern int16_t radspa_add_sat(int32_t a, int32_t b);
 // (a*b)>>15
 extern int16_t radspa_mult_shift(int32_t a, int32_t b);
 
-extern int16_t radspa_trigger_start(int16_t velocity, int16_t* hist);
-extern int16_t radspa_trigger_stop(int16_t* hist);
-extern int16_t radspa_trigger_get(int16_t trigger_signal, int16_t* hist);
+extern int16_t radspa_trigger_start(int16_t velocity, int16_t * hist);
+extern int16_t radspa_trigger_stop(int16_t * hist);
+extern int16_t radspa_trigger_get(int16_t trigger_signal, int16_t * hist);
diff --git a/components/bl00mbox/radspa/radspa_helpers.c b/components/bl00mbox/radspa/radspa_helpers.c
index 66848db4e712e5e924b1c785a64c18f4c790c92f..a557e51b831cdbf94362a2bffdc3cbcbed8fbe0e 100644
--- a/components/bl00mbox/radspa/radspa_helpers.c
+++ b/components/bl00mbox/radspa/radspa_helpers.c
@@ -1,29 +1,26 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #include "radspa_helpers.h"
 
-radspa_signal_t* radspa_signal_get_by_index(radspa_t* plugin,
-                                            uint16_t signal_index) {
-    radspa_signal_t* ret = plugin->signals;
-    for (uint16_t i = 0; i < signal_index; i++) {
+radspa_signal_t * radspa_signal_get_by_index(radspa_t * plugin, uint16_t signal_index){
+    radspa_signal_t * ret = plugin->signals;
+    for(uint16_t i = 0; i < signal_index; i++){
         ret = ret->next;
-        if (ret == NULL) break;
+        if(ret == NULL) break;
     }
     return ret;
 }
 
-void radspa_signal_set(radspa_t* plugin, uint8_t signal_index, char* name,
-                       uint32_t hints, int16_t value) {
-    radspa_signal_t* sig = radspa_signal_get_by_index(plugin, signal_index);
-    if (sig == NULL) return;
+void radspa_signal_set(radspa_t * plugin, uint8_t signal_index, char * name, uint32_t hints, int16_t value){
+    radspa_signal_t * sig = radspa_signal_get_by_index(plugin, signal_index);
+    if(sig == NULL) return;
     sig->name = name;
     sig->hints = hints;
     sig->value = value;
 }
 
-int16_t radspa_signal_add(radspa_t* plugin, char* name, uint32_t hints,
-                          int16_t value) {
-    radspa_signal_t* sig = calloc(1, sizeof(radspa_signal_t));
-    if (sig == NULL) return -1;  // allocation failed
+int16_t radspa_signal_add(radspa_t * plugin, char * name, uint32_t hints, int16_t value){
+    radspa_signal_t * sig = calloc(1,sizeof(radspa_signal_t));
+    if(sig == NULL) return -1; // allocation failed
     sig->name = name;
     sig->hints = hints;
     sig->unit = "";
@@ -33,33 +30,29 @@ int16_t radspa_signal_add(radspa_t* plugin, char* name, uint32_t hints,
     sig->value = value;
     sig->name_multiplex = -1;
     sig->get_value = radspa_signal_get_value;
-
-    // find end of linked list
+    
+    //find end of linked list
     uint16_t list_index = 0;
-    if (plugin->signals == NULL) {
+    if(plugin->signals == NULL){
         plugin->signals = sig;
     } else {
-        radspa_signal_t* sigs = plugin->signals;
+        radspa_signal_t * sigs = plugin->signals;
         list_index++;
-        while (sigs->next != NULL) {
+        while(sigs->next != NULL){
             sigs = sigs->next;
             list_index++;
         }
         sigs->next = sig;
     }
-    if (plugin->len_signals != list_index) {
-        abort();
-    }
+    if(plugin->len_signals != list_index){ abort(); }  
     plugin->len_signals++;
     return list_index;
 }
 
-int16_t radspa_signal_get_value(radspa_signal_t* sig, int16_t index,
-                                uint16_t num_samples, uint32_t render_pass_id) {
-    if (sig->buffer != NULL) {
-        if (sig->render_pass_id != render_pass_id) {
-            radspa_host_request_buffer_render(
-                sig->buffer, num_samples);  //, render_pass_id);
+int16_t radspa_signal_get_value(radspa_signal_t * sig, int16_t index, uint16_t num_samples, uint32_t render_pass_id){
+    if(sig->buffer != NULL){
+        if(sig->render_pass_id != render_pass_id){
+            radspa_host_request_buffer_render(sig->buffer, num_samples); //, render_pass_id);
             sig->render_pass_id = render_pass_id;
         }
         return sig->buffer[index];
@@ -67,15 +60,12 @@ int16_t radspa_signal_get_value(radspa_signal_t* sig, int16_t index,
     return sig->value;
 }
 
-radspa_t* radspa_standard_plugin_create(radspa_descriptor_t* desc,
-                                        uint8_t num_signals,
-                                        size_t plugin_data_size,
-                                        uint32_t plugin_table_size) {
-    radspa_t* ret = calloc(1, sizeof(radspa_t));
-    if (ret == NULL) return NULL;
-    if (plugin_data_size) {
-        ret->plugin_data = calloc(1, plugin_data_size);
-        if (ret->plugin_data == NULL) {
+radspa_t * radspa_standard_plugin_create(radspa_descriptor_t * desc, uint8_t num_signals, size_t plugin_data_size, uint32_t plugin_table_size){
+    radspa_t * ret = calloc(1, sizeof(radspa_t));
+    if(ret == NULL) return NULL;
+    if(plugin_data_size){
+        ret->plugin_data = calloc(1,plugin_data_size);
+        if(ret->plugin_data == NULL){
             free(ret);
             return NULL;
         }
@@ -87,35 +77,35 @@ radspa_t* radspa_standard_plugin_create(radspa_descriptor_t* desc,
     ret->plugin_table_len = plugin_table_size;
 
     bool init_failed = false;
-    for (uint8_t i = 0; i < num_signals; i++) {
-        if (radspa_signal_add(ret, "UNINITIALIZED", 0, 0) == -1) {
+    for(uint8_t i = 0; i < num_signals; i++){
+        if(radspa_signal_add(ret,"UNINITIALIZED",0,0) == -1){
             init_failed = true;
             break;
         }
     }
 
-    if (ret->plugin_table_len) {
+    if(ret->plugin_table_len){
         ret->plugin_table = calloc(plugin_table_size, sizeof(int16_t));
-        if (ret->plugin_table == NULL) init_failed = true;
+        if(ret->plugin_table == NULL) init_failed = true;
     } else {
         ret->plugin_table = NULL;
     }
 
-    if (init_failed) {
+    if(init_failed){
         radspa_standard_plugin_destroy(ret);
         return NULL;
     }
     return ret;
 }
 
-void radspa_standard_plugin_destroy(radspa_t* plugin) {
-    radspa_signal_t* sig = plugin->signals;
-    while (sig != NULL) {
-        radspa_signal_t* sig_next = sig->next;
+void radspa_standard_plugin_destroy(radspa_t * plugin){
+    radspa_signal_t * sig = plugin->signals;
+    while(sig != NULL){
+        radspa_signal_t * sig_next = sig->next;
         free(sig);
         sig = sig_next;
     }
-    if (plugin->plugin_table != NULL) free(plugin->plugin_table);
-    if (plugin->plugin_data != NULL) free(plugin->plugin_data);
+    if(plugin->plugin_table != NULL) free(plugin->plugin_table);
+    if(plugin->plugin_data != NULL) free(plugin->plugin_data);
     free(plugin);
 }
diff --git a/components/bl00mbox/radspa/radspa_helpers.h b/components/bl00mbox/radspa/radspa_helpers.h
index 0db184684991dde91e0bd73dabf8f0d9446523d4..e1b9fa0eb852a38869384d6ee1161e7bb23a9557 100644
--- a/components/bl00mbox/radspa/radspa_helpers.h
+++ b/components/bl00mbox/radspa/radspa_helpers.h
@@ -1,31 +1,22 @@
-// SPDX-License-Identifier: CC0-1.0
+//SPDX-License-Identifier: CC0-1.0
 #pragma once
 #include "radspa.h"
 
-// adds signal to plugin instance struct. typically used to initiate a plugin
-// instance.
-int16_t radspa_signal_add(radspa_t* plugin, char* name, uint32_t hints,
-                          int16_t value);
-// as above, but sets parameters of an already existing signal with at list
-// position signal_index
-void radspa_signal_set(radspa_t* plugin, uint8_t signal_index, char* name,
-                       uint32_t hints, int16_t value);
+// adds signal to plugin instance struct. typically used to initiate a plugin instance.
+int16_t radspa_signal_add(radspa_t * plugin, char * name, uint32_t hints, int16_t value);
+// as above, but sets parameters of an already existing signal with at list position signal_index
+void radspa_signal_set(radspa_t * plugin, uint8_t signal_index, char * name, uint32_t hints, int16_t value);
 // get signal struct from a signal index
-radspa_signal_t* radspa_signal_get_by_index(radspa_t* plugin,
-                                            uint16_t signal_index);
+radspa_signal_t * radspa_signal_get_by_index(radspa_t * plugin, uint16_t signal_index);
 
-radspa_t* radspa_standard_plugin_create(radspa_descriptor_t* desc,
-                                        uint8_t num_signals,
-                                        size_t plugin_data_size,
-                                        uint32_t plugin_table_size);
-void radspa_standard_plugin_destroy(radspa_t* plugin);
+radspa_t * radspa_standard_plugin_create(radspa_descriptor_t * desc, uint8_t num_signals, size_t plugin_data_size, uint32_t plugin_table_size);
+void radspa_standard_plugin_destroy(radspa_t * plugin);
 
 // frees all signal structs. typically used to destroy a plugin instance.
-void radspa_signals_free(radspa_t* plugin);
+void radspa_signals_free(radspa_t * plugin);
 
 /* returns the value that a signal has at a given moment in time. time is
- * represented as the buffer index. requests rendering from host and requires
- * implementation of radspa_host_request_buffer_render.
+ * represented as the buffer index. requests rendering from host and requires implementation
+ * of radspa_host_request_buffer_render.
  */
-int16_t radspa_signal_get_value(radspa_signal_t* sig, int16_t index,
-                                uint16_t num_samples, uint32_t render_pass_id);
+int16_t radspa_signal_get_value(radspa_signal_t * sig, int16_t index, uint16_t num_samples, uint32_t render_pass_id);
diff --git a/tools/format.sh b/tools/format.sh
index bbb3b711978d8d9d14619e8dfb92ed958357194c..72383cbe702db46e484c31f8d1fbea9b946a0061 100755
--- a/tools/format.sh
+++ b/tools/format.sh
@@ -17,6 +17,7 @@ find . \
         -path './components/micropython/vendor' -o \
         -path './components/tinyusb' -o \
         -path './components/ctx' -o \
+        -path './components/bl00mbox' -o \
         -path './components/bmi270' -o \
         -path './components/bmp581' -o \
         -path './sim' \