diff --git a/.github/workflows/pvs_studio.yml b/.github/workflows/pvs_studio.yml
index 7bd71de49..981575551 100644
--- a/.github/workflows/pvs_studio.yml
+++ b/.github/workflows/pvs_studio.yml
@@ -65,6 +65,7 @@ jobs:
           pvs-studio-analyzer credentials ${{ secrets.PVS_STUDIO_CREDENTIALS }}
           pvs-studio-analyzer analyze \
               @.pvsoptions \
+              --disableLicenseExpirationCheck \
               -j$(grep -c processor /proc/cpuinfo) \
               -f build/f7-firmware-DC/compile_commands.json \
               -o PVS-Studio.log
diff --git a/applications/debug/bt_debug_app/views/bt_test.c b/applications/debug/bt_debug_app/views/bt_test.c
index 9f2830d34..9588b667b 100644
--- a/applications/debug/bt_debug_app/views/bt_test.c
+++ b/applications/debug/bt_debug_app/views/bt_test.c
@@ -154,7 +154,9 @@ static bool bt_test_input_callback(InputEvent* event, void* context) {
 
 void bt_test_process_up(BtTest* bt_test) {
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             uint8_t params_on_screen = 3;
             if(model->position > 0) {
                 model->position--;
@@ -168,13 +170,15 @@ void bt_test_process_up(BtTest* bt_test) {
                     model->window_position = model->position - (params_on_screen - 1);
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void bt_test_process_down(BtTest* bt_test) {
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             uint8_t params_on_screen = 3;
             if(model->position < (BtTestParamArray_size(model->params) - 1)) {
                 model->position++;
@@ -187,8 +191,8 @@ void bt_test_process_down(BtTest* bt_test) {
                 model->position = 0;
                 model->window_position = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 BtTestParam* bt_test_get_selected_param(BtTestModel* model) {
@@ -213,7 +217,9 @@ BtTestParam* bt_test_get_selected_param(BtTestModel* model) {
 void bt_test_process_left(BtTest* bt_test) {
     BtTestParam* param;
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             param = bt_test_get_selected_param(model);
             if(param->current_value_index > 0) {
                 param->current_value_index--;
@@ -225,8 +231,8 @@ void bt_test_process_left(BtTest* bt_test) {
                     model->packets_num_tx = 0;
                 }
             }
-            return true;
-        });
+        },
+        true);
     if(param->change_callback) {
         param->change_callback(param);
     }
@@ -235,7 +241,9 @@ void bt_test_process_left(BtTest* bt_test) {
 void bt_test_process_right(BtTest* bt_test) {
     BtTestParam* param;
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             param = bt_test_get_selected_param(model);
             if(param->current_value_index < (param->values_count - 1)) {
                 param->current_value_index++;
@@ -247,8 +255,8 @@ void bt_test_process_right(BtTest* bt_test) {
                     model->packets_num_tx = 0;
                 }
             }
-            return true;
-        });
+        },
+        true);
     if(param->change_callback) {
         param->change_callback(param);
     }
@@ -257,7 +265,9 @@ void bt_test_process_right(BtTest* bt_test) {
 void bt_test_process_ok(BtTest* bt_test) {
     BtTestState state;
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             if(model->state == BtTestStateStarted) {
                 model->state = BtTestStateStopped;
                 model->message = BT_TEST_START_MESSAGE;
@@ -269,8 +279,8 @@ void bt_test_process_ok(BtTest* bt_test) {
                 model->message = BT_TEST_STOP_MESSAGE;
             }
             state = model->state;
-            return true;
-        });
+        },
+        true);
     if(bt_test->change_state_callback) {
         bt_test->change_state_callback(state, bt_test->context);
     }
@@ -278,13 +288,15 @@ void bt_test_process_ok(BtTest* bt_test) {
 
 void bt_test_process_back(BtTest* bt_test) {
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             model->state = BtTestStateStopped;
             model->rssi = 0.0f;
             model->packets_num_rx = 0;
             model->packets_num_tx = 0;
-            return false;
-        });
+        },
+        false);
     if(bt_test->back_callback) {
         bt_test->back_callback(bt_test->context);
     }
@@ -299,7 +311,9 @@ BtTest* bt_test_alloc() {
     view_set_input_callback(bt_test->view, bt_test_input_callback);
 
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             model->state = BtTestStateStopped;
             model->message = "Ok - Start";
             BtTestParamArray_init(model->params);
@@ -308,8 +322,8 @@ BtTest* bt_test_alloc() {
             model->rssi = 0.0f;
             model->packets_num_tx = 0;
             model->packets_num_rx = 0;
-            return true;
-        });
+        },
+        true);
 
     return bt_test;
 }
@@ -318,15 +332,17 @@ void bt_test_free(BtTest* bt_test) {
     furi_assert(bt_test);
 
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             BtTestParamArray_it_t it;
             for(BtTestParamArray_it(it, model->params); !BtTestParamArray_end_p(it);
                 BtTestParamArray_next(it)) {
                 furi_string_free(BtTestParamArray_ref(it)->current_value_text);
             }
             BtTestParamArray_clear(model->params);
-            return false;
-        });
+        },
+        false);
     view_free(bt_test->view);
     free(bt_test);
 }
@@ -347,7 +363,9 @@ BtTestParam* bt_test_param_add(
     furi_assert(bt_test);
 
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
+        bt_test->view,
+        BtTestModel * model,
+        {
             param = BtTestParamArray_push_new(model->params);
             param->label = label;
             param->values_count = values_count;
@@ -355,8 +373,8 @@ BtTestParam* bt_test_param_add(
             param->context = context;
             param->current_value_index = 0;
             param->current_value_text = furi_string_alloc();
-            return true;
-        });
+        },
+        true);
 
     return param;
 }
@@ -364,28 +382,19 @@ BtTestParam* bt_test_param_add(
 void bt_test_set_rssi(BtTest* bt_test, float rssi) {
     furi_assert(bt_test);
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
-            model->rssi = rssi;
-            return true;
-        });
+        bt_test->view, BtTestModel * model, { model->rssi = rssi; }, true);
 }
 
 void bt_test_set_packets_tx(BtTest* bt_test, uint32_t packets_num) {
     furi_assert(bt_test);
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
-            model->packets_num_tx = packets_num;
-            return true;
-        });
+        bt_test->view, BtTestModel * model, { model->packets_num_tx = packets_num; }, true);
 }
 
 void bt_test_set_packets_rx(BtTest* bt_test, uint32_t packets_num) {
     furi_assert(bt_test);
     with_view_model(
-        bt_test->view, (BtTestModel * model) {
-            model->packets_num_rx = packets_num;
-            return true;
-        });
+        bt_test->view, BtTestModel * model, { model->packets_num_rx = packets_num; }, true);
 }
 
 void bt_test_set_change_state_callback(BtTest* bt_test, BtTestChangeStateCallback callback) {
diff --git a/applications/debug/display_test/view_display_test.c b/applications/debug/display_test/view_display_test.c
index f00fe0094..b47c74c6c 100644
--- a/applications/debug/display_test/view_display_test.c
+++ b/applications/debug/display_test/view_display_test.c
@@ -110,7 +110,9 @@ static bool view_display_test_input_callback(InputEvent* event, void* context) {
     bool consumed = false;
     if(event->type == InputTypeShort || event->type == InputTypeRepeat) {
         with_view_model(
-            instance->view, (ViewDisplayTestModel * model) {
+            instance->view,
+            ViewDisplayTestModel * model,
+            {
                 if(event->key == InputKeyLeft && model->test > 0) {
                     model->test--;
                     consumed = true;
@@ -129,8 +131,8 @@ static bool view_display_test_input_callback(InputEvent* event, void* context) {
                     model->flip_flop = !model->flip_flop;
                     consumed = true;
                 }
-                return consumed;
-            });
+            },
+            consumed);
     }
 
     return consumed;
@@ -149,10 +151,7 @@ static void view_display_test_exit(void* context) {
 static void view_display_test_timer_callback(void* context) {
     ViewDisplayTest* instance = context;
     with_view_model(
-        instance->view, (ViewDisplayTestModel * model) {
-            model->counter++;
-            return true;
-        });
+        instance->view, ViewDisplayTestModel * model, { model->counter++; }, true);
 }
 
 ViewDisplayTest* view_display_test_alloc() {
diff --git a/applications/debug/lfrfid_debug/views/lfrfid_debug_view_tune.c b/applications/debug/lfrfid_debug/views/lfrfid_debug_view_tune.c
index 38fe36036..fd221c4e9 100644
--- a/applications/debug/lfrfid_debug/views/lfrfid_debug_view_tune.c
+++ b/applications/debug/lfrfid_debug/views/lfrfid_debug_view_tune.c
@@ -52,23 +52,29 @@ static void lfrfid_debug_view_tune_draw_callback(Canvas* canvas, void* _model) {
 
 static void lfrfid_debug_view_tune_button_up(LfRfidTuneView* tune_view) {
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             if(model->pos > 0) model->pos--;
-            return true;
-        });
+        },
+        true);
 }
 
 static void lfrfid_debug_view_tune_button_down(LfRfidTuneView* tune_view) {
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             if(model->pos < 1) model->pos++;
-            return true;
-        });
+        },
+        true);
 }
 
 static void lfrfid_debug_view_tune_button_left(LfRfidTuneView* tune_view) {
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             if(model->pos == 0) {
                 if(model->fine) {
                     model->ARR -= 1;
@@ -84,13 +90,15 @@ static void lfrfid_debug_view_tune_button_left(LfRfidTuneView* tune_view) {
             }
 
             model->dirty = true;
-            return true;
-        });
+        },
+        true);
 }
 
 static void lfrfid_debug_view_tune_button_right(LfRfidTuneView* tune_view) {
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             if(model->pos == 0) {
                 if(model->fine) {
                     model->ARR += 1;
@@ -106,16 +114,13 @@ static void lfrfid_debug_view_tune_button_right(LfRfidTuneView* tune_view) {
             }
 
             model->dirty = true;
-            return true;
-        });
+        },
+        true);
 }
 
 static void lfrfid_debug_view_tune_button_ok(LfRfidTuneView* tune_view) {
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
-            model->fine = !model->fine;
-            return true;
-        });
+        tune_view->view, LfRfidTuneViewModel * model, { model->fine = !model->fine; }, true);
 }
 
 static bool lfrfid_debug_view_tune_input_callback(InputEvent* event, void* context) {
@@ -158,14 +163,16 @@ LfRfidTuneView* lfrfid_debug_view_tune_alloc() {
     view_allocate_model(tune_view->view, ViewModelTypeLocking, sizeof(LfRfidTuneViewModel));
 
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             model->dirty = true;
             model->fine = false;
             model->ARR = 511;
             model->CCR = 255;
             model->pos = 0;
-            return true;
-        });
+        },
+        true);
 
     view_set_draw_callback(tune_view->view, lfrfid_debug_view_tune_draw_callback);
     view_set_input_callback(tune_view->view, lfrfid_debug_view_tune_input_callback);
@@ -184,24 +191,28 @@ View* lfrfid_debug_view_tune_get_view(LfRfidTuneView* tune_view) {
 
 void lfrfid_debug_view_tune_clean(LfRfidTuneView* tune_view) {
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             model->dirty = true;
             model->fine = false;
             model->ARR = 511;
             model->CCR = 255;
             model->pos = 0;
-            return true;
-        });
+        },
+        true);
 }
 
 bool lfrfid_debug_view_tune_is_dirty(LfRfidTuneView* tune_view) {
     bool result = false;
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
+        tune_view->view,
+        LfRfidTuneViewModel * model,
+        {
             result = model->dirty;
             model->dirty = false;
-            return false;
-        });
+        },
+        false);
 
     return result;
 }
@@ -209,10 +220,7 @@ bool lfrfid_debug_view_tune_is_dirty(LfRfidTuneView* tune_view) {
 uint32_t lfrfid_debug_view_tune_get_arr(LfRfidTuneView* tune_view) {
     uint32_t result = false;
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
-            result = model->ARR;
-            return false;
-        });
+        tune_view->view, LfRfidTuneViewModel * model, { result = model->ARR; }, false);
 
     return result;
 }
@@ -220,10 +228,7 @@ uint32_t lfrfid_debug_view_tune_get_arr(LfRfidTuneView* tune_view) {
 uint32_t lfrfid_debug_view_tune_get_ccr(LfRfidTuneView* tune_view) {
     uint32_t result = false;
     with_view_model(
-        tune_view->view, (LfRfidTuneViewModel * model) {
-            result = model->CCR;
-            return false;
-        });
+        tune_view->view, LfRfidTuneViewModel * model, { result = model->CCR; }, false);
 
     return result;
 }
diff --git a/applications/debug/uart_echo/uart_echo.c b/applications/debug/uart_echo/uart_echo.c
index 03b6a31a6..701e5325a 100644
--- a/applications/debug/uart_echo/uart_echo.c
+++ b/applications/debug/uart_echo/uart_echo.c
@@ -3,7 +3,6 @@
 #include <notification/notification.h>
 #include <notification/notification_messages.h>
 #include <gui/elements.h>
-#include <stream_buffer.h>
 #include <furi_hal_uart.h>
 #include <furi_hal_console.h>
 #include <gui/view_dispatcher.h>
@@ -20,7 +19,7 @@ typedef struct {
     ViewDispatcher* view_dispatcher;
     View* view;
     FuriThread* worker_thread;
-    StreamBufferHandle_t rx_stream;
+    FuriStreamBuffer* rx_stream;
 } UartEchoApp;
 
 typedef struct {
@@ -92,13 +91,11 @@ static uint32_t uart_echo_exit(void* context) {
 
 static void uart_echo_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     furi_assert(context);
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     UartEchoApp* app = context;
 
     if(ev == UartIrqEventRXNE) {
-        xStreamBufferSendFromISR(app->rx_stream, &data, 1, &xHigherPriorityTaskWoken);
+        furi_stream_buffer_send(app->rx_stream, &data, 1, 0);
         furi_thread_flags_set(furi_thread_get_id(app->worker_thread), WorkerEventRx);
-        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
     }
 }
 
@@ -158,25 +155,24 @@ static int32_t uart_echo_worker(void* context) {
             size_t length = 0;
             do {
                 uint8_t data[64];
-                length = xStreamBufferReceive(app->rx_stream, data, 64, 0);
+                length = furi_stream_buffer_receive(app->rx_stream, data, 64, 0);
                 if(length > 0) {
                     furi_hal_uart_tx(FuriHalUartIdUSART1, data, length);
                     with_view_model(
-                        app->view, (UartDumpModel * model) {
+                        app->view,
+                        UartDumpModel * model,
+                        {
                             for(size_t i = 0; i < length; i++) {
                                 uart_echo_push_to_list(model, data[i]);
                             }
-                            return false;
-                        });
+                        },
+                        false);
                 }
             } while(length > 0);
 
             notification_message(app->notification, &sequence_notification);
             with_view_model(
-                app->view, (UartDumpModel * model) {
-                    UNUSED(model);
-                    return true;
-                });
+                app->view, UartDumpModel * model, { UNUSED(model); }, true);
         }
     }
 
@@ -186,7 +182,7 @@ static int32_t uart_echo_worker(void* context) {
 static UartEchoApp* uart_echo_app_alloc() {
     UartEchoApp* app = malloc(sizeof(UartEchoApp));
 
-    app->rx_stream = xStreamBufferCreate(2048, 1);
+    app->rx_stream = furi_stream_buffer_alloc(2048, 1);
 
     // Gui
     app->gui = furi_record_open(RECORD_GUI);
@@ -203,15 +199,17 @@ static UartEchoApp* uart_echo_app_alloc() {
     view_set_input_callback(app->view, uart_echo_view_input_callback);
     view_allocate_model(app->view, ViewModelTypeLocking, sizeof(UartDumpModel));
     with_view_model(
-        app->view, (UartDumpModel * model) {
+        app->view,
+        UartDumpModel * model,
+        {
             for(size_t i = 0; i < LINES_ON_SCREEN; i++) {
                 model->line = 0;
                 model->escape = false;
                 model->list[i] = malloc(sizeof(ListElement));
                 model->list[i]->text = furi_string_alloc();
             }
-            return true;
-        });
+        },
+        true);
 
     view_set_previous_callback(app->view, uart_echo_exit);
     view_dispatcher_add_view(app->view_dispatcher, 0, app->view);
@@ -245,13 +243,15 @@ static void uart_echo_app_free(UartEchoApp* app) {
     view_dispatcher_remove_view(app->view_dispatcher, 0);
 
     with_view_model(
-        app->view, (UartDumpModel * model) {
+        app->view,
+        UartDumpModel * model,
+        {
             for(size_t i = 0; i < LINES_ON_SCREEN; i++) {
                 furi_string_free(model->list[i]->text);
                 free(model->list[i]);
             }
-            return true;
-        });
+        },
+        true);
     view_free(app->view);
     view_dispatcher_free(app->view_dispatcher);
 
@@ -260,7 +260,7 @@ static void uart_echo_app_free(UartEchoApp* app) {
     furi_record_close(RECORD_NOTIFICATION);
     app->gui = NULL;
 
-    vStreamBufferDelete(app->rx_stream);
+    furi_stream_buffer_free(app->rx_stream);
 
     // Free rest
     free(app);
diff --git a/applications/debug/unit_tests/infrared/infrared_test.c b/applications/debug/unit_tests/infrared/infrared_test.c
index d861f266e..8879c8fc8 100644
--- a/applications/debug/unit_tests/infrared/infrared_test.c
+++ b/applications/debug/unit_tests/infrared/infrared_test.c
@@ -221,13 +221,13 @@ static void infrared_test_run_encoder(InfraredProtocol protocol, uint32_t test_i
     const char* protocol_name = infrared_get_protocol_name(protocol);
     mu_assert(infrared_test_prepare_file(protocol_name), "Failed to prepare test file");
 
-    furi_string_printf(buf, "encoder_input%d", test_index);
+    furi_string_printf(buf, "encoder_input%ld", test_index);
     mu_assert(
         infrared_test_load_messages(
             test->ff, furi_string_get_cstr(buf), &input_messages, &input_messages_count),
         "Failed to load messages from file");
 
-    furi_string_printf(buf, "encoder_expected%d", test_index);
+    furi_string_printf(buf, "encoder_expected%ld", test_index);
     mu_assert(
         infrared_test_load_raw_signal(
             test->ff, furi_string_get_cstr(buf), &expected_timings, &expected_timings_count),
@@ -277,7 +277,7 @@ static void infrared_test_run_encoder_decoder(InfraredProtocol protocol, uint32_
     const char* protocol_name = infrared_get_protocol_name(protocol);
     mu_assert(infrared_test_prepare_file(protocol_name), "Failed to prepare test file");
 
-    furi_string_printf(buf, "encoder_decoder_input%d", test_index);
+    furi_string_printf(buf, "encoder_decoder_input%ld", test_index);
     mu_assert(
         infrared_test_load_messages(
             test->ff, furi_string_get_cstr(buf), &input_messages, &input_messages_count),
@@ -336,13 +336,13 @@ static void infrared_test_run_decoder(InfraredProtocol protocol, uint32_t test_i
         infrared_test_prepare_file(infrared_get_protocol_name(protocol)),
         "Failed to prepare test file");
 
-    furi_string_printf(buf, "decoder_input%d", test_index);
+    furi_string_printf(buf, "decoder_input%ld", test_index);
     mu_assert(
         infrared_test_load_raw_signal(
             test->ff, furi_string_get_cstr(buf), &timings, &timings_count),
         "Failed to load raw signal from file");
 
-    furi_string_printf(buf, "decoder_expected%d", test_index);
+    furi_string_printf(buf, "decoder_expected%ld", test_index);
     mu_assert(
         infrared_test_load_messages(
             test->ff, furi_string_get_cstr(buf), &messages, &messages_count),
diff --git a/applications/debug/unit_tests/nfc/nfc_test.c b/applications/debug/unit_tests/nfc/nfc_test.c
index c1468c86f..f149508b0 100644
--- a/applications/debug/unit_tests/nfc/nfc_test.c
+++ b/applications/debug/unit_tests/nfc/nfc_test.c
@@ -112,7 +112,7 @@ static bool nfc_test_digital_signal_test_encode(
         // Check timings
         if(time > encode_max_time) {
             FURI_LOG_E(
-                TAG, "Encoding time: %d us while accepted value: %d us", time, encode_max_time);
+                TAG, "Encoding time: %ld us while accepted value: %ld us", time, encode_max_time);
             break;
         }
 
@@ -132,7 +132,7 @@ static bool nfc_test_digital_signal_test_encode(
             ref_timings_sum += ref[i];
             if(timings_diff > timing_tolerance) {
                 FURI_LOG_E(
-                    TAG, "Too big differece in %d timings. Ref: %d, DUT: %d", i, ref[i], dut[i]);
+                    TAG, "Too big differece in %d timings. Ref: %ld, DUT: %ld", i, ref[i], dut[i]);
                 timing_check_success = false;
                 break;
             }
@@ -143,16 +143,16 @@ static bool nfc_test_digital_signal_test_encode(
         if(sum_diff > timings_sum_tolerance) {
             FURI_LOG_E(
                 TAG,
-                "Too big difference in timings sum. Ref: %d, DUT: %d",
+                "Too big difference in timings sum. Ref: %ld, DUT: %ld",
                 ref_timings_sum,
                 dut_timings_sum);
             break;
         }
 
-        FURI_LOG_I(TAG, "Encoding time: %d us. Acceptable time: %d us", time, encode_max_time);
+        FURI_LOG_I(TAG, "Encoding time: %ld us. Acceptable time: %ld us", time, encode_max_time);
         FURI_LOG_I(
             TAG,
-            "Timings sum difference: %d [1/64MHZ]. Acceptable difference: %d [1/64MHz]",
+            "Timings sum difference: %ld [1/64MHZ]. Acceptable difference: %ld [1/64MHz]",
             sum_diff,
             timings_sum_tolerance);
         success = true;
diff --git a/applications/debug/unit_tests/rpc/rpc_test.c b/applications/debug/unit_tests/rpc/rpc_test.c
index 6ee2aed65..5b52df2fa 100644
--- a/applications/debug/unit_tests/rpc/rpc_test.c
+++ b/applications/debug/unit_tests/rpc/rpc_test.c
@@ -10,7 +10,6 @@
 #include <furi.h>
 #include "../minunit.h"
 #include <stdint.h>
-#include <stream_buffer.h>
 #include <pb.h>
 #include <pb_encode.h>
 #include <m-list.h>
@@ -34,7 +33,7 @@ static uint32_t command_id = 0;
 
 typedef struct {
     RpcSession* session;
-    StreamBufferHandle_t output_stream;
+    FuriStreamBuffer* output_stream;
     SemaphoreHandle_t close_session_semaphore;
     SemaphoreHandle_t terminate_semaphore;
     TickType_t timeout;
@@ -90,7 +89,7 @@ static void test_rpc_setup(void) {
     }
     furi_check(rpc_session[0].session);
 
-    rpc_session[0].output_stream = xStreamBufferCreate(1000, 1);
+    rpc_session[0].output_stream = furi_stream_buffer_alloc(1000, 1);
     rpc_session_set_send_bytes_callback(rpc_session[0].session, output_bytes_callback);
     rpc_session[0].close_session_semaphore = xSemaphoreCreateBinary();
     rpc_session[0].terminate_semaphore = xSemaphoreCreateBinary();
@@ -110,7 +109,7 @@ static void test_rpc_setup_second_session(void) {
     }
     furi_check(rpc_session[1].session);
 
-    rpc_session[1].output_stream = xStreamBufferCreate(1000, 1);
+    rpc_session[1].output_stream = furi_stream_buffer_alloc(1000, 1);
     rpc_session_set_send_bytes_callback(rpc_session[1].session, output_bytes_callback);
     rpc_session[1].close_session_semaphore = xSemaphoreCreateBinary();
     rpc_session[1].terminate_semaphore = xSemaphoreCreateBinary();
@@ -126,7 +125,7 @@ static void test_rpc_teardown(void) {
     rpc_session_close(rpc_session[0].session);
     furi_check(xSemaphoreTake(rpc_session[0].terminate_semaphore, portMAX_DELAY));
     furi_record_close(RECORD_RPC);
-    vStreamBufferDelete(rpc_session[0].output_stream);
+    furi_stream_buffer_free(rpc_session[0].output_stream);
     vSemaphoreDelete(rpc_session[0].close_session_semaphore);
     vSemaphoreDelete(rpc_session[0].terminate_semaphore);
     ++command_id;
@@ -141,7 +140,7 @@ static void test_rpc_teardown_second_session(void) {
     xSemaphoreTake(rpc_session[1].terminate_semaphore, 0);
     rpc_session_close(rpc_session[1].session);
     furi_check(xSemaphoreTake(rpc_session[1].terminate_semaphore, portMAX_DELAY));
-    vStreamBufferDelete(rpc_session[1].output_stream);
+    furi_stream_buffer_free(rpc_session[1].output_stream);
     vSemaphoreDelete(rpc_session[1].close_session_semaphore);
     vSemaphoreDelete(rpc_session[1].terminate_semaphore);
     ++command_id;
@@ -268,8 +267,8 @@ static PB_CommandStatus test_rpc_storage_get_file_error(File* file) {
 static void output_bytes_callback(void* ctx, uint8_t* got_bytes, size_t got_size) {
     RpcSessionContext* callbacks_context = ctx;
 
-    size_t bytes_sent =
-        xStreamBufferSend(callbacks_context->output_stream, got_bytes, got_size, FuriWaitForever);
+    size_t bytes_sent = furi_stream_buffer_send(
+        callbacks_context->output_stream, got_bytes, got_size, FuriWaitForever);
     (void)bytes_sent;
     furi_check(bytes_sent == got_size);
 }
@@ -534,7 +533,8 @@ static bool test_rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_
     TickType_t now = xTaskGetTickCount();
     int32_t time_left = session_context->timeout - now;
     time_left = MAX(time_left, 0);
-    bytes_received = xStreamBufferReceive(session_context->output_stream, buf, count, time_left);
+    bytes_received =
+        furi_stream_buffer_receive(session_context->output_stream, buf, count, time_left);
     return (count == bytes_received);
 }
 
diff --git a/applications/main/archive/helpers/archive_browser.c b/applications/main/archive/helpers/archive_browser.c
index f66030706..9689454ba 100644
--- a/applications/main/archive/helpers/archive_browser.c
+++ b/applications/main/archive/helpers/archive_browser.c
@@ -21,7 +21,9 @@ static void
         archive_switch_tab(browser, browser->last_tab_switch_dir);
     } else if(!furi_string_start_with_str(browser->path, "/app:")) {
         with_view_model(
-            browser->view, (ArchiveBrowserViewModel * model) {
+            browser->view,
+            ArchiveBrowserViewModel * model,
+            {
                 files_array_reset(model->files);
                 model->item_cnt = item_cnt;
                 model->item_idx = (file_idx > 0) ? file_idx : 0;
@@ -31,8 +33,8 @@ static void
                 model->list_offset = 0;
                 model->list_loading = true;
                 model->folder_loading = false;
-                return false;
-            });
+            },
+            false);
         archive_update_offset(browser);
 
         file_browser_worker_load(browser->worker, load_offset, FILE_LIST_BUF_LEN);
@@ -44,11 +46,13 @@ static void archive_list_load_cb(void* context, uint32_t list_load_offset) {
     ArchiveBrowserView* browser = (ArchiveBrowserView*)context;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             files_array_reset(model->files);
             model->array_offset = list_load_offset;
-            return false;
-        });
+        },
+        false);
 }
 
 static void
@@ -60,10 +64,7 @@ static void
         archive_add_file_item(browser, is_folder, furi_string_get_cstr(item_path));
     } else {
         with_view_model(
-            browser->view, (ArchiveBrowserViewModel * model) {
-                model->list_loading = false;
-                return true;
-            });
+            browser->view, ArchiveBrowserViewModel * model, { model->list_loading = false; }, true);
     }
 }
 
@@ -72,10 +73,7 @@ static void archive_long_load_cb(void* context) {
     ArchiveBrowserView* browser = (ArchiveBrowserView*)context;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            model->folder_loading = true;
-            return true;
-        });
+        browser->view, ArchiveBrowserViewModel * model, { model->folder_loading = true; }, true);
 }
 
 static void archive_file_browser_set_path(
@@ -113,7 +111,9 @@ void archive_update_offset(ArchiveBrowserView* browser) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             uint16_t bounds = model->item_cnt > 3 ? 2 : model->item_cnt;
 
             if((model->item_cnt > 3u) && (model->item_idx >= ((int32_t)model->item_cnt - 1))) {
@@ -125,9 +125,8 @@ void archive_update_offset(ArchiveBrowserView* browser) {
                 model->list_offset =
                     CLAMP(model->item_idx - 1, (int32_t)model->item_cnt - bounds, 0);
             }
-
-            return true;
-        });
+        },
+        true);
 }
 
 void archive_update_focus(ArchiveBrowserView* browser, const char* target) {
@@ -140,7 +139,9 @@ void archive_update_focus(ArchiveBrowserView* browser, const char* target) {
         archive_switch_tab(browser, TAB_RIGHT);
     } else {
         with_view_model(
-            browser->view, (ArchiveBrowserViewModel * model) {
+            browser->view,
+            ArchiveBrowserViewModel * model,
+            {
                 uint16_t idx = 0;
                 while(idx < files_array_size(model->files)) {
                     ArchiveFile_t* current = files_array_get(model->files, idx);
@@ -150,8 +151,8 @@ void archive_update_focus(ArchiveBrowserView* browser, const char* target) {
                     }
                     ++idx;
                 }
-                return false;
-            });
+            },
+            false);
 
         archive_update_offset(browser);
     }
@@ -162,10 +163,10 @@ size_t archive_file_get_array_size(ArchiveBrowserView* browser) {
 
     uint16_t size = 0;
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            size = files_array_size(model->files);
-            return false;
-        });
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        { size = files_array_size(model->files); },
+        false);
     return size;
 }
 
@@ -173,11 +174,13 @@ void archive_set_item_count(ArchiveBrowserView* browser, uint32_t count) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             model->item_cnt = count;
             model->item_idx = CLAMP(model->item_idx, (int32_t)model->item_cnt - 1, 0);
-            return false;
-        });
+        },
+        false);
     archive_update_offset(browser);
 }
 
@@ -186,7 +189,9 @@ void archive_file_array_rm_selected(ArchiveBrowserView* browser) {
     uint32_t items_cnt = 0;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             files_array_remove_v(
                 model->files,
                 model->item_idx - model->array_offset,
@@ -194,8 +199,8 @@ void archive_file_array_rm_selected(ArchiveBrowserView* browser) {
             model->item_cnt--;
             model->item_idx = CLAMP(model->item_idx, (int32_t)model->item_cnt - 1, 0);
             items_cnt = model->item_cnt;
-            return false;
-        });
+        },
+        false);
 
     if((items_cnt == 0) && (archive_is_home(browser))) {
         archive_switch_tab(browser, TAB_RIGHT);
@@ -208,7 +213,9 @@ void archive_file_array_swap(ArchiveBrowserView* browser, int8_t dir) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             ArchiveFile_t temp;
             size_t array_size = files_array_size(model->files) - 1;
             uint8_t swap_idx = CLAMP((size_t)(model->item_idx + dir), array_size, 0u);
@@ -226,18 +233,18 @@ void archive_file_array_swap(ArchiveBrowserView* browser, int8_t dir) {
             } else {
                 files_array_swap_at(model->files, model->item_idx, swap_idx);
             }
-            return false;
-        });
+        },
+        false);
 }
 
 void archive_file_array_rm_all(ArchiveBrowserView* browser) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            files_array_reset(model->files);
-            return false;
-        });
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        { files_array_reset(model->files); },
+        false);
 }
 
 void archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
@@ -246,7 +253,9 @@ void archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
     int32_t offset_new = 0;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             if(model->item_cnt > FILE_LIST_BUF_LEN) {
                 if(dir < 0) {
                     offset_new = model->item_idx - FILE_LIST_BUF_LEN / 4 * 3;
@@ -262,8 +271,8 @@ void archive_file_array_load(ArchiveBrowserView* browser, int8_t dir) {
                     offset_new = 0;
                 }
             }
-            return false;
-        });
+        },
+        false);
 
     file_browser_worker_load(browser->worker, offset_new, FILE_LIST_BUF_LEN);
 }
@@ -273,12 +282,14 @@ ArchiveFile_t* archive_get_current_file(ArchiveBrowserView* browser) {
 
     ArchiveFile_t* selected = NULL;
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             selected = files_array_size(model->files) ?
                            files_array_get(model->files, model->item_idx - model->array_offset) :
                            NULL;
-            return false;
-        });
+        },
+        false);
     return selected;
 }
 
@@ -288,11 +299,13 @@ ArchiveFile_t* archive_get_file_at(ArchiveBrowserView* browser, size_t idx) {
     ArchiveFile_t* selected = NULL;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             idx = CLAMP(idx - model->array_offset, files_array_size(model->files), 0u);
             selected = files_array_size(model->files) ? files_array_get(model->files, idx) : NULL;
-            return false;
-        });
+        },
+        false);
     return selected;
 }
 
@@ -301,10 +314,7 @@ ArchiveTabEnum archive_get_tab(ArchiveBrowserView* browser) {
 
     ArchiveTabEnum tab_id = 0;
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            tab_id = model->tab_idx;
-            return false;
-        });
+        browser->view, ArchiveBrowserViewModel * model, { tab_id = model->tab_idx; }, false);
     return tab_id;
 }
 
@@ -328,10 +338,7 @@ void archive_set_tab(ArchiveBrowserView* browser, ArchiveTabEnum tab) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            model->tab_idx = tab;
-            return false;
-        });
+        browser->view, ArchiveBrowserViewModel * model, { model->tab_idx = tab; }, false);
 }
 
 void archive_add_app_item(ArchiveBrowserView* browser, const char* name) {
@@ -344,11 +351,13 @@ void archive_add_app_item(ArchiveBrowserView* browser, const char* name) {
     archive_set_file_type(&item, name, false, true);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             files_array_push_back(model->files, item);
             model->item_cnt = files_array_size(model->files);
-            return false;
-        });
+        },
+        false);
     ArchiveFile_t_clear(&item);
 }
 
@@ -379,17 +388,19 @@ void archive_add_file_item(ArchiveBrowserView* browser, bool is_folder, const ch
         }
     }
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            files_array_push_back(model->files, item);
-            return false;
-        });
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        { files_array_push_back(model->files, item); },
+        false);
     ArchiveFile_t_clear(&item);
 }
 
 void archive_show_file_menu(ArchiveBrowserView* browser, bool show) {
     furi_assert(browser);
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             if(show) {
                 if(archive_is_item_in_array(model, model->item_idx)) {
                     model->menu = true;
@@ -403,19 +414,15 @@ void archive_show_file_menu(ArchiveBrowserView* browser, bool show) {
                 model->menu = false;
                 model->menu_idx = 0;
             }
-
-            return true;
-        });
+        },
+        true);
 }
 
 void archive_favorites_move_mode(ArchiveBrowserView* browser, bool active) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            model->move_fav = active;
-            return true;
-        });
+        browser->view, ArchiveBrowserViewModel * model, { model->move_fav = active; }, true);
 }
 
 static bool archive_is_dir_exists(FuriString* path) {
@@ -476,11 +483,13 @@ void archive_switch_tab(ArchiveBrowserView* browser, InputKey key) {
         archive_switch_tab(browser, key);
     } else {
         with_view_model(
-            browser->view, (ArchiveBrowserViewModel * model) {
+            browser->view,
+            ArchiveBrowserViewModel * model,
+            {
                 model->item_idx = 0;
                 model->array_offset = 0;
-                return false;
-            });
+            },
+            false);
         archive_get_items(browser, furi_string_get_cstr(browser->path));
         archive_update_offset(browser);
     }
@@ -493,10 +502,7 @@ void archive_enter_dir(ArchiveBrowserView* browser, FuriString* path) {
     int32_t idx_temp = 0;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            idx_temp = model->item_idx;
-            return false;
-        });
+        browser->view, ArchiveBrowserViewModel * model, { idx_temp = model->item_idx; }, false);
 
     furi_string_set(browser->path, path);
     file_browser_worker_folder_enter(browser->worker, path, idx_temp);
@@ -514,9 +520,6 @@ void archive_refresh_dir(ArchiveBrowserView* browser) {
     int32_t idx_temp = 0;
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            idx_temp = model->item_idx;
-            return false;
-        });
+        browser->view, ArchiveBrowserViewModel * model, { idx_temp = model->item_idx; }, false);
     file_browser_worker_folder_refresh(browser->worker, idx_temp);
 }
diff --git a/applications/main/archive/helpers/archive_favorites.h b/applications/main/archive/helpers/archive_favorites.h
index 29eedcdb6..db8943378 100644
--- a/applications/main/archive/helpers/archive_favorites.h
+++ b/applications/main/archive/helpers/archive_favorites.h
@@ -7,8 +7,8 @@
 
 uint16_t archive_favorites_count(void* context);
 bool archive_favorites_read(void* context);
-bool archive_favorites_delete(const char* format, ...);
-bool archive_is_favorite(const char* format, ...);
+bool archive_favorites_delete(const char* format, ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
+bool archive_is_favorite(const char* format, ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
 bool archive_favorites_rename(const char* src, const char* dst);
 void archive_add_to_favorites(const char* file_path);
 void archive_favorites_save(void* context);
diff --git a/applications/main/archive/helpers/archive_files.h b/applications/main/archive/helpers/archive_files.h
index 2017a9574..1822befa3 100644
--- a/applications/main/archive/helpers/archive_files.h
+++ b/applications/main/archive/helpers/archive_files.h
@@ -86,5 +86,7 @@ ARRAY_DEF(
 
 void archive_set_file_type(ArchiveFile_t* file, const char* path, bool is_folder, bool is_app);
 bool archive_get_items(void* context, const char* path);
-void archive_file_append(const char* path, const char* format, ...);
-void archive_delete_file(void* context, const char* format, ...);
+void archive_file_append(const char* path, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 2, 3)));
+void archive_delete_file(void* context, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 2, 3)));
diff --git a/applications/main/archive/views/archive_browser_view.c b/applications/main/archive/views/archive_browser_view.c
index f13094a1c..a2e219b95 100644
--- a/applications/main/archive/views/archive_browser_view.c
+++ b/applications/main/archive/views/archive_browser_view.c
@@ -263,33 +263,37 @@ static bool archive_view_input(InputEvent* event, void* context) {
     bool in_menu;
     bool move_fav_mode;
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             in_menu = model->menu;
             move_fav_mode = model->move_fav;
-            return false;
-        });
+        },
+        false);
 
     if(in_menu) {
         if(event->type == InputTypeShort) {
             if(event->key == InputKeyUp || event->key == InputKeyDown) {
                 with_view_model(
-                    browser->view, (ArchiveBrowserViewModel * model) {
+                    browser->view,
+                    ArchiveBrowserViewModel * model,
+                    {
                         if(event->key == InputKeyUp) {
                             model->menu_idx = ((model->menu_idx - 1) + MENU_ITEMS) % MENU_ITEMS;
                         } else if(event->key == InputKeyDown) {
                             model->menu_idx = (model->menu_idx + 1) % MENU_ITEMS;
                         }
-                        return true;
-                    });
+                    },
+                    true);
             }
 
             if(event->key == InputKeyOk) {
                 uint8_t idx;
                 with_view_model(
-                    browser->view, (ArchiveBrowserViewModel * model) {
-                        idx = model->menu_idx;
-                        return false;
-                    });
+                    browser->view,
+                    ArchiveBrowserViewModel * model,
+                    { idx = model->menu_idx; },
+                    false);
                 browser->callback(file_menu_actions[idx], browser->context);
             } else if(event->key == InputKeyBack) {
                 browser->callback(ArchiveBrowserEventFileMenuClose, browser->context);
@@ -313,7 +317,9 @@ static bool archive_view_input(InputEvent* event, void* context) {
         if((event->key == InputKeyUp || event->key == InputKeyDown) &&
            (event->type == InputTypeShort || event->type == InputTypeRepeat)) {
             with_view_model(
-                browser->view, (ArchiveBrowserViewModel * model) {
+                browser->view,
+                ArchiveBrowserViewModel * model,
+                {
                     if(event->key == InputKeyUp) {
                         model->item_idx =
                             ((model->item_idx - 1) + model->item_cnt) % model->item_cnt;
@@ -334,9 +340,8 @@ static bool archive_view_input(InputEvent* event, void* context) {
                             browser->callback(ArchiveBrowserEventFavMoveDown, browser->context);
                         }
                     }
-
-                    return true;
-                });
+                },
+                true);
             archive_update_offset(browser);
         }
 
@@ -384,11 +389,13 @@ ArchiveBrowserView* browser_alloc() {
     browser->path = furi_string_alloc_set(archive_get_default_path(TAB_DEFAULT));
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        {
             files_array_init(model->files);
             model->tab_idx = TAB_DEFAULT;
-            return true;
-        });
+        },
+        true);
 
     return browser;
 }
@@ -401,10 +408,10 @@ void browser_free(ArchiveBrowserView* browser) {
     }
 
     with_view_model(
-        browser->view, (ArchiveBrowserViewModel * model) {
-            files_array_clear(model->files);
-            return false;
-        });
+        browser->view,
+        ArchiveBrowserViewModel * model,
+        { files_array_clear(model->files); },
+        false);
 
     furi_string_free(browser->path);
 
diff --git a/applications/main/bad_usb/bad_usb_script.c b/applications/main/bad_usb/bad_usb_script.c
index 4166642bd..78aba88ed 100644
--- a/applications/main/bad_usb/bad_usb_script.c
+++ b/applications/main/bad_usb/bad_usb_script.c
@@ -109,6 +109,7 @@ static const char ducky_cmd_string[] = {"STRING "};
 static const char ducky_cmd_defdelay_1[] = {"DEFAULT_DELAY "};
 static const char ducky_cmd_defdelay_2[] = {"DEFAULTDELAY "};
 static const char ducky_cmd_repeat[] = {"REPEAT "};
+static const char ducky_cmd_sysrq[] = {"SYSRQ "};
 
 static const char ducky_cmd_altchar[] = {"ALTCHAR "};
 static const char ducky_cmd_altstr_1[] = {"ALTSTRING "};
@@ -292,6 +293,14 @@ static int32_t ducky_parse_line(BadUsbScript* bad_usb, FuriString* line) {
         line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
         state = ducky_get_number(line_tmp, &bad_usb->repeat_cnt);
         return (state) ? (0) : SCRIPT_STATE_ERROR;
+    } else if(strncmp(line_tmp, ducky_cmd_sysrq, strlen(ducky_cmd_sysrq)) == 0) {
+        // SYSRQ
+        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
+        uint16_t key = ducky_get_keycode(line_tmp, true);
+        furi_hal_hid_kb_press(KEY_MOD_LEFT_ALT | HID_KEYBOARD_PRINT_SCREEN);
+        furi_hal_hid_kb_press(key);
+        furi_hal_hid_kb_release_all();
+        return (0);
     } else {
         // Special keys + modifiers
         uint16_t key = ducky_get_keycode(line_tmp, false);
@@ -323,7 +332,7 @@ static bool ducky_set_usb_id(BadUsbScript* bad_usb, const char* line) {
         }
         FURI_LOG_D(
             WORKER_TAG,
-            "set id: %04X:%04X mfr:%s product:%s",
+            "set id: %04lX:%04lX mfr:%s product:%s",
             bad_usb->hid_cfg.vid,
             bad_usb->hid_cfg.pid,
             bad_usb->hid_cfg.manuf,
@@ -388,7 +397,7 @@ static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_fil
             return 0;
         } else if(delay_val < 0) { // Script error
             bad_usb->st.error_line = bad_usb->st.line_cur - 1;
-            FURI_LOG_E(WORKER_TAG, "Unknown command at line %lu", bad_usb->st.line_cur - 1);
+            FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur - 1);
             return SCRIPT_STATE_ERROR;
         } else {
             return (delay_val + bad_usb->defdelay);
@@ -420,7 +429,7 @@ static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_fil
                 delay_val = ducky_parse_line(bad_usb, bad_usb->line);
                 if(delay_val < 0) {
                     bad_usb->st.error_line = bad_usb->st.line_cur;
-                    FURI_LOG_E(WORKER_TAG, "Unknown command at line %lu", bad_usb->st.line_cur);
+                    FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur);
                     return SCRIPT_STATE_ERROR;
                 } else {
                     return (delay_val + bad_usb->defdelay);
diff --git a/applications/main/bad_usb/views/bad_usb_view.c b/applications/main/bad_usb/views/bad_usb_view.c
index 4e025b99c..db10d01ee 100644
--- a/applications/main/bad_usb/views/bad_usb_view.c
+++ b/applications/main/bad_usb/views/bad_usb_view.c
@@ -91,7 +91,7 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
         furi_string_reset(disp_str);
         canvas_draw_icon(canvas, 117, 22, &I_Percent_10x14);
         canvas_set_font(canvas, FontSecondary);
-        furi_string_printf(disp_str, "delay %us", model->state.delay_remain);
+        furi_string_printf(disp_str, "delay %lus", model->state.delay_remain);
         canvas_draw_str_aligned(
             canvas, 127, 46, AlignRight, AlignBottom, furi_string_get_cstr(disp_str));
         furi_string_reset(disp_str);
@@ -145,29 +145,33 @@ void bad_usb_set_ok_callback(BadUsb* bad_usb, BadUsbOkCallback callback, void* c
     furi_assert(bad_usb);
     furi_assert(callback);
     with_view_model(
-        bad_usb->view, (BadUsbModel * model) {
+        bad_usb->view,
+        BadUsbModel * model,
+        {
             UNUSED(model);
             bad_usb->callback = callback;
             bad_usb->context = context;
-            return true;
-        });
+        },
+        true);
 }
 
 void bad_usb_set_file_name(BadUsb* bad_usb, const char* name) {
     furi_assert(name);
     with_view_model(
-        bad_usb->view, (BadUsbModel * model) {
-            strlcpy(model->file_name, name, MAX_NAME_LEN);
-            return true;
-        });
+        bad_usb->view,
+        BadUsbModel * model,
+        { strlcpy(model->file_name, name, MAX_NAME_LEN); },
+        true);
 }
 
 void bad_usb_set_state(BadUsb* bad_usb, BadUsbState* st) {
     furi_assert(st);
     with_view_model(
-        bad_usb->view, (BadUsbModel * model) {
+        bad_usb->view,
+        BadUsbModel * model,
+        {
             memcpy(&(model->state), st, sizeof(BadUsbState));
             model->anim_frame ^= 1;
-            return true;
-        });
+        },
+        true);
 }
diff --git a/applications/main/fap_loader/elf_cpp/elf_hashtable.cpp b/applications/main/fap_loader/elf_cpp/elf_hashtable.cpp
index 17e2ba83f..f8adbf9d8 100644
--- a/applications/main/fap_loader/elf_cpp/elf_hashtable.cpp
+++ b/applications/main/fap_loader/elf_cpp/elf_hashtable.cpp
@@ -31,7 +31,7 @@ bool elf_resolve_from_hashtable(const char* name, Elf32_Addr* address) {
 
     auto find_res = std::lower_bound(elf_api_table.cbegin(), elf_api_table.cend(), key);
     if((find_res == elf_api_table.cend() || (find_res->hash != gnu_sym_hash))) {
-        FURI_LOG_W(TAG, "Cant find symbol '%s' (hash %x)!", name, gnu_sym_hash);
+        FURI_LOG_W(TAG, "Cant find symbol '%s' (hash %lx)!", name, gnu_sym_hash);
         result = false;
     } else {
         result = true;
diff --git a/applications/main/fap_loader/fap_loader_app.c b/applications/main/fap_loader/fap_loader_app.c
index fb0a300e7..d2f6b1f41 100644
--- a/applications/main/fap_loader/fap_loader_app.c
+++ b/applications/main/fap_loader/fap_loader_app.c
@@ -70,6 +70,7 @@ static bool fap_loader_run_selected_app(FapLoader* loader) {
     do {
         file_selected = true;
         loader->app = flipper_application_alloc(loader->storage, &hashtable_api_interface);
+        size_t start = furi_get_tick();
 
         FURI_LOG_I(TAG, "FAP Loader is loading %s", furi_string_get_cstr(loader->fap_path));
 
@@ -99,6 +100,7 @@ static bool fap_loader_run_selected_app(FapLoader* loader) {
             break;
         }
 
+        FURI_LOG_I(TAG, "Loaded in %ums", (size_t)(furi_get_tick() - start));
         FURI_LOG_I(TAG, "FAP Loader is staring app");
 
         FuriThread* thread = flipper_application_spawn(loader->app, NULL);
diff --git a/applications/main/gpio/usb_uart_bridge.c b/applications/main/gpio/usb_uart_bridge.c
index 02f58ed10..6e0bce736 100644
--- a/applications/main/gpio/usb_uart_bridge.c
+++ b/applications/main/gpio/usb_uart_bridge.c
@@ -1,6 +1,5 @@
 #include "usb_uart_bridge.h"
 #include "furi_hal.h"
-#include <stream_buffer.h>
 #include <furi_hal_usb_cdc.h>
 #include "usb_cdc.h"
 #include "cli/cli_vcp.h"
@@ -43,7 +42,7 @@ struct UsbUartBridge {
     FuriThread* thread;
     FuriThread* tx_thread;
 
-    StreamBufferHandle_t rx_stream;
+    FuriStreamBuffer* rx_stream;
 
     FuriMutex* usb_mutex;
 
@@ -74,12 +73,10 @@ static int32_t usb_uart_tx_thread(void* context);
 
 static void usb_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
     UsbUartBridge* usb_uart = (UsbUartBridge*)context;
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
 
     if(ev == UartIrqEventRXNE) {
-        xStreamBufferSendFromISR(usb_uart->rx_stream, &data, 1, &xHigherPriorityTaskWoken);
+        furi_stream_buffer_send(usb_uart->rx_stream, &data, 1, 0);
         furi_thread_flags_set(furi_thread_get_id(usb_uart->thread), WorkerEvtRxDone);
-        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
     }
 }
 
@@ -156,7 +153,7 @@ static int32_t usb_uart_worker(void* context) {
 
     memcpy(&usb_uart->cfg, &usb_uart->cfg_new, sizeof(UsbUartConfig));
 
-    usb_uart->rx_stream = xStreamBufferCreate(USB_UART_RX_BUF_SIZE, 1);
+    usb_uart->rx_stream = furi_stream_buffer_alloc(USB_UART_RX_BUF_SIZE, 1);
 
     usb_uart->tx_sem = furi_semaphore_alloc(1, 1);
     usb_uart->usb_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
@@ -189,8 +186,8 @@ static int32_t usb_uart_worker(void* context) {
         furi_check((events & FuriFlagError) == 0);
         if(events & WorkerEvtStop) break;
         if(events & WorkerEvtRxDone) {
-            size_t len =
-                xStreamBufferReceive(usb_uart->rx_stream, usb_uart->rx_buf, USB_CDC_PKT_LEN, 0);
+            size_t len = furi_stream_buffer_receive(
+                usb_uart->rx_stream, usb_uart->rx_buf, USB_CDC_PKT_LEN, 0);
             if(len > 0) {
                 if(furi_semaphore_acquire(usb_uart->tx_sem, 100) == FuriStatusOk) {
                     usb_uart->st.rx_cnt += len;
@@ -199,7 +196,7 @@ static int32_t usb_uart_worker(void* context) {
                     furi_hal_cdc_send(usb_uart->cfg.vcp_ch, usb_uart->rx_buf, len);
                     furi_check(furi_mutex_release(usb_uart->usb_mutex) == FuriStatusOk);
                 } else {
-                    xStreamBufferReset(usb_uart->rx_stream);
+                    furi_stream_buffer_reset(usb_uart->rx_stream);
                 }
             }
         }
@@ -270,7 +267,7 @@ static int32_t usb_uart_worker(void* context) {
     furi_thread_join(usb_uart->tx_thread);
     furi_thread_free(usb_uart->tx_thread);
 
-    vStreamBufferDelete(usb_uart->rx_stream);
+    furi_stream_buffer_free(usb_uart->rx_stream);
     furi_mutex_free(usb_uart->usb_mutex);
     furi_semaphore_free(usb_uart->tx_sem);
 
diff --git a/applications/main/gpio/views/gpio_test.c b/applications/main/gpio/views/gpio_test.c
index 89c09f864..69dc0f67b 100644
--- a/applications/main/gpio/views/gpio_test.c
+++ b/applications/main/gpio/views/gpio_test.c
@@ -48,23 +48,27 @@ static bool gpio_test_input_callback(InputEvent* event, void* context) {
 
 static bool gpio_test_process_left(GpioTest* gpio_test) {
     with_view_model(
-        gpio_test->view, (GpioTestModel * model) {
+        gpio_test->view,
+        GpioTestModel * model,
+        {
             if(model->pin_idx) {
                 model->pin_idx--;
             }
-            return true;
-        });
+        },
+        true);
     return true;
 }
 
 static bool gpio_test_process_right(GpioTest* gpio_test) {
     with_view_model(
-        gpio_test->view, (GpioTestModel * model) {
+        gpio_test->view,
+        GpioTestModel * model,
+        {
             if(model->pin_idx < GPIO_ITEM_COUNT) {
                 model->pin_idx++;
             }
-            return true;
-        });
+        },
+        true);
     return true;
 }
 
@@ -72,7 +76,9 @@ static bool gpio_test_process_ok(GpioTest* gpio_test, InputEvent* event) {
     bool consumed = false;
 
     with_view_model(
-        gpio_test->view, (GpioTestModel * model) {
+        gpio_test->view,
+        GpioTestModel * model,
+        {
             if(event->type == InputTypePress) {
                 if(model->pin_idx < GPIO_ITEM_COUNT) {
                     gpio_item_set_pin(model->pin_idx, true);
@@ -89,8 +95,8 @@ static bool gpio_test_process_ok(GpioTest* gpio_test, InputEvent* event) {
                 consumed = true;
             }
             gpio_test->callback(event->type, gpio_test->context);
-            return true;
-        });
+        },
+        true);
 
     return consumed;
 }
@@ -122,10 +128,12 @@ void gpio_test_set_ok_callback(GpioTest* gpio_test, GpioTestOkCallback callback,
     furi_assert(gpio_test);
     furi_assert(callback);
     with_view_model(
-        gpio_test->view, (GpioTestModel * model) {
+        gpio_test->view,
+        GpioTestModel * model,
+        {
             UNUSED(model);
             gpio_test->callback = callback;
             gpio_test->context = context;
-            return false;
-        });
+        },
+        false);
 }
diff --git a/applications/main/gpio/views/gpio_usb_uart.c b/applications/main/gpio/views/gpio_usb_uart.c
index d2d371b68..c7406d29b 100644
--- a/applications/main/gpio/views/gpio_usb_uart.c
+++ b/applications/main/gpio/views/gpio_usb_uart.c
@@ -54,7 +54,7 @@ static void gpio_usb_uart_draw_callback(Canvas* canvas, void* _model) {
         canvas_draw_str_aligned(canvas, 116, 24, AlignRight, AlignBottom, temp_str);
     } else {
         canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 127, 24, AlignRight, AlignBottom, "KB.");
+        canvas_draw_str_aligned(canvas, 127, 24, AlignRight, AlignBottom, "KiB.");
         canvas_set_font(canvas, FontKeyboard);
         snprintf(temp_str, 18, "%lu", model->tx_cnt / 1024);
         canvas_draw_str_aligned(canvas, 111, 24, AlignRight, AlignBottom, temp_str);
@@ -68,7 +68,7 @@ static void gpio_usb_uart_draw_callback(Canvas* canvas, void* _model) {
         canvas_draw_str_aligned(canvas, 116, 41, AlignRight, AlignBottom, temp_str);
     } else {
         canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 127, 41, AlignRight, AlignBottom, "KB.");
+        canvas_draw_str_aligned(canvas, 127, 41, AlignRight, AlignBottom, "KiB.");
         canvas_set_font(canvas, FontKeyboard);
         snprintf(temp_str, 18, "%lu", model->rx_cnt / 1024);
         canvas_draw_str_aligned(canvas, 111, 41, AlignRight, AlignBottom, temp_str);
@@ -129,12 +129,14 @@ void gpio_usb_uart_set_callback(GpioUsbUart* usb_uart, GpioUsbUartCallback callb
     furi_assert(callback);
 
     with_view_model(
-        usb_uart->view, (GpioUsbUartModel * model) {
+        usb_uart->view,
+        GpioUsbUartModel * model,
+        {
             UNUSED(model);
             usb_uart->callback = callback;
             usb_uart->context = context;
-            return false;
-        });
+        },
+        false);
 }
 
 void gpio_usb_uart_update_state(GpioUsbUart* instance, UsbUartConfig* cfg, UsbUartState* st) {
@@ -143,7 +145,9 @@ void gpio_usb_uart_update_state(GpioUsbUart* instance, UsbUartConfig* cfg, UsbUa
     furi_assert(st);
 
     with_view_model(
-        instance->view, (GpioUsbUartModel * model) {
+        instance->view,
+        GpioUsbUartModel * model,
+        {
             model->baudrate = st->baudrate_cur;
             model->vcp_port = cfg->vcp_ch;
             model->tx_pin = (cfg->uart_ch == 0) ? (13) : (15);
@@ -152,6 +156,6 @@ void gpio_usb_uart_update_state(GpioUsbUart* instance, UsbUartConfig* cfg, UsbUa
             model->rx_active = (model->rx_cnt != st->rx_cnt);
             model->tx_cnt = st->tx_cnt;
             model->rx_cnt = st->rx_cnt;
-            return true;
-        });
+        },
+        true);
 }
diff --git a/applications/main/infrared/infrared.c b/applications/main/infrared/infrared.c
index a647b158e..f62db14c1 100644
--- a/applications/main/infrared/infrared.c
+++ b/applications/main/infrared/infrared.c
@@ -92,14 +92,14 @@ static void infrared_find_vacant_remote_name(FuriString* name, const char* path)
         uint32_t i = 1;
         do {
             furi_string_printf(
-                path_temp, "%s%u%s", furi_string_get_cstr(base_path), ++i, INFRARED_APP_EXTENSION);
+                path_temp, "%s%lu%s", furi_string_get_cstr(base_path), ++i, INFRARED_APP_EXTENSION);
             status = storage_common_stat(storage, furi_string_get_cstr(path_temp), NULL);
         } while(status == FSE_OK);
 
         furi_string_free(path_temp);
 
         if(status == FSE_NOT_EXIST) {
-            furi_string_cat_printf(name, "%u", i);
+            furi_string_cat_printf(name, "%lu", i);
         }
     }
 
diff --git a/applications/main/infrared/infrared_signal.c b/applications/main/infrared/infrared_signal.c
index 30459d60f..d399b9587 100644
--- a/applications/main/infrared/infrared_signal.c
+++ b/applications/main/infrared/infrared_signal.c
@@ -61,7 +61,7 @@ static bool infrared_signal_is_raw_valid(InfraredRawSignal* raw) {
     if((raw->frequency > INFRARED_MAX_FREQUENCY) || (raw->frequency < INFRARED_MIN_FREQUENCY)) {
         FURI_LOG_E(
             TAG,
-            "Frequency is out of range (%lX - %lX): %lX",
+            "Frequency is out of range (%X - %X): %lX",
             INFRARED_MIN_FREQUENCY,
             INFRARED_MAX_FREQUENCY,
             raw->frequency);
@@ -74,7 +74,7 @@ static bool infrared_signal_is_raw_valid(InfraredRawSignal* raw) {
     } else if((raw->timings_size <= 0) || (raw->timings_size > MAX_TIMINGS_AMOUNT)) {
         FURI_LOG_E(
             TAG,
-            "Timings amount is out of range (0 - %lX): %lX",
+            "Timings amount is out of range (0 - %X): %X",
             MAX_TIMINGS_AMOUNT,
             raw->timings_size);
         return false;
diff --git a/applications/main/lfrfid/scenes/lfrfid_scene_save_data.c b/applications/main/lfrfid/scenes/lfrfid_scene_save_data.c
index 2ca1bb433..6c5ea2f2d 100644
--- a/applications/main/lfrfid/scenes/lfrfid_scene_save_data.c
+++ b/applications/main/lfrfid/scenes/lfrfid_scene_save_data.c
@@ -9,14 +9,11 @@ void lfrfid_scene_save_data_on_enter(void* context) {
 
     bool need_restore = scene_manager_get_scene_state(app->scene_manager, LfRfidSceneSaveData);
 
-    if(need_restore) {
-        protocol_dict_set_data(app->dict, app->protocol_id, app->old_key_data, size);
-    } else {
+    if(!need_restore) {
         protocol_dict_get_data(app->dict, app->protocol_id, app->old_key_data, size);
+        protocol_dict_get_data(app->dict, app->protocol_id, app->new_key_data, size);
     }
 
-    protocol_dict_get_data(app->dict, app->protocol_id, app->new_key_data, size);
-
     byte_input_set_header_text(byte_input, "Enter the data in hex");
 
     byte_input_set_result_callback(
@@ -41,6 +38,8 @@ bool lfrfid_scene_save_data_on_event(void* context, SceneManagerEvent event) {
         }
     } else if(event.type == SceneManagerEventTypeBack) {
         scene_manager_set_scene_state(scene_manager, LfRfidSceneSaveData, 0);
+        size_t size = protocol_dict_get_data_size(app->dict, app->protocol_id);
+        protocol_dict_set_data(app->dict, app->protocol_id, app->old_key_data, size);
     }
 
     return consumed;
diff --git a/applications/main/lfrfid/scenes/lfrfid_scene_save_success.c b/applications/main/lfrfid/scenes/lfrfid_scene_save_success.c
index 830ef3368..e91ad04e3 100644
--- a/applications/main/lfrfid/scenes/lfrfid_scene_save_success.c
+++ b/applications/main/lfrfid/scenes/lfrfid_scene_save_success.c
@@ -5,6 +5,9 @@ void lfrfid_scene_save_success_on_enter(void* context) {
     LfRfid* app = context;
     Popup* popup = app->popup;
 
+    // Clear state of data enter scene
+    scene_manager_set_scene_state(app->scene_manager, LfRfidSceneSaveData, 0);
+
     DOLPHIN_DEED(DolphinDeedRfidSave);
     popup_set_icon(popup, 32, 5, &I_DolphinNice_96x59);
     popup_set_header(popup, "Saved!", 5, 7, AlignLeft, AlignTop);
diff --git a/applications/main/lfrfid/views/lfrfid_view_read.c b/applications/main/lfrfid/views/lfrfid_view_read.c
index 66caf8df7..0d4db6178 100644
--- a/applications/main/lfrfid/views/lfrfid_view_read.c
+++ b/applications/main/lfrfid/views/lfrfid_view_read.c
@@ -56,19 +56,13 @@ static void lfrfid_view_read_draw_callback(Canvas* canvas, void* _model) {
 void lfrfid_view_read_enter(void* context) {
     LfRfidReadView* read_view = context;
     with_view_model(
-        read_view->view, (LfRfidReadViewModel * model) {
-            icon_animation_start(model->icon);
-            return true;
-        });
+        read_view->view, LfRfidReadViewModel * model, { icon_animation_start(model->icon); }, true);
 }
 
 void lfrfid_view_read_exit(void* context) {
     LfRfidReadView* read_view = context;
     with_view_model(
-        read_view->view, (LfRfidReadViewModel * model) {
-            icon_animation_stop(model->icon);
-            return false;
-        });
+        read_view->view, LfRfidReadViewModel * model, { icon_animation_stop(model->icon); }, false);
 }
 
 LfRfidReadView* lfrfid_view_read_alloc() {
@@ -78,11 +72,13 @@ LfRfidReadView* lfrfid_view_read_alloc() {
     view_allocate_model(read_view->view, ViewModelTypeLocking, sizeof(LfRfidReadViewModel));
 
     with_view_model(
-        read_view->view, (LfRfidReadViewModel * model) {
+        read_view->view,
+        LfRfidReadViewModel * model,
+        {
             model->icon = icon_animation_alloc(&A_Round_loader_8x8);
             view_tie_icon_animation(read_view->view, model->icon);
-            return false;
-        });
+        },
+        false);
 
     view_set_draw_callback(read_view->view, lfrfid_view_read_draw_callback);
     view_set_enter_callback(read_view->view, lfrfid_view_read_enter);
@@ -93,10 +89,7 @@ LfRfidReadView* lfrfid_view_read_alloc() {
 
 void lfrfid_view_read_free(LfRfidReadView* read_view) {
     with_view_model(
-        read_view->view, (LfRfidReadViewModel * model) {
-            icon_animation_free(model->icon);
-            return false;
-        });
+        read_view->view, LfRfidReadViewModel * model, { icon_animation_free(model->icon); }, false);
 
     view_free(read_view->view);
     free(read_view);
@@ -108,10 +101,12 @@ View* lfrfid_view_read_get_view(LfRfidReadView* read_view) {
 
 void lfrfid_view_read_set_read_mode(LfRfidReadView* read_view, LfRfidReadViewMode mode) {
     with_view_model(
-        read_view->view, (LfRfidReadViewModel * model) {
+        read_view->view,
+        LfRfidReadViewModel * model,
+        {
             icon_animation_stop(model->icon);
             icon_animation_start(model->icon);
             model->read_mode = mode;
-            return true;
-        });
+        },
+        true);
 }
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c b/applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c
index 5649ea870..19d2f556f 100644
--- a/applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c
+++ b/applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c
@@ -27,7 +27,7 @@ void nfc_scene_mf_classic_keys_list_prepare(Nfc* nfc, MfClassicDict* dict) {
         char* current_key = (char*)malloc(sizeof(char) * 13);
         strncpy(current_key, furi_string_get_cstr(temp_key), 12);
         MfClassicUserKeys_push_back(nfc->mfc_key_strs, current_key);
-        FURI_LOG_D("ListKeys", "Key %d: %s", index, current_key);
+        FURI_LOG_D("ListKeys", "Key %ld: %s", index, current_key);
         submenu_add_item(
             submenu, current_key, index++, nfc_scene_mf_classic_keys_list_submenu_callback, nfc);
     }
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c b/applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c
index c5b8cfa20..2ab0355ca 100644
--- a/applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c
+++ b/applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c
@@ -28,11 +28,11 @@ void nfc_scene_mf_desfire_read_success_on_enter(void* context) {
 
     uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
     uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
-    furi_string_cat_printf(temp_str, "\n%d", bytes_total);
+    furi_string_cat_printf(temp_str, "\n%ld", bytes_total);
     if(data->version.sw_storage & 1) {
         furi_string_push_back(temp_str, '+');
     }
-    furi_string_cat_printf(temp_str, " bytes, %d bytes free\n", bytes_free);
+    furi_string_cat_printf(temp_str, " bytes, %ld bytes free\n", bytes_free);
 
     uint16_t n_apps = 0;
     uint16_t n_files = 0;
diff --git a/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c b/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
index 158b1d2c1..0bb8eec7e 100644
--- a/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
+++ b/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
@@ -59,11 +59,11 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
         MifareDesfireData* data = &dev_data->mf_df_data;
         uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
         uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
-        furi_string_cat_printf(temp_str, "\n%d", bytes_total);
+        furi_string_cat_printf(temp_str, "\n%ld", bytes_total);
         if(data->version.sw_storage & 1) {
             furi_string_push_back(temp_str, '+');
         }
-        furi_string_cat_printf(temp_str, " bytes, %d bytes free\n", bytes_free);
+        furi_string_cat_printf(temp_str, " bytes, %ld bytes free\n", bytes_free);
 
         uint16_t n_apps = 0;
         uint16_t n_files = 0;
diff --git a/applications/main/nfc/views/detect_reader.c b/applications/main/nfc/views/detect_reader.c
index 9a0770438..2dbb4338b 100644
--- a/applications/main/nfc/views/detect_reader.c
+++ b/applications/main/nfc/views/detect_reader.c
@@ -64,10 +64,7 @@ static bool detect_reader_input_callback(InputEvent* event, void* context) {
 
     uint8_t nonces = 0;
     with_view_model(
-        detect_reader->view, (DetectReaderViewModel * model) {
-            nonces = model->nonces;
-            return false;
-        });
+        detect_reader->view, DetectReaderViewModel * model, { nonces = model->nonces; }, false);
 
     if(event->type == InputTypeShort) {
         if(event->key == InputKeyOk) {
@@ -103,12 +100,14 @@ void detect_reader_reset(DetectReader* detect_reader) {
     furi_assert(detect_reader);
 
     with_view_model(
-        detect_reader->view, (DetectReaderViewModel * model) {
+        detect_reader->view,
+        DetectReaderViewModel * model,
+        {
             model->nonces = 0;
             model->nonces_max = 0;
             model->state = DetectReaderStateStart;
-            return false;
-        });
+        },
+        false);
 }
 
 View* detect_reader_get_view(DetectReader* detect_reader) {
@@ -132,27 +131,24 @@ void detect_reader_set_nonces_max(DetectReader* detect_reader, uint16_t nonces_m
     furi_assert(detect_reader);
 
     with_view_model(
-        detect_reader->view, (DetectReaderViewModel * model) {
-            model->nonces_max = nonces_max;
-            return false;
-        });
+        detect_reader->view,
+        DetectReaderViewModel * model,
+        { model->nonces_max = nonces_max; },
+        false);
 }
 
 void detect_reader_set_nonces_collected(DetectReader* detect_reader, uint16_t nonces_collected) {
     furi_assert(detect_reader);
 
     with_view_model(
-        detect_reader->view, (DetectReaderViewModel * model) {
-            model->nonces = nonces_collected;
-            return false;
-        });
+        detect_reader->view,
+        DetectReaderViewModel * model,
+        { model->nonces = nonces_collected; },
+        false);
 }
 
 void detect_reader_set_state(DetectReader* detect_reader, DetectReaderState state) {
     furi_assert(detect_reader);
     with_view_model(
-        detect_reader->view, (DetectReaderViewModel * model) {
-            model->state = state;
-            return true;
-        });
+        detect_reader->view, DetectReaderViewModel * model, { model->state = state; }, true);
 }
diff --git a/applications/main/nfc/views/dict_attack.c b/applications/main/nfc/views/dict_attack.c
index cbafbf69a..c5f55ae76 100644
--- a/applications/main/nfc/views/dict_attack.c
+++ b/applications/main/nfc/views/dict_attack.c
@@ -80,20 +80,20 @@ DictAttack* dict_attack_alloc() {
     view_set_input_callback(dict_attack->view, dict_attack_input_callback);
     view_set_context(dict_attack->view, dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            model->header = furi_string_alloc();
-            return false;
-        });
+        dict_attack->view,
+        DictAttackViewModel * model,
+        { model->header = furi_string_alloc(); },
+        false);
     return dict_attack;
 }
 
 void dict_attack_free(DictAttack* dict_attack) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            furi_string_free(model->header);
-            return false;
-        });
+        dict_attack->view,
+        DictAttackViewModel * model,
+        { furi_string_free(model->header); },
+        false);
     view_free(dict_attack->view);
     free(dict_attack);
 }
@@ -101,7 +101,9 @@ void dict_attack_free(DictAttack* dict_attack) {
 void dict_attack_reset(DictAttack* dict_attack) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
             model->state = DictAttackStateRead;
             model->type = MfClassicType1k;
             model->sectors_total = 0;
@@ -112,8 +114,8 @@ void dict_attack_reset(DictAttack* dict_attack) {
             model->dict_keys_total = 0;
             model->dict_keys_current = 0;
             furi_string_reset(model->header);
-            return false;
-        });
+        },
+        false);
 }
 
 View* dict_attack_get_view(DictAttack* dict_attack) {
@@ -133,99 +135,103 @@ void dict_attack_set_header(DictAttack* dict_attack, const char* header) {
     furi_assert(header);
 
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            furi_string_set(model->header, header);
-            return true;
-        });
+        dict_attack->view,
+        DictAttackViewModel * model,
+        { furi_string_set(model->header, header); },
+        true);
 }
 
 void dict_attack_set_card_detected(DictAttack* dict_attack, MfClassicType type) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
             model->state = DictAttackStateRead;
             model->sectors_total = mf_classic_get_total_sectors_num(type);
             model->keys_total = model->sectors_total * 2;
-            return true;
-        });
+        },
+        true);
 }
 
 void dict_attack_set_card_removed(DictAttack* dict_attack) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            model->state = DictAttackStateCardRemoved;
-            return true;
-        });
+        dict_attack->view,
+        DictAttackViewModel * model,
+        { model->state = DictAttackStateCardRemoved; },
+        true);
 }
 
 void dict_attack_set_sector_read(DictAttack* dict_attack, uint8_t sec_read) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            model->sectors_read = sec_read;
-            return true;
-        });
+        dict_attack->view, DictAttackViewModel * model, { model->sectors_read = sec_read; }, true);
 }
 
 void dict_attack_set_keys_found(DictAttack* dict_attack, uint8_t keys_found) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            model->keys_found = keys_found;
-            return true;
-        });
+        dict_attack->view, DictAttackViewModel * model, { model->keys_found = keys_found; }, true);
 }
 
 void dict_attack_set_current_sector(DictAttack* dict_attack, uint8_t curr_sec) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
             model->sector_current = curr_sec;
             model->dict_keys_current = 0;
-            return true;
-        });
+        },
+        true);
 }
 
 void dict_attack_inc_current_sector(DictAttack* dict_attack) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
             if(model->sector_current < model->sectors_total) {
                 model->sector_current++;
                 model->dict_keys_current = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void dict_attack_inc_keys_found(DictAttack* dict_attack) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
             if(model->keys_found < model->keys_total) {
                 model->keys_found++;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void dict_attack_set_total_dict_keys(DictAttack* dict_attack, uint16_t dict_keys_total) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
-            model->dict_keys_total = dict_keys_total;
-            return true;
-        });
+        dict_attack->view,
+        DictAttackViewModel * model,
+        { model->dict_keys_total = dict_keys_total; },
+        true);
 }
 
 void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tried) {
     furi_assert(dict_attack);
     with_view_model(
-        dict_attack->view, (DictAttackViewModel * model) {
+        dict_attack->view,
+        DictAttackViewModel * model,
+        {
             if(model->dict_keys_current + keys_tried < model->dict_keys_total) {
                 model->dict_keys_current += keys_tried;
             }
-            return true;
-        });
+        },
+        true);
 }
diff --git a/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c b/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
index 35abbddc1..0341990d8 100644
--- a/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
+++ b/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
@@ -149,7 +149,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
 
         FURI_LOG_T(
             TAG,
-            "RSSI: avg %f, max %f at %u, min %f",
+            "RSSI: avg %f, max %f at %lu, min %f",
             (double)(rssi_avg / rssi_avg_samples),
             (double)frequency_rssi.rssi_coarse,
             frequency_rssi.frequency_coarse,
@@ -180,7 +180,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
 
                     rssi = furi_hal_subghz_get_rssi();
 
-                    FURI_LOG_T(TAG, "#:%u:%f", frequency, (double)rssi);
+                    FURI_LOG_T(TAG, "#:%lu:%f", frequency, (double)rssi);
 
                     if(frequency_rssi.rssi_fine < rssi) {
                         frequency_rssi.rssi_fine = rssi;
@@ -193,7 +193,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
         // Deliver results fine
         if(frequency_rssi.rssi_fine > SUBGHZ_FREQUENCY_ANALYZER_THRESHOLD) {
             FURI_LOG_D(
-                TAG, "=:%u:%f", frequency_rssi.frequency_fine, (double)frequency_rssi.rssi_fine);
+                TAG, "=:%lu:%f", frequency_rssi.frequency_fine, (double)frequency_rssi.rssi_fine);
 
             instance->sample_hold_counter = 20;
             rssi_temp = frequency_rssi.rssi_fine;
@@ -217,7 +217,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
             (instance->sample_hold_counter < 10)) {
             FURI_LOG_D(
                 TAG,
-                "~:%u:%f",
+                "~:%lu:%f",
                 frequency_rssi.frequency_coarse,
                 (double)frequency_rssi.rssi_coarse);
 
diff --git a/applications/main/subghz/subghz_cli.c b/applications/main/subghz/subghz_cli.c
index c6e196fb6..a1474885e 100644
--- a/applications/main/subghz/subghz_cli.c
+++ b/applications/main/subghz/subghz_cli.c
@@ -2,7 +2,6 @@
 
 #include <furi.h>
 #include <furi_hal.h>
-#include <stream_buffer.h>
 
 #include <lib/toolbox/args.h>
 #include <lib/subghz/subghz_keystore.h>
@@ -152,8 +151,8 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
         "Protocol: Princeton\n"
         "Bit: 24\n"
         "Key: 00 00 00 00 00 %02X %02X %02X\n"
-        "TE: %d\n"
-        "Repeat: %d\n",
+        "TE: %ld\n"
+        "Repeat: %ld\n",
         (uint8_t)((key >> 16) & 0xFF),
         (uint8_t)((key >> 8) & 0xFF),
         (uint8_t)(key & 0xFF),
@@ -194,23 +193,21 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
 
 typedef struct {
     volatile bool overrun;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
     size_t packet_count;
 } SubGhzCliCommandRx;
 
 static void subghz_cli_command_rx_capture_callback(bool level, uint32_t duration, void* context) {
     SubGhzCliCommandRx* instance = context;
 
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     LevelDuration level_duration = level_duration_make(level, duration);
     if(instance->overrun) {
         instance->overrun = false;
         level_duration = level_duration_reset();
     }
-    size_t ret = xStreamBufferSendFromISR(
-        instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
+    size_t ret =
+        furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
     if(sizeof(LevelDuration) != ret) instance->overrun = true;
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
 }
 
 static void subghz_cli_command_rx_callback(
@@ -249,7 +246,8 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
 
     // Allocate context and buffers
     SubGhzCliCommandRx* instance = malloc(sizeof(SubGhzCliCommandRx));
-    instance->stream = xStreamBufferCreate(sizeof(LevelDuration) * 1024, sizeof(LevelDuration));
+    instance->stream =
+        furi_stream_buffer_alloc(sizeof(LevelDuration) * 1024, sizeof(LevelDuration));
     furi_check(instance->stream);
 
     SubGhzEnvironment* environment = subghz_environment_alloc();
@@ -279,8 +277,8 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
     printf("Listening at %lu. Press CTRL+C to stop\r\n", frequency);
     LevelDuration level_duration;
     while(!cli_cmd_interrupt_received(cli)) {
-        int ret =
-            xStreamBufferReceive(instance->stream, &level_duration, sizeof(LevelDuration), 10);
+        int ret = furi_stream_buffer_receive(
+            instance->stream, &level_duration, sizeof(LevelDuration), 10);
         if(ret == sizeof(LevelDuration)) {
             if(level_duration_is_reset(level_duration)) {
                 printf(".");
@@ -304,7 +302,7 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
     // Cleanup
     subghz_receiver_free(receiver);
     subghz_environment_free(environment);
-    vStreamBufferDelete(instance->stream);
+    furi_stream_buffer_free(instance->stream);
     free(instance);
 }
 
@@ -796,7 +794,7 @@ static bool subghz_on_system_start_istream_decode_band(
 
     FURI_LOG_I(
         "SubGhzOnStart",
-        "Add allowed band: start %dHz, stop %dHz, power_limit %ddBm, duty_cycle %d%%",
+        "Add allowed band: start %ldHz, stop %ldHz, power_limit %ddBm, duty_cycle %d%%",
         band.start,
         band.end,
         band.power_limit,
diff --git a/applications/main/subghz/subghz_i.c b/applications/main/subghz/subghz_i.c
index f2658c0e4..acf07bc14 100644
--- a/applications/main/subghz/subghz_i.c
+++ b/applications/main/subghz/subghz_i.c
@@ -60,7 +60,7 @@ void subghz_get_frequency_modulation(SubGhz* subghz, FuriString* frequency, Furi
             subghz->txrx->preset->frequency / 10000 % 100);
     }
     if(modulation != NULL) {
-        furi_string_printf(modulation, "%0.2s", furi_string_get_cstr(subghz->txrx->preset->name));
+        furi_string_printf(modulation, "%2s", furi_string_get_cstr(subghz->txrx->preset->name));
     }
 }
 
diff --git a/applications/main/subghz/views/receiver.c b/applications/main/subghz/views/receiver.c
index 6ec12e781..cdebc6320 100644
--- a/applications/main/subghz/views/receiver.c
+++ b/applications/main/subghz/views/receiver.c
@@ -67,17 +67,17 @@ void subghz_view_receiver_set_lock(SubGhzViewReceiver* subghz_receiver, SubGhzLo
     if(lock == SubGhzLockOn) {
         subghz_receiver->lock = lock;
         with_view_model(
-            subghz_receiver->view, (SubGhzViewReceiverModel * model) {
-                model->bar_show = SubGhzViewReceiverBarShowLock;
-                return true;
-            });
+            subghz_receiver->view,
+            SubGhzViewReceiverModel * model,
+            { model->bar_show = SubGhzViewReceiverBarShowLock; },
+            true);
         furi_timer_start(subghz_receiver->timer, pdMS_TO_TICKS(1000));
     } else {
         with_view_model(
-            subghz_receiver->view, (SubGhzViewReceiverModel * model) {
-                model->bar_show = SubGhzViewReceiverBarShowDefault;
-                return true;
-            });
+            subghz_receiver->view,
+            SubGhzViewReceiverModel * model,
+            { model->bar_show = SubGhzViewReceiverBarShowDefault; },
+            true);
     }
 }
 
@@ -95,7 +95,9 @@ static void subghz_view_receiver_update_offset(SubGhzViewReceiver* subghz_receiv
     furi_assert(subghz_receiver);
 
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             size_t history_item = model->history_item;
             uint16_t bounds = history_item > 3 ? 2 : history_item;
 
@@ -107,8 +109,8 @@ static void subghz_view_receiver_update_offset(SubGhzViewReceiver* subghz_receiv
             } else if(model->list_offset > model->idx - bounds) {
                 model->list_offset = CLAMP(model->idx - 1, (int16_t)(history_item - bounds), 0);
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_view_receiver_add_item_to_menu(
@@ -117,7 +119,9 @@ void subghz_view_receiver_add_item_to_menu(
     uint8_t type) {
     furi_assert(subghz_receiver);
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             SubGhzReceiverMenuItem* item_menu =
                 SubGhzReceiverMenuItemArray_push_raw(model->history->data);
             item_menu->item_str = furi_string_alloc_set(name);
@@ -128,9 +132,8 @@ void subghz_view_receiver_add_item_to_menu(
             } else {
                 model->history_item++;
             }
-
-            return true;
-        });
+        },
+        true);
     subghz_view_receiver_update_offset(subghz_receiver);
 }
 
@@ -141,12 +144,14 @@ void subghz_view_receiver_add_data_statusbar(
     const char* history_stat_str) {
     furi_assert(subghz_receiver);
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             furi_string_set(model->frequency_str, frequency_str);
             furi_string_set(model->preset_str, preset_str);
             furi_string_set(model->history_stat_str, history_stat_str);
-            return true;
-        });
+        },
+        true);
 }
 
 static void subghz_view_receiver_draw_frame(Canvas* canvas, uint16_t idx, bool scrollbar) {
@@ -240,10 +245,10 @@ static void subghz_view_receiver_timer_callback(void* context) {
     furi_assert(context);
     SubGhzViewReceiver* subghz_receiver = context;
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
-            model->bar_show = SubGhzViewReceiverBarShowDefault;
-            return true;
-        });
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        { model->bar_show = SubGhzViewReceiverBarShowDefault; },
+        true);
     if(subghz_receiver->lock_count < UNLOCK_CNT) {
         subghz_receiver->callback(
             SubGhzCustomEventViewReceiverOffDisplay, subghz_receiver->context);
@@ -260,10 +265,10 @@ bool subghz_view_receiver_input(InputEvent* event, void* context) {
 
     if(subghz_receiver->lock == SubGhzLockOn) {
         with_view_model(
-            subghz_receiver->view, (SubGhzViewReceiverModel * model) {
-                model->bar_show = SubGhzViewReceiverBarShowToUnlockPress;
-                return true;
-            });
+            subghz_receiver->view,
+            SubGhzViewReceiverModel * model,
+            { model->bar_show = SubGhzViewReceiverBarShowToUnlockPress; },
+            true);
         if(subghz_receiver->lock_count == 0) {
             furi_timer_start(subghz_receiver->timer, pdMS_TO_TICKS(1000));
         }
@@ -274,10 +279,10 @@ bool subghz_view_receiver_input(InputEvent* event, void* context) {
             // subghz_receiver->callback(
             //     SubGhzCustomEventViewReceiverUnlock, subghz_receiver->context);
             with_view_model(
-                subghz_receiver->view, (SubGhzViewReceiverModel * model) {
-                    model->bar_show = SubGhzViewReceiverBarShowUnlock;
-                    return true;
-                });
+                subghz_receiver->view,
+                SubGhzViewReceiverModel * model,
+                { model->bar_show = SubGhzViewReceiverBarShowUnlock; },
+                true);
             //subghz_receiver->lock = SubGhzLockOff;
             furi_timer_start(subghz_receiver->timer, pdMS_TO_TICKS(650));
         }
@@ -291,29 +296,35 @@ bool subghz_view_receiver_input(InputEvent* event, void* context) {
         event->key == InputKeyUp &&
         (event->type == InputTypeShort || event->type == InputTypeRepeat)) {
         with_view_model(
-            subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+            subghz_receiver->view,
+            SubGhzViewReceiverModel * model,
+            {
                 if(model->idx != 0) model->idx--;
-                return true;
-            });
+            },
+            true);
     } else if(
         event->key == InputKeyDown &&
         (event->type == InputTypeShort || event->type == InputTypeRepeat)) {
         with_view_model(
-            subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+            subghz_receiver->view,
+            SubGhzViewReceiverModel * model,
+            {
                 if(model->idx != model->history_item - 1) model->idx++;
-                return true;
-            });
+            },
+            true);
     } else if(event->key == InputKeyLeft && event->type == InputTypeShort) {
         subghz_receiver->callback(SubGhzCustomEventViewReceiverConfig, subghz_receiver->context);
     } else if(event->key == InputKeyOk && event->type == InputTypeShort) {
         with_view_model(
-            subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+            subghz_receiver->view,
+            SubGhzViewReceiverModel * model,
+            {
                 if(model->history_item != 0) {
                     subghz_receiver->callback(
                         SubGhzCustomEventViewReceiverOK, subghz_receiver->context);
                 }
-                return false;
-            });
+            },
+            false);
     }
 
     subghz_view_receiver_update_offset(subghz_receiver);
@@ -329,7 +340,9 @@ void subghz_view_receiver_exit(void* context) {
     furi_assert(context);
     SubGhzViewReceiver* subghz_receiver = context;
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             furi_string_reset(model->frequency_str);
             furi_string_reset(model->preset_str);
             furi_string_reset(model->history_stat_str);
@@ -342,8 +355,8 @@ void subghz_view_receiver_exit(void* context) {
                 model->idx = 0;
                 model->list_offset = 0;
                 model->history_item = 0;
-                return false;
-        });
+        },
+        false);
     furi_timer_stop(subghz_receiver->timer);
 }
 
@@ -364,15 +377,17 @@ SubGhzViewReceiver* subghz_view_receiver_alloc() {
     view_set_exit_callback(subghz_receiver->view, subghz_view_receiver_exit);
 
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             model->frequency_str = furi_string_alloc();
             model->preset_str = furi_string_alloc();
             model->history_stat_str = furi_string_alloc();
             model->bar_show = SubGhzViewReceiverBarShowDefault;
             model->history = malloc(sizeof(SubGhzReceiverHistory));
             SubGhzReceiverMenuItemArray_init(model->history->data);
-            return true;
-        });
+        },
+        true);
     subghz_receiver->timer =
         furi_timer_alloc(subghz_view_receiver_timer_callback, FuriTimerTypeOnce, subghz_receiver);
     return subghz_receiver;
@@ -382,7 +397,9 @@ void subghz_view_receiver_free(SubGhzViewReceiver* subghz_receiver) {
     furi_assert(subghz_receiver);
 
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             furi_string_free(model->frequency_str);
             furi_string_free(model->preset_str);
             furi_string_free(model->history_stat_str);
@@ -393,8 +410,8 @@ void subghz_view_receiver_free(SubGhzViewReceiver* subghz_receiver) {
                     }
                 SubGhzReceiverMenuItemArray_clear(model->history->data);
                 free(model->history);
-                return false;
-        });
+        },
+        false);
     furi_timer_free(subghz_receiver->timer);
     view_free(subghz_receiver->view);
     free(subghz_receiver);
@@ -409,20 +426,19 @@ uint16_t subghz_view_receiver_get_idx_menu(SubGhzViewReceiver* subghz_receiver)
     furi_assert(subghz_receiver);
     uint32_t idx = 0;
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
-            idx = model->idx;
-            return false;
-        });
+        subghz_receiver->view, SubGhzViewReceiverModel * model, { idx = model->idx; }, false);
     return idx;
 }
 
 void subghz_view_receiver_set_idx_menu(SubGhzViewReceiver* subghz_receiver, uint16_t idx) {
     furi_assert(subghz_receiver);
     with_view_model(
-        subghz_receiver->view, (SubGhzViewReceiverModel * model) {
+        subghz_receiver->view,
+        SubGhzViewReceiverModel * model,
+        {
             model->idx = idx;
             if(model->idx > 2) model->list_offset = idx - 2;
-            return true;
-        });
+        },
+        true);
     subghz_view_receiver_update_offset(subghz_receiver);
 }
diff --git a/applications/main/subghz/views/subghz_frequency_analyzer.c b/applications/main/subghz/views/subghz_frequency_analyzer.c
index 608cf5862..c169f3611 100644
--- a/applications/main/subghz/views/subghz_frequency_analyzer.c
+++ b/applications/main/subghz/views/subghz_frequency_analyzer.c
@@ -132,12 +132,14 @@ void subghz_frequency_analyzer_pair_callback(
         }
         //update history
         with_view_model(
-            instance->view, (SubGhzFrequencyAnalyzerModel * model) {
+            instance->view,
+            SubGhzFrequencyAnalyzerModel * model,
+            {
                 model->history_frequency[2] = model->history_frequency[1];
                 model->history_frequency[1] = model->history_frequency[0];
                 model->history_frequency[0] = model->frequency;
-                return false;
-            });
+            },
+            false);
     } else if((rssi != 0.f) && (!instance->locked)) {
         if(instance->callback) {
             instance->callback(SubGhzCustomEventSceneAnalyzerLock, instance->context);
@@ -146,12 +148,14 @@ void subghz_frequency_analyzer_pair_callback(
 
     instance->locked = (rssi != 0.f);
     with_view_model(
-        instance->view, (SubGhzFrequencyAnalyzerModel * model) {
+        instance->view,
+        SubGhzFrequencyAnalyzerModel * model,
+        {
             model->rssi = rssi;
             model->frequency = frequency;
             model->signal = signal;
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_frequency_analyzer_enter(void* context) {
@@ -169,14 +173,16 @@ void subghz_frequency_analyzer_enter(void* context) {
     subghz_frequency_analyzer_worker_start(instance->worker);
 
     with_view_model(
-        instance->view, (SubGhzFrequencyAnalyzerModel * model) {
+        instance->view,
+        SubGhzFrequencyAnalyzerModel * model,
+        {
             model->rssi = 0;
             model->frequency = 0;
             model->history_frequency[2] = 0;
             model->history_frequency[1] = 0;
             model->history_frequency[0] = 0;
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_frequency_analyzer_exit(void* context) {
@@ -190,10 +196,7 @@ void subghz_frequency_analyzer_exit(void* context) {
     subghz_frequency_analyzer_worker_free(instance->worker);
 
     with_view_model(
-        instance->view, (SubGhzFrequencyAnalyzerModel * model) {
-            model->rssi = 0;
-            return true;
-        });
+        instance->view, SubGhzFrequencyAnalyzerModel * model, { model->rssi = 0; }, true);
 }
 
 SubGhzFrequencyAnalyzer* subghz_frequency_analyzer_alloc() {
@@ -210,10 +213,7 @@ SubGhzFrequencyAnalyzer* subghz_frequency_analyzer_alloc() {
     view_set_exit_callback(instance->view, subghz_frequency_analyzer_exit);
 
     with_view_model(
-        instance->view, (SubGhzFrequencyAnalyzerModel * model) {
-            model->rssi = 0;
-            return true;
-        });
+        instance->view, SubGhzFrequencyAnalyzerModel * model, { model->rssi = 0; }, true);
 
     return instance;
 }
diff --git a/applications/main/subghz/views/subghz_read_raw.c b/applications/main/subghz/views/subghz_read_raw.c
index 0b4305b7e..2d951b11a 100644
--- a/applications/main/subghz/views/subghz_read_raw.c
+++ b/applications/main/subghz/views/subghz_read_raw.c
@@ -45,11 +45,13 @@ void subghz_read_raw_add_data_statusbar(
     const char* preset_str) {
     furi_assert(instance);
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             furi_string_set(model->frequency_str, frequency_str);
             furi_string_set(model->preset_str, preset_str);
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_read_raw_add_data_rssi(SubGhzReadRAW* instance, float rssi) {
@@ -63,31 +65,35 @@ void subghz_read_raw_add_data_rssi(SubGhzReadRAW* instance, float rssi) {
     }
 
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             model->rssi_history[model->ind_write++] = u_rssi;
             if(model->ind_write > SUBGHZ_READ_RAW_RSSI_HISTORY_SIZE) {
                 model->rssi_history_end = true;
                 model->ind_write = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_read_raw_update_sample_write(SubGhzReadRAW* instance, size_t sample) {
     furi_assert(instance);
 
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
-            furi_string_printf(model->sample_write, "%d spl.", sample);
-            return false;
-        });
+        instance->view,
+        SubGhzReadRAWModel * model,
+        { furi_string_printf(model->sample_write, "%d spl.", sample); },
+        false);
 }
 
 void subghz_read_raw_stop_send(SubGhzReadRAW* instance) {
     furi_assert(instance);
 
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             switch(model->status) {
             case SubGhzReadRAWStatusTXRepeat:
             case SubGhzReadRAWStatusLoadKeyTXRepeat:
@@ -105,19 +111,21 @@ void subghz_read_raw_stop_send(SubGhzReadRAW* instance) {
                 model->status = SubGhzReadRAWStatusIDLE;
                 break;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_read_raw_update_sin(SubGhzReadRAW* instance) {
     furi_assert(instance);
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             if(model->ind_sin++ > 62) {
                 model->ind_sin = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static int8_t subghz_read_raw_tab_sin(uint8_t x) {
@@ -286,9 +294,11 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
         //further check of events is not needed, we exit
         return false;
     } else if(event->key == InputKeyOk && event->type == InputTypePress) {
+        uint8_t ret = false;
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
-                uint8_t ret = false;
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 switch(model->status) {
                 case SubGhzReadRAWStatusIDLE:
                     // Start TX
@@ -314,11 +324,13 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                 default:
                     break;
                 }
-                return ret;
-            });
+            },
+            ret);
     } else if(event->key == InputKeyOk && event->type == InputTypeRelease) {
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 if(model->status == SubGhzReadRAWStatusTXRepeat) {
                     // Stop repeat TX
                     model->status = SubGhzReadRAWStatusTX;
@@ -326,11 +338,13 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                     // Stop repeat TX
                     model->status = SubGhzReadRAWStatusLoadKeyTX;
                 }
-                return false;
-            });
+            },
+            false);
     } else if(event->key == InputKeyBack && event->type == InputTypeShort) {
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 switch(model->status) {
                 case SubGhzReadRAWStatusREC:
                     //Stop REC
@@ -357,11 +371,13 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                     instance->callback(SubGhzCustomEventViewReadRAWBack, instance->context);
                     break;
                 }
-                return true;
-            });
+            },
+            true);
     } else if(event->key == InputKeyLeft && event->type == InputTypeShort) {
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 if(model->status == SubGhzReadRAWStatusStart) {
                     //Config
                     instance->callback(SubGhzCustomEventViewReadRAWConfig, instance->context);
@@ -376,11 +392,13 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                     furi_string_reset(model->file_name);
                     instance->callback(SubGhzCustomEventViewReadRAWErase, instance->context);
                 }
-                return true;
-            });
+            },
+            true);
     } else if(event->key == InputKeyRight && event->type == InputTypeShort) {
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 if(model->status == SubGhzReadRAWStatusIDLE) {
                     //Save
                     instance->callback(SubGhzCustomEventViewReadRAWSave, instance->context);
@@ -388,11 +406,13 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                     //More
                     instance->callback(SubGhzCustomEventViewReadRAWMore, instance->context);
                 }
-                return true;
-            });
+            },
+            true);
     } else if(event->key == InputKeyOk && event->type == InputTypeShort) {
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 if(model->status == SubGhzReadRAWStatusStart) {
                     //Record
                     instance->callback(SubGhzCustomEventViewReadRAWREC, instance->context);
@@ -404,8 +424,8 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                     instance->callback(SubGhzCustomEventViewReadRAWIDLE, instance->context);
                     model->status = SubGhzReadRAWStatusIDLE;
                 }
-                return true;
-            });
+            },
+            true);
     }
     return true;
 }
@@ -419,36 +439,42 @@ void subghz_read_raw_set_status(
     switch(status) {
     case SubGhzReadRAWStatusStart:
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 model->status = SubGhzReadRAWStatusStart;
                 model->rssi_history_end = false;
                 model->ind_write = 0;
                 furi_string_reset(model->file_name);
                 furi_string_set(model->sample_write, "0 spl.");
-                return true;
-            });
+            },
+            true);
         break;
     case SubGhzReadRAWStatusIDLE:
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
-                model->status = SubGhzReadRAWStatusIDLE;
-                return true;
-            });
+            instance->view,
+            SubGhzReadRAWModel * model,
+            { model->status = SubGhzReadRAWStatusIDLE; },
+            true);
         break;
     case SubGhzReadRAWStatusLoadKeyTX:
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 model->status = SubGhzReadRAWStatusLoadKeyIDLE;
                 model->rssi_history_end = false;
                 model->ind_write = 0;
                 furi_string_set(model->file_name, file_name);
                 furi_string_set(model->sample_write, "RAW");
-                return true;
-            });
+            },
+            true);
         break;
     case SubGhzReadRAWStatusSaveKey:
         with_view_model(
-            instance->view, (SubGhzReadRAWModel * model) {
+            instance->view,
+            SubGhzReadRAWModel * model,
+            {
                 model->status = SubGhzReadRAWStatusLoadKeyIDLE;
                 if(!model->ind_write) {
                     furi_string_set(model->file_name, file_name);
@@ -456,8 +482,8 @@ void subghz_read_raw_set_status(
                 } else {
                     furi_string_reset(model->file_name);
                 }
-                return true;
-            });
+            },
+            true);
         break;
 
     default:
@@ -476,15 +502,17 @@ void subghz_read_raw_exit(void* context) {
     SubGhzReadRAW* instance = context;
 
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             if(model->status != SubGhzReadRAWStatusIDLE &&
                model->status != SubGhzReadRAWStatusStart &&
                model->status != SubGhzReadRAWStatusLoadKeyIDLE) {
                 instance->callback(SubGhzCustomEventViewReadRAWIDLE, instance->context);
                 model->status = SubGhzReadRAWStatusStart;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 SubGhzReadRAW* subghz_read_raw_alloc() {
@@ -500,14 +528,16 @@ SubGhzReadRAW* subghz_read_raw_alloc() {
     view_set_exit_callback(instance->view, subghz_read_raw_exit);
 
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             model->frequency_str = furi_string_alloc();
             model->preset_str = furi_string_alloc();
             model->sample_write = furi_string_alloc();
             model->file_name = furi_string_alloc();
             model->rssi_history = malloc(SUBGHZ_READ_RAW_RSSI_HISTORY_SIZE * sizeof(uint8_t));
-            return true;
-        });
+        },
+        true);
 
     return instance;
 }
@@ -516,14 +546,16 @@ void subghz_read_raw_free(SubGhzReadRAW* instance) {
     furi_assert(instance);
 
     with_view_model(
-        instance->view, (SubGhzReadRAWModel * model) {
+        instance->view,
+        SubGhzReadRAWModel * model,
+        {
             furi_string_free(model->frequency_str);
             furi_string_free(model->preset_str);
             furi_string_free(model->sample_write);
             furi_string_free(model->file_name);
             free(model->rssi_history);
-            return true;
-        });
+        },
+        true);
     view_free(instance->view);
     free(instance);
 }
diff --git a/applications/main/subghz/views/subghz_test_carrier.c b/applications/main/subghz/views/subghz_test_carrier.c
index 6729eaad8..e533a6aac 100644
--- a/applications/main/subghz/views/subghz_test_carrier.c
+++ b/applications/main/subghz/views/subghz_test_carrier.c
@@ -89,7 +89,9 @@ bool subghz_test_carrier_input(InputEvent* event, void* context) {
     }
 
     with_view_model(
-        subghz_test_carrier->view, (SubGhzTestCarrierModel * model) {
+        subghz_test_carrier->view,
+        SubGhzTestCarrierModel * model,
+        {
             furi_hal_subghz_idle();
 
             if(event->key == InputKeyLeft) {
@@ -125,9 +127,8 @@ bool subghz_test_carrier_input(InputEvent* event, void* context) {
                         SubGhzTestCarrierEventOnlyRx, subghz_test_carrier->context);
                 }
             }
-
-            return true;
-        });
+        },
+        true);
 
     return true;
 }
@@ -142,15 +143,17 @@ void subghz_test_carrier_enter(void* context) {
     furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
 
     with_view_model(
-        subghz_test_carrier->view, (SubGhzTestCarrierModel * model) {
+        subghz_test_carrier->view,
+        SubGhzTestCarrierModel * model,
+        {
             model->frequency = subghz_frequencies_433_92_testing; // 433
             model->real_frequency =
                 furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
             model->path = FuriHalSubGhzPathIsolate; // isolate
             model->rssi = 0.0f;
             model->status = SubGhzTestCarrierModelStatusRx;
-            return true;
-        });
+        },
+        true);
 
     furi_hal_subghz_rx();
 
@@ -172,13 +175,14 @@ void subghz_test_carrier_rssi_timer_callback(void* context) {
     SubGhzTestCarrier* subghz_test_carrier = context;
 
     with_view_model(
-        subghz_test_carrier->view, (SubGhzTestCarrierModel * model) {
+        subghz_test_carrier->view,
+        SubGhzTestCarrierModel * model,
+        {
             if(model->status == SubGhzTestCarrierModelStatusRx) {
                 model->rssi = furi_hal_subghz_get_rssi();
-                return true;
             }
-            return false;
-        });
+        },
+        false);
 }
 
 SubGhzTestCarrier* subghz_test_carrier_alloc() {
diff --git a/applications/main/subghz/views/subghz_test_packet.c b/applications/main/subghz/views/subghz_test_packet.c
index c83aebec9..a42898f77 100644
--- a/applications/main/subghz/views/subghz_test_packet.c
+++ b/applications/main/subghz/views/subghz_test_packet.c
@@ -68,7 +68,9 @@ static void subghz_test_packet_rssi_timer_callback(void* context) {
     SubGhzTestPacket* instance = context;
 
     with_view_model(
-        instance->view, (SubGhzTestPacketModel * model) {
+        instance->view,
+        SubGhzTestPacketModel * model,
+        {
             if(model->status == SubGhzTestPacketModelStatusRx) {
                 model->rssi = furi_hal_subghz_get_rssi();
                 model->packets = instance->packet_rx;
@@ -77,8 +79,8 @@ static void subghz_test_packet_rssi_timer_callback(void* context) {
                     SUBGHZ_TEST_PACKET_COUNT -
                     subghz_encoder_princeton_for_testing_get_repeat_left(instance->encoder);
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void subghz_test_packet_draw(Canvas* canvas, SubGhzTestPacketModel* model) {
@@ -137,7 +139,9 @@ static bool subghz_test_packet_input(InputEvent* event, void* context) {
     }
 
     with_view_model(
-        instance->view, (SubGhzTestPacketModel * model) {
+        instance->view,
+        SubGhzTestPacketModel * model,
+        {
             if(model->status == SubGhzTestPacketModelStatusRx) {
                 furi_hal_subghz_stop_async_rx();
             } else if(model->status == SubGhzTestPacketModelStatusTx) {
@@ -179,9 +183,8 @@ static bool subghz_test_packet_input(InputEvent* event, void* context) {
                     instance->callback(SubGhzTestPacketEventOnlyRx, instance->context);
                 }
             }
-
-            return true;
-        });
+        },
+        true);
 
     return true;
 }
@@ -194,15 +197,17 @@ void subghz_test_packet_enter(void* context) {
     furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);
 
     with_view_model(
-        instance->view, (SubGhzTestPacketModel * model) {
+        instance->view,
+        SubGhzTestPacketModel * model,
+        {
             model->frequency = subghz_frequencies_433_92_testing;
             model->real_frequency =
                 furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
             model->path = FuriHalSubGhzPathIsolate; // isolate
             model->rssi = 0.0f;
             model->status = SubGhzTestPacketModelStatusRx;
-            return true;
-        });
+        },
+        true);
 
     furi_hal_subghz_start_async_rx(subghz_test_packet_rx_callback, instance);
 
@@ -217,15 +222,17 @@ void subghz_test_packet_exit(void* context) {
 
     // Reinitialize IC to default state
     with_view_model(
-        instance->view, (SubGhzTestPacketModel * model) {
+        instance->view,
+        SubGhzTestPacketModel * model,
+        {
             if(model->status == SubGhzTestPacketModelStatusRx) {
                 furi_hal_subghz_stop_async_rx();
             } else if(model->status == SubGhzTestPacketModelStatusTx) {
                 subghz_encoder_princeton_for_testing_stop(instance->encoder, furi_get_tick());
                 furi_hal_subghz_stop_async_tx();
             }
-            return true;
-        });
+        },
+        true);
     furi_hal_subghz_sleep();
 }
 
diff --git a/applications/main/subghz/views/subghz_test_static.c b/applications/main/subghz/views/subghz_test_static.c
index 7af54c3c0..6abefda76 100644
--- a/applications/main/subghz/views/subghz_test_static.c
+++ b/applications/main/subghz/views/subghz_test_static.c
@@ -77,7 +77,9 @@ bool subghz_test_static_input(InputEvent* event, void* context) {
     }
 
     with_view_model(
-        instance->view, (SubGhzTestStaticModel * model) {
+        instance->view,
+        SubGhzTestStaticModel * model,
+        {
             if(event->type == InputTypeShort) {
                 if(event->key == InputKeyLeft) {
                     if(model->frequency > 0) model->frequency--;
@@ -128,9 +130,8 @@ bool subghz_test_static_input(InputEvent* event, void* context) {
                 }
                 furi_record_close(RECORD_NOTIFICATION);
             }
-
-            return true;
-        });
+        },
+        true);
 
     return true;
 }
@@ -147,13 +148,14 @@ void subghz_test_static_enter(void* context) {
     instance->status_tx = SubGhzTestStaticStatusIDLE;
 
     with_view_model(
-        instance->view, (SubGhzTestStaticModel * model) {
+        instance->view,
+        SubGhzTestStaticModel * model,
+        {
             model->frequency = subghz_frequencies_433_92_testing;
             model->real_frequency = subghz_frequencies_testing[model->frequency];
             model->button = 0;
-
-            return true;
-        });
+        },
+        true);
 }
 
 void subghz_test_static_exit(void* context) {
diff --git a/applications/main/subghz/views/transmitter.c b/applications/main/subghz/views/transmitter.c
index 1094c5c58..833805ccb 100644
--- a/applications/main/subghz/views/transmitter.c
+++ b/applications/main/subghz/views/transmitter.c
@@ -35,13 +35,15 @@ void subghz_view_transmitter_add_data_to_show(
     uint8_t show_button) {
     furi_assert(subghz_transmitter);
     with_view_model(
-        subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
+        subghz_transmitter->view,
+        SubGhzViewTransmitterModel * model,
+        {
             furi_string_set(model->key_str, key_str);
             furi_string_set(model->frequency_str, frequency_str);
             furi_string_set(model->preset_str, preset_str);
             model->show_button = show_button;
-            return true;
-        });
+        },
+        true);
 }
 
 static void subghz_view_transmitter_button_right(Canvas* canvas, const char* str) {
@@ -95,23 +97,27 @@ bool subghz_view_transmitter_input(InputEvent* event, void* context) {
 
     if(event->key == InputKeyBack && event->type == InputTypeShort) {
         with_view_model(
-            subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
+            subghz_transmitter->view,
+            SubGhzViewTransmitterModel * model,
+            {
                 furi_string_reset(model->frequency_str);
                 furi_string_reset(model->preset_str);
                 furi_string_reset(model->key_str);
                 model->show_button = 0;
-                return false;
-            });
+            },
+            false);
         return false;
     }
 
     with_view_model(
-        subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
+        subghz_transmitter->view,
+        SubGhzViewTransmitterModel * model,
+        {
             if(model->show_button) {
                 can_be_sent = true;
             }
-            return true;
-        });
+        },
+        true);
 
     if(can_be_sent && event->key == InputKeyOk && event->type == InputTypePress) {
         subghz_transmitter->callback(
@@ -149,12 +155,14 @@ SubGhzViewTransmitter* subghz_view_transmitter_alloc() {
     view_set_exit_callback(subghz_transmitter->view, subghz_view_transmitter_exit);
 
     with_view_model(
-        subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
+        subghz_transmitter->view,
+        SubGhzViewTransmitterModel * model,
+        {
             model->frequency_str = furi_string_alloc();
             model->preset_str = furi_string_alloc();
             model->key_str = furi_string_alloc();
-            return true;
-        });
+        },
+        true);
     return subghz_transmitter;
 }
 
@@ -162,12 +170,14 @@ void subghz_view_transmitter_free(SubGhzViewTransmitter* subghz_transmitter) {
     furi_assert(subghz_transmitter);
 
     with_view_model(
-        subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
+        subghz_transmitter->view,
+        SubGhzViewTransmitterModel * model,
+        {
             furi_string_free(model->frequency_str);
             furi_string_free(model->preset_str);
             furi_string_free(model->key_str);
-            return true;
-        });
+        },
+        true);
     view_free(subghz_transmitter->view);
     free(subghz_transmitter);
 }
diff --git a/applications/main/u2f/views/u2f_view.c b/applications/main/u2f/views/u2f_view.c
index 11e2c9b04..fa3d6cc24 100644
--- a/applications/main/u2f/views/u2f_view.c
+++ b/applications/main/u2f/views/u2f_view.c
@@ -85,18 +85,17 @@ void u2f_view_set_ok_callback(U2fView* u2f, U2fOkCallback callback, void* contex
     furi_assert(u2f);
     furi_assert(callback);
     with_view_model(
-        u2f->view, (U2fModel * model) {
+        u2f->view,
+        U2fModel * model,
+        {
             UNUSED(model);
             u2f->callback = callback;
             u2f->context = context;
-            return false;
-        });
+        },
+        false);
 }
 
 void u2f_view_set_state(U2fView* u2f, U2fViewMsg msg) {
     with_view_model(
-        u2f->view, (U2fModel * model) {
-            model->display_msg = msg;
-            return true;
-        });
+        u2f->view, U2fModel * model, { model->display_msg = msg; }, true);
 }
diff --git a/applications/plugins/bt_hid_app/views/bt_hid_keyboard.c b/applications/plugins/bt_hid_app/views/bt_hid_keyboard.c
index 8b9ae593a..2c65f6ab1 100644
--- a/applications/plugins/bt_hid_app/views/bt_hid_keyboard.c
+++ b/applications/plugins/bt_hid_app/views/bt_hid_keyboard.c
@@ -277,7 +277,9 @@ static void bt_hid_keyboard_get_select_key(BtHidKeyboardModel* model, BtHidKeybo
 
 static void bt_hid_keyboard_process(BtHidKeyboard* bt_hid_keyboard, InputEvent* event) {
     with_view_model(
-        bt_hid_keyboard->view, (BtHidKeyboardModel * model) {
+        bt_hid_keyboard->view,
+        BtHidKeyboardModel * model,
+        {
             if(event->key == InputKeyOk) {
                 if(event->type == InputTypePress) {
                     model->ok_pressed = true;
@@ -338,8 +340,8 @@ static void bt_hid_keyboard_process(BtHidKeyboard* bt_hid_keyboard, InputEvent*
                     bt_hid_keyboard_get_select_key(model, (BtHidKeyboardPoint){.x = 1, .y = 0});
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static bool bt_hid_keyboard_input_callback(InputEvent* event, void* context) {
@@ -382,8 +384,5 @@ View* bt_hid_keyboard_get_view(BtHidKeyboard* bt_hid_keyboard) {
 void bt_hid_keyboard_set_connected_status(BtHidKeyboard* bt_hid_keyboard, bool connected) {
     furi_assert(bt_hid_keyboard);
     with_view_model(
-        bt_hid_keyboard->view, (BtHidKeyboardModel * model) {
-            model->connected = connected;
-            return true;
-        });
+        bt_hid_keyboard->view, BtHidKeyboardModel * model, { model->connected = connected; }, true);
 }
diff --git a/applications/plugins/bt_hid_app/views/bt_hid_keynote.c b/applications/plugins/bt_hid_app/views/bt_hid_keynote.c
index ea4ee16fa..db88b8000 100644
--- a/applications/plugins/bt_hid_app/views/bt_hid_keynote.c
+++ b/applications/plugins/bt_hid_app/views/bt_hid_keynote.c
@@ -106,7 +106,9 @@ static void bt_hid_keynote_draw_callback(Canvas* canvas, void* context) {
 
 static void bt_hid_keynote_process(BtHidKeynote* bt_hid_keynote, InputEvent* event) {
     with_view_model(
-        bt_hid_keynote->view, (BtHidKeynoteModel * model) {
+        bt_hid_keynote->view,
+        BtHidKeynoteModel * model,
+        {
             if(event->type == InputTypePress) {
                 if(event->key == InputKeyUp) {
                     model->up_pressed = true;
@@ -153,8 +155,8 @@ static void bt_hid_keynote_process(BtHidKeynote* bt_hid_keynote, InputEvent* eve
                     furi_hal_bt_hid_consumer_key_release(HID_CONSUMER_AC_BACK);
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static bool bt_hid_keynote_input_callback(InputEvent* event, void* context) {
@@ -197,8 +199,5 @@ View* bt_hid_keynote_get_view(BtHidKeynote* bt_hid_keynote) {
 void bt_hid_keynote_set_connected_status(BtHidKeynote* bt_hid_keynote, bool connected) {
     furi_assert(bt_hid_keynote);
     with_view_model(
-        bt_hid_keynote->view, (BtHidKeynoteModel * model) {
-            model->connected = connected;
-            return true;
-        });
+        bt_hid_keynote->view, BtHidKeynoteModel * model, { model->connected = connected; }, true);
 }
diff --git a/applications/plugins/bt_hid_app/views/bt_hid_media.c b/applications/plugins/bt_hid_app/views/bt_hid_media.c
index 258ea0a40..181cd347b 100644
--- a/applications/plugins/bt_hid_app/views/bt_hid_media.c
+++ b/applications/plugins/bt_hid_app/views/bt_hid_media.c
@@ -107,7 +107,9 @@ static void bt_hid_media_draw_callback(Canvas* canvas, void* context) {
 
 static void bt_hid_media_process_press(BtHidMedia* bt_hid_media, InputEvent* event) {
     with_view_model(
-        bt_hid_media->view, (BtHidMediaModel * model) {
+        bt_hid_media->view,
+        BtHidMediaModel * model,
+        {
             if(event->key == InputKeyUp) {
                 model->up_pressed = true;
                 furi_hal_bt_hid_consumer_key_press(HID_CONSUMER_VOLUME_INCREMENT);
@@ -124,13 +126,15 @@ static void bt_hid_media_process_press(BtHidMedia* bt_hid_media, InputEvent* eve
                 model->ok_pressed = true;
                 furi_hal_bt_hid_consumer_key_press(HID_CONSUMER_PLAY_PAUSE);
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void bt_hid_media_process_release(BtHidMedia* bt_hid_media, InputEvent* event) {
     with_view_model(
-        bt_hid_media->view, (BtHidMediaModel * model) {
+        bt_hid_media->view,
+        BtHidMediaModel * model,
+        {
             if(event->key == InputKeyUp) {
                 model->up_pressed = false;
                 furi_hal_bt_hid_consumer_key_release(HID_CONSUMER_VOLUME_INCREMENT);
@@ -147,8 +151,8 @@ static void bt_hid_media_process_release(BtHidMedia* bt_hid_media, InputEvent* e
                 model->ok_pressed = false;
                 furi_hal_bt_hid_consumer_key_release(HID_CONSUMER_PLAY_PAUSE);
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static bool bt_hid_media_input_callback(InputEvent* event, void* context) {
@@ -196,8 +200,5 @@ View* bt_hid_media_get_view(BtHidMedia* bt_hid_media) {
 void bt_hid_media_set_connected_status(BtHidMedia* bt_hid_media, bool connected) {
     furi_assert(bt_hid_media);
     with_view_model(
-        bt_hid_media->view, (BtHidMediaModel * model) {
-            model->connected = connected;
-            return true;
-        });
+        bt_hid_media->view, BtHidMediaModel * model, { model->connected = connected; }, true);
 }
diff --git a/applications/plugins/bt_hid_app/views/bt_hid_mouse.c b/applications/plugins/bt_hid_app/views/bt_hid_mouse.c
index 395cb52c9..098adb732 100644
--- a/applications/plugins/bt_hid_app/views/bt_hid_mouse.c
+++ b/applications/plugins/bt_hid_app/views/bt_hid_mouse.c
@@ -103,7 +103,9 @@ static void bt_hid_mouse_draw_callback(Canvas* canvas, void* context) {
 
 static void bt_hid_mouse_process(BtHidMouse* bt_hid_mouse, InputEvent* event) {
     with_view_model(
-        bt_hid_mouse->view, (BtHidMouseModel * model) {
+        bt_hid_mouse->view,
+        BtHidMouseModel * model,
+        {
             if(event->key == InputKeyBack) {
                 if(event->type == InputTypeShort) {
                     furi_hal_bt_hid_mouse_press(HID_MOUSE_BTN_RIGHT);
@@ -167,8 +169,8 @@ static void bt_hid_mouse_process(BtHidMouse* bt_hid_mouse, InputEvent* event) {
                     model->up_pressed = false;
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static bool bt_hid_mouse_input_callback(InputEvent* event, void* context) {
@@ -211,8 +213,5 @@ View* bt_hid_mouse_get_view(BtHidMouse* bt_hid_mouse) {
 void bt_hid_mouse_set_connected_status(BtHidMouse* bt_hid_mouse, bool connected) {
     furi_assert(bt_hid_mouse);
     with_view_model(
-        bt_hid_mouse->view, (BtHidMouseModel * model) {
-            model->connected = connected;
-            return true;
-        });
+        bt_hid_mouse->view, BtHidMouseModel * model, { model->connected = connected; }, true);
 }
diff --git a/applications/plugins/music_player/music_player.c b/applications/plugins/music_player/music_player.c
index 6d3c4483e..192500c2e 100644
--- a/applications/plugins/music_player/music_player.c
+++ b/applications/plugins/music_player/music_player.c
@@ -248,12 +248,16 @@ static void music_player_worker_callback(
     view_port_update(music_player->view_port);
 }
 
+void music_player_clear(MusicPlayer* instance) {
+    memset(instance->model->duration_history, 0xff, MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
+    memset(instance->model->semitone_history, 0xff, MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
+    music_player_worker_clear(instance->worker);
+}
+
 MusicPlayer* music_player_alloc() {
     MusicPlayer* instance = malloc(sizeof(MusicPlayer));
 
     instance->model = malloc(sizeof(MusicPlayerModel));
-    memset(instance->model->duration_history, 0xff, MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
-    memset(instance->model->semitone_history, 0xff, MUSIC_PLAYER_SEMITONE_HISTORY_SIZE);
     instance->model->volume = 3;
 
     instance->model_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
@@ -265,6 +269,8 @@ MusicPlayer* music_player_alloc() {
         instance->worker, MUSIC_PLAYER_VOLUMES[instance->model->volume]);
     music_player_worker_set_callback(instance->worker, music_player_worker_callback, instance);
 
+    music_player_clear(instance);
+
     instance->view_port = view_port_alloc();
     view_port_draw_callback_set(instance->view_port, render_callback, instance);
     view_port_input_callback_set(instance->view_port, input_callback, instance);
@@ -299,7 +305,7 @@ int32_t music_player_app(void* p) {
 
     do {
         if(p && strlen(p)) {
-            furi_string_cat(file_path, (const char*)p);
+            furi_string_set(file_path, (const char*)p);
         } else {
             furi_string_set(file_path, MUSIC_PLAYER_APP_PATH_FOLDER);
 
@@ -350,7 +356,9 @@ int32_t music_player_app(void* p) {
         }
 
         music_player_worker_stop(music_player->worker);
-    } while(0);
+        if(p && strlen(p)) break; // Exit instead of going to browser if launched with arg
+        music_player_clear(music_player);
+    } while(1);
 
     furi_string_free(file_path);
     music_player_free(music_player);
diff --git a/applications/plugins/music_player/music_player_worker.c b/applications/plugins/music_player/music_player_worker.c
index af09f0535..3f1ac62f7 100644
--- a/applications/plugins/music_player/music_player_worker.c
+++ b/applications/plugins/music_player/music_player_worker.c
@@ -108,6 +108,10 @@ MusicPlayerWorker* music_player_worker_alloc() {
     return instance;
 }
 
+void music_player_worker_clear(MusicPlayerWorker* instance) {
+    NoteBlockArray_reset(instance->notes);
+}
+
 void music_player_worker_free(MusicPlayerWorker* instance) {
     furi_assert(instance);
     furi_thread_free(instance->thread);
@@ -129,6 +133,7 @@ static bool is_space(const char c) {
 
 static size_t extract_number(const char* string, uint32_t* number) {
     size_t ret = 0;
+    *number = 0;
     while(is_digit(*string)) {
         *number *= 10;
         *number += (*string - '0');
@@ -140,6 +145,7 @@ static size_t extract_number(const char* string, uint32_t* number) {
 
 static size_t extract_dots(const char* string, uint32_t* number) {
     size_t ret = 0;
+    *number = 0;
     while(*string == '.') {
         *number += 1;
         string++;
@@ -258,7 +264,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             if(!is_valid) {
                 FURI_LOG_E(
                     TAG,
-                    "Invalid note: %u%c%c%u.%u",
+                    "Invalid note: %lu%c%c%lu.%lu",
                     duration,
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
@@ -281,7 +287,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             if(music_player_worker_add_note(instance, semitone, duration, dots)) {
                 FURI_LOG_D(
                     TAG,
-                    "Added note: %c%c%u.%u = %u %u",
+                    "Added note: %c%c%lu.%lu = %u %lu",
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
                     octave,
@@ -291,7 +297,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
             } else {
                 FURI_LOG_E(
                     TAG,
-                    "Invalid note: %c%c%u.%u = %u %u",
+                    "Invalid note: %c%c%lu.%lu = %u %lu",
                     note_char == '\0' ? '_' : note_char,
                     sharp_char == '\0' ? '_' : sharp_char,
                     octave,
diff --git a/applications/plugins/music_player/music_player_worker.h b/applications/plugins/music_player/music_player_worker.h
index 3aa99ea37..00320b11f 100644
--- a/applications/plugins/music_player/music_player_worker.h
+++ b/applications/plugins/music_player/music_player_worker.h
@@ -14,6 +14,8 @@ typedef struct MusicPlayerWorker MusicPlayerWorker;
 
 MusicPlayerWorker* music_player_worker_alloc();
 
+void music_player_worker_clear(MusicPlayerWorker* instance);
+
 void music_player_worker_free(MusicPlayerWorker* instance);
 
 bool music_player_worker_load(MusicPlayerWorker* instance, const char* file_path);
diff --git a/applications/plugins/signal_generator/scenes/signal_gen_scene_mco.c b/applications/plugins/signal_generator/scenes/signal_gen_scene_mco.c
index 632b08c75..0855cde0a 100644
--- a/applications/plugins/signal_generator/scenes/signal_gen_scene_mco.c
+++ b/applications/plugins/signal_generator/scenes/signal_gen_scene_mco.c
@@ -1,12 +1,17 @@
 #include "../signal_gen_app_i.h"
 
 typedef enum {
+    LineIndexPin,
     LineIndexSource,
     LineIndexDivision,
 } LineIndex;
 
+static const char* const mco_pin_names[] = {
+    "13(Tx)",
+};
+
 static const char* const mco_source_names[] = {
-    "32768",
+    "32768Hz",
     "64MHz",
     "~100K",
     "~200K",
@@ -81,14 +86,22 @@ void signal_gen_scene_mco_on_enter(void* context) {
 
     VariableItem* item;
 
+    item = variable_item_list_add(var_item_list, "GPIO Pin", COUNT_OF(mco_pin_names), NULL, NULL);
+    variable_item_set_current_value_index(item, 0);
+    variable_item_set_current_value_text(item, mco_pin_names[0]);
+
     item = variable_item_list_add(
-        var_item_list, "Source", COUNT_OF(mco_source_names), mco_source_list_change_callback, app);
+        var_item_list,
+        "Frequency",
+        COUNT_OF(mco_source_names),
+        mco_source_list_change_callback,
+        app);
     variable_item_set_current_value_index(item, 0);
     variable_item_set_current_value_text(item, mco_source_names[0]);
 
     item = variable_item_list_add(
         var_item_list,
-        "Division",
+        "Freq. divider",
         COUNT_OF(mco_divisor_names),
         mco_divisor_list_change_callback,
         app);
diff --git a/applications/plugins/signal_generator/scenes/signal_gen_scene_start.c b/applications/plugins/signal_generator/scenes/signal_gen_scene_start.c
index 91f6081d8..3c7b9cc32 100644
--- a/applications/plugins/signal_generator/scenes/signal_gen_scene_start.c
+++ b/applications/plugins/signal_generator/scenes/signal_gen_scene_start.c
@@ -16,10 +16,10 @@ void signal_gen_scene_start_on_enter(void* context) {
     Submenu* submenu = app->submenu;
 
     submenu_add_item(
-        submenu, "PWM", SubmenuIndexPwm, signal_gen_scene_start_submenu_callback, app);
+        submenu, "PWM Generator", SubmenuIndexPwm, signal_gen_scene_start_submenu_callback, app);
     submenu_add_item(
         submenu,
-        "Clock Output",
+        "Clock Generator",
         SubmenuIndexClockOutput,
         signal_gen_scene_start_submenu_callback,
         app);
diff --git a/applications/plugins/signal_generator/views/signal_gen_pwm.c b/applications/plugins/signal_generator/views/signal_gen_pwm.c
index 00b4ef267..6d1a3c1ba 100644
--- a/applications/plugins/signal_generator/views/signal_gen_pwm.c
+++ b/applications/plugins/signal_generator/views/signal_gen_pwm.c
@@ -9,7 +9,7 @@ typedef enum {
     LineIndexTotalCount
 } LineIndex;
 
-static const char* const pwm_ch_names[] = {"TIM1(2)", "LPTIM2(4)"};
+static const char* const pwm_ch_names[] = {"2(A7)", "4(A4)"};
 
 struct SignalGenPwm {
     View* view;
@@ -31,8 +31,8 @@ typedef struct {
 #define ITEM_H 64 / 3
 #define ITEM_W 128
 
-#define VALUE_X 95
-#define VALUE_W 55
+#define VALUE_X 100
+#define VALUE_W 45
 
 #define FREQ_VALUE_X 62
 #define FREQ_MAX 1000000UL
@@ -44,12 +44,14 @@ static void pwm_set_config(SignalGenPwm* pwm) {
     uint8_t duty;
 
     with_view_model(
-        pwm->view, (SignalGenPwmViewModel * model) {
+        pwm->view,
+        SignalGenPwmViewModel * model,
+        {
             channel = model->channel_id;
             freq = model->freq;
             duty = model->duty;
-            return false;
-        });
+        },
+        false);
 
     furi_assert(pwm->callback);
     pwm->callback(channel, freq, duty, pwm->context);
@@ -126,11 +128,11 @@ static void signal_gen_pwm_draw_callback(Canvas* canvas, void* _model) {
 
     for(uint8_t line = 0; line < LineIndexTotalCount; line++) {
         if(line == LineIndexChannel) {
-            line_label = "PWM Channel";
+            line_label = "GPIO Pin";
         } else if(line == LineIndexFrequency) {
             line_label = "Frequency";
         } else if(line == LineIndexDuty) {
-            line_label = "Duty Cycle";
+            line_label = "Pulse width";
         }
 
         canvas_set_color(canvas, ColorBlack);
@@ -162,9 +164,9 @@ static void signal_gen_pwm_draw_callback(Canvas* canvas, void* _model) {
             canvas_set_font(canvas, FontSecondary);
 
             if(model->edit_mode) {
-                uint8_t icon_x = (FREQ_VALUE_X - 1) + (FREQ_DIGITS_NB - model->edit_digit - 1) * 6;
-                canvas_draw_icon(canvas, icon_x, text_y - 9, &I_SmallArrowUp_4x7);
-                canvas_draw_icon(canvas, icon_x, text_y + 4, &I_SmallArrowDown_4x7);
+                uint8_t icon_x = (FREQ_VALUE_X) + (FREQ_DIGITS_NB - model->edit_digit - 1) * 6;
+                canvas_draw_icon(canvas, icon_x, text_y - 9, &I_SmallArrowUp_3x5);
+                canvas_draw_icon(canvas, icon_x, text_y + 5, &I_SmallArrowDown_3x5);
             }
         } else if(line == LineIndexDuty) {
             snprintf(val_text, sizeof(val_text), "%d%%", model->duty);
@@ -188,7 +190,9 @@ static bool signal_gen_pwm_input_callback(InputEvent* event, void* context) {
     bool need_update = false;
 
     with_view_model(
-        pwm->view, (SignalGenPwmViewModel * model) {
+        pwm->view,
+        SignalGenPwmViewModel * model,
+        {
             if(model->edit_mode == false) {
                 if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
                     if(event->key == InputKeyUp) {
@@ -238,8 +242,8 @@ static bool signal_gen_pwm_input_callback(InputEvent* event, void* context) {
                     }
                 }
             }
-            return true;
-        });
+        },
+        true);
 
     if(need_update) {
         pwm_set_config(pwm);
@@ -279,22 +283,26 @@ void signal_gen_pwm_set_callback(
     furi_assert(callback);
 
     with_view_model(
-        pwm->view, (SignalGenPwmViewModel * model) {
+        pwm->view,
+        SignalGenPwmViewModel * model,
+        {
             UNUSED(model);
             pwm->callback = callback;
             pwm->context = context;
-            return false;
-        });
+        },
+        false);
 }
 
 void signal_gen_pwm_set_params(SignalGenPwm* pwm, uint8_t channel_id, uint32_t freq, uint8_t duty) {
     with_view_model(
-        pwm->view, (SignalGenPwmViewModel * model) {
+        pwm->view,
+        SignalGenPwmViewModel * model,
+        {
             model->channel_id = channel_id;
             model->freq = freq;
             model->duty = duty;
-            return true;
-        });
+        },
+        true);
 
     furi_assert(pwm->callback);
     pwm->callback(channel_id, freq, duty, pwm->context);
diff --git a/applications/plugins/snake_game/snake_game.c b/applications/plugins/snake_game/snake_game.c
index b7aabb17c..0b665a943 100644
--- a/applications/plugins/snake_game/snake_game.c
+++ b/applications/plugins/snake_game/snake_game.c
@@ -2,6 +2,8 @@
 #include <gui/gui.h>
 #include <input/input.h>
 #include <stdlib.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
 
 typedef struct {
     //    +-----x
@@ -59,6 +61,35 @@ typedef struct {
     InputEvent input;
 } SnakeEvent;
 
+const NotificationSequence sequence_fail = {
+    &message_vibro_on,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_vibro_off,
+    NULL,
+};
+
+const NotificationSequence sequence_eat = {
+    &message_note_c7,
+    &message_delay_50,
+    &message_sound_off,
+    NULL,
+};
+
 static void snake_game_render_callback(Canvas* const canvas, void* ctx) {
     const SnakeState* snake_state = acquire_mutex((ValueMutex*)ctx, 25);
     if(snake_state == NULL) {
@@ -230,7 +261,8 @@ static void snake_game_move_snake(SnakeState* const snake_state, Point const nex
     snake_state->points[0] = next_step;
 }
 
-static void snake_game_process_game_step(SnakeState* const snake_state) {
+static void
+    snake_game_process_game_step(SnakeState* const snake_state, NotificationApp* notification) {
     if(snake_state->state == GameStateGameOver) {
         return;
     }
@@ -249,6 +281,7 @@ static void snake_game_process_game_step(SnakeState* const snake_state) {
             return;
         } else if(snake_state->state == GameStateLastChance) {
             snake_state->state = GameStateGameOver;
+            notification_message_block(notification, &sequence_fail);
             return;
         }
     } else {
@@ -260,6 +293,7 @@ static void snake_game_process_game_step(SnakeState* const snake_state) {
     crush = snake_game_collision_with_tail(snake_state, next_step);
     if(crush) {
         snake_state->state = GameStateGameOver;
+        notification_message_block(notification, &sequence_fail);
         return;
     }
 
@@ -268,6 +302,7 @@ static void snake_game_process_game_step(SnakeState* const snake_state) {
         snake_state->len++;
         if(snake_state->len >= MAX_SNAKE_LEN) {
             snake_state->state = GameStateGameOver;
+            notification_message_block(notification, &sequence_fail);
             return;
         }
     }
@@ -276,6 +311,7 @@ static void snake_game_process_game_step(SnakeState* const snake_state) {
 
     if(eatFruit) {
         snake_state->fruit = snake_game_get_new_fruit(snake_state);
+        notification_message(notification, &sequence_eat);
     }
 }
 
@@ -306,6 +342,9 @@ int32_t snake_game_app(void* p) {
     // Open GUI and register view_port
     Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+    NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
+
+    notification_message_block(notification, &sequence_display_backlight_enforce_on);
 
     SnakeEvent event;
     for(bool processing = true; processing;) {
@@ -341,7 +380,7 @@ int32_t snake_game_app(void* p) {
                     }
                 }
             } else if(event.type == EventTypeTick) {
-                snake_game_process_game_step(snake_state);
+                snake_game_process_game_step(snake_state, notification);
             }
         } else {
             // event timeout
@@ -351,10 +390,14 @@ int32_t snake_game_app(void* p) {
         release_mutex(&state_mutex, snake_state);
     }
 
+    // Wait for all notifications to be played and return backlight to normal state
+    notification_message_block(notification, &sequence_display_backlight_enforce_auto);
+
     furi_timer_free(timer);
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
     furi_record_close(RECORD_GUI);
+    furi_record_close(RECORD_NOTIFICATION);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
     delete_mutex(&state_mutex);
diff --git a/applications/services/bt/bt_service/bt.c b/applications/services/bt/bt_service/bt.c
index 2bb083f27..aeb2beec9 100644
--- a/applications/services/bt/bt_service/bt.c
+++ b/applications/services/bt/bt_service/bt.c
@@ -77,7 +77,7 @@ static bool bt_pin_code_verify_event_handler(Bt* bt, uint32_t pin) {
     notification_message(bt->notification, &sequence_display_backlight_on);
     FuriString* pin_str;
     dialog_message_set_icon(bt->dialog_message, &I_BLE_Pairing_128x64, 0, 0);
-    pin_str = furi_string_alloc_printf("Verify code\n%06d", pin);
+    pin_str = furi_string_alloc_printf("Verify code\n%06ld", pin);
     dialog_message_set_text(
         bt->dialog_message, furi_string_get_cstr(pin_str), 64, 4, AlignCenter, AlignTop);
     dialog_message_set_buttons(bt->dialog_message, "Cancel", "OK", NULL);
@@ -277,7 +277,7 @@ static bool bt_on_gap_event_callback(GapEvent event, void* context) {
 static void bt_on_key_storage_change_callback(uint8_t* addr, uint16_t size, void* context) {
     furi_assert(context);
     Bt* bt = context;
-    FURI_LOG_I(TAG, "Changed addr start: %08lX, size changed: %d", addr, size);
+    FURI_LOG_I(TAG, "Changed addr start: %p, size changed: %d", addr, size);
     BtMessage message = {.type = BtMessageTypeKeysStorageUpdated};
     furi_check(
         furi_message_queue_put(bt->message_queue, &message, FuriWaitForever) == FuriStatusOk);
diff --git a/applications/services/cli/cli_commands.c b/applications/services/cli/cli_commands.c
index cee2ca98c..239434b7a 100644
--- a/applications/services/cli/cli_commands.c
+++ b/applications/services/cli/cli_commands.c
@@ -7,7 +7,6 @@
 #include <time.h>
 #include <notification/notification_messages.h>
 #include <loader/loader.h>
-#include <stream_buffer.h>
 
 // Close to ISO, `date +'%Y-%m-%d %H:%M:%S %u'`
 #define CLI_DATE_FORMAT "%.4d-%.2d-%.2d %.2d:%.2d:%.2d %d"
@@ -140,7 +139,7 @@ void cli_command_date(Cli* cli, FuriString* args, void* context) {
 #define CLI_COMMAND_LOG_BUFFER_SIZE 64
 
 void cli_command_log_tx_callback(const uint8_t* buffer, size_t size, void* context) {
-    xStreamBufferSend(context, buffer, size, 0);
+    furi_stream_buffer_send(context, buffer, size, 0);
 }
 
 void cli_command_log_level_set_from_string(FuriString* level) {
@@ -165,7 +164,7 @@ void cli_command_log_level_set_from_string(FuriString* level) {
 
 void cli_command_log(Cli* cli, FuriString* args, void* context) {
     UNUSED(context);
-    StreamBufferHandle_t ring = xStreamBufferCreate(CLI_COMMAND_LOG_RING_SIZE, 1);
+    FuriStreamBuffer* ring = furi_stream_buffer_alloc(CLI_COMMAND_LOG_RING_SIZE, 1);
     uint8_t buffer[CLI_COMMAND_LOG_BUFFER_SIZE];
     FuriLogLevel previous_level = furi_log_get_level();
     bool restore_log_level = false;
@@ -179,7 +178,7 @@ void cli_command_log(Cli* cli, FuriString* args, void* context) {
 
     printf("Press CTRL+C to stop...\r\n");
     while(!cli_cmd_interrupt_received(cli)) {
-        size_t ret = xStreamBufferReceive(ring, buffer, CLI_COMMAND_LOG_BUFFER_SIZE, 50);
+        size_t ret = furi_stream_buffer_receive(ring, buffer, CLI_COMMAND_LOG_BUFFER_SIZE, 50);
         cli_write(cli, buffer, ret);
     }
 
@@ -190,7 +189,7 @@ void cli_command_log(Cli* cli, FuriString* args, void* context) {
         furi_log_set_level(previous_level);
     }
 
-    vStreamBufferDelete(ring);
+    furi_stream_buffer_free(ring);
 }
 
 void cli_command_vibro(Cli* cli, FuriString* args, void* context) {
diff --git a/applications/services/cli/cli_vcp.c b/applications/services/cli/cli_vcp.c
index f2893a48b..1e27e185b 100644
--- a/applications/services/cli/cli_vcp.c
+++ b/applications/services/cli/cli_vcp.c
@@ -1,7 +1,6 @@
 #include <furi_hal_usb_cdc.h>
 #include <furi_hal.h>
 #include <furi.h>
-#include <stream_buffer.h>
 #include "cli_i.h"
 
 #define TAG "CliVcp"
@@ -29,8 +28,8 @@ typedef enum {
 typedef struct {
     FuriThread* thread;
 
-    StreamBufferHandle_t tx_stream;
-    StreamBufferHandle_t rx_stream;
+    FuriStreamBuffer* tx_stream;
+    FuriStreamBuffer* rx_stream;
 
     volatile bool connected;
     volatile bool running;
@@ -62,8 +61,8 @@ static const uint8_t ascii_eot = 0x04;
 static void cli_vcp_init() {
     if(vcp == NULL) {
         vcp = malloc(sizeof(CliVcp));
-        vcp->tx_stream = xStreamBufferCreate(VCP_TX_BUF_SIZE, 1);
-        vcp->rx_stream = xStreamBufferCreate(VCP_RX_BUF_SIZE, 1);
+        vcp->tx_stream = furi_stream_buffer_alloc(VCP_TX_BUF_SIZE, 1);
+        vcp->rx_stream = furi_stream_buffer_alloc(VCP_RX_BUF_SIZE, 1);
     }
     furi_assert(vcp->thread == NULL);
 
@@ -113,7 +112,7 @@ static int32_t vcp_worker(void* context) {
 #endif
             if(vcp->connected == false) {
                 vcp->connected = true;
-                xStreamBufferSend(vcp->rx_stream, &ascii_soh, 1, FuriWaitForever);
+                furi_stream_buffer_send(vcp->rx_stream, &ascii_soh, 1, FuriWaitForever);
             }
         }
 
@@ -124,8 +123,8 @@ static int32_t vcp_worker(void* context) {
 #endif
             if(vcp->connected == true) {
                 vcp->connected = false;
-                xStreamBufferReceive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
-                xStreamBufferSend(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
+                furi_stream_buffer_receive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
+                furi_stream_buffer_send(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
             }
         }
 
@@ -134,7 +133,7 @@ static int32_t vcp_worker(void* context) {
 #ifdef CLI_VCP_DEBUG
             FURI_LOG_D(TAG, "StreamRx");
 #endif
-            if(xStreamBufferSpacesAvailable(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
+            if(furi_stream_buffer_spaces_available(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
                 flags |= VcpEvtRx;
                 missed_rx--;
             }
@@ -142,14 +141,15 @@ static int32_t vcp_worker(void* context) {
 
         // New data received
         if(flags & VcpEvtRx) {
-            if(xStreamBufferSpacesAvailable(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
+            if(furi_stream_buffer_spaces_available(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
                 int32_t len = furi_hal_cdc_receive(VCP_IF_NUM, vcp->data_buffer, USB_CDC_PKT_LEN);
 #ifdef CLI_VCP_DEBUG
                 FURI_LOG_D(TAG, "Rx %d", len);
 #endif
                 if(len > 0) {
                     furi_check(
-                        xStreamBufferSend(vcp->rx_stream, vcp->data_buffer, len, FuriWaitForever) ==
+                        furi_stream_buffer_send(
+                            vcp->rx_stream, vcp->data_buffer, len, FuriWaitForever) ==
                         (size_t)len);
                 }
             } else {
@@ -173,7 +173,7 @@ static int32_t vcp_worker(void* context) {
         // CDC write transfer done
         if(flags & VcpEvtTx) {
             size_t len =
-                xStreamBufferReceive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
+                furi_stream_buffer_receive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
 #ifdef CLI_VCP_DEBUG
             FURI_LOG_D(TAG, "Tx %d", len);
 #endif
@@ -202,8 +202,8 @@ static int32_t vcp_worker(void* context) {
                 furi_hal_usb_unlock();
                 furi_hal_usb_set_config(vcp->usb_if_prev, NULL);
             }
-            xStreamBufferReceive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
-            xStreamBufferSend(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
+            furi_stream_buffer_receive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
+            furi_stream_buffer_send(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
             break;
         }
     }
@@ -229,7 +229,7 @@ static size_t cli_vcp_rx(uint8_t* buffer, size_t size, uint32_t timeout) {
         size_t batch_size = size;
         if(batch_size > VCP_RX_BUF_SIZE) batch_size = VCP_RX_BUF_SIZE;
 
-        size_t len = xStreamBufferReceive(vcp->rx_stream, buffer, batch_size, timeout);
+        size_t len = furi_stream_buffer_receive(vcp->rx_stream, buffer, batch_size, timeout);
 #ifdef CLI_VCP_DEBUG
         FURI_LOG_D(TAG, "rx %u ", batch_size);
 #endif
@@ -262,7 +262,7 @@ static void cli_vcp_tx(const uint8_t* buffer, size_t size) {
         size_t batch_size = size;
         if(batch_size > USB_CDC_PKT_LEN) batch_size = USB_CDC_PKT_LEN;
 
-        xStreamBufferSend(vcp->tx_stream, buffer, batch_size, FuriWaitForever);
+        furi_stream_buffer_send(vcp->tx_stream, buffer, batch_size, FuriWaitForever);
         furi_thread_flags_set(furi_thread_get_id(vcp->thread), VcpEvtStreamTx);
 #ifdef CLI_VCP_DEBUG
         FURI_LOG_D(TAG, "tx %u", batch_size);
diff --git a/applications/services/desktop/animations/animation_storage.c b/applications/services/desktop/animations/animation_storage.c
index 922d7dc85..0727fd6ae 100644
--- a/applications/services/desktop/animations/animation_storage.c
+++ b/applications/services/desktop/animations/animation_storage.c
@@ -304,7 +304,7 @@ static bool animation_storage_load_frames(
         if(file_info.size > max_filesize) {
             FURI_LOG_E(
                 TAG,
-                "Filesize %d, max: %d (width %d, height %d)",
+                "Filesize %lld, max: %d (width %d, height %d)",
                 file_info.size,
                 max_filesize,
                 width,
@@ -329,7 +329,7 @@ static bool animation_storage_load_frames(
     if(!frames_ok) {
         FURI_LOG_E(
             TAG,
-            "Load \'%s\' failed, %dx%d, size: %d",
+            "Load \'%s\' failed, %dx%d, size: %lld",
             furi_string_get_cstr(filename),
             width,
             height,
diff --git a/applications/services/desktop/views/desktop_view_debug.c b/applications/services/desktop/views/desktop_view_debug.c
index c965432f1..f9c8aedc2 100644
--- a/applications/services/desktop/views/desktop_view_debug.c
+++ b/applications/services/desktop/views/desktop_view_debug.c
@@ -124,16 +124,17 @@ bool desktop_debug_input(InputEvent* event, void* context) {
 
     DesktopViewStatsScreens current = 0;
     with_view_model(
-        debug_view->view, (DesktopDebugViewModel * model) {
-
+        debug_view->view,
+        DesktopDebugViewModel * model,
+        {
 #ifdef SRV_DOLPHIN_STATE_DEBUG
             if((event->key == InputKeyDown) || (event->key == InputKeyUp)) {
                 model->screen = !model->screen;
             }
 #endif
             current = model->screen;
-            return true;
-        });
+        },
+        true);
 
     size_t count = (event->type == InputTypeRepeat) ? 10 : 1;
     if(current == DesktopViewStatsMeta) {
@@ -181,20 +182,19 @@ void desktop_debug_get_dolphin_data(DesktopDebugView* debug_view) {
     Dolphin* dolphin = furi_record_open(RECORD_DOLPHIN);
     DolphinStats stats = dolphin_stats(dolphin);
     with_view_model(
-        debug_view->view, (DesktopDebugViewModel * model) {
+        debug_view->view,
+        DesktopDebugViewModel * model,
+        {
             model->icounter = stats.icounter;
             model->butthurt = stats.butthurt;
             model->timestamp = stats.timestamp;
-            return true;
-        });
+        },
+        true);
 
     furi_record_close(RECORD_DOLPHIN);
 }
 
 void desktop_debug_reset_screen_idx(DesktopDebugView* debug_view) {
     with_view_model(
-        debug_view->view, (DesktopDebugViewModel * model) {
-            model->screen = 0;
-            return true;
-        });
+        debug_view->view, DesktopDebugViewModel * model, { model->screen = 0; }, true);
 }
diff --git a/applications/services/desktop/views/desktop_view_lock_menu.c b/applications/services/desktop/views/desktop_view_lock_menu.c
index 294191bf2..8cb8a7a12 100644
--- a/applications/services/desktop/views/desktop_view_lock_menu.c
+++ b/applications/services/desktop/views/desktop_view_lock_menu.c
@@ -24,27 +24,24 @@ void desktop_lock_menu_set_callback(
 
 void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set) {
     with_view_model(
-        lock_menu->view, (DesktopLockMenuViewModel * model) {
-            model->pin_is_set = pin_is_set;
-            return true;
-        });
+        lock_menu->view,
+        DesktopLockMenuViewModel * model,
+        { model->pin_is_set = pin_is_set; },
+        true);
 }
 
 void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode) {
     with_view_model(
-        lock_menu->view, (DesktopLockMenuViewModel * model) {
-            model->dummy_mode = dummy_mode;
-            return true;
-        });
+        lock_menu->view,
+        DesktopLockMenuViewModel * model,
+        { model->dummy_mode = dummy_mode; },
+        true);
 }
 
 void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx) {
     furi_assert(idx < DesktopLockMenuIndexTotalCount);
     with_view_model(
-        lock_menu->view, (DesktopLockMenuViewModel * model) {
-            model->idx = idx;
-            return true;
-        });
+        lock_menu->view, DesktopLockMenuViewModel * model, { model->idx = idx; }, true);
 }
 
 void desktop_lock_menu_draw_callback(Canvas* canvas, void* model) {
@@ -95,10 +92,12 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
     uint8_t idx = 0;
     bool consumed = false;
     bool dummy_mode = false;
+    bool update = false;
 
     with_view_model(
-        lock_menu->view, (DesktopLockMenuViewModel * model) {
-            bool ret = false;
+        lock_menu->view,
+        DesktopLockMenuViewModel * model,
+        {
             if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
                 if(event->key == InputKeyUp) {
                     if(model->idx == 0) {
@@ -106,7 +105,7 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
                     } else {
                         model->idx = CLAMP(model->idx - 1, DesktopLockMenuIndexTotalCount - 1, 0);
                     }
-                    ret = true;
+                    update = true;
                     consumed = true;
                 } else if(event->key == InputKeyDown) {
                     if(model->idx == DesktopLockMenuIndexTotalCount - 1) {
@@ -114,14 +113,14 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
                     } else {
                         model->idx = CLAMP(model->idx + 1, DesktopLockMenuIndexTotalCount - 1, 0);
                     }
-                    ret = true;
+                    update = true;
                     consumed = true;
                 }
             }
             idx = model->idx;
             dummy_mode = model->dummy_mode;
-            return ret;
-        });
+        },
+        update);
 
     if(event->key == InputKeyOk) {
         if((idx == DesktopLockMenuIndexLock) && (event->type == InputTypeShort)) {
diff --git a/applications/services/dolphin/helpers/dolphin_state.c b/applications/services/dolphin/helpers/dolphin_state.c
index 95e2f42f4..10cb85c28 100644
--- a/applications/services/dolphin/helpers/dolphin_state.c
+++ b/applications/services/dolphin/helpers/dolphin_state.c
@@ -171,7 +171,7 @@ void dolphin_state_on_deed(DolphinState* dolphin_state, DolphinDeed deed) {
 
     FURI_LOG_D(
         TAG,
-        "icounter %d, butthurt %d",
+        "icounter %ld, butthurt %ld",
         dolphin_state->data.icounter,
         dolphin_state->data.butthurt);
 }
diff --git a/applications/services/gui/gui.c b/applications/services/gui/gui.c
index 6b4b9a0a7..0535b32b8 100644
--- a/applications/services/gui/gui.c
+++ b/applications/services/gui/gui.c
@@ -260,7 +260,7 @@ void gui_input(Gui* gui, InputEvent* input_event) {
             "non-complementary input, discarding key: %s type: %s, sequence: %p",
             input_get_key_name(input_event->key),
             input_get_type_name(input_event->type),
-            input_event->sequence);
+            (void*)input_event->sequence);
         return;
     }
 
@@ -290,7 +290,7 @@ void gui_input(Gui* gui, InputEvent* input_event) {
             view_port,
             input_get_key_name(input_event->key),
             input_get_type_name(input_event->type),
-            input_event->sequence);
+            (void*)input_event->sequence);
         view_port_input(gui->ongoing_input_view_port, input_event);
     } else {
         FURI_LOG_D(
@@ -300,7 +300,7 @@ void gui_input(Gui* gui, InputEvent* input_event) {
             view_port,
             input_get_key_name(input_event->key),
             input_get_type_name(input_event->type),
-            input_event->sequence);
+            (void*)input_event->sequence);
     }
 
     gui_unlock(gui);
diff --git a/applications/services/gui/modules/button_menu.c b/applications/services/gui/modules/button_menu.c
index 1dce014d8..37a04326a 100644
--- a/applications/services/gui/modules/button_menu.c
+++ b/applications/services/gui/modules/button_menu.c
@@ -148,28 +148,32 @@ static void button_menu_process_up(ButtonMenu* button_menu) {
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             if(model->position > 0) {
                 model->position--;
             } else {
                 model->position = ButtonMenuItemArray_size(model->items) - 1;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void button_menu_process_down(ButtonMenu* button_menu) {
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             if(model->position < (ButtonMenuItemArray_size(model->items) - 1)) {
                 model->position++;
             } else {
                 model->position = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void button_menu_process_ok(ButtonMenu* button_menu, InputType type) {
@@ -178,12 +182,14 @@ static void button_menu_process_ok(ButtonMenu* button_menu, InputType type) {
     ButtonMenuItem* item = NULL;
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             if(model->position < (ButtonMenuItemArray_size(model->items))) {
                 item = ButtonMenuItemArray_get(model->items, model->position);
             }
-            return false;
-        });
+        },
+        false);
 
     if(item) {
         if(item->type == ButtonMenuItemTypeControl) {
@@ -248,22 +254,21 @@ void button_menu_reset(ButtonMenu* button_menu) {
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             ButtonMenuItemArray_reset(model->items);
             model->position = 0;
             model->header = NULL;
-            return true;
-        });
+        },
+        true);
 }
 
 void button_menu_set_header(ButtonMenu* button_menu, const char* header) {
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
-            model->header = header;
-            return true;
-        });
+        button_menu->view, ButtonMenuModel * model, { model->header = header; }, true);
 }
 
 ButtonMenuItem* button_menu_add_item(
@@ -278,15 +283,17 @@ ButtonMenuItem* button_menu_add_item(
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             item = ButtonMenuItemArray_push_new(model->items);
             item->label = label;
             item->index = index;
             item->type = type;
             item->callback = callback;
             item->callback_context = callback_context;
-            return true;
-        });
+        },
+        true);
 
     return item;
 }
@@ -301,12 +308,14 @@ ButtonMenu* button_menu_alloc(void) {
     view_set_input_callback(button_menu->view, button_menu_view_input_callback);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             ButtonMenuItemArray_init(model->items);
             model->position = 0;
             model->header = NULL;
-            return true;
-        });
+        },
+        true);
 
     button_menu->freeze_input = false;
     return button_menu;
@@ -316,10 +325,10 @@ void button_menu_free(ButtonMenu* button_menu) {
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
-            ButtonMenuItemArray_clear(model->items);
-            return true;
-        });
+        button_menu->view,
+        ButtonMenuModel * model,
+        { ButtonMenuItemArray_clear(model->items); },
+        true);
     view_free(button_menu->view);
     free(button_menu);
 }
@@ -328,7 +337,9 @@ void button_menu_set_selected_item(ButtonMenu* button_menu, uint32_t index) {
     furi_assert(button_menu);
 
     with_view_model(
-        button_menu->view, (ButtonMenuModel * model) {
+        button_menu->view,
+        ButtonMenuModel * model,
+        {
             uint8_t item_position = 0;
             ButtonMenuItemArray_it_t it;
             for(ButtonMenuItemArray_it(it, model->items); !ButtonMenuItemArray_end_p(it);
@@ -338,6 +349,6 @@ void button_menu_set_selected_item(ButtonMenu* button_menu, uint32_t index) {
                     break;
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
diff --git a/applications/services/gui/modules/button_panel.c b/applications/services/gui/modules/button_panel.c
index c823e4b18..47b6ed488 100644
--- a/applications/services/gui/modules/button_panel.c
+++ b/applications/services/gui/modules/button_panel.c
@@ -70,15 +70,17 @@ ButtonPanel* button_panel_alloc() {
     view_set_input_callback(button_panel->view, button_panel_view_input_callback);
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             model->reserve_x = 0;
             model->reserve_y = 0;
             model->selected_item_x = 0;
             model->selected_item_y = 0;
             ButtonMatrix_init(model->button_matrix);
             LabelList_init(model->labels);
-            return true;
-        });
+        },
+        true);
 
     return button_panel;
 }
@@ -88,7 +90,9 @@ void button_panel_reserve(ButtonPanel* button_panel, size_t reserve_x, size_t re
     furi_check(reserve_y > 0);
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             model->reserve_x = reserve_x;
             model->reserve_y = reserve_y;
             ButtonMatrix_reserve(model->button_matrix, model->reserve_y);
@@ -99,8 +103,8 @@ void button_panel_reserve(ButtonPanel* button_panel, size_t reserve_x, size_t re
                 // TODO: do we need to clear allocated memory of ptr-s to ButtonItem ??
             }
             LabelList_init(model->labels);
-            return true;
-        });
+        },
+        true);
 }
 
 void button_panel_free(ButtonPanel* button_panel) {
@@ -109,11 +113,13 @@ void button_panel_free(ButtonPanel* button_panel) {
     button_panel_reset(button_panel);
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             LabelList_clear(model->labels);
             ButtonMatrix_clear(model->button_matrix);
-            return true;
-        });
+        },
+        true);
 
     view_free(button_panel->view);
     free(button_panel);
@@ -123,7 +129,9 @@ void button_panel_reset(ButtonPanel* button_panel) {
     furi_assert(button_panel);
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             for(size_t x = 0; x < model->reserve_x; ++x) {
                 for(size_t y = 0; y < model->reserve_y; ++y) {
                     ButtonItem** button_item = button_panel_get_item(model, x, y);
@@ -137,8 +145,8 @@ void button_panel_reset(ButtonPanel* button_panel) {
             model->selected_item_y = 0;
             LabelList_reset(model->labels);
             ButtonMatrix_reset(model->button_matrix);
-            return true;
-        });
+        },
+        true);
 }
 
 static ButtonItem** button_panel_get_item(ButtonPanelModel* model, size_t x, size_t y) {
@@ -165,7 +173,9 @@ void button_panel_add_item(
     furi_assert(button_panel);
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             ButtonItem** button_item_ptr =
                 button_panel_get_item(model, matrix_place_x, matrix_place_y);
             furi_check(*button_item_ptr == NULL);
@@ -178,8 +188,8 @@ void button_panel_add_item(
             button_item->icon.name = icon_name;
             button_item->icon.name_selected = icon_name_selected;
             button_item->index = index;
-            return true;
-        });
+        },
+        true);
 }
 
 View* button_panel_get_view(ButtonPanel* button_panel) {
@@ -216,114 +226,123 @@ static void button_panel_view_draw_callback(Canvas* canvas, void* _model) {
 
 static void button_panel_process_down(ButtonPanel* button_panel) {
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             uint16_t new_selected_item_x = model->selected_item_x;
             uint16_t new_selected_item_y = model->selected_item_y;
             size_t i;
 
-            if(new_selected_item_y >= (model->reserve_y - 1)) return false;
+            if(new_selected_item_y < (model->reserve_y - 1)) {
+                ++new_selected_item_y;
 
-            ++new_selected_item_y;
-
-            for(i = 0; i < model->reserve_x; ++i) {
-                new_selected_item_x = (model->selected_item_x + i) % model->reserve_x;
-                if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
-                    break;
+                for(i = 0; i < model->reserve_x; ++i) {
+                    new_selected_item_x = (model->selected_item_x + i) % model->reserve_x;
+                    if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
+                        break;
+                    }
+                }
+                if(i != model->reserve_x) {
+                    model->selected_item_x = new_selected_item_x;
+                    model->selected_item_y = new_selected_item_y;
                 }
             }
-            if(i == model->reserve_x) return false;
-
-            model->selected_item_x = new_selected_item_x;
-            model->selected_item_y = new_selected_item_y;
-
-            return true;
-        });
+        },
+        true);
 }
 
 static void button_panel_process_up(ButtonPanel* button_panel) {
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             size_t new_selected_item_x = model->selected_item_x;
             size_t new_selected_item_y = model->selected_item_y;
             size_t i;
 
-            if(new_selected_item_y <= 0) return false;
+            if(new_selected_item_y > 0) {
+                --new_selected_item_y;
 
-            --new_selected_item_y;
-
-            for(i = 0; i < model->reserve_x; ++i) {
-                new_selected_item_x = (model->selected_item_x + i) % model->reserve_x;
-                if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
-                    break;
+                for(i = 0; i < model->reserve_x; ++i) {
+                    new_selected_item_x = (model->selected_item_x + i) % model->reserve_x;
+                    if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
+                        break;
+                    }
+                }
+                if(i != model->reserve_x) {
+                    model->selected_item_x = new_selected_item_x;
+                    model->selected_item_y = new_selected_item_y;
                 }
             }
-            if(i == model->reserve_x) return false;
-
-            model->selected_item_x = new_selected_item_x;
-            model->selected_item_y = new_selected_item_y;
-            return true;
-        });
+        },
+        true);
 }
 
 static void button_panel_process_left(ButtonPanel* button_panel) {
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             size_t new_selected_item_x = model->selected_item_x;
             size_t new_selected_item_y = model->selected_item_y;
             size_t i;
 
-            if(new_selected_item_x <= 0) return false;
+            if(new_selected_item_x > 0) {
+                --new_selected_item_x;
 
-            --new_selected_item_x;
-
-            for(i = 0; i < model->reserve_y; ++i) {
-                new_selected_item_y = (model->selected_item_y + i) % model->reserve_y;
-                if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
-                    break;
+                for(i = 0; i < model->reserve_y; ++i) {
+                    new_selected_item_y = (model->selected_item_y + i) % model->reserve_y;
+                    if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
+                        break;
+                    }
+                }
+                if(i != model->reserve_y) {
+                    model->selected_item_x = new_selected_item_x;
+                    model->selected_item_y = new_selected_item_y;
                 }
             }
-            if(i == model->reserve_y) return false;
-
-            model->selected_item_x = new_selected_item_x;
-            model->selected_item_y = new_selected_item_y;
-            return true;
-        });
+        },
+        true);
 }
 
 static void button_panel_process_right(ButtonPanel* button_panel) {
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             uint16_t new_selected_item_x = model->selected_item_x;
             uint16_t new_selected_item_y = model->selected_item_y;
             size_t i;
 
-            if(new_selected_item_x >= (model->reserve_x - 1)) return false;
+            if(new_selected_item_x < (model->reserve_x - 1)) {
+                ++new_selected_item_x;
 
-            ++new_selected_item_x;
-
-            for(i = 0; i < model->reserve_y; ++i) {
-                new_selected_item_y = (model->selected_item_y + i) % model->reserve_y;
-                if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
-                    break;
+                for(i = 0; i < model->reserve_y; ++i) {
+                    new_selected_item_y = (model->selected_item_y + i) % model->reserve_y;
+                    if(*button_panel_get_item(model, new_selected_item_x, new_selected_item_y)) {
+                        break;
+                    }
+                }
+                if(i != model->reserve_y) {
+                    model->selected_item_x = new_selected_item_x;
+                    model->selected_item_y = new_selected_item_y;
                 }
             }
-            if(i == model->reserve_y) return false;
-
-            model->selected_item_x = new_selected_item_x;
-            model->selected_item_y = new_selected_item_y;
-            return true;
-        });
+        },
+        true);
 }
 
 void button_panel_process_ok(ButtonPanel* button_panel) {
     ButtonItem* button_item = NULL;
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             button_item =
                 *button_panel_get_item(model, model->selected_item_x, model->selected_item_y);
-            return true;
-        });
+        },
+        true);
 
     if(button_item && button_item->callback) {
         button_item->callback(button_item->callback_context, button_item->index);
@@ -374,12 +393,14 @@ void button_panel_add_label(
     furi_assert(button_panel);
 
     with_view_model(
-        button_panel->view, (ButtonPanelModel * model) {
+        button_panel->view,
+        ButtonPanelModel * model,
+        {
             LabelElement* label = LabelList_push_raw(model->labels);
             label->x = x;
             label->y = y;
             label->font = font;
             label->str = label_str;
-            return true;
-        });
+        },
+        true);
 }
diff --git a/applications/services/gui/modules/byte_input.c b/applications/services/gui/modules/byte_input.c
index bb18a107a..8d7e7fd4f 100644
--- a/applications/services/gui/modules/byte_input.c
+++ b/applications/services/gui/modules/byte_input.c
@@ -618,42 +618,30 @@ static bool byte_input_view_input_callback(InputEvent* event, void* context) {
         switch(event->key) {
         case InputKeyLeft:
             with_view_model(
-                byte_input->view, (ByteInputModel * model) {
-                    byte_input_handle_left(model);
-                    return true;
-                });
+                byte_input->view, ByteInputModel * model, { byte_input_handle_left(model); }, true);
             consumed = true;
             break;
         case InputKeyRight:
             with_view_model(
-                byte_input->view, (ByteInputModel * model) {
-                    byte_input_handle_right(model);
-                    return true;
-                });
+                byte_input->view,
+                ByteInputModel * model,
+                { byte_input_handle_right(model); },
+                true);
             consumed = true;
             break;
         case InputKeyUp:
             with_view_model(
-                byte_input->view, (ByteInputModel * model) {
-                    byte_input_handle_up(model);
-                    return true;
-                });
+                byte_input->view, ByteInputModel * model, { byte_input_handle_up(model); }, true);
             consumed = true;
             break;
         case InputKeyDown:
             with_view_model(
-                byte_input->view, (ByteInputModel * model) {
-                    byte_input_handle_down(model);
-                    return true;
-                });
+                byte_input->view, ByteInputModel * model, { byte_input_handle_down(model); }, true);
             consumed = true;
             break;
         case InputKeyOk:
             with_view_model(
-                byte_input->view, (ByteInputModel * model) {
-                    byte_input_handle_ok(model);
-                    return true;
-                });
+                byte_input->view, ByteInputModel * model, { byte_input_handle_ok(model); }, true);
             consumed = true;
             break;
         default:
@@ -664,10 +652,10 @@ static bool byte_input_view_input_callback(InputEvent* event, void* context) {
     if((event->type == InputTypeLong || event->type == InputTypeRepeat) &&
        event->key == InputKeyBack) {
         with_view_model(
-            byte_input->view, (ByteInputModel * model) {
-                byte_input_clear_selected_byte(model);
-                return true;
-            });
+            byte_input->view,
+            ByteInputModel * model,
+            { byte_input_clear_selected_byte(model); },
+            true);
         consumed = true;
     }
 
@@ -703,14 +691,16 @@ ByteInput* byte_input_alloc() {
     view_set_input_callback(byte_input->view, byte_input_view_input_callback);
 
     with_view_model(
-        byte_input->view, (ByteInputModel * model) {
+        byte_input->view,
+        ByteInputModel * model,
+        {
             model->header = "";
             model->input_callback = NULL;
             model->changed_callback = NULL;
             model->callback_context = NULL;
             byte_input_reset_model_input_data(model);
-            return true;
-        });
+        },
+        true);
 
     return byte_input;
 }
@@ -755,15 +745,17 @@ void byte_input_set_result_callback(
     uint8_t* bytes,
     uint8_t bytes_count) {
     with_view_model(
-        byte_input->view, (ByteInputModel * model) {
+        byte_input->view,
+        ByteInputModel * model,
+        {
             byte_input_reset_model_input_data(model);
             model->input_callback = input_callback;
             model->changed_callback = changed_callback;
             model->callback_context = callback_context;
             model->bytes = bytes;
             model->bytes_count = bytes_count;
-            return true;
-        });
+        },
+        true);
 }
 
 /**
@@ -774,8 +766,5 @@ void byte_input_set_result_callback(
  */
 void byte_input_set_header_text(ByteInput* byte_input, const char* text) {
     with_view_model(
-        byte_input->view, (ByteInputModel * model) {
-            model->header = text;
-            return true;
-        });
+        byte_input->view, ByteInputModel * model, { model->header = text; }, true);
 }
diff --git a/applications/services/gui/modules/dialog_ex.c b/applications/services/gui/modules/dialog_ex.c
index dee2a0971..1cb467232 100644
--- a/applications/services/gui/modules/dialog_ex.c
+++ b/applications/services/gui/modules/dialog_ex.c
@@ -90,12 +90,14 @@ static bool dialog_ex_view_input_callback(InputEvent* event, void* context) {
     const char* right_text = NULL;
 
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
+        dialog_ex->view,
+        DialogExModel * model,
+        {
             left_text = model->left_text;
             center_text = model->center_text;
             right_text = model->right_text;
-            return true;
-        });
+        },
+        true);
 
     if(dialog_ex->callback) {
         if(event->type == InputTypeShort) {
@@ -149,7 +151,9 @@ DialogEx* dialog_ex_alloc() {
     view_set_draw_callback(dialog_ex->view, dialog_ex_view_draw_callback);
     view_set_input_callback(dialog_ex->view, dialog_ex_view_input_callback);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
+        dialog_ex->view,
+        DialogExModel * model,
+        {
             model->header.text = NULL;
             model->header.x = 0;
             model->header.y = 0;
@@ -169,9 +173,8 @@ DialogEx* dialog_ex_alloc() {
             model->left_text = NULL;
             model->center_text = NULL;
             model->right_text = NULL;
-
-            return true;
-        });
+        },
+        true);
     dialog_ex->enable_extended_events = false;
     return dialog_ex;
 }
@@ -206,14 +209,16 @@ void dialog_ex_set_header(
     Align vertical) {
     furi_assert(dialog_ex);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
+        dialog_ex->view,
+        DialogExModel * model,
+        {
             model->header.text = text;
             model->header.x = x;
             model->header.y = y;
             model->header.horizontal = horizontal;
             model->header.vertical = vertical;
-            return true;
-        });
+        },
+        true);
 }
 
 void dialog_ex_set_text(
@@ -225,52 +230,47 @@ void dialog_ex_set_text(
     Align vertical) {
     furi_assert(dialog_ex);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
+        dialog_ex->view,
+        DialogExModel * model,
+        {
             model->text.text = text;
             model->text.x = x;
             model->text.y = y;
             model->text.horizontal = horizontal;
             model->text.vertical = vertical;
-            return true;
-        });
+        },
+        true);
 }
 
 void dialog_ex_set_icon(DialogEx* dialog_ex, uint8_t x, uint8_t y, const Icon* icon) {
     furi_assert(dialog_ex);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
+        dialog_ex->view,
+        DialogExModel * model,
+        {
             model->icon.x = x;
             model->icon.y = y;
             model->icon.icon = icon;
-            return true;
-        });
+        },
+        true);
 }
 
 void dialog_ex_set_left_button_text(DialogEx* dialog_ex, const char* text) {
     furi_assert(dialog_ex);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
-            model->left_text = text;
-            return true;
-        });
+        dialog_ex->view, DialogExModel * model, { model->left_text = text; }, true);
 }
 
 void dialog_ex_set_center_button_text(DialogEx* dialog_ex, const char* text) {
     furi_assert(dialog_ex);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
-            model->center_text = text;
-            return true;
-        });
+        dialog_ex->view, DialogExModel * model, { model->center_text = text; }, true);
 }
 
 void dialog_ex_set_right_button_text(DialogEx* dialog_ex, const char* text) {
     furi_assert(dialog_ex);
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
-            model->right_text = text;
-            return true;
-        });
+        dialog_ex->view, DialogExModel * model, { model->right_text = text; }, true);
 }
 
 void dialog_ex_reset(DialogEx* dialog_ex) {
@@ -279,15 +279,17 @@ void dialog_ex_reset(DialogEx* dialog_ex) {
         .text = NULL, .x = 0, .y = 0, .horizontal = AlignLeft, .vertical = AlignLeft};
     IconElement clean_icon_el = {.icon = NULL, .x = 0, .y = 0};
     with_view_model(
-        dialog_ex->view, (DialogExModel * model) {
+        dialog_ex->view,
+        DialogExModel * model,
+        {
             model->header = clean_text_el;
             model->text = clean_text_el;
             model->icon = clean_icon_el;
             model->left_text = NULL;
             model->center_text = NULL;
             model->right_text = NULL;
-            return true;
-        });
+        },
+        true);
     dialog_ex->context = NULL;
     dialog_ex->callback = NULL;
 }
diff --git a/applications/services/gui/modules/file_browser.c b/applications/services/gui/modules/file_browser.c
index f15b09f6b..60e78b01c 100644
--- a/applications/services/gui/modules/file_browser.c
+++ b/applications/services/gui/modules/file_browser.c
@@ -57,7 +57,6 @@ static void BrowserItem_t_set(BrowserItem_t* obj, const BrowserItem_t* src) {
     furi_string_set(obj->path, src->path);
     furi_string_set(obj->display_name, src->display_name);
     if(src->custom_icon_data) {
-        obj->custom_icon_data = malloc(CUSTOM_ICON_MAX_SIZE);
         memcpy(obj->custom_icon_data, src->custom_icon_data, CUSTOM_ICON_MAX_SIZE);
     } else {
         obj->custom_icon_data = NULL;
@@ -140,10 +139,7 @@ FileBrowser* file_browser_alloc(FuriString* result_path) {
     browser->result_path = result_path;
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
-            items_array_init(model->items);
-            return false;
-        });
+        browser->view, FileBrowserModel * model, { items_array_init(model->items); }, false);
 
     return browser;
 }
@@ -152,10 +148,7 @@ void file_browser_free(FileBrowser* browser) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
-            items_array_clear(model->items);
-            return false;
-        });
+        browser->view, FileBrowserModel * model, { items_array_clear(model->items); }, false);
 
     view_free(browser->view);
     free(browser);
@@ -179,11 +172,13 @@ void file_browser_configure(
     browser->hide_ext = hide_ext;
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
+        browser->view,
+        FileBrowserModel * model,
+        {
             model->file_icon = file_icon;
             model->hide_ext = hide_ext;
-            return false;
-        });
+        },
+        false);
 }
 
 void file_browser_start(FileBrowser* browser, FuriString* path) {
@@ -200,14 +195,16 @@ void file_browser_stop(FileBrowser* browser) {
     furi_assert(browser);
     file_browser_worker_free(browser->worker);
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
+        browser->view,
+        FileBrowserModel * model,
+        {
             items_array_reset(model->items);
             model->item_cnt = 0;
             model->item_idx = 0;
             model->array_offset = 0;
             model->list_offset = 0;
-            return false;
-        });
+        },
+        false);
 }
 
 void file_browser_set_callback(FileBrowser* browser, FileBrowserCallback callback, void* context) {
@@ -258,7 +255,9 @@ static void browser_update_offset(FileBrowser* browser) {
     furi_assert(browser);
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
+        browser->view,
+        FileBrowserModel * model,
+        {
             uint16_t bounds = model->item_cnt > (LIST_ITEMS - 1) ? 2 : model->item_cnt;
 
             if((model->item_cnt > (LIST_ITEMS - 1)) &&
@@ -273,9 +272,8 @@ static void browser_update_offset(FileBrowser* browser) {
                 model->list_offset =
                     CLAMP(model->item_idx - 1, (int32_t)model->item_cnt - bounds, 0);
             }
-
-            return false;
-        });
+        },
+        false);
 }
 
 static void
@@ -286,7 +284,9 @@ static void
     int32_t load_offset = 0;
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
+        browser->view,
+        FileBrowserModel * model,
+        {
             items_array_reset(model->items);
             if(is_root) {
                 model->item_cnt = item_cnt;
@@ -304,8 +304,8 @@ static void
             model->is_root = is_root;
             model->list_loading = true;
             model->folder_loading = false;
-            return true;
-        });
+        },
+        true);
     browser_update_offset(browser);
 
     file_browser_worker_load(browser->worker, load_offset, ITEM_LIST_LEN_MAX);
@@ -320,7 +320,9 @@ static void browser_list_load_cb(void* context, uint32_t list_load_offset) {
     back_item.type = BrowserItemTypeBack;
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
+        browser->view,
+        FileBrowserModel * model,
+        {
             items_array_reset(model->items);
             model->array_offset = list_load_offset;
             if(!model->is_root) {
@@ -330,8 +332,8 @@ static void browser_list_load_cb(void* context, uint32_t list_load_offset) {
                     model->array_offset += 1;
                 }
             }
-            return false;
-        });
+        },
+        true);
 
     BrowserItem_t_clear(&back_item);
 }
@@ -372,19 +374,21 @@ static void
         }
 
         with_view_model(
-            browser->view, (FileBrowserModel * model) {
+            browser->view,
+            FileBrowserModel * model,
+            {
                 items_array_push_back(model->items, item);
                 // TODO: calculate if element is visible
-                return true;
-            });
+            },
+            true);
         furi_string_free(item.display_name);
         furi_string_free(item.path);
+        if(item.custom_icon_data) {
+            free(item.custom_icon_data);
+        }
     } else {
         with_view_model(
-            browser->view, (FileBrowserModel * model) {
-                model->list_loading = false;
-                return true;
-            });
+            browser->view, FileBrowserModel * model, { model->list_loading = false; }, true);
     }
 }
 
@@ -393,10 +397,7 @@ static void browser_long_load_cb(void* context) {
     FileBrowser* browser = (FileBrowser*)context;
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
-            model->folder_loading = true;
-            return true;
-        });
+        browser->view, FileBrowserModel * model, { model->folder_loading = true; }, true);
 }
 
 static void browser_draw_frame(Canvas* canvas, uint16_t idx, bool scrollbar) {
@@ -506,17 +507,16 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
     bool is_loading = false;
 
     with_view_model(
-        browser->view, (FileBrowserModel * model) {
-            is_loading = model->folder_loading;
-            return false;
-        });
+        browser->view, FileBrowserModel * model, { is_loading = model->folder_loading; }, false);
 
     if(is_loading) {
         return false;
     } else if(event->key == InputKeyUp || event->key == InputKeyDown) {
         if(event->type == InputTypeShort || event->type == InputTypeRepeat) {
             with_view_model(
-                browser->view, (FileBrowserModel * model) {
+                browser->view,
+                FileBrowserModel * model,
+                {
                     if(event->key == InputKeyUp) {
                         model->item_idx =
                             ((model->item_idx - 1) + model->item_cnt) % model->item_cnt;
@@ -541,8 +541,8 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
                                 browser->worker, load_offset, ITEM_LIST_LEN_MAX);
                         }
                     }
-                    return true;
-                });
+                },
+                true);
             browser_update_offset(browser);
             consumed = true;
         }
@@ -551,7 +551,9 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
             BrowserItem_t* selected_item = NULL;
             int32_t select_index = 0;
             with_view_model(
-                browser->view, (FileBrowserModel * model) {
+                browser->view,
+                FileBrowserModel * model,
+                {
                     if(browser_is_item_in_array(model, model->item_idx)) {
                         selected_item =
                             items_array_get(model->items, model->item_idx - model->array_offset);
@@ -560,8 +562,8 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
                             select_index -= 1;
                         }
                     }
-                    return false;
-                });
+                },
+                false);
 
             if(selected_item) {
                 if(selected_item->type == BrowserItemTypeBack) {
@@ -582,10 +584,7 @@ static bool file_browser_view_input_callback(InputEvent* event, void* context) {
         if(event->type == InputTypeShort) {
             bool is_root = false;
             with_view_model(
-                browser->view, (FileBrowserModel * model) {
-                    is_root = model->is_root;
-                    return false;
-                });
+                browser->view, FileBrowserModel * model, { is_root = model->is_root; }, false);
             if(!is_root) {
                 file_browser_worker_folder_exit(browser->worker);
             }
diff --git a/applications/services/gui/modules/file_browser_worker.c b/applications/services/gui/modules/file_browser_worker.c
index 319304f92..fdaf8273f 100644
--- a/applications/services/gui/modules/file_browser_worker.c
+++ b/applications/services/gui/modules/file_browser_worker.c
@@ -291,7 +291,7 @@ static int32_t browser_worker(void* context) {
             browser_folder_init(browser, path, filename, &items_cnt, &file_idx);
             FURI_LOG_D(
                 TAG,
-                "Enter folder: %s items: %u idx: %d",
+                "Enter folder: %s items: %lu idx: %ld",
                 furi_string_get_cstr(path),
                 items_cnt,
                 file_idx);
@@ -313,7 +313,7 @@ static int32_t browser_worker(void* context) {
             }
             FURI_LOG_D(
                 TAG,
-                "Exit to: %s items: %u idx: %d",
+                "Exit to: %s items: %lu idx: %ld",
                 furi_string_get_cstr(path),
                 items_cnt,
                 file_idx);
@@ -330,7 +330,7 @@ static int32_t browser_worker(void* context) {
             browser_folder_init(browser, path, filename, &items_cnt, &file_idx);
             FURI_LOG_D(
                 TAG,
-                "Refresh folder: %s items: %u idx: %d",
+                "Refresh folder: %s items: %lu idx: %ld",
                 furi_string_get_cstr(path),
                 items_cnt,
                 browser->item_sel_idx);
@@ -340,7 +340,8 @@ static int32_t browser_worker(void* context) {
         }
 
         if(flags & WorkerEvtLoad) {
-            FURI_LOG_D(TAG, "Load offset: %u cnt: %u", browser->load_offset, browser->load_count);
+            FURI_LOG_D(
+                TAG, "Load offset: %lu cnt: %lu", browser->load_offset, browser->load_count);
             browser_folder_load(browser, path, browser->load_offset, browser->load_count);
         }
 
diff --git a/applications/services/gui/modules/menu.c b/applications/services/gui/modules/menu.c
index 67d46d5f3..db0717f77 100644
--- a/applications/services/gui/modules/menu.c
+++ b/applications/services/gui/modules/menu.c
@@ -103,25 +103,29 @@ static bool menu_input_callback(InputEvent* event, void* context) {
 static void menu_enter(void* context) {
     Menu* menu = context;
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             MenuItem* item = MenuItemArray_get(model->items, model->position);
             if(item && item->icon) {
                 icon_animation_start(item->icon);
             }
-            return false;
-        });
+        },
+        false);
 }
 
 static void menu_exit(void* context) {
     Menu* menu = context;
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             MenuItem* item = MenuItemArray_get(model->items, model->position);
             if(item && item->icon) {
                 icon_animation_stop(item->icon);
             }
-            return false;
-        });
+        },
+        false);
 }
 
 Menu* menu_alloc() {
@@ -135,11 +139,13 @@ Menu* menu_alloc() {
     view_set_exit_callback(menu->view, menu_exit);
 
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             MenuItemArray_init(model->items);
             model->position = 0;
-            return true;
-        });
+        },
+        true);
 
     return menu;
 }
@@ -168,7 +174,9 @@ void menu_add_item(
 
     MenuItem* item = NULL;
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             item = MenuItemArray_push_new(model->items);
             item->label = label;
             item->icon = icon ? icon_animation_alloc(icon) : icon_animation_alloc(&A_Plugins_14);
@@ -176,14 +184,16 @@ void menu_add_item(
             item->index = index;
             item->callback = callback;
             item->callback_context = context;
-            return true;
-        });
+        },
+        true);
 }
 
 void menu_reset(Menu* menu) {
     furi_assert(menu);
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             for
                 M_EACH(item, model->items, MenuItemArray_t) {
                     icon_animation_stop(item->icon);
@@ -192,25 +202,27 @@ void menu_reset(Menu* menu) {
 
             MenuItemArray_reset(model->items);
             model->position = 0;
-            return true;
-        });
+        },
+        true);
 }
 
 void menu_set_selected_item(Menu* menu, uint32_t index) {
     with_view_model(
-        menu->view, (MenuModel * model) {
-            if(index >= MenuItemArray_size(model->items)) {
-                return false;
+        menu->view,
+        MenuModel * model,
+        {
+            if(index < MenuItemArray_size(model->items)) {
+                model->position = index;
             }
-
-            model->position = index;
-            return true;
-        });
+        },
+        true);
 }
 
 static void menu_process_up(Menu* menu) {
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             MenuItem* item = MenuItemArray_get(model->items, model->position);
             if(item && item->icon) {
                 icon_animation_stop(item->icon);
@@ -226,13 +238,15 @@ static void menu_process_up(Menu* menu) {
             if(item && item->icon) {
                 icon_animation_start(item->icon);
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void menu_process_down(Menu* menu) {
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             MenuItem* item = MenuItemArray_get(model->items, model->position);
             if(item && item->icon) {
                 icon_animation_stop(item->icon);
@@ -248,19 +262,21 @@ static void menu_process_down(Menu* menu) {
             if(item && item->icon) {
                 icon_animation_start(item->icon);
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void menu_process_ok(Menu* menu) {
     MenuItem* item = NULL;
     with_view_model(
-        menu->view, (MenuModel * model) {
+        menu->view,
+        MenuModel * model,
+        {
             if(model->position < MenuItemArray_size(model->items)) {
                 item = MenuItemArray_get(model->items, model->position);
             }
-            return true;
-        });
+        },
+        true);
     if(item && item->callback) {
         item->callback(item->callback_context, item->index);
     }
diff --git a/applications/services/gui/modules/popup.c b/applications/services/gui/modules/popup.c
index b3cb5e536..08e8d8c2b 100644
--- a/applications/services/gui/modules/popup.c
+++ b/applications/services/gui/modules/popup.c
@@ -124,7 +124,9 @@ Popup* popup_alloc() {
     view_set_exit_callback(popup->view, popup_stop_timer);
 
     with_view_model(
-        popup->view, (PopupModel * model) {
+        popup->view,
+        PopupModel * model,
+        {
             model->header.text = NULL;
             model->header.x = 0;
             model->header.y = 0;
@@ -140,8 +142,8 @@ Popup* popup_alloc() {
             model->icon.x = 0;
             model->icon.y = 0;
             model->icon.icon = NULL;
-            return true;
-        });
+        },
+        true);
     return popup;
 }
 
@@ -176,14 +178,16 @@ void popup_set_header(
     Align vertical) {
     furi_assert(popup);
     with_view_model(
-        popup->view, (PopupModel * model) {
+        popup->view,
+        PopupModel * model,
+        {
             model->header.text = text;
             model->header.x = x;
             model->header.y = y;
             model->header.horizontal = horizontal;
             model->header.vertical = vertical;
-            return true;
-        });
+        },
+        true);
 }
 
 void popup_set_text(
@@ -195,25 +199,29 @@ void popup_set_text(
     Align vertical) {
     furi_assert(popup);
     with_view_model(
-        popup->view, (PopupModel * model) {
+        popup->view,
+        PopupModel * model,
+        {
             model->text.text = text;
             model->text.x = x;
             model->text.y = y;
             model->text.horizontal = horizontal;
             model->text.vertical = vertical;
-            return true;
-        });
+        },
+        true);
 }
 
 void popup_set_icon(Popup* popup, uint8_t x, uint8_t y, const Icon* icon) {
     furi_assert(popup);
     with_view_model(
-        popup->view, (PopupModel * model) {
+        popup->view,
+        PopupModel * model,
+        {
             model->icon.x = x;
             model->icon.y = y;
             model->icon.icon = icon;
-            return true;
-        });
+        },
+        true);
 }
 
 void popup_set_timeout(Popup* popup, uint32_t timeout_in_ms) {
@@ -233,12 +241,14 @@ void popup_reset(Popup* popup) {
     furi_assert(popup);
 
     with_view_model(
-        popup->view, (PopupModel * model) {
+        popup->view,
+        PopupModel * model,
+        {
             memset(&model->header, 0, sizeof(model->header));
             memset(&model->text, 0, sizeof(model->text));
             memset(&model->icon, 0, sizeof(model->icon));
-            return false;
-        });
+        },
+        false);
     popup->callback = NULL;
     popup->context = NULL;
     popup->timer_enabled = false;
diff --git a/applications/services/gui/modules/submenu.c b/applications/services/gui/modules/submenu.c
index 8d40d97b7..949598772 100644
--- a/applications/services/gui/modules/submenu.c
+++ b/applications/services/gui/modules/submenu.c
@@ -128,13 +128,15 @@ Submenu* submenu_alloc() {
     view_set_input_callback(submenu->view, submenu_view_input_callback);
 
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             SubmenuItemArray_init(model->items);
             model->position = 0;
             model->window_position = 0;
             model->header = NULL;
-            return true;
-        });
+        },
+        true);
 
     return submenu;
 }
@@ -143,10 +145,7 @@ void submenu_free(Submenu* submenu) {
     furi_assert(submenu);
 
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
-            SubmenuItemArray_clear(model->items);
-            return true;
-        });
+        submenu->view, SubmenuModel * model, { SubmenuItemArray_clear(model->items); }, true);
     view_free(submenu->view);
     free(submenu);
 }
@@ -167,32 +166,38 @@ void submenu_add_item(
     furi_assert(submenu);
 
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             item = SubmenuItemArray_push_new(model->items);
             item->label = label;
             item->index = index;
             item->callback = callback;
             item->callback_context = callback_context;
-            return true;
-        });
+        },
+        true);
 }
 
 void submenu_reset(Submenu* submenu) {
     furi_assert(submenu);
 
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             SubmenuItemArray_reset(model->items);
             model->position = 0;
             model->window_position = 0;
             model->header = NULL;
-            return true;
-        });
+        },
+        true);
 }
 
 void submenu_set_selected_item(Submenu* submenu, uint32_t index) {
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             uint32_t position = 0;
             SubmenuItemArray_it_t it;
             for(SubmenuItemArray_it(it, model->items); !SubmenuItemArray_end_p(it);
@@ -225,14 +230,15 @@ void submenu_set_selected_item(Submenu* submenu, uint32_t index) {
                         (SubmenuItemArray_size(model->items) - items_on_screen);
                 }
             }
-
-            return true;
-        });
+        },
+        true);
 }
 
 void submenu_process_up(Submenu* submenu) {
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             uint8_t items_on_screen = model->header ? 3 : 4;
             if(model->position > 0) {
                 model->position--;
@@ -246,13 +252,15 @@ void submenu_process_up(Submenu* submenu) {
                     model->window_position = model->position - (items_on_screen - 1);
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void submenu_process_down(Submenu* submenu) {
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             uint8_t items_on_screen = model->header ? 3 : 4;
             if(model->position < (SubmenuItemArray_size(model->items) - 1)) {
                 model->position++;
@@ -265,20 +273,22 @@ void submenu_process_down(Submenu* submenu) {
                 model->position = 0;
                 model->window_position = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void submenu_process_ok(Submenu* submenu) {
     SubmenuItem* item = NULL;
 
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
+        submenu->view,
+        SubmenuModel * model,
+        {
             if(model->position < (SubmenuItemArray_size(model->items))) {
                 item = SubmenuItemArray_get(model->items, model->position);
             }
-            return true;
-        });
+        },
+        true);
 
     if(item && item->callback) {
         item->callback(item->callback_context, item->index);
@@ -289,8 +299,5 @@ void submenu_set_header(Submenu* submenu, const char* header) {
     furi_assert(submenu);
 
     with_view_model(
-        submenu->view, (SubmenuModel * model) {
-            model->header = header;
-            return true;
-        });
+        submenu->view, SubmenuModel * model, { model->header = header; }, true);
 }
diff --git a/applications/services/gui/modules/text_box.c b/applications/services/gui/modules/text_box.c
index 65ee28301..99d7d04f1 100644
--- a/applications/services/gui/modules/text_box.c
+++ b/applications/services/gui/modules/text_box.c
@@ -21,20 +21,24 @@ typedef struct {
 
 static void text_box_process_down(TextBox* text_box) {
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
+        text_box->view,
+        TextBoxModel * model,
+        {
             if(model->scroll_pos < model->scroll_num - 1) {
                 model->scroll_pos++;
                 // Search next line start
                 while(*model->text_pos++ != '\n')
                     ;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void text_box_process_up(TextBox* text_box) {
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
+        text_box->view,
+        TextBoxModel * model,
+        {
             if(model->scroll_pos > 0) {
                 model->scroll_pos--;
                 // Reach last symbol of previous line
@@ -46,8 +50,8 @@ static void text_box_process_up(TextBox* text_box) {
                     model->text_pos++;
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 static void text_box_insert_endline(Canvas* canvas, TextBoxModel* model) {
@@ -137,13 +141,15 @@ TextBox* text_box_alloc() {
     view_set_input_callback(text_box->view, text_box_view_input_callback);
 
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
+        text_box->view,
+        TextBoxModel * model,
+        {
             model->text = NULL;
             model->text_formatted = furi_string_alloc_set("");
             model->formatted = false;
             model->font = TextBoxFontText;
-            return true;
-        });
+        },
+        true);
 
     return text_box;
 }
@@ -152,10 +158,7 @@ void text_box_free(TextBox* text_box) {
     furi_assert(text_box);
 
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
-            furi_string_free(model->text_formatted);
-            return true;
-        });
+        text_box->view, TextBoxModel * model, { furi_string_free(model->text_formatted); }, true);
     view_free(text_box->view);
     free(text_box);
 }
@@ -169,13 +172,15 @@ void text_box_reset(TextBox* text_box) {
     furi_assert(text_box);
 
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
+        text_box->view,
+        TextBoxModel * model,
+        {
             model->text = NULL;
             furi_string_set(model->text_formatted, "");
             model->font = TextBoxFontText;
             model->focus = TextBoxFocusStart;
-            return true;
-        });
+        },
+        true);
 }
 
 void text_box_set_text(TextBox* text_box, const char* text) {
@@ -183,31 +188,27 @@ void text_box_set_text(TextBox* text_box, const char* text) {
     furi_assert(text);
 
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
+        text_box->view,
+        TextBoxModel * model,
+        {
             model->text = text;
             furi_string_reset(model->text_formatted);
             furi_string_reserve(model->text_formatted, strlen(text));
             model->formatted = false;
-            return true;
-        });
+        },
+        true);
 }
 
 void text_box_set_font(TextBox* text_box, TextBoxFont font) {
     furi_assert(text_box);
 
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
-            model->font = font;
-            return true;
-        });
+        text_box->view, TextBoxModel * model, { model->font = font; }, true);
 }
 
 void text_box_set_focus(TextBox* text_box, TextBoxFocus focus) {
     furi_assert(text_box);
 
     with_view_model(
-        text_box->view, (TextBoxModel * model) {
-            model->focus = focus;
-            return true;
-        });
+        text_box->view, TextBoxModel * model, { model->focus = focus; }, true);
 }
diff --git a/applications/services/gui/modules/text_input.c b/applications/services/gui/modules/text_input.c
index d7e00940d..79fa87728 100644
--- a/applications/services/gui/modules/text_input.c
+++ b/applications/services/gui/modules/text_input.c
@@ -429,10 +429,10 @@ void text_input_timer_callback(void* context) {
     TextInput* text_input = context;
 
     with_view_model(
-        text_input->view, (TextInputModel * model) {
-            model->valadator_message_visible = false;
-            return true;
-        });
+        text_input->view,
+        TextInputModel * model,
+        { model->valadator_message_visible = false; },
+        true);
 }
 
 TextInput* text_input_alloc() {
@@ -446,10 +446,10 @@ TextInput* text_input_alloc() {
     text_input->timer = furi_timer_alloc(text_input_timer_callback, FuriTimerTypeOnce, text_input);
 
     with_view_model(
-        text_input->view, (TextInputModel * model) {
-            model->validator_text = furi_string_alloc();
-            return false;
-        });
+        text_input->view,
+        TextInputModel * model,
+        { model->validator_text = furi_string_alloc(); },
+        false);
 
     text_input_reset(text_input);
 
@@ -459,10 +459,10 @@ TextInput* text_input_alloc() {
 void text_input_free(TextInput* text_input) {
     furi_assert(text_input);
     with_view_model(
-        text_input->view, (TextInputModel * model) {
-            furi_string_free(model->validator_text);
-            return false;
-        });
+        text_input->view,
+        TextInputModel * model,
+        { furi_string_free(model->validator_text); },
+        false);
 
     // Send stop command
     furi_timer_stop(text_input->timer);
@@ -477,7 +477,9 @@ void text_input_free(TextInput* text_input) {
 void text_input_reset(TextInput* text_input) {
     furi_assert(text_input);
     with_view_model(
-        text_input->view, (TextInputModel * model) {
+        text_input->view,
+        TextInputModel * model,
+        {
             model->text_buffer_size = 0;
             model->header = "";
             model->selected_row = 0;
@@ -491,8 +493,8 @@ void text_input_reset(TextInput* text_input) {
             model->validator_callback_context = NULL;
             furi_string_reset(model->validator_text);
             model->valadator_message_visible = false;
-            return true;
-        });
+        },
+        true);
 }
 
 View* text_input_get_view(TextInput* text_input) {
@@ -508,7 +510,9 @@ void text_input_set_result_callback(
     size_t text_buffer_size,
     bool clear_default_text) {
     with_view_model(
-        text_input->view, (TextInputModel * model) {
+        text_input->view,
+        TextInputModel * model,
+        {
             model->callback = callback;
             model->callback_context = callback_context;
             model->text_buffer = text_buffer;
@@ -519,8 +523,8 @@ void text_input_set_result_callback(
                 model->selected_row = 2;
                 model->selected_column = 8;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void text_input_set_validator(
@@ -528,37 +532,36 @@ void text_input_set_validator(
     TextInputValidatorCallback callback,
     void* callback_context) {
     with_view_model(
-        text_input->view, (TextInputModel * model) {
+        text_input->view,
+        TextInputModel * model,
+        {
             model->validator_callback = callback;
             model->validator_callback_context = callback_context;
-            return true;
-        });
+        },
+        true);
 }
 
 TextInputValidatorCallback text_input_get_validator_callback(TextInput* text_input) {
     TextInputValidatorCallback validator_callback = NULL;
     with_view_model(
-        text_input->view, (TextInputModel * model) {
-            validator_callback = model->validator_callback;
-            return false;
-        });
+        text_input->view,
+        TextInputModel * model,
+        { validator_callback = model->validator_callback; },
+        false);
     return validator_callback;
 }
 
 void* text_input_get_validator_callback_context(TextInput* text_input) {
     void* validator_callback_context = NULL;
     with_view_model(
-        text_input->view, (TextInputModel * model) {
-            validator_callback_context = model->validator_callback_context;
-            return false;
-        });
+        text_input->view,
+        TextInputModel * model,
+        { validator_callback_context = model->validator_callback_context; },
+        false);
     return validator_callback_context;
 }
 
 void text_input_set_header_text(TextInput* text_input, const char* text) {
     with_view_model(
-        text_input->view, (TextInputModel * model) {
-            model->header = text;
-            return true;
-        });
+        text_input->view, TextInputModel * model, { model->header = text; }, true);
 }
diff --git a/applications/services/gui/modules/variable_item_list.c b/applications/services/gui/modules/variable_item_list.c
index ec8fd3d20..acd46ee4b 100644
--- a/applications/services/gui/modules/variable_item_list.c
+++ b/applications/services/gui/modules/variable_item_list.c
@@ -92,7 +92,9 @@ static void variable_item_list_draw_callback(Canvas* canvas, void* _model) {
 
 void variable_item_list_set_selected_item(VariableItemList* variable_item_list, uint8_t index) {
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             uint8_t position = index;
             if(position >= VariableItemArray_size(model->items)) {
                 position = 0;
@@ -112,9 +114,8 @@ void variable_item_list_set_selected_item(VariableItemList* variable_item_list,
                     model->window_position = (VariableItemArray_size(model->items) - 4);
                 }
             }
-
-            return true;
-        });
+        },
+        true);
 }
 
 uint8_t variable_item_list_get_selected_item_index(VariableItemList* variable_item_list) {
@@ -181,7 +182,9 @@ static bool variable_item_list_input_callback(InputEvent* event, void* context)
 
 void variable_item_list_process_up(VariableItemList* variable_item_list) {
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             uint8_t items_on_screen = 4;
             if(model->position > 0) {
                 model->position--;
@@ -195,13 +198,15 @@ void variable_item_list_process_up(VariableItemList* variable_item_list) {
                     model->window_position = model->position - (items_on_screen - 1);
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void variable_item_list_process_down(VariableItemList* variable_item_list) {
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             uint8_t items_on_screen = 4;
             if(model->position < (VariableItemArray_size(model->items) - 1)) {
                 model->position++;
@@ -214,8 +219,8 @@ void variable_item_list_process_down(VariableItemList* variable_item_list) {
                 model->position = 0;
                 model->window_position = 0;
             }
-            return true;
-        });
+        },
+        true);
 }
 
 VariableItem* variable_item_list_get_selected_item(VariableItemListModel* model) {
@@ -239,7 +244,9 @@ VariableItem* variable_item_list_get_selected_item(VariableItemListModel* model)
 
 void variable_item_list_process_left(VariableItemList* variable_item_list) {
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             VariableItem* item = variable_item_list_get_selected_item(model);
             if(item->current_value_index > 0) {
                 item->current_value_index--;
@@ -247,13 +254,15 @@ void variable_item_list_process_left(VariableItemList* variable_item_list) {
                     item->change_callback(item);
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void variable_item_list_process_right(VariableItemList* variable_item_list) {
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             VariableItem* item = variable_item_list_get_selected_item(model);
             if(item->current_value_index < (item->values_count - 1)) {
                 item->current_value_index++;
@@ -261,18 +270,20 @@ void variable_item_list_process_right(VariableItemList* variable_item_list) {
                     item->change_callback(item);
                 }
             }
-            return true;
-        });
+        },
+        true);
 }
 
 void variable_item_list_process_ok(VariableItemList* variable_item_list) {
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             if(variable_item_list->callback) {
                 variable_item_list->callback(variable_item_list->context, model->position);
             }
-            return false;
-        });
+        },
+        false);
 }
 
 VariableItemList* variable_item_list_alloc() {
@@ -285,12 +296,14 @@ VariableItemList* variable_item_list_alloc() {
     view_set_input_callback(variable_item_list->view, variable_item_list_input_callback);
 
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             VariableItemArray_init(model->items);
             model->position = 0;
             model->window_position = 0;
-            return true;
-        });
+        },
+        true);
 
     return variable_item_list;
 }
@@ -299,15 +312,17 @@ void variable_item_list_free(VariableItemList* variable_item_list) {
     furi_assert(variable_item_list);
 
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             VariableItemArray_it_t it;
             for(VariableItemArray_it(it, model->items); !VariableItemArray_end_p(it);
                 VariableItemArray_next(it)) {
                 furi_string_free(VariableItemArray_ref(it)->current_value_text);
             }
             VariableItemArray_clear(model->items);
-            return false;
-        });
+        },
+        false);
     view_free(variable_item_list->view);
     free(variable_item_list);
 }
@@ -316,15 +331,17 @@ void variable_item_list_reset(VariableItemList* variable_item_list) {
     furi_assert(variable_item_list);
 
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             VariableItemArray_it_t it;
             for(VariableItemArray_it(it, model->items); !VariableItemArray_end_p(it);
                 VariableItemArray_next(it)) {
                 furi_string_free(VariableItemArray_ref(it)->current_value_text);
             }
             VariableItemArray_reset(model->items);
-            return false;
-        });
+        },
+        false);
 }
 
 View* variable_item_list_get_view(VariableItemList* variable_item_list) {
@@ -343,7 +360,9 @@ VariableItem* variable_item_list_add(
     furi_assert(variable_item_list);
 
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             item = VariableItemArray_push_new(model->items);
             item->label = label;
             item->values_count = values_count;
@@ -351,8 +370,8 @@ VariableItem* variable_item_list_add(
             item->context = context;
             item->current_value_index = 0;
             item->current_value_text = furi_string_alloc();
-            return true;
-        });
+        },
+        true);
 
     return item;
 }
@@ -363,12 +382,14 @@ void variable_item_list_set_enter_callback(
     void* context) {
     furi_assert(callback);
     with_view_model(
-        variable_item_list->view, (VariableItemListModel * model) {
+        variable_item_list->view,
+        VariableItemListModel * model,
+        {
             UNUSED(model);
             variable_item_list->callback = callback;
             variable_item_list->context = context;
-            return false;
-        });
+        },
+        false);
 }
 
 void variable_item_set_current_value_index(VariableItem* item, uint8_t current_value_index) {
diff --git a/applications/services/gui/modules/widget.c b/applications/services/gui/modules/widget.c
index 802f76e24..6153b425b 100644
--- a/applications/services/gui/modules/widget.c
+++ b/applications/services/gui/modules/widget.c
@@ -36,7 +36,9 @@ static bool gui_widget_view_input_callback(InputEvent* event, void* context) {
 
     // Call all Widget Elements input handlers
     with_view_model(
-        widget->view, (GuiWidgetModel * model) {
+        widget->view,
+        GuiWidgetModel * model,
+        {
             ElementArray_it_t it;
             ElementArray_it(it, model->element);
             while(!ElementArray_end_p(it)) {
@@ -46,8 +48,8 @@ static bool gui_widget_view_input_callback(InputEvent* event, void* context) {
                 }
                 ElementArray_next(it);
             }
-            return true;
-        });
+        },
+        true);
 
     return consumed;
 }
@@ -61,10 +63,7 @@ Widget* widget_alloc() {
     view_set_input_callback(widget->view, gui_widget_view_input_callback);
 
     with_view_model(
-        widget->view, (GuiWidgetModel * model) {
-            ElementArray_init(model->element);
-            return true;
-        });
+        widget->view, GuiWidgetModel * model, { ElementArray_init(model->element); }, true);
 
     return widget;
 }
@@ -73,7 +72,9 @@ void widget_reset(Widget* widget) {
     furi_assert(widget);
 
     with_view_model(
-        widget->view, (GuiWidgetModel * model) {
+        widget->view,
+        GuiWidgetModel * model,
+        {
             ElementArray_it_t it;
             ElementArray_it(it, model->element);
             while(!ElementArray_end_p(it)) {
@@ -83,8 +84,8 @@ void widget_reset(Widget* widget) {
                 ElementArray_next(it);
             }
             ElementArray_reset(model->element);
-            return true;
-        });
+        },
+        true);
 }
 
 void widget_free(Widget* widget) {
@@ -93,10 +94,7 @@ void widget_free(Widget* widget) {
     widget_reset(widget);
     // Free elements container
     with_view_model(
-        widget->view, (GuiWidgetModel * model) {
-            ElementArray_clear(model->element);
-            return true;
-        });
+        widget->view, GuiWidgetModel * model, { ElementArray_clear(model->element); }, true);
 
     view_free(widget->view);
     free(widget);
@@ -112,11 +110,13 @@ static void widget_add_element(Widget* widget, WidgetElement* element) {
     furi_assert(element);
 
     with_view_model(
-        widget->view, (GuiWidgetModel * model) {
+        widget->view,
+        GuiWidgetModel * model,
+        {
             element->parent = widget;
             ElementArray_push_back(model->element, element);
-            return true;
-        });
+        },
+        true);
 }
 
 void widget_add_string_multiline_element(
diff --git a/applications/services/gui/view.h b/applications/services/gui/view.h
index 5b4bf3609..b40f8ded5 100644
--- a/applications/services/gui/view.h
+++ b/applications/services/gui/view.h
@@ -211,25 +211,25 @@ void view_commit_model(View* view, bool update);
 #endif
 
 #ifdef __cplusplus
-#define with_view_model_cpp(view, type, var, function_body) \
+#define with_view_model_cpp(view, type, var, code, update)  \
     {                                                       \
-        type* p = static_cast<type*>(view_get_model(view)); \
-        bool update = [&](type * var) function_body(p);     \
+        type var = static_cast<type>(view_get_model(view)); \
+        {code};                                             \
         view_commit_model(view, update);                    \
     }
 #else
 /** With clause for view model
  *
  * @param      view           View instance pointer
- * @param      function_body  a (){} lambda declaration, executed within you
- *                            parent function context
+ * @param      type           View model type
+ * @param      code           Code block that will be executed between model lock and unlock
+ * @param      update         Bool flag, if true, view will be updated after code block. Can be variable, so code block can decide if update is needed.
  *
- * @return     true if you want to emit view update, false otherwise
  */
-#define with_view_model(view, function_body)                      \
-    {                                                             \
-        void* p = view_get_model(view);                           \
-        bool update = ({ bool __fn__ function_body __fn__; })(p); \
-        view_commit_model(view, update);                          \
+#define with_view_model(view, type, code, update) \
+    {                                             \
+        type = view_get_model(view);              \
+        {code};                                   \
+        view_commit_model(view, update);          \
     }
 #endif
diff --git a/applications/services/gui/view_dispatcher.c b/applications/services/gui/view_dispatcher.c
index 307206c14..6e4ce8360 100644
--- a/applications/services/gui/view_dispatcher.c
+++ b/applications/services/gui/view_dispatcher.c
@@ -246,7 +246,7 @@ void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* e
             "non-complementary input, discarding key: %s, type: %s, sequence: %p",
             input_get_key_name(event->key),
             input_get_type_name(event->type),
-            event->sequence);
+            (void*)event->sequence);
         return;
     }
 
@@ -286,7 +286,7 @@ void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* e
             view_dispatcher->current_view,
             input_get_key_name(event->key),
             input_get_type_name(event->type),
-            event->sequence);
+            (void*)event->sequence);
         view_input(view_dispatcher->ongoing_input_view, event);
     }
 }
diff --git a/applications/services/loader/loader.c b/applications/services/loader/loader.c
index 51cddec70..bc456536c 100644
--- a/applications/services/loader/loader.c
+++ b/applications/services/loader/loader.c
@@ -61,6 +61,7 @@ static void loader_cli_print_usage() {
     printf("Cmd list:\r\n");
     printf("\tlist\t - List available applications\r\n");
     printf("\topen <Application Name:string>\t - Open application by name\r\n");
+    printf("\tinfo\t - Show loader state\r\n");
 }
 
 static FlipperApplication const* loader_find_application_by_name_in_list(
@@ -98,10 +99,15 @@ const FlipperApplication* loader_find_application_by_name(const char* name) {
     return application;
 }
 
-void loader_cli_open(Cli* cli, FuriString* args, Loader* instance) {
+static void loader_cli_open(Cli* cli, FuriString* args, Loader* instance) {
     UNUSED(cli);
     if(loader_is_locked(instance)) {
-        printf("Can't start, furi application is running");
+        if(instance->application) {
+            furi_assert(instance->application->name);
+            printf("Can't start, %s application is running", instance->application->name);
+        } else {
+            printf("Can't start, furi application is running");
+        }
         return;
     }
 
@@ -137,7 +143,7 @@ void loader_cli_open(Cli* cli, FuriString* args, Loader* instance) {
     furi_string_free(application_name);
 }
 
-void loader_cli_list(Cli* cli, FuriString* args, Loader* instance) {
+static void loader_cli_list(Cli* cli, FuriString* args, Loader* instance) {
     UNUSED(cli);
     UNUSED(args);
     UNUSED(instance);
@@ -159,6 +165,22 @@ void loader_cli_list(Cli* cli, FuriString* args, Loader* instance) {
     }
 }
 
+static void loader_cli_info(Cli* cli, FuriString* args, Loader* instance) {
+    UNUSED(cli);
+    UNUSED(args);
+    if(!loader_is_locked(instance)) {
+        printf("No application is running\r\n");
+    } else {
+        printf("Running application: ");
+        if(instance->application) {
+            furi_assert(instance->application->name);
+            printf("%s\r\n", instance->application->name);
+        } else {
+            printf("unknown\r\n");
+        }
+    }
+}
+
 static void loader_cli(Cli* cli, FuriString* args, void* _ctx) {
     furi_assert(_ctx);
     Loader* instance = _ctx;
@@ -182,6 +204,11 @@ static void loader_cli(Cli* cli, FuriString* args, void* _ctx) {
             break;
         }
 
+        if(furi_string_cmp_str(cmd, "info") == 0) {
+            loader_cli_info(cli, args, instance);
+            break;
+        }
+
         loader_cli_print_usage();
     } while(false);
 
diff --git a/applications/services/power/power_service/views/power_off.c b/applications/services/power/power_service/views/power_off.c
index 398ebe4ab..b0046325c 100644
--- a/applications/services/power/power_service/views/power_off.c
+++ b/applications/services/power/power_service/views/power_off.c
@@ -87,19 +87,13 @@ View* power_off_get_view(PowerOff* power_off) {
 void power_off_set_time_left(PowerOff* power_off, uint8_t time_left) {
     furi_assert(power_off);
     with_view_model(
-        power_off->view, (PowerOffModel * model) {
-            model->time_left_sec = time_left;
-            return true;
-        });
+        power_off->view, PowerOffModel * model, { model->time_left_sec = time_left; }, true);
 }
 
 PowerOffResponse power_off_get_response(PowerOff* power_off) {
     furi_assert(power_off);
     PowerOffResponse response;
     with_view_model(
-        power_off->view, (PowerOffModel * model) {
-            response = model->response;
-            return false;
-        });
+        power_off->view, PowerOffModel * model, { response = model->response; }, false);
     return response;
 }
diff --git a/applications/services/rpc/rpc.c b/applications/services/rpc/rpc.c
index 4e8c29b44..06c05173c 100644
--- a/applications/services/rpc/rpc.c
+++ b/applications/services/rpc/rpc.c
@@ -13,7 +13,6 @@
 #include <cli/cli.h>
 #include <stdint.h>
 #include <stdio.h>
-#include <stream_buffer.h>
 #include <m-dict.h>
 
 #define TAG "RpcSrv"
@@ -61,7 +60,7 @@ struct RpcSession {
     FuriThread* thread;
 
     RpcHandlerDict_t handlers;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
     PB_Main* decoded_message;
     bool terminate;
     void** system_contexts;
@@ -151,7 +150,7 @@ size_t
     furi_assert(encoded_bytes);
     furi_assert(size > 0);
 
-    size_t bytes_sent = xStreamBufferSend(session->stream, encoded_bytes, size, timeout);
+    size_t bytes_sent = furi_stream_buffer_send(session->stream, encoded_bytes, size, timeout);
 
     furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtNewData);
 
@@ -160,7 +159,7 @@ size_t
 
 size_t rpc_session_get_available_size(RpcSession* session) {
     furi_assert(session);
-    return xStreamBufferSpacesAvailable(session->stream);
+    return furi_stream_buffer_spaces_available(session->stream);
 }
 
 bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
@@ -174,9 +173,9 @@ bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
     size_t bytes_received = 0;
 
     while(1) {
-        bytes_received +=
-            xStreamBufferReceive(session->stream, buf + bytes_received, count - bytes_received, 0);
-        if(xStreamBufferIsEmpty(session->stream)) {
+        bytes_received += furi_stream_buffer_receive(
+            session->stream, buf + bytes_received, count - bytes_received, 0);
+        if(furi_stream_buffer_is_empty(session->stream)) {
             if(session->buffer_is_empty_callback) {
                 session->buffer_is_empty_callback(session->context);
             }
@@ -190,7 +189,7 @@ bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
         } else {
             flags = furi_thread_flags_wait(RPC_ALL_EVENTS, FuriFlagWaitAny, FuriWaitForever);
             if(flags & RpcEvtDisconnect) {
-                if(xStreamBufferIsEmpty(session->stream)) {
+                if(furi_stream_buffer_is_empty(session->stream)) {
                     session->terminate = true;
                     istream->bytes_left = 0;
                     bytes_received = 0;
@@ -279,7 +278,7 @@ static int32_t rpc_session_worker(void* context) {
         }
 
         if(message_decode_failed) {
-            xStreamBufferReset(session->stream);
+            furi_stream_buffer_reset(session->stream);
             if(!session->terminate) {
                 /* Protobuf can't determine start and end of message.
                  * Handle this by adding varint at beginning
@@ -329,7 +328,7 @@ static void rpc_session_free_callback(FuriThreadState thread_state, void* contex
         free(session->system_contexts);
         free(session->decoded_message);
         RpcHandlerDict_clear(session->handlers);
-        vStreamBufferDelete(session->stream);
+        furi_stream_buffer_free(session->stream);
 
         furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
         if(session->terminated_callback) {
@@ -348,7 +347,7 @@ RpcSession* rpc_session_open(Rpc* rpc) {
 
     RpcSession* session = malloc(sizeof(RpcSession));
     session->callbacks_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-    session->stream = xStreamBufferCreate(RPC_BUFFER_SIZE, 1);
+    session->stream = furi_stream_buffer_alloc(RPC_BUFFER_SIZE, 1);
     session->rpc = rpc;
     session->terminate = false;
     session->decode_error = false;
diff --git a/applications/services/rpc/rpc_app.c b/applications/services/rpc/rpc_app.c
index b8b34170e..301055570 100644
--- a/applications/services/rpc/rpc_app.c
+++ b/applications/services/rpc/rpc_app.c
@@ -32,7 +32,7 @@ static void rpc_system_app_start_process(const PB_Main* request, void* context)
     furi_assert(!rpc_app->last_id);
     furi_assert(!rpc_app->last_data);
 
-    FURI_LOG_D(TAG, "StartProcess: id %d", request->command_id);
+    FURI_LOG_D(TAG, "StartProcess: id %ld", request->command_id);
 
     PB_CommandStatus result = PB_CommandStatus_ERROR_APP_CANT_START;
 
@@ -63,7 +63,7 @@ static void rpc_system_app_start_process(const PB_Main* request, void* context)
 
     furi_record_close(RECORD_LOADER);
 
-    FURI_LOG_D(TAG, "StartProcess: response id %d, result %d", request->command_id, result);
+    FURI_LOG_D(TAG, "StartProcess: response id %ld, result %d", request->command_id, result);
     rpc_send_and_release_empty(session, request->command_id, result);
 }
 
@@ -108,7 +108,7 @@ static void rpc_system_app_exit_request(const PB_Main* request, void* context) {
     PB_CommandStatus status;
 
     if(rpc_app->app_callback) {
-        FURI_LOG_D(TAG, "ExitRequest: id %d", request->command_id);
+        FURI_LOG_D(TAG, "ExitRequest: id %ld", request->command_id);
         furi_assert(!rpc_app->last_id);
         furi_assert(!rpc_app->last_data);
         rpc_app->last_id = request->command_id;
@@ -116,7 +116,7 @@ static void rpc_system_app_exit_request(const PB_Main* request, void* context) {
     } else {
         status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
         FURI_LOG_E(
-            TAG, "ExitRequest: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
+            TAG, "ExitRequest: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
         rpc_send_and_release_empty(session, request->command_id, status);
     }
 }
@@ -132,7 +132,7 @@ static void rpc_system_app_load_file(const PB_Main* request, void* context) {
 
     PB_CommandStatus status;
     if(rpc_app->app_callback) {
-        FURI_LOG_D(TAG, "LoadFile: id %d", request->command_id);
+        FURI_LOG_D(TAG, "LoadFile: id %ld", request->command_id);
         furi_assert(!rpc_app->last_id);
         furi_assert(!rpc_app->last_data);
         rpc_app->last_id = request->command_id;
@@ -141,7 +141,7 @@ static void rpc_system_app_load_file(const PB_Main* request, void* context) {
     } else {
         status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
         FURI_LOG_E(
-            TAG, "LoadFile: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
+            TAG, "LoadFile: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
         rpc_send_and_release_empty(session, request->command_id, status);
     }
 }
@@ -166,7 +166,7 @@ static void rpc_system_app_button_press(const PB_Main* request, void* context) {
     } else {
         status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
         FURI_LOG_E(
-            TAG, "ButtonPress: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
+            TAG, "ButtonPress: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
         rpc_send_and_release_empty(session, request->command_id, status);
     }
 }
@@ -190,7 +190,7 @@ static void rpc_system_app_button_release(const PB_Main* request, void* context)
     } else {
         status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
         FURI_LOG_E(
-            TAG, "ButtonRelease: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
+            TAG, "ButtonRelease: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
         rpc_send_and_release_empty(session, request->command_id, status);
     }
 }
@@ -243,7 +243,7 @@ void rpc_system_app_confirm(RpcAppSystem* rpc_app, RpcAppSystemEvent event, bool
             free(rpc_app->last_data);
             rpc_app->last_data = NULL;
         }
-        FURI_LOG_D(TAG, "AppConfirm: event %d last_id %d status %d", event, last_id, status);
+        FURI_LOG_D(TAG, "AppConfirm: event %d last_id %ld status %d", event, last_id, status);
         rpc_send_and_release_empty(session, last_id, status);
         break;
     default:
diff --git a/applications/services/rpc/rpc_cli.c b/applications/services/rpc/rpc_cli.c
index d03e2198c..82023e316 100644
--- a/applications/services/rpc/rpc_cli.c
+++ b/applications/services/rpc/rpc_cli.c
@@ -44,7 +44,7 @@ void rpc_cli_command_start_session(Cli* cli, FuriString* args, void* context) {
     Rpc* rpc = context;
 
     uint32_t mem_before = memmgr_get_free_heap();
-    FURI_LOG_D(TAG, "Free memory %d", mem_before);
+    FURI_LOG_D(TAG, "Free memory %ld", mem_before);
 
     furi_hal_usb_lock();
     RpcSession* rpc_session = rpc_session_open(rpc);
diff --git a/applications/services/rpc/rpc_debug.c b/applications/services/rpc/rpc_debug.c
index a060654d8..8eb81dece 100644
--- a/applications/services/rpc/rpc_debug.c
+++ b/applications/services/rpc/rpc_debug.c
@@ -158,9 +158,9 @@ void rpc_debug_print_message(const PB_Main* message) {
     case PB_Main_storage_info_response_tag: {
         furi_string_cat_printf(str, "\tinfo_response {\r\n");
         furi_string_cat_printf(
-            str, "\t\ttotal_space: %lu\r\n", message->content.storage_info_response.total_space);
+            str, "\t\ttotal_space: %llu\r\n", message->content.storage_info_response.total_space);
         furi_string_cat_printf(
-            str, "\t\tfree_space: %lu\r\n", message->content.storage_info_response.free_space);
+            str, "\t\tfree_space: %llu\r\n", message->content.storage_info_response.free_space);
         break;
     }
     case PB_Main_storage_stat_request_tag: {
diff --git a/applications/services/storage/storage_cli.c b/applications/services/storage/storage_cli.c
index 5e72dce8e..880fb9700 100644
--- a/applications/services/storage/storage_cli.c
+++ b/applications/services/storage/storage_cli.c
@@ -52,7 +52,7 @@ static void storage_cli_info(Cli* cli, FuriString* path) {
             storage_cli_print_error(error);
         } else {
             printf(
-                "Label: %s\r\nType: LittleFS\r\n%luKB total\r\n%luKB free\r\n",
+                "Label: %s\r\nType: LittleFS\r\n%luKiB total\r\n%luKiB free\r\n",
                 furi_hal_version_get_name_ptr() ? furi_hal_version_get_name_ptr() : "Unknown",
                 (uint32_t)(total_space / 1024),
                 (uint32_t)(free_space / 1024));
@@ -65,7 +65,7 @@ static void storage_cli_info(Cli* cli, FuriString* path) {
             storage_cli_print_error(error);
         } else {
             printf(
-                "Label: %s\r\nType: %s\r\n%luKB total\r\n%luKB free\r\n",
+                "Label: %s\r\nType: %s\r\n%luKiB total\r\n%luKiB free\r\n",
                 sd_info.label,
                 sd_api_get_fs_type_text(sd_info.fs_type),
                 sd_info.kb_total,
@@ -364,7 +364,7 @@ static void storage_cli_stat(Cli* cli, FuriString* path) {
             storage_cli_print_error(error);
         } else {
             printf(
-                "Storage, %luKB total, %luKB free\r\n",
+                "Storage, %luKiB total, %luKiB free\r\n",
                 (uint32_t)(total_space / 1024),
                 (uint32_t)(free_space / 1024));
         }
diff --git a/applications/services/storage/storage_external_api.c b/applications/services/storage/storage_external_api.c
index 379fc4ed1..c0c730fb7 100644
--- a/applications/services/storage/storage_external_api.c
+++ b/applications/services/storage/storage_external_api.c
@@ -119,7 +119,11 @@ bool storage_file_open(
     furi_event_flag_free(event);
 
     FURI_LOG_T(
-        TAG, "File %p - %p open (%s)", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE, path);
+        TAG,
+        "File %p - %p open (%s)",
+        (void*)((uint32_t)file - SRAM_BASE),
+        (void*)(file->file_id - SRAM_BASE),
+        path);
 
     return result;
 }
@@ -132,7 +136,11 @@ bool storage_file_close(File* file) {
     S_API_MESSAGE(StorageCommandFileClose);
     S_API_EPILOGUE;
 
-    FURI_LOG_T(TAG, "File %p - %p closed", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE);
+    FURI_LOG_T(
+        TAG,
+        "File %p - %p closed",
+        (void*)((uint32_t)file - SRAM_BASE),
+        (void*)(file->file_id - SRAM_BASE));
     file->type = FileTypeClosed;
 
     return S_RETURN_BOOL;
@@ -291,7 +299,11 @@ bool storage_dir_open(File* file, const char* path) {
     furi_event_flag_free(event);
 
     FURI_LOG_T(
-        TAG, "Dir %p - %p open (%s)", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE, path);
+        TAG,
+        "Dir %p - %p open (%s)",
+        (void*)((uint32_t)file - SRAM_BASE),
+        (void*)(file->file_id - SRAM_BASE),
+        path);
 
     return result;
 }
@@ -303,7 +315,11 @@ bool storage_dir_close(File* file) {
     S_API_MESSAGE(StorageCommandDirClose);
     S_API_EPILOGUE;
 
-    FURI_LOG_T(TAG, "Dir %p - %p closed", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE);
+    FURI_LOG_T(
+        TAG,
+        "Dir %p - %p closed",
+        (void*)((uint32_t)file - SRAM_BASE),
+        (void*)(file->file_id - SRAM_BASE));
 
     file->type = FileTypeClosed;
 
@@ -675,7 +691,7 @@ File* storage_file_alloc(Storage* storage) {
     file->type = FileTypeClosed;
     file->storage = storage;
 
-    FURI_LOG_T(TAG, "File/Dir %p alloc", (uint32_t)file - SRAM_BASE);
+    FURI_LOG_T(TAG, "File/Dir %p alloc", (void*)((uint32_t)file - SRAM_BASE));
 
     return file;
 }
@@ -697,7 +713,7 @@ void storage_file_free(File* file) {
         }
     }
 
-    FURI_LOG_T(TAG, "File/Dir %p free", (uint32_t)file - SRAM_BASE);
+    FURI_LOG_T(TAG, "File/Dir %p free", (void*)((uint32_t)file - SRAM_BASE));
     free(file);
 }
 
diff --git a/applications/services/storage/storages/storage_int.c b/applications/services/storage/storages/storage_int.c
index ab0255014..4fa5d130c 100644
--- a/applications/services/storage/storages/storage_int.c
+++ b/applications/services/storage/storages/storage_int.c
@@ -77,12 +77,12 @@ static int storage_int_device_read(
 
     FURI_LOG_T(
         TAG,
-        "Device read: block %d, off %d, buffer: %p, size %d, translated address: %p",
+        "Device read: block %ld, off %ld, buffer: %p, size %ld, translated address: %p",
         block,
         off,
         buffer,
         size,
-        address);
+        (void*)address);
 
     memcpy(buffer, (void*)address, size);
 
@@ -100,12 +100,12 @@ static int storage_int_device_prog(
 
     FURI_LOG_T(
         TAG,
-        "Device prog: block %d, off %d, buffer: %p, size %d, translated address: %p",
+        "Device prog: block %ld, off %ld, buffer: %p, size %ld, translated address: %p",
         block,
         off,
         buffer,
         size,
-        address);
+        (void*)address);
 
     int ret = 0;
     while(size > 0) {
@@ -122,7 +122,7 @@ static int storage_int_device_erase(const struct lfs_config* c, lfs_block_t bloc
     LFSData* lfs_data = c->context;
     size_t page = lfs_data->start_page + block;
 
-    FURI_LOG_D(TAG, "Device erase: page %d, translated page: %x", block, page);
+    FURI_LOG_D(TAG, "Device erase: page %ld, translated page: %x", block, page);
 
     furi_hal_flash_erase(page);
     return 0;
@@ -740,8 +740,8 @@ void storage_int_init(StorageData* storage) {
     LFSData* lfs_data = storage_int_lfs_data_alloc();
     FURI_LOG_I(
         TAG,
-        "Config: start %p, read %d, write %d, page size: %d, page count: %d, cycles: %d",
-        lfs_data->start_address,
+        "Config: start %p, read %ld, write %ld, page size: %ld, page count: %ld, cycles: %ld",
+        (void*)lfs_data->start_address,
         lfs_data->config.read_size,
         lfs_data->config.prog_size,
         lfs_data->config.block_size,
diff --git a/applications/settings/power_settings_app/views/battery_info.c b/applications/settings/power_settings_app/views/battery_info.c
index aa3a1e962..1a8bc71ec 100644
--- a/applications/settings/power_settings_app/views/battery_info.c
+++ b/applications/settings/power_settings_app/views/battery_info.c
@@ -119,8 +119,8 @@ void battery_info_set_data(BatteryInfo* battery_info, BatteryInfoModel* data) {
     furi_assert(battery_info);
     furi_assert(data);
     with_view_model(
-        battery_info->view, (BatteryInfoModel * model) {
-            memcpy(model, data, sizeof(BatteryInfoModel));
-            return true;
-        });
+        battery_info->view,
+        BatteryInfoModel * model,
+        { memcpy(model, data, sizeof(BatteryInfoModel)); },
+        true);
 }
diff --git a/applications/settings/storage_settings/scenes/storage_settings_scene_internal_info.c b/applications/settings/storage_settings/scenes/storage_settings_scene_internal_info.c
index d2d4ecd8a..f205efc0a 100644
--- a/applications/settings/storage_settings/scenes/storage_settings_scene_internal_info.c
+++ b/applications/settings/storage_settings/scenes/storage_settings_scene_internal_info.c
@@ -27,7 +27,7 @@ void storage_settings_scene_internal_info_on_enter(void* context) {
     } else {
         furi_string_printf(
             app->text_string,
-            "Label: %s\nType: LittleFS\n%lu KB total\n%lu KB free",
+            "Label: %s\nType: LittleFS\n%lu KiB total\n%lu KiB free",
             furi_hal_version_get_name_ptr() ? furi_hal_version_get_name_ptr() : "Unknown",
             (uint32_t)(total_space / 1024),
             (uint32_t)(free_space / 1024));
diff --git a/applications/settings/storage_settings/scenes/storage_settings_scene_sd_info.c b/applications/settings/storage_settings/scenes/storage_settings_scene_sd_info.c
index f5d286c7f..ede610d0e 100644
--- a/applications/settings/storage_settings/scenes/storage_settings_scene_sd_info.c
+++ b/applications/settings/storage_settings/scenes/storage_settings_scene_sd_info.c
@@ -26,7 +26,7 @@ void storage_settings_scene_sd_info_on_enter(void* context) {
     } else {
         furi_string_printf(
             app->text_string,
-            "Label: %s\nType: %s\n%lu KB total\n%lu KB free",
+            "Label: %s\nType: %s\n%lu KiB total\n%lu KiB free",
             sd_info.label,
             sd_api_get_fs_type_text(sd_info.fs_type),
             sd_info.kb_total,
diff --git a/applications/system/updater/util/update_task_worker_flasher.c b/applications/system/updater/util/update_task_worker_flasher.c
index b235d0018..7358a6334 100644
--- a/applications/system/updater/util/update_task_worker_flasher.c
+++ b/applications/system/updater/util/update_task_worker_flasher.c
@@ -271,7 +271,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
             match = false;
             FURI_LOG_E(
                 TAG,
-                "OB MISMATCH: #%d: real %08X != %08X (exp.), full %08X",
+                "OB MISMATCH: #%d: real %08lX != %08lX (exp.), full %08lX",
                 idx,
                 device_ob_value_masked,
                 ref_value,
@@ -289,7 +289,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
                     (manifest->ob_reference.obs[idx].values.base &
                      manifest->ob_write_mask.obs[idx].values.base);
 
-                FURI_LOG_W(TAG, "Fixing up OB byte #%d to %08X", idx, patched_value);
+                FURI_LOG_W(TAG, "Fixing up OB byte #%d to %08lX", idx, patched_value);
                 ob_dirty = true;
 
                 bool is_fixed = furi_hal_flash_ob_set_word(idx, patched_value) &&
@@ -301,7 +301,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
                      * reference value */
                     FURI_LOG_W(
                         TAG,
-                        "OB #%d is FUBAR (fixed&masked %08X, not %08X)",
+                        "OB #%d is FUBAR (fixed&masked %08lX, not %08lX)",
                         idx,
                         patched_value,
                         ref_value);
@@ -310,7 +310,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
         } else {
             FURI_LOG_D(
                 TAG,
-                "OB MATCH: #%d: real %08X == %08X (exp.)",
+                "OB MATCH: #%d: real %08lX == %08lX (exp.)",
                 idx,
                 device_ob_value_masked,
                 ref_value);
diff --git a/applications/system/updater/views/updater_main.c b/applications/system/updater/views/updater_main.c
index 8d6694d89..5ed3c70aa 100644
--- a/applications/system/updater/views/updater_main.c
+++ b/applications/system/updater/views/updater_main.c
@@ -28,22 +28,25 @@ void updater_main_model_set_state(
     const char* message,
     uint8_t progress,
     bool failed) {
+    bool update = false;
     with_view_model(
-        main_view->view, (UpdaterProgressModel * model) {
+        main_view->view,
+        UpdaterProgressModel * model,
+        {
             model->failed = failed;
             model->progress = progress;
             if(furi_string_cmp_str(model->status, message)) {
                 furi_string_set(model->status, message);
                 model->rendered_progress = progress;
-                return true;
-            }
-            if((model->rendered_progress > progress) ||
-               ((progress - model->rendered_progress) > PROGRESS_RENDER_STEP)) {
+                update = true;
+            } else if(
+                (model->rendered_progress > progress) ||
+                ((progress - model->rendered_progress) > PROGRESS_RENDER_STEP)) {
                 model->rendered_progress = progress;
-                return true;
+                update = true;
             }
-            return false;
-        });
+        },
+        update);
 }
 
 View* updater_main_get_view(UpdaterMainView* main_view) {
@@ -104,10 +107,10 @@ UpdaterMainView* updater_main_alloc() {
     view_allocate_model(main_view->view, ViewModelTypeLocking, sizeof(UpdaterProgressModel));
 
     with_view_model(
-        main_view->view, (UpdaterProgressModel * model) {
-            model->status = furi_string_alloc_set("Waiting for SD card");
-            return true;
-        });
+        main_view->view,
+        UpdaterProgressModel * model,
+        { model->status = furi_string_alloc_set("Waiting for SD card"); },
+        true);
 
     view_set_context(main_view->view, main_view);
     view_set_input_callback(main_view->view, updater_main_input);
@@ -119,10 +122,7 @@ UpdaterMainView* updater_main_alloc() {
 void updater_main_free(UpdaterMainView* main_view) {
     furi_assert(main_view);
     with_view_model(
-        main_view->view, (UpdaterProgressModel * model) {
-            furi_string_free(model->status);
-            return false;
-        });
+        main_view->view, UpdaterProgressModel * model, { furi_string_free(model->status); }, false);
     view_free(main_view->view);
     free(main_view);
 }
diff --git a/assets/icons/Interface/SmallArrowDown_3x5.png b/assets/icons/Interface/SmallArrowDown_3x5.png
new file mode 100644
index 000000000..1912e5d24
Binary files /dev/null and b/assets/icons/Interface/SmallArrowDown_3x5.png differ
diff --git a/assets/icons/Interface/SmallArrowUp_3x5.png b/assets/icons/Interface/SmallArrowUp_3x5.png
new file mode 100644
index 000000000..9c6242078
Binary files /dev/null and b/assets/icons/Interface/SmallArrowUp_3x5.png differ
diff --git a/documentation/AppManifests.md b/documentation/AppManifests.md
index 14c0ae3ac..4fec9d22c 100644
--- a/documentation/AppManifests.md
+++ b/documentation/AppManifests.md
@@ -47,7 +47,7 @@ Only 2 parameters are mandatory: ***appid*** and ***apptype***, others are optio
 The following parameters are used only for [FAPs](./AppsOnSDCard.md):
 
 * **sources**: list of strings, file name masks, used for gathering sources within app folder. Default value of `["*.c*"]` includes C and C++ source files. Application cannot use `"lib"` folder for their own source code, as it is reserved for **fap_private_libs**.
-* **fap_version**: tuple, 2 numbers in form of (x,y): application version to be embedded within .fap file. Default value is (0,1), meanig version "0.1".
+* **fap_version**: tuple, 2 numbers in form of (x,y): application version to be embedded within .fap file. Default value is (0,1), meaning version "0.1".
 * **fap_icon**: name of a .png file, 1-bit color depth, 10x10px, to be embedded within .fap file.
 * **fap_libs**: list of extra libraries to link application against. Provides access to extra functions that are not exported as a part of main firmware at expense of increased .fap file size and RAM consumption.
 * **fap_category**: string, may be empty. App subcategory, also works as path of FAP within apps folder in the file system.
diff --git a/documentation/AppsOnSDCard.md b/documentation/AppsOnSDCard.md
index 552be13e4..aff8314dc 100644
--- a/documentation/AppsOnSDCard.md
+++ b/documentation/AppsOnSDCard.md
@@ -13,7 +13,7 @@ FAPs are created and developed the same way as internal applications that are pa
 
 To build your application as a FAP, just create a folder with your app's source code in `applications_user`, then write its code the way you'd do when creating a regular built-in application. Then configure its `application.fam` manifest — and set its *apptype* to FlipperAppType.EXTERNAL. See [Application Manifests](./AppManifests.md#application-definition) for more details. 
 
- * To build your application, run `./fbt firmware_{APPID}`, where APPID is your application's ID in its manifest.
+ * To build your application, run `./fbt fap_{APPID}`, where APPID is your application's ID in its manifest.
  * To build your app, then upload it over USB & run it on Flipper, use `./fbt launch_app APPSRC=applications/path/to/app`. This command is configured in default [VSCode profile](../.vscode/ReadMe.md) as "Launch App on Flipper" build action (Ctrl+Shift+B menu).
  * To build all FAPs, run `./fbt plugin_dist`.
 
diff --git a/firmware/targets/f7/api_symbols.csv b/firmware/targets/f7/api_symbols.csv
index 4e1704d06..c9e2371f4 100644
--- a/firmware/targets/f7/api_symbols.csv
+++ b/firmware/targets/f7/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,2.0,,
+Version,+,2.2,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -1342,6 +1342,16 @@ Function,+,furi_semaphore_alloc,FuriSemaphore*,"uint32_t, uint32_t"
 Function,+,furi_semaphore_free,void,FuriSemaphore*
 Function,+,furi_semaphore_get_count,uint32_t,FuriSemaphore*
 Function,+,furi_semaphore_release,FuriStatus,FuriSemaphore*
+Function,+,furi_stream_buffer_alloc,FuriStreamBuffer*,"size_t, size_t"
+Function,+,furi_stream_buffer_bytes_available,size_t,FuriStreamBuffer*
+Function,+,furi_stream_buffer_free,void,FuriStreamBuffer*
+Function,+,furi_stream_buffer_is_empty,_Bool,FuriStreamBuffer*
+Function,+,furi_stream_buffer_is_full,_Bool,FuriStreamBuffer*
+Function,+,furi_stream_buffer_receive,size_t,"FuriStreamBuffer*, void*, size_t, uint32_t"
+Function,+,furi_stream_buffer_reset,FuriStatus,FuriStreamBuffer*
+Function,+,furi_stream_buffer_send,size_t,"FuriStreamBuffer*, const void*, size_t, uint32_t"
+Function,+,furi_stream_buffer_spaces_available,size_t,FuriStreamBuffer*
+Function,+,furi_stream_set_trigger_level,_Bool,"FuriStreamBuffer*, size_t"
 Function,+,furi_string_alloc,FuriString*,
 Function,+,furi_string_alloc_move,FuriString*,FuriString*
 Function,+,furi_string_alloc_printf,FuriString*,"const char[], ..."
@@ -2729,7 +2739,9 @@ Variable,+,I_SDQuestion_35x43,const Icon,
 Variable,+,I_SDcardFail_11x8,const Icon,
 Variable,+,I_SDcardMounted_11x8,const Icon,
 Variable,+,I_Scanning_123x52,const Icon,
+Variable,+,I_SmallArrowDown_3x5,const Icon,
 Variable,+,I_SmallArrowDown_4x7,const Icon,
+Variable,+,I_SmallArrowUp_3x5,const Icon,
 Variable,+,I_SmallArrowUp_4x7,const Icon,
 Variable,+,I_Smile_18x18,const Icon,
 Variable,+,I_Space_65x18,const Icon,
diff --git a/firmware/targets/f7/ble_glue/gap.c b/firmware/targets/f7/ble_glue/gap.c
index 62db30fee..aa8cd2c90 100644
--- a/firmware/targets/f7/ble_glue/gap.c
+++ b/firmware/targets/f7/ble_glue/gap.c
@@ -184,7 +184,7 @@ SVCCTL_UserEvtFlowStatus_t SVCCTL_App_Notification(void* pckt) {
             if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
                 FURI_LOG_I(TAG, "Pass key request event. Pin: ******");
             } else {
-                FURI_LOG_I(TAG, "Pass key request event. Pin: %06d", pin);
+                FURI_LOG_I(TAG, "Pass key request event. Pin: %06ld", pin);
             }
             GapEvent event = {.type = GapEventTypePinCodeShow, .data.pin_code = pin};
             gap->on_event_cb(event, gap->context);
@@ -227,7 +227,7 @@ SVCCTL_UserEvtFlowStatus_t SVCCTL_App_Notification(void* pckt) {
         case EVT_BLUE_GAP_NUMERIC_COMPARISON_VALUE: {
             uint32_t pin =
                 ((aci_gap_numeric_comparison_value_event_rp0*)(blue_evt->data))->Numeric_Value;
-            FURI_LOG_I(TAG, "Verify numeric comparison: %06d", pin);
+            FURI_LOG_I(TAG, "Verify numeric comparison: %06ld", pin);
             GapEvent event = {.type = GapEventTypePinCodeVerify, .data.pin_code = pin};
             bool result = gap->on_event_cb(event, gap->context);
             aci_gap_numeric_comparison_value_confirm_yesno(gap->service.connection_handle, result);
diff --git a/firmware/targets/f7/ble_glue/serial_service.c b/firmware/targets/f7/ble_glue/serial_service.c
index eb58ae0ec..536557cce 100644
--- a/firmware/targets/f7/ble_glue/serial_service.c
+++ b/firmware/targets/f7/ble_glue/serial_service.c
@@ -63,13 +63,13 @@ static SVCCTL_EvtAckStatus_t serial_svc_event_handler(void* event) {
                             .size = attribute_modified->Attr_Data_Length,
                         }};
                     uint32_t buff_free_size = serial_svc->callback(event, serial_svc->context);
-                    FURI_LOG_D(TAG, "Available buff size: %d", buff_free_size);
+                    FURI_LOG_D(TAG, "Available buff size: %ld", buff_free_size);
                     furi_check(furi_mutex_release(serial_svc->buff_size_mtx) == FuriStatusOk);
                 }
                 ret = SVCCTL_EvtAckFlowEnable;
             }
         } else if(blecore_evt->ecode == ACI_GATT_SERVER_CONFIRMATION_VSEVT_CODE) {
-            FURI_LOG_T(TAG, "Ack received", blecore_evt->ecode);
+            FURI_LOG_T(TAG, "Ack received");
             if(serial_svc->callback) {
                 SerialServiceEvent event = {
                     .event = SerialServiceEventTypeDataSent,
diff --git a/firmware/targets/f7/furi_hal/furi_hal_console.h b/firmware/targets/f7/furi_hal/furi_hal_console.h
index 104515ce9..ce31a66b3 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_console.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_console.h
@@ -2,6 +2,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,7 +28,7 @@ void furi_hal_console_tx_with_new_line(const uint8_t* buffer, size_t buffer_size
  * @param format 
  * @param ... 
  */
-void furi_hal_console_printf(const char format[], ...);
+void furi_hal_console_printf(const char format[], ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
 
 void furi_hal_console_puts(const char* data);
 
diff --git a/firmware/targets/f7/furi_hal/furi_hal_flash.c b/firmware/targets/f7/furi_hal/furi_hal_flash.c
index f99cf8c3d..e49cd5f29 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_flash.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_flash.c
@@ -83,7 +83,7 @@ void furi_hal_flash_init() {
     // WRITE_REG(FLASH->SR, FLASH_SR_OPTVERR);
     /* Actually, reset all error flags on start */
     if(READ_BIT(FLASH->SR, FURI_HAL_FLASH_SR_ERRORS)) {
-        FURI_LOG_E(TAG, "FLASH->SR 0x%08X", FLASH->SR);
+        FURI_LOG_E(TAG, "FLASH->SR 0x%08lX", FLASH->SR);
         WRITE_REG(FLASH->SR, FURI_HAL_FLASH_SR_ERRORS);
     }
 }
@@ -514,10 +514,10 @@ bool furi_hal_flash_ob_set_word(size_t word_idx, const uint32_t value) {
 
     FURI_LOG_W(
         TAG,
-        "Setting OB reg %d for word %d (addr 0x%08X) to 0x%08X",
+        "Setting OB reg %d for word %d (addr 0x%08lX) to 0x%08lX",
         reg_def->ob_reg,
         word_idx,
-        reg_def->ob_register_address,
+        (uint32_t)reg_def->ob_register_address,
         value);
 
     /* 1. Clear OPTLOCK option lock bit with the clearing sequence */
diff --git a/firmware/targets/f7/furi_hal/furi_hal_memory.c b/firmware/targets/f7/furi_hal/furi_hal_memory.c
index 43dc56f11..9cf2c3120 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_memory.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_memory.c
@@ -55,9 +55,9 @@ void furi_hal_memory_init() {
         memory->region[SRAM_B].size = sram2b_unprotected_size;
 
         FURI_LOG_I(
-            TAG, "SRAM2A: 0x%p, %d", memory->region[SRAM_A].start, memory->region[SRAM_A].size);
+            TAG, "SRAM2A: 0x%p, %ld", memory->region[SRAM_A].start, memory->region[SRAM_A].size);
         FURI_LOG_I(
-            TAG, "SRAM2B: 0x%p, %d", memory->region[SRAM_B].start, memory->region[SRAM_B].size);
+            TAG, "SRAM2B: 0x%p, %ld", memory->region[SRAM_B].start, memory->region[SRAM_B].size);
 
         if((memory->region[SRAM_A].size > 0) || (memory->region[SRAM_B].size > 0)) {
             if((memory->region[SRAM_A].size > 0)) {
diff --git a/firmware/targets/f7/furi_hal/furi_hal_power.c b/firmware/targets/f7/furi_hal/furi_hal_power.c
index bc98f108d..86505c573 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_power.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_power.c
@@ -569,13 +569,13 @@ void furi_hal_power_info_get(FuriHalPowerInfoCallback out, void* context) {
     furi_string_printf(value, "%u", furi_hal_power_get_bat_health_pct());
     out("battery_health", furi_string_get_cstr(value), false, context);
 
-    furi_string_printf(value, "%u", furi_hal_power_get_battery_remaining_capacity());
+    furi_string_printf(value, "%lu", furi_hal_power_get_battery_remaining_capacity());
     out("capacity_remain", furi_string_get_cstr(value), false, context);
 
-    furi_string_printf(value, "%u", furi_hal_power_get_battery_full_capacity());
+    furi_string_printf(value, "%lu", furi_hal_power_get_battery_full_capacity());
     out("capacity_full", furi_string_get_cstr(value), false, context);
 
-    furi_string_printf(value, "%u", furi_hal_power_get_battery_design_capacity());
+    furi_string_printf(value, "%lu", furi_hal_power_get_battery_design_capacity());
     out("capacity_design", furi_string_get_cstr(value), true, context);
 
     furi_string_free(value);
diff --git a/firmware/targets/f7/furi_hal/furi_hal_subghz.c b/firmware/targets/f7/furi_hal/furi_hal_subghz.c
index b73d074fd..5eeb4e9a5 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_subghz.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_subghz.c
@@ -173,7 +173,7 @@ void furi_hal_subghz_load_custom_preset(uint8_t* preset_data) {
             i += 2;
         }
         for(uint8_t y = i; y < i + 10; y++) {
-            FURI_LOG_D(TAG, "PA[%lu]:  %02X", y, preset_data[y]);
+            FURI_LOG_D(TAG, "PA[%u]:  %02X", y, preset_data[y]);
         }
     }
 }
diff --git a/furi/core/log.h b/furi/core/log.h
index 30026fc44..cb8b3d9cc 100644
--- a/furi/core/log.h
+++ b/furi/core/log.h
@@ -51,7 +51,8 @@ void furi_log_init();
  * @param format 
  * @param ... 
  */
-void furi_log_print_format(FuriLogLevel level, const char* tag, const char* format, ...);
+void furi_log_print_format(FuriLogLevel level, const char* tag, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 3, 4)));
 
 /** Set log level
  *
diff --git a/furi/core/stream_buffer.c b/furi/core/stream_buffer.c
new file mode 100644
index 000000000..b9d0629fe
--- /dev/null
+++ b/furi/core/stream_buffer.c
@@ -0,0 +1,77 @@
+#include "base.h"
+#include "stream_buffer.h"
+#include "common_defines.h"
+#include <FreeRTOS.h>
+#include <FreeRTOS-Kernel/include/stream_buffer.h>
+
+FuriStreamBuffer* furi_stream_buffer_alloc(size_t size, size_t trigger_level) {
+    return xStreamBufferCreate(size, trigger_level);
+};
+
+void furi_stream_buffer_free(FuriStreamBuffer* stream_buffer) {
+    vStreamBufferDelete(stream_buffer);
+};
+
+bool furi_stream_set_trigger_level(FuriStreamBuffer* stream_buffer, size_t trigger_level) {
+    return xStreamBufferSetTriggerLevel(stream_buffer, trigger_level) == pdTRUE;
+};
+
+size_t furi_stream_buffer_send(
+    FuriStreamBuffer* stream_buffer,
+    const void* data,
+    size_t length,
+    uint32_t timeout) {
+    size_t ret;
+
+    if(FURI_IS_IRQ_MODE() != 0U) {
+        BaseType_t yield;
+        ret = xStreamBufferSendFromISR(stream_buffer, data, length, &yield);
+        portYIELD_FROM_ISR(yield);
+    } else {
+        ret = xStreamBufferSend(stream_buffer, data, length, timeout);
+    }
+
+    return ret;
+};
+
+size_t furi_stream_buffer_receive(
+    FuriStreamBuffer* stream_buffer,
+    void* data,
+    size_t length,
+    uint32_t timeout) {
+    size_t ret;
+
+    if(FURI_IS_IRQ_MODE() != 0U) {
+        BaseType_t yield;
+        ret = xStreamBufferReceiveFromISR(stream_buffer, data, length, &yield);
+        portYIELD_FROM_ISR(yield);
+    } else {
+        ret = xStreamBufferReceive(stream_buffer, data, length, timeout);
+    }
+
+    return ret;
+}
+
+size_t furi_stream_buffer_bytes_available(FuriStreamBuffer* stream_buffer) {
+    return xStreamBufferBytesAvailable(stream_buffer);
+};
+
+size_t furi_stream_buffer_spaces_available(FuriStreamBuffer* stream_buffer) {
+    return xStreamBufferSpacesAvailable(stream_buffer);
+};
+
+bool furi_stream_buffer_is_full(FuriStreamBuffer* stream_buffer) {
+    return xStreamBufferIsFull(stream_buffer) == pdTRUE;
+};
+
+bool furi_stream_buffer_is_empty(FuriStreamBuffer* stream_buffer) {
+    return (xStreamBufferIsEmpty(stream_buffer) == pdTRUE);
+};
+
+FuriStatus furi_stream_buffer_reset(FuriStreamBuffer* stream_buffer) {
+    if(xStreamBufferReset(stream_buffer) == pdPASS) {
+        return FuriStatusOk;
+    } else {
+        return FuriStatusError;
+    }
+}
\ No newline at end of file
diff --git a/furi/core/stream_buffer.h b/furi/core/stream_buffer.h
new file mode 100644
index 000000000..d07f7e60b
--- /dev/null
+++ b/furi/core/stream_buffer.h
@@ -0,0 +1,152 @@
+/**
+ * @file stream_buffer.h
+ * Furi stream buffer primitive.
+ * 
+ * Stream buffers are used to send a continuous stream of data from one task or
+ * interrupt to another.  Their implementation is light weight, making them
+ * particularly suited for interrupt to task and core to core communication
+ * scenarios.
+ * 
+ * ***NOTE***: Stream buffer implementation assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).
+ */
+#pragma once
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void FuriStreamBuffer;
+
+/**
+ * @brief Allocate stream buffer instance.
+ * Stream buffer implementation assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).
+ * 
+ * @param size The total number of bytes the stream buffer will be able to hold at any one time.
+ * @param trigger_level The number of bytes that must be in the stream buffer 
+ * before a task that is blocked on the stream buffer to wait for data is moved out of the blocked state.
+ * @return The stream buffer instance.
+ */
+FuriStreamBuffer* furi_stream_buffer_alloc(size_t size, size_t trigger_level);
+
+/**
+ * @brief Free stream buffer instance
+ * 
+ * @param stream_buffer The stream buffer instance.
+ */
+void furi_stream_buffer_free(FuriStreamBuffer* stream_buffer);
+
+/**
+ * @brief Set trigger level for stream buffer.
+ * A stream buffer's trigger level is the number of bytes that must be in the
+ * stream buffer before a task that is blocked on the stream buffer to
+ * wait for data is moved out of the blocked state.
+ * 
+ * @param stream_buffer The stream buffer instance
+ * @param trigger_level The new trigger level for the stream buffer.
+ * @return true if trigger level can be be updated (new trigger level was less than or equal to the stream buffer's length). 
+ * @return false if trigger level can't be be updated (new trigger level was greater than the stream buffer's length).
+ */
+bool furi_stream_set_trigger_level(FuriStreamBuffer* stream_buffer, size_t trigger_level);
+
+/**
+ * @brief Sends bytes to a stream buffer. The bytes are copied into the stream buffer.
+ * Wakes up task waiting for data to become available if called from ISR.
+ * 
+ * @param stream_buffer The stream buffer instance.
+ * @param data A pointer to the data that is to be copied into the stream buffer.
+ * @param length The maximum number of bytes to copy from data into the stream buffer.
+ * @param timeout The maximum amount of time the task should remain in the
+ * Blocked state to wait for space to become available if the stream buffer is full. 
+ * Will return immediately if timeout is zero. 
+ * Setting timeout to FuriWaitForever will cause the task to wait indefinitely.
+ * Ignored if called from ISR.
+ * @return The number of bytes actually written to the stream buffer. 
+ */
+size_t furi_stream_buffer_send(
+    FuriStreamBuffer* stream_buffer,
+    const void* data,
+    size_t length,
+    uint32_t timeout);
+
+/**
+ * @brief Receives bytes from a stream buffer.
+ * Wakes up task waiting for space to become available if called from ISR.
+ * 
+ * @param stream_buffer The stream buffer instance.
+ * @param data A pointer to the buffer into which the received bytes will be
+ * copied.
+ * @param length The length of the buffer pointed to by the data parameter.
+ * @param timeout The maximum amount of time the task should remain in the
+ * Blocked state to wait for data to become available if the stream buffer is empty. 
+ * Will return immediately if timeout is zero. 
+ * Setting timeout to FuriWaitForever will cause the task to wait indefinitely.
+ * Ignored if called from ISR.
+ * @return The number of bytes read from the stream buffer, if any. 
+ */
+size_t furi_stream_buffer_receive(
+    FuriStreamBuffer* stream_buffer,
+    void* data,
+    size_t length,
+    uint32_t timeout);
+
+/**
+ * @brief Queries a stream buffer to see how much data it contains, which is equal to
+ * the number of bytes that can be read from the stream buffer before the stream
+ * buffer would be empty.
+ * 
+ * @param stream_buffer The stream buffer instance.
+ * @return The number of bytes that can be read from the stream buffer before
+ * the stream buffer would be empty.
+ */
+size_t furi_stream_buffer_bytes_available(FuriStreamBuffer* stream_buffer);
+
+/**
+ * @brief Queries a stream buffer to see how much free space it contains, which is
+ * equal to the amount of data that can be sent to the stream buffer before it
+ * is full.
+ * 
+ * @param stream_buffer The stream buffer instance.
+ * @return The number of bytes that can be written to the stream buffer before
+ * the stream buffer would be full. 
+ */
+size_t furi_stream_buffer_spaces_available(FuriStreamBuffer* stream_buffer);
+
+/**
+ * @brief Queries a stream buffer to see if it is full.
+ * 
+ * @param stream_buffer stream buffer instance.
+ * @return true if the stream buffer is full.
+ * @return false if the stream buffer is not full.
+ */
+bool furi_stream_buffer_is_full(FuriStreamBuffer* stream_buffer);
+
+/**
+ * @brief Queries a stream buffer to see if it is empty.
+ * 
+ * @param stream_buffer The stream buffer instance.
+ * @return true if the stream buffer is empty.
+ * @return false if the stream buffer is not empty.
+ */
+bool furi_stream_buffer_is_empty(FuriStreamBuffer* stream_buffer);
+
+/**
+ * @brief Resets a stream buffer to its initial, empty, state. Any data that was 
+ * in the stream buffer is discarded. A stream buffer can only be reset if there 
+ * are no tasks blocked waiting to either send to or receive from the stream buffer.
+ * 
+ * @param stream_buffer The stream buffer instance.
+ * @return FuriStatusOk if the stream buffer is reset. 
+ * @return FuriStatusError if there was a task blocked waiting to send to or read 
+ * from the stream buffer then the stream buffer is not reset.
+ */
+FuriStatus furi_stream_buffer_reset(FuriStreamBuffer* stream_buffer);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/furi/core/string.h b/furi/core/string.h
index b6700c9ca..01b26cce1 100644
--- a/furi/core/string.h
+++ b/furi/core/string.h
@@ -57,7 +57,8 @@ FuriString* furi_string_alloc_set_str(const char cstr_source[]);
  * @param ... 
  * @return FuriString* 
  */
-FuriString* furi_string_alloc_printf(const char format[], ...);
+FuriString* furi_string_alloc_printf(const char format[], ...)
+    _ATTRIBUTE((__format__(__printf__, 1, 2)));
 
 /**
  * @brief Allocate new FuriString and printf to it.
@@ -214,7 +215,8 @@ void furi_string_set_n(FuriString* string, const FuriString* source, size_t offs
  * @param ... 
  * @return int 
  */
-int furi_string_printf(FuriString* string, const char format[], ...);
+int furi_string_printf(FuriString* string, const char format[], ...)
+    _ATTRIBUTE((__format__(__printf__, 2, 3)));
 
 /**
  * @brief Format in the string the given printf format
@@ -259,7 +261,8 @@ void furi_string_cat_str(FuriString* string_1, const char cstring_2[]);
  * @param ... 
  * @return int 
  */
-int furi_string_cat_printf(FuriString* string, const char format[], ...);
+int furi_string_cat_printf(FuriString* string, const char format[], ...)
+    _ATTRIBUTE((__format__(__printf__, 2, 3)));
 
 /**
  * @brief Append to the string the formatted string of the given printf format.
diff --git a/furi/core/thread.c b/furi/core/thread.c
index 3ebca807e..508146f63 100644
--- a/furi/core/thread.c
+++ b/furi/core/thread.c
@@ -103,6 +103,7 @@ static void furi_thread_body(void* context) {
     furi_assert(pvTaskGetThreadLocalStoragePointer(NULL, 0) != NULL);
     vTaskSetThreadLocalStoragePointer(NULL, 0, NULL);
 
+    thread->task_handle = NULL;
     vTaskDelete(NULL);
     furi_thread_catch();
 }
@@ -211,13 +212,8 @@ bool furi_thread_join(FuriThread* thread) {
 
     furi_check(furi_thread_get_current() != thread);
 
-    // Check if thread was started
-    if(thread->task_handle == NULL) {
-        return false;
-    }
-
     // Wait for thread to stop
-    while(eTaskGetState(thread->task_handle) != eDeleted) {
+    while(thread->task_handle) {
         furi_delay_ms(10);
     }
 
diff --git a/furi/furi.h b/furi/furi.h
index 306c9b949..3ce834227 100644
--- a/furi/furi.h
+++ b/furi/furi.h
@@ -2,22 +2,23 @@
 
 #include <stdlib.h>
 
-#include <core/check.h>
-#include <core/common_defines.h>
-#include <core/event_flag.h>
-#include <core/kernel.h>
-#include <core/log.h>
-#include <core/memmgr.h>
-#include <core/memmgr_heap.h>
-#include <core/message_queue.h>
-#include <core/mutex.h>
-#include <core/pubsub.h>
-#include <core/record.h>
-#include <core/semaphore.h>
-#include <core/thread.h>
-#include <core/timer.h>
-#include <core/valuemutex.h>
-#include <core/string.h>
+#include "core/check.h"
+#include "core/common_defines.h"
+#include "core/event_flag.h"
+#include "core/kernel.h"
+#include "core/log.h"
+#include "core/memmgr.h"
+#include "core/memmgr_heap.h"
+#include "core/message_queue.h"
+#include "core/mutex.h"
+#include "core/pubsub.h"
+#include "core/record.h"
+#include "core/semaphore.h"
+#include "core/thread.h"
+#include "core/timer.h"
+#include "core/valuemutex.h"
+#include "core/string.h"
+#include "core/stream_buffer.h"
 
 #include <furi_hal_gpio.h>
 
diff --git a/lib/flipper_application/elf/elf_file.c b/lib/flipper_application/elf/elf_file.c
index b66e27d9a..3fe57162f 100644
--- a/lib/flipper_application/elf/elf_file.c
+++ b/lib/flipper_application/elf/elf_file.c
@@ -57,8 +57,23 @@ static ELFSection* elf_file_get_section(ELFFile* elf, const char* name) {
     return ELFSectionDict_get(elf->sections, name);
 }
 
-static void elf_file_put_section(ELFFile* elf, const char* name, ELFSection* section) {
-    ELFSectionDict_set_at(elf->sections, strdup(name), *section);
+static ELFSection* elf_file_get_or_put_section(ELFFile* elf, const char* name) {
+    ELFSection* section_p = elf_file_get_section(elf, name);
+    if(!section_p) {
+        ELFSectionDict_set_at(
+            elf->sections,
+            strdup(name),
+            (ELFSection){
+                .data = NULL,
+                .sec_idx = 0,
+                .size = 0,
+                .rel_count = 0,
+                .rel_offset = 0,
+            });
+        section_p = elf_file_get_section(elf, name);
+    }
+
+    return section_p;
 }
 
 static bool elf_read_string_from_offset(ELFFile* elf, off_t offset, FuriString* name) {
@@ -320,12 +335,12 @@ static bool elf_relocate_symbol(ELFFile* elf, Elf32_Addr relAddr, int type, Elf3
     return true;
 }
 
-static bool elf_relocate(ELFFile* elf, Elf32_Shdr* h, ELFSection* s) {
+static bool elf_relocate(ELFFile* elf, ELFSection* s) {
     if(s->data) {
         Elf32_Rel rel;
-        size_t relEntries = h->sh_size / sizeof(rel);
+        size_t relEntries = s->rel_count;
         size_t relCount;
-        (void)storage_file_seek(elf->fd, h->sh_offset, true);
+        (void)storage_file_seek(elf->fd, s->rel_offset, true);
         FURI_LOG_D(TAG, " Offset   Info     Type             Name");
 
         int relocate_result = true;
@@ -395,14 +410,6 @@ static bool elf_relocate(ELFFile* elf, Elf32_Shdr* h, ELFSection* s) {
     return false;
 }
 
-/**************************************************************************************************/
-/********************************************* MISC ***********************************************/
-/**************************************************************************************************/
-
-static bool cstr_prefix(const char* prefix, const char* string) {
-    return strncmp(prefix, string, strlen(prefix)) == 0;
-}
-
 /**************************************************************************************************/
 /************************************ Internal FAP interfaces *************************************/
 /**************************************************************************************************/
@@ -445,6 +452,35 @@ static bool elf_load_debug_link(ELFFile* elf, Elf32_Shdr* section_header) {
                section_header->sh_size;
 }
 
+static bool str_prefix(const char* str, const char* prefix) {
+    return strncmp(prefix, str, strlen(prefix)) == 0;
+}
+
+static bool elf_load_section_data(ELFFile* elf, ELFSection* section, Elf32_Shdr* section_header) {
+    if(section_header->sh_size == 0) {
+        FURI_LOG_D(TAG, "No data for section");
+        return true;
+    }
+
+    section->data = aligned_malloc(section_header->sh_size, section_header->sh_addralign);
+    section->size = section_header->sh_size;
+
+    if(section_header->sh_type == SHT_NOBITS) {
+        // BSS section, no data to load
+        return true;
+    }
+
+    if((!storage_file_seek(elf->fd, section_header->sh_offset, true)) ||
+       (storage_file_read(elf->fd, section->data, section_header->sh_size) !=
+        section_header->sh_size)) {
+        FURI_LOG_E(TAG, "    seek/read fail");
+        return false;
+    }
+
+    FURI_LOG_D(TAG, "0x%X", section->data);
+    return true;
+}
+
 static SectionType elf_preload_section(
     ELFFile* elf,
     size_t section_idx,
@@ -453,73 +489,100 @@ static SectionType elf_preload_section(
     FlipperApplicationManifest* manifest) {
     const char* name = furi_string_get_cstr(name_string);
 
-    const struct {
-        const char* prefix;
-        SectionType type;
-    } lookup_sections[] = {
-        {".text", SectionTypeData},
-        {".rodata", SectionTypeData},
-        {".data", SectionTypeData},
-        {".bss", SectionTypeData},
-        {".preinit_array", SectionTypeData},
-        {".init_array", SectionTypeData},
-        {".fini_array", SectionTypeData},
-        {".rel.text", SectionTypeRelData},
-        {".rel.rodata", SectionTypeRelData},
-        {".rel.data", SectionTypeRelData},
-        {".rel.preinit_array", SectionTypeRelData},
-        {".rel.init_array", SectionTypeRelData},
-        {".rel.fini_array", SectionTypeRelData},
-    };
+#ifdef ELF_DEBUG_LOG
+    // log section name, type and flags
+    FuriString* flags_string = furi_string_alloc();
+    if(section_header->sh_flags & SHF_WRITE) furi_string_cat(flags_string, "W");
+    if(section_header->sh_flags & SHF_ALLOC) furi_string_cat(flags_string, "A");
+    if(section_header->sh_flags & SHF_EXECINSTR) furi_string_cat(flags_string, "X");
+    if(section_header->sh_flags & SHF_MERGE) furi_string_cat(flags_string, "M");
+    if(section_header->sh_flags & SHF_STRINGS) furi_string_cat(flags_string, "S");
+    if(section_header->sh_flags & SHF_INFO_LINK) furi_string_cat(flags_string, "I");
+    if(section_header->sh_flags & SHF_LINK_ORDER) furi_string_cat(flags_string, "L");
+    if(section_header->sh_flags & SHF_OS_NONCONFORMING) furi_string_cat(flags_string, "O");
+    if(section_header->sh_flags & SHF_GROUP) furi_string_cat(flags_string, "G");
+    if(section_header->sh_flags & SHF_TLS) furi_string_cat(flags_string, "T");
+    if(section_header->sh_flags & SHF_COMPRESSED) furi_string_cat(flags_string, "T");
+    if(section_header->sh_flags & SHF_MASKOS) furi_string_cat(flags_string, "o");
+    if(section_header->sh_flags & SHF_MASKPROC) furi_string_cat(flags_string, "p");
+    if(section_header->sh_flags & SHF_ORDERED) furi_string_cat(flags_string, "R");
+    if(section_header->sh_flags & SHF_EXCLUDE) furi_string_cat(flags_string, "E");
 
-    for(size_t i = 0; i < COUNT_OF(lookup_sections); i++) {
-        if(cstr_prefix(lookup_sections[i].prefix, name)) {
-            FURI_LOG_D(TAG, "Found section %s", lookup_sections[i].prefix);
+    FURI_LOG_I(
+        TAG,
+        "Section %s: type: %ld, flags: %s",
+        name,
+        section_header->sh_type,
+        furi_string_get_cstr(flags_string));
+    furi_string_free(flags_string);
+#endif
 
-            if(lookup_sections[i].type == SectionTypeRelData) {
-                name = name + strlen(".rel");
-            }
+    // ignore .ARM and .rel.ARM sections
+    // TODO: how to do it not by name?
+    // .ARM: type 0x70000001, flags SHF_ALLOC | SHF_LINK_ORDER
+    // .rel.ARM: type 0x9, flags SHT_REL
+    if(str_prefix(name, ".ARM.") || str_prefix(name, ".rel.ARM.")) {
+        FURI_LOG_D(TAG, "Ignoring ARM section");
+        return SectionTypeUnused;
+    }
 
-            ELFSection* section_p = elf_file_get_section(elf, name);
-            if(!section_p) {
-                ELFSection section = {
-                    .data = NULL,
-                    .sec_idx = 0,
-                    .rel_sec_idx = 0,
-                    .size = 0,
-                };
+    // Load allocable section
+    if(section_header->sh_flags & SHF_ALLOC) {
+        ELFSection* section_p = elf_file_get_or_put_section(elf, name);
+        section_p->sec_idx = section_idx;
 
-                elf_file_put_section(elf, name, &section);
-                section_p = elf_file_get_section(elf, name);
-            }
+        if(section_header->sh_type == SHT_PREINIT_ARRAY) {
+            elf->preinit_array = section_p;
+        } else if(section_header->sh_type == SHT_INIT_ARRAY) {
+            elf->init_array = section_p;
+        } else if(section_header->sh_type == SHT_FINI_ARRAY) {
+            elf->fini_array = section_p;
+        }
 
-            if(lookup_sections[i].type == SectionTypeRelData) {
-                section_p->rel_sec_idx = section_idx;
-            } else {
-                section_p->sec_idx = section_idx;
-            }
-
-            return lookup_sections[i].type;
+        if(!elf_load_section_data(elf, section_p, section_header)) {
+            FURI_LOG_E(TAG, "Error loading section '%s'", name);
+            return SectionTypeERROR;
+        } else {
+            return SectionTypeData;
         }
     }
 
+    // Load link info section
+    if(section_header->sh_flags & SHF_INFO_LINK) {
+        name = name + strlen(".rel");
+        ELFSection* section_p = elf_file_get_or_put_section(elf, name);
+        section_p->rel_count = section_header->sh_size / sizeof(Elf32_Rel);
+        section_p->rel_offset = section_header->sh_offset;
+        return SectionTypeRelData;
+    }
+
+    // Load symbol table
     if(strcmp(name, ".symtab") == 0) {
         FURI_LOG_D(TAG, "Found .symtab section");
         elf->symbol_table = section_header->sh_offset;
         elf->symbol_count = section_header->sh_size / sizeof(Elf32_Sym);
         return SectionTypeSymTab;
-    } else if(strcmp(name, ".strtab") == 0) {
+    }
+
+    // Load string table
+    if(strcmp(name, ".strtab") == 0) {
         FURI_LOG_D(TAG, "Found .strtab section");
         elf->symbol_table_strings = section_header->sh_offset;
         return SectionTypeStrTab;
-    } else if(strcmp(name, ".fapmeta") == 0) {
+    }
+
+    // Load manifest section
+    if(strcmp(name, ".fapmeta") == 0) {
         FURI_LOG_D(TAG, "Found .fapmeta section");
         if(elf_load_metadata(elf, section_header, manifest)) {
             return SectionTypeManifest;
         } else {
             return SectionTypeERROR;
         }
-    } else if(strcmp(name, ".gnu_debuglink") == 0) {
+    }
+
+    // Load debug link section
+    if(strcmp(name, ".gnu_debuglink") == 0) {
         FURI_LOG_D(TAG, "Found .gnu_debuglink section");
         if(elf_load_debug_link(elf, section_header)) {
             return SectionTypeDebugLink;
@@ -531,61 +594,17 @@ static SectionType elf_preload_section(
     return SectionTypeUnused;
 }
 
-static bool elf_load_section_data(ELFFile* elf, ELFSection* section) {
-    Elf32_Shdr section_header;
-    if(section->sec_idx == 0) {
-        FURI_LOG_D(TAG, "Section is not present");
-        return true;
-    }
-
-    if(!elf_read_section_header(elf, section->sec_idx, &section_header)) {
-        return false;
-    }
-
-    if(section_header.sh_size == 0) {
-        FURI_LOG_D(TAG, "No data for section");
-        return true;
-    }
-
-    section->data = aligned_malloc(section_header.sh_size, section_header.sh_addralign);
-    section->size = section_header.sh_size;
-
-    if(section_header.sh_type == SHT_NOBITS) {
-        /* section is empty (.bss?) */
-        /* no need to memset - allocator already did that */
-        return true;
-    }
-
-    if((!storage_file_seek(elf->fd, section_header.sh_offset, true)) ||
-       (storage_file_read(elf->fd, section->data, section_header.sh_size) !=
-        section_header.sh_size)) {
-        FURI_LOG_E(TAG, "    seek/read fail");
-        return false;
-    }
-
-    FURI_LOG_D(TAG, "0x%X", section->data);
-    return true;
-}
-
 static bool elf_relocate_section(ELFFile* elf, ELFSection* section) {
-    Elf32_Shdr section_header;
-    if(section->rel_sec_idx) {
+    if(section->rel_count) {
         FURI_LOG_D(TAG, "Relocating section");
-        if(elf_read_section_header(elf, section->rel_sec_idx, &section_header))
-            return elf_relocate(elf, &section_header, section);
-        else {
-            FURI_LOG_E(TAG, "Error reading section header");
-            return false;
-        }
+        return elf_relocate(elf, section);
     } else {
         FURI_LOG_D(TAG, "No relocation index"); /* Not an error */
     }
     return true;
 }
 
-static void elf_file_call_section_list(ELFFile* elf, const char* name, bool reverse_order) {
-    ELFSection* section = elf_file_get_section(elf, name);
-
+static void elf_file_call_section_list(ELFSection* section, bool reverse_order) {
     if(section && section->size) {
         const uint32_t* start = section->data;
         const uint32_t* end = section->data + section->size;
@@ -729,7 +748,6 @@ bool elf_file_load_section_table(ELFFile* elf, FlipperApplicationManifest* manif
     }
 
     furi_string_free(name);
-    FURI_LOG_D(TAG, "Load symbols done");
 
     return IS_FLAGS_SET(loaded_sections, SectionTypeValid);
 }
@@ -739,16 +757,6 @@ ELFFileLoadStatus elf_file_load_sections(ELFFile* elf) {
     ELFSectionDict_it_t it;
 
     AddressCache_init(elf->relocation_cache);
-    size_t start = furi_get_tick();
-
-    for(ELFSectionDict_it(it, elf->sections); !ELFSectionDict_end_p(it); ELFSectionDict_next(it)) {
-        ELFSectionDict_itref_t* itref = ELFSectionDict_ref(it);
-        FURI_LOG_D(TAG, "Loading section '%s'", itref->key);
-        if(!elf_load_section_data(elf, &itref->value)) {
-            FURI_LOG_E(TAG, "Error loading section '%s'", itref->key);
-            status = ELFFileLoadStatusUnspecifiedError;
-        }
-    }
 
     if(status == ELFFileLoadStatusSuccess) {
         for(ELFSectionDict_it(it, elf->sections); !ELFSectionDict_end_p(it);
@@ -777,14 +785,13 @@ ELFFileLoadStatus elf_file_load_sections(ELFFile* elf) {
     FURI_LOG_D(TAG, "Relocation cache size: %u", AddressCache_size(elf->relocation_cache));
     FURI_LOG_D(TAG, "Trampoline cache size: %u", AddressCache_size(elf->trampoline_cache));
     AddressCache_clear(elf->relocation_cache);
-    FURI_LOG_I(TAG, "Loaded in %ums", (size_t)(furi_get_tick() - start));
 
     return status;
 }
 
 void elf_file_pre_run(ELFFile* elf) {
-    elf_file_call_section_list(elf, ".preinit_array", false);
-    elf_file_call_section_list(elf, ".init_array", false);
+    elf_file_call_section_list(elf->preinit_array, false);
+    elf_file_call_section_list(elf->init_array, false);
 }
 
 int32_t elf_file_run(ELFFile* elf, void* args) {
@@ -794,7 +801,7 @@ int32_t elf_file_run(ELFFile* elf, void* args) {
 }
 
 void elf_file_post_run(ELFFile* elf) {
-    elf_file_call_section_list(elf, ".fini_array", true);
+    elf_file_call_section_list(elf->fini_array, true);
 }
 
 const ElfApiInterface* elf_file_get_api_interface(ELFFile* elf_file) {
diff --git a/lib/flipper_application/elf/elf_file_i.h b/lib/flipper_application/elf/elf_file_i.h
index 1df075f06..9b38540b7 100644
--- a/lib/flipper_application/elf/elf_file_i.h
+++ b/lib/flipper_application/elf/elf_file_i.h
@@ -16,8 +16,10 @@ typedef int32_t(entry_t)(void*);
 typedef struct {
     void* data;
     uint16_t sec_idx;
-    uint16_t rel_sec_idx;
     Elf32_Word size;
+
+    size_t rel_count;
+    Elf32_Off rel_offset;
 } ELFSection;
 
 DICT_DEF2(ELFSectionDict, const char*, M_CSTR_OPLIST, ELFSection, M_POD_OPLIST)
@@ -39,6 +41,10 @@ struct ELFFile {
     File* fd;
     const ElfApiInterface* api_interface;
     ELFDebugLinkInfo debug_link_info;
+
+    ELFSection* preinit_array;
+    ELFSection* init_array;
+    ELFSection* fini_array;
 };
 
 #ifdef __cplusplus
diff --git a/lib/infrared/worker/infrared_worker.c b/lib/infrared/worker/infrared_worker.c
index 2b4e3cdbb..86b19114c 100644
--- a/lib/infrared/worker/infrared_worker.c
+++ b/lib/infrared/worker/infrared_worker.c
@@ -9,7 +9,6 @@
 #include <furi.h>
 
 #include <notification/notification_messages.h>
-#include <stream_buffer.h>
 
 #define INFRARED_WORKER_RX_TIMEOUT INFRARED_RAW_RX_TIMING_DELAY_US
 
@@ -50,7 +49,7 @@ struct InfraredWorkerSignal {
 
 struct InfraredWorker {
     FuriThread* thread;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
 
     InfraredWorkerSignal signal;
     InfraredWorkerState state;
@@ -100,15 +99,13 @@ static void infrared_worker_rx_timeout_callback(void* context) {
 static void infrared_worker_rx_callback(void* context, bool level, uint32_t duration) {
     InfraredWorker* instance = context;
 
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     furi_assert(duration != 0);
     LevelDuration level_duration = level_duration_make(level, duration);
 
-    size_t ret = xStreamBufferSendFromISR(
-        instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
+    size_t ret =
+        furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
     uint32_t events = (ret == sizeof(LevelDuration)) ? INFRARED_WORKER_RX_RECEIVED :
                                                        INFRARED_WORKER_OVERRUN;
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
 
     uint32_t flags_set = furi_thread_flags_set(furi_thread_get_id(instance->thread), events);
     furi_check(flags_set & events);
@@ -179,7 +176,7 @@ static int32_t infrared_worker_rx_thread(void* thread_context) {
             if(instance->signal.timings_cnt == 0)
                 notification_message(instance->notification, &sequence_display_backlight_on);
             while(sizeof(LevelDuration) ==
-                  xStreamBufferReceive(
+                  furi_stream_buffer_receive(
                       instance->stream, &level_duration, sizeof(LevelDuration), 0)) {
                 if(!instance->rx.overrun) {
                     bool level = level_duration_get_level(level_duration);
@@ -232,7 +229,7 @@ InfraredWorker* infrared_worker_alloc() {
     size_t buffer_size =
         MAX(sizeof(InfraredWorkerTiming) * (MAX_TIMINGS_AMOUNT + 1),
             sizeof(LevelDuration) * MAX_TIMINGS_AMOUNT);
-    instance->stream = xStreamBufferCreate(buffer_size, sizeof(InfraredWorkerTiming));
+    instance->stream = furi_stream_buffer_alloc(buffer_size, sizeof(InfraredWorkerTiming));
     instance->infrared_decoder = infrared_alloc_decoder();
     instance->infrared_encoder = infrared_alloc_encoder();
     instance->blink_enable = false;
@@ -249,7 +246,7 @@ void infrared_worker_free(InfraredWorker* instance) {
     furi_record_close(RECORD_NOTIFICATION);
     infrared_free_decoder(instance->infrared_decoder);
     infrared_free_encoder(instance->infrared_encoder);
-    vStreamBufferDelete(instance->stream);
+    furi_stream_buffer_free(instance->stream);
     furi_thread_free(instance->thread);
 
     free(instance);
@@ -259,7 +256,7 @@ void infrared_worker_rx_start(InfraredWorker* instance) {
     furi_assert(instance);
     furi_assert(instance->state == InfraredWorkerStateIdle);
 
-    xStreamBufferSetTriggerLevel(instance->stream, sizeof(LevelDuration));
+    furi_stream_set_trigger_level(instance->stream, sizeof(LevelDuration));
 
     furi_thread_set_callback(instance->thread, infrared_worker_rx_thread);
     furi_thread_start(instance->thread);
@@ -285,9 +282,9 @@ void infrared_worker_rx_stop(InfraredWorker* instance) {
     furi_thread_flags_set(furi_thread_get_id(instance->thread), INFRARED_WORKER_EXIT);
     furi_thread_join(instance->thread);
 
-    BaseType_t xReturn = xStreamBufferReset(instance->stream);
-    furi_assert(xReturn == pdPASS);
-    (void)xReturn;
+    FuriStatus status = furi_stream_buffer_reset(instance->stream);
+    furi_assert(status == FuriStatusOk);
+    (void)status;
 
     instance->state = InfraredWorkerStateIdle;
 }
@@ -325,7 +322,7 @@ void infrared_worker_tx_start(InfraredWorker* instance) {
     furi_assert(instance->tx.get_signal_callback);
 
     // size have to be greater than api hal infrared async tx buffer size
-    xStreamBufferSetTriggerLevel(instance->stream, sizeof(InfraredWorkerTiming));
+    furi_stream_set_trigger_level(instance->stream, sizeof(InfraredWorkerTiming));
 
     furi_thread_set_callback(instance->thread, infrared_worker_tx_thread);
 
@@ -358,7 +355,7 @@ static FuriHalInfraredTxGetDataState
     FuriHalInfraredTxGetDataState state;
 
     if(sizeof(InfraredWorkerTiming) ==
-       xStreamBufferReceiveFromISR(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0)) {
+       furi_stream_buffer_receive(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0)) {
         *level = timing.level;
         *duration = timing.duration;
         state = timing.state;
@@ -420,7 +417,7 @@ static bool infrared_worker_tx_fill_buffer(InfraredWorker* instance) {
     InfraredWorkerTiming timing;
     InfraredStatus status = InfraredStatusError;
 
-    while(!xStreamBufferIsFull(instance->stream) && !instance->tx.need_reinitialization &&
+    while(!furi_stream_buffer_is_full(instance->stream) && !instance->tx.need_reinitialization &&
           new_data_available) {
         if(instance->signal.decoded) {
             status = infrared_encode(instance->infrared_encoder, &timing.duration, &timing.level);
@@ -454,7 +451,7 @@ static bool infrared_worker_tx_fill_buffer(InfraredWorker* instance) {
             furi_assert(0);
         }
         uint32_t written_size =
-            xStreamBufferSend(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0);
+            furi_stream_buffer_send(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0);
         furi_assert(sizeof(InfraredWorkerTiming) == written_size);
         (void)written_size;
     }
@@ -564,10 +561,9 @@ void infrared_worker_tx_stop(InfraredWorker* instance) {
     furi_hal_infrared_async_tx_set_signal_sent_isr_callback(NULL, NULL);
 
     instance->signal.timings_cnt = 0;
-    BaseType_t xReturn = pdFAIL;
-    xReturn = xStreamBufferReset(instance->stream);
-    furi_assert(xReturn == pdPASS);
-    (void)xReturn;
+    FuriStatus status = furi_stream_buffer_reset(instance->stream);
+    furi_assert(status == FuriStatusOk);
+    (void)status;
     instance->state = InfraredWorkerStateIdle;
 }
 
diff --git a/lib/lfrfid/lfrfid_raw_worker.c b/lib/lfrfid/lfrfid_raw_worker.c
index b277bbd34..1547d20f9 100644
--- a/lib/lfrfid/lfrfid_raw_worker.c
+++ b/lib/lfrfid/lfrfid_raw_worker.c
@@ -2,7 +2,6 @@
 #include <toolbox/stream/file_stream.h>
 #include <toolbox/buffer_stream.h>
 #include <toolbox/varint.h>
-#include <stream_buffer.h>
 #include "lfrfid_raw_worker.h"
 #include "lfrfid_raw_file.h"
 #include "tools/varint_pair.h"
@@ -16,7 +15,7 @@
 // emulate mode
 typedef struct {
     size_t overrun_count;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
 } RfidEmulateCtx;
 
 typedef struct {
@@ -126,20 +125,13 @@ void lfrfid_raw_worker_stop(LFRFIDRawWorker* worker) {
 static void lfrfid_raw_worker_capture(bool level, uint32_t duration, void* context) {
     LFRFIDRawWorkerReadData* ctx = context;
 
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-
     bool need_to_send = varint_pair_pack(ctx->pair, level, duration);
 
     if(need_to_send) {
         buffer_stream_send_from_isr(
-            ctx->stream,
-            varint_pair_get_data(ctx->pair),
-            varint_pair_get_size(ctx->pair),
-            &xHigherPriorityTaskWoken);
+            ctx->stream, varint_pair_get_data(ctx->pair), varint_pair_get_size(ctx->pair));
         varint_pair_reset(ctx->pair);
     }
-
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
 }
 
 static int32_t lfrfid_raw_read_worker_thread(void* thread_context) {
@@ -236,7 +228,7 @@ static void rfid_emulate_dma_isr(bool half, void* context) {
     RfidEmulateCtx* ctx = context;
 
     uint32_t flag = half ? HalfTransfer : TransferComplete;
-    size_t len = xStreamBufferSendFromISR(ctx->stream, &flag, sizeof(uint32_t), pdFALSE);
+    size_t len = furi_stream_buffer_send(ctx->stream, &flag, sizeof(uint32_t), 0);
     if(len != sizeof(uint32_t)) {
         ctx->overrun_count++;
     }
@@ -251,7 +243,7 @@ static int32_t lfrfid_raw_emulate_worker_thread(void* thread_context) {
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
     data->ctx.overrun_count = 0;
-    data->ctx.stream = xStreamBufferCreate(sizeof(uint32_t), sizeof(uint32_t));
+    data->ctx.stream = furi_stream_buffer_alloc(sizeof(uint32_t), sizeof(uint32_t));
 
     LFRFIDRawFile* file = lfrfid_raw_file_alloc(storage);
 
@@ -287,7 +279,8 @@ static int32_t lfrfid_raw_emulate_worker_thread(void* thread_context) {
         uint32_t flag = 0;
 
         while(true) {
-            size_t size = xStreamBufferReceive(data->ctx.stream, &flag, sizeof(uint32_t), 100);
+            size_t size =
+                furi_stream_buffer_receive(data->ctx.stream, &flag, sizeof(uint32_t), 100);
 
             if(size == sizeof(uint32_t)) {
                 size_t start = 0;
@@ -345,10 +338,10 @@ static int32_t lfrfid_raw_emulate_worker_thread(void* thread_context) {
     }
 
     if(data->ctx.overrun_count) {
-        FURI_LOG_E(TAG_EMULATE, "overruns: %lu", data->ctx.overrun_count);
+        FURI_LOG_E(TAG_EMULATE, "overruns: %u", data->ctx.overrun_count);
     }
 
-    vStreamBufferDelete(data->ctx.stream);
+    furi_stream_buffer_free(data->ctx.stream);
     lfrfid_raw_file_free(file);
     furi_record_close(RECORD_STORAGE);
     free(data);
diff --git a/lib/lfrfid/lfrfid_worker_modes.c b/lib/lfrfid/lfrfid_worker_modes.c
index 564470576..1fbae04c8 100644
--- a/lib/lfrfid/lfrfid_worker_modes.c
+++ b/lib/lfrfid/lfrfid_worker_modes.c
@@ -2,7 +2,6 @@
 #include <furi_hal.h>
 #include "lfrfid_worker_i.h"
 #include "tools/t5577.h"
-#include <stream_buffer.h>
 #include <toolbox/pulse_protocols/pulse_glue.h>
 #include <toolbox/buffer_stream.h>
 #include "tools/varint_pair.h"
@@ -81,17 +80,12 @@ static void lfrfid_worker_read_capture(bool level, uint32_t duration, void* cont
     furi_hal_gpio_write(LFRFID_WORKER_READ_DEBUG_GPIO_VALUE, level);
 #endif
 
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     bool need_to_send = varint_pair_pack(ctx->pair, level, duration);
     if(need_to_send) {
         buffer_stream_send_from_isr(
-            ctx->stream,
-            varint_pair_get_data(ctx->pair),
-            varint_pair_get_size(ctx->pair),
-            &xHigherPriorityTaskWoken);
+            ctx->stream, varint_pair_get_data(ctx->pair), varint_pair_get_size(ctx->pair));
         varint_pair_reset(ctx->pair);
     }
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
 }
 
 typedef enum {
@@ -407,14 +401,14 @@ typedef enum {
 } LFRFIDWorkerEmulateDMAEvent;
 
 static void lfrfid_worker_emulate_dma_isr(bool half, void* context) {
-    StreamBufferHandle_t stream = context;
+    FuriStreamBuffer* stream = context;
     uint32_t flag = half ? HalfTransfer : TransferComplete;
-    xStreamBufferSendFromISR(stream, &flag, sizeof(uint32_t), pdFALSE);
+    furi_stream_buffer_send(stream, &flag, sizeof(uint32_t), 0);
 }
 
 static void lfrfid_worker_mode_emulate_process(LFRFIDWorker* worker) {
     LFRFIDWorkerEmulateBuffer* buffer = malloc(sizeof(LFRFIDWorkerEmulateBuffer));
-    StreamBufferHandle_t stream = xStreamBufferCreate(sizeof(uint32_t), sizeof(uint32_t));
+    FuriStreamBuffer* stream = furi_stream_buffer_alloc(sizeof(uint32_t), sizeof(uint32_t));
     LFRFIDProtocol protocol = worker->protocol;
     PulseGlue* pulse_glue = pulse_glue_alloc();
 
@@ -449,7 +443,7 @@ static void lfrfid_worker_mode_emulate_process(LFRFIDWorker* worker) {
 
     while(true) {
         uint32_t flag = 0;
-        size_t size = xStreamBufferReceive(stream, &flag, sizeof(uint32_t), 100);
+        size_t size = furi_stream_buffer_receive(stream, &flag, sizeof(uint32_t), 100);
 
 #ifdef LFRFID_WORKER_READ_DEBUG_GPIO
         furi_hal_gpio_write(LFRFID_WORKER_READ_DEBUG_GPIO_LOAD, true);
@@ -497,7 +491,7 @@ static void lfrfid_worker_mode_emulate_process(LFRFIDWorker* worker) {
 #endif
 
     free(buffer);
-    vStreamBufferDelete(stream);
+    furi_stream_buffer_free(stream);
     pulse_glue_free(pulse_glue);
 }
 
diff --git a/lib/lfrfid/protocols/protocol_gallagher.c b/lib/lfrfid/protocols/protocol_gallagher.c
index 460c23a39..4720d3a4d 100644
--- a/lib/lfrfid/protocols/protocol_gallagher.c
+++ b/lib/lfrfid/protocols/protocol_gallagher.c
@@ -276,7 +276,7 @@ void protocol_gallagher_render_data(ProtocolGallagher* protocol, FuriString* res
     uint32_t card_id = bit_lib_get_bits_32(protocol->data, 32, 32);
 
     furi_string_cat_printf(result, "Region: %u, Issue Level: %u\r\n", rc, il);
-    furi_string_cat_printf(result, "FC: %u, C: %lu\r\n", fc, card_id);
+    furi_string_cat_printf(result, "FC: %lu, C: %lu\r\n", fc, card_id);
 };
 
 const ProtocolBase protocol_gallagher = {
diff --git a/lib/lfrfid/protocols/protocol_keri.c b/lib/lfrfid/protocols/protocol_keri.c
index 099fd1680..f0a12863e 100644
--- a/lib/lfrfid/protocols/protocol_keri.c
+++ b/lib/lfrfid/protocols/protocol_keri.c
@@ -218,7 +218,7 @@ void protocol_keri_render_data(ProtocolKeri* protocol, FuriString* result) {
     uint32_t fc = 0;
     uint32_t cn = 0;
     protocol_keri_descramble(&fc, &cn, &data);
-    furi_string_printf(result, "Internal ID: %u\r\nFC: %u, Card: %u\r\n", internal_id, fc, cn);
+    furi_string_printf(result, "Internal ID: %lu\r\nFC: %lu, Card: %lu\r\n", internal_id, fc, cn);
 }
 
 bool protocol_keri_write_data(ProtocolKeri* protocol, void* data) {
diff --git a/lib/lfrfid/protocols/protocol_paradox.c b/lib/lfrfid/protocols/protocol_paradox.c
index 6a8e33ba4..7e029f1de 100644
--- a/lib/lfrfid/protocols/protocol_paradox.c
+++ b/lib/lfrfid/protocols/protocol_paradox.c
@@ -142,7 +142,7 @@ void protocol_paradox_render_data(ProtocolParadox* protocol, FuriString* result)
     uint16_t card_id = bit_lib_get_bits_16(decoded_data, 18, 16);
 
     furi_string_cat_printf(result, "Facility: %u\r\n", fc);
-    furi_string_cat_printf(result, "Card: %lu\r\n", card_id);
+    furi_string_cat_printf(result, "Card: %u\r\n", card_id);
     furi_string_cat_printf(result, "Data: ");
     for(size_t i = 0; i < PARADOX_DECODED_DATA_SIZE; i++) {
         furi_string_cat_printf(result, "%02X", decoded_data[i]);
diff --git a/lib/lfrfid/protocols/protocol_pyramid.c b/lib/lfrfid/protocols/protocol_pyramid.c
index 545744580..974bb6da6 100644
--- a/lib/lfrfid/protocols/protocol_pyramid.c
+++ b/lib/lfrfid/protocols/protocol_pyramid.c
@@ -243,7 +243,7 @@ void protocol_pyramid_render_data(ProtocolPyramid* protocol, FuriString* result)
     uint8_t* decoded_data = protocol->data;
     uint8_t format_length = decoded_data[0];
 
-    furi_string_cat_printf(result, "Format: 26\r\n", format_length);
+    furi_string_cat_printf(result, "Format: %d\r\n", format_length);
     if(format_length == 26) {
         uint8_t facility;
         bit_lib_copy_bits(&facility, 0, 8, decoded_data, 8);
diff --git a/lib/nfc/helpers/mf_classic_dict.c b/lib/nfc/helpers/mf_classic_dict.c
index 356f6f7c7..a842ed921 100644
--- a/lib/nfc/helpers/mf_classic_dict.c
+++ b/lib/nfc/helpers/mf_classic_dict.c
@@ -87,7 +87,7 @@ MfClassicDict* mf_classic_dict_alloc(MfClassicDictType dict_type) {
         stream_rewind(dict->stream);
 
         dict_loaded = true;
-        FURI_LOG_I(TAG, "Loaded dictionary with %d keys", dict->total_keys);
+        FURI_LOG_I(TAG, "Loaded dictionary with %ld keys", dict->total_keys);
     } while(false);
 
     if(!dict_loaded) {
diff --git a/lib/nfc/helpers/mfkey32.c b/lib/nfc/helpers/mfkey32.c
index fa5713f27..47e7e9f6b 100644
--- a/lib/nfc/helpers/mfkey32.c
+++ b/lib/nfc/helpers/mfkey32.c
@@ -92,7 +92,7 @@ void mfkey32_set_callback(Mfkey32* instance, Mfkey32ParseDataCallback callback,
 
 static bool mfkey32_write_params(Mfkey32* instance, Mfkey32Params* params) {
     FuriString* str = furi_string_alloc_printf(
-        "Sec %d key %c cuid %08x nt0 %08x nr0 %08x ar0 %08x nt1 %08x nr1 %08x ar1 %08x\n",
+        "Sec %d key %c cuid %08lx nt0 %08lx nr0 %08lx ar0 %08lx nt1 %08lx nr1 %08lx ar1 %08lx\n",
         params->sector,
         params->key == MfClassicKeyA ? 'A' : 'B',
         params->cuid,
diff --git a/lib/nfc/helpers/reader_analyzer.c b/lib/nfc/helpers/reader_analyzer.c
index 680b8cef9..0ba657a2e 100644
--- a/lib/nfc/helpers/reader_analyzer.c
+++ b/lib/nfc/helpers/reader_analyzer.c
@@ -1,5 +1,4 @@
 #include "reader_analyzer.h"
-#include <stream_buffer.h>
 #include <lib/nfc/protocols/nfc_util.h>
 #include <lib/nfc/protocols/mifare_classic.h>
 #include <m-array.h>
@@ -26,7 +25,7 @@ struct ReaderAnalyzer {
     FuriHalNfcDevData nfc_data;
 
     bool alive;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
     FuriThread* thread;
 
     ReaderAnalyzerParseDataCallback callback;
@@ -86,8 +85,8 @@ int32_t reader_analyzer_thread(void* context) {
     ReaderAnalyzer* reader_analyzer = context;
     uint8_t buffer[READER_ANALYZER_MAX_BUFF_SIZE] = {};
 
-    while(reader_analyzer->alive || !xStreamBufferIsEmpty(reader_analyzer->stream)) {
-        size_t ret = xStreamBufferReceive(
+    while(reader_analyzer->alive || !furi_stream_buffer_is_empty(reader_analyzer->stream)) {
+        size_t ret = furi_stream_buffer_receive(
             reader_analyzer->stream, buffer, READER_ANALYZER_MAX_BUFF_SIZE, 50);
         if(ret) {
             reader_analyzer_parse(reader_analyzer, buffer, ret);
@@ -103,7 +102,7 @@ ReaderAnalyzer* reader_analyzer_alloc() {
     instance->nfc_data = reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic];
     instance->alive = false;
     instance->stream =
-        xStreamBufferCreate(READER_ANALYZER_MAX_BUFF_SIZE, sizeof(ReaderAnalyzerHeader));
+        furi_stream_buffer_alloc(READER_ANALYZER_MAX_BUFF_SIZE, sizeof(ReaderAnalyzerHeader));
 
     instance->thread = furi_thread_alloc();
     furi_thread_set_name(instance->thread, "ReaderAnalyzerWorker");
@@ -129,7 +128,7 @@ static void reader_analyzer_mfkey_callback(Mfkey32Event event, void* context) {
 void reader_analyzer_start(ReaderAnalyzer* instance, ReaderAnalyzerMode mode) {
     furi_assert(instance);
 
-    xStreamBufferReset(instance->stream);
+    furi_stream_buffer_reset(instance->stream);
     if(mode & ReaderAnalyzerModeDebugLog) {
         instance->debug_log = nfc_debug_log_alloc();
     }
@@ -171,7 +170,7 @@ void reader_analyzer_free(ReaderAnalyzer* instance) {
 
     reader_analyzer_stop(instance);
     furi_thread_free(instance->thread);
-    vStreamBufferDelete(instance->stream);
+    furi_stream_buffer_free(instance->stream);
     free(instance);
 }
 
@@ -215,12 +214,12 @@ static void reader_analyzer_write(
     ReaderAnalyzerHeader header = {
         .reader_to_tag = reader_to_tag, .crc_dropped = crc_dropped, .len = len};
     size_t data_sent = 0;
-    data_sent = xStreamBufferSend(
+    data_sent = furi_stream_buffer_send(
         instance->stream, &header, sizeof(ReaderAnalyzerHeader), FuriWaitForever);
     if(data_sent != sizeof(ReaderAnalyzerHeader)) {
         FURI_LOG_W(TAG, "Sent %d out of %d bytes", data_sent, sizeof(ReaderAnalyzerHeader));
     }
-    data_sent = xStreamBufferSend(instance->stream, data, len, FuriWaitForever);
+    data_sent = furi_stream_buffer_send(instance->stream, data, len, FuriWaitForever);
     if(data_sent != len) {
         FURI_LOG_W(TAG, "Sent %d out of %d bytes", data_sent, len);
     }
diff --git a/lib/nfc/nfc_worker.c b/lib/nfc/nfc_worker.c
index 10494193f..fc05b8264 100644
--- a/lib/nfc/nfc_worker.c
+++ b/lib/nfc/nfc_worker.c
@@ -536,7 +536,8 @@ void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker) {
         return;
     }
 
-    FURI_LOG_D(TAG, "Start Dictionary attack, Key Count %d", mf_classic_dict_get_total_keys(dict));
+    FURI_LOG_D(
+        TAG, "Start Dictionary attack, Key Count %ld", mf_classic_dict_get_total_keys(dict));
     for(size_t i = 0; i < total_sectors; i++) {
         FURI_LOG_I(TAG, "Sector %d", i);
         nfc_worker->callback(NfcWorkerEventNewSector, nfc_worker->context);
diff --git a/lib/nfc/parsers/all_in_one.c b/lib/nfc/parsers/all_in_one.c
index f63fb7e6d..05cfe5764 100644
--- a/lib/nfc/parsers/all_in_one.c
+++ b/lib/nfc/parsers/all_in_one.c
@@ -108,6 +108,6 @@ bool all_in_one_parser_parse(NfcDeviceData* dev_data) {
 
     // Format string for rides count
     furi_string_printf(
-        dev_data->parsed_data, "\e#All-In-One\nNumber: %u\nRides left: %u", serial, ride_count);
+        dev_data->parsed_data, "\e#All-In-One\nNumber: %lu\nRides left: %u", serial, ride_count);
     return true;
 }
\ No newline at end of file
diff --git a/lib/nfc/parsers/plantain_4k_parser.c b/lib/nfc/parsers/plantain_4k_parser.c
index eddebac23..348b5a64c 100644
--- a/lib/nfc/parsers/plantain_4k_parser.c
+++ b/lib/nfc/parsers/plantain_4k_parser.c
@@ -132,7 +132,7 @@ bool plantain_4k_parser_parse(NfcDeviceData* dev_data) {
 
     furi_string_printf(
         dev_data->parsed_data,
-        "\e#Plantain\nN:%s\nBalance:%d\n",
+        "\e#Plantain\nN:%s\nBalance:%ld\n",
         furi_string_get_cstr(card_number_str),
         balance);
     furi_string_free(card_number_str);
diff --git a/lib/nfc/parsers/plantain_parser.c b/lib/nfc/parsers/plantain_parser.c
index ac7a90b24..5328b5c4f 100644
--- a/lib/nfc/parsers/plantain_parser.c
+++ b/lib/nfc/parsers/plantain_parser.c
@@ -105,7 +105,7 @@ bool plantain_parser_parse(NfcDeviceData* dev_data) {
 
     furi_string_printf(
         dev_data->parsed_data,
-        "\e#Plantain\nN:%s\nBalance:%d\n",
+        "\e#Plantain\nN:%s\nBalance:%ld\n",
         furi_string_get_cstr(card_number_str),
         balance);
     furi_string_free(card_number_str);
diff --git a/lib/nfc/parsers/two_cities.c b/lib/nfc/parsers/two_cities.c
index f5e31d51b..2c6184a71 100644
--- a/lib/nfc/parsers/two_cities.c
+++ b/lib/nfc/parsers/two_cities.c
@@ -149,7 +149,7 @@ bool two_cities_parser_parse(NfcDeviceData* dev_data) {
 
     furi_string_printf(
         dev_data->parsed_data,
-        "\e#Troika+Plantain\nPN: %s\nPB: %d rur.\nTN: %d\nTB: %d rur.\n",
+        "\e#Troika+Plantain\nPN: %s\nPB: %ld rur.\nTN: %ld\nTB: %d rur.\n",
         furi_string_get_cstr(card_number_str),
         balance,
         troika_number,
diff --git a/lib/nfc/protocols/mifare_classic.c b/lib/nfc/protocols/mifare_classic.c
index 3b5343932..783202451 100644
--- a/lib/nfc/protocols/mifare_classic.c
+++ b/lib/nfc/protocols/mifare_classic.c
@@ -847,7 +847,7 @@ bool mf_classic_emulator(MfClassicEmulator* emulator, FuriHalNfcTxRxContext* tx_
 
             FURI_LOG_D(
                 TAG,
-                "%08x key%c block %d nt/nr/ar: %08x %08x %08x",
+                "%08lx key%c block %d nt/nr/ar: %08lx %08lx %08lx",
                 emulator->cuid,
                 access_key == MfClassicKeyA ? 'A' : 'B',
                 sector_trailer_block,
@@ -858,7 +858,7 @@ bool mf_classic_emulator(MfClassicEmulator* emulator, FuriHalNfcTxRxContext* tx_
             crypto1_word(&emulator->crypto, nr, 1);
             uint32_t cardRr = ar ^ crypto1_word(&emulator->crypto, 0, 0);
             if(cardRr != prng_successor(nonce, 64)) {
-                FURI_LOG_T(TAG, "Wrong AUTH! %08X != %08X", cardRr, prng_successor(nonce, 64));
+                FURI_LOG_T(TAG, "Wrong AUTH! %08lX != %08lX", cardRr, prng_successor(nonce, 64));
                 // Don't send NACK, as the tag doesn't send it
                 command_processed = true;
                 break;
diff --git a/lib/nfc/protocols/mifare_desfire.c b/lib/nfc/protocols/mifare_desfire.c
index 9dd37f1ee..b2247bf20 100644
--- a/lib/nfc/protocols/mifare_desfire.c
+++ b/lib/nfc/protocols/mifare_desfire.c
@@ -108,7 +108,7 @@ void mf_df_cat_version(MifareDesfireVersion* version, FuriString* out) {
 }
 
 void mf_df_cat_free_mem(MifareDesfireFreeMemory* free_mem, FuriString* out) {
-    furi_string_cat_printf(out, "freeMem %d\n", free_mem->bytes);
+    furi_string_cat_printf(out, "freeMem %ld\n", free_mem->bytes);
 }
 
 void mf_df_cat_key_settings(MifareDesfireKeySettings* ks, FuriString* out) {
@@ -191,10 +191,10 @@ void mf_df_cat_file(MifareDesfireFile* file, FuriString* out) {
     case MifareDesfireFileTypeValue:
         size = 4;
         furi_string_cat_printf(
-            out, "lo %d hi %d\n", file->settings.value.lo_limit, file->settings.value.hi_limit);
+            out, "lo %ld hi %ld\n", file->settings.value.lo_limit, file->settings.value.hi_limit);
         furi_string_cat_printf(
             out,
-            "limit %d enabled %d\n",
+            "limit %ld enabled %d\n",
             file->settings.value.limited_credit_value,
             file->settings.value.limited_credit_enabled);
         break;
@@ -203,7 +203,7 @@ void mf_df_cat_file(MifareDesfireFile* file, FuriString* out) {
         size = file->settings.record.size;
         num = file->settings.record.cur;
         furi_string_cat_printf(out, "size %d\n", size);
-        furi_string_cat_printf(out, "num %d max %d\n", num, file->settings.record.max);
+        furi_string_cat_printf(out, "num %d max %ld\n", num, file->settings.record.max);
         break;
     }
     uint8_t* data = file->contents;
diff --git a/lib/nfc/protocols/mifare_ultralight.c b/lib/nfc/protocols/mifare_ultralight.c
index e9278d6e2..4ea14b38c 100644
--- a/lib/nfc/protocols/mifare_ultralight.c
+++ b/lib/nfc/protocols/mifare_ultralight.c
@@ -193,7 +193,7 @@ bool mf_ultralight_authenticate(FuriHalNfcTxRxContext* tx_rx, uint32_t key, uint
             *pack = (tx_rx->rx_data[1] << 8) | tx_rx->rx_data[0];
         }
 
-        FURI_LOG_I(TAG, "Auth success. Password: %08X. PACK: %04X", key, *pack);
+        FURI_LOG_I(TAG, "Auth success. Password: %08lX. PACK: %04X", key, *pack);
         authenticated = true;
     } while(false);
 
@@ -1061,7 +1061,7 @@ static void mf_ul_make_ascii_mirror(MfUltralightEmulator* emulator, FuriString*
             if(mirror_conf == MfUltralightMirrorUidCounter)
                 furi_string_cat(str, uid_printed ? "x" : " ");
 
-            furi_string_cat_printf(str, "%06X", emulator->data.counter[2]);
+            furi_string_cat_printf(str, "%06lX", emulator->data.counter[2]);
         }
     }
 }
diff --git a/lib/one_wire/ibutton/ibutton_worker_modes.c b/lib/one_wire/ibutton/ibutton_worker_modes.c
index d585e27f4..691aea9ee 100644
--- a/lib/one_wire/ibutton/ibutton_worker_modes.c
+++ b/lib/one_wire/ibutton/ibutton_worker_modes.c
@@ -2,7 +2,6 @@
 #include <furi_hal.h>
 #include "ibutton_worker_i.h"
 #include "ibutton_key_command.h"
-#include <stream_buffer.h>
 
 void ibutton_worker_mode_idle_start(iButtonWorker* worker);
 void ibutton_worker_mode_idle_tick(iButtonWorker* worker);
@@ -65,7 +64,7 @@ void ibutton_worker_mode_idle_stop(iButtonWorker* worker) {
 
 typedef struct {
     uint32_t last_dwt_value;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
 } iButtonReadContext;
 
 void ibutton_worker_comparator_callback(bool level, void* context) {
@@ -75,7 +74,7 @@ void ibutton_worker_comparator_callback(bool level, void* context) {
 
     LevelDuration data =
         level_duration_make(level, current_dwt_value - read_context->last_dwt_value);
-    xStreamBufferSend(read_context->stream, &data, sizeof(LevelDuration), 0);
+    furi_stream_buffer_send(read_context->stream, &data, sizeof(LevelDuration), 0);
 
     read_context->last_dwt_value = current_dwt_value;
 }
@@ -91,7 +90,7 @@ bool ibutton_worker_read_comparator(iButtonWorker* worker) {
 
     iButtonReadContext read_context = {
         .last_dwt_value = DWT->CYCCNT,
-        .stream = xStreamBufferCreate(sizeof(LevelDuration) * 512, 1),
+        .stream = furi_stream_buffer_alloc(sizeof(LevelDuration) * 512, 1),
     };
 
     furi_hal_rfid_comp_set_callback(ibutton_worker_comparator_callback, &read_context);
@@ -100,7 +99,8 @@ bool ibutton_worker_read_comparator(iButtonWorker* worker) {
     uint32_t tick_start = furi_get_tick();
     while(true) {
         LevelDuration level;
-        size_t ret = xStreamBufferReceive(read_context.stream, &level, sizeof(LevelDuration), 100);
+        size_t ret =
+            furi_stream_buffer_receive(read_context.stream, &level, sizeof(LevelDuration), 100);
 
         if((furi_get_tick() - tick_start) > 100) {
             break;
@@ -141,7 +141,7 @@ bool ibutton_worker_read_comparator(iButtonWorker* worker) {
     furi_hal_rfid_comp_set_callback(NULL, NULL);
     furi_hal_rfid_pins_reset();
 
-    vStreamBufferDelete(read_context.stream);
+    furi_stream_buffer_free(read_context.stream);
 
     return result;
 }
diff --git a/lib/print/printf_tiny.h b/lib/print/printf_tiny.h
index 8f292819e..58f6a673b 100644
--- a/lib/print/printf_tiny.h
+++ b/lib/print/printf_tiny.h
@@ -34,6 +34,7 @@
 
 #include <stdarg.h>
 #include <stddef.h>
+#include <stdio.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -54,7 +55,7 @@ void _putchar(char character);
  * \param format A string that specifies the format of the output
  * \return The number of characters that are written into the array, not counting the terminating null character
  */
-int printf_(const char* format, ...);
+int printf_(const char* format, ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
 
 /**
  * Tiny sprintf implementation
@@ -63,7 +64,7 @@ int printf_(const char* format, ...);
  * \param format A string that specifies the format of the output
  * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
  */
-int sprintf_(char* buffer, const char* format, ...);
+int sprintf_(char* buffer, const char* format, ...) _ATTRIBUTE((__format__(__printf__, 2, 3)));
 
 /**
  * Tiny snprintf/vsnprintf implementation
@@ -75,7 +76,8 @@ int sprintf_(char* buffer, const char* format, ...);
  *         null character. A value equal or larger than count indicates truncation. Only when the returned value
  *         is non-negative and less than count, the string has been completely written.
  */
-int snprintf_(char* buffer, size_t count, const char* format, ...);
+int snprintf_(char* buffer, size_t count, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 3, 4)));
 int vsnprintf_(char* buffer, size_t count, const char* format, va_list va);
 
 /**
@@ -94,7 +96,8 @@ int vprintf_(const char* format, va_list va);
  * \param format A string that specifies the format of the output
  * \return The number of characters that are sent to the output function, not counting the terminating null character
  */
-int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...);
+int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 3, 4)));
 
 #ifdef __cplusplus
 }
diff --git a/lib/subghz/protocols/came_atomo.c b/lib/subghz/protocols/came_atomo.c
index 1349d976e..8c2a542c2 100644
--- a/lib/subghz/protocols/came_atomo.c
+++ b/lib/subghz/protocols/came_atomo.c
@@ -338,7 +338,7 @@ void subghz_protocol_decoder_came_atomo_get_string(void* context, FuriString* ou
         "%s %db\r\n"
         "Key:0x%lX%08lX\r\n"
         "Sn:0x%08lX  Btn:0x%01X\r\n"
-        "Cnt:0x%03X\r\n",
+        "Cnt:0x%03lX\r\n",
 
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
diff --git a/lib/subghz/protocols/came_twee.c b/lib/subghz/protocols/came_twee.c
index 65667be21..3d5029ec9 100644
--- a/lib/subghz/protocols/came_twee.c
+++ b/lib/subghz/protocols/came_twee.c
@@ -457,7 +457,7 @@ void subghz_protocol_decoder_came_twee_get_string(void* context, FuriString* out
         output,
         "%s %db\r\n"
         "Key:0x%lX%08lX\r\n"
-        "Btn:%lX\r\n"
+        "Btn:%X\r\n"
         "DIP:" DIP_PATTERN "\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
diff --git a/lib/subghz/protocols/doitrand.c b/lib/subghz/protocols/doitrand.c
index eeab2576e..5c3402144 100644
--- a/lib/subghz/protocols/doitrand.c
+++ b/lib/subghz/protocols/doitrand.c
@@ -345,7 +345,7 @@ void subghz_protocol_decoder_doitrand_get_string(void* context, FuriString* outp
         output,
         "%s %dbit\r\n"
         "Key:%02lX%08lX\r\n"
-        "Btn:%lX\r\n"
+        "Btn:%X\r\n"
         "DIP:" DIP_PATTERN "\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
diff --git a/lib/subghz/protocols/faac_slh.c b/lib/subghz/protocols/faac_slh.c
index 75f8d4e97..b54435902 100644
--- a/lib/subghz/protocols/faac_slh.c
+++ b/lib/subghz/protocols/faac_slh.c
@@ -222,7 +222,7 @@ void subghz_protocol_decoder_faac_slh_get_string(void* context, FuriString* outp
         "Key:%lX%08lX\r\n"
         "Fix:%08lX \r\n"
         "Hop:%08lX \r\n"
-        "Sn:%07lX Btn:%lX\r\n",
+        "Sn:%07lX Btn:%X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)(instance->generic.data >> 32),
diff --git a/lib/subghz/protocols/gate_tx.c b/lib/subghz/protocols/gate_tx.c
index 73a509261..5cf3a8714 100644
--- a/lib/subghz/protocols/gate_tx.c
+++ b/lib/subghz/protocols/gate_tx.c
@@ -325,7 +325,7 @@ void subghz_protocol_decoder_gate_tx_get_string(void* context, FuriString* outpu
         output,
         "%s %dbit\r\n"
         "Key:%06lX\r\n"
-        "Sn:%05lX  Btn:%lX\r\n",
+        "Sn:%05lX  Btn:%X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)(instance->generic.data & 0xFFFFFF),
diff --git a/lib/subghz/protocols/honeywell_wdb.c b/lib/subghz/protocols/honeywell_wdb.c
index 326e79f83..3cd62698d 100644
--- a/lib/subghz/protocols/honeywell_wdb.c
+++ b/lib/subghz/protocols/honeywell_wdb.c
@@ -385,7 +385,7 @@ void subghz_protocol_decoder_honeywell_wdb_get_string(void* context, FuriString*
         "Key:0x%lX%08lX\r\n"
         "Sn:0x%05lX\r\n"
         "DT:%s  Al:%s\r\n"
-        "SK:%01lX R:%01lX LBat:%01lX\r\n",
+        "SK:%01X R:%01X LBat:%01X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)((instance->generic.data >> 32) & 0xFFFFFFFF),
diff --git a/lib/subghz/protocols/ido.c b/lib/subghz/protocols/ido.c
index a0332f9e5..6cc60bde8 100644
--- a/lib/subghz/protocols/ido.c
+++ b/lib/subghz/protocols/ido.c
@@ -221,7 +221,7 @@ void subghz_protocol_decoder_ido_get_string(void* context, FuriString* output) {
         "Key:0x%lX%08lX\r\n"
         "Fix:%06lX \r\n"
         "Hop:%06lX \r\n"
-        "Sn:%05lX Btn:%lX\r\n",
+        "Sn:%05lX Btn:%X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)(instance->generic.data >> 32),
diff --git a/lib/subghz/protocols/keeloq.c b/lib/subghz/protocols/keeloq.c
index 2865309ee..039d97a6a 100644
--- a/lib/subghz/protocols/keeloq.c
+++ b/lib/subghz/protocols/keeloq.c
@@ -700,8 +700,8 @@ void subghz_protocol_decoder_keeloq_get_string(void* context, FuriString* output
         output,
         "%s %dbit\r\n"
         "Key:%08lX%08lX\r\n"
-        "Fix:0x%08lX    Cnt:%04X\r\n"
-        "Hop:0x%08lX    Btn:%01lX\r\n"
+        "Fix:0x%08lX    Cnt:%04lX\r\n"
+        "Hop:0x%08lX    Btn:%01X\r\n"
         "MF:%s\r\n"
         "Sn:0x%07lX \r\n",
         instance->generic.protocol_name,
diff --git a/lib/subghz/protocols/kia.c b/lib/subghz/protocols/kia.c
index aad26f16a..d46838661 100644
--- a/lib/subghz/protocols/kia.c
+++ b/lib/subghz/protocols/kia.c
@@ -268,7 +268,7 @@ void subghz_protocol_decoder_kia_get_string(void* context, FuriString* output) {
         output,
         "%s %dbit\r\n"
         "Key:%08lX%08lX\r\n"
-        "Sn:%07lX Btn:%lX Cnt:%04X\r\n",
+        "Sn:%07lX Btn:%X Cnt:%04lX\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         code_found_hi,
diff --git a/lib/subghz/protocols/magellen.c b/lib/subghz/protocols/magellen.c
index 0c801c08e..160ec4a2c 100644
--- a/lib/subghz/protocols/magellen.c
+++ b/lib/subghz/protocols/magellen.c
@@ -432,7 +432,7 @@ void subghz_protocol_decoder_magellen_get_string(void* context, FuriString* outp
         output,
         "%s %dbit\r\n"
         "Key:0x%08lX\r\n"
-        "Sn:%03d%03d, Event:0x%02X\r\n"
+        "Sn:%03ld%03ld, Event:0x%02X\r\n"
         "Stat:",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
diff --git a/lib/subghz/protocols/marantec.c b/lib/subghz/protocols/marantec.c
index 1c3997b97..a72238a41 100644
--- a/lib/subghz/protocols/marantec.c
+++ b/lib/subghz/protocols/marantec.c
@@ -383,7 +383,7 @@ void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* outp
         "%s %db\r\n"
         "Key:0x%lX%08lX\r\n"
         "Sn:0x%07lX \r\n"
-        "Btn:%lX\r\n",
+        "Btn:%X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)(instance->generic.data >> 32),
diff --git a/lib/subghz/protocols/megacode.c b/lib/subghz/protocols/megacode.c
index 40f22cfdb..baa8188d3 100644
--- a/lib/subghz/protocols/megacode.c
+++ b/lib/subghz/protocols/megacode.c
@@ -417,8 +417,8 @@ void subghz_protocol_decoder_megacode_get_string(void* context, FuriString* outp
         output,
         "%s %dbit\r\n"
         "Key:0x%06lX\r\n"
-        "Sn:0x%04lX - %d\r\n"
-        "Facility:%X Btn:%X\r\n",
+        "Sn:0x%04lX - %ld\r\n"
+        "Facility:%lX Btn:%X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)instance->generic.data,
diff --git a/lib/subghz/protocols/nice_flor_s.c b/lib/subghz/protocols/nice_flor_s.c
index ffd94811f..d567ddf2c 100644
--- a/lib/subghz/protocols/nice_flor_s.c
+++ b/lib/subghz/protocols/nice_flor_s.c
@@ -368,7 +368,7 @@ void subghz_protocol_decoder_nice_flor_s_get_string(void* context, FuriString* o
         "%s %dbit\r\n"
         "Key:0x%lX%08lX\r\n"
         "Sn:%05lX\r\n"
-        "Cnt:%04X Btn:%02lX\r\n",
+        "Cnt:%04lX Btn:%02X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         code_found_hi,
diff --git a/lib/subghz/protocols/oregon2.c b/lib/subghz/protocols/oregon2.c
index 48435502f..561df819f 100644
--- a/lib/subghz/protocols/oregon2.c
+++ b/lib/subghz/protocols/oregon2.c
@@ -253,7 +253,7 @@ static void
         val = ((var_data >> 4) & 0xF) * 10 + ((var_data >> 8) & 0xF);
         furi_string_cat_printf(
             output,
-            "Temp: %s%d.%d C\r\n",
+            "Temp: %s%ld.%ld C\r\n",
             (var_data & 0xF) ? "-" : "+",
             val,
             (uint32_t)(var_data >> 12) & 0xF);
@@ -286,7 +286,7 @@ void subghz_protocol_decoder_oregon2_get_string(void* context, FuriString* outpu
     furi_string_cat_printf(
         output,
         "%s\r\n"
-        "ID: 0x%04lX, ch: %d%s, rc: 0x%02lX\r\n",
+        "ID: 0x%04lX, ch: %ld%s, rc: 0x%02lX\r\n",
         instance->generic.protocol_name,
         (uint32_t)sensor_id,
         (uint32_t)(instance->generic.data >> 12) & 0xF,
diff --git a/lib/subghz/protocols/phoenix_v2.c b/lib/subghz/protocols/phoenix_v2.c
index e97df9b65..019c3ec25 100644
--- a/lib/subghz/protocols/phoenix_v2.c
+++ b/lib/subghz/protocols/phoenix_v2.c
@@ -329,7 +329,7 @@ void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* ou
         "%s %dbit\r\n"
         "Key:%02lX%08lX\r\n"
         "Sn:0x%07lX \r\n"
-        "Btn:%lX\r\n",
+        "Btn:%X\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)(instance->generic.data >> 32) & 0xFFFFFFFF,
diff --git a/lib/subghz/protocols/princeton.c b/lib/subghz/protocols/princeton.c
index c981de1b8..370f33fb0 100644
--- a/lib/subghz/protocols/princeton.c
+++ b/lib/subghz/protocols/princeton.c
@@ -364,7 +364,7 @@ void subghz_protocol_decoder_princeton_get_string(void* context, FuriString* out
         "Key:0x%08lX\r\n"
         "Yek:0x%08lX\r\n"
         "Sn:0x%05lX Btn:%01X\r\n"
-        "Te:%dus\r\n",
+        "Te:%ldus\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         (uint32_t)(instance->generic.data & 0xFFFFFF),
diff --git a/lib/subghz/protocols/princeton_for_testing.c b/lib/subghz/protocols/princeton_for_testing.c
index 43078d2e2..0987e0ad6 100644
--- a/lib/subghz/protocols/princeton_for_testing.c
+++ b/lib/subghz/protocols/princeton_for_testing.c
@@ -94,7 +94,7 @@ void subghz_encoder_princeton_for_testing_print_log(void* context) {
         ((float)instance->time_high / (instance->time_high + instance->time_low)) * 100;
     FURI_LOG_I(
         TAG "Encoder",
-        "Radio tx_time=%dus  ON=%dus, OFF=%dus, DutyCycle=%d,%d%%",
+        "Radio tx_time=%ldus  ON=%ldus, OFF=%ldus, DutyCycle=%ld,%ld%%",
         instance->time_high + instance->time_low,
         instance->time_high,
         instance->time_low,
diff --git a/lib/subghz/protocols/raw.c b/lib/subghz/protocols/raw.c
index 48c3ff4df..fd234502a 100644
--- a/lib/subghz/protocols/raw.c
+++ b/lib/subghz/protocols/raw.c
@@ -115,7 +115,7 @@ bool subghz_protocol_raw_save_to_file_init(
         // Open file
         if(!flipper_format_file_open_always(
                instance->flipper_file, furi_string_get_cstr(temp_str))) {
-            FURI_LOG_E(TAG, "Unable to open file for write: %s", temp_str);
+            FURI_LOG_E(TAG, "Unable to open file for write: %s", furi_string_get_cstr(temp_str));
             break;
         }
 
diff --git a/lib/subghz/protocols/scher_khan.c b/lib/subghz/protocols/scher_khan.c
index 617efbbab..837dcf058 100644
--- a/lib/subghz/protocols/scher_khan.c
+++ b/lib/subghz/protocols/scher_khan.c
@@ -274,7 +274,7 @@ void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* ou
         output,
         "%s %dbit\r\n"
         "Key:0x%lX%08lX\r\n"
-        "Sn:%07lX Btn:%lX Cnt:%04X\r\n"
+        "Sn:%07lX Btn:%X Cnt:%04lX\r\n"
         "Pt: %s\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
diff --git a/lib/subghz/protocols/secplus_v1.c b/lib/subghz/protocols/secplus_v1.c
index 885615b6e..cfe6bdee5 100644
--- a/lib/subghz/protocols/secplus_v1.c
+++ b/lib/subghz/protocols/secplus_v1.c
@@ -606,7 +606,7 @@ void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* ou
         furi_string_cat_printf(
             output,
             "Sn:0x%08lX\r\n"
-            "Cnt:0x%03X\r\n"
+            "Cnt:0x%03lX\r\n"
             "Sw_id:0x%X\r\n",
             instance->generic.serial,
             instance->generic.cnt,
@@ -625,7 +625,7 @@ void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* ou
         furi_string_cat_printf(
             output,
             "Sn:0x%08lX\r\n"
-            "Cnt:0x%03X\r\n"
+            "Cnt:0x%03lX\r\n"
             "Sw_id:0x%X\r\n",
             instance->generic.serial,
             instance->generic.cnt,
diff --git a/lib/subghz/protocols/secplus_v2.c b/lib/subghz/protocols/secplus_v2.c
index 3c9b966a9..73bb7802b 100644
--- a/lib/subghz/protocols/secplus_v2.c
+++ b/lib/subghz/protocols/secplus_v2.c
@@ -821,7 +821,7 @@ void subghz_protocol_decoder_secplus_v2_get_string(void* context, FuriString* ou
         "Pk1:0x%lX%08lX\r\n"
         "Pk2:0x%lX%08lX\r\n"
         "Sn:0x%08lX  Btn:0x%01X\r\n"
-        "Cnt:0x%03X\r\n",
+        "Cnt:0x%03lX\r\n",
 
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
diff --git a/lib/subghz/protocols/somfy_keytis.c b/lib/subghz/protocols/somfy_keytis.c
index e1b750749..cf627ef37 100644
--- a/lib/subghz/protocols/somfy_keytis.c
+++ b/lib/subghz/protocols/somfy_keytis.c
@@ -437,7 +437,7 @@ void subghz_protocol_decoder_somfy_keytis_get_string(void* context, FuriString*
         "%s %db\r\n"
         "%lX%08lX%06lX\r\n"
         "Sn:0x%06lX \r\n"
-        "Cnt:0x%04X\r\n"
+        "Cnt:0x%04lX\r\n"
         "Btn:%s\r\n",
 
         instance->generic.protocol_name,
diff --git a/lib/subghz/protocols/somfy_telis.c b/lib/subghz/protocols/somfy_telis.c
index 1dfdf0c43..6e375bb38 100644
--- a/lib/subghz/protocols/somfy_telis.c
+++ b/lib/subghz/protocols/somfy_telis.c
@@ -374,7 +374,7 @@ void subghz_protocol_decoder_somfy_telis_get_string(void* context, FuriString* o
         "%s %db\r\n"
         "Key:0x%lX%08lX\r\n"
         "Sn:0x%06lX \r\n"
-        "Cnt:0x%04X\r\n"
+        "Cnt:0x%04lX\r\n"
         "Btn:%s\r\n",
 
         instance->generic.protocol_name,
diff --git a/lib/subghz/protocols/star_line.c b/lib/subghz/protocols/star_line.c
index a8b0dad73..4b89bd2bf 100644
--- a/lib/subghz/protocols/star_line.c
+++ b/lib/subghz/protocols/star_line.c
@@ -373,8 +373,8 @@ void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* out
         output,
         "%s %dbit\r\n"
         "Key:%08lX%08lX\r\n"
-        "Fix:0x%08lX    Cnt:%04X\r\n"
-        "Hop:0x%08lX    Btn:%02lX\r\n"
+        "Fix:0x%08lX    Cnt:%04lX\r\n"
+        "Hop:0x%08lX    Btn:%02X\r\n"
         "MF:%s\r\n"
         "Sn:0x%07lX \r\n",
         instance->generic.protocol_name,
diff --git a/lib/subghz/subghz_file_encoder_worker.c b/lib/subghz/subghz_file_encoder_worker.c
index 1b8e99f19..29834b412 100644
--- a/lib/subghz/subghz_file_encoder_worker.c
+++ b/lib/subghz/subghz_file_encoder_worker.c
@@ -1,5 +1,4 @@
 #include "subghz_file_encoder_worker.h"
-#include <stream_buffer.h>
 
 #include <toolbox/stream/stream.h>
 #include <flipper_format/flipper_format.h>
@@ -11,7 +10,7 @@
 
 struct SubGhzFileEncoderWorker {
     FuriThread* thread;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
 
     Storage* storage;
     FlipperFormat* flipper_format;
@@ -48,7 +47,7 @@ void subghz_file_encoder_worker_add_level_duration(
 
     if(res) {
         instance->level = !instance->level;
-        xStreamBufferSend(instance->stream, &duration, sizeof(int32_t), 100);
+        furi_stream_buffer_send(instance->stream, &duration, sizeof(int32_t), 100);
     } else {
         FURI_LOG_E(TAG, "Invalid level in the stream");
     }
@@ -83,10 +82,7 @@ LevelDuration subghz_file_encoder_worker_get_level_duration(void* context) {
     furi_assert(context);
     SubGhzFileEncoderWorker* instance = context;
     int32_t duration;
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-    int ret = xStreamBufferReceiveFromISR(
-        instance->stream, &duration, sizeof(int32_t), &xHigherPriorityTaskWoken);
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+    int ret = furi_stream_buffer_receive(instance->stream, &duration, sizeof(int32_t), 0);
     if(ret == sizeof(int32_t)) {
         LevelDuration level_duration = {.level = LEVEL_DURATION_RESET};
         if(duration < 0) {
@@ -137,7 +133,7 @@ static int32_t subghz_file_encoder_worker_thread(void* context) {
     } while(0);
 
     while(res && instance->worker_running) {
-        size_t stream_free_byte = xStreamBufferSpacesAvailable(instance->stream);
+        size_t stream_free_byte = furi_stream_buffer_spaces_available(instance->stream);
         if((stream_free_byte / sizeof(int32_t)) >= SUBGHZ_FILE_ENCODER_LOAD) {
             if(stream_read_line(stream, instance->str_data)) {
                 furi_string_trim(instance->str_data);
@@ -183,7 +179,7 @@ SubGhzFileEncoderWorker* subghz_file_encoder_worker_alloc() {
     furi_thread_set_stack_size(instance->thread, 2048);
     furi_thread_set_context(instance->thread, instance);
     furi_thread_set_callback(instance->thread, subghz_file_encoder_worker_thread);
-    instance->stream = xStreamBufferCreate(sizeof(int32_t) * 2048, sizeof(int32_t));
+    instance->stream = furi_stream_buffer_alloc(sizeof(int32_t) * 2048, sizeof(int32_t));
 
     instance->storage = furi_record_open(RECORD_STORAGE);
     instance->flipper_format = flipper_format_file_alloc(instance->storage);
@@ -199,7 +195,7 @@ SubGhzFileEncoderWorker* subghz_file_encoder_worker_alloc() {
 void subghz_file_encoder_worker_free(SubGhzFileEncoderWorker* instance) {
     furi_assert(instance);
 
-    vStreamBufferDelete(instance->stream);
+    furi_stream_buffer_free(instance->stream);
     furi_thread_free(instance->thread);
 
     furi_string_free(instance->str_data);
@@ -215,7 +211,7 @@ bool subghz_file_encoder_worker_start(SubGhzFileEncoderWorker* instance, const c
     furi_assert(instance);
     furi_assert(!instance->worker_running);
 
-    xStreamBufferReset(instance->stream);
+    furi_stream_buffer_reset(instance->stream);
     furi_string_set(instance->file_path, file_path);
     instance->worker_running = true;
     furi_thread_start(instance->thread);
diff --git a/lib/subghz/subghz_tx_rx_worker.c b/lib/subghz/subghz_tx_rx_worker.c
index 78a186931..37c0bfc5e 100644
--- a/lib/subghz/subghz_tx_rx_worker.c
+++ b/lib/subghz/subghz_tx_rx_worker.c
@@ -1,6 +1,5 @@
 #include "subghz_tx_rx_worker.h"
 
-#include <stream_buffer.h>
 #include <furi.h>
 
 #define TAG "SubGhzTxRxWorker"
@@ -13,8 +12,8 @@
 
 struct SubGhzTxRxWorker {
     FuriThread* thread;
-    StreamBufferHandle_t stream_tx;
-    StreamBufferHandle_t stream_rx;
+    FuriStreamBuffer* stream_tx;
+    FuriStreamBuffer* stream_rx;
 
     volatile bool worker_running;
     volatile bool worker_stoping;
@@ -30,9 +29,9 @@ struct SubGhzTxRxWorker {
 bool subghz_tx_rx_worker_write(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
     furi_assert(instance);
     bool ret = false;
-    size_t stream_tx_free_byte = xStreamBufferSpacesAvailable(instance->stream_tx);
+    size_t stream_tx_free_byte = furi_stream_buffer_spaces_available(instance->stream_tx);
     if(size && (stream_tx_free_byte >= size)) {
-        if(xStreamBufferSend(
+        if(furi_stream_buffer_send(
                instance->stream_tx, data, size, SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF) ==
            size) {
             ret = true;
@@ -43,12 +42,12 @@ bool subghz_tx_rx_worker_write(SubGhzTxRxWorker* instance, uint8_t* data, size_t
 
 size_t subghz_tx_rx_worker_available(SubGhzTxRxWorker* instance) {
     furi_assert(instance);
-    return xStreamBufferBytesAvailable(instance->stream_rx);
+    return furi_stream_buffer_bytes_available(instance->stream_rx);
 }
 
 size_t subghz_tx_rx_worker_read(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
     furi_assert(instance);
-    return xStreamBufferReceive(instance->stream_rx, data, size, 0);
+    return furi_stream_buffer_receive(instance->stream_rx, data, size, 0);
 }
 
 void subghz_tx_rx_worker_set_callback_have_read(
@@ -148,11 +147,11 @@ static int32_t subghz_tx_rx_worker_thread(void* context) {
 
     while(instance->worker_running) {
         //transmit
-        size_tx = xStreamBufferBytesAvailable(instance->stream_tx);
+        size_tx = furi_stream_buffer_bytes_available(instance->stream_tx);
         if(size_tx > 0 && !timeout_tx) {
             timeout_tx = 10; //20ms
             if(size_tx > SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE) {
-                xStreamBufferReceive(
+                furi_stream_buffer_receive(
                     instance->stream_tx,
                     &data,
                     SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE,
@@ -160,20 +159,20 @@ static int32_t subghz_tx_rx_worker_thread(void* context) {
                 subghz_tx_rx_worker_tx(instance, data, SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE);
             } else {
                 //todo checking that he managed to write all the data to the TX buffer
-                xStreamBufferReceive(
+                furi_stream_buffer_receive(
                     instance->stream_tx, &data, size_tx, SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF);
                 subghz_tx_rx_worker_tx(instance, data, size_tx);
             }
         } else {
             //recive
             if(subghz_tx_rx_worker_rx(instance, data, size_rx)) {
-                if(xStreamBufferSpacesAvailable(instance->stream_rx) >= size_rx[0]) {
+                if(furi_stream_buffer_spaces_available(instance->stream_rx) >= size_rx[0]) {
                     if(instance->callback_have_read &&
-                       xStreamBufferBytesAvailable(instance->stream_rx) == 0) {
+                       furi_stream_buffer_bytes_available(instance->stream_rx) == 0) {
                         callback_rx = true;
                     }
                     //todo checking that he managed to write all the data to the RX buffer
-                    xStreamBufferSend(
+                    furi_stream_buffer_send(
                         instance->stream_rx,
                         &data,
                         size_rx[0],
@@ -208,9 +207,9 @@ SubGhzTxRxWorker* subghz_tx_rx_worker_alloc() {
     furi_thread_set_context(instance->thread, instance);
     furi_thread_set_callback(instance->thread, subghz_tx_rx_worker_thread);
     instance->stream_tx =
-        xStreamBufferCreate(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
+        furi_stream_buffer_alloc(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
     instance->stream_rx =
-        xStreamBufferCreate(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
+        furi_stream_buffer_alloc(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
 
     instance->status = SubGhzTxRxWorkerStatusIDLE;
     instance->worker_stoping = true;
@@ -221,8 +220,8 @@ SubGhzTxRxWorker* subghz_tx_rx_worker_alloc() {
 void subghz_tx_rx_worker_free(SubGhzTxRxWorker* instance) {
     furi_assert(instance);
     furi_assert(!instance->worker_running);
-    vStreamBufferDelete(instance->stream_tx);
-    vStreamBufferDelete(instance->stream_rx);
+    furi_stream_buffer_free(instance->stream_tx);
+    furi_stream_buffer_free(instance->stream_rx);
     furi_thread_free(instance->thread);
 
     free(instance);
@@ -232,8 +231,8 @@ bool subghz_tx_rx_worker_start(SubGhzTxRxWorker* instance, uint32_t frequency) {
     furi_assert(instance);
     furi_assert(!instance->worker_running);
     bool res = false;
-    xStreamBufferReset(instance->stream_tx);
-    xStreamBufferReset(instance->stream_rx);
+    furi_stream_buffer_reset(instance->stream_tx);
+    furi_stream_buffer_reset(instance->stream_rx);
 
     instance->worker_running = true;
 
diff --git a/lib/subghz/subghz_worker.c b/lib/subghz/subghz_worker.c
index 58db8ea5d..61146c168 100644
--- a/lib/subghz/subghz_worker.c
+++ b/lib/subghz/subghz_worker.c
@@ -1,13 +1,12 @@
 #include "subghz_worker.h"
 
-#include <stream_buffer.h>
 #include <furi.h>
 
 #define TAG "SubGhzWorker"
 
 struct SubGhzWorker {
     FuriThread* thread;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
 
     volatile bool running;
     volatile bool overrun;
@@ -30,16 +29,14 @@ struct SubGhzWorker {
 void subghz_worker_rx_callback(bool level, uint32_t duration, void* context) {
     SubGhzWorker* instance = context;
 
-    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     LevelDuration level_duration = level_duration_make(level, duration);
     if(instance->overrun) {
         instance->overrun = false;
         level_duration = level_duration_reset();
     }
-    size_t ret = xStreamBufferSendFromISR(
-        instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
+    size_t ret =
+        furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
     if(sizeof(LevelDuration) != ret) instance->overrun = true;
-    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
 }
 
 /** Worker callback thread
@@ -52,8 +49,8 @@ static int32_t subghz_worker_thread_callback(void* context) {
 
     LevelDuration level_duration;
     while(instance->running) {
-        int ret =
-            xStreamBufferReceive(instance->stream, &level_duration, sizeof(LevelDuration), 10);
+        int ret = furi_stream_buffer_receive(
+            instance->stream, &level_duration, sizeof(LevelDuration), 10);
         if(ret == sizeof(LevelDuration)) {
             if(level_duration_is_reset(level_duration)) {
                 FURI_LOG_E(TAG, "Overrun buffer");
@@ -97,7 +94,8 @@ SubGhzWorker* subghz_worker_alloc() {
     furi_thread_set_context(instance->thread, instance);
     furi_thread_set_callback(instance->thread, subghz_worker_thread_callback);
 
-    instance->stream = xStreamBufferCreate(sizeof(LevelDuration) * 4096, sizeof(LevelDuration));
+    instance->stream =
+        furi_stream_buffer_alloc(sizeof(LevelDuration) * 4096, sizeof(LevelDuration));
 
     //setting filter
     instance->filter_running = true;
@@ -109,7 +107,7 @@ SubGhzWorker* subghz_worker_alloc() {
 void subghz_worker_free(SubGhzWorker* instance) {
     furi_assert(instance);
 
-    vStreamBufferDelete(instance->stream);
+    furi_stream_buffer_free(instance->stream);
     furi_thread_free(instance->thread);
 
     free(instance);
diff --git a/lib/toolbox/buffer_stream.c b/lib/toolbox/buffer_stream.c
index 66d210963..37b2514ef 100644
--- a/lib/toolbox/buffer_stream.c
+++ b/lib/toolbox/buffer_stream.c
@@ -1,5 +1,4 @@
 #include "buffer_stream.h"
-#include <stream_buffer.h>
 
 struct Buffer {
     volatile bool occupied;
@@ -10,7 +9,7 @@ struct Buffer {
 
 struct BufferStream {
     size_t stream_overrun_count;
-    StreamBufferHandle_t stream;
+    FuriStreamBuffer* stream;
 
     size_t index;
     Buffer* buffers;
@@ -54,7 +53,7 @@ BufferStream* buffer_stream_alloc(size_t buffer_size, size_t buffers_count) {
         buffer_stream->buffers[i].data = malloc(buffer_size);
         buffer_stream->buffers[i].max_data_size = buffer_size;
     }
-    buffer_stream->stream = xStreamBufferCreate(
+    buffer_stream->stream = furi_stream_buffer_alloc(
         sizeof(BufferStream*) * buffer_stream->max_buffers_count, sizeof(BufferStream*));
     buffer_stream->stream_overrun_count = 0;
     buffer_stream->index = 0;
@@ -66,7 +65,7 @@ void buffer_stream_free(BufferStream* buffer_stream) {
     for(size_t i = 0; i < buffer_stream->max_buffers_count; i++) {
         free(buffer_stream->buffers[i].data);
     }
-    vStreamBufferDelete(buffer_stream->stream);
+    furi_stream_buffer_free(buffer_stream->stream);
     free(buffer_stream->buffers);
     free(buffer_stream);
 }
@@ -83,11 +82,7 @@ static inline int8_t buffer_stream_get_free_buffer(BufferStream* buffer_stream)
     return id;
 }
 
-bool buffer_stream_send_from_isr(
-    BufferStream* buffer_stream,
-    const uint8_t* data,
-    size_t size,
-    BaseType_t* const task_woken) {
+bool buffer_stream_send_from_isr(BufferStream* buffer_stream, const uint8_t* data, size_t size) {
     Buffer* buffer = &buffer_stream->buffers[buffer_stream->index];
     bool result = true;
 
@@ -96,7 +91,7 @@ bool buffer_stream_send_from_isr(
         // if buffer is full - send it
         buffer->occupied = true;
         // we always have space for buffer in stream
-        xStreamBufferSendFromISR(buffer_stream->stream, &buffer, sizeof(Buffer*), task_woken);
+        furi_stream_buffer_send(buffer_stream->stream, &buffer, sizeof(Buffer*), 0);
 
         // get new buffer from the pool
         int8_t index = buffer_stream_get_free_buffer(buffer_stream);
@@ -119,7 +114,8 @@ bool buffer_stream_send_from_isr(
 
 Buffer* buffer_stream_receive(BufferStream* buffer_stream, TickType_t timeout) {
     Buffer* buffer;
-    size_t size = xStreamBufferReceive(buffer_stream->stream, &buffer, sizeof(Buffer*), timeout);
+    size_t size =
+        furi_stream_buffer_receive(buffer_stream->stream, &buffer, sizeof(Buffer*), timeout);
 
     if(size == sizeof(Buffer*)) {
         return buffer;
@@ -134,9 +130,8 @@ size_t buffer_stream_get_overrun_count(BufferStream* buffer_stream) {
 
 void buffer_stream_reset(BufferStream* buffer_stream) {
     FURI_CRITICAL_ENTER();
-    BaseType_t xReturn = xStreamBufferReset(buffer_stream->stream);
-    furi_assert(xReturn == pdPASS);
-    UNUSED(xReturn);
+    furi_stream_buffer_reset(buffer_stream->stream);
+
     buffer_stream->stream_overrun_count = 0;
     for(size_t i = 0; i < buffer_stream->max_buffers_count; i++) {
         buffer_reset(&buffer_stream->buffers[i]);
diff --git a/lib/toolbox/buffer_stream.h b/lib/toolbox/buffer_stream.h
index d4c3cddf7..9db547753 100644
--- a/lib/toolbox/buffer_stream.h
+++ b/lib/toolbox/buffer_stream.h
@@ -59,14 +59,9 @@ void buffer_stream_free(BufferStream* buffer_stream);
  * @param buffer_stream 
  * @param data 
  * @param size 
- * @param task_woken 
  * @return bool 
  */
-bool buffer_stream_send_from_isr(
-    BufferStream* buffer_stream,
-    const uint8_t* data,
-    size_t size,
-    BaseType_t* const task_woken);
+bool buffer_stream_send_from_isr(BufferStream* buffer_stream, const uint8_t* data, size_t size);
 
 /**
  * @brief Receive buffer from stream
diff --git a/lib/toolbox/stream/stream.h b/lib/toolbox/stream/stream.h
index 1ffb40445..fc3855102 100644
--- a/lib/toolbox/stream/stream.h
+++ b/lib/toolbox/stream/stream.h
@@ -143,7 +143,8 @@ size_t stream_write_cstring(Stream* stream, const char* string);
  * @param ... 
  * @return size_t how many bytes was written
  */
-size_t stream_write_format(Stream* stream, const char* format, ...);
+size_t stream_write_format(Stream* stream, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 2, 3)));
 
 /**
  * Write formatted string to the stream, va_list version
@@ -200,7 +201,8 @@ bool stream_insert_cstring(Stream* stream, const char* string);
  * @return true if the operation was successful
  * @return false on error
  */
-bool stream_insert_format(Stream* stream, const char* format, ...);
+bool stream_insert_format(Stream* stream, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 2, 3)));
 
 /**
  * Insert formatted string to the stream, va_list version
@@ -251,7 +253,8 @@ bool stream_delete_and_insert_cstring(Stream* stream, size_t delete_size, const
  * @return true if the operation was successful
  * @return false on error
  */
-bool stream_delete_and_insert_format(Stream* stream, size_t delete_size, const char* format, ...);
+bool stream_delete_and_insert_format(Stream* stream, size_t delete_size, const char* format, ...)
+    _ATTRIBUTE((__format__(__printf__, 3, 4)));
 
 /**
  * Delete N chars from the stream and insert formatted string to the stream, va_list version