diff --git a/applications/services/gui/modules/submenu.h b/applications/services/gui/modules/submenu.h
index 702f30e7e..a5b94b2d7 100644
--- a/applications/services/gui/modules/submenu.h
+++ b/applications/services/gui/modules/submenu.h
@@ -53,14 +53,6 @@ void submenu_add_item(
     SubmenuItemCallback callback,
     void* callback_context);
 
-/** Change label of an existing item
- * 
- * @param      submenu  Submenu instance
- * @param      index    The index of the item
- * @param      label    The new label
- */
-void submenu_change_item_label(Submenu* submenu, uint32_t index, const char* label);
-
 /** Add lockable item to submenu
  *
  * @param      submenu           Submenu instance
@@ -81,6 +73,14 @@ void submenu_add_lockable_item(
     bool locked,
     const char* locked_message);
 
+/** Change label of an existing item
+ * 
+ * @param      submenu  Submenu instance
+ * @param      index    The index of the item
+ * @param      label    The new label
+ */
+void submenu_change_item_label(Submenu* submenu, uint32_t index, const char* label);
+
 /** Remove all items from submenu
  *
  * @param      submenu  Submenu instance
diff --git a/applications/system/hid_app/hid.c b/applications/system/hid_app/hid.c
index 91bf79188..6e1ed4a82 100644
--- a/applications/system/hid_app/hid.c
+++ b/applications/system/hid_app/hid.c
@@ -48,6 +48,7 @@ static void bt_hid_connection_status_changed_callback(BtStatus status, void* con
     hid_mouse_set_connected_status(hid->hid_mouse, connected);
     hid_mouse_clicker_set_connected_status(hid->hid_mouse_clicker, connected);
     hid_mouse_jiggler_set_connected_status(hid->hid_mouse_jiggler, connected);
+    hid_mouse_jiggler_stealth_set_connected_status(hid->hid_mouse_jiggler_stealth, connected);
     hid_ptt_set_connected_status(hid->hid_ptt, connected);
     hid_tiktok_set_connected_status(hid->hid_tiktok, connected);
 }
@@ -57,7 +58,7 @@ static uint32_t hid_ptt_menu_view(void* context) {
     return HidViewPushToTalkMenu;
 }
 
-Hid* hid_alloc() {
+Hid* hid_alloc(void) {
     Hid* app = malloc(sizeof(Hid));
 
     // Gui
@@ -146,6 +147,12 @@ Hid* hid_alloc() {
         app->view_dispatcher,
         HidViewMouseJiggler,
         hid_mouse_jiggler_get_view(app->hid_mouse_jiggler));
+    // Mouse jiggler stealth view
+    app->hid_mouse_jiggler_stealth = hid_mouse_jiggler_stealth_alloc(app);
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        HidViewMouseJigglerStealth,
+        hid_mouse_jiggler_stealth_get_view(app->hid_mouse_jiggler_stealth));
 
     // PushToTalk view
     app->hid_ptt_menu = hid_ptt_menu_alloc(app);
@@ -191,6 +198,8 @@ void hid_free(Hid* app) {
     hid_mouse_clicker_free(app->hid_mouse_clicker);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewMouseJiggler);
     hid_mouse_jiggler_free(app->hid_mouse_jiggler);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewMouseJigglerStealth);
+    hid_mouse_jiggler_stealth_free(app->hid_mouse_jiggler_stealth);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewPushToTalkMenu);
     hid_ptt_menu_free(app->hid_ptt_menu);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewPushToTalk);
diff --git a/applications/system/hid_app/hid.h b/applications/system/hid_app/hid.h
index 0024812a2..ac565217a 100644
--- a/applications/system/hid_app/hid.h
+++ b/applications/system/hid_app/hid.h
@@ -27,6 +27,7 @@
 #include "views/hid_mouse.h"
 #include "views/hid_mouse_clicker.h"
 #include "views/hid_mouse_jiggler.h"
+#include "views/hid_mouse_jiggler_stealth.h"
 #include "views/hid_tiktok.h"
 #include "views/hid_ptt.h"
 #include "views/hid_ptt_menu.h"
@@ -56,6 +57,7 @@ struct Hid {
     HidMouse* hid_mouse;
     HidMouseClicker* hid_mouse_clicker;
     HidMouseJiggler* hid_mouse_jiggler;
+    HidMouseJigglerStealth* hid_mouse_jiggler_stealth;
     HidTikTok* hid_tiktok;
     HidPushToTalk* hid_ptt;
     HidPushToTalkMenu* hid_ptt_menu;
diff --git a/applications/system/hid_app/scenes/hid_scene_config.h b/applications/system/hid_app/scenes/hid_scene_config.h
index d18b15558..4491012ff 100644
--- a/applications/system/hid_app/scenes/hid_scene_config.h
+++ b/applications/system/hid_app/scenes/hid_scene_config.h
@@ -1,3 +1,3 @@
 ADD_SCENE(hid, start, Start)
 ADD_SCENE(hid, main, Main)
-ADD_SCENE(hid, unpair, Unpair)
+ADD_SCENE(hid, unpair, Unpair)
\ No newline at end of file
diff --git a/applications/system/hid_app/scenes/hid_scene_main.c b/applications/system/hid_app/scenes/hid_scene_main.c
index 1d0ca5ef4..cd1051ac7 100644
--- a/applications/system/hid_app/scenes/hid_scene_main.c
+++ b/applications/system/hid_app/scenes/hid_scene_main.c
@@ -3,6 +3,7 @@
 
 void hid_scene_main_on_enter(void* context) {
     Hid* app = context;
+
     view_dispatcher_switch_to_view(
         app->view_dispatcher, scene_manager_get_scene_state(app->scene_manager, HidSceneMain));
 }
diff --git a/applications/system/hid_app/scenes/hid_scene_start.c b/applications/system/hid_app/scenes/hid_scene_start.c
index 5fb1dd343..61d340eec 100644
--- a/applications/system/hid_app/scenes/hid_scene_start.c
+++ b/applications/system/hid_app/scenes/hid_scene_start.c
@@ -13,6 +13,7 @@ enum HidSubmenuIndex {
     HidSubmenuIndexMouse,
     HidSubmenuIndexMouseClicker,
     HidSubmenuIndexMouseJiggler,
+    HidSubmenuIndexMouseJigglerStealth,
     HidSubmenuIndexPushToTalk,
     HidSubmenuIndexRemovePairing,
 };
@@ -67,6 +68,12 @@ void hid_scene_start_on_enter(void* context) {
         HidSubmenuIndexMouseJiggler,
         hid_scene_start_submenu_callback,
         app);
+    submenu_add_item(
+        app->submenu,
+        "Mouse Jiggler Stealth",
+        HidSubmenuIndexMouseJigglerStealth,
+        hid_scene_start_submenu_callback,
+        app);
     submenu_add_item(
         app->submenu,
         "PushToTalk",
@@ -133,6 +140,9 @@ bool hid_scene_start_on_event(void* context, SceneManagerEvent event) {
             case HidSubmenuIndexMouseJiggler:
                 view_id = HidViewMouseJiggler;
                 break;
+            case HidSubmenuIndexMouseJigglerStealth:
+                view_id = HidViewMouseJigglerStealth;
+                break;
             case HidSubmenuIndexPushToTalk:
                 view_id = HidViewPushToTalkMenu;
                 break;
diff --git a/applications/system/hid_app/views.h b/applications/system/hid_app/views.h
index 6fc8531ae..71cd30e5d 100644
--- a/applications/system/hid_app/views.h
+++ b/applications/system/hid_app/views.h
@@ -9,6 +9,7 @@ typedef enum {
     HidViewMouse,
     HidViewMouseClicker,
     HidViewMouseJiggler,
+    HidViewMouseJigglerStealth,
     BtHidViewTikTok,
     HidViewPushToTalk,
     HidViewPushToTalkMenu,
diff --git a/applications/system/hid_app/views/hid_keyboard.c b/applications/system/hid_app/views/hid_keyboard.c
index 9dd2ad655..83c2a584a 100644
--- a/applications/system/hid_app/views/hid_keyboard.c
+++ b/applications/system/hid_app/views/hid_keyboard.c
@@ -228,7 +228,7 @@ static void hid_keyboard_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidKeyboardModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(!model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
@@ -400,8 +400,7 @@ HidKeyboard* hid_keyboard_alloc(Hid* bt_hid) {
     view_set_draw_callback(hid_keyboard->view, hid_keyboard_draw_callback);
     view_set_input_callback(hid_keyboard->view, hid_keyboard_input_callback);
 
-    with_view_model(
-        hid_keyboard->view, HidKeyboardModel * model, { model->y = 1; }, true);
+    with_view_model(hid_keyboard->view, HidKeyboardModel * model, { model->y = 1; }, true);
 
     return hid_keyboard;
 }
diff --git a/applications/system/hid_app/views/hid_keynote.c b/applications/system/hid_app/views/hid_keynote.c
index 793f6e5d3..3c966e20c 100644
--- a/applications/system/hid_app/views/hid_keynote.c
+++ b/applications/system/hid_app/views/hid_keynote.c
@@ -38,7 +38,7 @@ static void hid_keynote_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidKeynoteModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -114,7 +114,7 @@ static void hid_keynote_draw_vertical_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidKeynoteModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -273,6 +273,7 @@ HidKeynote* hid_keynote_alloc(Hid* hid) {
     view_allocate_model(hid_keynote->view, ViewModelTypeLocking, sizeof(HidKeynoteModel));
     view_set_draw_callback(hid_keynote->view, hid_keynote_draw_callback);
     view_set_input_callback(hid_keynote->view, hid_keynote_input_callback);
+
     return hid_keynote;
 }
 
diff --git a/applications/system/hid_app/views/hid_media.c b/applications/system/hid_app/views/hid_media.c
index e99065f74..104e8a6c6 100644
--- a/applications/system/hid_app/views/hid_media.c
+++ b/applications/system/hid_app/views/hid_media.c
@@ -41,7 +41,7 @@ static void hid_media_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidMediaModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -208,6 +208,7 @@ HidMedia* hid_media_alloc(Hid* hid) {
     view_allocate_model(hid_media->view, ViewModelTypeLocking, sizeof(HidMediaModel));
     view_set_draw_callback(hid_media->view, hid_media_draw_callback);
     view_set_input_callback(hid_media->view, hid_media_input_callback);
+
     return hid_media;
 }
 
diff --git a/applications/system/hid_app/views/hid_mouse.c b/applications/system/hid_app/views/hid_mouse.c
index 4f568b26c..6822fecf0 100644
--- a/applications/system/hid_app/views/hid_mouse.c
+++ b/applications/system/hid_app/views/hid_mouse.c
@@ -27,7 +27,7 @@ static void hid_mouse_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidMouseModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -226,6 +226,7 @@ HidMouse* hid_mouse_alloc(Hid* hid) {
     view_allocate_model(hid_mouse->view, ViewModelTypeLocking, sizeof(HidMouseModel));
     view_set_draw_callback(hid_mouse->view, hid_mouse_draw_callback);
     view_set_input_callback(hid_mouse->view, hid_mouse_input_callback);
+
     return hid_mouse;
 }
 
diff --git a/applications/system/hid_app/views/hid_mouse_clicker.c b/applications/system/hid_app/views/hid_mouse_clicker.c
index 3a2a064cb..0552650df 100644
--- a/applications/system/hid_app/views/hid_mouse_clicker.c
+++ b/applications/system/hid_app/views/hid_mouse_clicker.c
@@ -42,7 +42,7 @@ static void hid_mouse_clicker_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidMouseClickerModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -52,37 +52,37 @@ static void hid_mouse_clicker_draw_callback(Canvas* canvas, void* context) {
 #endif
 
     canvas_set_font(canvas, FontPrimary);
-    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse Clicker");
-    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text_aligned(canvas, 27, 3, AlignLeft, AlignTop, "Mouse Clicker");
 
     // Ok
-    canvas_draw_icon(canvas, 58, 25, &I_Space_65x18);
-
+    canvas_draw_icon(canvas, 63, 25, &I_Space_65x18);
     if(model->running) {
-        elements_slightly_rounded_box(canvas, 61, 27, 60, 13);
+        canvas_set_font(canvas, FontPrimary);
+
+        FuriString* rate_label = furi_string_alloc();
+        furi_string_printf(rate_label, "%d clicks/s\n\nUp / Down", model->rate);
+        elements_multiline_text(canvas, AlignLeft, 35, furi_string_get_cstr(rate_label));
+        canvas_set_font(canvas, FontSecondary);
+        furi_string_free(rate_label);
+
+        elements_slightly_rounded_box(canvas, 66, 27, 60, 13);
         canvas_set_color(canvas, ColorWhite);
-    }
-
-    canvas_draw_icon(canvas, 69, 29, &I_Ok_btn_9x9);
-
-    if(model->running) {
-        elements_multiline_text_aligned(canvas, 86, 37, AlignLeft, AlignBottom, "Stop");
     } else {
-        elements_multiline_text_aligned(canvas, 86, 37, AlignLeft, AlignBottom, "Start");
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text(canvas, AlignLeft, 35, "Press Start\nto start\nclicking");
+        canvas_set_font(canvas, FontSecondary);
+    }
+    canvas_draw_icon(canvas, 74, 29, &I_Ok_btn_9x9);
+    if(model->running) {
+        elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Stop");
+    } else {
+        elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Start");
     }
     canvas_set_color(canvas, ColorBlack);
 
-    // Clicks/s
-    char label[20];
-    snprintf(label, sizeof(label), "%d clicks/s", model->rate);
-    elements_multiline_text_aligned(canvas, 28, 37, AlignCenter, AlignBottom, label);
-
-    canvas_draw_icon(canvas, 25, 20, &I_ButtonUp_7x4);
-    canvas_draw_icon(canvas, 25, 44, &I_ButtonDown_7x4);
-
     // Back
-    canvas_draw_icon(canvas, 0, 54, &I_Pin_back_arrow_10x8);
-    elements_multiline_text_aligned(canvas, 13, 62, AlignLeft, AlignBottom, "Exit");
+    canvas_draw_icon(canvas, 74, 49, &I_Pin_back_arrow_10x8);
+    elements_multiline_text_aligned(canvas, 91, 57, AlignLeft, AlignBottom, "Quit");
 }
 
 static void hid_mouse_clicker_timer_callback(void* context) {
diff --git a/applications/system/hid_app/views/hid_mouse_jiggler.c b/applications/system/hid_app/views/hid_mouse_jiggler.c
index b0f3d4d09..3040753b6 100644
--- a/applications/system/hid_app/views/hid_mouse_jiggler.c
+++ b/applications/system/hid_app/views/hid_mouse_jiggler.c
@@ -15,15 +15,17 @@ struct HidMouseJiggler {
 typedef struct {
     bool connected;
     bool running;
-    int min_interval; // Minimum interval for random range
-    int max_interval; // Maximum interval for random range
+    int interval_idx;
+    uint8_t counter;
 } HidMouseJigglerModel;
 
+const int intervals[6] = {500, 2000, 5000, 10000, 30000, 60000};
+
 static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
     HidMouseJigglerModel* model = context;
 
-    // Header
+// Header
 #ifdef HID_TRANSPORT_BLE
     if(model->connected) {
         canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -32,26 +34,22 @@ static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
     }
 #endif
 
-    // Title "Mouse Jiggler"
     canvas_set_font(canvas, FontPrimary);
-    elements_multiline_text_aligned(canvas, 17, 2, AlignLeft, AlignTop, "Mouse Jiggler");
+    elements_multiline_text_aligned(canvas, 27, 2, AlignLeft, AlignTop, "Mouse Jiggler");
 
-    // Display the current min interval in minutes
-    canvas_set_font(canvas, FontSecondary); // Assuming there's a smaller font available
-    FuriString* min_interval_str = furi_string_alloc_printf("Min: %d min", model->min_interval);
-    elements_multiline_text_aligned(
-        canvas, 0, 16, AlignLeft, AlignTop, furi_string_get_cstr(min_interval_str));
-    furi_string_free(min_interval_str);
+    // Timeout
+    elements_multiline_text(canvas, AlignLeft, 26, "Interval (ms):");
+    canvas_set_font(canvas, FontSecondary);
+    if(model->interval_idx != 0) canvas_draw_icon(canvas, 74, 19, &I_ButtonLeft_4x7);
+    if(model->interval_idx != (int)COUNT_OF(intervals) - 1)
+        canvas_draw_icon(canvas, 80, 19, &I_ButtonRight_4x7);
+    FuriString* interval_str = furi_string_alloc_printf("%d", intervals[model->interval_idx]);
+    elements_multiline_text(canvas, 91, 26, furi_string_get_cstr(interval_str));
+    furi_string_free(interval_str);
 
-    // Display the current max interval in minutes
-    FuriString* max_interval_str = furi_string_alloc_printf("Max: %d min", model->max_interval);
-    elements_multiline_text_aligned(
-        canvas, 0, 28, AlignLeft, AlignTop, furi_string_get_cstr(max_interval_str));
-    furi_string_free(max_interval_str);
-
-    // "Press Start to jiggle"
     canvas_set_font(canvas, FontPrimary);
-    elements_multiline_text(canvas, AlignLeft, 50, "Press Start\nto jiggle");
+    elements_multiline_text(canvas, AlignLeft, 40, "Press Start\nto jiggle");
+    canvas_set_font(canvas, FontSecondary);
 
     // Ok
     canvas_draw_icon(canvas, 63, 30, &I_Space_65x18);
@@ -80,20 +78,11 @@ static void hid_mouse_jiggler_timer_callback(void* context) {
         HidMouseJigglerModel * model,
         {
             if(model->running) {
-                // Generate a random interval in minutes and convert to milliseconds
-                int randomIntervalMinutes =
-                    model->min_interval + rand() % (model->max_interval - model->min_interval + 1);
-
-                // Randomize the mouse movement distance and direction
-                int move_x = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
-                int move_y = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
-
-                // Perform the mouse move with the randomized values
-                hid_hal_mouse_move(hid_mouse_jiggler->hid, move_x, move_y);
-
-                // Restart timer with the new random interval
-                furi_timer_stop(hid_mouse_jiggler->timer);
-                furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
+                model->counter++;
+                hid_hal_mouse_move(
+                    hid_mouse_jiggler->hid,
+                    (model->counter % 2 == 0) ? MOUSE_MOVE_SHORT : -MOUSE_MOVE_SHORT,
+                    0);
             }
         },
         false);
@@ -115,51 +104,23 @@ static bool hid_mouse_jiggler_input_callback(InputEvent* event, void* context) {
         hid_mouse_jiggler->view,
         HidMouseJigglerModel * model,
         {
-            if(event->type == InputTypePress) {
-                switch(event->key) {
-                case InputKeyOk:
-                    model->running = !model->running;
-                    if(model->running) {
-                        furi_timer_stop(hid_mouse_jiggler->timer);
-                        int randomIntervalMinutes =
-                            model->min_interval +
-                            rand() % (model->max_interval - model->min_interval + 1);
-                        furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
-                    }
-                    consumed = true;
-                    break;
-
-                case InputKeyUp:
-                    if(!model->running && model->min_interval < model->max_interval) {
-                        model->min_interval++; // Increment min interval by 1 minute
-                    }
-                    consumed = true;
-                    break;
-
-                case InputKeyDown:
-                    if(!model->running && model->min_interval > 1) { // Minimum 1 minute
-                        model->min_interval--; // Decrement min interval by 1 minute
-                    }
-                    consumed = true;
-                    break;
-
-                case InputKeyRight:
-                    if(!model->running && model->max_interval < 30) { // Maximum 30 minutes
-                        model->max_interval++; // Increment max interval by 1 minute
-                    }
-                    consumed = true;
-                    break;
-
-                case InputKeyLeft:
-                    if(!model->running && model->max_interval > model->min_interval + 1) {
-                        model->max_interval--; // Decrement max interval by 1 minute
-                    }
-                    consumed = true;
-                    break;
-
-                default:
-                    break;
-                }
+            if(event->type == InputTypePress && event->key == InputKeyOk) {
+                model->running = !model->running;
+                if(model->running) {
+                    furi_timer_stop(hid_mouse_jiggler->timer);
+                    furi_timer_start(hid_mouse_jiggler->timer, intervals[model->interval_idx]);
+                };
+                consumed = true;
+            }
+            if(event->type == InputTypePress && event->key == InputKeyRight && !model->running &&
+               model->interval_idx < (int)COUNT_OF(intervals) - 1) {
+                model->interval_idx++;
+                consumed = true;
+            }
+            if(event->type == InputTypePress && event->key == InputKeyLeft && !model->running &&
+               model->interval_idx > 0) {
+                model->interval_idx--;
+                consumed = true;
             }
         },
         true);
@@ -184,14 +145,7 @@ HidMouseJiggler* hid_mouse_jiggler_alloc(Hid* hid) {
         hid_mouse_jiggler_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
 
     with_view_model(
-        hid_mouse_jiggler->view,
-        HidMouseJigglerModel * model,
-        {
-            // Initialize the min and max interval values
-            model->min_interval = 2; // 2 minutes
-            model->max_interval = 15; // 15 minutes
-        },
-        true);
+        hid_mouse_jiggler->view, HidMouseJigglerModel * model, { model->interval_idx = 2; }, true);
 
     return hid_mouse_jiggler;
 }
diff --git a/applications/system/hid_app/views/hid_mouse_jiggler.h b/applications/system/hid_app/views/hid_mouse_jiggler.h
index 4361e0bde..025a86385 100644
--- a/applications/system/hid_app/views/hid_mouse_jiggler.h
+++ b/applications/system/hid_app/views/hid_mouse_jiggler.h
@@ -2,6 +2,8 @@
 
 #include <gui/view.h>
 
+#define MOUSE_MOVE_SHORT 5
+
 typedef struct Hid Hid;
 typedef struct HidMouseJiggler HidMouseJiggler;
 
diff --git a/applications/system/hid_app/views/hid_mouse_jiggler_stealth.c b/applications/system/hid_app/views/hid_mouse_jiggler_stealth.c
new file mode 100644
index 000000000..736cfbac0
--- /dev/null
+++ b/applications/system/hid_app/views/hid_mouse_jiggler_stealth.c
@@ -0,0 +1,224 @@
+#include "hid_mouse_jiggler_stealth.h"
+#include <gui/elements.h>
+#include "../hid.h"
+
+#include "hid_icons.h"
+
+#define TAG "HidMouseJigglerStealth"
+
+struct HidMouseJigglerStealth {
+    View* view;
+    Hid* hid;
+    FuriTimer* timer;
+};
+
+typedef struct {
+    bool connected;
+    bool running;
+    int min_interval; // Minimum interval for random range
+    int max_interval; // Maximum interval for random range
+} HidMouseJigglerStealthModel;
+
+static void hid_mouse_jiggler_stealth_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMouseJigglerStealthModel* model = context;
+
+// Header
+#ifdef HID_TRANSPORT_BLE
+    if(model->connected) {
+        canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+    } else {
+        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+    }
+#endif
+
+    // Title "Mouse Jiggler"
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 10, 2, AlignLeft, AlignTop, "Mouse Jiggler Stealth");
+
+    // Display the current min interval in minutes
+    canvas_set_font(canvas, FontSecondary); // Assuming there's a smaller font available
+    FuriString* min_interval_str = furi_string_alloc_printf("Min: %d min", model->min_interval);
+    elements_multiline_text_aligned(
+        canvas, 0, 16, AlignLeft, AlignTop, furi_string_get_cstr(min_interval_str));
+    furi_string_free(min_interval_str);
+
+    // Display the current max interval in minutes
+    FuriString* max_interval_str = furi_string_alloc_printf("Max: %d min", model->max_interval);
+    elements_multiline_text_aligned(
+        canvas, 0, 28, AlignLeft, AlignTop, furi_string_get_cstr(max_interval_str));
+    furi_string_free(max_interval_str);
+
+    // "Press Start to jiggle"
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text(canvas, AlignLeft, 50, "Press Start\nto jiggle");
+
+    // Ok
+    canvas_draw_icon(canvas, 63, 30, &I_Space_65x18);
+    if(model->running) {
+        elements_slightly_rounded_box(canvas, 66, 32, 60, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 74, 34, &I_Ok_btn_9x9);
+    if(model->running) {
+        elements_multiline_text_aligned(canvas, 91, 41, AlignLeft, AlignBottom, "Stop");
+    } else {
+        elements_multiline_text_aligned(canvas, 91, 41, AlignLeft, AlignBottom, "Start");
+    }
+    canvas_set_color(canvas, ColorBlack);
+
+    // Back
+    canvas_draw_icon(canvas, 74, 54, &I_Pin_back_arrow_10x8);
+    elements_multiline_text_aligned(canvas, 91, 62, AlignLeft, AlignBottom, "Quit");
+}
+
+static void hid_mouse_jiggler_stealth_timer_callback(void* context) {
+    furi_assert(context);
+    HidMouseJigglerStealth* hid_mouse_jiggler = context;
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerStealthModel * model,
+        {
+            if(model->running) {
+                // Generate a random interval in minutes and convert to milliseconds
+                int randomIntervalMinutes =
+                    model->min_interval + rand() % (model->max_interval - model->min_interval + 1);
+
+                // Randomize the mouse movement distance and direction
+                int move_x = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
+                int move_y = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
+
+                // Perform the mouse move with the randomized values
+                hid_hal_mouse_move(hid_mouse_jiggler->hid, move_x, move_y);
+
+                // Restart timer with the new random interval
+                furi_timer_stop(hid_mouse_jiggler->timer);
+                furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
+            }
+        },
+        false);
+}
+
+static void hid_mouse_jiggler_stealth_exit_callback(void* context) {
+    furi_assert(context);
+    HidMouseJigglerStealth* hid_mouse_jiggler = context;
+    furi_timer_stop(hid_mouse_jiggler->timer);
+}
+
+static bool hid_mouse_jiggler_stealth_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidMouseJigglerStealth* hid_mouse_jiggler = context;
+
+    bool consumed = false;
+
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerStealthModel * model,
+        {
+            if(event->type == InputTypePress) {
+                switch(event->key) {
+                case InputKeyOk:
+                    model->running = !model->running;
+                    if(model->running) {
+                        furi_timer_stop(hid_mouse_jiggler->timer);
+                        int randomIntervalMinutes =
+                            model->min_interval +
+                            rand() % (model->max_interval - model->min_interval + 1);
+                        furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
+                    }
+                    consumed = true;
+                    break;
+
+                case InputKeyUp:
+                    if(!model->running && model->min_interval < model->max_interval) {
+                        model->min_interval++; // Increment min interval by 1 minute
+                    }
+                    consumed = true;
+                    break;
+
+                case InputKeyDown:
+                    if(!model->running && model->min_interval > 1) { // Minimum 1 minute
+                        model->min_interval--; // Decrement min interval by 1 minute
+                    }
+                    consumed = true;
+                    break;
+
+                case InputKeyRight:
+                    if(!model->running && model->max_interval < 30) { // Maximum 30 minutes
+                        model->max_interval++; // Increment max interval by 1 minute
+                    }
+                    consumed = true;
+                    break;
+
+                case InputKeyLeft:
+                    if(!model->running && model->max_interval > model->min_interval + 1) {
+                        model->max_interval--; // Decrement max interval by 1 minute
+                    }
+                    consumed = true;
+                    break;
+
+                default:
+                    break;
+                }
+            }
+        },
+        true);
+
+    return consumed;
+}
+
+HidMouseJigglerStealth* hid_mouse_jiggler_stealth_alloc(Hid* hid) {
+    HidMouseJigglerStealth* hid_mouse_jiggler = malloc(sizeof(HidMouseJigglerStealth));
+
+    hid_mouse_jiggler->view = view_alloc();
+    view_set_context(hid_mouse_jiggler->view, hid_mouse_jiggler);
+    view_allocate_model(
+        hid_mouse_jiggler->view, ViewModelTypeLocking, sizeof(HidMouseJigglerStealthModel));
+    view_set_draw_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_stealth_draw_callback);
+    view_set_input_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_stealth_input_callback);
+    view_set_exit_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_stealth_exit_callback);
+
+    hid_mouse_jiggler->hid = hid;
+
+    hid_mouse_jiggler->timer = furi_timer_alloc(
+        hid_mouse_jiggler_stealth_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
+
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerStealthModel * model,
+        {
+            // Initialize the min and max interval values
+            model->min_interval = 1; // 1 minutes
+            model->max_interval = 4; // 4 minutes
+        },
+        true);
+
+    return hid_mouse_jiggler;
+}
+
+void hid_mouse_jiggler_stealth_free(HidMouseJigglerStealth* hid_mouse_jiggler) {
+    furi_assert(hid_mouse_jiggler);
+
+    furi_timer_stop(hid_mouse_jiggler->timer);
+    furi_timer_free(hid_mouse_jiggler->timer);
+
+    view_free(hid_mouse_jiggler->view);
+
+    free(hid_mouse_jiggler);
+}
+
+View* hid_mouse_jiggler_stealth_get_view(HidMouseJigglerStealth* hid_mouse_jiggler) {
+    furi_assert(hid_mouse_jiggler);
+    return hid_mouse_jiggler->view;
+}
+
+void hid_mouse_jiggler_stealth_set_connected_status(
+    HidMouseJigglerStealth* hid_mouse_jiggler,
+    bool connected) {
+    furi_assert(hid_mouse_jiggler);
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerStealthModel * model,
+        { model->connected = connected; },
+        true);
+}
diff --git a/applications/system/hid_app/views/hid_mouse_jiggler_stealth.h b/applications/system/hid_app/views/hid_mouse_jiggler_stealth.h
new file mode 100644
index 000000000..61b52b3cb
--- /dev/null
+++ b/applications/system/hid_app/views/hid_mouse_jiggler_stealth.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct Hid Hid;
+typedef struct HidMouseJigglerStealth HidMouseJigglerStealth;
+
+HidMouseJigglerStealth* hid_mouse_jiggler_stealth_alloc(Hid* bt_hid);
+
+void hid_mouse_jiggler_stealth_free(HidMouseJigglerStealth* hid_mouse_jiggler);
+
+View* hid_mouse_jiggler_stealth_get_view(HidMouseJigglerStealth* hid_mouse_jiggler);
+
+void hid_mouse_jiggler_stealth_set_connected_status(
+    HidMouseJigglerStealth* hid_mouse_jiggler,
+    bool connected);
diff --git a/applications/system/hid_app/views/hid_numpad.c b/applications/system/hid_app/views/hid_numpad.c
index 7eb8e45c6..7e528e3fb 100644
--- a/applications/system/hid_app/views/hid_numpad.c
+++ b/applications/system/hid_app/views/hid_numpad.c
@@ -143,6 +143,7 @@ static void hid_numpad_draw_callback(Canvas* canvas, void* context) {
             canvas, 7, 60, AlignLeft, AlignBottom, "Waiting for\nConnection...");
     }
     elements_multiline_text_aligned(canvas, 20, 3, AlignLeft, AlignTop, "Numpad");
+
 #else
     elements_multiline_text_aligned(canvas, 12, 3, AlignLeft, AlignTop, "Numpad");
 #endif
diff --git a/lib/subghz/devices/registry.c b/lib/subghz/devices/registry.c
index 779ba81d7..cf044c98a 100644
--- a/lib/subghz/devices/registry.c
+++ b/lib/subghz/devices/registry.c
@@ -23,8 +23,8 @@ void subghz_device_registry_init(void) {
         firmware_api_interface);
 
     //TODO FL-3556: fix path to plugins
-    if(plugin_manager_load_all(subghz_device->manager, "/any/apps_data/subghz/plugins") !=
-       //if(plugin_manager_load_all(subghz_device->manager, APP_DATA_PATH("plugins")) !=
+    //if(plugin_manager_load_all(subghz_device->manager, APP_DATA_PATH("plugins")) !=
+    if(plugin_manager_load_all(subghz_device->manager, "/ext/apps_data/subghz/plugins") !=
        PluginManagerErrorNone) {
         FURI_LOG_E(TAG, "Failed to load all libs");
     }