diff --git a/src/core/display.cpp b/src/core/display.cpp
index 341234ee9..08aa21a77 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -774,38 +774,8 @@ void drawSubmenu(int index, std::vector<Option> &options, const char *title) {
 }
 
 void drawStatusBar() {
-    int i = 0;
     uint8_t bat = getBattery();
-    uint8_t bat_margin = 85;
-    if (bat > 0) {
-        drawBatteryStatus(bat);
-    } else bat_margin = 26;
-    if (sdcardMounted) {
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        tft.setTextSize(FP);
-        tft.drawString("SD", tftWidth - (bat_margin), 12);
-        i++;
-    } // Indication for SD card on screen
-    if (gpsConnected) {
-        drawGpsSmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    }
-    if (WiFi.getMode()) {
-        drawWifiSmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    } // Draw Wifi Symbol beside battery
-    if (isWebUIActive) {
-        drawWebUISmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    } // Draw Wifi Symbol beside battery
-    if (BLEConnected) {
-        drawBLESmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    } // Draw BLE beside Wifi
-    if (isConnectedWireguard) {
-        drawWireguardStatus(tftWidth - (bat_margin + 24 * i), 7);
-        i++;
-    } // Draw Wg bedide BLE, if the others exist, if not, beside battery
+    if (bat > 0) drawBatteryStatus(bat);
 
     if (bruceConfig.theme.border) {
         tft.drawRoundRect(5, 5, tftWidth - 10, tftHeight - 10, 5, bruceConfig.priColor);
@@ -813,9 +783,8 @@ void drawStatusBar() {
     }
 
     if (clock_set) {
-        int clock_fontsize = 1; // Font size of the clock / BRUCE + BRUCE_VERSION
-        setTftDisplay(12, 12, bruceConfig.priColor, clock_fontsize, bruceConfig.bgColor);
-        tft.fillRect(12, 12, 100, clock_fontsize * LH, bruceConfig.bgColor);
+        setTftDisplay(12, 12, bruceConfig.priColor, 1, bruceConfig.bgColor);
+        tft.fillRect(12, 12, 60, LH, bruceConfig.bgColor);
 #if defined(HAS_RTC)
         updateTimeStr(_rtc.getTimeStruct());
 #else
@@ -826,6 +795,67 @@ void drawStatusBar() {
         setTftDisplay(12, 12, bruceConfig.priColor, 1, bruceConfig.bgColor);
         tft.print("BRUCE " + String(BRUCE_VERSION));
     }
+
+    int iconCount = 0;
+    bool showSD   = sdcardMounted;
+    bool showGPS  = gpsConnected;
+    bool showWifi = (WiFi.getMode() != 0);
+    bool showWeb  = isWebUIActive;
+    bool showBLE  = BLEConnected;
+    bool showWG   = isConnectedWireguard;
+    if (showSD)   iconCount++;
+    if (showGPS)  iconCount++;
+    if (showWifi) iconCount++;
+    if (showWeb)  iconCount++;
+    if (showBLE)  iconCount++;
+    if (showWG)   iconCount++;
+
+    if (iconCount > 0) {
+        const int IW  = 16;
+        const int IH  = 16;
+        const int GAP = 6;
+        int totalW = iconCount * IW + (iconCount - 1) * GAP;
+        int sx = (tftWidth - totalW) / 2;
+        int iy = 7;
+        int idx = 0;
+
+        if (showSD) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawSdSmall(x, iy);
+            idx++;
+        }
+        if (showGPS) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawGpsSmall(x, iy);
+            idx++;
+        }
+        if (showWifi) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawWifiSmall(x, iy);
+            idx++;
+        }
+        if (showWeb) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawWebUISmall(x, iy);
+            idx++;
+        }
+        if (showBLE) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawBLESmall(x, iy);
+            idx++;
+        }
+        if (showWG) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawWireguardStatus(x, iy);
+            idx++;
+        }
+    }
 }
 
 void drawMainBorder(bool clear) {
@@ -889,10 +919,6 @@ void printCenterFootnote(String text) {
     tft.drawCentreString(text, tftWidth / 2, tftHeight - BORDER_PAD_X - FP * LH, SMOOTH_FONT);
 }
 
-/***************************************************************************************
-** Function name: drawBatteryStatus()
-** Description:   Draws battery info into the Status bar
-***************************************************************************************/
 void drawBatteryStatus(uint8_t bat) {
     if (bat == 0) return;
 
@@ -901,31 +927,30 @@ void drawBatteryStatus(uint8_t bat) {
     uint16_t color = bruceConfig.priColor;
     uint16_t barcolor = bruceConfig.priColor;
     if (bat < 16) barcolor = color = TFT_RED;
-    else if (bat < 34) barcolor = color = TFT_YELLOW;
-    if (charging) color = TFT_GREEN;
 
-    tft.drawRoundRect(tftWidth - 43, 6, 36, 19, 2, charging ? color : bruceConfig.bgColor); // (bolder border)
     tft.drawRoundRect(tftWidth - 42, 7, 34, 17, 2, color);
     tft.setTextSize(FP);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawRightString((bat == 100 ? "" : " ") + String(bat) + "%", tftWidth - 45, 12, 1);
+    tft.fillRect(tftWidth - 85, 7, 42, 18, bruceConfig.bgColor);
+    if (charging) {
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.drawRightString("CHG", tftWidth - 44, 12, 1);
+    } else {
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.drawRightString((bat == 100 ? "" : " ") + String(bat) + "%", tftWidth - 44, 12, 1);
+    }
     tft.fillRoundRect(tftWidth - 40, 9, 30 * bat / 100, 13, 2, barcolor);
     tft.drawLine(tftWidth - 30, 9, tftWidth - 30, 9 + 13, bruceConfig.bgColor);
     tft.drawLine(tftWidth - 20, 9, tftWidth - 20, 9 + 13, bruceConfig.bgColor);
 }
-/***************************************************************************************
-** Function name: drawWireguardStatus()
-** Description:   Draws a padlock when connected
-***************************************************************************************/
+
 void drawWireguardStatus(int x, int y) {
-    tft.fillRect(x, y, 20, 17, bruceConfig.bgColor);
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
     if (isConnectedWireguard) {
-        tft.drawRoundRect(11 + x, 0 + y, 8, 12, 5, TFT_GREEN);
-        tft.fillRoundRect(10 + x, 8 + y, 10, 8, 0, TFT_GREEN);
+        tft.drawRoundRect(x + 4, y + 2, 8, 8, 3, bruceConfig.priColor);
+        tft.fillRoundRect(x + 3, y + 7, 10, 7, 1, bruceConfig.priColor);
     } else {
-        tft.drawRoundRect(1 + x, 0 + y, 8, 12, 5, bruceConfig.priColor);
-        tft.fillRoundRect(0 + x, 8 + y, 10, 8, 0, bruceConfig.bgColor);
-        tft.fillRoundRect(6 + x, 8 + y, 10, 10, 0, bruceConfig.priColor);
+        tft.drawRoundRect(x + 4, y + 2, 8, 8, 3, bruceConfig.priColor);
+        tft.drawRoundRect(x + 3, y + 7, 10, 7, 1, bruceConfig.priColor);
     }
 }
 
@@ -980,29 +1005,41 @@ Opt_Coord listFiles(int index, std::vector<FileList> fileList) {
 
 // desenhos do menu principal, sprite "draw" com 80x80 pixels
 
+void drawSdSmall(int x, int y) {
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
+    tft.drawLine(x + 3, y + 2, x + 3, y + 14, bruceConfig.priColor);
+    tft.drawLine(x + 3, y + 14, x + 13, y + 14, bruceConfig.priColor);
+    tft.drawLine(x + 13, y + 14, x + 13, y + 5, bruceConfig.priColor);
+    tft.drawLine(x + 13, y + 5, x + 10, y + 2, bruceConfig.priColor);
+    tft.drawLine(x + 10, y + 2, x + 3, y + 2, bruceConfig.priColor);
+
+    tft.drawLine(x + 5, y + 4, x + 5, y + 6, bruceConfig.priColor);
+    tft.drawLine(x + 7, y + 4, x + 7, y + 6, bruceConfig.priColor);
+    tft.drawLine(x + 9, y + 4, x + 9, y + 6, bruceConfig.priColor);
+    tft.drawLine(x + 11, y + 5, x + 11, y + 6, bruceConfig.priColor);
+}
+
 void drawWifiSmall(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
-    tft.fillCircle(9 + x, 14 + y, 1, bruceConfig.priColor);
-    tft.drawArc(9 + x, 14 + y, 4, 6, 130, 230, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawArc(9 + x, 14 + y, 10, 12, 130, 230, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.fillCircle(x + 8, y + 13, 1, bruceConfig.priColor);
+    tft.drawArc(x + 8, y + 13, 4, 6, 135, 225, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawArc(x + 8, y + 13, 9, 11, 135, 225, bruceConfig.priColor, bruceConfig.bgColor);
 }
 
 void drawWebUISmall(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
-
-    tft.drawCircle(8 + x, 8 + y, 7, bruceConfig.priColor);
-
-    tft.drawLine(3 + x, 4 + y, 14 + x, 4 + y, bruceConfig.priColor);
-    tft.drawLine(2 + x, 8 + y, 15 + x, 8 + y, bruceConfig.priColor);
-    tft.drawLine(3 + x, 12 + y, 14 + x, 12 + y, bruceConfig.priColor);
+    tft.drawCircle(x + 8, y + 8, 6, bruceConfig.priColor);
+    tft.drawLine(x + 3, y + 4, x + 13, y + 4, bruceConfig.priColor);
+    tft.drawLine(x + 2, y + 8, x + 14, y + 8, bruceConfig.priColor);
+    tft.drawLine(x + 3, y + 12, x + 13, y + 12, bruceConfig.priColor);
 }
 
 void drawBLESmall(int x, int y) {
-    tft.fillRect(x, 2 + y, 17, 13, bruceConfig.bgColor);
-    tft.drawWideLine(8 + x, 8 + y, 4 + x, 5 + y, 2, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawWideLine(8 + x, 8 + y, 4 + x, 13 + y, 2, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawTriangle(8 + x, 8 + y, 8 + x, 2 + y, 13 + x, 5 + y, bruceConfig.priColor);
-    tft.drawTriangle(8 + x, 8 + y, 8 + x, 14 + y, 13 + x, 11 + y, bruceConfig.priColor);
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
+    tft.drawWideLine(x + 8, y + 8, x + 4, y + 4, 2, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawWideLine(x + 8, y + 8, x + 4, y + 12, 2, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawTriangle(x + 8, y + 8, x + 8, y + 2, x + 12, y + 5, bruceConfig.priColor);
+    tft.drawTriangle(x + 8, y + 8, x + 8, y + 14, x + 12, y + 11, bruceConfig.priColor);
 }
 
 void drawBLE_beacon(int x, int y, uint16_t color) {
@@ -1024,10 +1061,10 @@ void drawGPS(int x, int y) {
 }
 
 void drawGpsSmall(int x, int y) {
-    tft.fillRect(x, y, 17, 17, bruceConfig.bgColor);
-    tft.drawEllipse(9 + x, 14 + y, 4, 3, bruceConfig.priColor);
-    tft.drawArc(9 + x, 6 + y, 5, 2, 0, 340, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.fillTriangle(9 + x, 15 + y, 5 + x, 9 + y, 13 + x, 9 + y, bruceConfig.priColor);
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
+    tft.drawEllipse(x + 8, y + 13, 4, 3, bruceConfig.priColor);
+    tft.drawArc(x + 8, y + 5, 5, 2, 0, 360, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.fillTriangle(x + 8, y + 14, x + 4, y + 8, x + 12, y + 8, bruceConfig.priColor);
 }
 
 void drawCreditCard(int x, int y) {
diff --git a/src/core/display.h b/src/core/display.h
index e887e89f1..8b3faf2e1 100644
--- a/src/core/display.h
+++ b/src/core/display.h
@@ -214,6 +214,8 @@ void drawGPS(int x, int y);
 
 void drawGpsSmall(int x, int y);
 
+void drawSdSmall(int x, int y);
+
 void drawCreditCard(int x, int y);
 
 void drawMfkey32Icon(int x, int y);
diff --git a/src/core/main_menu.cpp b/src/core/main_menu.cpp
index 4dcbbdaff..e727f3031 100644
--- a/src/core/main_menu.cpp
+++ b/src/core/main_menu.cpp
@@ -7,29 +7,28 @@ MainMenu::MainMenu() {
     _menuItems = {
         &wifiMenu,
         &bleMenu,
+        &rfMenu,
+        &nrf24Menu,
 #if !defined(LITE_VERSION)
-        &ethernetMenu,
+        &loraMenu,
 #endif
-        &rfMenu,
-        &rfidMenu,
-        &irMenu,
 #if defined(FM_SI4713) && !defined(LITE_VERSION)
         &fmMenu,
 #endif
-        &fileMenu,
-        &gpsMenu,
-        &nrf24Menu,
+        &irMenu,
 #if !defined(LITE_VERSION)
-#if !defined(DISABLE_INTERPRETER)
-        &scriptsMenu,
-        &appsMenu,
+        &ethernetMenu,
 #endif
-        &loraMenu,
+        &gpsMenu,
+        &rfidMenu,
+        &fileMenu,
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+        &scriptsMenu,
 #endif
-        &othersMenu,
         &clockMenu,
-#if !defined(LITE_VERSION)
-        &connectMenu,
+        &othersMenu,
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+        &appsMenu,
 #endif
         &configMenu,
     };
diff --git a/src/core/menu_items/AppsMenu.cpp b/src/core/menu_items/AppsMenu.cpp
index f2078159e..c3173b33e 100644
--- a/src/core/menu_items/AppsMenu.cpp
+++ b/src/core/menu_items/AppsMenu.cpp
@@ -33,16 +33,29 @@ void AppsMenu::optionsMenu() {
 void AppsMenu::drawIcon(float scale) {
     clearIconArea();
 
-    int size = scale * 14;
-    int gap = scale * 4;
-    int totalW = size * 2 + gap;
-
-    int startX = iconCenterX - totalW / 2;
-    int startY = iconCenterY - totalW / 2;
-
-    // Draw a 2x2 grid of rounded squares (app grid icon)
-    tft.drawRoundRect(startX, startY, size, size, 2, bruceConfig.priColor);
-    tft.drawRoundRect(startX + size + gap, startY, size, size, 2, bruceConfig.priColor);
-    tft.drawRoundRect(startX, startY + size + gap, size, size, 2, bruceConfig.priColor);
-    tft.drawRoundRect(startX + size + gap, startY + size + gap, size, size, 2, bruceConfig.priColor);
+    int iconW = scale * 60;
+    int iconH = scale * 60;
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+    int half = iconW / 2;
+
+    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
+    tft.drawLine(cx - half, cy - half + iconH / 4, cx + half, cy - half + iconH / 4, bruceConfig.priColor);
+
+    int gridW = iconW / 5;
+    int gridGap = iconW / 8;
+
+    int gridCenterY = cy + iconH / 8;
+    int gx1 = cx - gridW - gridGap / 2;
+    int gy1 = gridCenterY - gridW - gridGap / 2;
+    int gx2 = cx + gridGap / 2;
+    int gy2 = gridCenterY + gridGap / 2;
+
+    tft.fillRect(gx1, gy1, gridW, gridW, bruceConfig.priColor);
+    tft.drawRect(gx2, gy1, gridW, gridW, bruceConfig.priColor);
+    tft.drawRect(gx1, gy2, gridW, gridW, bruceConfig.priColor);
+    tft.fillRect(gx2, gy2, gridW, gridW, bruceConfig.priColor);
 }
diff --git a/src/core/menu_items/ConfigMenu.cpp b/src/core/menu_items/ConfigMenu.cpp
index 2b606096f..753f51064 100644
--- a/src/core/menu_items/ConfigMenu.cpp
+++ b/src/core/menu_items/ConfigMenu.cpp
@@ -32,11 +32,6 @@ void ConfigMenu::optionsMenu() {
             {"System Config", [this]() { systemMenu(); }   },
             {"Power",         [this]() { powerMenu(); }    },
         };
-#if !defined(LITE_VERSION)
-        if (!appStoreInstalled()) {
-            localOptions.push_back({"Install App Store", []() { installAppStoreJS(); }});
-        }
-#endif
 
         if (bruceConfig.devMode) {
             localOptions.push_back({"Dev Mode", [this]() { devMenu(); }});
diff --git a/src/core/menu_items/EthernetMenu.cpp b/src/core/menu_items/EthernetMenu.cpp
index 326117de9..28b096ddf 100644
--- a/src/core/menu_items/EthernetMenu.cpp
+++ b/src/core/menu_items/EthernetMenu.cpp
@@ -61,62 +61,55 @@ void EthernetMenu::optionsMenu() {
 void EthernetMenu::drawIcon(float scale) {
     clearIconArea();
 
-    int iconW = scale * 30;
-    int iconH = scale * 40;
-
-    int Y = iconCenterY - 25;
-
-    int smallerH = scale * 16;
-
-    int starterX = iconCenterX - iconW; // X of the first side
-    int finalX = iconCenterX + iconW;
-
-    int lineWidth = 2;
-
-    // Draw the main socket structure
-    /*
-    |-----|
-    |     |
-    |     |
-    */
-    tft.drawRect(starterX, Y, lineWidth, iconH, bruceConfig.priColor);
-
-    tft.drawRect(finalX, Y, lineWidth, iconH, bruceConfig.priColor);
-
-    tft.drawRect(starterX, Y, iconW * 2, lineWidth, bruceConfig.priColor);
-
-    // Draw the shorter side to close the first part of socket
-    /*
-    |-----|
-    |     |
-    |-   -|
-    */
-    tft.drawRect(starterX, Y + iconH, smallerH, lineWidth, bruceConfig.priColor);
-
-    tft.drawRect(finalX - smallerH + lineWidth, Y + iconH, smallerH, lineWidth, bruceConfig.priColor);
-
-    // Draw the final enclosure
-    /*
-    |------|
-    |      |
-    |-    -|
-      |  |
-    */
-    tft.drawRect(starterX + smallerH, Y + iconH, lineWidth, smallerH, bruceConfig.priColor);
-    tft.drawRect(finalX - smallerH + lineWidth, Y + iconH, lineWidth, smallerH, bruceConfig.priColor);
-
-    // Draw the four cable pin at a distance of 15 pixel
-    for (size_t i = 0; i < 4; i++) {
-        tft.drawRect(starterX + 15 + (i * 15), Y, lineWidth, 16, bruceConfig.priColor);
+    // Dimensions
+    int cx = iconCenterX;
+    int cy = iconCenterY + (4 * scale); // Centered and slightly lower
+    int w = 48 * scale;
+    int h = 40 * scale;
+    if (w % 2 != 0) w++;
+    if (h % 2 != 0) h++;
+
+    int x1 = cx - w / 2;
+    int x2 = cx + w / 2;
+    int y1 = cy - h / 2;
+    int y2 = cy + h / 2;
+
+    // Thickness, Width & Height
+    int t = 3 * scale;
+    if (t < 2) t = 2;
+
+    int nw = 20 * scale;
+    if (nw % 2 != 0) nw++;
+    int nh = 12 * scale;
+
+
+    // Borders
+    tft.fillRect(x1, y1, w, t, bruceConfig.priColor);
+
+    tft.fillRect(x1, y1, t, h, bruceConfig.priColor);
+    tft.fillRect(x2 - t, y1, t, h, bruceConfig.priColor);
+
+    // Pieces
+    int sideW = (w - nw) / 2 + t;
+    tft.fillRect(x1, y2 - t, sideW, t, bruceConfig.priColor);
+    tft.fillRect(x2 - sideW, y2 - t, sideW, t, bruceConfig.priColor);
+    tft.fillRect(cx - nw / 2, y2 - nh - t, t, nh + t, bruceConfig.priColor);
+    tft.fillRect(cx + nw / 2 - t, y2 - nh - t, t, nh + t, bruceConfig.priColor);
+    tft.fillRect(cx - nw / 2, y2 - nh - t, nw, t, bruceConfig.priColor);
+
+    // 8 Pins
+    int pinW = 2 * scale;
+    if (pinW < 1) pinW = 1;
+    int pinH = (h / 2) - t;
+
+    int step = (28 * scale) / 7;
+    if (step < 2) step = 2;
+    int totalSpread = step * 7;
+    int firstPinX = cx - (totalSpread / 2);
+
+    for (int i = 0; i < 8; i++) {
+        int px = firstPinX + (i * step) - (pinW / 2);
+        tft.fillRect(px, y1 + t, pinW, pinH, bruceConfig.priColor);
     }
-
-    // Close the socket calculating width of this side removing from total width, the size of the smaller size
-    tft.drawRect(
-        starterX + smallerH,
-        Y + iconH + smallerH,
-        (iconW * 2) - (smallerH * 2) + 4,
-        lineWidth,
-        bruceConfig.priColor
-    );
 }
 #endif
diff --git a/src/core/menu_items/FileMenu.cpp b/src/core/menu_items/FileMenu.cpp
index ef56057de..e73dc3290 100644
--- a/src/core/menu_items/FileMenu.cpp
+++ b/src/core/menu_items/FileMenu.cpp
@@ -4,6 +4,8 @@
 #include "core/sd_functions.h"
 #include "core/utils.h"
 #include "core/wifi/webInterface.h"
+#include "core/connect/file_sharing.h"
+#include "core/connect/serial_commands.h"
 
 void FileMenu::optionsMenu() {
     options.clear();
@@ -11,6 +13,19 @@ void FileMenu::optionsMenu() {
     options.push_back({"LittleFS", [=]() { loopSD(LittleFS); }});
     options.push_back({"WebUI", loopOptionsWebUi});
 
+#if !defined(LITE_VERSION)
+    options.push_back({"Connect", [=]() {
+        std::vector<Option> connectOpts = {
+            {"Send File", [=]() { FileSharing().sendFile(); }        },
+            {"Recv File", [=]() { FileSharing().receiveFile(); }     },
+            {"Send Cmds", [=]() { EspSerialCmd().sendCommands(); }   },
+            {"Recv Cmds", [=]() { EspSerialCmd().receiveCommands(); }},
+            {"Back",      [=]() { optionsMenu(); }                   }
+        };
+        loopOptions(connectOpts, MENU_TYPE_SUBMENU, "Connect");
+    }});
+#endif
+
 #if defined(SOC_USB_OTG_SUPPORTED)
     options.push_back({"Mass Storage", [=]() { MassStorage(); }});
 #endif
diff --git a/src/core/menu_items/RFMenu.cpp b/src/core/menu_items/RFMenu.cpp
index 23b3416f6..edc948444 100644
--- a/src/core/menu_items/RFMenu.cpp
+++ b/src/core/menu_items/RFMenu.cpp
@@ -27,9 +27,8 @@ void RFMenu::optionsMenu() {
         {"Listen",          rf_listen                 }, // dev_eclipse
 #endif
         {"Bruteforce",      rf_bruteforce             }, // dev_eclipse
-        {"Jammer Itmt",     [=]() { RFJammer(false); }},
+        {"Jammer",          [=]() { RFJammer(true); } },
 #endif
-        {"Jammer Full",     [=]() { RFJammer(true); } },
         {"Config",          [this]() { configMenu(); }},
     };
     addOptionToMainMenu();
diff --git a/src/core/wifi/webInterface.cpp b/src/core/wifi/webInterface.cpp
index bc46a0fe6..191123b2a 100644
--- a/src/core/wifi/webInterface.cpp
+++ b/src/core/wifi/webInterface.cpp
@@ -274,34 +274,42 @@ void notFound(AsyncWebServerRequest *request) { request->send(404, "text/plain",
 **  Draw information on screen of WebUI.
 **********************************************************************/
 void drawWebUiScreen(bool mode_ap) {
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.drawRoundRect(5, 5, tftWidth - 10, tftHeight - 10, 5, ALCOLOR);
-    if (mode_ap) {
-        setTftDisplay(0, 0, bruceConfig.bgColor, FM);
-        tft.drawCentreString("BruceNet/brucenet", tftWidth / 2, 7, 1);
-    }
-    setTftDisplay(0, 0, ALCOLOR, FM);
-    tft.drawCentreString("BRUCE WebUI", tftWidth / 2, 27, 1);
+    drawMainBorderWithTitle("WebUI", true);
+
     String txt;
     if (!mode_ap) txt = WiFi.localIP().toString();
     else txt = WiFi.softAPIP().toString();
-    tft.setTextColor(bruceConfig.priColor);
-
-    tft.drawCentreString("http://bruce.local", tftWidth / 2, 45, 1);
-    setTftDisplay(7, 67);
-
-    tft.setTextSize(FM);
-    tft.print("IP: ");
-    tft.println(txt);
-    tft.setCursor(7, tft.getCursorY());
-    tft.println("Usr: " + String(bruceConfig.webUI.user));
-    tft.setCursor(7, tft.getCursorY());
-    tft.println("Pwd: " + String(bruceConfig.webUI.pwd));
-    tft.setCursor(7, tft.getCursorY());
-    tft.setTextColor(TFT_RED);
+
+    int padX = 14;
+    int currentY = 55;
+
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setTextSize(FP);
+
+    if (mode_ap) {
+        tft.setCursor(padX, currentY);
+        tft.print("Net: BruceNet/brucenet");
+        currentY += LH * FP + 6;
+    }
+
+    tft.setCursor(padX, currentY);
+    tft.print("Url: http://bruce.local");
+    currentY += LH * FP + 6;
+
+    tft.setCursor(padX, currentY);
+    tft.print("IP:  " + txt);
+    currentY += LH * FP + 6;
+
+    tft.setCursor(padX, currentY);
+    tft.print("Usr: " + String(bruceConfig.webUI.user));
+    currentY += LH * FP + 6;
+
+    tft.setCursor(padX, currentY);
+    tft.print("Pwd: " + String(bruceConfig.webUI.pwd));
+
+    tft.setTextColor(TFT_RED, bruceConfig.bgColor);
     tft.setTextSize(FP);
-    tft.drawCentreString("press Esc to stop", tftWidth / 2, tftHeight - 2 * LH * FP, 1);
+    tft.drawCentreString("press Esc to stop", tftWidth / 2, tftHeight - 2 * LH * FP - 5, 1);
 
 #if defined(HAS_TOUCH)
     TouchFooter();
diff --git a/src/core/wifi/wg.cpp b/src/core/wifi/wg.cpp
index 07acc74c2..29e3c4202 100644
--- a/src/core/wifi/wg.cpp
+++ b/src/core/wifi/wg.cpp
@@ -2,6 +2,7 @@ bool isConnectedWireguard = false;
 #ifndef LITE_VERSION
 #include "wg.h"
 #include "core/display.h"
+#include "core/mykeyboard.h"
 #include "core/sd_functions.h"
 #include "core/wifi/wifi_common.h"
 #include <WireGuard-ESP32.h>
@@ -94,15 +95,8 @@ void read_and_parse_file() {
 
     File file = SD.open("/wg.conf");
     if (!file) {
-        tft.fillScreen(bruceConfig.bgColor);
-        tft.setCursor(0, 0);
-
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
         Serial.println("Failed to open wg.conf file");
-        // tft.println("No wg.conf file\nfound on\nthe SD");
-        displayRedStripe("No wg.conf file", TFT_RED, bruceConfig.priColor);
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        delay(6000);
+        displayError("No wg.conf file on SD", true);
         return;
     }
 
@@ -121,34 +115,37 @@ void wg_setup() {
 
     read_and_parse_file();
 
-    Serial.println("Adjusting system time...");
+    drawMainBorderWithTitle("WIREGUARD");
+    printSubtitle("Connecting...");
+    tft.setTextSize(FP);
+    padprintln("");
+    padprintln("Syncing time...");
+
     configTime(9 * 60 * 60, 0, "ntp.jst.mfeed.ad.jp", "ntp.nict.jp");
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
 
-    Serial.println("Connected. Initializing WireGuard...");
-    // tft.println("Connecting to\nwireguard...");
+    padprintln("Initializing tunnel...");
     wg.begin(local_ip, private_key, endpoint_address, public_key, endpoint_port);
-    Serial.println(local_ip);
-    Serial.println(private_key);
-    Serial.println(endpoint_address);
-    Serial.println(public_key);
-    Serial.println(endpoint_port);
-
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
-    tft.setTextSize(FG);
 
+    drawMainBorderWithTitle("WIREGUARD");
+    printSubtitle("Connected");
+    tft.setTextSize(FP);
+    padprintln("");
     tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-    tft.println("Connected!");
+    padprintln("Status: Connected");
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.println("IP on tunnel:");
+    padprintln("");
+    padprintln("Tunnel IP:");
     tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
-    tft.println(local_ip);
+    padprintln(local_ip.toString());
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    Serial.println(local_ip);
-    delay(7000);
+    padprintln("");
+    padprintln("Endpoint: " + String(endpoint_address));
+    padprintln("Port: " + String(endpoint_port));
+    padprintln("");
+    printFootnote("Press any key to return");
+
     isConnectedWireguard = true;
-    tft.fillScreen(bruceConfig.bgColor);
+
+    while (!check(AnyKeyPress)) { delay(100); }
 }
 #endif
diff --git a/src/modules/NRF24/nrf_jammer.cpp b/src/modules/NRF24/nrf_jammer.cpp
index 4da33ea75..cab2bc771 100644
--- a/src/modules/NRF24/nrf_jammer.cpp
+++ b/src/modules/NRF24/nrf_jammer.cpp
@@ -30,7 +30,7 @@ static const uint8_t JAM_FLOOD_DATA[32] = {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0
 
 // ── Config persistence ──────────────────────────────────────────
 static const char *NRF_JAM_CFG_PATH = "/nrf_jam_cfg.bin";
-#define NRF_JAM_CFG_VERSION 3
+#define NRF_JAM_CFG_VERSION 4
 
 // ── Per-mode default configs ────────────────────────────────────
 // Tuned for E01-ML01SP2 (PA+LNA): PA=3 → chip 0dBm → ~+20dBm at antenna
@@ -47,27 +47,18 @@ static const char *NRF_JAM_CFG_PATH = "/nrf_jam_cfg.bin";
 // CW: unmodulated carrier saturates receiver AGC → proven & fast
 // Flooding: packet collisions via writeFast → optional, enable in config
 //
-//                                        PA  DR  dwell  flood
+//                                        PA  DR  dwell strat burst rand _res
 static NrfJamConfig jamConfigs[NRF_JAM_MODE_COUNT] = {
-    /* FULL       */ {3, 1, 0, 0}, // CW: rapid sweep all 125ch (like original)
-                                   /* WIFI       */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* BLE        */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* BLE_ADV    */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* BLUETOOTH  */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep (like original)
-                                   /* USB        */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* VIDEO      */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* RC         */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* ZIGBEE     */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* DRONE      */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
+    /* FULL       */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood, max burst, random
+    /* WIFI       */ {3, 1, 0, 2, 20, 0, 0}, // Turbo flood WiFi channels
+    /* BLE        */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood, random hop
+    /* BLE_ADV    */ {3, 1, 0, 2, 20, 0, 0}, // Turbo flood adv channels
+    /* BLUETOOTH  */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random (FHSS)
+    /* USB        */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random
+    /* VIDEO      */ {3, 1, 0, 2, 20, 0, 0}, // Turbo flood video band
+    /* RC         */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random (FHSS)
+    /* ZIGBEE     */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random
+    /* DRONE      */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random (FHSS)
 };
 
 // ── Mode information table ──────────────────────────────────────
@@ -108,14 +99,24 @@ static const uint8_t CH_BLUETOOTH[] = {2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 1
                                        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
                                        66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80};
 
-// USB wireless dongles
-static const uint8_t CH_USB[] = {40, 50, 60};
+// USB wireless dongles: expanded range covering common dongle frequencies
+static const uint8_t CH_USB[] = {
+    32, 34, 36, 38, 40, 42, 44, 46, 48, 50,
+    52, 54, 56, 58, 60, 62, 64, 66, 68, 70
+};
 
-// Video streaming (upper ISM band)
-static const uint8_t CH_VIDEO[] = {70, 75, 80};
+// Video streaming: expanded FPV + baby monitor range (upper ISM band)
+static const uint8_t CH_VIDEO[] = {
+    60, 62, 64, 66, 68, 70, 72, 74, 76, 78,
+    80, 82, 84, 86, 88, 90, 92, 94, 96, 98,
+    100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124
+};
 
-// RC controllers (low channels)
-static const uint8_t CH_RC[] = {1, 3, 5, 7};
+// RC controllers: expanded to cover main RC frequency allocations
+static const uint8_t CH_RC[] = {
+    1, 3, 5, 7, 9, 11, 13, 15, 17, 19,
+    21, 23, 25, 27, 29, 31, 33, 35, 37, 39
+};
 
 // Zigbee ch 11-26: 3 nRF sub-channels per Zigbee channel (±1MHz)
 static const uint8_t CH_ZIGBEE[] = {
@@ -177,7 +178,9 @@ static void loadJamConfigs() {
         if (jamConfigs[i].paLevel > 3) jamConfigs[i].paLevel = 3;
         if (jamConfigs[i].dataRate > 2) jamConfigs[i].dataRate = 1;
         if (jamConfigs[i].dwellTimeMs > 200) jamConfigs[i].dwellTimeMs = 200;
-        if (jamConfigs[i].useFlooding > 1) jamConfigs[i].useFlooding = 1;
+        if (jamConfigs[i].strategy > 2) jamConfigs[i].strategy = 0;
+        if (jamConfigs[i].burstCount < 1 || jamConfigs[i].burstCount > 20) jamConfigs[i].burstCount = 6;
+        if (jamConfigs[i].randomHop > 1) jamConfigs[i].randomHop = 0;
     }
     Serial.println("[JAM] Configs loaded from flash");
 }
@@ -217,24 +220,83 @@ static void applyJamConfig(const NrfJamConfig &cfg, bool flooding) {
 
 // ── Data flooding on a channel ──────────────────────────────────
 // Safely switch channel (CE LOW → configure → CE HIGH) then burst.
-static void floodChannel(uint8_t ch, uint16_t dwellMs) {
+static void floodChannel(uint8_t ch, uint16_t dwellMs, uint8_t burstCount) {
     // CE LOW to safely change channel mid-flight
     digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
     NRFradio.flush_tx();
     NRFradio.setChannel(ch);
 
     if (dwellMs == 0) {
-        // Turbo: fill FIFO (3 packets) and fire
-        NRFradio.writeFast(JAM_FLOOD_DATA, 32, true);
-        NRFradio.writeFast(JAM_FLOOD_DATA, 32, true);
-        NRFradio.writeFast(JAM_FLOOD_DATA, 32, true);
-        delayMicroseconds(500);
+        // Turbo: fill FIFO with burstCount packets for maximum TX duty
+        for (int i = 0; i < burstCount; i++) {
+            if (!NRFradio.writeFast(JAM_FLOOD_DATA, 32, true)) {
+                NRFradio.flush_tx();
+                delayMicroseconds(3);
+            }
+        }
+        delayMicroseconds(200);
         return;
     }
 
     unsigned long startMs = millis();
     while ((millis() - startMs) < dwellMs) {
-        if (!NRFradio.writeFast(JAM_FLOOD_DATA, 32, true)) { delayMicroseconds(10); }
+        for (int i = 0; i < burstCount && (millis() - startMs) < dwellMs; i++) {
+            if (!NRFradio.writeFast(JAM_FLOOD_DATA, 32, true)) {
+                NRFradio.flush_tx();
+                delayMicroseconds(5);
+            }
+        }
+    }
+}
+
+// ── Turbo flooding: maximum throughput with varied data ─────────
+// Multi-payload pattern: sends different data patterns on rapid rotation
+// to defeat CRC filters and create maximum spectral pollution.
+// Also cycles address width (3→5) to hit varied receiver configs.
+static void turboFloodChannel(uint8_t ch, uint8_t burstCount) {
+    static uint8_t xorSeed = 0xA5;
+
+    digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
+    NRFradio.flush_tx();
+    NRFradio.setChannel(ch);
+
+    // Phase 1: Standard burst with XOR-varied payload
+    uint8_t data[32];
+    for (int i = 0; i < 32; i++) {
+        xorSeed ^= (xorSeed << 5);
+        xorSeed ^= (xorSeed >> 3);
+        data[i] = JAM_FLOOD_DATA[i] ^ xorSeed;
+    }
+    for (int i = 0; i < burstCount; i++) {
+        if (!NRFradio.writeFast(data, 32, true)) {
+            NRFradio.flush_tx();
+        }
+    }
+
+    // Phase 2: All-ones payload (max RF energy per bit at 2Mbps)
+    memset(data, 0xFF, 32);
+    for (int i = 0; i < burstCount; i++) {
+        if (!NRFradio.writeFast(data, 32, true)) {
+            NRFradio.flush_tx();
+        }
+    }
+
+    // Phase 3: Alternating 0x55/0xAA for maximum bit transitions
+    for (int i = 0; i < 32; i++) data[i] = (i & 1) ? 0xAA : 0x55;
+    for (int i = 0; i < burstCount; i++) {
+        if (!NRFradio.writeFast(data, 32, true)) {
+            NRFradio.flush_tx();
+        }
+    }
+}
+
+// ── Fisher-Yates shuffle for random channel hopping ─────────────
+static void shuffleChannels(uint8_t *arr, size_t count) {
+    for (size_t i = count - 1; i > 0; i--) {
+        size_t j = esp_random() % (i + 1);
+        uint8_t tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
     }
 }
 
@@ -277,11 +339,13 @@ static void editModeConfig(NrfJamMode mode) {
     NrfJamConfig &cfg = jamConfigs[(uint8_t)mode];
     const char *paLabels[] = {"MIN (-18dBm)", "LOW (-12dBm)", "HIGH (-6dBm)", "MAX (0/+20dBm)"};
     const char *drLabels[] = {"1 Mbps", "2 Mbps", "250 Kbps"};
-    const char *stratLabels[] = {"Constant Carrier", "Data Flooding"};
+    const char *stratLabels[] = {"Constant Carrier", "Data Flooding", "Turbo Flood"};
+    const char *hopLabels[] = {"Sequential", "Random"};
 
     int menuIdx = 0;
     bool editing = false;
     bool redraw = true;
+    const int ITEM_COUNT = 7;
 
     while (true) {
         if (check(EscPress)) {
@@ -295,19 +359,20 @@ static void editModeConfig(NrfJamMode mode) {
             tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
 
             int y = BORDER_PAD_Y + FM * LH + 4;
-            int lineH = max(14, tftHeight / 10);
+            int lineH = max(12, tftHeight / (ITEM_COUNT + 3));
 
-            // Items
-            const char *items[] = {"PA Level", "Data Rate", "Dwell (ms)", "Strategy", "Save & Back"};
+            const char *items[] = {"PA Level", "Data Rate", "Dwell (ms)", "Strategy", "Burst Pkts", "Hop Order", "Save & Back"};
             String values[] = {
                 paLabels[cfg.paLevel & 3],
                 drLabels[cfg.dataRate <= 2 ? cfg.dataRate : 1],
                 String(cfg.dwellTimeMs),
-                stratLabels[cfg.useFlooding & 1],
+                stratLabels[cfg.strategy <= 2 ? cfg.strategy : 0],
+                String(cfg.burstCount),
+                hopLabels[cfg.randomHop & 1],
                 ""
             };
 
-            for (int i = 0; i < 5; i++) {
+            for (int i = 0; i < ITEM_COUNT; i++) {
                 int itemY = y + i * lineH;
                 uint16_t fg = (i == menuIdx) ? bruceConfig.bgColor : bruceConfig.priColor;
                 uint16_t bg = (i == menuIdx) ? bruceConfig.priColor : bruceConfig.bgColor;
@@ -318,7 +383,7 @@ static void editModeConfig(NrfJamMode mode) {
                 if (values[i].length() > 0) { line += ": " + values[i]; }
                 tft.drawString(line, 12, itemY + 2, 1);
 
-                if (editing && i == menuIdx && i < 4) {
+                if (editing && i == menuIdx && i < ITEM_COUNT - 1) {
                     tft.setTextColor(TFT_YELLOW, bg);
                     tft.drawRightString("<>", tftWidth - 12, itemY + 2, 1);
                 }
@@ -332,10 +397,12 @@ static void editModeConfig(NrfJamMode mode) {
                     case 0: cfg.paLevel = (cfg.paLevel + 1) % 4; break;
                     case 1: cfg.dataRate = (cfg.dataRate + 1) % 3; break;
                     case 2: cfg.dwellTimeMs = min(200, (int)cfg.dwellTimeMs + 1); break;
-                    case 3: cfg.useFlooding = !cfg.useFlooding; break;
+                    case 3: cfg.strategy = (cfg.strategy + 1) % 3; break;
+                    case 4: cfg.burstCount = min((uint8_t)20, (uint8_t)(cfg.burstCount + 1)); break;
+                    case 5: cfg.randomHop = !cfg.randomHop; break;
                 }
             } else {
-                menuIdx = (menuIdx + 1) % 5;
+                menuIdx = (menuIdx + 1) % ITEM_COUNT;
             }
             redraw = true;
         }
@@ -346,16 +413,18 @@ static void editModeConfig(NrfJamMode mode) {
                     case 0: cfg.paLevel = (cfg.paLevel + 3) % 4; break;
                     case 1: cfg.dataRate = (cfg.dataRate + 2) % 3; break;
                     case 2: cfg.dwellTimeMs = max(0, (int)cfg.dwellTimeMs - 1); break;
-                    case 3: cfg.useFlooding = !cfg.useFlooding; break;
+                    case 3: cfg.strategy = (cfg.strategy + 2) % 3; break;
+                    case 4: cfg.burstCount = max((uint8_t)1, (uint8_t)(cfg.burstCount - 1)); break;
+                    case 5: cfg.randomHop = !cfg.randomHop; break;
                 }
             } else {
-                menuIdx = (menuIdx + 4) % 5;
+                menuIdx = (menuIdx + ITEM_COUNT - 1) % ITEM_COUNT;
             }
             redraw = true;
         }
 
         if (check(SelPress)) {
-            if (menuIdx == 4) {
+            if (menuIdx == ITEM_COUNT - 1) {
                 saveJamConfigs();
                 break;
             }
@@ -371,51 +440,103 @@ static void editModeConfig(NrfJamMode mode) {
 // ═══════════════ JAMMER STATUS UI ═════════════════════════════
 // ══════════════════════════════════════════════════════════════════
 
-static void drawJammerStatus(NrfJamMode mode, int currentCh, uint8_t nrfOnline, bool initial) {
+static void drawJammerStatus(NrfJamMode mode, int currentCh, uint8_t nrfOnline, bool initial,
+                             unsigned long elapsedMs = 0, unsigned long totalCh = 0, unsigned long sweeps = 0) {
     const NrfJamConfig &cfg = jamConfigs[(uint8_t)mode];
+    const char *paLabels[] = {"MIN", "LOW", "HIGH", "MAX"};
+    const char *drLabels[] = {"1M", "2M", "250K"};
+    const char *stratNames[] = {"CW", "FLOOD", "TURBO"};
 
     if (initial) { drawMainBorderWithTitle("NRF JAMMER"); }
 
     int y = BORDER_PAD_Y + FM * LH + 4;
     int lineH = max(14, tftHeight / 10);
+    char buf[48];
 
     tft.setTextSize(FP);
 
-    // Mode name
+    // Line 1: Mode name + Strategy badge
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
     tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-    tft.drawString(MODE_INFO[(uint8_t)mode].shortName, 12, y + 2, 1);
-
+    tft.drawString(MODE_INFO[(uint8_t)mode].name, 12, y + 2, 1);
+    const char *strat = stratNames[cfg.strategy <= 2 ? cfg.strategy : 0];
+    uint16_t badgeClr = (cfg.strategy == 2) ? TFT_RED : (cfg.strategy == 1) ? TFT_ORANGE : TFT_CYAN;
+    int bw = strlen(strat) * 6 + 8;
+    int bx = tftWidth - 12 - bw;
+    tft.fillRoundRect(bx, y + 1, bw, lineH - 3, 3, badgeClr);
+    tft.setTextColor(TFT_BLACK, badgeClr);
+    tft.drawCentreString(strat, bx + bw / 2, y + 2, 1);
     y += lineH;
 
-    // Status
+    // Line 2: Timer + Speed + Sweeps
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    char buf[40];
-    snprintf(buf, sizeof(buf), "Status: %d ACTIVE", nrfOnline);
+    unsigned long secs = elapsedMs / 1000;
+    unsigned long mins = secs / 60;
+    secs %= 60;
+    unsigned long chPerSec = (elapsedMs > 500) ? (totalCh * 1000UL / elapsedMs) : 0;
+    tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "%02lu:%02lu", mins, secs);
     tft.drawString(buf, 12, y + 2, 1);
-
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "%lu ch/s  S:%lu", chPerSec, sweeps);
+    tft.drawRightString(buf, tftWidth - 12, y + 2, 1);
     y += lineH;
 
-    // Channel / Frequency
+    // Line 3: Channel + Frequency + Radios + Hop mode
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
-    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
     int freq = 2400 + currentCh;
-    snprintf(buf, sizeof(buf), "CH:%d  %dMHz", currentCh, freq);
-    tft.drawString(buf, 12, y + 2, 1);
+    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "CH:%d %dMHz x%d%s", currentCh, freq, nrfOnline,
+             cfg.randomHop ? " RND" : "");
+    tft.drawCentreString(buf, tftWidth / 2, y + 2, 1);
+    y += lineH;
 
+    // Line 4: 2.4GHz Band visualization strip
+    {
+        int sX = 12, sW = tftWidth - 24;
+        int sH = max(6, lineH - 4);
+        int sY = y + (lineH - sH) / 2;
+        tft.fillRect(sX, sY, sW, sH, TFT_DARKGREY);
+        size_t chCount = 0;
+        const uint8_t *chList = getChannelList(mode, chCount);
+        if (mode == NRF_JAM_FULL || mode == NRF_JAM_DRONE) {
+            for (int c = 0; c < 125; c++) {
+                int px = sX + (c * sW) / 125;
+                int pw = max(1, sX + ((c + 1) * sW) / 125 - px);
+                uint16_t col = (c > 83) ? TFT_RED : (c > 42) ? TFT_YELLOW : TFT_GREEN;
+                tft.fillRect(px, sY + 1, pw, sH - 2, col);
+            }
+        } else if (chCount > 0 && chList) {
+            for (size_t ci = 0; ci < chCount; ci++) {
+                int c = chList[ci];
+                if (c >= 125) continue;
+                int px = sX + (c * sW) / 125;
+                int pw = max(1, sX + ((c + 1) * sW) / 125 - px);
+                tft.fillRect(px, sY + 1, pw, sH - 2, TFT_GREEN);
+            }
+        }
+        if (currentCh < 125) {
+            int mx = sX + (currentCh * sW) / 125;
+            tft.fillRect(mx, sY, 2, sH, TFT_WHITE);
+        }
+        tft.drawRect(sX, sY, sW, sH, bruceConfig.priColor);
+    }
     y += lineH;
 
-    // Config summary
+    // Line 5: Config summary
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
     tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
-    snprintf(buf, sizeof(buf), "%s dwell:%dms", cfg.useFlooding ? "FLOOD" : "CW", cfg.dwellTimeMs);
-    tft.drawString(buf, 12, y + 2, 1);
+    snprintf(buf, sizeof(buf), "PA:%s %s B:%d %s",
+             paLabels[cfg.paLevel & 3],
+             drLabels[cfg.dataRate <= 2 ? cfg.dataRate : 1],
+             cfg.burstCount,
+             cfg.randomHop ? "RND" : "SEQ");
+    tft.drawCentreString(buf, tftWidth / 2, y + 2, 1);
 
     // Footer
-    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
     int footerY = tftHeight - BORDER_PAD_X - FP * LH - 2;
     tft.fillRect(7, footerY, tftWidth - 14, FP * LH, bruceConfig.bgColor);
+    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
     tft.drawCentreString("[ESC]Stop [<>]Mode [OK]Cfg", tftWidth / 2, footerY, 1);
 }
 
@@ -430,10 +551,38 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
     NrfJamMode currentMode = jamMode;
     int channel = 0;
     int hopIndex = 0;
+    unsigned long jamStartMs = millis();
+    unsigned long totalCh = 0;
+    unsigned long sweepCount = 0;
+    unsigned long lastDrawMs = 0;
+
+    // Shuffled channel buffer for random hop
+    uint8_t shuffledCh[128];
+    size_t shuffledCount = 0;
+
+    auto prepareChannels = [&](NrfJamMode m) {
+        size_t count = 0;
+        const uint8_t *chList = getChannelList(m, count);
+        NrfJamConfig &c = jamConfigs[(uint8_t)m];
+        if (m == NRF_JAM_FULL || m == NRF_JAM_DRONE) {
+            shuffledCount = 125;
+            for (int i = 0; i < 125; i++) shuffledCh[i] = i;
+        } else if (count > 0 && chList) {
+            shuffledCount = count;
+            memcpy(shuffledCh, chList, count);
+        } else {
+            shuffledCount = 0;
+        }
+        if (c.randomHop && shuffledCount > 1) {
+            shuffleChannels(shuffledCh, shuffledCount);
+        }
+    };
+
+    prepareChannels(currentMode);
 
     if (CHECK_NRF_SPI(nrfMode)) {
         NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-        bool flooding = cfg.useFlooding;
+        bool flooding = (cfg.strategy >= 1);
 
         if (flooding) {
             applyJamConfig(cfg, true);
@@ -443,7 +592,7 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
         NRFSPI = 1;
     }
 
-    drawJammerStatus(currentMode, channel, NRFOnline, true);
+    drawJammerStatus(currentMode, channel, NRFOnline, true, 0, 0, 0);
 
     if (CHECK_NRF_UART(nrfMode) || CHECK_NRF_BOTH(nrfMode)) {
         NRFSerial.println("RADIOS");
@@ -483,17 +632,17 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             if (CHECK_NRF_SPI(nrfMode)) NRFradio.stopConstCarrier();
             editModeConfig(currentMode);
 
-            // Re-apply config after edit — must use initCW() because
-            // stopConstCarrier() → powerDown() clears internal PWR_UP,
-            // and bare startConstCarrier() never restores it.
+            // Re-apply config after edit
             if (CHECK_NRF_SPI(nrfMode)) {
                 NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-                if (cfg.useFlooding) {
+                if (cfg.strategy >= 1) {
                     applyJamConfig(cfg, true);
                 } else {
                     initCW(channel);
                 }
             }
+            prepareChannels(currentMode);
+            hopIndex = 0;
             redraw = true;
         }
 
@@ -502,12 +651,15 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             NrfJamMode prevMode = currentMode;
             currentMode = (NrfJamMode)(((uint8_t)currentMode + 1) % NRF_JAM_MODE_COUNT);
             hopIndex = 0;
+            prepareChannels(currentMode);
             if (CHECK_NRF_SPI(nrfMode)) {
                 NrfJamConfig &prevCfg = jamConfigs[(uint8_t)prevMode];
                 NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-                if (prevCfg.useFlooding != cfg.useFlooding) {
+                bool prevFlood = (prevCfg.strategy >= 1);
+                bool nowFlood = (cfg.strategy >= 1);
+                if (prevFlood != nowFlood) {
                     NRFradio.stopConstCarrier();
-                    if (cfg.useFlooding) {
+                    if (nowFlood) {
                         applyJamConfig(cfg, true);
                     } else {
                         initCW(channel);
@@ -523,12 +675,15 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             NrfJamMode prevMode = currentMode;
             currentMode = (NrfJamMode)(((uint8_t)currentMode + NRF_JAM_MODE_COUNT - 1) % NRF_JAM_MODE_COUNT);
             hopIndex = 0;
+            prepareChannels(currentMode);
             if (CHECK_NRF_SPI(nrfMode)) {
                 NrfJamConfig &prevCfg = jamConfigs[(uint8_t)prevMode];
                 NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-                if (prevCfg.useFlooding != cfg.useFlooding) {
+                bool prevFlood = (prevCfg.strategy >= 1);
+                bool nowFlood = (cfg.strategy >= 1);
+                if (prevFlood != nowFlood) {
                     NRFradio.stopConstCarrier();
-                    if (cfg.useFlooding) {
+                    if (nowFlood) {
                         applyJamConfig(cfg, true);
                     } else {
                         initCW(channel);
@@ -538,10 +693,14 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             redraw = true;
         }
 
-        // ── Redraw on state changes only (no periodic redraw) ───
-        if (redraw) {
-            drawJammerStatus(currentMode, channel, NRFOnline, true);
-            redraw = false;
+        // ── Periodic display update (every 200ms) ────────────
+        {
+            unsigned long nowMs = millis();
+            if (nowMs - lastDrawMs >= 200 || redraw) {
+                drawJammerStatus(currentMode, channel, NRFOnline, true, nowMs - jamStartMs, totalCh, sweepCount);
+                lastDrawMs = nowMs;
+                redraw = false;
+            }
         }
 
         // ── Jamming logic (SPI mode) ────────────────────────────
@@ -551,37 +710,32 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
         }
 
         NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-        bool flooding = cfg.useFlooding;
+        uint8_t strategy = cfg.strategy;
         uint16_t dwellMs = cfg.dwellTimeMs;
+        uint8_t burst = cfg.burstCount;
 
-        switch (currentMode) {
-            case NRF_JAM_FULL:
-            case NRF_JAM_DRONE: {
-                // Full sweep 0-124 (like original)
-                if (flooding) floodChannel(hopIndex, dwellMs);
-                else cwChannel(hopIndex, dwellMs);
-                channel = hopIndex;
-                hopIndex = (hopIndex + 1) % 125;
-                break;
+        if (shuffledCount > 0) {
+            uint8_t ch = shuffledCh[hopIndex % shuffledCount];
+
+            switch (strategy) {
+                case 0: cwChannel(ch, dwellMs); break;
+                case 1: floodChannel(ch, dwellMs, burst); break;
+                case 2: turboFloodChannel(ch, burst); break;
             }
 
-            default: {
-                // All preset channel list modes: sequential hopping
-                // (BLE, BLE_ADV, WiFi, Bluetooth, USB, Video, RC, Zigbee)
-                size_t count;
-                const uint8_t *channels = getChannelList(currentMode, count);
-                if (count > 0 && channels) {
-                    uint8_t ch = channels[hopIndex % count];
-                    if (flooding) floodChannel(ch, dwellMs);
-                    else cwChannel(ch, dwellMs);
-                    channel = ch;
-                    hopIndex++;
-                    if (hopIndex >= (int)count) hopIndex = 0;
-                } else {
-                    delay(1);
+            channel = ch;
+            totalCh++;
+            hopIndex++;
+            if (hopIndex >= (int)shuffledCount) {
+                hopIndex = 0;
+                sweepCount++;
+                // Re-shuffle for next sweep if random hop
+                if (cfg.randomHop && shuffledCount > 1) {
+                    shuffleChannels(shuffledCh, shuffledCount);
                 }
-                break;
             }
+        } else {
+            delay(1);
         }
     }
 
diff --git a/src/modules/NRF24/nrf_jammer.h b/src/modules/NRF24/nrf_jammer.h
index 38098c3d4..5bd23b2a7 100644
--- a/src/modules/NRF24/nrf_jammer.h
+++ b/src/modules/NRF24/nrf_jammer.h
@@ -41,7 +41,10 @@ struct NrfJamConfig {
     uint8_t paLevel;      // 0-3 (MIN..MAX, PA+LNA: 0dBm→+20dBm)
     uint8_t dataRate;     // 0=1Mbps, 1=2Mbps, 2=250Kbps
     uint16_t dwellTimeMs; // Time on each channel (0=turbo, max 200ms)
-    uint8_t useFlooding;  // 0=Constant Carrier, 1=Data Flooding
+    uint8_t strategy;     // 0=CW, 1=Flood, 2=Turbo Flood
+    uint8_t burstCount;   // Packets per flood burst (1-20, default 6)
+    uint8_t randomHop;    // 0=sequential, 1=randomized hop order
+    uint8_t _reserved;    // alignment padding
 };
 
 // ── Hopper config ───────────────────────────────────────────────
diff --git a/src/modules/NRF24/nrf_spectrum.cpp b/src/modules/NRF24/nrf_spectrum.cpp
index 28b3cf493..27d188420 100644
--- a/src/modules/NRF24/nrf_spectrum.cpp
+++ b/src/modules/NRF24/nrf_spectrum.cpp
@@ -1,183 +1,47 @@
-/**
- * @file nrf_spectrum.cpp
- * @brief Enhanced 2.4 GHz spectrum analyzer for Bruce firmware.
- *
- * Features:
- *  - 126 channels (full 2.400-2.525 GHz ISM band)
- *  - Color gradient bars (green→yellow→red based on signal level)
- *  - Peak hold markers with slow decay
- *  - Smooth EMA (Exponential Moving Average) filtering
- *  - 6 simultaneous receive pipes for maximum sensitivity
- *  - Adaptive layout for all screen resolutions
- *  - Grid lines every 10 channels for visual reference
- *  - PA+LNA module support (E01-ML01SP2: -90dBm effective threshold)
- *
- * RPD (Received Power Detector) is binary: 1 = signal above -64dBm
- * at chip input (-90dBm with PA+LNA module).
- */
-
 #include "nrf_spectrum.h"
 #include "core/display.h"
 #include "core/mykeyboard.h"
 
-// ── Spectrum data ───────────────────────────────────────────────
-static uint8_t channel[NRF_SPECTRUM_CHANNELS];
-static uint8_t peakHold[NRF_SPECTRUM_CHANNELS];
-static uint8_t peakTimer[NRF_SPECTRUM_CHANNELS];
-
-#define PEAK_HOLD_SWEEPS 25 // Number of sweeps before peak decays
-
-// ── Device label tracking ────────────────────────────────────────
-#define LABEL_DECAY_SWEEPS 10                           // Sweeps until label fades after signal gone
-static uint8_t deviceLabelTimer[NRF_SPECTRUM_CHANNELS]; // Decay timer per channel
-
-// Display mode (0=bars+peaks, 1=bars only, 2=bars+device labels)
-static uint8_t specDisplayMode = 0;
-
-// Device type detection for channels
-enum DeviceType { DEV_NONE, DEV_WIFI, DEV_BLE, DEV_BT, DEV_ZIGBEE };
-
-struct DeviceInfo {
-    const char *label;
-    uint16_t labelColor;
-};
-
-static const struct DeviceInfo deviceInfo[] = {
-    {nullptr,  TFT_BLACK  }, // DEV_NONE
-    {"WiFi",   TFT_WHITE  }, // DEV_WIFI
-    {"BLE",    TFT_CYAN   }, // DEV_BLE
-    {"BT",     TFT_MAGENTA}, // DEV_BT
-    {"Zigbee", TFT_GREEN  }, // DEV_ZIGBEE
-};
+#define CHANNELS 80
+#define RGB565(r, g, b) ((((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)))
+uint8_t channel[CHANNELS];
 
-// Detect device type from channel number
-static inline DeviceType getDeviceType(int channel) {
-    // WiFi: ch 1-14 (2.412-2.484 GHz) → NRF ch 12-84
-    if (channel >= 12 && channel <= 84) return DEV_WIFI;
-
-    // BLE Advertising: ch 37-39 (2.402, 2.426, 2.480 GHz) → NRF ch 2, 26, 80
-    if (channel == 2 || channel == 26 || channel == 80) return DEV_BLE;
-
-    // BT Classic: ch ~50-79 (2.450-2.480 GHz) → NRF ch 50-79
-    if (channel >= 50 && channel <= 79) return DEV_BT;
-
-    // Zigbee/Thread: ch 11-26 + 5-80 with 5MHz spacing (2.405-2.480 GHz) → NRF ch 5,10,15...80
-    if (channel >= 5 && channel <= 80 && (channel - 5) % 5 == 0) return DEV_ZIGBEE;
-
-    return DEV_NONE;
-}
-
-// ── Color gradient based on signal intensity (0-100) ────────────
-static uint16_t getSpectrumColor(uint8_t level) {
-    if (level > 85) return TFT_RED;
-    if (level > 65) return TFT_ORANGE;
-    if (level > 45) return TFT_YELLOW;
-    if (level > 25) return TFT_GREEN;
-    return TFT_DARKGREEN;
-}
-
-// ── Layout calculations ─────────────────────────────────────────
-static int spec_headerH;  // Header area height
-static int spec_footerH;  // Footer area height (freq labels)
-static int spec_barAreaY; // Top of bar area
-static int spec_barAreaH; // Height of bar area
-static int spec_mirrorH;  // Height of top mirror area
-static int spec_marginL;  // Left margin
-static int spec_drawW;    // Available drawing width (after margins)
-
-static void calcLayout() {
-    spec_headerH = 0;
-    spec_footerH = 14;
-    spec_mirrorH = 0; // Mirror removed — eliminates top artifacts
-    spec_barAreaY = 0;
-    spec_barAreaH = tftHeight - spec_footerH - 2;
-    spec_marginL = max(2, tftWidth / 80); // Small left margin
-    int marginR = spec_marginL;           // Symmetric right margin
-    spec_drawW = tftWidth - spec_marginL - marginR;
-}
-
-/// Get x position and width for channel i, distributed proportionally
-static inline void getBarGeom(int i, int &x, int &w) {
-    x = spec_marginL + (i * spec_drawW) / NRF_SPECTRUM_CHANNELS;
-    int nextX = spec_marginL + ((i + 1) * spec_drawW) / NRF_SPECTRUM_CHANNELS;
-    w = max(1, nextX - x);
-}
-
-// ── Scanning and drawing ────────────────────────────────────────
+// scanning channels
+#define _BW tftWidth / CHANNELS
 String scanChannels(bool web) {
-    String result = web ? "{" : "";
+    String result = "{";
 
-    // Toggle CE low during channel switch
+    uint8_t rpdValues[CHANNELS] = {0};
     digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
 
-    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+    for (int i = 0; i < CHANNELS; i++) {
         NRFradio.setChannel(i);
         NRFradio.startListening();
-        delayMicroseconds(170); // 130µs PLL settle + 40µs RPD sample window
+        delayMicroseconds(128);
         NRFradio.stopListening();
 
         int rpd = NRFradio.testRPD() ? 1 : 0;
-
-        // EMA smoothing: fast attack, medium decay
-        // Attack: signal instantly jumps to ~50 on first hit
-        // Decay: drops ~25% per sweep when signal gone
-        if (rpd) {
-            channel[i] = (uint8_t)min(100, (int)((channel[i] + 100) / 2));
-            deviceLabelTimer[i] = LABEL_DECAY_SWEEPS; // Reset label timer on active signal
-        } else {
-            channel[i] = (uint8_t)((channel[i] * 3) / 4);
-            // Decay label timer when no signal
-            if (deviceLabelTimer[i] > 0) { deviceLabelTimer[i]--; }
-        }
-
-        // Peak hold tracking
-        if (channel[i] >= peakHold[i]) {
-            peakHold[i] = channel[i];
-            peakTimer[i] = PEAK_HOLD_SWEEPS;
-        } else if (peakTimer[i] > 0) {
-            peakTimer[i]--;
-        } else {
-            if (peakHold[i] > 2) peakHold[i] -= 2;
-            else peakHold[i] = 0;
-        }
+        channel[i] = (channel[i] * 3 + rpd * 125) / 4;
+        rpdValues[i] = channel[i];
     }
 
     digitalWrite(bruceConfigPins.NRF24_bus.io0, HIGH);
 
-    // ── Draw spectrum bars ──────────────────────────────────────
-    uint8_t maxLevel = 0;
-    uint8_t maxCh = 0;
-
-    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
-        int x, w;
-        getBarGeom(i, x, w);
-
-        int level = channel[i];
-        if (level > maxLevel) {
-            maxLevel = level;
-            maxCh = i;
-        }
+    for (int i = 0; i < CHANNELS; i++) {
+        int level = rpdValues[i];
+        int x = i * _BW;
+        int c = i;
 
-        int barH = (level * spec_barAreaH) / 100;
-        int peakH = (peakHold[i] * spec_barAreaH) / 100;
+        tft.drawFastVLine(
+            x, tftHeight - (10 + level), level, (i % 2 == 0) ? bruceConfig.priColor : TFT_DARKGREY
+        ); // for level display
 
-        // Grid line color (every 10 channels)
-        uint16_t gridColor = (i % 10 == 0) ? TFT_DARKGREY : bruceConfig.bgColor;
-
-        // Main bar area: clear above, draw bar from bottom
-        if (barH < spec_barAreaH) { tft.fillRect(x, spec_barAreaY, w, spec_barAreaH - barH, gridColor); }
-        if (barH > 0) {
-            uint16_t barColor = getSpectrumColor(level);
-            tft.fillRect(x, spec_barAreaY + spec_barAreaH - barH, w, barH, barColor);
-        }
-
-        // Peak hold marker (Mode 0 only): white line segment
-        if (specDisplayMode == 0 && peakH > 0 && peakH >= barH) {
-            int peakY = spec_barAreaY + spec_barAreaH - peakH;
-            if (peakY >= spec_barAreaY && peakY < spec_barAreaY + spec_barAreaH) {
-                tft.fillRect(x, peakY, w, 1, TFT_WHITE);
-            }
-        }
+        tft.drawFastVLine(
+            x, 0, tftHeight - (9 + level), (i % 8) ? TFT_BLACK : RGB565(25, 25, 25)
+        );                                                    /// for clearing
+        tft.drawFastVLine(x, 0, level, bruceConfig.secColor); /// for top display
+        // show 5 channel gap only
+        if (c % 5 == 0 && c != 0) { tft.drawCentreString(String(c).c_str(), x, tftHeight / 2, 1); }
 
         if (web) {
             if (i > 0) result += ",";
@@ -185,98 +49,22 @@ String scanChannels(bool web) {
         }
     }
 
-    // Show peak channel indicator at top-right
-    if (maxLevel > 10) {
-        tft.setTextSize(FP);
-        tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
-        char peakBuf[12];
-        snprintf(peakBuf, sizeof(peakBuf), "pk:%d", (int)maxCh);
-        int pkW = 42;
-        int pkY = 1;
-        tft.fillRect(tftWidth - pkW - spec_marginL, pkY, pkW, 10, bruceConfig.bgColor);
-        tft.drawRightString(peakBuf, tftWidth - spec_marginL - 2, pkY, 1);
-    }
-
-    // ── Draw device labels (Mode 2 only) ──────────────────────────
-    if (specDisplayMode == 2) {
-        // Group labels by channel and stack vertically
-        int labelY = 2;
-        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
-            // Show label if signal present or timer still active
-            if ((channel[i] > 10) || (deviceLabelTimer[i] > 0)) {
-                DeviceType dev = getDeviceType(i);
-
-                if (dev != DEV_NONE) {
-                    // Display known device label
-                    int x, w;
-                    getBarGeom(i, x, w);
-                    int labelX = x + w / 2; // Center on channel
-
-                    tft.setTextSize(FP);
-                    tft.setTextColor(deviceInfo[dev].labelColor, bruceConfig.bgColor);
-                    tft.drawCentreString(deviceInfo[dev].label, labelX, labelY, 1);
-
-                    labelY += 8;                       // Stack labels vertically
-                    if (labelY > tftHeight / 4) break; // Prevent overflow
-                } else if (channel[i] > 10) {
-                    // Unknown device: show small "?" in gray
-                    int x, w;
-                    getBarGeom(i, x, w);
-                    int labelX = x + w / 2;
-
-                    tft.setTextSize(1); // Tiny font
-                    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
-                    tft.drawCentreString("?", labelX, labelY, 1);
-
-                    labelY += 6;
-                    if (labelY > tftHeight / 5) break;
-                }
-            }
-        }
-    }
-
     if (web) result += "}";
-    return result;
+    return result; // return a string in this format "{1,32,45,32,84,32 .... 12,54,65}" with 80 values to be
+                   // used in the WebUI (Future)
 }
 
 void nrf_spectrum() {
     tft.fillScreen(bruceConfig.bgColor);
-
-    // Initialize data
-    memset(channel, 0, sizeof(channel));
-    memset(peakHold, 0, sizeof(peakHold));
-    memset(peakTimer, 0, sizeof(peakTimer));
-    memset(deviceLabelTimer, 0, sizeof(deviceLabelTimer));
-    specDisplayMode = 0; // Start in mode 0
-
-    // Calculate layout
-    calcLayout();
-
-    // Draw frequency labels at bottom
-    tft.setTextSize(FP);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    int labelY = tftHeight - spec_footerH + 2;
-    tft.drawString("2.400", spec_marginL, labelY, 1);
-    tft.drawCentreString("2.462", tftWidth / 2, labelY, 1);
-    tft.drawRightString("2.525", tftWidth - spec_marginL, labelY, 1);
-
-    // Draw separator line
-    tft.drawFastHLine(0, spec_barAreaY + spec_barAreaH + 1, tftWidth, TFT_DARKGREY);
-
-    // Draw mode indicator
     tft.setTextSize(FP);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    const char *modeStr[] = {"Mode:Peak", "Mode:Bar", "Mode:Dev"};
-    tft.drawString(modeStr[specDisplayMode], spec_marginL, 2, 1);
+    tft.drawString("2.40Ghz", 0, tftHeight - LH);
+    tft.drawCentreString("2.44Ghz", tftWidth / 2, tftHeight - LH, 1);
+    tft.drawRightString("2.48Ghz", tftWidth, tftHeight - LH, 1);
 
-    if (nrf_start(NRF_MODE_SPI)) {
-        // Configure for wideband spectrum sensing
+    if (nrf_start(NRF_MODE_SPI)) { // This function only works on SPI
         NRFradio.setAutoAck(false);
-        NRFradio.disableCRC();
-        NRFradio.setAddressWidth(2);
-
-        // Open 6 reading pipes at noise-detection addresses
-        // More pipes = higher sensitivity (radio checks all in parallel)
+        NRFradio.disableCRC();       // accept any signal we find
+        NRFradio.setAddressWidth(2); // a reverse engineering tactic (not typically recommended)
         const uint8_t noiseAddress[][2] = {
             {0x55, 0x55},
             {0xAA, 0xAA},
@@ -286,27 +74,18 @@ void nrf_spectrum() {
             {0xAD, 0xAA}
         };
         for (uint8_t i = 0; i < 6; ++i) { NRFradio.openReadingPipe(i, noiseAddress[i]); }
-
         NRFradio.setDataRate(RF24_1MBPS);
 
-        while (!check(EscPress)) {
-            scanChannels();
-
-            // SEL to cycle through modes
-            if (check(SelPress)) {
-                specDisplayMode = (specDisplayMode + 1) % 3;
-                // Clear only spectrum bar area, preserve frequency labels at bottom
-                tft.fillRect(0, spec_barAreaY, tftWidth, spec_barAreaH, bruceConfig.bgColor);
-                delay(200);
-            }
-        }
-
+        while (!check(EscPress)) { scanChannels(); }
         NRFradio.stopListening();
         NRFradio.powerDown();
         delay(250);
+        return;
+
     } else {
         Serial.println("Fail Starting radio");
         displayError("NRF24 not found");
         delay(500);
+        return;
     }
 }
diff --git a/src/modules/NRF24/nrf_spectrum.cpp.bak b/src/modules/NRF24/nrf_spectrum.cpp.bak
new file mode 100644
index 000000000..cd27dc98d
--- /dev/null
+++ b/src/modules/NRF24/nrf_spectrum.cpp.bak
@@ -0,0 +1,365 @@
+/**
+ * @file nrf_spectrum.cpp
+ * @brief Enhanced 2.4 GHz spectrum analyzer for Bruce firmware.
+ *
+ * Features:
+ *  - 126 channels (full 2.400-2.525 GHz ISM band)
+ *  - Color gradient bars (green→yellow→red based on signal level)
+ *  - Peak hold markers with slow decay
+ *  - Smooth EMA (Exponential Moving Average) filtering
+ *  - 6 simultaneous receive pipes for maximum sensitivity
+ *  - Adaptive layout for all screen resolutions
+ *  - Grid lines every 10 channels for visual reference
+ *  - PA+LNA module support (E01-ML01SP2: -90dBm effective threshold)
+ *
+ * RPD (Received Power Detector) is binary: 1 = signal above -64dBm
+ * at chip input (-90dBm with PA+LNA module).
+ */
+
+#include "nrf_spectrum.h"
+#include "core/display.h"
+#include "core/mykeyboard.h"
+
+// ── Spectrum data ───────────────────────────────────────────────
+static uint8_t channel[NRF_SPECTRUM_CHANNELS];
+static uint8_t peakHold[NRF_SPECTRUM_CHANNELS];
+static uint8_t peakTimer[NRF_SPECTRUM_CHANNELS];
+
+#define PEAK_HOLD_SWEEPS 25 // Number of sweeps before peak decays
+
+// ── Device label tracking ────────────────────────────────────────
+#define LABEL_DECAY_SWEEPS 10                           // Sweeps until label fades after signal gone
+static uint8_t deviceLabelTimer[NRF_SPECTRUM_CHANNELS]; // Decay timer per channel
+
+// Display mode (0=bars+peaks, 1=bars only, 2=bars+device labels, 3=waterfall)
+static uint8_t specDisplayMode = 0;
+
+// Waterfall mode state
+static int waterfallY = 0;
+static unsigned long sweepCount = 0;
+
+// Device type detection for channels
+enum DeviceType { DEV_NONE, DEV_WIFI, DEV_BLE, DEV_BT, DEV_ZIGBEE };
+
+struct DeviceInfo {
+    const char *label;
+    uint16_t labelColor;
+};
+
+static const struct DeviceInfo deviceInfo[] = {
+    {nullptr,  TFT_BLACK  }, // DEV_NONE
+    {"WiFi",   TFT_WHITE  }, // DEV_WIFI
+    {"BLE",    TFT_CYAN   }, // DEV_BLE
+    {"BT",     TFT_MAGENTA}, // DEV_BT
+    {"Zigbee", TFT_GREEN  }, // DEV_ZIGBEE
+};
+
+// Detect device type from channel number
+static inline DeviceType getDeviceType(int channel) {
+    // WiFi: ch 1-14 (2.412-2.484 GHz) → NRF ch 12-84
+    if (channel >= 12 && channel <= 84) return DEV_WIFI;
+
+    // BLE Advertising: ch 37-39 (2.402, 2.426, 2.480 GHz) → NRF ch 2, 26, 80
+    if (channel == 2 || channel == 26 || channel == 80) return DEV_BLE;
+
+    // BT Classic: ch ~50-79 (2.450-2.480 GHz) → NRF ch 50-79
+    if (channel >= 50 && channel <= 79) return DEV_BT;
+
+    // Zigbee/Thread: ch 11-26 + 5-80 with 5MHz spacing (2.405-2.480 GHz) → NRF ch 5,10,15...80
+    if (channel >= 5 && channel <= 80 && (channel - 5) % 5 == 0) return DEV_ZIGBEE;
+
+    return DEV_NONE;
+}
+
+// ── Color gradient based on signal intensity (0-100) ────────────
+static uint16_t getSpectrumColor(uint8_t level) {
+    if (level > 85) return TFT_RED;
+    if (level > 65) return TFT_ORANGE;
+    if (level > 45) return TFT_YELLOW;
+    if (level > 25) return TFT_GREEN;
+    return TFT_DARKGREEN;
+}
+
+// ── Layout calculations ─────────────────────────────────────────
+static int spec_headerH;  // Header area height
+static int spec_footerH;  // Footer area height (freq labels)
+static int spec_barAreaY; // Top of bar area
+static int spec_barAreaH; // Height of bar area
+static int spec_mirrorH;  // Height of top mirror area
+static int spec_marginL;  // Left margin
+static int spec_drawW;    // Available drawing width (after margins)
+
+static void calcLayout() {
+    spec_headerH = 0;
+    spec_footerH = 14;
+    spec_mirrorH = 0; // Mirror removed — eliminates top artifacts
+    spec_barAreaY = 0;
+    spec_barAreaH = tftHeight - spec_footerH - 2;
+    spec_marginL = max(2, tftWidth / 80); // Small left margin
+    int marginR = spec_marginL;           // Symmetric right margin
+    spec_drawW = tftWidth - spec_marginL - marginR;
+}
+
+/// Get x position and width for channel i, distributed proportionally
+static inline void getBarGeom(int i, int &x, int &w) {
+    x = spec_marginL + (i * spec_drawW) / NRF_SPECTRUM_CHANNELS;
+    int nextX = spec_marginL + ((i + 1) * spec_drawW) / NRF_SPECTRUM_CHANNELS;
+    w = max(1, nextX - x);
+}
+
+// ── Scanning and drawing ────────────────────────────────────────
+String scanChannels(bool web) {
+    String result = web ? "{" : "";
+
+    // Toggle CE low during channel switch
+    digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
+
+    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+        NRFradio.setChannel(i);
+        NRFradio.startListening();
+        delayMicroseconds(170); // 130µs PLL settle + 40µs RPD sample window
+        NRFradio.stopListening();
+
+        int rpd = NRFradio.testRPD() ? 1 : 0;
+
+        // EMA smoothing: fast attack, medium decay
+        // Attack: signal instantly jumps to ~50 on first hit
+        // Decay: drops ~25% per sweep when signal gone
+        if (rpd) {
+            channel[i] = (uint8_t)min(100, (int)((channel[i] + 100) / 2));
+            deviceLabelTimer[i] = LABEL_DECAY_SWEEPS; // Reset label timer on active signal
+        } else {
+            channel[i] = (uint8_t)((channel[i] * 3) / 4);
+            // Decay label timer when no signal
+            if (deviceLabelTimer[i] > 0) { deviceLabelTimer[i]--; }
+        }
+
+        // Peak hold tracking
+        if (channel[i] >= peakHold[i]) {
+            peakHold[i] = channel[i];
+            peakTimer[i] = PEAK_HOLD_SWEEPS;
+        } else if (peakTimer[i] > 0) {
+            peakTimer[i]--;
+        } else {
+            if (peakHold[i] > 2) peakHold[i] -= 2;
+            else peakHold[i] = 0;
+        }
+    }
+
+    digitalWrite(bruceConfigPins.NRF24_bus.io0, HIGH);
+
+    sweepCount++;
+
+    // ── Draw spectrum bars (modes 0, 1, 2) ──────────────────────
+    if (specDisplayMode != 3) {
+    uint8_t maxLevel = 0;
+    uint8_t maxCh = 0;
+
+    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+        int x, w;
+        getBarGeom(i, x, w);
+
+        int level = channel[i];
+        if (level > maxLevel) {
+            maxLevel = level;
+            maxCh = i;
+        }
+
+        int barH = (level * spec_barAreaH) / 100;
+        int peakH = (peakHold[i] * spec_barAreaH) / 100;
+
+        // Grid line color (every 10 channels)
+        uint16_t gridColor = (i % 10 == 0) ? TFT_DARKGREY : bruceConfig.bgColor;
+
+        // Main bar area: clear above, draw bar from bottom
+        if (barH < spec_barAreaH) { tft.fillRect(x, spec_barAreaY, w, spec_barAreaH - barH, gridColor); }
+        if (barH > 0) {
+            uint16_t barColor = getSpectrumColor(level);
+            tft.fillRect(x, spec_barAreaY + spec_barAreaH - barH, w, barH, barColor);
+        }
+
+        // Peak hold marker (Mode 0 only): white line segment
+        if (specDisplayMode == 0 && peakH > 0 && peakH >= barH) {
+            int peakY = spec_barAreaY + spec_barAreaH - peakH;
+            if (peakY >= spec_barAreaY && peakY < spec_barAreaY + spec_barAreaH) {
+                tft.fillRect(x, peakY, w, 1, TFT_WHITE);
+            }
+        }
+
+        if (web) {
+            if (i > 0) result += ",";
+            result += String(level);
+        }
+    }
+
+    // Stats overlay (top, drawn after all bars)
+    {
+        int activeCh = 0;
+        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+            if (channel[i] > 10) activeCh++;
+        }
+        tft.setTextSize(FP);
+        char statBuf[36];
+        int stY = 1;
+        // Right: peak info
+        if (maxLevel > 10) {
+            int peakFreq = 2400 + (int)maxCh;
+            snprintf(statBuf, sizeof(statBuf), "PK:%dMHz %d%%", peakFreq, (int)maxLevel);
+            tft.fillRect(tftWidth - 110, stY, 110, 9, bruceConfig.bgColor);
+            tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+            tft.drawRightString(statBuf, tftWidth - spec_marginL - 2, stY, 1);
+        }
+        // Left (below mode): active + sweep count
+        snprintf(statBuf, sizeof(statBuf), "ACT:%d SW:%lu", activeCh, sweepCount);
+        tft.fillRect(spec_marginL, stY + 10, 90, 9, bruceConfig.bgColor);
+        tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+        tft.drawString(statBuf, spec_marginL, stY + 10, 1);
+    }
+
+    // ── Draw device labels (Mode 2 only) ──────────────────────────
+    if (specDisplayMode == 2) {
+        // Group labels by channel and stack vertically
+        int labelY = 2;
+        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+            // Show label if signal present or timer still active
+            if ((channel[i] > 10) || (deviceLabelTimer[i] > 0)) {
+                DeviceType dev = getDeviceType(i);
+
+                if (dev != DEV_NONE) {
+                    // Display known device label
+                    int x, w;
+                    getBarGeom(i, x, w);
+                    int labelX = x + w / 2; // Center on channel
+
+                    tft.setTextSize(FP);
+                    tft.setTextColor(deviceInfo[dev].labelColor, bruceConfig.bgColor);
+                    tft.drawCentreString(deviceInfo[dev].label, labelX, labelY, 1);
+
+                    labelY += 8;                       // Stack labels vertically
+                    if (labelY > tftHeight / 4) break; // Prevent overflow
+                } else if (channel[i] > 10) {
+                    // Unknown device: show small "?" in gray
+                    int x, w;
+                    getBarGeom(i, x, w);
+                    int labelX = x + w / 2;
+
+                    tft.setTextSize(1); // Tiny font
+                    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+                    tft.drawCentreString("?", labelX, labelY, 1);
+
+                    labelY += 6;
+                    if (labelY > tftHeight / 5) break;
+                }
+            }
+        }
+    }
+    } // end if (specDisplayMode != 3)
+
+    // ── Waterfall mode (mode 3) ─────────────────────────────────
+    if (specDisplayMode == 3) {
+        int rowH = max(2, spec_barAreaH / 60);
+        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+            int x, w;
+            getBarGeom(i, x, w);
+            uint16_t color = (channel[i] > 3) ? getSpectrumColor(channel[i]) : bruceConfig.bgColor;
+            tft.fillRect(x, spec_barAreaY + waterfallY, w, rowH, color);
+        }
+        // Draw cursor line at next position
+        int nextY = waterfallY + rowH;
+        if (nextY < spec_barAreaH) {
+            tft.drawFastHLine(spec_marginL, spec_barAreaY + nextY, spec_drawW, TFT_DARKGREY);
+        }
+        waterfallY += rowH;
+        if (waterfallY >= spec_barAreaH) waterfallY = 0;
+    }
+
+    if (web) result += "}";
+    return result;
+}
+
+void nrf_spectrum() {
+    tft.fillScreen(bruceConfig.bgColor);
+
+    // Initialize data
+    memset(channel, 0, sizeof(channel));
+    memset(peakHold, 0, sizeof(peakHold));
+    memset(peakTimer, 0, sizeof(peakTimer));
+    memset(deviceLabelTimer, 0, sizeof(deviceLabelTimer));
+    specDisplayMode = 0; // Start in mode 0
+    waterfallY = 0;
+    sweepCount = 0;
+
+    // Calculate layout
+    calcLayout();
+
+    // Draw frequency labels at bottom with WiFi channel markers
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    int labelY = tftHeight - spec_footerH + 2;
+    tft.drawString("2.400", spec_marginL, labelY, 1);
+    tft.drawCentreString("2.462", tftWidth / 2, labelY, 1);
+    tft.drawRightString("2.525", tftWidth - spec_marginL, labelY, 1);
+
+    // WiFi channel markers (ch1=nrf12, ch6=nrf37, ch11=nrf62)
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    int wifiChs[] = {12, 37, 62};
+    const char *wifiLabels[] = {"W1", "W6", "W11"};
+    for (int w = 0; w < 3; w++) {
+        int wx, ww;
+        getBarGeom(wifiChs[w], wx, ww);
+        tft.drawCentreString(wifiLabels[w], wx + ww / 2, labelY + 7, 1);
+        // Draw vertical tick mark at separator line
+        tft.drawFastVLine(wx + ww / 2, spec_barAreaY + spec_barAreaH + 1, 3, TFT_CYAN);
+    }
+
+    // Draw separator line
+    tft.drawFastHLine(0, spec_barAreaY + spec_barAreaH + 1, tftWidth, TFT_DARKGREY);
+
+    // Draw mode indicator
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    const char *modeStr[] = {"Mode:Peak", "Mode:Bar", "Mode:Dev", "Mode:WF"};
+    tft.drawString(modeStr[specDisplayMode], spec_marginL, 2, 1);
+
+    if (nrf_start(NRF_MODE_SPI)) {
+        // Configure for wideband spectrum sensing
+        NRFradio.setAutoAck(false);
+        NRFradio.disableCRC();
+        NRFradio.setAddressWidth(2);
+
+        // Open 6 reading pipes at noise-detection addresses
+        // More pipes = higher sensitivity (radio checks all in parallel)
+        const uint8_t noiseAddress[][2] = {
+            {0x55, 0x55},
+            {0xAA, 0xAA},
+            {0xA0, 0xAA},
+            {0xAB, 0xAA},
+            {0xAC, 0xAA},
+            {0xAD, 0xAA}
+        };
+        for (uint8_t i = 0; i < 6; ++i) { NRFradio.openReadingPipe(i, noiseAddress[i]); }
+
+        NRFradio.setDataRate(RF24_1MBPS);
+
+        while (!check(EscPress)) {
+            scanChannels();
+
+            // SEL to cycle through modes
+            if (check(SelPress)) {
+                specDisplayMode = (specDisplayMode + 1) % 4;
+                waterfallY = 0;
+                // Clear only spectrum bar area, preserve frequency labels at bottom
+                tft.fillRect(0, spec_barAreaY, tftWidth, spec_barAreaH, bruceConfig.bgColor);
+                delay(200);
+            }
+        }
+
+        NRFradio.stopListening();
+        NRFradio.powerDown();
+        delay(250);
+    } else {
+        Serial.println("Fail Starting radio");
+        displayError("NRF24 not found");
+        delay(500);
+    }
+}
diff --git a/src/modules/NRF24/nrf_spectrum.h b/src/modules/NRF24/nrf_spectrum.h
index 2e108e645..be57ae6bd 100644
--- a/src/modules/NRF24/nrf_spectrum.h
+++ b/src/modules/NRF24/nrf_spectrum.h
@@ -1,27 +1,10 @@
-/**
- * @file nrf_spectrum.h
- * @brief Enhanced 2.4 GHz spectrum analyzer using nRF24L01+ RPD register.
- *
- * Scans 126 channels (2.400-2.525 GHz, full ISM band) with color
- * gradient visualization, peak hold markers, and adaptive layout
- * for all Bruce-supported screen sizes.
- *
- * Supports PA+LNA modules (E01-ML01SP2) for improved sensitivity.
- */
 #ifndef __NRF_SPECTRUM_H
 #define __NRF_SPECTRUM_H
-
 #include "modules/NRF24/nrf_common.h"
+#include <RF24.h>
 
-/// Number of channels to scan (0-125 = 126 channels, full nRF24L01+ range)
-#define NRF_SPECTRUM_CHANNELS 126
-
-/// Main spectrum analyzer function (interactive, exits on ESC)
 void nrf_spectrum();
 
-/// Perform one scanning sweep and draw results.
-/// @param web  If true, returns JSON string of channel values.
-/// @return JSON string if web=true, empty string otherwise.
 String scanChannels(bool web = false);
 
-#endif // __NRF_SPECTRUM_H
+#endif
diff --git a/src/modules/ir/ir_read.cpp b/src/modules/ir/ir_read.cpp
index f54e60bde..65940ef94 100644
--- a/src/modules/ir/ir_read.cpp
+++ b/src/modules/ir/ir_read.cpp
@@ -12,18 +12,17 @@
 #include "core/mykeyboard.h"
 #include "core/sd_functions.h"
 #include "core/settings.h"
+#include "custom_ir.h"
 #include "ir_utils.h"
 #include <IRrecv.h>
 #include <IRutils.h>
 #include <globals.h>
 
-/* Dont touch this */
-// #define MAX_RAWBUF_SIZE 300
 #define IR_FREQUENCY 38000
 #define DUTY_CYCLE 0.330000
 
 String uint32ToString(uint32_t value) {
-    char buffer[12] = {0}; // 8 hex digits + 3 spaces + 1 null terminator
+    char buffer[12] = {0};
     snprintf(
         buffer,
         sizeof(buffer),
@@ -37,7 +36,7 @@ String uint32ToString(uint32_t value) {
 }
 
 String uint32ToStringInverted(uint32_t value) {
-    char buffer[12] = {0}; // 8 hex digits + 3 spaces + 1 null terminator
+    char buffer[12] = {0};
     snprintf(
         buffer,
         sizeof(buffer),
@@ -57,24 +56,46 @@ IrRead::IrRead(bool headless_mode, bool raw_mode) {
 }
 bool quickloop = false;
 
+static String getParsedProtocolName(const decode_results &r) {
+    switch (r.decode_type) {
+        case decode_type_t::RC5:
+            return (r.command > 0x3F) ? "RC5X" : "RC5";
+        case decode_type_t::RC6:
+            return "RC6";
+        case decode_type_t::SAMSUNG:
+            return "Samsung32";
+        case decode_type_t::SONY:
+            if (r.address > 0xFF) return "SIRC20";
+            if (r.address > 0x1F) return "SIRC15";
+            return "SIRC";
+        case decode_type_t::NEC:
+            if (r.address > 0xFFFF) return "NEC42ext";
+            if (r.address > 0xFF1F) return "NECext";
+            if (r.address > 0xFF) return "NEC42";
+            return "NEC";
+        case decode_type_t::UNKNOWN:
+            return "";
+        default:
+            return typeToString(r.decode_type, r.repeat);
+    }
+}
+
 void IrRead::setup() {
     irrecv.enableIRIn();
 
-#ifdef USE_BOOST /// ENABLE 5V OUTPUT
+#ifdef USE_BOOST
     PPM.enableOTG();
 #endif
-    // Checks if irRx pin is properly set
     const std::vector<std::pair<String, int>> pins = IR_RX_PINS;
     int count = 0;
     for (auto pin : pins) {
         if (pin.second == bruceConfigPins.irRx) count++;
     }
-    if (count == 0) gsetIrRxPin(true); // Open dialog to choose irRx pin
+    if (count == 0) gsetIrRxPin(true);
 
     setup_ir_pin(bruceConfigPins.irRx, INPUT_PULLUP);
     if (headless) return;
-    // else
-    returnToMenu = true; // make sure menu is redrawn when quitting in any point
+    returnToMenu = true;
     std::vector<Option> quickRemoteOptions = {
         {"TV",
          [&]() {
@@ -128,17 +149,26 @@ void IrRead::loop() {
             returnToMenu = true;
             button_pos = 0;
             quickloop = false;
-#ifdef USE_BOOST /// DISABLE 5V OUTPUT
+#ifdef USE_BOOST
             PPM.disableOTG();
 #endif
             break;
         }
-        if (check(NextPress)) save_signal();
-        if (quickloop && button_pos == quickButtons.size()) save_device();
-        if (check(SelPress)) save_device();
-        if (check(PrevPress)) discard_signal();
 
-        read_signal();
+        if (_emulate_mode) {
+            if (check(SelPress)) emulate_signal();
+            if (check(NextPress)) { _emulate_mode = false; discard_signal(); }
+            if (check(PrevPress)) { _emulate_mode = false; save_signal(); }
+        } else {
+            if (check(NextPress)) save_signal();
+            if (quickloop && button_pos == quickButtons.size()) save_device();
+            if (check(SelPress)) {
+                if (_read_signal) emulate_signal();
+                else save_device();
+            }
+            if (check(PrevPress)) discard_signal();
+            read_signal();
+        }
     }
 }
 
@@ -178,11 +208,17 @@ void IrRead::display_banner() {
 void IrRead::display_btn_options() {
     tft.println("");
     tft.println("");
-    if (_read_signal) {
-        padprintln("Press [PREV] to discard signal");
+    if (_emulate_mode) {
+        padprintln("Press [OK]   to send again");
+        padprintln("Press [NEXT] for new signal");
+        padprintln("Press [PREV] to save signal");
+    } else if (_read_signal) {
+        padprintln("Press [OK]   to emulate signal");
         padprintln("Press [NEXT] to save signal");
+        padprintln("Press [PREV] to discard");
+    } else {
+        if (signals_read > 0) { padprintln("Press [OK]   to save device"); }
     }
-    if (signals_read > 0) { padprintln("Press [OK]   to save device"); }
     padprintln("Press [ESC]  to exit");
 }
 
@@ -191,17 +227,22 @@ void IrRead::read_signal() {
 
     _read_signal = true;
 
-    // Always switches to RAW data, regardless of the decoding result
-    raw = true;
+    raw = (results.decode_type == decode_type_t::UNKNOWN) || hasACState(results.decode_type);
 
     display_banner();
 
-    // Dump of signal details
+    if (!raw) {
+        String proto = getParsedProtocolName(results);
+        padprintln("Protocol: " + (proto.length() ? proto : "UNKNOWN"));
+        padprintln("Bits: " + String(results.bits));
+    }
+
     padprint("RAW Data Captured:");
     String raw_signal = parse_raw_signal();
+    _captured_raw_signal = raw_signal;
     tft.println(
         raw_signal.substring(0, 45) + (raw_signal.length() > 45 ? "..." : "")
-    ); // Shows the RAW signal on the display
+    );
 
     display_btn_options();
     delay(500);
@@ -209,10 +250,44 @@ void IrRead::read_signal() {
 
 void IrRead::discard_signal() {
     if (!_read_signal) return;
+    _emulate_mode = false;
+    _captured_raw_signal = "";
     irrecv.resume();
     begin();
 }
 
+void IrRead::emulate_signal() {
+    IRCode code;
+    if (raw) {
+        code.type = "raw";
+        code.frequency = IR_FREQUENCY;
+        code.data = _captured_raw_signal;
+    } else {
+        code.type = "parsed";
+        code.protocol = getParsedProtocolName(results);
+        code.address = uint32ToString(results.address);
+        code.command = uint32ToString(results.command);
+        code.bits = results.bits;
+        code.data = resultToHexidecimal(&results);
+        if (code.protocol == "") {
+            code.type = "raw";
+            code.frequency = IR_FREQUENCY;
+            code.data = _captured_raw_signal;
+        }
+    }
+    sendIRCommand(&code);
+    if (code.type == "parsed" &&
+        (code.protocol == "RC5" || code.protocol == "RC5X" || code.protocol == "RC6")) {
+        delay(35);
+        sendIRCommand(&code);
+    }
+    _emulate_mode = true;
+    display_banner();
+    tft.setTextSize(FP);
+    padprintln("Signal emulated!");
+    display_btn_options();
+}
+
 void IrRead::save_signal() {
     if (!_read_signal) return;
     if (!quickloop) {
@@ -231,8 +306,7 @@ String IrRead::parse_state_signal() {
     String r = "";
     uint16_t state_len = (results.bits) / 8;
     for (uint16_t i = 0; i < state_len; i++) {
-        // r += uint64ToString(results.state[i], 16) + " ";
-        r += ((results.state[i] < 0x10) ? "0" : ""); // adds 0 padding if necessary
+        r += ((results.state[i] < 0x10) ? "0" : "");
         r += String(results.state[i], HEX) + " ";
     }
     r.toUpperCase();
@@ -264,7 +338,6 @@ void IrRead::append_to_file_str(String btn_name) {
         strDeviceContent += "duty_cycle: " + String(DUTY_CYCLE) + "\n";
         strDeviceContent += "data: " + parse_raw_signal() + "\n";
     } else {
-        // parsed signal  https://github.com/jamisonderek/flipper-zero-tutorials/wiki/Infrared
         strDeviceContent += "type: parsed\n";
         switch (results.decode_type) {
             case decode_type_t::RC5: {
@@ -281,14 +354,12 @@ void IrRead::append_to_file_str(String btn_name) {
                 break;
             }
             case decode_type_t::SONY: {
-                // check address and command ranges to find the exact protocol
                 if (results.address > 0xFF) strDeviceContent += "protocol: SIRC20\n";
                 else if (results.address > 0x1F) strDeviceContent += "protocol: SIRC15\n";
                 else strDeviceContent += "protocol: SIRC\n";
                 break;
             }
             case decode_type_t::NEC: {
-                // check address and command ranges to find the exact protocol
                 if (results.address > 0xFFFF) strDeviceContent += "protocol: NEC42ext\n";
                 else if (results.address > 0xFF1F) strDeviceContent += "protocol: NECext\n";
                 else if (results.address > 0xFF) strDeviceContent += "protocol: NEC42\n";
@@ -308,31 +379,12 @@ void IrRead::append_to_file_str(String btn_name) {
         strDeviceContent += "address: " + uint32ToString(results.address) + "\n";
         strDeviceContent += "command: " + uint32ToString(results.command) + "\n";
 
-        // extra fields not supported on flipper
         strDeviceContent += "bits: " + String(results.bits) + "\n";
         if (hasACState(results.decode_type)) strDeviceContent += "state: " + parse_state_signal() + "\n";
         else if (results.bits > 32)
             strDeviceContent += "value: " + uint32ToString(results.value) + " " +
-                                uint32ToString(results.value >> 32) + "\n"; // MEMO: from uint64_t
+                                uint32ToString(results.value >> 32) + "\n";
         else strDeviceContent += "value: " + uint32ToStringInverted(results.value) + "\n";
-
-        /*
-        Serial.println(results.bits);
-        Serial.println(results.address);
-        Serial.println(results.command);
-        Serial.println(results.overflow);
-        Serial.println(results.repeat);
-        Serial.println("value:");
-        serialPrintUint64(results.address, HEX);
-        serialPrintUint64(results.command, HEX);
-        Serial.print("resultToHexidecimal: ");
-        Serial.println(resultToHexidecimal(&results));
-        Serial.println(results.value);
-        String value = uint32ToString(results.value ) + " " + uint32ToString(results.value>> 32);
-        value.replace(" ", "");
-        uint64_t value_int = strtoull(value.c_str(), nullptr, 16);
-        Serial.println(value_int);
-        */
     }
     strDeviceContent += "#\n";
 }
@@ -350,7 +402,6 @@ void IrRead::save_device() {
     bool littleFsAvailable = checkLittleFsSize();
 
     if (sdCardAvailable && littleFsAvailable) {
-        // ask to choose one
         options = {
             {"SD Card",  [&]() { fs = &SD; }      },
             {"LittleFS", [&]() { fs = &LittleFS; }},
@@ -377,14 +428,13 @@ void IrRead::save_device() {
 
 String IrRead::loop_headless(int max_loops) {
 
-    while (!irrecv.decode(&results)) { // MEMO: default timeout is 15ms
+    while (!irrecv.decode(&results)) {
         max_loops -= 1;
         if (max_loops <= 0) {
             Serial.println("timeout");
-            return ""; // nothing received
+            return "";
         }
         delay(1000);
-        // delay(50);
     }
 
     irrecv.disableIRIn();
@@ -395,7 +445,6 @@ String IrRead::loop_headless(int max_loops) {
     }
 
     if (results.overflow) displayWarning("buffer overflow, data may be truncated", true);
-    // TODO: check results.repeat
 
     String r = "Filetype: IR signals file\n";
     r += "Version: 1\n";
@@ -403,7 +452,7 @@ String IrRead::loop_headless(int max_loops) {
     r += "#\n";
 
     strDeviceContent = "";
-    append_to_file_str("Unknown"); // writes on strDeviceContent
+    append_to_file_str("Unknown");
     r += strDeviceContent;
 
     return r;
@@ -421,7 +470,6 @@ bool IrRead::write_file(String filename, FS *fs) {
         displayWarning("File \"" + String(filename) + "\" already exists", true);
         display_banner();
 
-        // ask to choose one
         options = {
             {"Append number", [&]() { ch = 1; }},
             {"Overwrite ",    [&]() { ch = 2; }},
@@ -444,17 +492,6 @@ bool IrRead::write_file(String filename, FS *fs) {
         }
     }
 
-    /*
-    /Old "Add num index" solution
-
-    if ((*fs).exists("/BruceIR/" + filename + ".ir")) {
-        int i = 1;
-        filename += "_";
-        while((*fs).exists("/BruceIR/" + filename + String(i) + ".ir")) i++;
-        filename += String(i);
-    }
-    */
-
     File file = (*fs).open("/BruceIR/" + filename + ".ir", FILE_WRITE);
 
     if (!file) { return false; }
diff --git a/src/modules/ir/ir_read.h b/src/modules/ir/ir_read.h
index a8020435f..880a6925c 100644
--- a/src/modules/ir/ir_read.h
+++ b/src/modules/ir/ir_read.h
@@ -1,27 +1,12 @@
-/**
- * @file ir_read.h
- * @author Rennan Cockles (https://github.com/rennancockles)
- * @brief Read Infrared signals
- * @version 0.1
- * @date 2024-07-17
- */
-
 #include <IRrecv.h>
 #include <globals.h>
 
 class IrRead {
 public:
-    // IRrecv irrecv = IRrecv(bruceConfigPins.irRx);
     IRrecv irrecv = IRrecv(bruceConfigPins.irRx, SAFE_STACK_BUFFER_SIZE / 2, 50);
 
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Constructor
-    /////////////////////////////////////////////////////////////////////////////////////
     IrRead(bool headless_mode = false, bool raw_mode = false);
 
-    ///////////////////////////////////////////////////////////////////////////////////
-    // Arduino Life Cycle
-    ///////////////////////////////////////////////////////////////////////////////////
     void setup();
     void loop();
     void quickLoop();
@@ -30,6 +15,8 @@ class IrRead {
 
 private:
     bool _read_signal = false;
+    bool _emulate_mode = false;
+    String _captured_raw_signal = "";
     decode_results results;
     uint16_t *rawcode;
     uint16_t raw_data_len;
@@ -39,18 +26,13 @@ class IrRead {
     bool headless = false;
     bool raw = false;
 
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Display functions
-    /////////////////////////////////////////////////////////////////////////////////////
     void cls();
     void display_banner();
     void display_btn_options();
 
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Operations
-    /////////////////////////////////////////////////////////////////////////////////////
     void begin();
     void read_signal();
+    void emulate_signal();
     void save_device();
     void save_signal();
     void discard_signal();
@@ -58,9 +40,7 @@ class IrRead {
     bool write_file(String filename, FS *fs);
     String parse_raw_signal();
     String parse_state_signal();
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Quick Remotes
-    /////////////////////////////////////////////////////////////////////////////////////
+
     std::vector<String> quickButtonsTV = {"POWER", "UP",   "DOWN", "LEFT",  "RIGHT", "OK",       "SOURCES",
                                           "VOL+",  "VOL-", "CHA+", "CHA-",  "MUTE",  "SETTINGS", "NETFLIX",
                                           "HOME",  "BACK", "EXIT", "SMART", "1",     "2",        "3",
@@ -77,12 +57,12 @@ class IrRead {
                                              "STOP",     "NEXT",    "PREV", "SHUFFLE", "REPEAT"};
     std::vector<String> quickButtonsLED = {
     "ON", "OFF", "BRIGHTNESS+", "BRIGHTNESS-",
-    "RED", "GREEN", "BLUE", "WHITE",           
+    "RED", "GREEN", "BLUE", "WHITE",
     "ORANGE", "PEA_GREEN", "DARK_BLUE",
-    "DARK_YELLOW", "CYAN", "PURPLE",        
-    "YELLOW", "LIGHT_BLUE", "MAGENTA",    
-    "LIGHT_YELLOW", "SKY_BLUE", "ROSE",       
-    "MODE_FLASH", "MODE_STROBE", "MODE_FADE", "MODE_SMOOTH" 
+    "DARK_YELLOW", "CYAN", "PURPLE",
+    "YELLOW", "LIGHT_BLUE", "MAGENTA",
+    "LIGHT_YELLOW", "SKY_BLUE", "ROSE",
+    "MODE_FLASH", "MODE_STROBE", "MODE_FADE", "MODE_SMOOTH"
 };
     std::vector<String> &quickButtons = quickButtonsTV;
 };
diff --git a/src/modules/rf/rf_jammer.cpp b/src/modules/rf/rf_jammer.cpp
index 6bde6d172..7554d7a8c 100644
--- a/src/modules/rf/rf_jammer.cpp
+++ b/src/modules/rf/rf_jammer.cpp
@@ -1,157 +1,542 @@
 #include "rf_jammer.h"
 #include "core/display.h"
+#include "core/mykeyboard.h"
 #include "rf_utils.h"
+#include <ELECHOUSE_CC1101_SRC_DRV.h>
+#include <globals.h>
 
-static const uint32_t MAX_JAM_TIME_MS = 20000;
 static const uint32_t MAX_SEQUENCE = 50;
 static const uint32_t DURATION_CYCLES = 3;
 
-RFJammer::RFJammer(bool full) : fullJammer(full) { 
-    setup(); 
+static const char *JAM_MODE_NAMES[] = {"FULL POWER", "INTERMITTENT", "NOISE STORM", "FREQ SWEEP"};
+static const uint16_t JAM_MODE_COLORS[] = {TFT_RED, TFT_ORANGE, TFT_MAGENTA, TFT_CYAN};
+
+RFJammer::RFJammer(bool full) {
+    jamMode = full ? RF_JAM_FULL : RF_JAM_ITMT;
+    setup();
+}
+
+RFJammer::~RFJammer() {
+    deinitRfModule();
 }
 
-RFJammer::~RFJammer() { 
-    deinitRfModule(); 
+// ── Mode selection menu ─────────────────────────────────────────
+RFJamMode RFJammer::showModeMenu(bool defaultFull) {
+    isCC1101 = (bruceConfigPins.rfModule == CC1101_SPI_MODULE);
+
+    int menuIdx = defaultFull ? 0 : 1;
+    bool redraw = true;
+    int modeCount = isCC1101 ? RF_JAM_MODE_COUNT : 2; // Only Full+Itmt for raw GPIO
+
+    while (true) {
+        if (check(EscPress)) return (RFJamMode)255; // Cancel
+
+        if (redraw) {
+            drawMainBorderWithTitle("RF JAMMER MODE");
+            tft.setTextSize(FP);
+
+            int y = BORDER_PAD_Y + FM * LH + 4;
+            int lineH = max(14, tftHeight / (modeCount + 4));
+
+            for (int i = 0; i < modeCount; i++) {
+                int itemY = y + i * lineH;
+                uint16_t fg = (i == menuIdx) ? bruceConfig.bgColor : bruceConfig.priColor;
+                uint16_t bg = (i == menuIdx) ? JAM_MODE_COLORS[i] : bruceConfig.bgColor;
+
+                tft.fillRect(7, itemY, tftWidth - 14, lineH - 2, bg);
+                tft.setTextColor(fg, bg);
+                tft.drawCentreString(JAM_MODE_NAMES[i], tftWidth / 2, itemY + 2, 1);
+            }
+
+            // Description of selected mode
+            int descY = y + modeCount * lineH + 4;
+            tft.fillRect(7, descY, tftWidth - 14, lineH * 2, bruceConfig.bgColor);
+            tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+            const char *descs[] = {
+                "Max duty cycle continuous TX",
+                "Varied pulse patterns + bursts",
+                "CC1101 HW random noise (PN9)",
+                "Sweep +/-5MHz around target"
+            };
+            tft.drawCentreString(descs[menuIdx], tftWidth / 2, descY + 2, 1);
+
+            // Footer
+            int footerY = tftHeight - BORDER_PAD_X - FP * LH - 2;
+            tft.fillRect(7, footerY, tftWidth - 14, FP * LH, bruceConfig.bgColor);
+            tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+            tft.drawCentreString("[OK]Select [ESC]Back", tftWidth / 2, footerY, 1);
+
+            redraw = false;
+        }
+
+        if (check(NextPress)) { menuIdx = (menuIdx + 1) % modeCount; redraw = true; }
+        if (check(PrevPress)) { menuIdx = (menuIdx + modeCount - 1) % modeCount; redraw = true; }
+        if (check(SelPress)) return (RFJamMode)menuIdx;
+
+        delay(50);
+    }
 }
 
 void RFJammer::setup() {
+    // Show mode selection first
+    RFJamMode selected = showModeMenu(jamMode == RF_JAM_FULL);
+    if ((uint8_t)selected == 255) { sendRF = false; return; }
+    jamMode = selected;
+
     nTransmitterPin = bruceConfigPins.rfTx;
-    if (!initRfModule("tx")) return;
+    if (!initRfModule("tx")) { sendRF = false; return; }
 
-    if (bruceConfigPins.rfModule == CC1101_SPI_MODULE) {
+    isCC1101 = (bruceConfigPins.rfModule == CC1101_SPI_MODULE);
+    if (isCC1101) {
         nTransmitterPin = bruceConfigPins.CC1101_bus.io0;
     }
 
     sendRF = true;
+    pulseCount = 0;
+    sweepCount = 0;
     display_banner();
 
-    if (fullJammer) run_full_jammer();
-    else run_itmt_jammer();
+    switch (jamMode) {
+        case RF_JAM_FULL:  run_full_jammer();  break;
+        case RF_JAM_ITMT:  run_itmt_jammer();  break;
+        case RF_JAM_NOISE: run_noise_jammer(); break;
+        case RF_JAM_SWEEP: run_sweep_jammer(); break;
+        default: break;
+    }
 }
 
 void RFJammer::display_banner() {
-    drawMainBorderWithTitle("RF Jammer");
-    printSubtitle(String(fullJammer ? "Full Jammer" : "Intermittent Jammer"));
-    padprintln("Sending...");
-    padprintln("");
-    padprintln("");
-    
-    tft.setTextColor(getColorVariation(bruceConfig.priColor), bruceConfig.bgColor);
-    padprintln("Press [ESC] for options.");
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    drawMainBorderWithTitle("RF JAMMER");
+
+    int y = BORDER_PAD_Y + FM * LH + 4;
+    int lineH = max(14, tftHeight / 10);
+    tft.setTextSize(FP);
+    char buf[40];
+
+    // Line 1: Mode badge (centered, colored rounded rect)
+    const char *modeName = JAM_MODE_NAMES[jamMode];
+    uint16_t modeClr = JAM_MODE_COLORS[jamMode];
+    int mbW = strlen(modeName) * 6 + 10;
+    int mbX = (tftWidth - mbW) / 2;
+    tft.fillRoundRect(mbX, y, mbW, lineH - 2, 3, modeClr);
+    tft.setTextColor(TFT_BLACK, modeClr);
+    tft.drawCentreString(modeName, tftWidth / 2, y + 2, 1);
+    y += lineH;
+
+    // Line 2: Frequency + Module badge
+    tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "%.2f MHz", bruceConfigPins.rfFreq);
+    tft.drawString(buf, 12, y + 2, 1);
+    const char *modStr = isCC1101 ? "CC1101" : "RAW TX";
+    int mdW = strlen(modStr) * 6 + 8;
+    int mdX = tftWidth - 12 - mdW;
+    tft.fillRoundRect(mdX, y + 1, mdW, lineH - 3, 3, TFT_DARKGREY);
+    tft.setTextColor(TFT_WHITE, TFT_DARKGREY);
+    tft.drawCentreString(modStr, mdX + mdW / 2, y + 2, 1);
+    y += lineH;
+
+    // Line 3: Timer + Stats
+    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+    tft.drawString("00:00", 12, y + 2, 1);
+    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+    if (jamMode == RF_JAM_SWEEP) {
+        tft.drawRightString("Sweeps: 0", tftWidth - 12, y + 2, 1);
+    } else {
+        tft.drawRightString("Pulses: 0", tftWidth - 12, y + 2, 1);
+    }
+    y += lineH;
+
+    // Line 4: TX Power bar (gradient fill)
+    {
+        int bX = 12, bW = tftWidth - 24;
+        int bH = max(6, lineH - 6);
+        int bY = y + (lineH - bH) / 2;
+        tft.drawRect(bX, bY, bW, bH, bruceConfig.priColor);
+        int segW = (bW - 2) / 4;
+        tft.fillRect(bX + 1, bY + 1, segW, bH - 2, TFT_GREEN);
+        tft.fillRect(bX + 1 + segW, bY + 1, segW, bH - 2, TFT_YELLOW);
+        tft.fillRect(bX + 1 + segW * 2, bY + 1, segW, bH - 2, TFT_ORANGE);
+        tft.fillRect(bX + 1 + segW * 3, bY + 1, bW - 2 - segW * 3, bH - 2, TFT_RED);
+        tft.setTextColor(TFT_WHITE, TFT_BLACK);
+        tft.drawCentreString("TX POWER", tftWidth / 2, bY + 1, 1);
+    }
+    y += lineH;
+
+    // Line 5: ACTIVE indicator with dot
+    tft.fillCircle(tftWidth / 2 - 50, y + lineH / 2, 4, modeClr);
+    tft.setTextColor(modeClr, bruceConfig.bgColor);
+    tft.drawString("JAMMING ACTIVE", tftWidth / 2 - 38, y + 2, 1);
+
+    // Footer
+    int footerY = tftHeight - BORDER_PAD_X - FP * LH - 2;
+    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+    tft.drawCentreString("[ESC] Stop", tftWidth / 2, footerY, 1);
+}
+
+void RFJammer::update_display(uint32_t elapsedMs) {
+    unsigned long secs = elapsedMs / 1000;
+    unsigned long mins = secs / 60;
+    secs %= 60;
+
+    int y = BORDER_PAD_Y + FM * LH + 4;
+    int lineH = max(14, tftHeight / 10);
+    y += lineH * 2; // Skip to timer line
+
+    // Update timer + stats
+    tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+    tft.setTextSize(FP);
+    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+    char buf[30];
+    snprintf(buf, sizeof(buf), "%02lu:%02lu", mins, secs);
+    tft.drawString(buf, 12, y + 2, 1);
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    if (jamMode == RF_JAM_SWEEP) {
+        snprintf(buf, sizeof(buf), "Sweeps: %lu", (unsigned long)sweepCount);
+    } else {
+        snprintf(buf, sizeof(buf), "P: %lu", (unsigned long)pulseCount);
+    }
+    tft.drawRightString(buf, tftWidth - 12, y + 2, 1);
+
+    // Blink activity dot
+    y += lineH * 2; // Skip to ACTIVE line
+    uint16_t modeClr = JAM_MODE_COLORS[jamMode];
+    bool dotOn = (secs % 2 == 0);
+    tft.fillCircle(tftWidth / 2 - 50, y + lineH / 2, 4, dotOn ? modeClr : bruceConfig.bgColor);
 }
 
+// ── FULL POWER: Maximum duty cycle continuous TX ────────────────
+// Aggressive multi-pattern approach: alternates between sustained carrier,
+// rapid micro-glitches, and burst disruption patterns for maximum spectral
+// pollution across the widest bandwidth possible.
 void RFJammer::run_full_jammer() {
     digitalWrite(nTransmitterPin, HIGH);
     uint32_t startTime = millis();
     uint32_t lastCheckTime = startTime;
-    
+    uint32_t lastDisplayTime = startTime;
+    uint8_t phase = 0; // Cycle through 3 attack phases
+
     while (sendRF) {
-        static uint8_t microPulse = 0;
-        
-        if (micros() % 100 < 2) {
+        uint32_t currentTime = millis();
+        uint32_t elapsed = currentTime - startTime;
+
+        // Phase rotation every 100ms for maximum spectral diversity
+        phase = (elapsed / 100) % 3;
+
+        switch (phase) {
+        case 0:
+            // Phase A: Ultra-rapid micro-glitches (1µs LOW every 4µs)
+            for (int i = 0; i < 100 && sendRF; i++) {
+                digitalWrite(nTransmitterPin, HIGH);
+                delayMicroseconds(3);
+                digitalWrite(nTransmitterPin, LOW);
+                delayMicroseconds(1);
+                pulseCount++;
+            }
+            break;
+        case 1:
+            // Phase B: Variable-width burst disruption (2-20µs pulses)
+            for (int i = 0; i < 50 && sendRF; i++) {
+                uint32_t w = 2 + (micros() % 18);
+                digitalWrite(nTransmitterPin, HIGH);
+                delayMicroseconds(w);
+                digitalWrite(nTransmitterPin, LOW);
+                delayMicroseconds(1);
+                pulseCount++;
+            }
+            break;
+        case 2:
+            // Phase C: Sustained carrier with periodic hard cuts
+            digitalWrite(nTransmitterPin, HIGH);
+            delayMicroseconds(80);
             digitalWrite(nTransmitterPin, LOW);
-            delayMicroseconds(1);
+            delayMicroseconds(2);
             digitalWrite(nTransmitterPin, HIGH);
+            delayMicroseconds(80);
+            pulseCount += 2;
+            break;
         }
-        
-        uint32_t currentTime = millis();
+
         if (currentTime - lastCheckTime > 100) {
             lastCheckTime = currentTime;
-            
-            if (check(EscPress) || (currentTime - startTime > MAX_JAM_TIME_MS)) {
+            if (check(EscPress)) {
                 sendRF = false;
                 returnToMenu = true;
                 break;
             }
         }
-        
-        if (currentTime % 500 < 10) {
-            digitalWrite(nTransmitterPin, LOW);
-            delayMicroseconds(5);
-            digitalWrite(nTransmitterPin, HIGH);
+
+        if (currentTime - lastDisplayTime >= 1000) {
+            lastDisplayTime = currentTime;
+            update_display(currentTime - startTime);
         }
     }
     digitalWrite(nTransmitterPin, LOW);
 }
 
+// ── INTERMITTENT: Varied pulse patterns + bursts ────────────────
 void RFJammer::run_itmt_jammer() {
     uint32_t startTime = millis();
     uint32_t lastCheckTime = startTime;
-    
+    uint32_t lastDisplayTime = startTime;
+
     uint32_t sequenceValues[MAX_SEQUENCE];
-    for (int i = 0; i < MAX_SEQUENCE; i++) {
+    for (uint32_t i = 0; i < MAX_SEQUENCE; i++) {
         sequenceValues[i] = 10 * (i + 1);
     }
-    
+
     while (sendRF) {
-        for (int sequence = 0; sequence < MAX_SEQUENCE && sendRF; sequence++) {
+        // Forward sweep: 10µs → 500µs
+        for (uint32_t sequence = 0; sequence < MAX_SEQUENCE && sendRF; sequence++) {
             uint32_t pulseWidth = sequenceValues[sequence];
-            
-            for (int duration = 0; duration < DURATION_CYCLES && sendRF; duration++) {
+
+            for (uint32_t duration = 0; duration < DURATION_CYCLES && sendRF; duration++) {
                 send_optimized_pulse(pulseWidth);
-                
+                pulseCount++;
+
                 uint32_t currentTime = millis();
                 if (currentTime - lastCheckTime > 50) {
                     lastCheckTime = currentTime;
-                    
-                    if (check(EscPress) || (currentTime - startTime > MAX_JAM_TIME_MS)) {
+                    if (check(EscPress)) {
                         sendRF = false;
                         returnToMenu = true;
                         break;
                     }
                 }
+
+                if (currentTime - lastDisplayTime >= 1000) {
+                    lastDisplayTime = currentTime;
+                    update_display(currentTime - startTime);
+                }
+            }
+        }
+
+        // Reverse sweep: 500µs → 10µs for chirp effect
+        for (int sequence = MAX_SEQUENCE - 1; sequence >= 0 && sendRF; sequence--) {
+            send_optimized_pulse(sequenceValues[sequence]);
+            pulseCount++;
+
+            uint32_t currentTime = millis();
+            if (currentTime - lastCheckTime > 50) {
+                lastCheckTime = currentTime;
+                if (check(EscPress)) { sendRF = false; returnToMenu = true; break; }
+            }
+            if (currentTime - lastDisplayTime >= 1000) {
+                lastDisplayTime = currentTime;
+                update_display(currentTime - startTime);
             }
         }
-        
+
+        // Random noise burst
         if (sendRF) {
-            send_random_pattern(100);
+            send_random_pattern(200);
+            pulseCount += 200;
         }
     }
     digitalWrite(nTransmitterPin, LOW);
 }
 
-void RFJammer::send_optimized_pulse(int width) {
+// ── NOISE STORM: CC1101 PN9 hardware random TX ─────────────────
+// Uses CC1101's internal PN9 pseudo-random generator to transmit
+// continuous modulated noise at maximum bandwidth. Cycles between
+// modulation schemes (ASK→2FSK→MSK) for wideband spectral coverage.
+void RFJammer::run_noise_jammer() {
+    if (!isCC1101) return;
+
+    // Switch CC1101 to PN9 random TX mode — maximum aggression
+    ELECHOUSE_cc1101.setSidle();
+    ELECHOUSE_cc1101.setPktFormat(2);   // PN9 random TX mode
+    ELECHOUSE_cc1101.setDRate(800);     // Push data rate higher for wider occupied BW
+    ELECHOUSE_cc1101.setModulation(2);  // Start with ASK/OOK
+    ELECHOUSE_cc1101.setDeviation(47.6);// Max deviation for FSK modes
+    ELECHOUSE_cc1101.setRxBW(812);      // Widest RX BW setting (not critical for TX but sets filter)
+    ELECHOUSE_cc1101.setPA(12);         // Maximum TX power
+    ELECHOUSE_cc1101.SetTx();
+
+    uint32_t startTime = millis();
+    uint32_t lastDisplayTime = startTime;
+
+    // Update mode badge text for noise mode
+    int y = BORDER_PAD_Y + FM * LH + 4;
+    int lineH = max(14, tftHeight / 10);
+    y += lineH * 4; // ACTIVE line
+    tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+    tft.fillCircle(tftWidth / 2 - 50, y + lineH / 2, 4, TFT_MAGENTA);
+    tft.setTextColor(TFT_MAGENTA, bruceConfig.bgColor);
+    tft.setTextSize(FP);
+    tft.drawString("PN9 HW NOISE TX", tftWidth / 2 - 38, y + 2, 1);
+
+    uint8_t modCycle = 0;
+    static const uint8_t modSchemes[] = {2, 0, 1}; // ASK, 2FSK, MSK
+    static const char *modNames[] = {"ASK/OOK", "2-FSK", "MSK"};
+
+    while (sendRF) {
+        uint32_t currentTime = millis();
+
+        // Cycle modulation scheme every 3 seconds for spectral diversity
+        uint8_t newMod = ((currentTime - startTime) / 3000) % 3;
+        if (newMod != modCycle) {
+            modCycle = newMod;
+            ELECHOUSE_cc1101.setSidle();
+            ELECHOUSE_cc1101.setModulation(modSchemes[modCycle]);
+            ELECHOUSE_cc1101.SetTx();
+
+            // Show current modulation on display
+            int modY = BORDER_PAD_Y + FM * LH + 4 + max(14, tftHeight / 10) * 4;
+            tft.fillRect(7, modY, tftWidth - 14, max(14, tftHeight / 10), bruceConfig.bgColor);
+            tft.fillCircle(tftWidth / 2 - 50, modY + max(14, tftHeight / 10) / 2, 4, TFT_MAGENTA);
+            tft.setTextColor(TFT_MAGENTA, bruceConfig.bgColor);
+            tft.setTextSize(FP);
+            char modBuf[30];
+            snprintf(modBuf, sizeof(modBuf), "PN9 %s TX", modNames[modCycle]);
+            tft.drawString(modBuf, tftWidth / 2 - 38, modY + 2, 1);
+        }
+
+        if (currentTime - lastDisplayTime >= 1000) {
+            lastDisplayTime = currentTime;
+            pulseCount = (currentTime - startTime) / 1000;
+            update_display(currentTime - startTime);
+        }
+
+        if (check(EscPress)) {
+            sendRF = false;
+            returnToMenu = true;
+            break;
+        }
+
+        delay(50); // Low CPU usage since hardware handles TX
+    }
+
+    // Restore CC1101 to idle
+    ELECHOUSE_cc1101.setSidle();
+    ELECHOUSE_cc1101.setPktFormat(3); // Restore async serial mode
+}
+
+// ── FREQ SWEEP: Hop around target frequency ─────────────────────
+// Sweeps ±5MHz around the configured frequency in 50kHz steps.
+// Alternates sweep direction each pass for maximum coverage.
+// TX burst at each step creates wideband interference.
+void RFJammer::run_sweep_jammer() {
+    if (!isCC1101) return;
+
+    float baseFreq = bruceConfigPins.rfFreq;
+    float sweepMin = baseFreq - 5.0f;
+    float sweepMax = baseFreq + 5.0f;
+    float sweepStep = 0.05f; // 50kHz steps for finer coverage
+    float currentFreq = sweepMin;
+    bool sweepForward = true;
+
+    // Maximum CC1101 TX power
+    ELECHOUSE_cc1101.setPA(12);
+
+    uint32_t startTime = millis();
+    uint32_t lastCheckTime = startTime;
+    uint32_t lastDisplayTime = startTime;
+
+    // Start TX on first frequency
+    ELECHOUSE_cc1101.setMHZ(currentFreq);
     digitalWrite(nTransmitterPin, HIGH);
-    
-    for (uint32_t i = 0; i < width; i += 10) {
-        digitalWrite(nTransmitterPin, HIGH);
-        delayMicroseconds(5);
-        
-        if (i % 20 == 0) {
-            digitalWrite(nTransmitterPin, LOW);
-            delayMicroseconds(2);
+
+    while (sendRF) {
+        // Sweep frequency
+        ELECHOUSE_cc1101.setMHZ(currentFreq);
+
+        // TX burst at each frequency — 40 pulses with tight timing
+        for (int burst = 0; burst < 40 && sendRF; burst++) {
             digitalWrite(nTransmitterPin, HIGH);
+            delayMicroseconds(30);
+            digitalWrite(nTransmitterPin, LOW);
+            delayMicroseconds(5);
+            pulseCount++;
+        }
+
+        // Bidirectional sweep
+        if (sweepForward) {
+            currentFreq += sweepStep;
+            if (currentFreq > sweepMax) {
+                currentFreq = sweepMax;
+                sweepForward = false;
+                sweepCount++;
+            }
+        } else {
+            currentFreq -= sweepStep;
+            if (currentFreq < sweepMin) {
+                currentFreq = sweepMin;
+                sweepForward = true;
+                sweepCount++;
+            }
+        }
+
+        uint32_t currentTime = millis();
+        if (currentTime - lastCheckTime > 100) {
+            lastCheckTime = currentTime;
+            if (check(EscPress)) {
+                sendRF = false;
+                returnToMenu = true;
+                break;
+            }
+        }
+
+        if (currentTime - lastDisplayTime >= 500) {
+            lastDisplayTime = currentTime;
+
+            // Update frequency display on sweep
+            int y = BORDER_PAD_Y + FM * LH + 4;
+            int lineH = max(14, tftHeight / 10);
+            y += lineH; // Freq line
+            tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+            tft.setTextSize(FP);
+            tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+            char buf[30];
+            snprintf(buf, sizeof(buf), "%.2f MHz", currentFreq);
+            tft.drawString(buf, 12, y + 2, 1);
+
+            update_display(currentTime - startTime);
         }
-        
-        delayMicroseconds(5);
     }
-    
+
     digitalWrite(nTransmitterPin, LOW);
-    
-    uint32_t lowPeriod = width + (width % 23);
-    for (uint32_t i = 0; i < lowPeriod; i += 10) {
+    // Restore original frequency
+    ELECHOUSE_cc1101.setMHZ(baseFreq);
+}
+
+void RFJammer::send_optimized_pulse(int width) {
+    // Aggressive HIGH phase: rapid micro-interruptions every 6µs
+    // creates wideband harmonic content around center frequency
+    for (uint32_t i = 0; i < (uint32_t)width; i += 6) {
+        digitalWrite(nTransmitterPin, HIGH);
+        delayMicroseconds(5);
+        // Sub-microsecond glitch every cycle for spectral spread
         digitalWrite(nTransmitterPin, LOW);
-        delayMicroseconds(10);
+        delayMicroseconds(1);
     }
+    digitalWrite(nTransmitterPin, HIGH);
+    delayMicroseconds(width / 3); // Extra sustained tail
+    digitalWrite(nTransmitterPin, LOW);
+
+    // Minimal dead time — maximize duty cycle
+    uint32_t lowPeriod = width / 4;
+    if (lowPeriod > 0) delayMicroseconds(lowPeriod);
 }
 
 void RFJammer::send_random_pattern(int numPulses) {
     uint32_t startTime = millis();
-    
+
     for (int i = 0; i < numPulses && sendRF; i++) {
-        uint32_t pulseWidth = 5 + (millis() % 46);
-        
+        // Wider range of pulse widths for maximum spectral diversity
+        uint32_t pulseWidth = 1 + (micros() % 60);
+
         digitalWrite(nTransmitterPin, HIGH);
         delayMicroseconds(pulseWidth);
-        
+
         digitalWrite(nTransmitterPin, LOW);
-        
-        uint32_t spaceWidth = 5 + (micros() % 96);
+
+        // Minimal dead time: 1-8µs for near-max duty cycle
+        uint32_t spaceWidth = 1 + (micros() % 8);
         delayMicroseconds(spaceWidth);
-        
-        if (millis() - startTime > 100) {
-            break;
+
+        if (millis() - startTime > 250) {
+            break; // Longer burst window
         }
     }
 }
diff --git a/src/modules/rf/rf_jammer.h b/src/modules/rf/rf_jammer.h
index bed7795f6..a7e02d0f0 100644
--- a/src/modules/rf/rf_jammer.h
+++ b/src/modules/rf/rf_jammer.h
@@ -1,6 +1,17 @@
 #ifndef __RF_JAMMER_H__
 #define __RF_JAMMER_H__
 
+#include <cstdint>
+
+// ── RF Jammer modes ─────────────────────────────────────────────
+enum RFJamMode : uint8_t {
+    RF_JAM_FULL = 0,     // Continuous TX — maximum duty cycle
+    RF_JAM_ITMT,         // Intermittent bursts — varied pulse patterns
+    RF_JAM_NOISE,        // CC1101 PN9 random TX — hardware noise generator
+    RF_JAM_SWEEP,        // Frequency sweep around target — CC1101 only
+    RF_JAM_MODE_COUNT
+};
+
 class RFJammer {
 public:
     RFJammer(bool full = false);
@@ -11,11 +22,18 @@ class RFJammer {
 private:
     int nTransmitterPin;
     bool sendRF = true;
-    bool fullJammer = false;
+    bool isCC1101 = false;
+    RFJamMode jamMode = RF_JAM_FULL;
+    uint32_t pulseCount = 0;
+    uint32_t sweepCount = 0;
 
+    RFJamMode showModeMenu(bool defaultFull);
     void display_banner();
+    void update_display(uint32_t elapsedMs);
     void run_full_jammer();
     void run_itmt_jammer();
+    void run_noise_jammer();
+    void run_sweep_jammer();
     void send_optimized_pulse(int width);
     void send_random_pattern(int numPulses);
 };
diff --git a/src/modules/rf/rf_spectrum.cpp.bak b/src/modules/rf/rf_spectrum.cpp.bak
new file mode 100644
index 000000000..a277006f1
--- /dev/null
+++ b/src/modules/rf/rf_spectrum.cpp.bak
@@ -0,0 +1,303 @@
+#include "rf_spectrum.h"
+#include "rf_utils.h"
+#include "structs.h"
+#include <RCSwitch.h>
+
+static bool spectrum_rmt_rx_done_callback(
+    rmt_channel_t *channel, const rmt_rx_done_event_data_t *edata, void *user_data
+) {
+    BaseType_t high_task_wakeup = pdFALSE;
+    QueueHandle_t receive_queue = (QueueHandle_t)user_data;
+    // send the received RMT symbols to the parser task
+    xQueueSendFromISR(receive_queue, edata, &high_task_wakeup);
+    return high_task_wakeup == pdTRUE;
+}
+
+void draw_tf_spectrum_grid() {
+    tft.setTextSize(1);
+    tft.setCursor(3, 2);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.printf(" RF - Spectrum (%.2f Mhz)", bruceConfigPins.rfFreq);
+    tft.fillRect(0, 20, tftWidth, tftHeight - 20, bruceConfig.bgColor);
+    tft.drawFastHLine(0, 20 + tftHeight / 2, tftWidth, TFT_DARKGREY);
+    tft.drawFastVLine((1 * tftWidth) / 4, 20, tftHeight - 20, TFT_DARKGREY);
+    tft.drawFastVLine((2 * tftWidth) / 4, 20, tftHeight - 20, TFT_DARKGREY);
+    tft.drawFastVLine((3 * tftWidth) / 4, 20, tftHeight - 20, TFT_DARKGREY);
+}
+
+void rf_spectrum() {
+    tft.fillScreen(bruceConfig.bgColor);
+    draw_tf_spectrum_grid();
+    rmt_channel_handle_t rx_ch = NULL;
+    rx_ch = setup_rf_rx();
+    if (rx_ch == NULL) return;
+    ESP_LOGI("RMT_SPECTRUM", "register RX done callback");
+    QueueHandle_t receive_queue = xQueueCreate(1, sizeof(rmt_rx_done_event_data_t));
+    assert(receive_queue);
+    rmt_rx_event_callbacks_t cbs = {
+        .on_recv_done = spectrum_rmt_rx_done_callback,
+    };
+    ESP_ERROR_CHECK(rmt_rx_register_event_callbacks(rx_ch, &cbs, receive_queue));
+    ESP_ERROR_CHECK(rmt_enable(rx_ch));
+    rmt_receive_config_t receive_config = {
+        .signal_range_min_ns = 3000,     // 6us minimum signal duration
+        .signal_range_max_ns = 12000000, // 24ms maximum signal duration
+    };
+    rmt_symbol_word_t item[64];
+    rmt_rx_done_event_data_t rx_data;
+    ESP_ERROR_CHECK(rmt_receive(rx_ch, item, sizeof(item), &receive_config));
+
+    size_t rx_size = 0;
+    while (1) {
+        rmt_symbol_word_t *rx_items = NULL;
+        if (xQueueReceive(receive_queue, &rx_data, 0) == pdPASS) {
+            rx_size = rx_data.num_symbols;
+            rx_items = rx_data.received_symbols;
+        }
+        if (rx_size != 0) {
+            // Draw grid and info
+            draw_tf_spectrum_grid();
+            // Draw waveform based on signal strength
+            for (size_t i = 0; i < rx_size; i++) {
+                int lineHeight =
+                    map(rx_items[i].duration0 + rx_items[i].duration1,
+                        0,
+                        SIGNAL_STRENGTH_THRESHOLD,
+                        0,
+                        tftHeight / 2);
+                int lineX = map(i, 0, rx_size - 1, 0, tftWidth - 1); // Map i to within the display width
+                int startY = constrain(20 + tftHeight / 2 - lineHeight / 2, 20, 20 + tftHeight);
+                int endY = constrain(20 + tftHeight / 2 + lineHeight / 2, 20, 20 + tftHeight);
+                tft.drawLine(lineX, startY, lineX, endY, bruceConfig.priColor);
+            }
+
+            ESP_ERROR_CHECK(rmt_receive(rx_ch, item, sizeof(item), &receive_config));
+            rx_size = 0;
+        }
+        // Checks to leave while
+        if (check(EscPress)) { break; }
+        if (setMHZMenu()) yield();
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    returnToMenu = true;
+    rmt_disable(rx_ch);
+    rmt_del_channel(rx_ch);
+    vQueueDelete(receive_queue);
+    deinitRfModule();
+}
+
+#define TIME_DIVIDER (tftWidth / 10)
+//@Pirata
+void rf_SquareWave() {
+    RCSwitch rcswitch;
+    if (!initRfModule("rx", bruceConfigPins.rfFreq)) return;
+
+    if (bruceConfigPins.rfModule == CC1101_SPI_MODULE) rcswitch.enableReceive(bruceConfigPins.CC1101_bus.io0);
+    else rcswitch.enableReceive(bruceConfigPins.rfRx);
+    int line_w = 0;
+    int line_h = 15;
+    unsigned int *raw;
+PRINT:
+    tft.drawPixel(0, 0, 0);
+    tft.fillScreen(bruceConfig.bgColor);
+    tft.setTextSize(1);
+    tft.setCursor(3, 2);
+    tft.printf("  RF - SquareWave (%.2f Mhz)", bruceConfigPins.rfFreq);
+
+    while (1) {
+        if (rcswitch.RAWavailable()) {
+            raw = rcswitch.getRAWReceivedRawdata();
+            // Clear the display area
+            // tft.fillRect(0, 0, tftWidth, tftHeight, bruceConfig.bgColor);
+            // Draw waveform based on signal strength
+            for (int i = 0; i < RCSWITCH_RAW_MAX_CHANGES - 1; i += 2) {
+                if (raw[i] == 0) break;
+
+                if (raw[i] > 20000) raw[i] = 20000;
+                if (raw[i + 1] > 20000) raw[i + 1] = 20000;
+                if (line_w + (raw[i] + raw[i + 1]) / TIME_DIVIDER > tftWidth) {
+                    line_w = 10;
+                    line_h += 10;
+                }
+                if (line_h > tftHeight) {
+                    line_h = 15;
+                    tft.fillRect(0, 12, tftWidth, tftHeight, bruceConfig.bgColor);
+                }
+                tft.drawFastVLine(line_w, line_h, 6, bruceConfig.priColor);
+                tft.drawFastHLine(line_w, line_h, raw[i] / TIME_DIVIDER, bruceConfig.priColor);
+
+                tft.drawFastVLine(line_w + raw[i] / TIME_DIVIDER, line_h, 6, bruceConfig.priColor);
+                tft.drawFastHLine(
+                    line_w + raw[i] / TIME_DIVIDER,
+                    line_h + 6,
+                    raw[i + 1] / TIME_DIVIDER,
+                    bruceConfig.priColor
+                );
+                line_w += (raw[i] + raw[i + 1]) / TIME_DIVIDER;
+            }
+            rcswitch.resetAvailable();
+        }
+        // Checks to leave while
+        if (check(EscPress)) { break; }
+        if (setMHZMenu()) goto PRINT;
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    returnToMenu = true;
+}
+
+void rf_CC1101_rssi() {
+#if !defined(LITE_VERSION)
+    if (bruceConfigPins.rfModule != CC1101_SPI_MODULE) {
+        displayError("only for CC1101 module", true);
+        return;
+    }
+    int graph_size = tftWidth - 20;
+    std::vector<int> signal(graph_size, -95);
+    const size_t freq_count = sizeof(subghz_frequency_list) / sizeof(float);
+    std::vector<int> bar_size(freq_count, 0);
+    std::vector<int> peak_size(freq_count, 0);
+    int max_bar_size = tftHeight - 20 /*bottom margin*/ - 20 /*top margin*/;
+    bool redraw = true;
+    const int min_value = map(-70, -95, -20, 0, max_bar_size);
+    while (1) {
+        if (redraw) {
+            redraw = false;
+            tft.drawPixel(0, 0, 0);
+            tft.fillScreen(bruceConfig.bgColor);
+            tft.setTextSize(1);
+            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+            tft.setCursor(3, 2);
+            // Fixed frequency sees a dot running grafic, showing RSSI over time
+            if (bruceConfigPins.rfFxdFreq) {
+                if (!initRfModule("rx", bruceConfigPins.rfFreq))
+                    displayError("Error setting frequency", true);
+                tft.printf(" RF - RSSI spectrum (%.2f Mhz)", bruceConfigPins.rfFreq);
+                tft.drawFastVLine(20, 20, tftHeight, bruceConfig.priColor);
+                tft.drawString("-95", 0, (tftHeight - 120) + 95);
+                tft.drawString("-80", 0, (tftHeight - 120) + 80);
+                tft.drawString("-65", 0, (tftHeight - 120) + 65);
+                tft.drawString("-50", 0, (tftHeight - 120) + 50);
+                tft.drawString("-35", 0, (tftHeight - 120) + 35);
+                tft.drawString("-20", 0, (tftHeight - 120) + 20);
+                // resets signal array
+                std::fill(signal.begin(), signal.end(), -95);
+            }
+            // Range Scan Sees a bargraph simillar to NRF24 grafic, using RSSI across frequencies
+            else {
+                if (!initRfModule("rx", bruceConfigPins.rfFreq)) displayError("Error starting module", true);
+                tft.printf(" RF - RSSI spectrum (%s)", subghz_frequency_ranges[bruceConfigPins.rfScanRange]);
+                tft.drawFastHLine(0, tftHeight - 20, tftWidth, bruceConfig.priColor);
+                char buf[7];
+                float var = subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][0]];
+                snprintf(buf, sizeof(buf), "%.3f", var);
+                tft.drawString(buf, 2, tftHeight - 10);
+                var = subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][1]];
+                snprintf(buf, sizeof(buf), "%.3f", var);
+                tft.drawRightString(buf, tftWidth - 2, tftHeight - 10);
+                int range = range_limits[bruceConfigPins.rfScanRange][1] -
+                            range_limits[bruceConfigPins.rfScanRange][0] + 1;
+                int space = tftWidth / range;
+                for (int i = 0; i < range; i++) {
+                    tft.drawFastVLine(space * i, tftHeight - 20, 5, bruceConfig.priColor);
+                }
+                std::fill(bar_size.begin(), bar_size.end(), 0);
+                std::fill(peak_size.begin(), peak_size.end(), 0);
+            }
+        }
+
+        // draw dot graph for fixed frequency
+        if (bruceConfigPins.rfFxdFreq) {
+            int rssi = ELECHOUSE_cc1101.getRssi();
+            tft.drawPixel(0, 0, 0); // To make sure CC1101 shared with TFT works properly
+            const int base_y = tftHeight - 120;
+            int prev = signal[0];
+            for (int i = 1; i < graph_size; i++) {
+                if (EscPress || SelPress) break;
+                const int x0 = 20 + (i - 1);
+                const int x1 = 20 + i;
+                const int curr = signal[i];
+                // erase old segment between previous and current points
+                tft.drawLine(x0, base_y - prev, x1, base_y - curr, bruceConfig.bgColor);
+                const int next_val = (i == graph_size - 1) ? rssi : signal[i + 1];
+                // shift buffer left by one
+                signal[i - 1] = curr;
+                if (i == graph_size - 1) signal[i] = rssi;
+                // draw updated segment using new values
+                tft.drawLine(x0, base_y - curr, x1, base_y - next_val, bruceConfig.priColor);
+                prev = curr;
+            }
+            tft.drawFastVLine(20, 20, tftHeight, bruceConfig.priColor);
+            vTaskDelay(pdMS_TO_TICKS(75));
+        }
+        // draw a bargraph similar to nrf24 across the range
+        else {
+            int range = range_limits[bruceConfigPins.rfScanRange][1] -
+                        range_limits[bruceConfigPins.rfScanRange][0] + 1;
+
+            int space = tftWidth / range;
+            int max_idx = 0;
+            for (int i = 0; i < range; i++) {
+                if (EscPress || SelPress) break;
+                setMHZ(subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][0] + i]);
+                vTaskDelay(pdMS_TO_TICKS(5));
+                int rssi = ELECHOUSE_cc1101.getRssi();
+                tft.drawPixel(0, 0, 0); // To make sure CC1101 shared with TFT works properly
+                int size = map(rssi, -95, -20, 0, max_bar_size);
+                if (size > bar_size[i]) bar_size[i] = size;
+                else bar_size[i] = bar_size[i] - (bar_size[i] - size) / 2; // slow down decrease
+                // Peak hold tracking
+                if (bar_size[i] > peak_size[i]) peak_size[i] = bar_size[i];
+                else if (peak_size[i] > 0) peak_size[i]--;
+                // Color gradient based on strength
+                uint16_t barClr = TFT_DARKGREEN;
+                if (bar_size[i] > max_bar_size * 85 / 100) barClr = TFT_RED;
+                else if (bar_size[i] > max_bar_size * 65 / 100) barClr = TFT_ORANGE;
+                else if (bar_size[i] > max_bar_size * 45 / 100) barClr = TFT_YELLOW;
+                else if (bar_size[i] > max_bar_size * 25 / 100) barClr = TFT_GREEN;
+                tft.fillRect(
+                    i * space, tftHeight - 20 - bar_size[i], space - 2, bar_size[i], barClr
+                );
+                tft.fillRect(i * space, 20, space, max_bar_size - bar_size[i], bruceConfig.bgColor);
+                // Peak hold marker (white line)
+                if (peak_size[i] > bar_size[i] && peak_size[i] > 0) {
+                    int peakY = tftHeight - 20 - peak_size[i];
+                    tft.drawFastHLine(i * space, peakY, space - 2, TFT_WHITE);
+                }
+                if (bar_size[i] > bar_size[max_idx] && bar_size[i] > min_value) max_idx = i;
+            }
+            // dBm reference labels (overlaid on bars)
+            {
+                int refs[] = {-70, -45};
+                const char *rlbl[] = {"-70", "-45"};
+                tft.setTextSize(FP);
+                for (int r = 0; r < 2; r++) {
+                    int refH = map(refs[r], -95, -20, 0, max_bar_size);
+                    int refY = tftHeight - 20 - refH;
+                    tft.fillRect(0, refY - 4, 20, 9, bruceConfig.bgColor);
+                    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+                    tft.drawString(rlbl[r], 1, refY - 4, 1);
+                    tft.drawFastHLine(0, refY, 4, TFT_DARKGREY);
+                }
+            }
+            if (bar_size[max_idx] > min_value) {
+                char buf[24];
+                float var = subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][0] + max_idx];
+                int peakDbm = map(bar_size[max_idx], 0, max_bar_size, -95, -20);
+                snprintf(buf, sizeof(buf), "PK:%.2f %ddBm", var, peakDbm);
+                tft.fillRect(tftWidth / 2 - 70, tftHeight - 10, 140, 10, bruceConfig.bgColor);
+                tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+                tft.drawCentreString(buf, tftWidth / 2, tftHeight - 10);
+            }
+        }
+        if (check(EscPress)) { break; }
+        if (check(SelPress)) {
+            deinitRfModule();
+            rf_range_selection(bruceConfigPins.rfFreq);
+            redraw = true;
+        }
+    }
+    deinitRfModule();
+#else
+    displayError("Not available on Launcher version");
+#endif
+}
diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index 035d421ec..da4eb93dc 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -56,8 +56,9 @@ bool filterAnsiSequences = true; // Set to false to disable ANSI sequence filter
 void ssh_setup(String host) {
     if (!wifiConnected) wifiConnectMenu();
 
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    drawMainBorderWithTitle("SSH");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     if (host != "") ssh_host = host;
     else {
         String my_net =
@@ -104,8 +105,9 @@ void ssh_setup(String host) {
 void ssh_loop(void *pvParameters) {
     String message = "";
     tft.setTextSize(FP);
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    drawMainBorderWithTitle("SSH");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     cursorY = tft.getCursorY();
     log_d("BEFORE SSH");
     my_ssh_session = ssh_new();
@@ -193,9 +195,10 @@ void ssh_loop(void *pvParameters) {
     }
 
     log_d("SSH setup completed.");
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
+    drawMainBorderWithTitle("SSH");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
     tft.setTextSize(FP);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     char buffer[1024];
     int nbytes;
     keyStroke key;
@@ -222,8 +225,9 @@ void ssh_loop(void *pvParameters) {
                     tft.setTextColor(TFT_GREEN);
                     commandBuffer.trim();
                     if (commandBuffer.substring(2) == "cls") {
-                        tft.fillScreen(bruceConfig.bgColor);
-                        tft.setCursor(0, 0);
+                        drawMainBorderWithTitle("SSH");
+                        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                        tft.setCursor(10, BORDER_PAD_Y + FM * LH);
                         tft.print("> ");
                         commandBuffer = "> ";
                     } else {
@@ -247,8 +251,9 @@ void ssh_loop(void *pvParameters) {
             message = keyboard("cls", 76, "SSH Command: ");
             while (check(SelPress)) { yield(); } // timerless debounce
             if (message == "cls") {
-                tft.fillScreen(bruceConfig.bgColor);
-                tft.setCursor(0, 0);
+                drawMainBorderWithTitle("SSH");
+                tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                tft.setCursor(10, BORDER_PAD_Y + FM * LH);
                 tft.print("> ");
             } else {
                 message += "\r";
@@ -257,7 +262,7 @@ void ssh_loop(void *pvParameters) {
             }
 
             commandBuffer = "> " + message;
-            tft.setCursor(0, 0);
+            tft.setCursor(10, tft.getCursorY());
             tft.setTextSize(FP);
         }
 
@@ -273,13 +278,15 @@ void ssh_loop(void *pvParameters) {
                 msg += char(buffer[i]);
                 if (buffer[i] == '\r') continue; // Ignore carriage return
                 tft.write(buffer[i]);
-                if (tft.getCursorY() > tftHeight) {
-                    tft.fillScreen(bruceConfig.bgColor);
-                    tft.setCursor(0, 0);
-                    tft.setTextColor(TFT_GREEN);
+                if (tft.getCursorY() > tftHeight - 20) {
+                    drawMainBorderWithTitle("SSH");
+                    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+                    tft.setTextColor(bruceConfig.secColor);
                     tft.print(commandBuffer); // Move to the next line on display
                     tft.setTextColor(TFT_WHITE);
                 }
+                if (tft.getCursorX() == 0) tft.setCursor(10, tft.getCursorY());
                 cursorY = tft.getCursorY();
             }
             log_d("%s", msg);
@@ -351,18 +358,21 @@ void telnet_loop() {
     }
 
     Serial.println("Connected to TELNET server");
-    tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-    displayTextLine("Connected to TELNET server");
+    drawMainBorderWithTitle("TELNET");
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
 
     String commandInput;
 
     while (1) {
+        tft.setCursor(10, tft.getCursorY());
         tft.print("> ");
         // waitForInput(commandInput);
         commandInput = keyboard("", 76, "COMMAND");
+        drawMainBorderWithTitle("TELNET");
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+        tft.println("> " + commandInput);
         const char *command = commandInput.c_str();
         send(sock, command, strlen(command), 0);
 
@@ -382,6 +392,7 @@ if (buffer[0] == 0xFF) {
             Serial.printf("Received from server %s\n", buffer);
             // tft.printf("Received from server %s\n", buffer);
             for (int i = 0; i < len; i++) { Serial.printf("%02X ", buffer[i]); }
+            tft.setCursor(10, tft.getCursorY());
             tft.printf("%s\n", buffer);
 
             tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
@@ -394,19 +405,20 @@ if (buffer[0] == 0xFF) {
 void telnet_setup() {
     if (!wifiConnected) wifiConnectMenu();
 
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    drawMainBorderWithTitle("TELNET");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     Serial.begin(115200); // Initialize serial communication for debugging
     Serial.println("Starting Setup");
 
     // auto cfg = M5.config();
     // M5Cardputer.begin(cfg, true);
     tft.setRotation(bruceConfigPins.rotation);
-    tft.setTextSize(1); // Set text size
+    tft.setTextSize(FP); // Set text size
 
     cursorY = tft.getCursorY();
 
-    tft.setCursor(0, 0);
+    tft.setCursor(10, tft.getCursorY());
     // tft.print("TELNET Host: \n");
 
     // Here the telnet_server_ip needs to be a char*, thats why the stringTochar()
diff --git a/src/modules/wifi/responder.cpp b/src/modules/wifi/responder.cpp
index e3373f621..fc80d4f6d 100644
--- a/src/modules/wifi/responder.cpp
+++ b/src/modules/wifi/responder.cpp
@@ -195,43 +195,43 @@ String readUTF16(uint8_t *pkt, uint32_t offset, uint16_t len) {
 
 void updateHashUI() {
     // auto& d = M5Cardputer.Display;
-    // tft.fillScreen(bruceConfig.bgColor);
+    // drawMainBorderWithTitle("RESPONDER", true); // clear
 
     // 1) NTLM count
-    tft.setTextSize(1.0);
+    tft.setTextSize(FP);
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setCursor(5, 5);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     tft.print("NTLM: ");
     tft.setTextSize(2);
-    tft.print(hashCount);
+    tft.println(hashCount);
 
     // 2) User
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 30);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print("User: ");
     tft.setTextSize(2);
-    tft.print(lastUser);
+    tft.println(lastUser);
 
     // 3) Domain
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 55);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print("Domain: ");
     tft.setTextSize(2);
-    tft.print(lastDomain);
+    tft.println(lastDomain);
 
     // 4) Client (hostname)
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 80);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print("Client: ");
     tft.setTextSize(2);
-    tft.print(lastClient);
+    tft.println(lastClient);
 
     // 5) Query (NBNS/LLMNR + name)
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 105);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print(lastQueryProtocol + ": ");
     tft.setTextSize(2);
-    tft.print(lastQueryName);
+    tft.println(lastQueryName);
 }
 
 void extractAndPrintHash(uint8_t *pkt, uint32_t smbLength, uint8_t *ntlm) {
@@ -564,8 +564,8 @@ void decodeNetBIOSLabel(const uint8_t *enc32, char *out, size_t outSize) {
 ***************************************************************************************/
 void responder() {
 
-    tft.fillScreen(bruceConfig.bgColor);
-    // M5Cardputer.Display.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    drawMainBorderWithTitle("RESPONDER");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
     if (!wifiConnected) wifiConnectMenu();
 
     netbiosname_str = keyboard("Bruce", 20);
@@ -575,6 +575,9 @@ void responder() {
     dnsdomain_str = keyboard("Bruce.Local", 20);
     dnsDomain = stringTochar(dnsdomain_str);
 
+    drawMainBorderWithTitle("RESPONDER"); // draw again after keyboard
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+
     hashCount = 0;
     // Démarrer l'écoute NBNS (UDP 137)
     if (!nbnsUDP.begin(NBNS_PORT)) { Serial.println(F("Erreur: Impossible to listen on UDP 137")); }
@@ -595,18 +598,18 @@ void responder() {
         //  Choix de la fonction selon le count
         if (hashCount == 0) {
             // showWaitingAnimation();
-            tft.setCursor(0, 0);
-            tft.setTextSize(0);
-            tft.println("Waiting\nLLMNR Interact...");
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+            tft.setTextSize(FP);
+            tft.println("Waiting LLMNR Interact");
         } else if (hashCount == 1) {
-
-            tft.setCursor(60, 90);
-            tft.setTextSize(0);
-            tft.println("Found Interaction!\n\nthanks 7h30th3r0n3");
-
+            drawMainBorderWithTitle("RESPONDER", true);
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+            tft.setTextSize(FP);
+            tft.println("Found Interaction!\nthanks 7h30th3r0n3");
         } else {
-
-            tft.setCursor(60, 90);
+            drawMainBorderWithTitle("RESPONDER", true);
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+            tft.setTextSize(FP);
             tft.println("End");
         }
         // lastAnim = now;
diff --git a/src/modules/wifi/sniffer.cpp b/src/modules/wifi/sniffer.cpp
index 0810204b3..41f4845d6 100644
--- a/src/modules/wifi/sniffer.cpp
+++ b/src/modules/wifi/sniffer.cpp
@@ -979,9 +979,10 @@ void sniffer_setup() {
     SnifferMode startMode = sniffer_full_mode_available() ? SnifferMode::Full : SnifferMode::HandshakesOnly;
     sniffer_set_mode(startMode);
 
-    displayTextLine("Sniffing Started");
     tft.setTextSize(FP);
-    tft.setCursor(80, 100);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    tft.println("Sniffing Started");
 
     sniffer_reset_handshake_cache(); // Need to clear to restart HS count
     registeredBeacons.clear();
diff --git a/src/modules/wifi/socks4_proxy.cpp b/src/modules/wifi/socks4_proxy.cpp
index cb104c747..b06ae4be9 100644
--- a/src/modules/wifi/socks4_proxy.cpp
+++ b/src/modules/wifi/socks4_proxy.cpp
@@ -87,15 +87,15 @@ void socks4Proxy(uint16_t port) {
     WiFiServer server(port);
     server.begin();
 
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setTextSize(2);
+    drawMainBorderWithTitle("SOCKS4 PROXY");
+    tft.setTextSize(FP);
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawCentreString("SOCKS4 Proxy", tftWidth / 2, 10, 1);
-    tft.setCursor(0, 28);
-    tft.setTextSize(1);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     tft.println("Port: " + String(port));
+    tft.setCursor(10, tft.getCursorY());
     tft.println("IP: " + WiFi.localIP().toString());
-    tft.println("Esc: exit");
+    tft.println();
+    tft.setCursor(10, tft.getCursorY());
     tft.println("Waiting for clients...");
     tft.println("");
     Serial.println("[SOCKS4] Listening on " + WiFi.localIP().toString() + ":" + String(port));
@@ -118,13 +118,16 @@ void socks4Proxy(uint16_t port) {
         connCount++;
         client.setNoDelay(true);
         String clientIp = client.remoteIP().toString();
+        tft.setCursor(10, tft.getCursorY());
         tft.println("---");
+        tft.setCursor(10, tft.getCursorY());
         tft.println("CLIENT #" + String(connCount) + " " + clientIp);
         Serial.println("[SOCKS4] Client #" + String(connCount) + " connected from " + clientIp);
 
         if (!readSocks4Request(client, cd, dstPort, dstIp, hostname, sizeof(hostname))) {
             sendSocks4Reply(client, SOCKS4_REP_REJECTED, 0, dstIp);
             client.stop();
+            tft.setCursor(10, tft.getCursorY());
             tft.println("  Bad request");
             Serial.println("[SOCKS4] Bad request from " + clientIp);
             continue;
@@ -132,7 +135,8 @@ void socks4Proxy(uint16_t port) {
         if (cd != SOCKS4_CMD_CONNECT) {
             sendSocks4Reply(client, SOCKS4_REP_REJECTED, 0, dstIp);
             client.stop();
-            tft.println("  Unsupported command");
+            tft.setCursor(10, tft.getCursorY());
+            tft.println("  Unsupported cmd");
             continue;
         }
 
@@ -140,7 +144,8 @@ void socks4Proxy(uint16_t port) {
             hostname[0] != '\0'
                 ? (String(hostname) + ":" + String(dstPort))
                 : (IPAddress(dstIp[0], dstIp[1], dstIp[2], dstIp[3]).toString() + ":" + String(dstPort));
-        tft.println("  -> " + destStr + " ...");
+        tft.setCursor(10, tft.getCursorY());
+        tft.println("  -> " + destStr);
         Serial.println("[SOCKS4] Connecting to " + destStr);
 
         WiFiClient target;
@@ -155,11 +160,13 @@ void socks4Proxy(uint16_t port) {
         if (!ok) {
             sendSocks4Reply(client, SOCKS4_REP_REJECTED, 0, dstIp);
             client.stop();
+            tft.setCursor(10, tft.getCursorY());
             tft.println("  FAILED");
             Serial.println("[SOCKS4] Connect failed: " + destStr);
             continue;
         }
 
+        tft.setCursor(10, tft.getCursorY());
         tft.println("  OK - relaying");
         Serial.println("[SOCKS4] Tunnel up: " + clientIp + " <-> " + destStr);
 
@@ -169,6 +176,7 @@ void socks4Proxy(uint16_t port) {
 
         target.stop();
         client.stop();
+        tft.setCursor(10, tft.getCursorY());
         tft.println("  Closed");
         Serial.println("[SOCKS4] Tunnel closed: " + clientIp + " -> " + destStr);
     }
diff --git a/src/modules/wifi/tcp_utils.cpp b/src/modules/wifi/tcp_utils.cpp
index 5bd51e7ae..f2e30a7a5 100644
--- a/src/modules/wifi/tcp_utils.cpp
+++ b/src/modules/wifi/tcp_utils.cpp
@@ -3,17 +3,13 @@
 #ifndef LITE_VERSION
 #include "modules/wifi/tcp_utils.h"
 #include "core/wifi/wifi_common.h"
+#include "core/display.h"
 
 bool inputMode;
 
 void listenTcpPort() {
     if (!wifiConnected) wifiConnectMenu();
 
-    WiFiClient tcpClient;
-    tft.fillScreen(TFT_BLACK);
-    tft.setTextSize(1);
-    tft.setTextColor(TFT_WHITE, TFT_BLACK);
-
     String portNumber = num_keyboard("", 5, "TCP port to listen");
     if (portNumber.length() == 0) {
         displayError("No port number given, exiting");
@@ -25,18 +21,26 @@ void listenTcpPort() {
         return;
     }
 
+    WiFiClient tcpClient;
+    drawMainBorderWithTitle("LISTEN TCP");
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+
     WiFiServer server(portNumberInt);
     server.begin();
 
-    tft.println("Listening...");
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    tft.println("Listening on:");
+    tft.setCursor(10, tft.getCursorY());
     tft.print(WiFi.localIP().toString().c_str());
     tft.println(":" + portNumber);
 
     for (;;) {
-        WiFiClient client = server.accept(); // Wait for a client to connect
+        WiFiClient client = server.accept();
 
         if (client) {
             Serial.println("Client connected");
+            tft.setCursor(10, tft.getCursorY());
             tft.println("Client connected");
 
             while (client.connected()) {
@@ -49,15 +53,17 @@ void listenTcpPort() {
                         return;
                     }
                     inputMode = false;
-                    tft.fillScreen(TFT_BLACK);
-                    tft.setCursor(0, 0);
+                    drawMainBorderWithTitle("LISTEN TCP");
+                    tft.setTextSize(FP);
+                    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
                     if (keyString.length() > 0) {
-                        client.print(keyString); // Send the entire string to the client
+                        client.print(keyString);
                         Serial.print(keyString);
                     }
                 } else {
                     if (client.available()) {
-                        char incomingChar = client.read(); // Read one byte at time from the client
+                        char incomingChar = client.read();
                         tft.print(incomingChar);
                         Serial.print(incomingChar);
                     }
@@ -89,24 +95,32 @@ void clientTCP() {
     }
 
     WiFiClient client;
+    drawMainBorderWithTitle("TCP CLIENT");
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    tft.println("Connecting to:");
+    tft.setCursor(10, tft.getCursorY());
+    tft.println(serverIP + ":" + portString);
+
     if (!client.connect(serverIP.c_str(), portNumber)) {
         displayError("Connection failed");
         return;
     }
 
-    tft.fillScreen(TFT_BLACK);
-    tft.setTextSize(1);
-    tft.setTextColor(TFT_WHITE, TFT_BLACK);
-    tft.println("Connected to:");
-    tft.println(serverIP + ":" + portString);
+    tft.setCursor(10, tft.getCursorY());
+    tft.println("Connected!");
     Serial.println("Connected to server");
 
     while (client.connected()) {
         if (inputMode) {
             String keyString = keyboard("", 16, "send input data");
             inputMode = false;
-            tft.fillScreen(TFT_BLACK);
-            tft.setCursor(0, 0);
+            drawMainBorderWithTitle("TCP CLIENT");
+            tft.setTextSize(FP);
+            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
             if (keyString.length() > 0) {
                 client.print(keyString);
                 Serial.print(keyString);