From 3371d3372c87c91aa9b81cae2afa3f2864c4160d Mon Sep 17 00:00:00 2001
From: zeropt <ferr0fluidmann@gmail.com>
Date: Sat, 20 Dec 2025 12:15:42 -0800
Subject: [PATCH 01/10] Adding support for InkHUD joystick navigation for the
 Seeed Wio Tracker L1 E-ink (#8678)

* TwoButtonExtened mirrors TwoButton but added joystick functionality

* basic ui navigation with a joystick

settings->joystick.enabled setting added and SETTINGS_VERSION
incremented by one in InkHUD/Persistence.h

in seeed_wio_tracker_L1_eink/nicheGraphics.h enable joystick and
disable "Next Tile" menu item in

implement prevTile and prevApplet functions in
InkHUD/WindowManager.h,cpp and InkHUD/InkHUD.h,cpp

onStickCenterShort, onStickCenterLong, onStickUp, onStickDown,
onStickLeft, and onStickRight functions added to:
- InkHUD/InkHUD.h,cpp
- InkHUD/Events.h,cpp
- InkHUD/Applet.h

change navigation actions in InkHUD/Events.cpp events based on
whether the joystick is enabled or not

in seeed_wio_tracker_L1_eink/nicheGraphics.h connect joystick events to
the new joystick handler functions

* handle joystick input in NotificationApplet and TipsApplet

Both the joystick center short press and the user button short press can
be used to advance through the Tips applet.

dismiss notifications with any joystick input

* MenuApplet controls
allows menu navigation including a back button

* add AlignStickApplet for aligning the joystick with the screen

add joystick.aligned and joystick.alignment to InkHUD/Persistence.h for
storing alignment status and relative angle

create AlignStick applet that prompts the user for a joystick input and
rotates the controls to align with the screen

AlignStick applet is run after the tips applet if the joystick is
enabled and not aligned

add menu item for opening the AlignStick applet

* update tips applet with joystick controls

* format InkHUD additions

* fix stroke consistency when resizing joystick graphic

* tweak button tips for order consistency

* increase joystick debounce

* fix comments

* remove unnecessary '+'

* remap joystick controls to match standard inkHUD behavior

Input with a joystick now behaves as follows

User Button (joystick center):
- short press in applet -> opens menu
- long press in applet -> opens menu
- short press in menu -> selects
- long press in menu -> selects

Exit Button:
- short press in applet -> switches tile
- long press in applet -> nothing for now
- short press in menu -> closes menu
- long press in menu -> nothing for now

---------

Co-authored-by: scobert <scobert57@gmail.com>
Co-authored-by: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>
---
 src/graphics/niche/InkHUD/Applet.h            |  10 +-
 .../System/AlignStick/AlignStickApplet.cpp    | 205 +++++++
 .../System/AlignStick/AlignStickApplet.h      |  50 ++
 .../InkHUD/Applets/System/Menu/MenuAction.h   |   1 +
 .../InkHUD/Applets/System/Menu/MenuApplet.cpp |  92 ++-
 .../InkHUD/Applets/System/Menu/MenuApplet.h   |   8 +-
 .../Notification/NotificationApplet.cpp       |  36 ++
 .../System/Notification/NotificationApplet.h  |   6 +
 .../InkHUD/Applets/System/Tips/TipsApplet.cpp |  36 +-
 .../InkHUD/Applets/System/Tips/TipsApplet.h   |   1 +
 src/graphics/niche/InkHUD/Events.cpp          | 161 +++++-
 src/graphics/niche/InkHUD/Events.h            |   6 +
 src/graphics/niche/InkHUD/InkHUD.cpp          | 116 ++++
 src/graphics/niche/InkHUD/InkHUD.h            |  10 +
 src/graphics/niche/InkHUD/Persistence.h       |  15 +-
 src/graphics/niche/InkHUD/WindowManager.cpp   |  99 ++++
 src/graphics/niche/InkHUD/WindowManager.h     |   3 +
 .../niche/Inputs/TwoButtonExtended.cpp        | 523 ++++++++++++++++++
 src/graphics/niche/Inputs/TwoButtonExtended.h | 136 +++++
 .../seeed_wio_tracker_L1_eink/nicheGraphics.h |  37 +-
 20 files changed, 1523 insertions(+), 28 deletions(-)
 create mode 100644 src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.cpp
 create mode 100644 src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.h
 create mode 100644 src/graphics/niche/Inputs/TwoButtonExtended.cpp
 create mode 100644 src/graphics/niche/Inputs/TwoButtonExtended.h

diff --git a/src/graphics/niche/InkHUD/Applet.h b/src/graphics/niche/InkHUD/Applet.h
index 802186e6e..b35ca5cc0 100644
--- a/src/graphics/niche/InkHUD/Applet.h
+++ b/src/graphics/niche/InkHUD/Applet.h
@@ -88,8 +88,14 @@ class Applet : public GFX
     virtual void onForeground() {}
     virtual void onBackground() {}
     virtual void onShutdown() {}
-    virtual void onButtonShortPress() {} // (System Applets only)
-    virtual void onButtonLongPress() {}  // (System Applets only)
+    virtual void onButtonShortPress() {}
+    virtual void onButtonLongPress() {}
+    virtual void onExitShort() {}
+    virtual void onExitLong() {}
+    virtual void onNavUp() {}
+    virtual void onNavDown() {}
+    virtual void onNavLeft() {}
+    virtual void onNavRight() {}
 
     virtual bool approveNotification(Notification &n); // Allow an applet to veto a notification
 
diff --git a/src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.cpp b/src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.cpp
new file mode 100644
index 000000000..67ef87f41
--- /dev/null
+++ b/src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.cpp
@@ -0,0 +1,205 @@
+#ifdef MESHTASTIC_INCLUDE_INKHUD
+
+#include "./AlignStickApplet.h"
+
+using namespace NicheGraphics;
+
+InkHUD::AlignStickApplet::AlignStickApplet()
+{
+    if (!settings->joystick.aligned)
+        bringToForeground();
+}
+
+void InkHUD::AlignStickApplet::onRender()
+{
+    setFont(fontMedium);
+    printAt(0, 0, "Align Joystick:");
+    setFont(fontSmall);
+    std::string instructions = "Move joystick in the direction indicated";
+    printWrapped(0, fontMedium.lineHeight() * 1.5, width(), instructions);
+
+    // Size of the region in which the joystick graphic should fit
+    uint16_t joyXLimit = X(0.8);
+    uint16_t contentH = fontMedium.lineHeight() * 1.5 + fontSmall.lineHeight() * 1;
+    if (getTextWidth(instructions) > width())
+        contentH += fontSmall.lineHeight();
+    uint16_t freeY = height() - contentH - fontSmall.lineHeight() * 1.2;
+    uint16_t joyYLimit = freeY * 0.8;
+
+    // Use the shorter of the two
+    uint16_t joyWidth = joyXLimit < joyYLimit ? joyXLimit : joyYLimit;
+
+    // Center the joystick graphic
+    uint16_t centerX = X(0.5);
+    uint16_t centerY = contentH + freeY * 0.5;
+
+    // Draw joystick graphic
+    drawStick(centerX, centerY, joyWidth);
+
+    setFont(fontSmall);
+    printAt(X(0.5), Y(1.0) - fontSmall.lineHeight() * 0.2, "Long press to skip", CENTER, BOTTOM);
+}
+
+// Draw a scalable joystick graphic
+void InkHUD::AlignStickApplet::drawStick(uint16_t centerX, uint16_t centerY, uint16_t width)
+{
+    if (width < 9) // too small to draw
+        return;
+
+    else if (width < 40) { // only draw up arrow
+        uint16_t chamfer = width < 20 ? 1 : 2;
+
+        // Draw filled up arrow
+        drawDirection(centerX, centerY - width / 4, Direction::UP, width, chamfer, BLACK);
+
+    } else { // large enough to draw the full thing
+        uint16_t chamfer = width < 80 ? 1 : 2;
+        uint16_t stroke = 3; // pixels
+        uint16_t arrowW = width * 0.22;
+        uint16_t hollowW = arrowW - stroke * 2;
+
+        // Draw center circle
+        fillCircle((int16_t)centerX, (int16_t)centerY, (int16_t)(width * 0.2), BLACK);
+        fillCircle((int16_t)centerX, (int16_t)centerY, (int16_t)(width * 0.2) - stroke, WHITE);
+
+        // Draw filled up arrow
+        drawDirection(centerX, centerY - width / 2, Direction::UP, arrowW, chamfer, BLACK);
+
+        // Draw down arrow
+        drawDirection(centerX, centerY + width / 2, Direction::DOWN, arrowW, chamfer, BLACK);
+        drawDirection(centerX, centerY + width / 2 - stroke, Direction::DOWN, hollowW, 0, WHITE);
+
+        // Draw left arrow
+        drawDirection(centerX - width / 2, centerY, Direction::LEFT, arrowW, chamfer, BLACK);
+        drawDirection(centerX - width / 2 + stroke, centerY, Direction::LEFT, hollowW, 0, WHITE);
+
+        // Draw right arrow
+        drawDirection(centerX + width / 2, centerY, Direction::RIGHT, arrowW, chamfer, BLACK);
+        drawDirection(centerX + width / 2 - stroke, centerY, Direction::RIGHT, hollowW, 0, WHITE);
+    }
+}
+
+// Draw a scalable joystick direction arrow
+// a right-triangle with blunted tips
+/*
+            _ <--point
+    ^      / \
+    |     /   \
+   size  /     \
+    |   /       \
+    v  |_________|
+
+*/
+void InkHUD::AlignStickApplet::drawDirection(uint16_t pointX, uint16_t pointY, Direction direction, uint16_t size,
+                                             uint16_t chamfer, Color color)
+{
+    uint16_t chamferW = chamfer * 2 + 1;
+    uint16_t triangleW = size - chamferW;
+
+    // Draw arrow
+    switch (direction) {
+    case Direction::UP:
+        fillRect(pointX - chamfer, pointY, chamferW, triangleW, color);
+        fillRect(pointX - chamfer - triangleW, pointY + triangleW, chamferW + triangleW * 2, chamferW, color);
+        fillTriangle(pointX - chamfer, pointY, pointX - chamfer - triangleW, pointY + triangleW, pointX - chamfer,
+                     pointY + triangleW, color);
+        fillTriangle(pointX + chamfer, pointY, pointX + chamfer + triangleW, pointY + triangleW, pointX + chamfer,
+                     pointY + triangleW, color);
+        break;
+    case Direction::DOWN:
+        fillRect(pointX - chamfer, pointY - triangleW + 1, chamferW, triangleW, color);
+        fillRect(pointX - chamfer - triangleW, pointY - size + 1, chamferW + triangleW * 2, chamferW, color);
+        fillTriangle(pointX - chamfer, pointY, pointX - chamfer - triangleW, pointY - triangleW, pointX - chamfer,
+                     pointY - triangleW, color);
+        fillTriangle(pointX + chamfer, pointY, pointX + chamfer + triangleW, pointY - triangleW, pointX + chamfer,
+                     pointY - triangleW, color);
+        break;
+    case Direction::LEFT:
+        fillRect(pointX, pointY - chamfer, triangleW, chamferW, color);
+        fillRect(pointX + triangleW, pointY - chamfer - triangleW, chamferW, chamferW + triangleW * 2, color);
+        fillTriangle(pointX, pointY - chamfer, pointX + triangleW, pointY - chamfer - triangleW, pointX + triangleW,
+                     pointY - chamfer, color);
+        fillTriangle(pointX, pointY + chamfer, pointX + triangleW, pointY + chamfer + triangleW, pointX + triangleW,
+                     pointY + chamfer, color);
+        break;
+    case Direction::RIGHT:
+        fillRect(pointX - triangleW + 1, pointY - chamfer, triangleW, chamferW, color);
+        fillRect(pointX - size + 1, pointY - chamfer - triangleW, chamferW, chamferW + triangleW * 2, color);
+        fillTriangle(pointX, pointY - chamfer, pointX - triangleW, pointY - chamfer - triangleW, pointX - triangleW,
+                     pointY - chamfer, color);
+        fillTriangle(pointX, pointY + chamfer, pointX - triangleW, pointY + chamfer + triangleW, pointX - triangleW,
+                     pointY + chamfer, color);
+        break;
+    }
+}
+
+void InkHUD::AlignStickApplet::onForeground()
+{
+    // Prevent most other applets from requesting update, and skip their rendering entirely
+    // Another system applet with a higher precedence can potentially ignore this
+    SystemApplet::lockRendering = true;
+    SystemApplet::lockRequests = true;
+
+    handleInput = true; // Intercept the button input for our applet
+}
+
+void InkHUD::AlignStickApplet::onBackground()
+{
+    // Allow normal update behavior to resume
+    SystemApplet::lockRendering = false;
+    SystemApplet::lockRequests = false;
+    SystemApplet::handleInput = false;
+
+    // Need to force an update, as a polite request wouldn't be honored, seeing how we are now in the background
+    // Usually, onBackground is followed by another applet's onForeground (which requests update), but not in this case
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onButtonLongPress()
+{
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onExitLong()
+{
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavUp()
+{
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavDown()
+{
+    inkhud->rotateJoystick(2); // 180 deg
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavLeft()
+{
+    inkhud->rotateJoystick(3); // 270 deg
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::AlignStickApplet::onNavRight()
+{
+    inkhud->rotateJoystick(1); // 90 deg
+    settings->joystick.aligned = true;
+
+    sendToBackground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+#endif
\ No newline at end of file
diff --git a/src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.h b/src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.h
new file mode 100644
index 000000000..8dba33165
--- /dev/null
+++ b/src/graphics/niche/InkHUD/Applets/System/AlignStick/AlignStickApplet.h
@@ -0,0 +1,50 @@
+#ifdef MESHTASTIC_INCLUDE_INKHUD
+
+/*
+
+System Applet for manually aligning the joystick with the screen
+
+should be run at startup if the joystick is enabled
+and not aligned to the screen
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#include "graphics/niche/InkHUD/SystemApplet.h"
+
+namespace NicheGraphics::InkHUD
+{
+
+class AlignStickApplet : public SystemApplet
+{
+  public:
+    AlignStickApplet();
+
+    void onRender() override;
+    void onForeground() override;
+    void onBackground() override;
+    void onButtonLongPress() override;
+    void onExitLong() override;
+    void onNavUp() override;
+    void onNavDown() override;
+    void onNavLeft() override;
+    void onNavRight() override;
+
+  protected:
+    enum Direction {
+        UP,
+        DOWN,
+        LEFT,
+        RIGHT,
+    };
+
+    void drawStick(uint16_t centerX, uint16_t centerY, uint16_t width);
+    void drawDirection(uint16_t pointX, uint16_t pointY, Direction direction, uint16_t size, uint16_t chamfer, Color color);
+};
+
+} // namespace NicheGraphics::InkHUD
+
+#endif
\ No newline at end of file
diff --git a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h
index c84ee09e0..debe2b719 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuAction.h
@@ -30,6 +30,7 @@ enum MenuAction {
     TOGGLE_AUTOSHOW_APPLET,
     SET_RECENTS,
     ROTATE,
+    ALIGN_JOYSTICK,
     LAYOUT,
     TOGGLE_BATTERY_ICON,
     TOGGLE_NOTIFICATIONS,
diff --git a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp
index 09f76ed46..7e7093857 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp
@@ -178,6 +178,10 @@ void InkHUD::MenuApplet::execute(MenuItem item)
         inkhud->rotate();
         break;
 
+    case ALIGN_JOYSTICK:
+        inkhud->openAlignStick();
+        break;
+
     case LAYOUT:
         // Todo: smarter incrementing of tile count
         settings->userTiles.count++;
@@ -287,14 +291,17 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         // items.push_back(MenuItem("Display Off", MenuPage::EXIT)); // TODO
         items.push_back(MenuItem("Save & Shut Down", MenuAction::SHUTDOWN));
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::EXIT;
         break;
 
     case SEND:
         populateSendPage();
+        previousPage = MenuPage::ROOT;
         break;
 
     case CANNEDMESSAGE_RECIPIENT:
         populateRecipientPage();
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case OPTIONS:
@@ -321,6 +328,8 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         if (settings->userTiles.maxCount > 1)
             items.push_back(MenuItem("Layout", MenuAction::LAYOUT, MenuPage::OPTIONS));
         items.push_back(MenuItem("Rotate", MenuAction::ROTATE, MenuPage::OPTIONS));
+        if (settings->joystick.enabled)
+            items.push_back(MenuItem("Align Joystick", MenuAction::ALIGN_JOYSTICK, MenuPage::EXIT));
         items.push_back(MenuItem("Notifications", MenuAction::TOGGLE_NOTIFICATIONS, MenuPage::OPTIONS,
                                  &settings->optionalFeatures.notifications));
         items.push_back(MenuItem("Battery Icon", MenuAction::TOGGLE_BATTERY_ICON, MenuPage::OPTIONS,
@@ -332,20 +341,24 @@ void InkHUD::MenuApplet::showPage(MenuPage page)
         items.push_back(
             MenuItem("12-Hour Clock", MenuAction::TOGGLE_12H_CLOCK, MenuPage::OPTIONS, &config.display.use_12h_clock));
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::ROOT;
         break;
 
     case APPLETS:
         populateAppletPage();
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case AUTOSHOW:
         populateAutoshowPage();
         items.push_back(MenuItem("Exit", MenuPage::EXIT));
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case RECENTS:
         populateRecentsPage();
+        previousPage = MenuPage::OPTIONS;
         break;
 
     case EXIT:
@@ -479,12 +492,21 @@ void InkHUD::MenuApplet::onButtonShortPress()
     // Push the auto-close timer back
     OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
 
-    // Move menu cursor to next entry, then update
-    if (cursorShown)
-        cursor = (cursor + 1) % items.size();
-    else
-        cursorShown = true;
-    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    if (!settings->joystick.enabled) {
+        // Move menu cursor to next entry, then update
+        if (cursorShown)
+            cursor = (cursor + 1) % items.size();
+        else
+            cursorShown = true;
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    } else {
+        if (cursorShown)
+            execute(items.at(cursor));
+        else
+            showPage(MenuPage::EXIT);
+        if (!wantsToRender())
+            requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+    }
 }
 
 void InkHUD::MenuApplet::onButtonLongPress()
@@ -504,6 +526,62 @@ void InkHUD::MenuApplet::onButtonLongPress()
         requestUpdate(Drivers::EInk::UpdateTypes::FAST);
 }
 
+void InkHUD::MenuApplet::onExitShort()
+{
+    // Exit the menu
+    showPage(MenuPage::EXIT);
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavUp()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    // Move menu cursor to previous entry, then update
+    if (cursor == 0)
+        cursor = items.size() - 1;
+    else
+        cursor--;
+
+    if (!cursorShown)
+        cursorShown = true;
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavDown()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    // Move menu cursor to next entry, then update
+    if (cursorShown)
+        cursor = (cursor + 1) % items.size();
+    else
+        cursorShown = true;
+
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavLeft()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    // Go to the previous menu page
+    showPage(previousPage);
+    requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
+void InkHUD::MenuApplet::onNavRight()
+{
+    OSThread::setIntervalFromNow(MENU_TIMEOUT_SEC * 1000UL);
+
+    if (cursorShown)
+        execute(items.at(cursor));
+    if (!wantsToRender())
+        requestUpdate(Drivers::EInk::UpdateTypes::FAST);
+}
+
 // Dynamically create MenuItem entries for activating / deactivating Applets, for the "Applet Selection" submenu
 void InkHUD::MenuApplet::populateAppletPage()
 {
@@ -796,4 +874,4 @@ void InkHUD::MenuApplet::freeCannedMessageResources()
     cm.recipientItems.clear();
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h
index 8f9280e6f..4f9f92227 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.h
@@ -27,6 +27,11 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
     void onBackground() override;
     void onButtonShortPress() override;
     void onButtonLongPress() override;
+    void onExitShort() override;
+    void onNavUp() override;
+    void onNavDown() override;
+    void onNavLeft() override;
+    void onNavRight() override;
     void onRender() override;
 
     void show(Tile *t); // Open the menu, onto a user tile
@@ -52,6 +57,7 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
     void freeCannedMessageResources();                                      // Clear MenuApplet's canned message processing data
 
     MenuPage currentPage = MenuPage::ROOT;
+    MenuPage previousPage = MenuPage::EXIT;
     uint8_t cursor = 0;       // Which menu item is currently highlighted
     bool cursorShown = false; // Is *any* item highlighted? (Root menu: no initial selection)
 
@@ -97,4 +103,4 @@ class MenuApplet : public SystemApplet, public concurrency::OSThread
 
 } // namespace NicheGraphics::InkHUD
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp b/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp
index ae0836d19..2ea9c7fe0 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.cpp
@@ -153,6 +153,42 @@ void InkHUD::NotificationApplet::onButtonLongPress()
     inkhud->forceUpdate(EInk::UpdateTypes::FULL);
 }
 
+void InkHUD::NotificationApplet::onExitShort()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onExitLong()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavUp()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavDown()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavLeft()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
+void InkHUD::NotificationApplet::onNavRight()
+{
+    dismiss();
+    inkhud->forceUpdate(EInk::UpdateTypes::FULL);
+}
+
 // Ask the WindowManager to check whether any displayed applets are already displaying the info from this notification
 // Called internally when we first get a "notifiable event", and then again before render,
 // in case autoshow swapped which applet was displayed
diff --git a/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.h b/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.h
index 66df784b4..16ea13407 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Notification/NotificationApplet.h
@@ -31,6 +31,12 @@ class NotificationApplet : public SystemApplet
     void onBackground() override;
     void onButtonShortPress() override;
     void onButtonLongPress() override;
+    void onExitShort() override;
+    void onExitLong() override;
+    void onNavUp() override;
+    void onNavDown() override;
+    void onNavLeft() override;
+    void onNavRight() override;
 
     int onReceiveTextMessage(const meshtastic_MeshPacket *p);
 
diff --git a/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp b/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp
index ade44ab65..a9d579873 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp
+++ b/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.cpp
@@ -112,12 +112,21 @@ void InkHUD::TipsApplet::onRender()
         setFont(fontSmall);
         int16_t cursorY = fontMedium.lineHeight() * 1.5;
 
-        printAt(0, cursorY, "User Button");
-        cursorY += fontSmall.lineHeight() * 1.2;
-        printAt(0, cursorY, "- short press: next");
-        cursorY += fontSmall.lineHeight() * 1.2;
-        printAt(0, cursorY, "- long press: select / open menu");
-        cursorY += fontSmall.lineHeight() * 1.5;
+        if (!settings->joystick.enabled) {
+            printAt(0, cursorY, "User Button");
+            cursorY += fontSmall.lineHeight() * 1.2;
+            printAt(0, cursorY, "- short press: next");
+            cursorY += fontSmall.lineHeight() * 1.2;
+            printAt(0, cursorY, "- long press: select / open menu");
+        } else {
+            printAt(0, cursorY, "Joystick");
+            cursorY += fontSmall.lineHeight() * 1.2;
+            printAt(0, cursorY, "- open menu / select");
+            cursorY += fontSmall.lineHeight() * 1.5;
+            printAt(0, cursorY, "Exit Button");
+            cursorY += fontSmall.lineHeight() * 1.2;
+            printAt(0, cursorY, "- switch tile / close menu");
+        }
 
         printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
     } break;
@@ -127,8 +136,13 @@ void InkHUD::TipsApplet::onRender()
         printAt(0, 0, "Tip: Rotation");
 
         setFont(fontSmall);
-        printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
-                     "To rotate the display, use the InkHUD menu. Long-press the user button > Options > Rotate.");
+        if (!settings->joystick.enabled) {
+            printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
+                         "To rotate the display, use the InkHUD menu. Long-press the user button > Options > Rotate.");
+        } else {
+            printWrapped(0, fontMedium.lineHeight() * 1.5, width(),
+                         "To rotate the display, use the InkHUD menu. Press the user button > Options > Rotate.");
+        }
 
         printAt(0, Y(1.0), "Press button to continue", LEFT, BOTTOM);
 
@@ -232,4 +246,10 @@ void InkHUD::TipsApplet::onButtonShortPress()
         requestUpdate();
 }
 
+// Functions the same as the user button in this instance
+void InkHUD::TipsApplet::onExitShort()
+{
+    onButtonShortPress();
+}
+
 #endif
\ No newline at end of file
diff --git a/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h b/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h
index db88585e9..159e6f58f 100644
--- a/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h
+++ b/src/graphics/niche/InkHUD/Applets/System/Tips/TipsApplet.h
@@ -36,6 +36,7 @@ class TipsApplet : public SystemApplet
     void onForeground() override;
     void onBackground() override;
     void onButtonShortPress() override;
+    void onExitShort() override;
 
   protected:
     void renderWelcome(); // Very first screen of tutorial
diff --git a/src/graphics/niche/InkHUD/Events.cpp b/src/graphics/niche/InkHUD/Events.cpp
index cdda1638d..5382d2391 100644
--- a/src/graphics/niche/InkHUD/Events.cpp
+++ b/src/graphics/niche/InkHUD/Events.cpp
@@ -55,10 +55,15 @@ void InkHUD::Events::onButtonShort()
     }
 
     // If no system applet is handling input, default behavior instead is to cycle applets
-    if (consumer)
+    // or open menu if joystick is enabled
+    if (consumer) {
         consumer->onButtonShortPress();
-    else if (!dismissedExt) // Don't change applet if this button press silenced the external notification module
-        inkhud->nextApplet();
+    } else if (!dismissedExt) { // Don't change applet if this button press silenced the external notification module
+        if (!settings->joystick.enabled)
+            inkhud->nextApplet();
+        else
+            inkhud->openMenu();
+    }
 }
 
 void InkHUD::Events::onButtonLong()
@@ -83,6 +88,156 @@ void InkHUD::Events::onButtonLong()
         inkhud->openMenu();
 }
 
+void InkHUD::Events::onExitShort()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        // If no system applet is handling input, default behavior instead is change tiles
+        if (consumer)
+            consumer->onExitShort();
+        else if (!dismissedExt) // Don't change tile if this button press silenced the external notification module
+            inkhud->nextTile();
+    }
+}
+
+void InkHUD::Events::onExitLong()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Slightly longer than playChirp
+        playBoop();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        if (consumer)
+            consumer->onExitLong();
+    }
+}
+
+void InkHUD::Events::onNavUp()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        if (consumer)
+            consumer->onNavUp();
+    }
+}
+
+void InkHUD::Events::onNavDown()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        if (consumer)
+            consumer->onNavDown();
+    }
+}
+
+void InkHUD::Events::onNavLeft()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        // If no system applet is handling input, default behavior instead is to cycle applets
+        if (consumer)
+            consumer->onNavLeft();
+        else if (!dismissedExt) // Don't change applet if this button press silenced the external notification module
+            inkhud->prevApplet();
+    }
+}
+
+void InkHUD::Events::onNavRight()
+{
+    if (settings->joystick.enabled) {
+        // Audio feedback (via buzzer)
+        // Short tone
+        playChirp();
+        // Cancel any beeping, buzzing, blinking
+        // Some button handling suppressed if we are dismissing an external notification (see below)
+        bool dismissedExt = dismissExternalNotification();
+
+        // Check which system applet wants to handle the button press (if any)
+        SystemApplet *consumer = nullptr;
+        for (SystemApplet *sa : inkhud->systemApplets) {
+            if (sa->handleInput) {
+                consumer = sa;
+                break;
+            }
+        }
+
+        // If no system applet is handling input, default behavior instead is to cycle applets
+        if (consumer)
+            consumer->onNavRight();
+        else if (!dismissedExt) // Don't change applet if this button press silenced the external notification module
+            inkhud->nextApplet();
+    }
+}
+
 // Callback for deepSleepObserver
 // Returns 0 to signal that we agree to sleep now
 int InkHUD::Events::beforeDeepSleep(void *unused)
diff --git a/src/graphics/niche/InkHUD/Events.h b/src/graphics/niche/InkHUD/Events.h
index df68f368c..664ca19f0 100644
--- a/src/graphics/niche/InkHUD/Events.h
+++ b/src/graphics/niche/InkHUD/Events.h
@@ -29,6 +29,12 @@ class Events
 
     void onButtonShort(); // User button: short press
     void onButtonLong();  // User button: long press
+    void onExitShort();   // Exit button: short press
+    void onExitLong();    // Exit button: long press
+    void onNavUp();       // Navigate up
+    void onNavDown();     // Navigate down
+    void onNavLeft();     // Navigate left
+    void onNavRight();    // Navigate right
 
     int beforeDeepSleep(void *unused);                             // Prepare for shutdown
     int beforeReboot(void *unused);                                // Prepare for reboot
diff --git a/src/graphics/niche/InkHUD/InkHUD.cpp b/src/graphics/niche/InkHUD/InkHUD.cpp
index 90b6718e0..9f05ae5bb 100644
--- a/src/graphics/niche/InkHUD/InkHUD.cpp
+++ b/src/graphics/niche/InkHUD/InkHUD.cpp
@@ -80,6 +80,94 @@ void InkHUD::InkHUD::longpress()
     events->onButtonLong();
 }
 
+// Call this when your exit button gets a short press
+void InkHUD::InkHUD::exitShort()
+{
+    events->onExitShort();
+}
+
+// Call this when your exit button gets a long press
+void InkHUD::InkHUD::exitLong()
+{
+    events->onExitLong();
+}
+
+// Call this when your joystick gets an up input
+void InkHUD::InkHUD::navUp()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavLeft();
+        break;
+    case 2: // 180 deg
+        events->onNavDown();
+        break;
+    case 3: // 270 deg
+        events->onNavRight();
+        break;
+    default: // 0 deg
+        events->onNavUp();
+        break;
+    }
+}
+
+// Call this when your joystick gets a down input
+void InkHUD::InkHUD::navDown()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavRight();
+        break;
+    case 2: // 180 deg
+        events->onNavUp();
+        break;
+    case 3: // 270 deg
+        events->onNavLeft();
+        break;
+    default: // 0 deg
+        events->onNavDown();
+        break;
+    }
+}
+
+// Call this when your joystick gets a left input
+void InkHUD::InkHUD::navLeft()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavDown();
+        break;
+    case 2: // 180 deg
+        events->onNavRight();
+        break;
+    case 3: // 270 deg
+        events->onNavUp();
+        break;
+    default: // 0 deg
+        events->onNavLeft();
+        break;
+    }
+}
+
+// Call this when your joystick gets a right input
+void InkHUD::InkHUD::navRight()
+{
+    switch ((persistence->settings.rotation + persistence->settings.joystick.alignment) % 4) {
+    case 1: // 90 deg
+        events->onNavUp();
+        break;
+    case 2: // 180 deg
+        events->onNavLeft();
+        break;
+    case 3: // 270 deg
+        events->onNavDown();
+        break;
+    default: // 0 deg
+        events->onNavRight();
+        break;
+    }
+}
+
 // Cycle the next user applet to the foreground
 // Only activated applets are cycled
 // If user has a multi-applet layout, the applets will cycle on the "focused tile"
@@ -88,6 +176,14 @@ void InkHUD::InkHUD::nextApplet()
     windowManager->nextApplet();
 }
 
+// Cycle the previous user applet to the foreground
+// Only activated applets are cycled
+// If user has a multi-applet layout, the applets will cycle on the "focused tile"
+void InkHUD::InkHUD::prevApplet()
+{
+    windowManager->prevApplet();
+}
+
 // Show the menu (on the the focused tile)
 // The applet previously displayed there will be restored once the menu closes
 void InkHUD::InkHUD::openMenu()
@@ -95,6 +191,12 @@ void InkHUD::InkHUD::openMenu()
     windowManager->openMenu();
 }
 
+// Bring AlignStick applet to the foreground
+void InkHUD::InkHUD::openAlignStick()
+{
+    windowManager->openAlignStick();
+}
+
 // In layouts where multiple applets are shown at once, change which tile is focused
 // The focused tile in the one which cycles applets on button short press, and displays menu on long press
 void InkHUD::InkHUD::nextTile()
@@ -102,12 +204,26 @@ void InkHUD::InkHUD::nextTile()
     windowManager->nextTile();
 }
 
+// In layouts where multiple applets are shown at once, change which tile is focused
+// The focused tile in the one which cycles applets on button short press, and displays menu on long press
+void InkHUD::InkHUD::prevTile()
+{
+    windowManager->prevTile();
+}
+
 // Rotate the display image by 90 degrees
 void InkHUD::InkHUD::rotate()
 {
     windowManager->rotate();
 }
 
+// rotate the joystick in 90 degree increments
+void InkHUD::InkHUD::rotateJoystick(uint8_t angle)
+{
+    persistence->settings.joystick.alignment += angle;
+    persistence->settings.joystick.alignment %= 4;
+}
+
 // Show / hide the battery indicator in top-right
 void InkHUD::InkHUD::toggleBatteryIcon()
 {
diff --git a/src/graphics/niche/InkHUD/InkHUD.h b/src/graphics/niche/InkHUD/InkHUD.h
index 13839ea22..7325d8262 100644
--- a/src/graphics/niche/InkHUD/InkHUD.h
+++ b/src/graphics/niche/InkHUD/InkHUD.h
@@ -55,15 +55,25 @@ class InkHUD
 
     void shortpress();
     void longpress();
+    void exitShort();
+    void exitLong();
+    void navUp();
+    void navDown();
+    void navLeft();
+    void navRight();
 
     // Trigger UI changes
     // - called by various InkHUD components
     // - suitable(?) for use by aux button, connected in variant nicheGraphics.h
 
     void nextApplet();
+    void prevApplet();
     void openMenu();
+    void openAlignStick();
     void nextTile();
+    void prevTile();
     void rotate();
+    void rotateJoystick(uint8_t angle = 1); // rotate 90 deg by default
     void toggleBatteryIcon();
 
     // Updating the display
diff --git a/src/graphics/niche/InkHUD/Persistence.h b/src/graphics/niche/InkHUD/Persistence.h
index b85274c87..5054b7234 100644
--- a/src/graphics/niche/InkHUD/Persistence.h
+++ b/src/graphics/niche/InkHUD/Persistence.h
@@ -29,7 +29,7 @@ class Persistence
 
     // Used to invalidate old settings, if needed
     // Version 0 is reserved for testing, and will always load defaults
-    static constexpr uint32_t SETTINGS_VERSION = 2;
+    static constexpr uint32_t SETTINGS_VERSION = 3;
 
     struct Settings {
         struct Meta {
@@ -96,6 +96,19 @@ class Persistence
             bool safeShutdownSeen = false;
         } tips;
 
+        // Joystick settings for enabling and aligning to the screen
+        struct Joystick {
+            // Modifies the UI for joystick use
+            bool enabled = false;
+
+            // gets set to true when AlignStick applet is completed
+            bool aligned = false;
+
+            // Rotation of the joystick
+            // Multiples of 90 degrees clockwise
+            uint8_t alignment = 0;
+        } joystick;
+
         // Rotation of the display
         // Multiples of 90 degrees clockwise
         // Most commonly: rotation is 0 when flex connector is oriented below display
diff --git a/src/graphics/niche/InkHUD/WindowManager.cpp b/src/graphics/niche/InkHUD/WindowManager.cpp
index c883e9a29..0548de1eb 100644
--- a/src/graphics/niche/InkHUD/WindowManager.cpp
+++ b/src/graphics/niche/InkHUD/WindowManager.cpp
@@ -2,6 +2,7 @@
 
 #include "./WindowManager.h"
 
+#include "./Applets/System/AlignStick/AlignStickApplet.h"
 #include "./Applets/System/BatteryIcon/BatteryIconApplet.h"
 #include "./Applets/System/Logo/LogoApplet.h"
 #include "./Applets/System/Menu/MenuApplet.h"
@@ -98,6 +99,38 @@ void InkHUD::WindowManager::nextTile()
         userTiles.at(settings->userTiles.focused)->requestHighlight();
 }
 
+// Focus on a different tile but decrement index
+void InkHUD::WindowManager::prevTile()
+{
+    // Close the menu applet if open
+    // We don't *really* want to do this, but it simplifies handling *a lot*
+    MenuApplet *menu = (MenuApplet *)inkhud->getSystemApplet("Menu");
+    bool menuWasOpen = false;
+    if (menu->isForeground()) {
+        menu->sendToBackground();
+        menuWasOpen = true;
+    }
+
+    // Swap to next tile
+    if (settings->userTiles.focused == 0)
+        settings->userTiles.focused = settings->userTiles.count - 1;
+    else
+        settings->userTiles.focused--;
+
+    // Make sure that we don't get stuck on the placeholder tile
+    refocusTile();
+
+    if (menuWasOpen)
+        menu->show(userTiles.at(settings->userTiles.focused));
+
+    // Ask the tile to draw an indicator showing which tile is now focused
+    // Requests a render
+    // We only draw this indicator if the device uses an aux button to switch tiles.
+    // Assume aux button is used to switch tiles if the "next tile" menu item is hidden
+    if (!settings->optionalMenuItems.nextTile)
+        userTiles.at(settings->userTiles.focused)->requestHighlight();
+}
+
 // Show the menu (on the the focused tile)
 // The applet previously displayed there will be restored once the menu closes
 void InkHUD::WindowManager::openMenu()
@@ -106,6 +139,15 @@ void InkHUD::WindowManager::openMenu()
     menu->show(userTiles.at(settings->userTiles.focused));
 }
 
+// Bring the AlignStick applet to the foreground
+void InkHUD::WindowManager::openAlignStick()
+{
+    if (settings->joystick.enabled) {
+        AlignStickApplet *alignStick = (AlignStickApplet *)inkhud->getSystemApplet("AlignStick");
+        alignStick->bringToForeground();
+    }
+}
+
 // On the currently focussed tile: cycle to the next available user applet
 // Applets available for this must be activated, and not already displayed on another tile
 void InkHUD::WindowManager::nextApplet()
@@ -155,6 +197,59 @@ void InkHUD::WindowManager::nextApplet()
     inkhud->forceUpdate(EInk::UpdateTypes::FAST); // bringToForeground already requested, but we're manually forcing FAST
 }
 
+// On the currently focussed tile: cycle to the previous available user applet
+// Applets available for this must be activated, and not already displayed on another tile
+void InkHUD::WindowManager::prevApplet()
+{
+    Tile *t = userTiles.at(settings->userTiles.focused);
+
+    // Abort if zero applets available
+    // nullptr means WindowManager::refocusTile determined that there were no available applets
+    if (!t->getAssignedApplet())
+        return;
+
+    // Find the index of the applet currently shown on the tile
+    uint8_t appletIndex = -1;
+    for (uint8_t i = 0; i < inkhud->userApplets.size(); i++) {
+        if (inkhud->userApplets.at(i) == t->getAssignedApplet()) {
+            appletIndex = i;
+            break;
+        }
+    }
+
+    // Confirm that we did find the applet
+    assert(appletIndex != (uint8_t)-1);
+
+    // Iterate forward through the WindowManager::applets, looking for the previous valid applet
+    Applet *prevValidApplet = nullptr;
+    for (uint8_t i = 1; i < inkhud->userApplets.size(); i++) {
+        uint8_t newAppletIndex = 0;
+        if (i > appletIndex)
+            newAppletIndex = inkhud->userApplets.size() + appletIndex - i;
+        else
+            newAppletIndex = (appletIndex - i);
+        Applet *a = inkhud->userApplets.at(newAppletIndex);
+
+        // Looking for an applet which is active (enabled by user), but currently in background
+        if (a->isActive() && !a->isForeground()) {
+            prevValidApplet = a;
+            settings->userTiles.displayedUserApplet[settings->userTiles.focused] =
+                newAppletIndex; // Remember this setting between boots!
+            break;
+        }
+    }
+
+    // Confirm that we found another applet
+    if (!prevValidApplet)
+        return;
+
+    // Hide old applet, show new applet
+    t->getAssignedApplet()->sendToBackground();
+    t->assignApplet(prevValidApplet);
+    prevValidApplet->bringToForeground();
+    inkhud->forceUpdate(EInk::UpdateTypes::FAST); // bringToForeground already requested, but we're manually forcing FAST
+}
+
 // Rotate the display image by 90 degrees
 void InkHUD::WindowManager::rotate()
 {
@@ -338,6 +433,8 @@ void InkHUD::WindowManager::createSystemApplets()
     addSystemApplet("Logo", new LogoApplet, new Tile);
     addSystemApplet("Pairing", new PairingApplet, new Tile);
     addSystemApplet("Tips", new TipsApplet, new Tile);
+    if (settings->joystick.enabled)
+        addSystemApplet("AlignStick", new AlignStickApplet, new Tile);
 
     addSystemApplet("Menu", new MenuApplet, nullptr);
 
@@ -360,6 +457,8 @@ void InkHUD::WindowManager::placeSystemTiles()
     inkhud->getSystemApplet("Logo")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
     inkhud->getSystemApplet("Pairing")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
     inkhud->getSystemApplet("Tips")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
+    if (settings->joystick.enabled)
+        inkhud->getSystemApplet("AlignStick")->getTile()->setRegion(0, 0, inkhud->width(), inkhud->height());
 
     inkhud->getSystemApplet("Notification")->getTile()->setRegion(0, 0, inkhud->width(), 20);
 
diff --git a/src/graphics/niche/InkHUD/WindowManager.h b/src/graphics/niche/InkHUD/WindowManager.h
index 4d1aedf1b..5def48f8c 100644
--- a/src/graphics/niche/InkHUD/WindowManager.h
+++ b/src/graphics/niche/InkHUD/WindowManager.h
@@ -28,8 +28,11 @@ class WindowManager
     // - call these to make stuff change
 
     void nextTile();
+    void prevTile();
     void openMenu();
+    void openAlignStick();
     void nextApplet();
+    void prevApplet();
     void rotate();
     void toggleBatteryIcon();
 
diff --git a/src/graphics/niche/Inputs/TwoButtonExtended.cpp b/src/graphics/niche/Inputs/TwoButtonExtended.cpp
new file mode 100644
index 000000000..287fb943f
--- /dev/null
+++ b/src/graphics/niche/Inputs/TwoButtonExtended.cpp
@@ -0,0 +1,523 @@
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+#include "./TwoButtonExtended.h"
+
+#include "NodeDB.h" // For the helper function TwoButtonExtended::getUserButtonPin
+#include "PowerFSM.h"
+#include "sleep.h"
+
+using namespace NicheGraphics::Inputs;
+
+TwoButtonExtended::TwoButtonExtended() : concurrency::OSThread("TwoButtonExtended")
+{
+    // Don't start polling buttons for release immediately
+    // Assume they are in a "released" state at boot
+    OSThread::disable();
+
+#ifdef ARCH_ESP32
+    // Register callbacks for before and after lightsleep
+    lsObserver.observe(&notifyLightSleep);
+    lsEndObserver.observe(&notifyLightSleepEnd);
+#endif
+
+    // Explicitly initialize these, just to keep cppcheck quiet..
+    buttons[0] = Button();
+    buttons[1] = Button();
+    joystick[Direction::UP] = SimpleButton();
+    joystick[Direction::DOWN] = SimpleButton();
+    joystick[Direction::LEFT] = SimpleButton();
+    joystick[Direction::RIGHT] = SimpleButton();
+}
+
+// Get access to (or create) the singleton instance of this class
+// Accessible inside the ISRs, even though we maybe shouldn't
+TwoButtonExtended *TwoButtonExtended::getInstance()
+{
+    // Instantiate the class the first time this method is called
+    static TwoButtonExtended *const singletonInstance = new TwoButtonExtended;
+
+    return singletonInstance;
+}
+
+// Begin receiving button input
+// We probably need to do this after sleep, as well as at boot
+void TwoButtonExtended::start()
+{
+    if (buttons[0].pin != 0xFF)
+        attachInterrupt(buttons[0].pin, TwoButtonExtended::isrPrimary, buttons[0].activeLogic == LOW ? FALLING : RISING);
+
+    if (buttons[1].pin != 0xFF)
+        attachInterrupt(buttons[1].pin, TwoButtonExtended::isrSecondary, buttons[1].activeLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::UP].pin != 0xFF)
+        attachInterrupt(joystick[Direction::UP].pin, TwoButtonExtended::isrJoystickUp,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::DOWN].pin != 0xFF)
+        attachInterrupt(joystick[Direction::DOWN].pin, TwoButtonExtended::isrJoystickDown,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::LEFT].pin != 0xFF)
+        attachInterrupt(joystick[Direction::LEFT].pin, TwoButtonExtended::isrJoystickLeft,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+
+    if (joystick[Direction::RIGHT].pin != 0xFF)
+        attachInterrupt(joystick[Direction::RIGHT].pin, TwoButtonExtended::isrJoystickRight,
+                        joystickActiveLogic == LOW ? FALLING : RISING);
+}
+
+// Stop receiving button input, and run custom sleep code
+// Called before device sleeps. This might be power-off, or just ESP32 light sleep
+// Some devices will want to attach interrupts here, for the user button to wake from sleep
+void TwoButtonExtended::stop()
+{
+    if (buttons[0].pin != 0xFF)
+        detachInterrupt(buttons[0].pin);
+
+    if (buttons[1].pin != 0xFF)
+        detachInterrupt(buttons[1].pin);
+
+    if (joystick[Direction::UP].pin != 0xFF)
+        detachInterrupt(joystick[Direction::UP].pin);
+
+    if (joystick[Direction::DOWN].pin != 0xFF)
+        detachInterrupt(joystick[Direction::DOWN].pin);
+
+    if (joystick[Direction::LEFT].pin != 0xFF)
+        detachInterrupt(joystick[Direction::LEFT].pin);
+
+    if (joystick[Direction::RIGHT].pin != 0xFF)
+        detachInterrupt(joystick[Direction::RIGHT].pin);
+}
+
+// Attempt to resolve a GPIO pin for the user button, honoring userPrefs.jsonc and device settings
+// This helper method isn't used by the TwoButtonExtended class itself, it could be moved elsewhere.
+// Intention is to pass this value to TwoButtonExtended::setWiring in the setupNicheGraphics method.
+uint8_t TwoButtonExtended::getUserButtonPin()
+{
+    uint8_t pin = 0xFF; // Unset
+
+    // Use default pin for variant, if no better source
+#ifdef BUTTON_PIN
+    pin = BUTTON_PIN;
+#endif
+
+    // From userPrefs.jsonc, if set
+#ifdef USERPREFS_BUTTON_PIN
+    pin = USERPREFS_BUTTON_PIN;
+#endif
+
+    // From user's override in device settings, if set
+    if (config.device.button_gpio)
+        pin = config.device.button_gpio;
+
+    return pin;
+}
+
+// Configures the wiring and logic of either button
+// Called when outlining your NicheGraphics implementation, in variant/nicheGraphics.cpp
+void TwoButtonExtended::setWiring(uint8_t whichButton, uint8_t pin, bool internalPullup)
+{
+    // Prevent the same GPIO being assigned to multiple buttons
+    // Allows an edge case when the user remaps hardware buttons using device settings, due to a broken user button
+    for (uint8_t i = 0; i < whichButton; i++) {
+        if (buttons[i].pin == pin) {
+            LOG_WARN("Attempted reuse of GPIO %d. Ignoring assignment whichButton=%d", pin, whichButton);
+            return;
+        }
+    }
+
+    assert(whichButton < 2);
+    buttons[whichButton].pin = pin;
+    buttons[whichButton].activeLogic = LOW;
+
+    pinMode(buttons[whichButton].pin, internalPullup ? INPUT_PULLUP : INPUT);
+}
+
+// Configures the wiring and logic of the joystick buttons
+// Called when outlining your NicheGraphics implementation, in variant/nicheGraphics.cpp
+void TwoButtonExtended::setJoystickWiring(uint8_t uPin, uint8_t dPin, uint8_t lPin, uint8_t rPin, bool internalPullup)
+{
+    if (joystick[Direction::UP].pin == uPin || joystick[Direction::DOWN].pin == dPin || joystick[Direction::LEFT].pin == lPin ||
+        joystick[Direction::RIGHT].pin == rPin) {
+        LOG_WARN("Attempted reuse of Joystick GPIO. Ignoring assignment");
+        return;
+    }
+
+    joystick[Direction::UP].pin = uPin;
+    joystick[Direction::DOWN].pin = dPin;
+    joystick[Direction::LEFT].pin = lPin;
+    joystick[Direction::RIGHT].pin = rPin;
+    joystickActiveLogic = LOW;
+
+    pinMode(joystick[Direction::UP].pin, internalPullup ? INPUT_PULLUP : INPUT);
+    pinMode(joystick[Direction::DOWN].pin, internalPullup ? INPUT_PULLUP : INPUT);
+    pinMode(joystick[Direction::LEFT].pin, internalPullup ? INPUT_PULLUP : INPUT);
+    pinMode(joystick[Direction::RIGHT].pin, internalPullup ? INPUT_PULLUP : INPUT);
+}
+
+void TwoButtonExtended::setTiming(uint8_t whichButton, uint32_t debounceMs, uint32_t longpressMs)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].debounceLength = debounceMs;
+    buttons[whichButton].longpressLength = longpressMs;
+}
+
+void TwoButtonExtended::setJoystickDebounce(uint32_t debounceMs)
+{
+    joystickDebounceLength = debounceMs;
+}
+
+// Set what should happen when a button becomes pressed
+// Use this to implement a "while held" behavior
+void TwoButtonExtended::setHandlerDown(uint8_t whichButton, Callback onDown)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onDown = onDown;
+}
+
+// Set what should happen when a button becomes unpressed
+// Use this to implement a "While held" behavior
+void TwoButtonExtended::setHandlerUp(uint8_t whichButton, Callback onUp)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onUp = onUp;
+}
+
+// Set what should happen when a "short press" event has occurred
+void TwoButtonExtended::setHandlerShortPress(uint8_t whichButton, Callback onPress)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onPress = onPress;
+}
+
+// Set what should happen when a "long press" event has fired
+// Note: this will occur while the button is still held
+void TwoButtonExtended::setHandlerLongPress(uint8_t whichButton, Callback onLongPress)
+{
+    assert(whichButton < 2);
+    buttons[whichButton].onLongPress = onLongPress;
+}
+
+// Set what should happen when a joystick button becomes pressed
+// Use this to implement a "while held" behavior
+void TwoButtonExtended::setJoystickDownHandlers(Callback uDown, Callback dDown, Callback lDown, Callback rDown)
+{
+    joystick[Direction::UP].onDown = uDown;
+    joystick[Direction::DOWN].onDown = dDown;
+    joystick[Direction::LEFT].onDown = lDown;
+    joystick[Direction::RIGHT].onDown = rDown;
+}
+
+// Set what should happen when a joystick button becomes unpressed
+// Use this to implement a "while held" behavior
+void TwoButtonExtended::setJoystickUpHandlers(Callback uUp, Callback dUp, Callback lUp, Callback rUp)
+{
+    joystick[Direction::UP].onUp = uUp;
+    joystick[Direction::DOWN].onUp = dUp;
+    joystick[Direction::LEFT].onUp = lUp;
+    joystick[Direction::RIGHT].onUp = rUp;
+}
+
+// Set what should happen when a "press" event has fired
+// Note: this will occur while the joystick button is still held
+void TwoButtonExtended::setJoystickPressHandlers(Callback uPress, Callback dPress, Callback lPress, Callback rPress)
+{
+    joystick[Direction::UP].onPress = uPress;
+    joystick[Direction::DOWN].onPress = dPress;
+    joystick[Direction::LEFT].onPress = lPress;
+    joystick[Direction::RIGHT].onPress = rPress;
+}
+
+// Handle the start of a press to the primary button
+// Wakes our button thread
+void TwoButtonExtended::isrPrimary()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->buttons[0].state == State::REST) {
+            b->buttons[0].state = State::IRQ;
+            b->buttons[0].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+// Handle the start of a press to the secondary button
+// Wakes our button thread
+void TwoButtonExtended::isrSecondary()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->buttons[1].state == State::REST) {
+            b->buttons[1].state = State::IRQ;
+            b->buttons[1].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+// Handle the start of a press to the joystick buttons
+// Also wakes our button thread
+void TwoButtonExtended::isrJoystickUp()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::UP].state == State::REST) {
+            b->joystick[Direction::UP].state = State::IRQ;
+            b->joystick[Direction::UP].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+void TwoButtonExtended::isrJoystickDown()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::DOWN].state == State::REST) {
+            b->joystick[Direction::DOWN].state = State::IRQ;
+            b->joystick[Direction::DOWN].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+void TwoButtonExtended::isrJoystickLeft()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::LEFT].state == State::REST) {
+            b->joystick[Direction::LEFT].state = State::IRQ;
+            b->joystick[Direction::LEFT].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+void TwoButtonExtended::isrJoystickRight()
+{
+    static volatile bool isrRunning = false;
+
+    if (!isrRunning) {
+        isrRunning = true;
+        TwoButtonExtended *b = TwoButtonExtended::getInstance();
+        if (b->joystick[Direction::RIGHT].state == State::REST) {
+            b->joystick[Direction::RIGHT].state = State::IRQ;
+            b->joystick[Direction::RIGHT].irqAtMillis = millis();
+            b->startThread();
+        }
+        isrRunning = false;
+    }
+}
+
+// Concise method to start our button thread
+// Follows an ISR, listening for button release
+void TwoButtonExtended::startThread()
+{
+    if (!OSThread::enabled) {
+        OSThread::setInterval(10);
+        OSThread::enabled = true;
+    }
+}
+
+// Concise method to stop our button thread
+// Called when we no longer need to poll for button release
+void TwoButtonExtended::stopThread()
+{
+    if (OSThread::enabled) {
+        OSThread::disable();
+    }
+
+    // Reset both buttons manually
+    // Just in case an IRQ fires during the process of resetting the system
+    // Can occur with super rapid presses?
+    buttons[0].state = REST;
+    buttons[1].state = REST;
+    joystick[Direction::UP].state = REST;
+    joystick[Direction::DOWN].state = REST;
+    joystick[Direction::LEFT].state = REST;
+    joystick[Direction::RIGHT].state = REST;
+}
+
+// Our button thread
+// Started by an IRQ, on either button
+// Polls for button releases
+// Stops when both buttons released
+int32_t TwoButtonExtended::runOnce()
+{
+    constexpr uint8_t BUTTON_COUNT = sizeof(buttons) / sizeof(Button);
+    constexpr uint8_t JOYSTICK_COUNT = sizeof(joystick) / sizeof(SimpleButton);
+
+    // Allow either button to request that our thread should continue polling
+    bool awaitingRelease = false;
+
+    // Check both primary and secondary buttons
+    for (uint8_t i = 0; i < BUTTON_COUNT; i++) {
+        switch (buttons[i].state) {
+        // No action: button has not been pressed
+        case REST:
+            break;
+
+        // New press detected by interrupt
+        case IRQ:
+            powerFSM.trigger(EVENT_PRESS);             // Tell PowerFSM that press occurred (resets sleep timer)
+            buttons[i].onDown();                       // Run callback: press has begun (possible hold behavior)
+            buttons[i].state = State::POLLING_UNFIRED; // Mark that button-down has been handled
+            awaitingRelease = true;                    // Mark that polling-for-release should continue
+            break;
+
+        // An existing press continues
+        // Not held long enough to register as longpress
+        case POLLING_UNFIRED: {
+            uint32_t length = millis() - buttons[i].irqAtMillis;
+
+            // If button released since last thread tick,
+            if (digitalRead(buttons[i].pin) != buttons[i].activeLogic) {
+                buttons[i].onUp();              // Run callback: press has ended (possible release of a hold)
+                buttons[i].state = State::REST; // Mark that the button has reset
+                if (length > buttons[i].debounceLength && length < buttons[i].longpressLength) // If too short for longpress,
+                    buttons[i].onPress();                                                      // Run callback: press
+            }
+            // If button not yet released
+            else {
+                awaitingRelease = true; // Mark that polling-for-release should continue
+                if (length >= buttons[i].longpressLength) {
+                    // Run callback: long press (once)
+                    // Then continue waiting for release, to rearm
+                    buttons[i].state = State::POLLING_FIRED;
+                    buttons[i].onLongPress();
+                }
+            }
+            break;
+        }
+
+        // Button still held, but duration long enough that longpress event already fired
+        // Just waiting for release
+        case POLLING_FIRED:
+            // Release detected
+            if (digitalRead(buttons[i].pin) != buttons[i].activeLogic) {
+                buttons[i].state = State::REST;
+                buttons[i].onUp(); // Callback: release of hold (in this case: *after* longpress has fired)
+            }
+            // Not yet released, keep polling
+            else
+                awaitingRelease = true;
+            break;
+        }
+    }
+
+    // Check all the joystick directions
+    for (uint8_t i = 0; i < JOYSTICK_COUNT; i++) {
+        switch (joystick[i].state) {
+        // No action: button has not been pressed
+        case REST:
+            break;
+
+        // New press detected by interrupt
+        case IRQ:
+            powerFSM.trigger(EVENT_PRESS);              // Tell PowerFSM that press occurred (resets sleep timer)
+            joystick[i].onDown();                       // Run callback: press has begun (possible hold behavior)
+            joystick[i].state = State::POLLING_UNFIRED; // Mark that button-down has been handled
+            awaitingRelease = true;                     // Mark that polling-for-release should continue
+            break;
+
+        // An existing press continues
+        // Not held long enough to register as press
+        case POLLING_UNFIRED: {
+            uint32_t length = millis() - joystick[i].irqAtMillis;
+
+            // If button released since last thread tick,
+            if (digitalRead(joystick[i].pin) != joystickActiveLogic) {
+                joystick[i].onUp();              // Run callback: press has ended (possible release of a hold)
+                joystick[i].state = State::REST; // Mark that the button has reset
+            }
+            // If button not yet released
+            else {
+                awaitingRelease = true; // Mark that polling-for-release should continue
+                if (length >= joystickDebounceLength) {
+                    // Run callback: long press (once)
+                    // Then continue waiting for release, to rearm
+                    joystick[i].state = State::POLLING_FIRED;
+                    joystick[i].onPress();
+                }
+            }
+            break;
+        }
+
+        // Button still held after press
+        // Just waiting for release
+        case POLLING_FIRED:
+            // Release detected
+            if (digitalRead(joystick[i].pin) != joystickActiveLogic) {
+                joystick[i].state = State::REST;
+                joystick[i].onUp(); // Callback: release of hold
+            }
+            // Not yet released, keep polling
+            else
+                awaitingRelease = true;
+            break;
+        }
+    }
+
+    // If all buttons are now released
+    // we don't need to waste cpu resources polling
+    // IRQ will restart this thread when we next need it
+    if (!awaitingRelease)
+        stopThread();
+
+    // Run this method again, or don't..
+    // Use whatever behavior was previously set by stopThread() or startThread()
+    return OSThread::interval;
+}
+
+#ifdef ARCH_ESP32
+
+// Detach our class' interrupts before lightsleep
+// Allows sleep.cpp to configure its own interrupts, which wake the device on user-button press
+int TwoButtonExtended::beforeLightSleep(void *unused)
+{
+    stop();
+    return 0; // Indicates success
+}
+
+// Reconfigure our interrupts
+// Our class' interrupts were disconnected during sleep, to allow the user button to wake the device from sleep
+int TwoButtonExtended::afterLightSleep(esp_sleep_wakeup_cause_t cause)
+{
+    start();
+
+    // Manually trigger the button-down ISR
+    // - during light sleep, our ISR is disabled
+    // - if light sleep ends by button press, pretend our own ISR caught it
+    // - need to manually confirm by reading pin ourselves, to avoid occasional false positives
+    //   (false positive only when using internal pullup resistors?)
+    if (cause == ESP_SLEEP_WAKEUP_GPIO && digitalRead(buttons[0].pin) == buttons[0].activeLogic)
+        isrPrimary();
+
+    return 0; // Indicates success
+}
+
+#endif
+
+#endif
diff --git a/src/graphics/niche/Inputs/TwoButtonExtended.h b/src/graphics/niche/Inputs/TwoButtonExtended.h
new file mode 100644
index 000000000..23fd78a2a
--- /dev/null
+++ b/src/graphics/niche/Inputs/TwoButtonExtended.h
@@ -0,0 +1,136 @@
+#ifdef MESHTASTIC_INCLUDE_NICHE_GRAPHICS
+
+/*
+
+Re-usable NicheGraphics input source
+
+Short and Long press for up to two buttons
+Interrupt driven
+
+*/
+
+/*
+
+This expansion adds support for four more buttons
+These buttons are single-action only, no long press
+Interrupt driven
+
+*/
+
+#pragma once
+
+#include "configuration.h"
+
+#include "assert.h"
+#include "functional"
+
+#ifdef ARCH_ESP32
+#include "esp_sleep.h" // For light-sleep handling
+#endif
+
+#include "Observer.h"
+
+namespace NicheGraphics::Inputs
+{
+
+class TwoButtonExtended : protected concurrency::OSThread
+{
+  public:
+    typedef std::function<void()> Callback;
+
+    static uint8_t getUserButtonPin(); // Resolve the GPIO, considering the various possible source of definition
+
+    static TwoButtonExtended *getInstance(); // Create or get the singleton instance
+    void start();                            // Start handling button input
+    void stop();                             // Stop handling button input (disconnect ISRs for sleep)
+    void setWiring(uint8_t whichButton, uint8_t pin, bool internalPullup = false);
+    void setJoystickWiring(uint8_t uPin, uint8_t dPin, uint8_t lPin, uint8_t rPin, bool internalPullup = false);
+    void setTiming(uint8_t whichButton, uint32_t debounceMs, uint32_t longpressMs);
+    void setJoystickDebounce(uint32_t debounceMs);
+    void setHandlerDown(uint8_t whichButton, Callback onDown);
+    void setHandlerUp(uint8_t whichButton, Callback onUp);
+    void setHandlerShortPress(uint8_t whichButton, Callback onShortPress);
+    void setHandlerLongPress(uint8_t whichButton, Callback onLongPress);
+    void setJoystickDownHandlers(Callback uDown, Callback dDown, Callback ldown, Callback rDown);
+    void setJoystickUpHandlers(Callback uUp, Callback dUp, Callback lUp, Callback rUp);
+    void setJoystickPressHandlers(Callback uPress, Callback dPress, Callback lPress, Callback rPress);
+
+    // Disconnect and reconnect interrupts for light sleep
+#ifdef ARCH_ESP32
+    int beforeLightSleep(void *unused);
+    int afterLightSleep(esp_sleep_wakeup_cause_t cause);
+#endif
+
+  private:
+    // Internal state of a specific button
+    enum State {
+        REST,            // Up, no activity
+        IRQ,             // Down detected, not yet handled
+        POLLING_UNFIRED, // Down handled, polling for release
+        POLLING_FIRED,   // Longpress fired, button still held
+    };
+
+    // Joystick Directions
+    enum Direction { UP = 0, DOWN, LEFT, RIGHT };
+
+    // Data used for direction (single-action) buttons
+    class SimpleButton
+    {
+      public:
+        // Per-button config
+        uint8_t pin = 0xFF;                 // 0xFF: unset
+        volatile State state = State::REST; // Internal state
+        volatile uint32_t irqAtMillis;      // millis() when button went down
+
+        // Per-button event callbacks
+        static void noop(){};
+        std::function<void()> onDown = noop;
+        std::function<void()> onUp = noop;
+        std::function<void()> onPress = noop;
+    };
+
+    // Data used for double-action buttons
+    class Button : public SimpleButton
+    {
+      public:
+        // Per-button extended config
+        bool activeLogic = LOW;         // Active LOW by default.
+        uint32_t debounceLength = 50;   // Minimum length for shortpress in ms
+        uint32_t longpressLength = 500; // Time until longpress in ms
+
+        // Per-button event callbacks
+        std::function<void()> onLongPress = noop;
+    };
+
+#ifdef ARCH_ESP32
+    // Get notified when lightsleep begins and ends
+    CallbackObserver<TwoButtonExtended, void *> lsObserver =
+        CallbackObserver<TwoButtonExtended, void *>(this, &TwoButtonExtended::beforeLightSleep);
+    CallbackObserver<TwoButtonExtended, esp_sleep_wakeup_cause_t> lsEndObserver =
+        CallbackObserver<TwoButtonExtended, esp_sleep_wakeup_cause_t>(this, &TwoButtonExtended::afterLightSleep);
+#endif
+
+    int32_t runOnce() override; // Timer method. Polls for button release
+
+    void startThread(); // Start polling for release
+    void stopThread();  // Stop polling for release
+
+    static void isrPrimary();   // User Button ISR
+    static void isrSecondary(); // optional aux button or joystick center
+    static void isrJoystickUp();
+    static void isrJoystickDown();
+    static void isrJoystickLeft();
+    static void isrJoystickRight();
+
+    TwoButtonExtended(); // Constructor made private: force use of Button::instance()
+
+    // Info about both buttons
+    Button buttons[2];
+    bool joystickActiveLogic = LOW;       // Active LOW by default
+    uint32_t joystickDebounceLength = 50; // time until press in ms
+    SimpleButton joystick[4];
+};
+
+}; // namespace NicheGraphics::Inputs
+
+#endif
diff --git a/variants/nrf52840/seeed_wio_tracker_L1_eink/nicheGraphics.h b/variants/nrf52840/seeed_wio_tracker_L1_eink/nicheGraphics.h
index 7fb890303..98aeb8700 100644
--- a/variants/nrf52840/seeed_wio_tracker_L1_eink/nicheGraphics.h
+++ b/variants/nrf52840/seeed_wio_tracker_L1_eink/nicheGraphics.h
@@ -19,7 +19,7 @@
 // Shared NicheGraphics components
 // --------------------------------
 #include "graphics/niche/Drivers/EInk/ZJY122250_0213BAAMFGN.h"
-#include "graphics/niche/Inputs/TwoButton.h"
+#include "graphics/niche/Inputs/TwoButtonExtended.h"
 
 void setupNicheGraphics()
 {
@@ -54,7 +54,12 @@ void setupNicheGraphics()
     InkHUD::Applet::fontSmall = FREESANS_6PT_WIN1252;
 
     // Customize default settings
-    inkhud->persistence->settings.rotation = 1;                        // 90 degrees clockwise
+    inkhud->persistence->settings.rotation = 1; // 90 degrees clockwise
+#if HAS_TRACKBALL
+    inkhud->persistence->settings.joystick.enabled = true;            // Device uses a joystick
+    inkhud->persistence->settings.joystick.alignment = 3;             // 270 degrees
+    inkhud->persistence->settings.optionalMenuItems.nextTile = false; // Use joystick instead
+#endif
     inkhud->persistence->settings.optionalFeatures.batteryIcon = true; // Device definitely has a battery
     inkhud->persistence->settings.userTiles.count = 1;    // One tile only by default, keep things simple for new users
     inkhud->persistence->settings.userTiles.maxCount = 2; // Two applets side-by-side
@@ -75,16 +80,36 @@ void setupNicheGraphics()
     //  Buttons
     //  --------------------------
 
-    Inputs::TwoButton *buttons = Inputs::TwoButton::getInstance(); // Shared NicheGraphics component
+    Inputs::TwoButtonExtended *buttons = Inputs::TwoButtonExtended::getInstance(); // Shared NicheGraphics component
 
-    // #0: Main User Button
-    buttons->setWiring(0, Inputs::TwoButton::getUserButtonPin());
+#if HAS_TRACKBALL
+    // #0: Exit Button
+    buttons->setWiring(0, Inputs::TwoButtonExtended::getUserButtonPin());
+    buttons->setTiming(0, 75, 500);
+    buttons->setHandlerShortPress(0, [inkhud]() { inkhud->exitShort(); });
+    buttons->setHandlerLongPress(0, [inkhud]() { inkhud->exitLong(); });
+
+    // #1: Joystick Center
+    buttons->setWiring(1, TB_PRESS);
+    buttons->setTiming(1, 75, 500);
+    buttons->setHandlerShortPress(1, [inkhud]() { inkhud->shortpress(); });
+    buttons->setHandlerLongPress(1, [inkhud]() { inkhud->longpress(); });
+
+    // Joystick Directions
+    buttons->setJoystickWiring(TB_UP, TB_DOWN, TB_LEFT, TB_RIGHT);
+    buttons->setJoystickDebounce(50);
+    buttons->setJoystickPressHandlers([inkhud]() { inkhud->navUp(); }, [inkhud]() { inkhud->navDown(); },
+                                      [inkhud]() { inkhud->navLeft(); }, [inkhud]() { inkhud->navRight(); });
+#else
+    // #0: User Button
+    buttons->setWiring(0, Inputs::TwoButtonExtended::getUserButtonPin());
     buttons->setTiming(0, 75, 500);
     buttons->setHandlerShortPress(0, [inkhud]() { inkhud->shortpress(); });
     buttons->setHandlerLongPress(0, [inkhud]() { inkhud->longpress(); });
+#endif
 
     // Begin handling button events
     buttons->start();
 }
 
-#endif
\ No newline at end of file
+#endif

From db64a5b51e6427deb68c8a5a905b5e444b23bdbc Mon Sep 17 00:00:00 2001
From: Jorropo <jorropo.pgm@gmail.com>
Date: Sun, 21 Dec 2025 01:29:01 +0100
Subject: [PATCH 02/10] implement basic github action comment reporting target
 diffs (#9022)

This is missing logic:
- report average
- don't bother reporting if the results are negligeable
- praise the user if it's improving the situation
- shame the user if it's not improving the situation
---
 .github/workflows/build_firmware.yml |  13 +++-
 .github/workflows/main_matrix.yml    |  34 +++++++++
 bin/shame.py                         | 101 +++++++++++++++++++++++++++
 3 files changed, 146 insertions(+), 2 deletions(-)
 create mode 100644 bin/shame.py

diff --git a/.github/workflows/build_firmware.yml b/.github/workflows/build_firmware.yml
index d384540a4..19381e211 100644
--- a/.github/workflows/build_firmware.yml
+++ b/.github/workflows/build_firmware.yml
@@ -21,7 +21,7 @@ jobs:
     # Use 'arctastic' self-hosted runner pool when building in the main repo
     runs-on: ${{ github.repository_owner == 'meshtastic' && 'arctastic' || 'ubuntu-latest' }}
     outputs:
-      artifact-id: ${{ steps.upload.outputs.artifact-id }}
+      artifact-id: ${{ steps.upload-firmware.outputs.artifact-id }}
     steps:
       - uses: actions/checkout@v6
         with:
@@ -71,7 +71,7 @@ jobs:
 
       - name: Store binaries as an artifact
         uses: actions/upload-artifact@v6
-        id: upload
+        id: upload-firmware
         with:
           name: firmware-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}
           overwrite: true
@@ -84,3 +84,12 @@ jobs:
             release/*.zip
             release/device-*.sh
             release/device-*.bat
+
+      - name: Store manifests as an artifact
+        uses: actions/upload-artifact@v6
+        id: upload-manifest
+        with:
+          name: manifest-${{ inputs.platform }}-${{ inputs.pio_env }}-${{ inputs.version }}
+          overwrite: true
+          path: |
+            release/*.mt.json
diff --git a/.github/workflows/main_matrix.yml b/.github/workflows/main_matrix.yml
index d7bde7bc5..8a25829e4 100644
--- a/.github/workflows/main_matrix.yml
+++ b/.github/workflows/main_matrix.yml
@@ -233,6 +233,40 @@ jobs:
           description: "Download firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip. This artifact will be available for 90 days from creation"
           github-token: ${{ secrets.GITHUB_TOKEN }}
 
+  shame:
+    if: github.repository == 'meshtastic/firmware'
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
+          fetch-depth: 0
+      - name: Download the current manifests
+        uses: actions/download-artifact@v7
+        with:
+          path: ./manifests-new/
+          pattern: manifest-*
+          merge-multiple: true
+      - name: Upload combined manifests for later commit and global stats crunching.
+        uses: actions/upload-artifact@v6
+        id: upload-manifest
+        with:
+          name: manifests-all
+          overwrite: true
+          path: |
+            manifests-new/*.mt.json
+      - name: Find the merge base
+        run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
+        env:
+          base: ${{ github.base_ref }}
+          head: ${{ github.head_ref }}
+      - name: Download the old manifests
+        run: gh run download -R ${{ github.repository }} --commit ${{ env.MERGE_BASE }} --name manifests-all --dir manifest-old/
+      - name: Do scan and post comment
+        run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
+
   release-artifacts:
     runs-on: ubuntu-latest
     if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
diff --git a/bin/shame.py b/bin/shame.py
new file mode 100644
index 000000000..9e9a7ea40
--- /dev/null
+++ b/bin/shame.py
@@ -0,0 +1,101 @@
+import sys
+import os
+import json
+from github import Github
+
+def parseFile(path):
+    with open(path, "r") as f:
+        data = json.loads(f)
+    for file in data["files"]:
+        if file["name"].endswith(".bin"):
+            return file["name"], file["bytes"]
+
+if len(sys.argv) != 4:
+    print(f"expected usage: {sys.argv[0]} <PR number> <path to old-manifests> <path to new-manifests>")
+    sys.exit(1)
+
+pr_number = int(sys.argv[1])
+
+token = os.getenv("GITHUB_TOKEN")
+if not token:
+    raise EnvironmentError("GITHUB_TOKEN not found in environment.")
+
+repo_name = os.getenv("GITHUB_REPOSITORY")  # "owner/repo"
+if not repo_name:
+    raise EnvironmentError("GITHUB_REPOSITORY not found in environment.")
+
+oldFiles = sys.argv[2]
+old = set(os.path.join(oldFiles, f) for f in os.listdir(oldFiles) if os.path.isfile(f))
+newFiles = sys.argv[3]
+new = set(os.path.join(newFiles, f) for f in os.listdir(newFiles) if os.path.isfile(f))
+
+startMarkdown = "# Target Size Changes\n\n"
+markdown = ""
+
+newlyIntroduced = new - old
+if len(newlyIntroduced) > 0:
+    markdown += "## Newly Introduced Targets\n\n"
+    # create a table
+    markdown += "| File | Size |\n"
+    markdown += "| ---- | ---- |\n"
+    for f in newlyIntroduced:
+        name, size = parseFile(f)
+        markdown += f"| `{name}` | {size}b |\n"
+
+removed = old - new
+if len(removed) > 0:
+    markdown += "\n## Removed Targets\n\n"
+    # create a table
+    markdown += "| File | Size |\n"
+    markdown += "| ---- | ---- |\n"
+    for f in removed:
+        name, size = parseFile(f)
+        markdown += f"| `{name}` | {size}b |\n"
+
+both = old & new
+degradations = []
+improvements = []
+for f in both:
+    oldName, oldSize = parseFile(f)
+    _, newSize = parseFile(f)
+    if oldSize != newSize:
+        if newSize < oldSize:
+            improvements.append((oldName, oldSize, newSize))
+        else:
+            degradations.append((oldName, oldSize, newSize))
+
+if len(degradations) > 0:
+    markdown += "\n## Degradation\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in degradations:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(improvements) > 0:
+    markdown += "\n## Improvement\n\n"
+    # create a table
+    markdown += "| File | Difference | Old Size | New Size |\n"
+    markdown += "| ---- | ---------- | -------- | -------- |\n"
+    for oldName, oldSize, newSize in improvements:
+        markdown += f"| `{oldName}` | **{oldSize - newSize}b** | {oldSize}b | {newSize}b |\n"
+
+if len(markdown) == 0:
+    markdown = "No changes in target sizes detected."
+
+g = Github(token)
+repo = g.get_repo(repo_name)
+pr = repo.get_pull(pr_number)
+
+existing_comment = None
+for comment in pr.get_issue_comments():
+    if comment.body.startswith(startMarkdown):
+        existing_comment = comment
+        break
+
+final_markdown = startMarkdown + markdown
+
+if existing_comment:
+    existing_comment.edit(body=final_markdown)
+else:
+    pr.create_issue_comment(body=final_markdown)

From 8fdba1f1e295825111b036c78e33810c1b847e7a Mon Sep 17 00:00:00 2001
From: WillyJL <me@willyjl.dev>
Date: Sun, 21 Dec 2025 02:10:21 +0100
Subject: [PATCH 03/10] RTC: PCF85063 support, port to SensorLib 0.3.1 (#8061)

* RTC: PCF85063 support, port to SensorLib 0.3.1

* Tidy up defines

* Remove RTC/PCF8563 mentions from unrelated variants

* Bump SensorLib 0.3.2

* Use SensorRtcHelper

* Consistent warning message

* Fix oversight

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Manuel <71137295+mverch67@users.noreply.github.com>
Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 src/configuration.h                           |  4 +-
 src/detect/ScanI2C.cpp                        |  4 +-
 src/detect/ScanI2C.h                          |  1 +
 src/detect/ScanI2CTwoWire.cpp                 |  4 ++
 src/gps/RTC.cpp                               | 48 +++++++++++--------
 src/motion/BMA423Sensor.cpp                   | 12 ++---
 src/motion/MotionSensor.h                     | 26 ----------
 variants/esp32/m5stack_coreink/platformio.ini |  4 +-
 variants/esp32/m5stack_coreink/variant.h      |  1 -
 .../esp32s3/ELECROW-ThinkNode-M2/variant.h    |  4 --
 .../ELECROW-ThinkNode-M5/platformio.ini       |  2 -
 .../esp32s3/ELECROW-ThinkNode-M5/variant.h    |  3 --
 .../heltec_vision_master_e213/platformio.ini  |  2 -
 .../heltec_vision_master_e290/platformio.ini  |  2 -
 .../heltec_vision_master_t190/platformio.ini  |  2 -
 .../heltec_wireless_paper/platformio.ini      |  2 -
 .../heltec_wireless_paper_v1/platformio.ini   |  2 -
 variants/esp32s3/t-watch-s3/platformio.ini    |  6 +--
 variants/esp32s3/t-watch-s3/variant.h         |  3 ++
 variants/esp32s3/tbeam-s3-core/platformio.ini |  5 +-
 variants/esp32s3/tbeam-s3-core/variant.h      |  5 +-
 variants/esp32s3/tlora-pager/platformio.ini   |  4 +-
 variants/esp32s3/tlora-pager/variant.h        |  7 +--
 .../ELECROW-ThinkNode-M1/platformio.ini       |  4 --
 .../nrf52840/ELECROW-ThinkNode-M1/variant.h   |  6 ---
 variants/nrf52840/canaryone/platformio.ini    |  2 -
 .../platformio.ini                            |  2 -
 .../heltec_mesh_node_t114-inkhud/variant.h    |  4 --
 .../heltec_mesh_node_t114/platformio.ini      |  2 -
 .../nrf52840/heltec_mesh_node_t114/variant.h  |  3 --
 .../heltec_mesh_pocket/platformio.ini         |  4 --
 .../nrf52840/heltec_mesh_pocket/variant.h     |  1 -
 .../nrf52840/heltec_mesh_solar/platformio.ini |  2 -
 variants/nrf52840/heltec_mesh_solar/variant.h |  1 -
 .../nrf52840/nano-g2-ultra/platformio.ini     |  4 +-
 variants/nrf52840/nano-g2-ultra/variant.h     |  6 +--
 variants/nrf52840/t-echo/platformio.ini       |  8 ++--
 variants/nrf52840/t-echo/variant.h            |  6 +--
 38 files changed, 68 insertions(+), 140 deletions(-)

diff --git a/src/configuration.h b/src/configuration.h
index b4ab57053..650e1cc71 100644
--- a/src/configuration.h
+++ b/src/configuration.h
@@ -29,8 +29,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #if __has_include("Melopero_RV3028.h")
 #include "Melopero_RV3028.h"
 #endif
-#if __has_include("pcf8563.h")
-#include "pcf8563.h"
+#if __has_include("SensorRtcHelper.hpp")
+#include "SensorRtcHelper.hpp"
 #endif
 
 /* Offer chance for variant-specific defines */
diff --git a/src/detect/ScanI2C.cpp b/src/detect/ScanI2C.cpp
index 8ac503b83..83a455de7 100644
--- a/src/detect/ScanI2C.cpp
+++ b/src/detect/ScanI2C.cpp
@@ -25,8 +25,8 @@ ScanI2C::FoundDevice ScanI2C::firstScreen() const
 
 ScanI2C::FoundDevice ScanI2C::firstRTC() const
 {
-    ScanI2C::DeviceType types[] = {RTC_RV3028, RTC_PCF8563, RTC_RX8130CE};
-    return firstOfOrNONE(3, types);
+    ScanI2C::DeviceType types[] = {RTC_RV3028, RTC_PCF8563, RTC_PCF85063, RTC_RX8130CE};
+    return firstOfOrNONE(4, types);
 }
 
 ScanI2C::FoundDevice ScanI2C::firstKeyboard() const
diff --git a/src/detect/ScanI2C.h b/src/detect/ScanI2C.h
index cced980a6..3a79d97c5 100644
--- a/src/detect/ScanI2C.h
+++ b/src/detect/ScanI2C.h
@@ -14,6 +14,7 @@ class ScanI2C
         SCREEN_ST7567,
         RTC_RV3028,
         RTC_PCF8563,
+        RTC_PCF85063,
         RTC_RX8130CE,
         CARDKB,
         TDECKKB,
diff --git a/src/detect/ScanI2CTwoWire.cpp b/src/detect/ScanI2CTwoWire.cpp
index db269ac64..8e91d1787 100644
--- a/src/detect/ScanI2CTwoWire.cpp
+++ b/src/detect/ScanI2CTwoWire.cpp
@@ -202,6 +202,10 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 SCAN_SIMPLE_CASE(RX8130CE_RTC, RTC_RX8130CE, "RX8130CE", (uint8_t)addr.address)
 #endif
 
+#ifdef PCF85063_RTC
+                SCAN_SIMPLE_CASE(PCF85063_RTC, RTC_PCF85063, "PCF85063", (uint8_t)addr.address)
+#endif
+
             case CARDKB_ADDR:
                 // Do we have the RAK14006 instead?
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x04), 1);
diff --git a/src/gps/RTC.cpp b/src/gps/RTC.cpp
index 1122f0a51..25cd3ceff 100644
--- a/src/gps/RTC.cpp
+++ b/src/gps/RTC.cpp
@@ -66,26 +66,26 @@ RTCSetResult readFromRTC()
             currentQuality = RTCQualityDevice;
         }
         return RTCSetResultSuccess;
+    } else {
+        LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address);
     }
-#elif defined(PCF8563_RTC)
+#elif defined(PCF8563_RTC) || defined(PCF85063_RTC)
+#if defined(PCF8563_RTC)
     if (rtc_found.address == PCF8563_RTC) {
+#elif defined(PCF85063_RTC)
+    if (rtc_found.address == PCF85063_RTC) {
+#endif
         uint32_t now = millis();
-        PCF8563_Class rtc;
+        SensorRtcHelper rtc;
 
 #if WIRE_INTERFACES_COUNT == 2
         rtc.begin(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
 #else
-        rtc.begin();
+        rtc.begin(Wire);
 #endif
 
-        auto tc = rtc.getDateTime();
-        tm t;
-        t.tm_year = tc.year - 1900;
-        t.tm_mon = tc.month - 1;
-        t.tm_mday = tc.day;
-        t.tm_hour = tc.hour;
-        t.tm_min = tc.minute;
-        t.tm_sec = tc.second;
+        RTC_DateTime datetime = rtc.getDateTime();
+        tm t = datetime.toUnixTime();
         tv.tv_sec = gm_mktime(&t);
         tv.tv_usec = 0;
         uint32_t printableEpoch = tv.tv_sec; // Print lib only supports 32 bit but time_t can be 64 bit on some platforms
@@ -100,14 +100,16 @@ RTCSetResult readFromRTC()
         }
 #endif
 
-        LOG_DEBUG("Read RTC time from PCF8563 getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", t.tm_year + 1900, t.tm_mon + 1,
-                  t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
+        LOG_DEBUG("Read RTC time from %s getDateTime as %02d-%02d-%02d %02d:%02d:%02d (%ld)", rtc.getChipName(), t.tm_year + 1900,
+                  t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, printableEpoch);
         if (currentQuality == RTCQualityNone) {
             timeStartMsec = now;
             zeroOffsetSecs = tv.tv_sec;
             currentQuality = RTCQualityDevice;
         }
         return RTCSetResultSuccess;
+    } else {
+        LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address);
     }
 #elif defined(RX8130CE_RTC)
     if (rtc_found.address == RX8130CE_RTC) {
@@ -232,20 +234,28 @@ RTCSetResult perhapsSetRTC(RTCQuality q, const struct timeval *tv, bool forceUpd
             rtc.setTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_wday, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
             LOG_DEBUG("RV3028_RTC setTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                       t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
+        } else {
+            LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address);
         }
-#elif defined(PCF8563_RTC)
+#elif defined(PCF8563_RTC) || defined(PCF85063_RTC)
+#if defined(PCF8563_RTC)
         if (rtc_found.address == PCF8563_RTC) {
-            PCF8563_Class rtc;
+#elif defined(PCF85063_RTC)
+        if (rtc_found.address == PCF85063_RTC) {
+#endif
+            SensorRtcHelper rtc;
 
 #if WIRE_INTERFACES_COUNT == 2
             rtc.begin(rtc_found.port == ScanI2C::I2CPort::WIRE1 ? Wire1 : Wire);
 #else
-            rtc.begin();
+            rtc.begin(Wire);
 #endif
             tm *t = gmtime(&tv->tv_sec);
-            rtc.setDateTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
-            LOG_DEBUG("PCF8563_RTC setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
-                      t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
+            rtc.setDateTime(*t);
+            LOG_DEBUG("%s setDateTime %02d-%02d-%02d %02d:%02d:%02d (%ld)", rtc.getChipName(), t->tm_year + 1900, t->tm_mon + 1,
+                      t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, printableEpoch);
+        } else {
+            LOG_WARN("RTC not found (found address 0x%02X)", rtc_found.address);
         }
 #elif defined(RX8130CE_RTC)
         if (rtc_found.address == RX8130CE_RTC) {
diff --git a/src/motion/BMA423Sensor.cpp b/src/motion/BMA423Sensor.cpp
index 7951a236e..5111dae32 100755
--- a/src/motion/BMA423Sensor.cpp
+++ b/src/motion/BMA423Sensor.cpp
@@ -2,16 +2,14 @@
 
 #if !defined(ARCH_STM32WL) && !MESHTASTIC_EXCLUDE_I2C && defined(HAS_BMA423) && __has_include(<SensorBMA423.hpp>)
 
-using namespace MotionSensorI2C;
-
 BMA423Sensor::BMA423Sensor(ScanI2C::FoundDevice foundDevice) : MotionSensor::MotionSensor(foundDevice) {}
 
 bool BMA423Sensor::init()
 {
-    if (sensor.begin(deviceAddress(), &MotionSensorI2C::readRegister, &MotionSensorI2C::writeRegister)) {
+    if (sensor.begin(Wire, deviceAddress())) {
         sensor.configAccelerometer(sensor.RANGE_2G, sensor.ODR_100HZ, sensor.BW_NORMAL_AVG4, sensor.PERF_CONTINUOUS_MODE);
         sensor.enableAccelerometer();
-        sensor.configInterrupt(BMA4_LEVEL_TRIGGER, BMA4_ACTIVE_HIGH, BMA4_PUSH_PULL, BMA4_OUTPUT_ENABLE, BMA4_INPUT_DISABLE);
+        sensor.configInterrupt();
 
 #ifdef BMA423_INT
         pinMode(BMA4XX_INT, INPUT);
@@ -26,9 +24,9 @@ bool BMA423Sensor::init()
 
 #ifdef T_WATCH_S3
         // Need to raise the wrist function, need to set the correct axis
-        sensor.setReampAxes(sensor.REMAP_TOP_LAYER_RIGHT_CORNER);
+        sensor.setRemapAxes(sensor.REMAP_TOP_LAYER_RIGHT_CORNER);
 #else
-        sensor.setReampAxes(sensor.REMAP_BOTTOM_LAYER_BOTTOM_LEFT_CORNER);
+        sensor.setRemapAxes(sensor.REMAP_BOTTOM_LAYER_BOTTOM_LEFT_CORNER);
 #endif
         // sensor.enableFeature(sensor.FEATURE_STEP_CNTR, true);
         sensor.enableFeature(sensor.FEATURE_TILT, true);
@@ -50,7 +48,7 @@ bool BMA423Sensor::init()
 
 int32_t BMA423Sensor::runOnce()
 {
-    if (sensor.readIrqStatus() != DEV_WIRE_NONE) {
+    if (sensor.readIrqStatus()) {
         if (sensor.isTilt() || sensor.isDoubleTap()) {
             wakeScreen();
             return 500;
diff --git a/src/motion/MotionSensor.h b/src/motion/MotionSensor.h
index 5039f2551..8eb3bf95b 100755
--- a/src/motion/MotionSensor.h
+++ b/src/motion/MotionSensor.h
@@ -61,32 +61,6 @@ class MotionSensor
     uint32_t endCalibrationAt = 0;
 };
 
-namespace MotionSensorI2C
-{
-
-static inline int readRegister(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
-{
-    Wire.beginTransmission(address);
-    Wire.write(reg);
-    Wire.endTransmission();
-    Wire.requestFrom((uint8_t)address, (uint8_t)len);
-    uint8_t i = 0;
-    while (Wire.available()) {
-        data[i++] = Wire.read();
-    }
-    return 0; // Pass
-}
-
-static inline int writeRegister(uint8_t address, uint8_t reg, uint8_t *data, uint8_t len)
-{
-    Wire.beginTransmission(address);
-    Wire.write(reg);
-    Wire.write(data, len);
-    return (0 != Wire.endTransmission());
-}
-
-} // namespace MotionSensorI2C
-
 #endif
 
 #endif
\ No newline at end of file
diff --git a/variants/esp32/m5stack_coreink/platformio.ini b/variants/esp32/m5stack_coreink/platformio.ini
index 057b8abd8..c6410efb2 100644
--- a/variants/esp32/m5stack_coreink/platformio.ini
+++ b/variants/esp32/m5stack_coreink/platformio.ini
@@ -20,8 +20,8 @@ lib_deps =
   ${esp32_base.lib_deps}
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
   zinggjm/GxEPD2@1.6.5
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
 lib_ignore =
   m5stack-coreink
 monitor_filters = esp32_exception_decoder
diff --git a/variants/esp32/m5stack_coreink/variant.h b/variants/esp32/m5stack_coreink/variant.h
index ecd93b7be..b1708352b 100644
--- a/variants/esp32/m5stack_coreink/variant.h
+++ b/variants/esp32/m5stack_coreink/variant.h
@@ -13,7 +13,6 @@
 #define LED_STATE_ON 1 // State when LED is lit
 #define LED_PIN 10
 
-#include "pcf8563.h"
 // PCF8563 RTC Module
 #define PCF8563_RTC 0x51
 #define HAS_RTC 1
diff --git a/variants/esp32s3/ELECROW-ThinkNode-M2/variant.h b/variants/esp32s3/ELECROW-ThinkNode-M2/variant.h
index cd8d43555..ff4f883fe 100644
--- a/variants/esp32s3/ELECROW-ThinkNode-M2/variant.h
+++ b/variants/esp32s3/ELECROW-ThinkNode-M2/variant.h
@@ -56,10 +56,6 @@
 #define HAS_SCREEN 1
 #define USE_SH1106 1
 
-// PCF8563 RTC Module
-// #define PCF8563_RTC 0x51
-// #define PIN_RTC_INT 48 // Interrupt from the PCF8563 RTC
-#define HAS_RTC 0
 #define HAS_GPS 0
 
 #define BUTTON_PIN PIN_BUTTON1
diff --git a/variants/esp32s3/ELECROW-ThinkNode-M5/platformio.ini b/variants/esp32s3/ELECROW-ThinkNode-M5/platformio.ini
index 8361e2ef0..3e87a5907 100644
--- a/variants/esp32s3/ELECROW-ThinkNode-M5/platformio.ini
+++ b/variants/esp32s3/ELECROW-ThinkNode-M5/platformio.ini
@@ -18,7 +18,5 @@ build_flags =
 lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/1655054ba298e0e29fc2044741940f927f9c2a43.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=custom.pio depName=PCA9557-arduino packageName=maxpromer/library/PCA9557-arduino
   maxpromer/PCA9557-arduino@1.0.0
diff --git a/variants/esp32s3/ELECROW-ThinkNode-M5/variant.h b/variants/esp32s3/ELECROW-ThinkNode-M5/variant.h
index 129b398e9..5f5133e61 100644
--- a/variants/esp32s3/ELECROW-ThinkNode-M5/variant.h
+++ b/variants/esp32s3/ELECROW-ThinkNode-M5/variant.h
@@ -44,9 +44,6 @@
 #define PIN_SERIAL1_RX GPS_TX_PIN
 #define PIN_SERIAL1_TX GPS_RX_PIN
 
-// PCF8563 RTC Module
-#define PCF8563_RTC 0x51
-
 #define SX126X_CS 17
 #define LORA_SCK 16
 #define LORA_MOSI 15
diff --git a/variants/esp32s3/heltec_vision_master_e213/platformio.ini b/variants/esp32s3/heltec_vision_master_e213/platformio.ini
index 5109efa67..cf28eb3e6 100644
--- a/variants/esp32s3/heltec_vision_master_e213/platformio.ini
+++ b/variants/esp32s3/heltec_vision_master_e213/platformio.ini
@@ -19,8 +19,6 @@ lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/1655054ba298e0e29fc2044741940f927f9c2a43.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
 upload_speed = 115200
 
 [env:heltec-vision-master-e213-inkhud]
diff --git a/variants/esp32s3/heltec_vision_master_e290/platformio.ini b/variants/esp32s3/heltec_vision_master_e290/platformio.ini
index cd653021b..0e069120b 100644
--- a/variants/esp32s3/heltec_vision_master_e290/platformio.ini
+++ b/variants/esp32s3/heltec_vision_master_e290/platformio.ini
@@ -22,8 +22,6 @@ lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/448c8538129fde3d02a7cb5e6fc81971ad92547f.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
 upload_speed = 115200
 
 [env:heltec-vision-master-e290-inkhud]
diff --git a/variants/esp32s3/heltec_vision_master_t190/platformio.ini b/variants/esp32s3/heltec_vision_master_t190/platformio.ini
index c373692c1..0b0754f60 100644
--- a/variants/esp32s3/heltec_vision_master_t190/platformio.ini
+++ b/variants/esp32s3/heltec_vision_master_t190/platformio.ini
@@ -8,8 +8,6 @@ build_flags =
   -D HELTEC_VISION_MASTER_T190
 lib_deps =
   ${esp32s3_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=git-refs depName=meshtastic-st7789 packageName=https://github.com/meshtastic/st7789 gitBranch=main
   https://github.com/meshtastic/st7789/archive/bd33ea58ddfe4a5e4a66d53300ccbd38d66ac21f.zip
 upload_speed = 921600
diff --git a/variants/esp32s3/heltec_wireless_paper/platformio.ini b/variants/esp32s3/heltec_wireless_paper/platformio.ini
index 5ed039942..4d9eab9d6 100644
--- a/variants/esp32s3/heltec_wireless_paper/platformio.ini
+++ b/variants/esp32s3/heltec_wireless_paper/platformio.ini
@@ -20,8 +20,6 @@ lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/1655054ba298e0e29fc2044741940f927f9c2a43.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
 upload_speed = 115200
 
 [env:heltec-wireless-paper-inkhud]
diff --git a/variants/esp32s3/heltec_wireless_paper_v1/platformio.ini b/variants/esp32s3/heltec_wireless_paper_v1/platformio.ini
index 26bf505e1..bff1fa71f 100644
--- a/variants/esp32s3/heltec_wireless_paper_v1/platformio.ini
+++ b/variants/esp32s3/heltec_wireless_paper_v1/platformio.ini
@@ -17,6 +17,4 @@ lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/55f618961db45a23eff0233546430f1e5a80f63a.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
 upload_speed = 115200
diff --git a/variants/esp32s3/t-watch-s3/platformio.ini b/variants/esp32s3/t-watch-s3/platformio.ini
index f4a01f186..7216d7727 100644
--- a/variants/esp32s3/t-watch-s3/platformio.ini
+++ b/variants/esp32s3/t-watch-s3/platformio.ini
@@ -9,14 +9,12 @@ upload_protocol = esptool
 build_flags = ${esp32s3_base.build_flags}
   -DT_WATCH_S3
   -Ivariants/esp32s3/t-watch-s3
-  -DPCF8563_RTC=0x51
-  -DHAS_BMA423=1
 
 lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
   lovyan03/LovyanGFX@1.2.7
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
   # renovate: datasource=custom.pio depName=Adafruit DRV2605 packageName=adafruit/library/Adafruit DRV2605 Library
   adafruit/Adafruit DRV2605 Library@1.2.4
   # renovate: datasource=custom.pio depName=ESP8266Audio packageName=earlephilhower/library/ESP8266Audio
diff --git a/variants/esp32s3/t-watch-s3/variant.h b/variants/esp32s3/t-watch-s3/variant.h
index 86b0a03c8..923ac86ce 100644
--- a/variants/esp32s3/t-watch-s3/variant.h
+++ b/variants/esp32s3/t-watch-s3/variant.h
@@ -41,11 +41,14 @@
 
 #define HAS_AXP2101
 
+// PCF8563 RTC Module
+#define PCF8563_RTC 0x51
 #define HAS_RTC 1
 
 #define I2C_SDA 10 // For QMC6310 sensors and screens
 #define I2C_SCL 11 // For QMC6310 sensors and screens
 
+#define HAS_BMA423 1
 #define BMA4XX_INT 14 // Interrupt for BMA_423 axis sensor
 
 #define HAS_GPS 0
diff --git a/variants/esp32s3/tbeam-s3-core/platformio.ini b/variants/esp32s3/tbeam-s3-core/platformio.ini
index 0f840627a..71b8eafc0 100644
--- a/variants/esp32s3/tbeam-s3-core/platformio.ini
+++ b/variants/esp32s3/tbeam-s3-core/platformio.ini
@@ -7,10 +7,9 @@ board_check = true
 
 lib_deps =
   ${esp32s3_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
 
 build_flags = 
   ${esp32s3_base.build_flags} 
   -I variants/esp32s3/tbeam-s3-core
-  -D PCF8563_RTC=0x51 ;Putting definitions in variant.h does not compile correctly
diff --git a/variants/esp32s3/tbeam-s3-core/variant.h b/variants/esp32s3/tbeam-s3-core/variant.h
index 1d99fbf14..1f900fcae 100644
--- a/variants/esp32s3/tbeam-s3-core/variant.h
+++ b/variants/esp32s3/tbeam-s3-core/variant.h
@@ -53,6 +53,8 @@
 // #define PMU_IRQ 40
 #define HAS_AXP2101
 
+// PCF8563 RTC Module
+#define PCF8563_RTC 0x51
 #define HAS_RTC 1
 
 // Specify the PMU as Wire1. In the t-beam-s3 core, PCF8563 and PMU share the bus
@@ -72,9 +74,6 @@
 #define HAS_SDCARD // Have SPI interface SD card slot
 #define SDCARD_USE_SPI1
 
-// PCF8563 RTC Module
-// #define PCF8563_RTC 0x51         //Putting definitions in variant. h does not compile correctly
-
 // has 32768 Hz crystal
 #define HAS_32768HZ 1
 
diff --git a/variants/esp32s3/tlora-pager/platformio.ini b/variants/esp32s3/tlora-pager/platformio.ini
index dc4104a81..3cd75c145 100644
--- a/variants/esp32s3/tlora-pager/platformio.ini
+++ b/variants/esp32s3/tlora-pager/platformio.ini
@@ -27,8 +27,8 @@ lib_deps = ${esp32s3_base.lib_deps}
   adafruit/Adafruit DRV2605 Library@1.2.4
   # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
   lewisxhe/PCF8563_Library@1.0.1
-  # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
   # renovate: datasource=github-tags depName=pschatzmann_arduino-audio-driver packageName=pschatzmann/arduino-audio-driver
   https://github.com/pschatzmann/arduino-audio-driver/archive/v0.1.3.zip
   # TODO renovate
diff --git a/variants/esp32s3/tlora-pager/variant.h b/variants/esp32s3/tlora-pager/variant.h
index fe563cded..5f479dfa6 100644
--- a/variants/esp32s3/tlora-pager/variant.h
+++ b/variants/esp32s3/tlora-pager/variant.h
@@ -35,11 +35,8 @@
 #define GPS_TX_PIN 12
 #define PIN_GPS_PPS 13
 
-// PCF8563 RTC Module
-#if __has_include("pcf8563.h")
-#include "pcf8563.h"
-#endif
-#define PCF8563_RTC 0x51
+// PCF85063 RTC Module
+#define PCF85063_RTC 0x51
 #define HAS_RTC 1
 
 // Rotary
diff --git a/variants/nrf52840/ELECROW-ThinkNode-M1/platformio.ini b/variants/nrf52840/ELECROW-ThinkNode-M1/platformio.ini
index c7522a04f..25f1b78b2 100644
--- a/variants/nrf52840/ELECROW-ThinkNode-M1/platformio.ini
+++ b/variants/nrf52840/ELECROW-ThinkNode-M1/platformio.ini
@@ -25,8 +25,6 @@ lib_deps =
   ${nrf52840_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/33db3fa8ee6fc47d160bdb44f8f127c9a9203a10.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=custom.pio depName=nRF52_PWM packageName=khoih-prog/library/nRF52_PWM
   khoih-prog/nRF52_PWM@1.0.1
 ;upload_protocol = fs
@@ -48,5 +46,3 @@ build_src_filter =
 lib_deps = 
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
diff --git a/variants/nrf52840/ELECROW-ThinkNode-M1/variant.h b/variants/nrf52840/ELECROW-ThinkNode-M1/variant.h
index e4a6c0397..cde0f49c1 100644
--- a/variants/nrf52840/ELECROW-ThinkNode-M1/variant.h
+++ b/variants/nrf52840/ELECROW-ThinkNode-M1/variant.h
@@ -93,8 +93,6 @@ static const uint8_t A0 = PIN_A0;
 
 #define TP_SER_IO (0 + 11)
 
-#define PIN_RTC_INT (0 + 16) // Interrupt from the PCF8563 RTC
-
 /*
 External serial flash WP25R1635FZUIL0
 */
@@ -161,9 +159,6 @@ External serial flash WP25R1635FZUIL0
 #define PIN_SERIAL1_TX GPS_TX_PIN
 #define PIN_SERIAL1_RX GPS_RX_PIN
 
-// PCF8563 RTC Module
-#define PCF8563_RTC 0x51
-
 /*
  * SPI Interfaces
  */
@@ -190,7 +185,6 @@ External serial flash WP25R1635FZUIL0
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
 #define ADC_MULTIPLIER (2.02F)
 
-// #define HAS_RTC 0
 // #define HAS_SCREEN 0
 
 #ifdef __cplusplus
diff --git a/variants/nrf52840/canaryone/platformio.ini b/variants/nrf52840/canaryone/platformio.ini
index c833fd5c7..1be04c9aa 100644
--- a/variants/nrf52840/canaryone/platformio.ini
+++ b/variants/nrf52840/canaryone/platformio.ini
@@ -11,6 +11,4 @@ build_flags =
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/canaryone>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
 ;upload_protocol = fs
diff --git a/variants/nrf52840/heltec_mesh_node_t114-inkhud/platformio.ini b/variants/nrf52840/heltec_mesh_node_t114-inkhud/platformio.ini
index 56f55eafc..fbdc999a3 100644
--- a/variants/nrf52840/heltec_mesh_node_t114-inkhud/platformio.ini
+++ b/variants/nrf52840/heltec_mesh_node_t114-inkhud/platformio.ini
@@ -14,8 +14,6 @@ build_src_filter =
 lib_deps = 
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
 extra_scripts =
   ${env.extra_scripts}
   variants/nrf52840/diy/nrf52_promicro_diy_tcxo/custom_build_tasks.py ; Add to PIO's Project Tasks pane: preset builds for common displays
diff --git a/variants/nrf52840/heltec_mesh_node_t114-inkhud/variant.h b/variants/nrf52840/heltec_mesh_node_t114-inkhud/variant.h
index 143d20459..14170d5f3 100644
--- a/variants/nrf52840/heltec_mesh_node_t114-inkhud/variant.h
+++ b/variants/nrf52840/heltec_mesh_node_t114-inkhud/variant.h
@@ -124,9 +124,6 @@ No longer populated on PCB
 #define PIN_SERIAL1_RX GPS_RX_PIN
 #define PIN_SERIAL1_TX GPS_TX_PIN
 
-// PCF8563 RTC Module
-#define PCF8563_RTC 0x51
-
 /*
  * SPI Interfaces
  */
@@ -163,7 +160,6 @@ No longer populated on PCB
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
 #define ADC_MULTIPLIER (4.90F)
 
-#define HAS_RTC 0
 #ifdef __cplusplus
 }
 #endif
diff --git a/variants/nrf52840/heltec_mesh_node_t114/platformio.ini b/variants/nrf52840/heltec_mesh_node_t114/platformio.ini
index cec59d6ee..7971e33c6 100644
--- a/variants/nrf52840/heltec_mesh_node_t114/platformio.ini
+++ b/variants/nrf52840/heltec_mesh_node_t114/platformio.ini
@@ -13,7 +13,5 @@ build_flags = ${nrf52840_base.build_flags}
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/heltec_mesh_node_t114>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=git-refs depName=meshtastic-st7789 packageName=https://github.com/meshtastic/st7789 gitBranch=main
   https://github.com/meshtastic/st7789/archive/bd33ea58ddfe4a5e4a66d53300ccbd38d66ac21f.zip
diff --git a/variants/nrf52840/heltec_mesh_node_t114/variant.h b/variants/nrf52840/heltec_mesh_node_t114/variant.h
index 28404fcce..bad488b35 100644
--- a/variants/nrf52840/heltec_mesh_node_t114/variant.h
+++ b/variants/nrf52840/heltec_mesh_node_t114/variant.h
@@ -175,9 +175,6 @@ No longer populated on PCB
 #define PIN_SERIAL1_RX GPS_RX_PIN
 #define PIN_SERIAL1_TX GPS_TX_PIN
 
-// PCF8563 RTC Module
-#define PCF8563_RTC 0x51
-
 /*
  * SPI Interfaces
  */
diff --git a/variants/nrf52840/heltec_mesh_pocket/platformio.ini b/variants/nrf52840/heltec_mesh_pocket/platformio.ini
index 39b75dada..4d3610fda 100644
--- a/variants/nrf52840/heltec_mesh_pocket/platformio.ini
+++ b/variants/nrf52840/heltec_mesh_pocket/platformio.ini
@@ -25,8 +25,6 @@ build_flags = ${nrf52840_base.build_flags}
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/heltec_mesh_pocket> 
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/b202ebfec6a4821e098cf7a625ba0f6f2400292d.zip
 
@@ -72,8 +70,6 @@ build_flags = ${nrf52840_base.build_flags}
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/heltec_mesh_pocket> 
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/b202ebfec6a4821e098cf7a625ba0f6f2400292d.zip
 
diff --git a/variants/nrf52840/heltec_mesh_pocket/variant.h b/variants/nrf52840/heltec_mesh_pocket/variant.h
index f4f695b34..7ec9b88ea 100644
--- a/variants/nrf52840/heltec_mesh_pocket/variant.h
+++ b/variants/nrf52840/heltec_mesh_pocket/variant.h
@@ -130,7 +130,6 @@ No longer populated on PCB
 
 #undef HAS_GPS
 #define HAS_GPS 0
-#define HAS_RTC 0
 #ifdef __cplusplus
 }
 #endif
diff --git a/variants/nrf52840/heltec_mesh_solar/platformio.ini b/variants/nrf52840/heltec_mesh_solar/platformio.ini
index a4d197cb0..9e73e745a 100644
--- a/variants/nrf52840/heltec_mesh_solar/platformio.ini
+++ b/variants/nrf52840/heltec_mesh_solar/platformio.ini
@@ -15,8 +15,6 @@ lib_deps =
   ${nrf52840_base.lib_deps}
   # renovate: datasource=git-refs depName=NMIoT-meshsolar packageName=https://github.com/NMIoT/meshsolar gitBranch=main
   https://github.com/NMIoT/meshsolar/archive/dfc5330dad443982e6cdd37a61d33fc7252f468b.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=custom.pio depName=ArduinoJson packageName=bblanchon/library/ArduinoJson
   bblanchon/ArduinoJson@6.21.4
 
diff --git a/variants/nrf52840/heltec_mesh_solar/variant.h b/variants/nrf52840/heltec_mesh_solar/variant.h
index 7a8fc579f..112bcd8b3 100644
--- a/variants/nrf52840/heltec_mesh_solar/variant.h
+++ b/variants/nrf52840/heltec_mesh_solar/variant.h
@@ -142,7 +142,6 @@ No longer populated on PCB
 #define BQ4050_SCL_PIN (32 + 0)                // I2C clock line pin
 #define BQ4050_EMERGENCY_SHUTDOWN_PIN (32 + 3) // Emergency shutdown pin
 
-#define HAS_RTC 0
 #ifdef __cplusplus
 }
 #endif
diff --git a/variants/nrf52840/nano-g2-ultra/platformio.ini b/variants/nrf52840/nano-g2-ultra/platformio.ini
index f7db6cd47..f44fd19ca 100644
--- a/variants/nrf52840/nano-g2-ultra/platformio.ini
+++ b/variants/nrf52840/nano-g2-ultra/platformio.ini
@@ -10,6 +10,6 @@ build_flags = ${nrf52840_base.build_flags}
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/nano-g2-ultra>
 lib_deps = 
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
 ;upload_protocol = fs
diff --git a/variants/nrf52840/nano-g2-ultra/variant.h b/variants/nrf52840/nano-g2-ultra/variant.h
index fd837f66e..86de6cb61 100644
--- a/variants/nrf52840/nano-g2-ultra/variant.h
+++ b/variants/nrf52840/nano-g2-ultra/variant.h
@@ -87,8 +87,6 @@ static const uint8_t A4 = PIN_A4;
 #define PIN_WIRE_SDA (0 + 17)
 #define PIN_WIRE_SCL (0 + 15)
 
-#define PIN_RTC_INT (0 + 14) // Interrupt from the PCF8563 RTC
-
 /*
 External serial flash W25Q16JV_IQ
 */
@@ -141,7 +139,9 @@ External serial flash W25Q16JV_IQ
 #define PIN_SERIAL1_RX PIN_GPS_RX
 
 // PCF8563 RTC Module
+#define PIN_RTC_INT (0 + 14) // Interrupt from the PCF8563 RTC
 #define PCF8563_RTC 0x51
+#define HAS_RTC 1
 
 /*
  * SPI Interfaces
@@ -169,8 +169,6 @@ External serial flash W25Q16JV_IQ
 #define VBAT_AR_INTERNAL AR_INTERNAL_3_0
 #define ADC_MULTIPLIER (2.0F)
 
-#define HAS_RTC 1
-
 /**
     OLED Screen Model
     */
diff --git a/variants/nrf52840/t-echo/platformio.ini b/variants/nrf52840/t-echo/platformio.ini
index c489efbc1..744fa23ab 100644
--- a/variants/nrf52840/t-echo/platformio.ini
+++ b/variants/nrf52840/t-echo/platformio.ini
@@ -22,8 +22,8 @@ lib_deps =
   ${nrf52840_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/55f618961db45a23eff0233546430f1e5a80f63a.zip
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
 ;upload_protocol = fs
 
 [env:t-echo-inkhud]
@@ -43,5 +43,5 @@ build_src_filter =
 lib_deps = 
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
-  # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
-  lewisxhe/PCF8563_Library@1.0.1
+  # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
+  lewisxhe/SensorLib@0.3.2
diff --git a/variants/nrf52840/t-echo/variant.h b/variants/nrf52840/t-echo/variant.h
index 9a0cd0578..9244fc6c3 100644
--- a/variants/nrf52840/t-echo/variant.h
+++ b/variants/nrf52840/t-echo/variant.h
@@ -108,8 +108,6 @@ No longer populated on PCB
 
 #define TP_SER_IO (0 + 11)
 
-#define PIN_RTC_INT (0 + 16) // Interrupt from the PCF8563 RTC
-
 /*
 External serial flash WP25R1635FZUIL0
 */
@@ -191,7 +189,9 @@ External serial flash WP25R1635FZUIL0
 #define PIN_SERIAL1_TX GPS_TX_PIN
 
 // PCF8563 RTC Module
+#define PIN_RTC_INT (0 + 16) // Interrupt from the PCF8563 RTC
 #define PCF8563_RTC 0x51
+#define HAS_RTC 1
 
 /*
  * SPI Interfaces
@@ -219,8 +219,6 @@ External serial flash WP25R1635FZUIL0
 
 // #define NO_EXT_GPIO 1
 
-#define HAS_RTC 1
-
 #ifdef __cplusplus
 }
 #endif

From 5a3855b208e396da1f9b62575477e1902cdf821a Mon Sep 17 00:00:00 2001
From: Jorropo <jorropo.pgm@gmail.com>
Date: Sun, 21 Dec 2025 14:11:18 +0100
Subject: [PATCH 04/10] in shame.py do not complain about missing targets
 (#9032)

PR CI only runs a small subset of all tests.

It is very likely a file we didn't found in the PR is just not tested in PR.
---
 bin/shame.py | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/bin/shame.py b/bin/shame.py
index 9e9a7ea40..f2253bfdc 100644
--- a/bin/shame.py
+++ b/bin/shame.py
@@ -42,15 +42,9 @@ if len(newlyIntroduced) > 0:
         name, size = parseFile(f)
         markdown += f"| `{name}` | {size}b |\n"
 
-removed = old - new
-if len(removed) > 0:
-    markdown += "\n## Removed Targets\n\n"
-    # create a table
-    markdown += "| File | Size |\n"
-    markdown += "| ---- | ---- |\n"
-    for f in removed:
-        name, size = parseFile(f)
-        markdown += f"| `{name}` | {size}b |\n"
+# do not log removed targets
+# PRs only run a small subset of builds, so removed targets are not meaningful
+# since they are very likely to just be not ran in PR CI
 
 both = old & new
 degradations = []

From 89c5e4034b66f9c583172abd2cdf392943e13e2d Mon Sep 17 00:00:00 2001
From: Austin <vidplace7@gmail.com>
Date: Tue, 23 Dec 2025 19:29:21 -0500
Subject: [PATCH 05/10] PlatformIO: Re-Org ESP32 family shared props (#9060)

---
 src/graphics/niche/InkHUD/docs/README.md |  8 +--
 variants/esp32/esp32-common.ini          | 88 ++++++++++++++++++++++++
 variants/esp32/esp32.ini                 | 88 ++----------------------
 variants/esp32c3/esp32c3.ini             |  8 +--
 variants/esp32c6/esp32c6.ini             |  5 +-
 variants/esp32s2/esp32s2.ini             |  8 +--
 variants/esp32s3/esp32s3.ini             |  8 +--
 7 files changed, 111 insertions(+), 102 deletions(-)
 create mode 100644 variants/esp32/esp32-common.ini

diff --git a/src/graphics/niche/InkHUD/docs/README.md b/src/graphics/niche/InkHUD/docs/README.md
index e7821299e..aa23f065f 100644
--- a/src/graphics/niche/InkHUD/docs/README.md
+++ b/src/graphics/niche/InkHUD/docs/README.md
@@ -273,7 +273,7 @@ _(Example shows only config required by InkHUD. This is not a complete `env` def
 extends = esp32s3_base, inkhud ; or nrf52840_base, etc
 
 build_src_filter =
-${esp32_base.build_src_filter}
+${esp32s3_base.build_src_filter}
 ${inkhud.build_src_filter}
 
 build_flags =
@@ -756,12 +756,12 @@ This mapping of emoji to control characters is fairly arbitrary. Selection was i
 | `0x03`     | 🙂                                             |
 | `0x04`     | 😆                                             |
 | `0x05`     | 👋                                             |
-| `0x06`     | ☀                                             |
+| `0x06`     | ☀                                              |
 | ~~`0x07`~~ | (bell char, unused)                            |
 | `0x08`     | 🌧                                             |
-| `0x09`     | ☁                                             |
+| `0x09`     | ☁                                              |
 | ~~`0x0A`~~ | (line feed, unused)                            |
-| `0x0B`     | ♥                                             |
+| `0x0B`     | ♥                                              |
 | `0x0C`     | 💩                                             |
 | ~~`0x0D`~~ | (carriage return, unused)                      |
 | `0x0E`     | 🔔                                             |
diff --git a/variants/esp32/esp32-common.ini b/variants/esp32/esp32-common.ini
new file mode 100644
index 000000000..15ab8ad44
--- /dev/null
+++ b/variants/esp32/esp32-common.ini
@@ -0,0 +1,88 @@
+; Common settings for ESP targets, mixin with extends = esp32_common
+[esp32_common]
+extends = arduino_base
+custom_esp32_kind =
+custom_mtjson_part =
+platform =
+  # renovate: datasource=custom.pio depName=platformio/espressif32 packageName=platformio/platform/espressif32
+  platformio/espressif32@6.12.0
+
+extra_scripts =
+  ${env.extra_scripts}
+  pre:extra_scripts/esp32_pre.py
+  extra_scripts/esp32_extra.py
+
+build_src_filter = 
+  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
+
+upload_speed = 921600
+debug_init_break = tbreak setup
+monitor_filters = esp32_exception_decoder
+
+board_build.filesystem = littlefs
+
+# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
+# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
+# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
+build_unflags = -fno-lto
+build_flags =
+  ${arduino_base.build_flags}
+  -flto
+  -Wall
+  -Wextra
+  -Isrc/platform/esp32
+  -std=c++11
+  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
+  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
+  -DAXP_DEBUG_PORT=Serial
+  -DCONFIG_BT_NIMBLE_ENABLED
+  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
+  -DCONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
+  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DSERIAL_BUFFER_SIZE=4096
+  -DSERIAL_HAS_ON_RECEIVE
+  -DLIBPAX_ARDUINO
+  -DLIBPAX_WIFI
+  -DLIBPAX_BLE
+  -DHAS_UDP_MULTICAST=1
+  ;-DDEBUG_HEAP
+
+lib_deps =
+  ${arduino_base.lib_deps}
+  ${networking_base.lib_deps}
+  ${networking_extra.lib_deps}
+  ${environmental_base.lib_deps}
+  ${environmental_extra.lib_deps}
+  ${radiolib_base.lib_deps}
+  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
+  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@2.3.7
+  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
+  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
+  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
+  lewisxhe/XPowersLib@0.3.2
+  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
+  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
+  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
+  rweather/Crypto@0.4.0
+
+lib_ignore = 
+  segger_rtt
+  ESP32 BLE Arduino
+
+; leave this commented out to avoid breaking Windows
+;upload_port = /dev/ttyUSB0
+;monitor_port = /dev/ttyUSB0
+
+; Please don't delete these lines. JM uses them.
+;upload_port = /dev/cu.SLAB_USBtoUART
+;monitor_port = /dev/cu.SLAB_USBtoUART
+
+; customize the partition table
+; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
+board_build.partitions = partition-table.csv
diff --git a/variants/esp32/esp32.ini b/variants/esp32/esp32.ini
index cc1a7b2d2..532fd4e12 100644
--- a/variants/esp32/esp32.ini
+++ b/variants/esp32/esp32.ini
@@ -1,88 +1,8 @@
-; Common settings for ESP targes, mixin with extends = esp32_base
+; Common settings for ESP32 OG (without suffix)
+; See 'esp32_common' for common ESP32-family settings
 [esp32_base]
-extends = arduino_base
+extends = esp32_common
 custom_esp32_kind = esp32
-custom_mtjson_part =
-platform =
-  # renovate: datasource=custom.pio depName=platformio/espressif32 packageName=platformio/platform/espressif32
-  platformio/espressif32@6.12.0
 
-extra_scripts =
-  ${env.extra_scripts}
-  pre:extra_scripts/esp32_pre.py
-  extra_scripts/esp32_extra.py
-
-build_src_filter = 
-  ${arduino_base.build_src_filter} -<platform/nrf52/> -<platform/stm32wl> -<platform/rp2xx0> -<mesh/eth/> -<mesh/raspihttp>
-
-upload_speed = 921600
-debug_init_break = tbreak setup
-monitor_filters = esp32_exception_decoder
-
-board_build.filesystem = littlefs
-
-# Remove -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL for low level BLE logging.
-# See library directory for BLE logging possible values: .pio/libdeps/tbeam/NimBLE-Arduino/src/log_common/log_common.h
-# This overrides the BLE logging default of LOG_LEVEL_INFO (1) from: .pio/libdeps/tbeam/NimBLE-Arduino/src/esp_nimble_cfg.h
-build_unflags = -fno-lto
 build_flags =
-  ${arduino_base.build_flags}
-  -flto
-  -Wall
-  -Wextra
-  -Isrc/platform/esp32
-  -std=c++11
-  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
-  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
-  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
-  -DAXP_DEBUG_PORT=Serial
-  -DCONFIG_BT_NIMBLE_ENABLED
-  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
-  -DCONFIG_BT_NIMBLE_ROLE_CENTRAL_DISABLED
-  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
-  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
-  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
-  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
-  -DSERIAL_BUFFER_SIZE=4096
-  -DSERIAL_HAS_ON_RECEIVE
-  -DLIBPAX_ARDUINO
-  -DLIBPAX_WIFI
-  -DLIBPAX_BLE
-  -DHAS_UDP_MULTICAST=1
-  ;-DDEBUG_HEAP
-
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${networking_base.lib_deps}
-  ${networking_extra.lib_deps}
-  ${environmental_base.lib_deps}
-  ${environmental_extra.lib_deps}
-  ${radiolib_base.lib_deps}
-  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
-  https://github.com/meshtastic/esp32_https_server/archive/3223704846752e6d545139204837bdb2a55459ca.zip
-  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
-  h2zero/NimBLE-Arduino@^2.3.7
-  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
-  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
-  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
-  lewisxhe/XPowersLib@0.3.2
-  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
-  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
-  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
-
-lib_ignore = 
-  segger_rtt
-  ESP32 BLE Arduino
-
-; leave this commented out to avoid breaking Windows
-;upload_port = /dev/ttyUSB0
-;monitor_port = /dev/ttyUSB0
-
-; Please don't delete these lines. JM uses them.
-;upload_port = /dev/cu.SLAB_USBtoUART
-;monitor_port = /dev/cu.SLAB_USBtoUART
-
-; customize the partition table
-; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
-board_build.partitions = partition-table.csv
+  ${esp32_common.build_flags}
diff --git a/variants/esp32c3/esp32c3.ini b/variants/esp32c3/esp32c3.ini
index 07f8bcdd1..7634a4141 100644
--- a/variants/esp32c3/esp32c3.ini
+++ b/variants/esp32c3/esp32c3.ini
@@ -1,11 +1,11 @@
 [esp32c3_base]
-extends = esp32_base
+extends = esp32_common
 custom_esp32_kind = esp32c3
 
 monitor_speed = 115200
 monitor_filters = esp32_c3_exception_decoder
 
 build_flags =
-	${esp32_base.build_flags}
-	-DCONFIG_BT_NIMBLE_EXT_ADV=1
-	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
+  ${esp32_common.build_flags}
+  -DCONFIG_BT_NIMBLE_EXT_ADV=1
+  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
diff --git a/variants/esp32c6/esp32c6.ini b/variants/esp32c6/esp32c6.ini
index b07a2dcd4..c1dfa4d28 100644
--- a/variants/esp32c6/esp32c6.ini
+++ b/variants/esp32c6/esp32c6.ini
@@ -1,5 +1,5 @@
 [esp32c6_base]
-extends = esp32_base
+extends = esp32_common
 platform =
   # Do not renovate until we have switched to pioarduino tagged builds
   https://github.com/Jason2866/platform-espressif32/archive/22faa566df8c789000f8136cd8d0aca49617af55.zip
@@ -35,12 +35,13 @@ lib_deps =
   rweather/Crypto@0.4.0
 
 build_src_filter = 
- ${esp32_base.build_src_filter} -<mesh/http> 
+  ${esp32_common.build_src_filter} -<mesh/http>
 
 monitor_speed = 460800
 monitor_filters = esp32_c3_exception_decoder
 
 lib_ignore =
+  ${esp32_common.lib_ignore}
   NonBlockingRTTTL
   NimBLE-Arduino
   libpax
diff --git a/variants/esp32s2/esp32s2.ini b/variants/esp32s2/esp32s2.ini
index 0f97408b8..c806943ee 100644
--- a/variants/esp32s2/esp32s2.ini
+++ b/variants/esp32s2/esp32s2.ini
@@ -1,19 +1,19 @@
 [esp32s2_base]
-extends = esp32_base
+extends = esp32_common
 custom_esp32_kind = esp32s2
 
 build_src_filter = 
- ${esp32_base.build_src_filter} - <libpax/> -<nimble/> -<mesh/raspihttp>
+ ${esp32_common.build_src_filter} - <libpax/> -<nimble/> -<mesh/raspihttp>
 
 monitor_speed = 115200
 
 build_flags =
-  ${esp32_base.build_flags} 
+  ${esp32_common.build_flags}
   -DHAS_BLUETOOTH=0
   -DMESHTASTIC_EXCLUDE_PAXCOUNTER
   -DMESHTASTIC_EXCLUDE_BLUETOOTH
   
 lib_ignore = 
-  ${esp32_base.lib_ignore} 
+  ${esp32_common.lib_ignore}
   NimBLE-Arduino
   libpax
diff --git a/variants/esp32s3/esp32s3.ini b/variants/esp32s3/esp32s3.ini
index 3230323ec..92ce25084 100644
--- a/variants/esp32s3/esp32s3.ini
+++ b/variants/esp32s3/esp32s3.ini
@@ -1,10 +1,10 @@
 [esp32s3_base]
-extends = esp32_base
+extends = esp32_common
 custom_esp32_kind = esp32s3
 
 monitor_speed = 115200
 
 build_flags =
-	${esp32_base.build_flags}
-	-DCONFIG_BT_NIMBLE_EXT_ADV=1
-	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
+  ${esp32_common.build_flags}
+  -DCONFIG_BT_NIMBLE_EXT_ADV=1
+  -DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2

From d7f0625adaf68b648ca9898c605fff0ba151a4ff Mon Sep 17 00:00:00 2001
From: Austin <vidplace7@gmail.com>
Date: Wed, 24 Dec 2025 05:56:17 -0500
Subject: [PATCH 06/10] Cleanup: Remove icarus custom arduino-esp32 (#9064)

---
 variants/esp32s3/icarus/platformio.ini | 2 --
 1 file changed, 2 deletions(-)

diff --git a/variants/esp32s3/icarus/platformio.ini b/variants/esp32s3/icarus/platformio.ini
index d73c010f2..0aaff52f5 100644
--- a/variants/esp32s3/icarus/platformio.ini
+++ b/variants/esp32s3/icarus/platformio.ini
@@ -7,8 +7,6 @@ board_build.mcu = esp32s3
 board_build.partitions = default_8MB.csv
 upload_protocol = esptool
 upload_speed = 921600
-; TODO renovate or remove
-platform_packages = platformio/framework-arduinoespressif32@https://github.com/PowerFeather/powerfeather-meshtastic-arduino-lib/releases/download/2.0.16a/esp32-2.0.16.zip
 build_unflags =
   ${esp32s3_base.build_unflags}
   -DARDUINO_USB_MODE=1

From 3b968c1d58a66fab1d37451ccc786d7f11306006 Mon Sep 17 00:00:00 2001
From: Austin <vidplace7@gmail.com>
Date: Wed, 24 Dec 2025 05:56:31 -0500
Subject: [PATCH 07/10] Update lewisxhe/SensorLib to 0.3.3 (#9061)

---
 variants/esp32/m5stack_coreink/platformio.ini  | 2 +-
 variants/esp32/tbeam/platformio.ini            | 2 +-
 variants/esp32s3/t-watch-s3/platformio.ini     | 4 +---
 variants/esp32s3/tbeam-s3-core/platformio.ini  | 2 +-
 variants/esp32s3/tlora-pager/platformio.ini    | 2 +-
 variants/nrf52840/nano-g2-ultra/platformio.ini | 2 +-
 variants/nrf52840/t-echo/platformio.ini        | 4 ++--
 7 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/variants/esp32/m5stack_coreink/platformio.ini b/variants/esp32/m5stack_coreink/platformio.ini
index c6410efb2..a4d44a15e 100644
--- a/variants/esp32/m5stack_coreink/platformio.ini
+++ b/variants/esp32/m5stack_coreink/platformio.ini
@@ -21,7 +21,7 @@ lib_deps =
   # renovate: datasource=custom.pio depName=GxEPD2 packageName=zinggjm/library/GxEPD2
   zinggjm/GxEPD2@1.6.5
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 lib_ignore =
   m5stack-coreink
 monitor_filters = esp32_exception_decoder
diff --git a/variants/esp32/tbeam/platformio.ini b/variants/esp32/tbeam/platformio.ini
index 79fd626e9..ed2bfb1a1 100644
--- a/variants/esp32/tbeam/platformio.ini
+++ b/variants/esp32/tbeam/platformio.ini
@@ -23,4 +23,4 @@ lib_deps =
   # renovate: datasource=github-tags depName=meshtastic-st7796 packageName=meshtastic/st7796
   https://github.com/meshtastic/st7796/archive/1.0.5.zip
   # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.1
+  lewisxhe/SensorLib@0.3.3
diff --git a/variants/esp32s3/t-watch-s3/platformio.ini b/variants/esp32s3/t-watch-s3/platformio.ini
index 7216d7727..9785119b5 100644
--- a/variants/esp32s3/t-watch-s3/platformio.ini
+++ b/variants/esp32s3/t-watch-s3/platformio.ini
@@ -14,12 +14,10 @@ lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
   lovyan03/LovyanGFX@1.2.7
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
   # renovate: datasource=custom.pio depName=Adafruit DRV2605 packageName=adafruit/library/Adafruit DRV2605 Library
   adafruit/Adafruit DRV2605 Library@1.2.4
   # renovate: datasource=custom.pio depName=ESP8266Audio packageName=earlephilhower/library/ESP8266Audio
   earlephilhower/ESP8266Audio@1.9.9
   # renovate: datasource=custom.pio depName=ESP8266SAM packageName=earlephilhower/library/ESP8266SAM
   earlephilhower/ESP8266SAM@1.1.0
-  # renovate: datasource=custom.pio depName=lewisxhe-SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.2.0
diff --git a/variants/esp32s3/tbeam-s3-core/platformio.ini b/variants/esp32s3/tbeam-s3-core/platformio.ini
index 71b8eafc0..5522e1d37 100644
--- a/variants/esp32s3/tbeam-s3-core/platformio.ini
+++ b/variants/esp32s3/tbeam-s3-core/platformio.ini
@@ -8,7 +8,7 @@ board_check = true
 lib_deps =
   ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 
 build_flags = 
   ${esp32s3_base.build_flags} 
diff --git a/variants/esp32s3/tlora-pager/platformio.ini b/variants/esp32s3/tlora-pager/platformio.ini
index 3cd75c145..98b9f51f5 100644
--- a/variants/esp32s3/tlora-pager/platformio.ini
+++ b/variants/esp32s3/tlora-pager/platformio.ini
@@ -28,7 +28,7 @@ lib_deps = ${esp32s3_base.lib_deps}
   # renovate: datasource=custom.pio depName=PCF8563 packageName=lewisxhe/library/PCF8563_Library
   lewisxhe/PCF8563_Library@1.0.1
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
   # renovate: datasource=github-tags depName=pschatzmann_arduino-audio-driver packageName=pschatzmann/arduino-audio-driver
   https://github.com/pschatzmann/arduino-audio-driver/archive/v0.1.3.zip
   # TODO renovate
diff --git a/variants/nrf52840/nano-g2-ultra/platformio.ini b/variants/nrf52840/nano-g2-ultra/platformio.ini
index f44fd19ca..5952029fd 100644
--- a/variants/nrf52840/nano-g2-ultra/platformio.ini
+++ b/variants/nrf52840/nano-g2-ultra/platformio.ini
@@ -11,5 +11,5 @@ build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/nano-g2
 lib_deps = 
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 ;upload_protocol = fs
diff --git a/variants/nrf52840/t-echo/platformio.ini b/variants/nrf52840/t-echo/platformio.ini
index 744fa23ab..4244419b7 100644
--- a/variants/nrf52840/t-echo/platformio.ini
+++ b/variants/nrf52840/t-echo/platformio.ini
@@ -23,7 +23,7 @@ lib_deps =
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master
   https://github.com/meshtastic/GxEPD2/archive/55f618961db45a23eff0233546430f1e5a80f63a.zip
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3
 ;upload_protocol = fs
 
 [env:t-echo-inkhud]
@@ -44,4 +44,4 @@ lib_deps =
   ${inkhud.lib_deps} ; InkHUD libs first, so we get GFXRoot instead of AdafruitGFX
   ${nrf52840_base.lib_deps}
   # renovate: datasource=custom.pio depName=SensorLib packageName=lewisxhe/library/SensorLib
-  lewisxhe/SensorLib@0.3.2
+  lewisxhe/SensorLib@0.3.3

From e5c3eda2a2c18684ff7b4c723c36a4fb45ce7270 Mon Sep 17 00:00:00 2001
From: Tom <116762865+NomDeTom@users.noreply.github.com>
Date: Wed, 24 Dec 2025 18:04:28 +0000
Subject: [PATCH 08/10] Fix gps pin defs for various NRF variants. (#9034)

* fix on nrf52_promicro

* try fix for GPS issue

* fix GPS pin assignment in variant.h

* cleared up some comments and confirmed pinouts from schematics

---------

Co-authored-by: macvenez <macvenez@gmail.com>
---
 .../nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h     |  8 ++++----
 variants/nrf52840/nano-g2-ultra/variant.h              |  8 ++++----
 variants/nrf52840/seeed_solar_node/variant.h           |  8 ++++----
 variants/nrf52840/seeed_wio_tracker_L1/variant.h       | 10 ++++------
 variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h  | 10 ++++------
 variants/nrf52840/seeed_xiao_nrf52840_kit/variant.h    |  8 ++++----
 6 files changed, 24 insertions(+), 28 deletions(-)

diff --git a/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h b/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h
index 7eeb26e65..63af1fe79 100644
--- a/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h
+++ b/variants/nrf52840/diy/nrf52_promicro_diy_tcxo/variant.h
@@ -90,16 +90,16 @@ NRF52 PRO MICRO PIN ASSIGNMENT
 #define BUTTON_PIN (32 + 0) // P1.00
 
 // GPS
-#define PIN_GPS_TX (0 + 20) // P0.20 - This is data from the MCU
-#define PIN_GPS_RX (0 + 22) // P0.22 - This is data from the GNSS
+#define GPS_TX_PIN (0 + 20) // P0.20 - This is data from the MCU
+#define GPS_RX_PIN (0 + 22) // P0.22 - This is data from the GNSS
 
 #define PIN_GPS_EN (0 + 24) // P0.24
 #define GPS_UBLOX
 // define GPS_DEBUG
 
 // UART interfaces
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 
 #define PIN_SERIAL2_RX (0 + 6) // P0.06
 #define PIN_SERIAL2_TX (0 + 8) // P0.08
diff --git a/variants/nrf52840/nano-g2-ultra/variant.h b/variants/nrf52840/nano-g2-ultra/variant.h
index 86de6cb61..d8f41a68c 100644
--- a/variants/nrf52840/nano-g2-ultra/variant.h
+++ b/variants/nrf52840/nano-g2-ultra/variant.h
@@ -130,13 +130,13 @@ External serial flash W25Q16JV_IQ
 #define GPS_L76K
 
 #define PIN_GPS_STANDBY (0 + 13) // An output to wake GPS, low means allow sleep, high means force wake STANDBY
-#define PIN_GPS_TX (0 + 10)      // This is for bits going TOWARDS the CPU
-#define PIN_GPS_RX (0 + 9)       // This is for bits going TOWARDS the GPS
+#define GPS_TX_PIN (0 + 10)      // This is for bits going FROM the CPU
+#define GPS_RX_PIN (0 + 9)       // This is for bits going FROM the GPS
 
 // #define GPS_THREAD_INTERVAL 50
 
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 
 // PCF8563 RTC Module
 #define PIN_RTC_INT (0 + 14) // Interrupt from the PCF8563 RTC
diff --git a/variants/nrf52840/seeed_solar_node/variant.h b/variants/nrf52840/seeed_solar_node/variant.h
index 7b7738547..b2a1e6dff 100644
--- a/variants/nrf52840/seeed_solar_node/variant.h
+++ b/variants/nrf52840/seeed_solar_node/variant.h
@@ -116,13 +116,13 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 #define GPS_L76K
 #ifdef GPS_L76K
-#define PIN_GPS_TX D6 // 44
-#define PIN_GPS_RX D7 // 43
+#define GPS_TX_PIN D6 // 44
+#define GPS_RX_PIN D7 // 43
 #define HAS_GPS 1
 #define GPS_BAUDRATE 9600
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 #define PIN_GPS_STANDBY D0
 #define GPS_EN D18 // P1.05
 #endif
diff --git a/variants/nrf52840/seeed_wio_tracker_L1/variant.h b/variants/nrf52840/seeed_wio_tracker_L1/variant.h
index c5647caa8..b62b65161 100644
--- a/variants/nrf52840/seeed_wio_tracker_L1/variant.h
+++ b/variants/nrf52840/seeed_wio_tracker_L1/variant.h
@@ -119,16 +119,14 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 #define GPS_L76K
 #ifdef GPS_L76K
-#define PIN_GPS_RX D6 // P0.26
-#define PIN_GPS_TX D7
+#define GPS_TX_PIN D6 // P0.26 - This is data from the MCU
+#define GPS_RX_PIN D7 // P0.27 - This is data from the GNSS
 #define HAS_GPS 1
 #define GPS_BAUDRATE 9600
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_RX PIN_GPS_TX
-#define PIN_SERIAL1_TX PIN_GPS_RX
+#define PIN_SERIAL1_RX GPS_RX_PIN
+#define PIN_SERIAL1_TX GPS_TX_PIN
 
-#define GPS_RX_PIN PIN_GPS_TX
-#define GPS_TX_PIN PIN_GPS_RX
 #define PIN_GPS_STANDBY D0
 
 // #define GPS_DEBUG
diff --git a/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h b/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h
index 09fefc7f2..ae20f3c36 100644
--- a/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h
+++ b/variants/nrf52840/seeed_wio_tracker_L1_eink/variant.h
@@ -129,16 +129,14 @@ static const uint8_t SCL = PIN_WIRE_SCL;
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 #define GPS_L76K
 #ifdef GPS_L76K
-#define PIN_GPS_RX D6 // P0.26
-#define PIN_GPS_TX D7
+#define GPS_TX_PIN D6 // P0.26 - This is data from the MCU
+#define GPS_RX_PIN D7 // P0.27 - This is data from the GNSS
 #define HAS_GPS 1
 #define GPS_BAUDRATE 9600
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_RX PIN_GPS_TX
-#define PIN_SERIAL1_TX PIN_GPS_RX
+#define PIN_SERIAL1_RX GPS_RX_PIN
+#define PIN_SERIAL1_TX GPS_TX_PIN
 
-#define GPS_RX_PIN PIN_GPS_TX
-#define GPS_TX_PIN PIN_GPS_RX
 #define PIN_GPS_STANDBY D0
 
 // #define GPS_DEBUG
diff --git a/variants/nrf52840/seeed_xiao_nrf52840_kit/variant.h b/variants/nrf52840/seeed_xiao_nrf52840_kit/variant.h
index fb112a302..0844595da 100644
--- a/variants/nrf52840/seeed_xiao_nrf52840_kit/variant.h
+++ b/variants/nrf52840/seeed_xiao_nrf52840_kit/variant.h
@@ -147,12 +147,12 @@ static const uint8_t SCK = PIN_SPI_SCK;
  */
 // GPS L76K
 #ifdef GPS_L76K
-#define PIN_GPS_TX D6
-#define PIN_GPS_RX D7
+#define GPS_TX_PIN D6 // This is data from the MCU
+#define GPS_RX_PIN D7 // This is data from the GNSS module
 #define HAS_GPS 1
 #define GPS_THREAD_INTERVAL 50
-#define PIN_SERIAL1_TX PIN_GPS_TX
-#define PIN_SERIAL1_RX PIN_GPS_RX
+#define PIN_SERIAL1_TX GPS_TX_PIN
+#define PIN_SERIAL1_RX GPS_RX_PIN
 #define PIN_GPS_STANDBY D0
 #else
 #define PIN_SERIAL1_RX (-1)

From 9da4396c6f600a00e9519dbcbc0698205fa50fdb Mon Sep 17 00:00:00 2001
From: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>
Date: Wed, 24 Dec 2025 17:13:31 -0500
Subject: [PATCH 09/10] Multi message storage (#8182)

* First try at multimessage storage and display

* Nrf built issue fix

* Message view mode

* Add channel name instead of channel slot

* trunk fix

* Fix for DM threading

* fix for message time

* rename of view mode to Conversations

* Reply in thread feature

* rename Select View Mode to Select Conversation

* dismiss all live fix

* Messages from phone show on screen

* Decoupled message packets from screen.cpp and cleaned up

* Cannedmessage cleanup and emotes fixed

* Ack on messages sent

* Ack message cleanup

* Dismiss feature fixed

* removed legacy temporary messages

* Emote picker fix

* Memory size debug

* Build error fix

* Sanity checks are okay sometimes

* Lengthen channel name and finalize cleanup removal of Broadcast

* Change DM to @ in order to unify on a single method

* Continue unifying display, also show message status on the "isMine" lines

* Add context for incoming messages

* Better to say "in" vs "on"

* crash fix for confirmation nodes

* Fix outbound labels based to avoid creating delays

* Eink autoscroll dissabled

* gating for message storage when not using a screen

* revert

* Build fail fix

* Don't error out with unset MAC address in unit tests

* Provide some extra spacing for low hanging characters in messages

* Reorder menu options and reword Respond

* Reword menus to better reflect actions

* Go to thread from favorite screen

* Reorder Favorite Action Menu with simple word modifications

* Consolidate wording on "Chats"

* Mute channel fix

* trunk fix

* Clean up how muting works along with when we wake the screen

* Fix builds for HELTEC_MESH_SOLAR

* Signal bars for message ack

* fix for notification renderer

* Remove duplicate code, fix more Chats, and fix C6L MessageRenderer

* Fix to many warnings related to BaseUI

* preset aware signal strength display

* More C6L fixes and clean up header lines

* Use text aligns for message layout where necessary

* Attempt to fix memory usage of invalidLifetime

* Update channel mute for adjusted protobuf

* Missed a comma in merge conflicts

* cleanup to get more space

* Trunk fixes

* Optimize Hi Rez Chirpy to save space

* more fixes

* More cleanup

* Remove used getConversationWith

* Remove unused dismissNewestMessage

* Fix another build error on occassion

* Dimiss key combo function deprecated

* More cleanup

* Fn symbol code removed

* Waypoint cleanup

* Trunk fix

* Fixup Waypoint screen with BaseUI code

* Implement Haruki's ClockRenderer and broadcast decomposeTime across various files.

* Revert "Implement Haruki's ClockRenderer and broadcast decomposeTime across various files."

This reverts commit 2f6572177482fe059d37253117fa8f47abdb6310.

* Implement Haruki's ClockRenderer and broadcast decomposeTime across various files. Attempt 2!

* remove memory usage debug

* Revert only RangeTestModule.cpp change

* Switch from dynamic std::string storage to fixed-size char[]

* Removing old left over code

* More optimization

* Free Heap when not on Message screen

* build error fixes

* Restore ellipsis to end of long names

* Remove legacy function renderMessageContent

* improved destination filtering

* force PKI

* cleanup

* Shorten longNames to not exceed message popups

* log messages sent from apps

* Trunk fix

* Improve layout of messages screen

* Fix potential crash for undefined variable

* Revert changes to RedirectablePrint.cpp

* Apply shortening to longNames in Select Destination

* Fix short name displays

* Fix sprintfOverlappingData issue

* Fix nullPointerRedundantCheck warning on ESP32

* Add "Delete All Chats" to all chat views

* Improve getSafeNodeName / sanitizeString code.

* Improve getSafeNodeName further

* Restore auto favorite; but only if not CLIENT_BASE

* Don't favorite if WE are CLIENT_BASE role

* Don't run message persistent in MUI

* Fix broken endifs

* Unkwnown nodes no longer show as ??? on message  thread

* More delete options and cleanup of code

* fix for delete this chat

* Message menu cleanup

* trunk fix

* Clean up some menu options and remove some Unit C6L ifdefines

* Rework Delete flow

* Desperate times call for desperate measures

* Create a background on the connected icon to reduce overlap impact

* Optimize code for background image

* Fix for Muzi_Base

* Trunk Fixes

* Remove the up/down shortcut to launch canned messages (#8370)

* Remove the up/down shortcut to launch canned messages

* Enabled MQTT and WEBSERVER by default (#8679)

Signed-off-by: kur1k0 <zhuzirun@m5stack.com>
Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>

---------

Signed-off-by: kur1k0 <zhuzirun@m5stack.com>
Co-authored-by: Riker <zhuzirun@m5stack.com>
Co-authored-by: Ben Meadors <benmmeadors@gmail.com>

* Correct string length calculation for signal bars

* Manual message scrolling

* Fix

* Restore CannedMessages on Home Frame

* UpDown situational destination for textMessage

* Correct up/down destinations on textMessage frame

* Update Screen.h for handleTextMessage

* Update Screen.cpp to repair a merge issue

* Add nudge scroll on UpDownEncoder devices.

* Set nodeName to maximum size

* Revert "Set nodeName to maximum size"

This reverts commit e254f399256c746b0c82d62475b580d27d4fbbb9.

* Reflow Node Lists and TLora Pager Views (#8942)

* Add files via upload

* Move files into the right place

* Short or Long Names for everyone!

* Add scrolling to Node list

* Pagination fix for Latest to oldest per page

* Page counters

* Dynamic scaling of column counts based upon screen size, clean up box drawing

* Reflow Node Lists and TLora Pager Views (#8942)

* Add files via upload

* Move files into the right place

* Short or Long Names for everyone!

* Add scrolling to Node list

* Pagination fix for Latest to oldest per page

* Page counters

* Dynamic scaling of column counts based upon screen size, clean up box drawing

* Update exempt labels for stale bot workflow

Adds triaged and backlog to the list of exempt labels.

* Update naming of Frame Visibility toggles

* Fix to scrolling

* Fix for content cutting off when from us

* Fix for "delete this chat" now it does delete the current one

* Rework isHighResolution to be an enum called ScreenResolution

* Migrate Unit C6L macro guards into currentResolution UltraLow checks

* Mistakes happen - restoring NodeList Renderer line

---------

Signed-off-by: kur1k0 <zhuzirun@m5stack.com>
Co-authored-by: Jason P <applewiz@mac.com>
Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>
Co-authored-by: Riker <zhuzirun@m5stack.com>
Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: whywilson <m.tools@qq.com>
Co-authored-by: Tom Fifield <tom@tomfifield.net>
---
 src/MessageStore.cpp                          |  426 +++++++
 src/MessageStore.h                            |  131 +++
 src/Power.cpp                                 |    5 +-
 src/RedirectablePrint.cpp                     |    1 +
 src/graphics/Screen.cpp                       |  322 ++---
 src/graphics/Screen.h                         |   31 +-
 src/graphics/SharedUIDisplay.cpp              |   66 +-
 src/graphics/SharedUIDisplay.h                |    7 +-
 src/graphics/VirtualKeyboard.cpp              |    2 -
 src/graphics/draw/ClockRenderer.cpp           |  205 ++--
 src/graphics/draw/CompassRenderer.cpp         |    4 +-
 src/graphics/draw/DebugRenderer.cpp           |  147 ++-
 src/graphics/draw/DrawRenderers.h             |    3 -
 src/graphics/draw/MenuHandler.cpp             |  699 ++++++++---
 src/graphics/draw/MenuHandler.h               |   10 +-
 src/graphics/draw/MessageRenderer.cpp         | 1038 ++++++++++++-----
 src/graphics/draw/MessageRenderer.h           |   49 +-
 src/graphics/draw/NodeListRenderer.cpp        |  379 ++++--
 src/graphics/draw/NodeListRenderer.h          |   21 +-
 src/graphics/draw/NotificationRenderer.cpp    |  215 ++--
 src/graphics/draw/UIRenderer.cpp              |  125 +-
 src/graphics/draw/UIRenderer.h                |    7 +-
 src/graphics/images.h                         |   52 -
 src/input/kbI2cBase.cpp                       |    2 -
 src/mesh/MeshModule.h                         |    1 +
 src/mesh/MeshService.cpp                      |   12 +-
 src/modules/CannedMessageModule.cpp           |  835 +++++++------
 src/modules/CannedMessageModule.h             |   17 +-
 src/modules/DropzoneModule.cpp                |    4 +-
 src/modules/SystemCommandsModule.cpp          |    9 +-
 .../Telemetry/EnvironmentTelemetry.cpp        |    2 +-
 src/modules/Telemetry/PowerTelemetry.cpp      |    2 +-
 src/modules/TextMessageModule.cpp             |   18 +-
 src/modules/TextMessageModule.h               |   16 +-
 src/modules/WaypointModule.cpp                |  120 +-
 src/platform/portduino/PortduinoGlue.cpp      |    2 +
 .../nrf52840/heltec_mesh_solar/platformio.ini |    8 +
 37 files changed, 3337 insertions(+), 1656 deletions(-)
 create mode 100644 src/MessageStore.cpp
 create mode 100644 src/MessageStore.h

diff --git a/src/MessageStore.cpp b/src/MessageStore.cpp
new file mode 100644
index 000000000..c96645b1c
--- /dev/null
+++ b/src/MessageStore.cpp
@@ -0,0 +1,426 @@
+#include "configuration.h"
+#if HAS_SCREEN
+#include "FSCommon.h"
+#include "MessageStore.h"
+#include "NodeDB.h"
+#include "SPILock.h"
+#include "SafeFile.h"
+#include "gps/RTC.h"
+#include "graphics/draw/MessageRenderer.h"
+#include <cstring> // memcpy
+
+#ifndef MESSAGE_TEXT_POOL_SIZE
+#define MESSAGE_TEXT_POOL_SIZE (MAX_MESSAGES_SAVED * MAX_MESSAGE_SIZE)
+#endif
+
+// Global message text pool and state
+static char *g_messagePool = nullptr;
+static size_t g_poolWritePos = 0;
+
+// Reset pool (called on boot or clear)
+static inline void resetMessagePool()
+{
+    if (!g_messagePool) {
+        g_messagePool = static_cast<char *>(malloc(MESSAGE_TEXT_POOL_SIZE));
+        if (!g_messagePool) {
+            LOG_ERROR("MessageStore: Failed to allocate %d bytes for message pool", MESSAGE_TEXT_POOL_SIZE);
+            return;
+        }
+    }
+    g_poolWritePos = 0;
+    memset(g_messagePool, 0, MESSAGE_TEXT_POOL_SIZE);
+}
+
+// Allocate text in pool and return offset
+// If not enough space remains, wrap around (ring buffer style)
+static inline uint16_t storeTextInPool(const char *src, size_t len)
+{
+    if (len >= MAX_MESSAGE_SIZE)
+        len = MAX_MESSAGE_SIZE - 1;
+
+    // Wrap pool if out of space
+    if (g_poolWritePos + len + 1 >= MESSAGE_TEXT_POOL_SIZE) {
+        g_poolWritePos = 0;
+    }
+
+    uint16_t offset = g_poolWritePos;
+    memcpy(&g_messagePool[g_poolWritePos], src, len);
+    g_messagePool[g_poolWritePos + len] = '\0';
+    g_poolWritePos += (len + 1);
+    return offset;
+}
+
+// Retrieve a const pointer to message text by offset
+static inline const char *getTextFromPool(uint16_t offset)
+{
+    if (!g_messagePool || offset >= MESSAGE_TEXT_POOL_SIZE)
+        return "";
+    return &g_messagePool[offset];
+}
+
+// Helper: assign a timestamp (RTC if available, else boot-relative)
+static inline void assignTimestamp(StoredMessage &sm)
+{
+    uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+    if (nowSecs) {
+        sm.timestamp = nowSecs;
+        sm.isBootRelative = false;
+    } else {
+        sm.timestamp = millis() / 1000;
+        sm.isBootRelative = true;
+    }
+}
+
+// Generic push with cap (used by live + persisted queues)
+template <typename T> static inline void pushWithLimit(std::deque<T> &queue, const T &msg)
+{
+    if (queue.size() >= MAX_MESSAGES_SAVED)
+        queue.pop_front();
+    queue.push_back(msg);
+}
+
+template <typename T> static inline void pushWithLimit(std::deque<T> &queue, T &&msg)
+{
+    if (queue.size() >= MAX_MESSAGES_SAVED)
+        queue.pop_front();
+    queue.emplace_back(std::move(msg));
+}
+
+MessageStore::MessageStore(const std::string &label)
+{
+    filename = "/Messages_" + label + ".msgs";
+    resetMessagePool(); // initialize text pool on boot
+}
+
+// Live message handling (RAM only)
+void MessageStore::addLiveMessage(StoredMessage &&msg)
+{
+    pushWithLimit(liveMessages, std::move(msg));
+}
+void MessageStore::addLiveMessage(const StoredMessage &msg)
+{
+    pushWithLimit(liveMessages, msg);
+}
+
+// Add from incoming/outgoing packet
+const StoredMessage &MessageStore::addFromPacket(const meshtastic_MeshPacket &packet)
+{
+    StoredMessage sm;
+    assignTimestamp(sm);
+    sm.channelIndex = packet.channel;
+
+    const char *payload = reinterpret_cast<const char *>(packet.decoded.payload.bytes);
+    size_t len = strnlen(payload, MAX_MESSAGE_SIZE - 1);
+    sm.textOffset = storeTextInPool(payload, len);
+    sm.textLength = len;
+
+    // Determine sender
+    uint32_t localNode = nodeDB->getNodeNum();
+    sm.sender = (packet.from == 0) ? localNode : packet.from;
+
+    sm.dest = packet.to;
+
+    bool isDM = (sm.dest != 0 && sm.dest != NODENUM_BROADCAST);
+
+    if (packet.from == 0) {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::NONE;
+    } else {
+        sm.type = isDM ? MessageType::DM_TO_US : MessageType::BROADCAST;
+        sm.ackStatus = AckStatus::ACKED;
+    }
+
+    addLiveMessage(sm);
+    return liveMessages.back();
+}
+
+// Outgoing/manual message
+void MessageStore::addFromString(uint32_t sender, uint8_t channelIndex, const std::string &text)
+{
+    StoredMessage sm;
+
+    // Always use our local time (helper handles RTC vs boot time)
+    assignTimestamp(sm);
+
+    sm.sender = sender;
+    sm.channelIndex = channelIndex;
+    sm.textOffset = storeTextInPool(text.c_str(), text.size());
+    sm.textLength = text.size();
+
+    // Use the provided destination
+    sm.dest = sender;
+    sm.type = MessageType::DM_TO_US;
+
+    // Outgoing messages always start with unknown ack status
+    sm.ackStatus = AckStatus::NONE;
+
+    addLiveMessage(sm);
+}
+
+#if ENABLE_MESSAGE_PERSISTENCE
+
+// Compact, fixed-size on-flash representation using offset + length
+struct __attribute__((packed)) StoredMessageRecord {
+    uint32_t timestamp;
+    uint32_t sender;
+    uint8_t channelIndex;
+    uint32_t dest;
+    uint8_t isBootRelative;
+    uint8_t ackStatus;           // static_cast<uint8_t>(AckStatus)
+    uint8_t type;                // static_cast<uint8_t>(MessageType)
+    uint16_t textLength;         // message length
+    char text[MAX_MESSAGE_SIZE]; // store actual text here
+};
+
+// Serialize one StoredMessage to flash
+static inline void writeMessageRecord(SafeFile &f, const StoredMessage &m)
+{
+    StoredMessageRecord rec = {};
+    rec.timestamp = m.timestamp;
+    rec.sender = m.sender;
+    rec.channelIndex = m.channelIndex;
+    rec.dest = m.dest;
+    rec.isBootRelative = m.isBootRelative;
+    rec.ackStatus = static_cast<uint8_t>(m.ackStatus);
+    rec.type = static_cast<uint8_t>(m.type);
+    rec.textLength = m.textLength;
+
+    // Copy the actual text into the record from RAM pool
+    const char *txt = getTextFromPool(m.textOffset);
+    strncpy(rec.text, txt, MAX_MESSAGE_SIZE - 1);
+    rec.text[MAX_MESSAGE_SIZE - 1] = '\0';
+
+    f.write(reinterpret_cast<const uint8_t *>(&rec), sizeof(rec));
+}
+
+// Deserialize one StoredMessage from flash; returns false on short read
+static inline bool readMessageRecord(File &f, StoredMessage &m)
+{
+    StoredMessageRecord rec = {};
+    if (f.readBytes(reinterpret_cast<char *>(&rec), sizeof(rec)) != sizeof(rec))
+        return false;
+
+    m.timestamp = rec.timestamp;
+    m.sender = rec.sender;
+    m.channelIndex = rec.channelIndex;
+    m.dest = rec.dest;
+    m.isBootRelative = rec.isBootRelative;
+    m.ackStatus = static_cast<AckStatus>(rec.ackStatus);
+    m.type = static_cast<MessageType>(rec.type);
+    m.textLength = rec.textLength;
+
+    // 💡 Re-store text into pool and update offset
+    m.textLength = strnlen(rec.text, MAX_MESSAGE_SIZE - 1);
+    m.textOffset = storeTextInPool(rec.text, m.textLength);
+
+    return true;
+}
+
+void MessageStore::saveToFlash()
+{
+#ifdef FSCom
+    // Ensure root exists
+    spiLock->lock();
+    FSCom.mkdir("/");
+    spiLock->unlock();
+
+    SafeFile f(filename.c_str(), false);
+
+    spiLock->lock();
+    uint8_t count = static_cast<uint8_t>(liveMessages.size());
+    if (count > MAX_MESSAGES_SAVED)
+        count = MAX_MESSAGES_SAVED;
+    f.write(&count, 1);
+
+    for (uint8_t i = 0; i < count; ++i) {
+        writeMessageRecord(f, liveMessages[i]);
+    }
+    spiLock->unlock();
+
+    f.close();
+#endif
+}
+
+void MessageStore::loadFromFlash()
+{
+    std::deque<StoredMessage>().swap(liveMessages);
+    resetMessagePool(); // reset pool when loading
+
+#ifdef FSCom
+    concurrency::LockGuard guard(spiLock);
+
+    if (!FSCom.exists(filename.c_str()))
+        return;
+
+    auto f = FSCom.open(filename.c_str(), FILE_O_READ);
+    if (!f)
+        return;
+
+    uint8_t count = 0;
+    f.readBytes(reinterpret_cast<char *>(&count), 1);
+    if (count > MAX_MESSAGES_SAVED)
+        count = MAX_MESSAGES_SAVED;
+
+    for (uint8_t i = 0; i < count; ++i) {
+        StoredMessage m;
+        if (!readMessageRecord(f, m))
+            break;
+        liveMessages.push_back(m);
+    }
+
+    f.close();
+#endif
+}
+
+#else
+// If persistence is disabled, these functions become no-ops
+void MessageStore::saveToFlash() {}
+void MessageStore::loadFromFlash() {}
+#endif
+
+// Clear all messages (RAM + persisted queue)
+void MessageStore::clearAllMessages()
+{
+    std::deque<StoredMessage>().swap(liveMessages);
+    resetMessagePool();
+
+#ifdef FSCom
+    SafeFile f(filename.c_str(), false);
+    uint8_t count = 0;
+    f.write(&count, 1); // write "0 messages"
+    f.close();
+#endif
+}
+
+// Internal helper: erase first or last message matching a predicate
+template <typename Predicate> static void eraseIf(std::deque<StoredMessage> &deque, Predicate pred, bool fromBack = false)
+{
+    if (fromBack) {
+        // Iterate from the back and erase all matches from the end
+        for (auto it = deque.rbegin(); it != deque.rend();) {
+            if (pred(*it)) {
+                it = std::deque<StoredMessage>::reverse_iterator(deque.erase(std::next(it).base()));
+            } else {
+                ++it;
+            }
+        }
+    } else {
+        // Manual forward search to erase all matches
+        for (auto it = deque.begin(); it != deque.end();) {
+            if (pred(*it)) {
+                it = deque.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+}
+
+// Delete oldest message (RAM + persisted queue)
+void MessageStore::deleteOldestMessage()
+{
+    eraseIf(liveMessages, [](StoredMessage &) { return true; });
+    saveToFlash();
+}
+
+// Delete oldest message in a specific channel
+void MessageStore::deleteOldestMessageInChannel(uint8_t channel)
+{
+    auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
+    eraseIf(liveMessages, pred);
+    saveToFlash();
+}
+
+void MessageStore::deleteAllMessagesInChannel(uint8_t channel)
+{
+    auto pred = [channel](const StoredMessage &m) { return m.type == MessageType::BROADCAST && m.channelIndex == channel; };
+    eraseIf(liveMessages, pred, false /* delete ALL, not just first */);
+    saveToFlash();
+}
+
+void MessageStore::deleteAllMessagesWithPeer(uint32_t peer)
+{
+    uint32_t local = nodeDB->getNodeNum();
+    auto pred = [&](const StoredMessage &m) {
+        if (m.type != MessageType::DM_TO_US)
+            return false;
+        uint32_t other = (m.sender == local) ? m.dest : m.sender;
+        return other == peer;
+    };
+    eraseIf(liveMessages, pred, false);
+    saveToFlash();
+}
+
+// Delete oldest message in a direct chat with a node
+void MessageStore::deleteOldestMessageWithPeer(uint32_t peer)
+{
+    auto pred = [peer](const StoredMessage &m) {
+        if (m.type != MessageType::DM_TO_US)
+            return false;
+        uint32_t other = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
+        return other == peer;
+    };
+    eraseIf(liveMessages, pred);
+    saveToFlash();
+}
+
+std::deque<StoredMessage> MessageStore::getChannelMessages(uint8_t channel) const
+{
+    std::deque<StoredMessage> result;
+    for (const auto &m : liveMessages) {
+        if (m.type == MessageType::BROADCAST && m.channelIndex == channel) {
+            result.push_back(m);
+        }
+    }
+    return result;
+}
+
+std::deque<StoredMessage> MessageStore::getDirectMessages() const
+{
+    std::deque<StoredMessage> result;
+    for (const auto &m : liveMessages) {
+        if (m.type == MessageType::DM_TO_US) {
+            result.push_back(m);
+        }
+    }
+    return result;
+}
+
+// Upgrade boot-relative timestamps once RTC is valid
+// Only same-boot boot-relative messages are healed.
+// Persisted boot-relative messages from old boots stay ??? forever.
+void MessageStore::upgradeBootRelativeTimestamps()
+{
+    uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+    if (nowSecs == 0)
+        return; // Still no valid RTC
+
+    uint32_t bootNow = millis() / 1000;
+
+    auto fix = [&](std::deque<StoredMessage> &dq) {
+        for (auto &m : dq) {
+            if (m.isBootRelative && m.timestamp <= bootNow) {
+                uint32_t bootOffset = nowSecs - bootNow;
+                m.timestamp += bootOffset;
+                m.isBootRelative = false;
+            }
+        }
+    };
+    fix(liveMessages);
+}
+
+const char *MessageStore::getText(const StoredMessage &msg)
+{
+    // Wrapper around the internal helper
+    return getTextFromPool(msg.textOffset);
+}
+
+uint16_t MessageStore::storeText(const char *src, size_t len)
+{
+    // Wrapper around the internal helper
+    return storeTextInPool(src, len);
+}
+
+// Global definition
+MessageStore messageStore("default");
+#endif
\ No newline at end of file
diff --git a/src/MessageStore.h b/src/MessageStore.h
new file mode 100644
index 000000000..41eb56b66
--- /dev/null
+++ b/src/MessageStore.h
@@ -0,0 +1,131 @@
+#pragma once
+
+#if HAS_SCREEN
+
+// Disable debug logging entirely on release builds of HELTEC_MESH_SOLAR for space constraints
+#if defined(HELTEC_MESH_SOLAR)
+#define LOG_DEBUG(...)
+#endif
+
+// Enable or disable message persistence (flash storage)
+// Define -DENABLE_MESSAGE_PERSISTENCE=0 in build_flags to disable it entirely
+#ifndef ENABLE_MESSAGE_PERSISTENCE
+#define ENABLE_MESSAGE_PERSISTENCE 1
+#endif
+
+#include "mesh/generated/meshtastic/mesh.pb.h"
+#include <cstdint>
+#include <deque>
+#include <string>
+
+// How many messages are stored (RAM + flash).
+// Define -DMESSAGE_HISTORY_LIMIT=N in build_flags to control memory usage.
+#ifndef MESSAGE_HISTORY_LIMIT
+#define MESSAGE_HISTORY_LIMIT 20
+#endif
+
+// Internal alias used everywhere in code – do NOT redefine elsewhere.
+#define MAX_MESSAGES_SAVED MESSAGE_HISTORY_LIMIT
+
+// Maximum text payload size per message in bytes.
+// This still defines the max message length, but we no longer reserve this space per message.
+#define MAX_MESSAGE_SIZE 220
+
+// Total shared text pool size for all messages combined.
+// The text pool is RAM-only. Text is re-stored from flash into the pool on boot.
+#ifndef MESSAGE_TEXT_POOL_SIZE
+#define MESSAGE_TEXT_POOL_SIZE (MAX_MESSAGES_SAVED * MAX_MESSAGE_SIZE)
+#endif
+
+// Explicit message classification
+enum class MessageType : uint8_t {
+    BROADCAST = 0, // broadcast message
+    DM_TO_US = 1   // direct message addressed to this node
+};
+
+// Delivery status for messages we sent
+enum class AckStatus : uint8_t {
+    NONE = 0,    // just sent, waiting (no symbol shown)
+    ACKED = 1,   // got a valid ACK from destination
+    NACKED = 2,  // explicitly failed
+    TIMEOUT = 3, // no ACK after retry window
+    RELAYED = 4  // got an ACK from relay, not destination
+};
+
+struct StoredMessage {
+    uint32_t timestamp;   // When message was created (secs since boot or RTC)
+    uint32_t sender;      // NodeNum of sender
+    uint8_t channelIndex; // Channel index used
+    uint32_t dest;        // Destination node (broadcast or direct)
+    MessageType type;     // Derived from dest (explicit classification)
+    bool isBootRelative;  // true = millis()/1000 fallback; false = epoch/RTC absolute
+    AckStatus ackStatus;  // Delivery status (only meaningful for our own sent messages)
+
+    // Text storage metadata — rebuilt from flash at boot
+    uint16_t textOffset; // Offset into global text pool (valid only after loadFromFlash())
+    uint16_t textLength; // Length of text in bytes
+
+    // Default constructor initializes all fields safely
+    StoredMessage()
+        : timestamp(0), sender(0), channelIndex(0), dest(0xffffffff), type(MessageType::BROADCAST), isBootRelative(false),
+          ackStatus(AckStatus::NONE), textOffset(0), textLength(0)
+    {
+    }
+};
+
+class MessageStore
+{
+  public:
+    explicit MessageStore(const std::string &label);
+
+    // Live RAM methods (always current, used by UI and runtime)
+    void addLiveMessage(StoredMessage &&msg);
+    void addLiveMessage(const StoredMessage &msg); // convenience overload
+    const std::deque<StoredMessage> &getLiveMessages() const { return liveMessages; }
+
+    // Add new messages from packets or manual input
+    const StoredMessage &addFromPacket(const meshtastic_MeshPacket &mp);                // Incoming/outgoing → RAM only
+    void addFromString(uint32_t sender, uint8_t channelIndex, const std::string &text); // Manual add
+
+    // Persistence methods (used only on boot/shutdown)
+    void saveToFlash();   // Save messages to flash
+    void loadFromFlash(); // Load messages from flash
+
+    // Clear all messages (RAM + persisted queue + text pool)
+    void clearAllMessages();
+
+    // Delete helpers
+    void deleteOldestMessage(); // remove oldest from RAM (and flash on save)
+    void deleteOldestMessageInChannel(uint8_t channel);
+    void deleteOldestMessageWithPeer(uint32_t peer);
+    void deleteAllMessagesInChannel(uint8_t channel);
+    void deleteAllMessagesWithPeer(uint32_t peer);
+
+    // Unified accessor (for UI code, defaults to RAM buffer)
+    const std::deque<StoredMessage> &getMessages() const { return liveMessages; }
+
+    // Helper filters for future use
+    std::deque<StoredMessage> getChannelMessages(uint8_t channel) const; // Only broadcast messages on a channel
+    std::deque<StoredMessage> getDirectMessages() const;                 // Only direct messages
+
+    // Upgrade boot-relative timestamps once RTC is valid
+    void upgradeBootRelativeTimestamps();
+
+    // Retrieve the C-string text for a stored message
+    static const char *getText(const StoredMessage &msg);
+
+    // Allocate text into pool (used by sender-side code)
+    static uint16_t storeText(const char *src, size_t len);
+
+    // Used when loading from flash to rebuild the text pool
+    static uint16_t rebuildTextFromFlash(const char *src, size_t len);
+
+  private:
+    std::deque<StoredMessage> liveMessages; // Single in-RAM message buffer (also used for persistence)
+    std::string filename;                   // Flash filename for persistence
+};
+
+// Global instance (defined in MessageStore.cpp)
+extern MessageStore messageStore;
+
+#endif
diff --git a/src/Power.cpp b/src/Power.cpp
index 7bb8896ce..33dda8e11 100644
--- a/src/Power.cpp
+++ b/src/Power.cpp
@@ -11,6 +11,7 @@
  * For more information, see: https://meshtastic.org/
  */
 #include "power.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "Throttle.h"
@@ -786,7 +787,9 @@ void Power::shutdown()
     playShutdownMelody();
 #endif
     nodeDB->saveToDisk();
-
+#if HAS_SCREEN
+    messageStore.saveToFlash();
+#endif
 #if defined(ARCH_NRF52) || defined(ARCH_ESP32) || defined(ARCH_RP2040)
 #ifdef PIN_LED1
     ledOff(PIN_LED1);
diff --git a/src/RedirectablePrint.cpp b/src/RedirectablePrint.cpp
index 9624a4593..895dcb147 100644
--- a/src/RedirectablePrint.cpp
+++ b/src/RedirectablePrint.cpp
@@ -131,6 +131,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         int hour = hms / SEC_PER_HOUR;
         int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
         int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+
 #ifdef ARCH_PORTDUINO
         ::printf("%s ", logLevel);
         if (color) {
diff --git a/src/graphics/Screen.cpp b/src/graphics/Screen.cpp
index 8bac6936a..0012aeb5d 100644
--- a/src/graphics/Screen.cpp
+++ b/src/graphics/Screen.cpp
@@ -46,6 +46,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #include "FSCommon.h"
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "RadioLibInterface.h"
 #include "error.h"
 #include "gps/GeoCoord.h"
@@ -64,10 +65,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "modules/WaypointModule.h"
 #include "sleep.h"
 #include "target_specific.h"
-
-using graphics::Emote;
-using graphics::emotes;
-using graphics::numEmotes;
+extern MessageStore messageStore;
 
 #if USE_TFTDISPLAY
 extern uint16_t TFT_MESH;
@@ -119,10 +117,6 @@ uint32_t dopThresholds[5] = {2000, 1000, 500, 200, 100};
 // we'll need to hold onto pointers for the modules that can draw a frame.
 std::vector<MeshModule *> moduleFrames;
 
-// Global variables for screen function overlay symbols
-std::vector<std::string> functionSymbol;
-std::string functionSymbolString;
-
 #if HAS_GPS
 // GeoCoord object for the screen
 GeoCoord geoCoord;
@@ -263,19 +257,11 @@ static void drawModuleFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
     } else {
         // otherwise, just display the module frame that's aligned with the current frame
         module_frame = state->currentFrame;
-        // LOG_DEBUG("Screen is not in transition.  Frame: %d", module_frame);
     }
-    // LOG_DEBUG("Draw Module Frame %d", module_frame);
     MeshModule &pi = *moduleFrames.at(module_frame);
     pi.drawFrame(display, state, x, y);
 }
 
-// Ignore messages originating from phone (from the current node 0x0) unless range test or store and forward module are enabled
-static bool shouldDrawMessage(const meshtastic_MeshPacket *packet)
-{
-    return packet->from != 0 && !moduleConfig.store_forward.enabled;
-}
-
 /**
  * Given a recent lat/lon return a guess of the heading the user is walking on.
  *
@@ -322,16 +308,16 @@ Screen::Screen(ScanI2C::DeviceAddress address, meshtastic_Config_DisplayConfig_O
 {
     graphics::normalFrames = new FrameCallback[MAX_NUM_NODES + NUM_EXTRA_FRAMES];
 
-    LOG_INFO("Protobuf Value uiconfig.screen_rgb_color: %d", uiconfig.screen_rgb_color);
     int32_t rawRGB = uiconfig.screen_rgb_color;
-    if (rawRGB > 0 && rawRGB <= 255255255) {
-        uint8_t TFT_MESH_r = (rawRGB >> 16) & 0xFF;
-        uint8_t TFT_MESH_g = (rawRGB >> 8) & 0xFF;
-        uint8_t TFT_MESH_b = rawRGB & 0xFF;
-        LOG_INFO("Values of r,g,b: %d, %d, %d", TFT_MESH_r, TFT_MESH_g, TFT_MESH_b);
 
-        if (TFT_MESH_r <= 255 && TFT_MESH_g <= 255 && TFT_MESH_b <= 255) {
-            TFT_MESH = COLOR565(TFT_MESH_r, TFT_MESH_g, TFT_MESH_b);
+    // Only validate the combined value once
+    if (rawRGB > 0 && rawRGB <= 255255255) {
+        // Extract each component as a normal int first
+        int r = (rawRGB >> 16) & 0xFF;
+        int g = (rawRGB >> 8) & 0xFF;
+        int b = rawRGB & 0xFF;
+        if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+            TFT_MESH = COLOR565(static_cast<uint8_t>(r), static_cast<uint8_t>(g), static_cast<uint8_t>(b));
         }
     }
 
@@ -550,10 +536,10 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 void Screen::setup()
 {
 
-    // === Enable display rendering ===
+    // Enable display rendering
     useDisplay = true;
 
-    // === Load saved brightness from UI config ===
+    // Load saved brightness from UI config
     // For OLED displays (SSD1306), default brightness is 255 if not set
     if (uiconfig.screen_brightness == 0) {
 #if defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107)
@@ -565,7 +551,7 @@ void Screen::setup()
         brightness = uiconfig.screen_brightness;
     }
 
-    // === Detect OLED subtype (if supported by board variant) ===
+    // Detect OLED subtype (if supported by board variant)
 #ifdef AutoOLEDWire_h
     if (isAUTOOled)
         static_cast<AutoOLEDWire *>(dispdev)->setDetected(model);
@@ -587,7 +573,7 @@ void Screen::setup()
     static_cast<ST7796Spi *>(dispdev)->setRGB(TFT_MESH);
 #endif
 
-    // === Initialize display and UI system ===
+    // Initialize display and UI system
     ui->init();
     displayWidth = dispdev->width();
     displayHeight = dispdev->height();
@@ -599,7 +585,7 @@ void Screen::setup()
     ui->disableAllIndicators();            // Disable page indicator dots
     ui->getUiState()->userData = this;     // Allow static callbacks to access Screen instance
 
-    // === Apply loaded brightness ===
+    // Apply loaded brightness
 #if defined(ST7789_CS)
     static_cast<TFTDisplay *>(dispdev)->setDisplayBrightness(brightness);
 #elif defined(USE_OLED) || defined(USE_SSD1306) || defined(USE_SH1106) || defined(USE_SH1107) || defined(USE_SPISSD1306)
@@ -607,20 +593,20 @@ void Screen::setup()
 #endif
     LOG_INFO("Applied screen brightness: %d", brightness);
 
-    // === Set custom overlay callbacks ===
+    // Set custom overlay callbacks
     static OverlayCallback overlays[] = {
         graphics::UIRenderer::drawNavigationBar // Custom indicator icons for each frame
     };
     ui->setOverlays(overlays, sizeof(overlays) / sizeof(overlays[0]));
 
-    // === Enable UTF-8 to display mapping ===
+    // Enable UTF-8 to display mapping
     dispdev->setFontTableLookupFunction(customFontTableLookup);
 
 #ifdef USERPREFS_OEM_TEXT
     logo_timeout *= 2; // Give more time for branded boot logos
 #endif
 
-    // === Configure alert frames (e.g., "Resuming..." or region name) ===
+    // Configure alert frames (e.g., "Resuming..." or region name)
     EINK_ADD_FRAMEFLAG(dispdev, DEMAND_FAST); // Skip slow refresh
     alertFrames[0] = [this](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) {
 #ifdef ARCH_ESP32
@@ -636,10 +622,10 @@ void Screen::setup()
     ui->setFrames(alertFrames, 1);
     ui->disableAutoTransition(); // Require manual navigation between frames
 
-    // === Log buffer for on-screen logs (3 lines max) ===
+    // Log buffer for on-screen logs (3 lines max)
     dispdev->setLogBuffer(3, 32);
 
-    // === Optional screen mirroring or flipping (e.g. for T-Beam orientation) ===
+    // Optional screen mirroring or flipping (e.g. for T-Beam orientation)
 #ifdef SCREEN_MIRROR
     dispdev->mirrorScreen();
 #else
@@ -657,7 +643,7 @@ void Screen::setup()
     }
 #endif
 
-    // === Generate device ID from MAC address ===
+    // Generate device ID from MAC address
     uint8_t dmac[6];
     getMacAddr(dmac);
     snprintf(screen->ourId, sizeof(screen->ourId), "%02x%02x", dmac[4], dmac[5]);
@@ -666,9 +652,9 @@ void Screen::setup()
     handleSetOn(false); // Ensure proper init for Arduino targets
 #endif
 
-    // === Turn on display and trigger first draw ===
+    //  Turn on display and trigger first draw
     handleSetOn(true);
-    determineResolution(dispdev->height(), dispdev->width());
+    graphics::currentResolution = graphics::determineScreenResolution(dispdev->height(), dispdev->width());
     ui->update();
 #ifndef USE_EINK
     ui->update(); // Some SSD1306 clones drop the first draw, so run twice
@@ -689,7 +675,7 @@ void Screen::setup()
     touchScreenImpl1->init();
 #endif
 
-    // === Subscribe to device status updates ===
+    // Subscribe to device status updates
     powerStatusObserver.observe(&powerStatus->onNewStatus);
     gpsStatusObserver.observe(&gpsStatus->onNewStatus);
     nodeStatusObserver.observe(&nodeStatus->onNewStatus);
@@ -697,12 +683,14 @@ void Screen::setup()
 #if !MESHTASTIC_EXCLUDE_ADMIN
     adminMessageObserver.observe(adminModule);
 #endif
-    if (textMessageModule)
-        textMessageObserver.observe(textMessageModule);
     if (inputBroker)
         inputObserver.observe(inputBroker);
 
-    // === Notify modules that support UI events ===
+    // Load persisted messages into RAM
+    messageStore.loadFromFlash();
+    LOG_INFO("MessageStore loaded from flash");
+
+    // Notify modules that support UI events
     MeshModule::observeUIEvents(&uiFrameEventObserver);
 }
 
@@ -773,6 +761,23 @@ int32_t Screen::runOnce()
     if (displayHeight == 0) {
         displayHeight = dispdev->getHeight();
     }
+
+    // Detect frame transitions and clear message cache when leaving text message screen
+    {
+        static int8_t lastFrameIndex = -1;
+        int8_t currentFrameIndex = ui->getUiState()->currentFrame;
+        int8_t textMsgIndex = framesetInfo.positions.textMessage;
+
+        if (lastFrameIndex != -1 && currentFrameIndex != lastFrameIndex) {
+
+            if (lastFrameIndex == textMsgIndex && currentFrameIndex != textMsgIndex) {
+                graphics::MessageRenderer::clearMessageCache();
+            }
+        }
+
+        lastFrameIndex = currentFrameIndex;
+    }
+
     menuHandler::handleMenuSwitch(dispdev);
 
     // Show boot screen for first logo_timeout seconds, then switch to normal operation.
@@ -828,17 +833,17 @@ int32_t Screen::runOnce()
             break;
         case Cmd::ON_PRESS:
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleOnPress();
+                showFrame(FrameDirection::NEXT);
             }
             break;
         case Cmd::SHOW_PREV_FRAME:
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleShowPrevFrame();
+                showFrame(FrameDirection::PREVIOUS);
             }
             break;
         case Cmd::SHOW_NEXT_FRAME:
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
-                handleShowNextFrame();
+                showFrame(FrameDirection::NEXT);
             }
             break;
         case Cmd::START_ALERT_FRAME: {
@@ -859,6 +864,7 @@ int32_t Screen::runOnce()
             break;
         case Cmd::STOP_ALERT_FRAME:
             NotificationRenderer::pauseBanner = false;
+            break;
         case Cmd::STOP_BOOT_SCREEN:
             EINK_ADD_FRAMEFLAG(dispdev, COSMETIC); // E-Ink: Explicitly use full-refresh for next frame
             if (NotificationRenderer::current_notification_type != notificationTypeEnum::text_input) {
@@ -1029,9 +1035,6 @@ void Screen::setFrames(FrameFocus focus)
     }
 #endif
 
-    // Declare this early so it’s available in FOCUS_PRESERVE block
-    bool willInsertTextMessage = shouldDrawMessage(&devicestate.rx_text_message);
-
     if (!hiddenFrames.home) {
         fsi.positions.home = numframes;
         normalFrames[numframes++] = graphics::UIRenderer::drawDeviceFocused;
@@ -1043,11 +1046,16 @@ void Screen::setFrames(FrameFocus focus)
     indicatorIcons.push_back(icon_mail);
 
 #ifndef USE_EINK
-    if (!hiddenFrames.nodelist) {
-        fsi.positions.nodelist = numframes;
-        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicNodeListScreen;
+    if (!hiddenFrames.nodelist_nodes) {
+        fsi.positions.nodelist_nodes = numframes;
+        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicListScreen_Nodes;
         indicatorIcons.push_back(icon_nodes);
     }
+    if (!hiddenFrames.nodelist_location) {
+        fsi.positions.nodelist_location = numframes;
+        normalFrames[numframes++] = graphics::NodeListRenderer::drawDynamicListScreen_Location;
+        indicatorIcons.push_back(icon_list);
+    }
 #endif
 
 // Show detailed node views only on E-Ink builds
@@ -1069,11 +1077,13 @@ void Screen::setFrames(FrameFocus focus)
     }
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
     if (!hiddenFrames.nodelist_bearings) {
         fsi.positions.nodelist_bearings = numframes;
         normalFrames[numframes++] = graphics::NodeListRenderer::drawNodeListWithCompasses;
         indicatorIcons.push_back(icon_list);
     }
+#endif
     if (!hiddenFrames.gps) {
         fsi.positions.gps = numframes;
         normalFrames[numframes++] = graphics::UIRenderer::drawCompassAndLocationScreen;
@@ -1173,7 +1183,7 @@ void Screen::setFrames(FrameFocus focus)
     }
 
     fsi.frameCount = numframes;   // Total framecount is used to apply FOCUS_PRESERVE
-    this->frameCount = numframes; // ✅ Save frame count for use in custom overlay
+    this->frameCount = numframes; // Save frame count for use in custom overlay
     LOG_DEBUG("Finished build frames. numframes: %d", numframes);
 
     ui->setFrames(normalFrames, numframes);
@@ -1193,10 +1203,6 @@ void Screen::setFrames(FrameFocus focus)
     case FOCUS_FAULT:
         ui->switchToFrame(fsi.positions.fault);
         break;
-    case FOCUS_TEXTMESSAGE:
-        hasUnreadMessage = false; // ✅ Clear when message is *viewed*
-        ui->switchToFrame(fsi.positions.textMessage);
-        break;
     case FOCUS_MODULE:
         // Whichever frame was marked by MeshModule::requestFocus(), if any
         // If no module requested focus, will show the first frame instead
@@ -1239,8 +1245,11 @@ void Screen::setFrameImmediateDraw(FrameCallback *drawFrames)
 void Screen::toggleFrameVisibility(const std::string &frameName)
 {
 #ifndef USE_EINK
-    if (frameName == "nodelist") {
-        hiddenFrames.nodelist = !hiddenFrames.nodelist;
+    if (frameName == "nodelist_nodes") {
+        hiddenFrames.nodelist_nodes = !hiddenFrames.nodelist_nodes;
+    }
+    if (frameName == "nodelist_location") {
+        hiddenFrames.nodelist_location = !hiddenFrames.nodelist_location;
     }
 #endif
 #ifdef USE_EINK
@@ -1255,9 +1264,11 @@ void Screen::toggleFrameVisibility(const std::string &frameName)
     }
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
     if (frameName == "nodelist_bearings") {
         hiddenFrames.nodelist_bearings = !hiddenFrames.nodelist_bearings;
     }
+#endif
     if (frameName == "gps") {
         hiddenFrames.gps = !hiddenFrames.gps;
     }
@@ -1279,8 +1290,10 @@ void Screen::toggleFrameVisibility(const std::string &frameName)
 bool Screen::isFrameHidden(const std::string &frameName) const
 {
 #ifndef USE_EINK
-    if (frameName == "nodelist")
-        return hiddenFrames.nodelist;
+    if (frameName == "nodelist_nodes")
+        return hiddenFrames.nodelist_nodes;
+    if (frameName == "nodelist_location")
+        return hiddenFrames.nodelist_location;
 #endif
 #ifdef USE_EINK
     if (frameName == "nodelist_lastheard")
@@ -1291,8 +1304,10 @@ bool Screen::isFrameHidden(const std::string &frameName) const
         return hiddenFrames.nodelist_distance;
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
     if (frameName == "nodelist_bearings")
         return hiddenFrames.nodelist_bearings;
+#endif
     if (frameName == "gps")
         return hiddenFrames.gps;
 #endif
@@ -1308,37 +1323,6 @@ bool Screen::isFrameHidden(const std::string &frameName) const
     return false;
 }
 
-// Dismisses the currently displayed screen frame, if possible
-// Relevant for text message, waypoint, others in future?
-// Triggered with a CardKB keycombo
-void Screen::hideCurrentFrame()
-{
-    uint8_t currentFrame = ui->getUiState()->currentFrame;
-    bool dismissed = false;
-    if (currentFrame == framesetInfo.positions.textMessage && devicestate.has_rx_text_message) {
-        LOG_INFO("Hide Text Message");
-        devicestate.has_rx_text_message = false;
-        memset(&devicestate.rx_text_message, 0, sizeof(devicestate.rx_text_message));
-    } else if (currentFrame == framesetInfo.positions.waypoint && devicestate.has_rx_waypoint) {
-        LOG_DEBUG("Hide Waypoint");
-        devicestate.has_rx_waypoint = false;
-        hiddenFrames.waypoint = true;
-        dismissed = true;
-    } else if (currentFrame == framesetInfo.positions.wifi) {
-        LOG_DEBUG("Hide WiFi Screen");
-        hiddenFrames.wifi = true;
-        dismissed = true;
-    } else if (currentFrame == framesetInfo.positions.lora) {
-        LOG_INFO("Hide LoRa");
-        hiddenFrames.lora = true;
-        dismissed = true;
-    }
-
-    if (dismissed) {
-        setFrames(FOCUS_DEFAULT); // You could also use FOCUS_PRESERVE
-    }
-}
-
 void Screen::handleStartFirmwareUpdateScreen()
 {
     LOG_DEBUG("Show firmware screen");
@@ -1391,28 +1375,6 @@ void Screen::decreaseBrightness()
     /* TO DO: add little popup in center of screen saying what brightness level it is set to*/
 }
 
-void Screen::setFunctionSymbol(std::string sym)
-{
-    if (std::find(functionSymbol.begin(), functionSymbol.end(), sym) == functionSymbol.end()) {
-        functionSymbol.push_back(sym);
-        functionSymbolString = "";
-        for (auto symbol : functionSymbol) {
-            functionSymbolString = symbol + " " + functionSymbolString;
-        }
-        setFastFramerate();
-    }
-}
-
-void Screen::removeFunctionSymbol(std::string sym)
-{
-    functionSymbol.erase(std::remove(functionSymbol.begin(), functionSymbol.end(), sym), functionSymbol.end());
-    functionSymbolString = "";
-    for (auto symbol : functionSymbol) {
-        functionSymbolString = symbol + " " + functionSymbolString;
-    }
-    setFastFramerate();
-}
-
 void Screen::handleOnPress()
 {
     // If screen was off, just wake it, otherwise advance to next frame
@@ -1424,23 +1386,17 @@ void Screen::handleOnPress()
     }
 }
 
-void Screen::handleShowPrevFrame()
+void Screen::showFrame(FrameDirection direction)
 {
-    // If screen was off, just wake it, otherwise go back to previous frame
-    // If we are in a transition, the press must have bounced, drop it.
+    // Only advance frames when UI is stable
     if (ui->getUiState()->frameState == FIXED) {
-        ui->previousFrame();
-        lastScreenTransition = millis();
-        setFastFramerate();
-    }
-}
 
-void Screen::handleShowNextFrame()
-{
-    // If screen was off, just wake it, otherwise advance to next frame
-    // If we are in a transition, the press must have bounced, drop it.
-    if (ui->getUiState()->frameState == FIXED) {
-        ui->nextFrame();
+        if (direction == FrameDirection::NEXT) {
+            ui->nextFrame();
+        } else {
+            ui->previousFrame();
+        }
+
         lastScreenTransition = millis();
         setFastFramerate();
     }
@@ -1466,7 +1422,6 @@ void Screen::setFastFramerate()
 
 int Screen::handleStatusUpdate(const meshtastic::Status *arg)
 {
-    // LOG_DEBUG("Screen got status update %d", arg->getStatusType());
     switch (arg->getStatusType()) {
     case STATUS_TYPE_NODE:
         if (showingNormalScreen && nodeStatus->getLastNumTotal() != nodeStatus->getNumTotal()) {
@@ -1584,11 +1539,11 @@ int Screen::handleTextMessage(const meshtastic_MeshPacket *packet)
                     screen->showSimpleBanner(banner, 3000);
                 } else if (!channel.settings.has_module_settings || !channel.settings.module_settings.is_muted) {
                     if (longName && longName[0]) {
-#if defined(M5STACK_UNITC6L)
-                        strcpy(banner, "New Message");
-#else
-                        snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
-#endif
+                        if (currentResolution == ScreenResolution::UltraLow) {
+                            strcpy(banner, "New Message");
+                        } else {
+                            snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
+                        }
                     } else {
                         strcpy(banner, "New Message");
                     }
@@ -1624,16 +1579,26 @@ int Screen::handleUIFrameEvent(const UIFrameEvent *event)
 
     if (showingNormalScreen) {
         // Regenerate the frameset, potentially honoring a module's internal requestFocus() call
-        if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET)
+        if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET) {
             setFrames(FOCUS_MODULE);
+        }
 
-        // Regenerate the frameset, while Attempt to maintain focus on the current frame
-        else if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND)
+        // Regenerate the frameset, while attempting to maintain focus on the current frame
+        else if (event->action == UIFrameEvent::Action::REGENERATE_FRAMESET_BACKGROUND) {
             setFrames(FOCUS_PRESERVE);
+        }
 
         // Don't regenerate the frameset, just re-draw whatever is on screen ASAP
-        else if (event->action == UIFrameEvent::Action::REDRAW_ONLY)
+        else if (event->action == UIFrameEvent::Action::REDRAW_ONLY) {
             setFastFramerate();
+        }
+
+        // Jump directly to the Text Message screen
+        else if (event->action == UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE) {
+            setFrames(FOCUS_PRESERVE); // preserve current frame ordering
+            ui->switchToFrame(framesetInfo.positions.textMessage);
+            setFastFramerate(); // force redraw ASAP
+        }
     }
 
     return 0;
@@ -1671,7 +1636,48 @@ int Screen::handleInputEvent(const InputEvent *event)
         menuHandler::handleMenuSwitch(dispdev);
         return 0;
     }
+    // UP/DOWN in message screen scrolls through message threads
+    if (ui->getUiState()->currentFrame == framesetInfo.positions.textMessage) {
 
+        if (event->inputEvent == INPUT_BROKER_UP) {
+            if (messageStore.getMessages().empty()) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
+            } else {
+                graphics::MessageRenderer::scrollUp();
+                setFastFramerate(); // match existing behavior
+                return 0;
+            }
+        }
+
+        if (event->inputEvent == INPUT_BROKER_DOWN) {
+            if (messageStore.getMessages().empty()) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
+            } else {
+                graphics::MessageRenderer::scrollDown();
+                setFastFramerate();
+                return 0;
+            }
+        }
+    }
+    // UP/DOWN in node list screens scrolls through node pages
+    if (ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_nodes ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_location ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_lastheard ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_hopsignal ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_distance ||
+        ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_bearings) {
+        if (event->inputEvent == INPUT_BROKER_UP) {
+            graphics::NodeListRenderer::scrollUp();
+            setFastFramerate();
+            return 0;
+        }
+
+        if (event->inputEvent == INPUT_BROKER_DOWN) {
+            graphics::NodeListRenderer::scrollDown();
+            setFastFramerate();
+            return 0;
+        }
+    }
     // Use left or right input from a keyboard to move between frames,
     // so long as a mesh module isn't using these events for some other purpose
     if (showingNormalScreen) {
@@ -1685,16 +1691,39 @@ int Screen::handleInputEvent(const InputEvent *event)
 
         // If no modules are using the input, move between frames
         if (!inputIntercepted) {
+#if defined(INPUTDRIVER_ENCODER_TYPE) && INPUTDRIVER_ENCODER_TYPE == 2
+            bool handledEncoderScroll = false;
+            const bool isTextMessageFrame = (framesetInfo.positions.textMessage != 255 &&
+                                             this->ui->getUiState()->currentFrame == framesetInfo.positions.textMessage &&
+                                             !messageStore.getMessages().empty());
+            if (isTextMessageFrame) {
+                if (event->inputEvent == INPUT_BROKER_UP_LONG) {
+                    graphics::MessageRenderer::nudgeScroll(-1);
+                    handledEncoderScroll = true;
+                } else if (event->inputEvent == INPUT_BROKER_DOWN_LONG) {
+                    graphics::MessageRenderer::nudgeScroll(1);
+                    handledEncoderScroll = true;
+                }
+            }
+
+            if (handledEncoderScroll) {
+                setFastFramerate();
+                return 0;
+            }
+#endif
             if (event->inputEvent == INPUT_BROKER_LEFT || event->inputEvent == INPUT_BROKER_ALT_PRESS) {
-                showPrevFrame();
+                showFrame(FrameDirection::PREVIOUS);
             } else if (event->inputEvent == INPUT_BROKER_RIGHT || event->inputEvent == INPUT_BROKER_USER_PRESS) {
-                showNextFrame();
+                showFrame(FrameDirection::NEXT);
             } else if (event->inputEvent == INPUT_BROKER_UP_LONG) {
                 // Long press up button for fast frame switching
                 showPrevFrame();
             } else if (event->inputEvent == INPUT_BROKER_DOWN_LONG) {
                 // Long press down button for fast frame switching
                 showNextFrame();
+            } else if ((event->inputEvent == INPUT_BROKER_UP || event->inputEvent == INPUT_BROKER_DOWN) &&
+                       this->ui->getUiState()->currentFrame == framesetInfo.positions.home) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST);
             } else if (event->inputEvent == INPUT_BROKER_SELECT) {
                 if (this->ui->getUiState()->currentFrame == framesetInfo.positions.home) {
                     menuHandler::homeBaseMenu();
@@ -1709,20 +1738,21 @@ int Screen::handleInputEvent(const InputEvent *event)
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.lora) {
                     menuHandler::loraMenu();
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.textMessage) {
-                    if (devicestate.rx_text_message.from) {
+                    if (!messageStore.getMessages().empty()) {
                         menuHandler::messageResponseMenu();
                     } else {
-#if defined(M5STACK_UNITC6L)
-                        menuHandler::textMessageMenu();
-#else
-                        menuHandler::textMessageBaseMenu();
-#endif
+                        if (currentResolution == ScreenResolution::UltraLow) {
+                            menuHandler::textMessageMenu();
+                        } else {
+                            menuHandler::textMessageBaseMenu();
+                        }
                     }
                 } else if (framesetInfo.positions.firstFavorite != 255 &&
                            this->ui->getUiState()->currentFrame >= framesetInfo.positions.firstFavorite &&
                            this->ui->getUiState()->currentFrame <= framesetInfo.positions.lastFavorite) {
                     menuHandler::favoriteBaseMenu();
-                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist ||
+                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_nodes ||
+                           this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_location ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_lastheard ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_hopsignal ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_distance ||
@@ -1733,7 +1763,7 @@ int Screen::handleInputEvent(const InputEvent *event)
                     menuHandler::wifiBaseMenu();
                 }
             } else if (event->inputEvent == INPUT_BROKER_BACK) {
-                showPrevFrame();
+                showFrame(FrameDirection::PREVIOUS);
             } else if (event->inputEvent == INPUT_BROKER_CANCEL) {
                 setOn(false);
             }
diff --git a/src/graphics/Screen.h b/src/graphics/Screen.h
index a40579ff5..4bb808970 100644
--- a/src/graphics/Screen.h
+++ b/src/graphics/Screen.h
@@ -40,7 +40,6 @@ class Screen
         FOCUS_DEFAULT,  // No specific frame
         FOCUS_PRESERVE, // Return to the previous frame
         FOCUS_FAULT,
-        FOCUS_TEXTMESSAGE,
         FOCUS_MODULE, // Note: target module should call requestFocus(), otherwise no info about which module to focus
         FOCUS_CLOCK,
         FOCUS_SYSTEM,
@@ -55,8 +54,6 @@ class Screen
     void startFirmwareUpdateScreen() {}
     void increaseBrightness() {}
     void decreaseBrightness() {}
-    void setFunctionSymbol(std::string) {}
-    void removeFunctionSymbol(std::string) {}
     void startAlert(const char *) {}
     void showSimpleBanner(const char *message, uint32_t durationMs = 0) {}
     void showOverlayBanner(BannerOverlayOptions) {}
@@ -172,6 +169,8 @@ class Point
 namespace graphics
 {
 
+enum class FrameDirection { NEXT, PREVIOUS };
+
 // Forward declarations
 class Screen;
 
@@ -211,8 +210,6 @@ class Screen : public concurrency::OSThread
         CallbackObserver<Screen, const meshtastic::Status *>(this, &Screen::handleStatusUpdate);
     CallbackObserver<Screen, const meshtastic::Status *> nodeStatusObserver =
         CallbackObserver<Screen, const meshtastic::Status *>(this, &Screen::handleStatusUpdate);
-    CallbackObserver<Screen, const meshtastic_MeshPacket *> textMessageObserver =
-        CallbackObserver<Screen, const meshtastic_MeshPacket *>(this, &Screen::handleTextMessage);
     CallbackObserver<Screen, const UIFrameEvent *> uiFrameEventObserver =
         CallbackObserver<Screen, const UIFrameEvent *>(this, &Screen::handleUIFrameEvent); // Sent by Mesh Modules
     CallbackObserver<Screen, const InputEvent *> inputObserver =
@@ -223,6 +220,10 @@ class Screen : public concurrency::OSThread
   public:
     OLEDDisplay *getDisplayDevice() { return dispdev; }
     explicit Screen(ScanI2C::DeviceAddress, meshtastic_Config_DisplayConfig_OledType, OLEDDISPLAY_GEOMETRY);
+
+    // Screen dimension accessors
+    inline int getHeight() const { return displayHeight; }
+    inline int getWidth() const { return displayWidth; }
     size_t frameCount = 0; // Total number of active frames
     ~Screen();
 
@@ -231,7 +232,6 @@ class Screen : public concurrency::OSThread
         FOCUS_DEFAULT,  // No specific frame
         FOCUS_PRESERVE, // Return to the previous frame
         FOCUS_FAULT,
-        FOCUS_TEXTMESSAGE,
         FOCUS_MODULE, // Note: target module should call requestFocus(), otherwise no info about which module to focus
         FOCUS_CLOCK,
         FOCUS_SYSTEM,
@@ -279,6 +279,7 @@ class Screen : public concurrency::OSThread
     void onPress() { enqueueCmd(ScreenCmd{.cmd = Cmd::ON_PRESS}); }
     void showPrevFrame() { enqueueCmd(ScreenCmd{.cmd = Cmd::SHOW_PREV_FRAME}); }
     void showNextFrame() { enqueueCmd(ScreenCmd{.cmd = Cmd::SHOW_NEXT_FRAME}); }
+    void showFrame(FrameDirection direction);
 
     // generic alert start
     void startAlert(FrameCallback _alertFrame)
@@ -346,9 +347,6 @@ class Screen : public concurrency::OSThread
     void increaseBrightness();
     void decreaseBrightness();
 
-    void setFunctionSymbol(std::string sym);
-    void removeFunctionSymbol(std::string sym);
-
     /// Stops showing the boot screen.
     void stopBootScreen() { enqueueCmd(ScreenCmd{.cmd = Cmd::STOP_BOOT_SCREEN}); }
 
@@ -579,7 +577,7 @@ class Screen : public concurrency::OSThread
 
     // Handle observer events
     int handleStatusUpdate(const meshtastic::Status *arg);
-    int handleTextMessage(const meshtastic_MeshPacket *arg);
+    int handleTextMessage(const meshtastic_MeshPacket *packet);
     int handleUIFrameEvent(const UIFrameEvent *arg);
     int handleInputEvent(const InputEvent *arg);
     int handleAdminMessage(AdminModule_ObserverData *arg);
@@ -590,9 +588,6 @@ class Screen : public concurrency::OSThread
     /// Draws our SSL cert screen during boot (called from WebServer)
     void setSSLFrames();
 
-    // Dismiss the currently focussed frame, if possible (e.g. text message, waypoint)
-    void hideCurrentFrame();
-
     // Menu-driven Show / Hide Toggle
     void toggleFrameVisibility(const std::string &frameName);
     bool isFrameHidden(const std::string &frameName) const;
@@ -640,8 +635,6 @@ class Screen : public concurrency::OSThread
     // Implementations of various commands, called from doTask().
     void handleSetOn(bool on, FrameCallback einkScreensaver = NULL);
     void handleOnPress();
-    void handleShowNextFrame();
-    void handleShowPrevFrame();
     void handleStartFirmwareUpdateScreen();
 
     // Info collected by setFrames method.
@@ -661,7 +654,8 @@ class Screen : public concurrency::OSThread
             uint8_t gps = 255;
             uint8_t home = 255;
             uint8_t textMessage = 255;
-            uint8_t nodelist = 255;
+            uint8_t nodelist_nodes = 255;
+            uint8_t nodelist_location = 255;
             uint8_t nodelist_lastheard = 255;
             uint8_t nodelist_hopsignal = 255;
             uint8_t nodelist_distance = 255;
@@ -684,7 +678,8 @@ class Screen : public concurrency::OSThread
         bool home = false;
         bool clock = false;
 #ifndef USE_EINK
-        bool nodelist = false;
+        bool nodelist_nodes = false;
+        bool nodelist_location = false;
 #endif
 #ifdef USE_EINK
         bool nodelist_lastheard = false;
@@ -692,7 +687,9 @@ class Screen : public concurrency::OSThread
         bool nodelist_distance = false;
 #endif
 #if HAS_GPS
+#ifdef USE_EINK
         bool nodelist_bearings = false;
+#endif
         bool gps = false;
 #endif
         bool lora = false;
diff --git a/src/graphics/SharedUIDisplay.cpp b/src/graphics/SharedUIDisplay.cpp
index 892285dcb..5660810e6 100644
--- a/src/graphics/SharedUIDisplay.cpp
+++ b/src/graphics/SharedUIDisplay.cpp
@@ -15,27 +15,49 @@
 namespace graphics
 {
 
-void determineResolution(int16_t screenheight, int16_t screenwidth)
+ScreenResolution determineScreenResolution(int16_t screenheight, int16_t screenwidth)
 {
 
 #ifdef FORCE_LOW_RES
-    isHighResolution = false;
-    return;
-#endif
-
-    if (screenwidth > 128) {
-        isHighResolution = true;
+    return ScreenResolution::Low;
+#else
+    // Unit C6L and other ultra low res screens
+    if (screenwidth <= 64 || screenheight <= 48) {
+        return ScreenResolution::UltraLow;
     }
 
+    // Standard OLED screens
     if (screenwidth > 128 && screenheight <= 64) {
-        isHighResolution = false;
+        return ScreenResolution::Low;
     }
+
+    // High Resolutions screens like T114, TDeck, TLora Pager, etc
+    if (screenwidth > 128) {
+        return ScreenResolution::High;
+    }
+
+    // Default to low resolution
+    return ScreenResolution::Low;
+#endif
+}
+
+void decomposeTime(uint32_t rtc_sec, int &hour, int &minute, int &second)
+{
+    hour = 0;
+    minute = 0;
+    second = 0;
+    if (rtc_sec == 0)
+        return;
+    uint32_t hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
+    hour = hms / SEC_PER_HOUR;
+    minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+    second = hms % SEC_PER_MIN;
 }
 
 // === Shared External State ===
 bool hasUnreadMessage = false;
 bool isMuted = false;
-bool isHighResolution = false;
+ScreenResolution currentResolution = ScreenResolution::Low;
 
 // === Internal State ===
 bool isBoltVisibleShared = true;
@@ -91,7 +113,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
             display->setColor(BLACK);
             display->fillRect(0, 0, screenW, highlightHeight + 2);
             display->setColor(WHITE);
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 display->drawLine(0, 20, screenW, 20);
             } else {
                 display->drawLine(0, 14, screenW, 14);
@@ -129,7 +151,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
     }
 #endif
 
-    bool useHorizontalBattery = (isHighResolution && screenW >= screenH);
+    bool useHorizontalBattery = (currentResolution == ScreenResolution::High && screenW >= screenH);
     const int textY = y + (highlightHeight - FONT_HEIGHT_SMALL) / 2;
 
     int batteryX = 1;
@@ -139,7 +161,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
     if (usbPowered && !isCharging) { // This is a basic check to determine USB Powered is flagged but not charging
         batteryX += 1;
         batteryY += 2;
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             display->drawXbm(batteryX, batteryY, 19, 12, imgUSB_HighResolution);
             batteryX += 20; // Icon + 1 pixel
         } else {
@@ -200,8 +222,8 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
     if (rtc_sec > 0) {
         // === Build Time String ===
         long hms = (rtc_sec % SEC_PER_DAY + SEC_PER_DAY) % SEC_PER_DAY;
-        int hour = hms / SEC_PER_HOUR;
-        int minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+        int hour, minute, second;
+        graphics::decomposeTime(rtc_sec, hour, minute, second);
         snprintf(timeStr, sizeof(timeStr), "%d:%02d", hour, minute);
 
         // === Build Date String ===
@@ -209,7 +231,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
         UIRenderer::formatDateTime(datetimeStr, sizeof(datetimeStr), rtc_sec, display, false);
         char dateLine[40];
 
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             snprintf(dateLine, sizeof(dateLine), "%s", datetimeStr);
         } else {
             if (hasUnreadMessage) {
@@ -285,7 +307,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 display->drawXbm(iconX, iconY, mail_width, mail_height, mail);
             }
         } else if (isMuted) {
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
 
@@ -362,7 +384,7 @@ void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const char *ti
                 display->drawXbm(iconX, iconY, mail_width, mail_height, mail);
             }
         } else if (isMuted) {
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 int iconX = iconRightEdge - mute_symbol_big_width;
                 int iconY = textY + (FONT_HEIGHT_SMALL - mute_symbol_big_height) / 2;
                 display->drawXbm(iconX, iconY, mute_symbol_big_width, mute_symbol_big_height, mute_symbol_big);
@@ -381,7 +403,7 @@ const int *getTextPositions(OLEDDisplay *display)
 {
     static int textPositions[7]; // Static array that persists beyond function scope
 
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         textPositions[0] = textZeroLine;
         textPositions[1] = textFirstLine_medium;
         textPositions[2] = textSecondLine_medium;
@@ -414,8 +436,12 @@ void drawCommonFooter(OLEDDisplay *display, int16_t x, int16_t y)
     }
 
     if (drawConnectionState) {
-        if (isHighResolution) {
-            const int scale = 2;
+        const int scale = (currentResolution == ScreenResolution::High) ? 2 : 1;
+        display->setColor(BLACK);
+        display->fillRect(0, SCREEN_HEIGHT - (1 * scale) - (connection_icon_height * scale), (connection_icon_width * scale),
+                          (connection_icon_height * scale) + (2 * scale));
+        display->setColor(WHITE);
+        if (currentResolution == ScreenResolution::High) {
             const int bytesPerRow = (connection_icon_width + 7) / 8;
             int iconX = 0;
             int iconY = SCREEN_HEIGHT - (connection_icon_height * 2);
diff --git a/src/graphics/SharedUIDisplay.h b/src/graphics/SharedUIDisplay.h
index b51dfea36..af0d8dac1 100644
--- a/src/graphics/SharedUIDisplay.h
+++ b/src/graphics/SharedUIDisplay.h
@@ -42,8 +42,11 @@ namespace graphics
 // Shared state (declare inside namespace)
 extern bool hasUnreadMessage;
 extern bool isMuted;
-extern bool isHighResolution;
-void determineResolution(int16_t screenheight, int16_t screenwidth);
+enum class ScreenResolution : uint8_t { UltraLow = 0, Low = 1, High = 2 };
+extern ScreenResolution currentResolution;
+ScreenResolution determineScreenResolution(int16_t screenheight, int16_t screenwidth);
+
+void decomposeTime(uint32_t rtc_sec, int &hour, int &minute, int &second);
 
 // Rounded highlight (used for inverted headers)
 void drawRoundedHighlight(OLEDDisplay *display, int16_t x, int16_t y, int16_t w, int16_t h, int16_t r);
diff --git a/src/graphics/VirtualKeyboard.cpp b/src/graphics/VirtualKeyboard.cpp
index a332aad9a..a24f5b15c 100644
--- a/src/graphics/VirtualKeyboard.cpp
+++ b/src/graphics/VirtualKeyboard.cpp
@@ -354,8 +354,6 @@ void VirtualKeyboard::drawInputArea(OLEDDisplay *display, int16_t offsetX, int16
         if (screenHeight <= 64) {
             textY = boxY + (boxHeight - inputLineH) / 2;
         } else {
-            const int innerLeft = boxX + 1;
-            const int innerRight = boxX + boxWidth - 2;
             const int innerTop = boxY + 1;
             const int innerBottom = boxY + boxHeight - 2;
 
diff --git a/src/graphics/draw/ClockRenderer.cpp b/src/graphics/draw/ClockRenderer.cpp
index cc6a70957..66bbe1bfe 100644
--- a/src/graphics/draw/ClockRenderer.cpp
+++ b/src/graphics/draw/ClockRenderer.cpp
@@ -1,15 +1,10 @@
 #include "configuration.h"
 #if HAS_SCREEN
 #include "ClockRenderer.h"
-#include "NodeDB.h"
-#include "UIRenderer.h"
-#include "configuration.h"
-#include "gps/GeoCoord.h"
 #include "gps/RTC.h"
 #include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
 #include "graphics/draw/UIRenderer.h"
-#include "graphics/emotes.h"
 #include "graphics/images.h"
 #include "main.h"
 
@@ -23,6 +18,31 @@ namespace graphics
 namespace ClockRenderer
 {
 
+// Segment bitmaps for numerals 0-9 stored in flash to save RAM.
+// Each row is a digit, each column is a segment state (1 = on, 0 = off).
+// Segment layout reference:
+//
+//             ___1___
+//           6 |     | 2
+//             |_7___|
+//           5 |     | 3
+//             |___4_|
+//
+// Segment order: [1, 2, 3, 4, 5, 6, 7]
+//
+static const uint8_t PROGMEM digitSegments[10][7] = {
+    {1, 1, 1, 1, 1, 1, 0}, // 0
+    {0, 1, 1, 0, 0, 0, 0}, // 1
+    {1, 1, 0, 1, 1, 0, 1}, // 2
+    {1, 1, 1, 1, 0, 0, 1}, // 3
+    {0, 1, 1, 0, 0, 1, 1}, // 4
+    {1, 0, 1, 1, 0, 1, 1}, // 5
+    {1, 0, 1, 1, 1, 1, 1}, // 6
+    {1, 1, 1, 0, 0, 1, 0}, // 7
+    {1, 1, 1, 1, 1, 1, 1}, // 8
+    {1, 1, 1, 1, 0, 1, 1}  // 9
+};
+
 void drawSegmentedDisplayColon(OLEDDisplay *display, int x, int y, float scale)
 {
     uint16_t segmentWidth = SEGMENT_WIDTH * scale;
@@ -30,7 +50,7 @@ void drawSegmentedDisplayColon(OLEDDisplay *display, int x, int y, float scale)
 
     uint16_t cellHeight = (segmentWidth * 2) + (segmentHeight * 3) + 8;
 
-    uint16_t topAndBottomX = x + (4 * scale);
+    uint16_t topAndBottomX = x + static_cast<uint16_t>(4 * scale);
 
     uint16_t quarterCellHeight = cellHeight / 4;
 
@@ -43,34 +63,16 @@ void drawSegmentedDisplayColon(OLEDDisplay *display, int x, int y, float scale)
 
 void drawSegmentedDisplayCharacter(OLEDDisplay *display, int x, int y, uint8_t number, float scale)
 {
-    // the numbers 0-9, each expressed as an array of seven boolean (0|1) values encoding the on/off state of
-    // segment {innerIndex + 1}
-    // e.g., to display the numeral '0', segments 1-6 are on, and segment 7 is off.
-    uint8_t numbers[10][7] = {
-        {1, 1, 1, 1, 1, 1, 0}, // 0          Display segment key
-        {0, 1, 1, 0, 0, 0, 0}, // 1                   1
-        {1, 1, 0, 1, 1, 0, 1}, // 2                  ___
-        {1, 1, 1, 1, 0, 0, 1}, // 3              6  |   | 2
-        {0, 1, 1, 0, 0, 1, 1}, // 4                 |_7̲_|
-        {1, 0, 1, 1, 0, 1, 1}, // 5              5  |   | 3
-        {1, 0, 1, 1, 1, 1, 1}, // 6                 |___|
-        {1, 1, 1, 0, 0, 1, 0}, // 7
-        {1, 1, 1, 1, 1, 1, 1}, // 8                   4
-        {1, 1, 1, 1, 0, 1, 1}, // 9
-    };
-
-    // the width and height of each segment's central rectangle:
-    //             _____________________
-    //           ⋰|  (only this part,  |⋱
-    //         ⋰  |   not including    |  ⋱
-    //         ⋱  |   the triangles    |  ⋰
-    //           ⋱|    on the ends)    |⋰
-    //             ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+    // Read 7-segment pattern for the digit from flash
+    uint8_t seg[7];
+    for (uint8_t i = 0; i < 7; i++) {
+        seg[i] = pgm_read_byte(&digitSegments[number][i]);
+    }
 
     uint16_t segmentWidth = SEGMENT_WIDTH * scale;
     uint16_t segmentHeight = SEGMENT_HEIGHT * scale;
 
-    // segment x and y coordinates
+    // Precompute segment positions
     uint16_t segmentOneX = x + segmentHeight + 2;
     uint16_t segmentOneY = y;
 
@@ -92,33 +94,21 @@ void drawSegmentedDisplayCharacter(OLEDDisplay *display, int x, int y, uint8_t n
     uint16_t segmentSevenX = segmentOneX;
     uint16_t segmentSevenY = segmentTwoY + segmentWidth + 2;
 
-    if (numbers[number][0]) {
-        graphics::ClockRenderer::drawHorizontalSegment(display, segmentOneX, segmentOneY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][1]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentTwoX, segmentTwoY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][2]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentThreeX, segmentThreeY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][3]) {
-        graphics::ClockRenderer::drawHorizontalSegment(display, segmentFourX, segmentFourY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][4]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentFiveX, segmentFiveY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][5]) {
-        graphics::ClockRenderer::drawVerticalSegment(display, segmentSixX, segmentSixY, segmentWidth, segmentHeight);
-    }
-
-    if (numbers[number][6]) {
-        graphics::ClockRenderer::drawHorizontalSegment(display, segmentSevenX, segmentSevenY, segmentWidth, segmentHeight);
-    }
+    // Draw only the active segments
+    if (seg[0])
+        drawHorizontalSegment(display, segmentOneX, segmentOneY, segmentWidth, segmentHeight);
+    if (seg[1])
+        drawVerticalSegment(display, segmentTwoX, segmentTwoY, segmentWidth, segmentHeight);
+    if (seg[2])
+        drawVerticalSegment(display, segmentThreeX, segmentThreeY, segmentWidth, segmentHeight);
+    if (seg[3])
+        drawHorizontalSegment(display, segmentFourX, segmentFourY, segmentWidth, segmentHeight);
+    if (seg[4])
+        drawVerticalSegment(display, segmentFiveX, segmentFiveY, segmentWidth, segmentHeight);
+    if (seg[5])
+        drawVerticalSegment(display, segmentSixX, segmentSixY, segmentWidth, segmentHeight);
+    if (seg[6])
+        drawHorizontalSegment(display, segmentSevenX, segmentSevenY, segmentWidth, segmentHeight);
 }
 
 void drawHorizontalSegment(OLEDDisplay *display, int x, int y, int width, int height)
@@ -147,42 +137,6 @@ void drawVerticalSegment(OLEDDisplay *display, int x, int y, int width, int heig
     display->fillTriangle(x, y + width, x + height - 1, y + width, x + halfHeight, y + width + halfHeight);
 }
 
-/*
-void drawWatchFaceToggleButton(OLEDDisplay *display, int16_t x, int16_t y, bool digitalMode, float scale)
-{
-    uint16_t segmentWidth = SEGMENT_WIDTH * scale;
-    uint16_t segmentHeight = SEGMENT_HEIGHT * scale;
-
-    if (digitalMode) {
-        uint16_t radius = (segmentWidth + (segmentHeight * 2) + 4) / 2;
-        uint16_t centerX = (x + segmentHeight + 2) + (radius / 2);
-        uint16_t centerY = (y + segmentHeight + 2) + (radius / 2);
-
-        display->drawCircle(centerX, centerY, radius);
-        display->drawCircle(centerX, centerY, radius + 1);
-        display->drawLine(centerX, centerY, centerX, centerY - radius + 3);
-        display->drawLine(centerX, centerY, centerX + radius - 3, centerY);
-    } else {
-        uint16_t segmentOneX = x + segmentHeight + 2;
-        uint16_t segmentOneY = y;
-
-        uint16_t segmentTwoX = segmentOneX + segmentWidth + 2;
-        uint16_t segmentTwoY = segmentOneY + segmentHeight + 2;
-
-        uint16_t segmentThreeX = segmentOneX;
-        uint16_t segmentThreeY = segmentTwoY + segmentWidth + 2;
-
-        uint16_t segmentFourX = x;
-        uint16_t segmentFourY = y + segmentHeight + 2;
-
-        drawHorizontalSegment(display, segmentOneX, segmentOneY, segmentWidth, segmentHeight);
-        drawVerticalSegment(display, segmentTwoX, segmentTwoY, segmentWidth, segmentHeight);
-        drawHorizontalSegment(display, segmentThreeX, segmentThreeY, segmentWidth, segmentHeight);
-        drawVerticalSegment(display, segmentFourX, segmentFourY, segmentWidth, segmentHeight);
-    }
-}
-*/
-// Draw a digital clock
 void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     display->clear();
@@ -192,7 +146,6 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
     const char *titleStr = "";
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr, true, true);
-    int line = 0;
 
     uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // Display local timezone
     char timeString[16];
@@ -237,7 +190,7 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
         float target_width = display->getWidth() * screenwidth_target_ratio;
         float target_height =
             display->getHeight() -
-            (isHighResolution
+            ((currentResolution == ScreenResolution::High)
                  ? 46
                  : 33); // Be careful adjusting this number, we have to account for header and the text under the time
 
@@ -268,10 +221,9 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
         scaleInitialized = true;
     }
 
-    size_t len = strlen(timeString);
-
     // calculate hours:minutes string width
-    uint16_t timeStringWidth = len * 5; // base spacing between characters
+    size_t len = strlen(timeString);
+    uint16_t timeStringWidth = len * 5;
 
     for (size_t i = 0; i < len; i++) {
         char character = timeString[i];
@@ -310,9 +262,16 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
 
     // draw seconds string + AM/PM
     display->setFont(FONT_SMALL);
-    int xOffset = (isHighResolution) ? 0 : -1;
+    int xOffset = -1;
+    if (currentResolution == ScreenResolution::High) {
+        xOffset = 0;
+    }
     if (hour >= 10) {
-        xOffset += (isHighResolution) ? 32 : 18;
+        if (currentResolution == ScreenResolution::High) {
+            xOffset += 32;
+        } else {
+            xOffset += 18;
+        }
     }
 
     if (config.display.use_12h_clock) {
@@ -320,7 +279,7 @@ void drawDigitalClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int1
     }
 
 #ifndef USE_EINK
-    xOffset = (isHighResolution) ? 18 : 10;
+    xOffset = (currentResolution == ScreenResolution::High) ? 18 : 10;
     if (scale >= 2.0f) {
         xOffset -= (int)(4.5f * scale);
     }
@@ -339,19 +298,13 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     const char *titleStr = "";
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr, true, true);
-    int line = 0;
 
     // clock face center coordinates
     int16_t centerX = display->getWidth() / 2;
     int16_t centerY = display->getHeight() / 2;
 
     // clock face radius
-    int16_t radius = 0;
-    if (display->getHeight() < display->getWidth()) {
-        radius = (display->getHeight() / 2) * 0.9;
-    } else {
-        radius = (display->getWidth() / 2) * 0.9;
-    }
+    int16_t radius = (std::min(display->getWidth(), display->getHeight()) / 2) * 0.9;
 #ifdef T_WATCH_S3
     radius = (display->getWidth() / 2) * 0.8;
 #endif
@@ -366,17 +319,8 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     // tick mark outer y coordinate; (first nested circle)
     int16_t tickMarkOuterNoonY = secondHandNoonY;
 
-    // seconds tick mark inner y coordinate; (second nested circle)
-    double secondsTickMarkInnerNoonY = (double)noonY + 4;
-    if (isHighResolution) {
-        secondsTickMarkInnerNoonY = (double)noonY + 8;
-    }
-
-    // hours tick mark inner y coordinate; (third nested circle)
-    double hoursTickMarkInnerNoonY = (double)noonY + 6;
-    if (isHighResolution) {
-        hoursTickMarkInnerNoonY = (double)noonY + 16;
-    }
+    double secondsTickMarkInnerNoonY = noonY + ((currentResolution == ScreenResolution::High) ? 8 : 4);
+    double hoursTickMarkInnerNoonY = noonY + ((currentResolution == ScreenResolution::High) ? 16 : 6);
 
     // minute hand y coordinate
     int16_t minuteHandNoonY = secondsTickMarkInnerNoonY + 4;
@@ -386,7 +330,7 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 
     // hour hand radius and y coordinate
     int16_t hourHandRadius = radius * 0.35;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         hourHandRadius = radius * 0.55;
     }
     int16_t hourHandNoonY = centerY - hourHandRadius;
@@ -396,19 +340,13 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 
     uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityDevice, true); // Display local timezone
     if (rtc_sec > 0) {
-        long hms = rtc_sec % SEC_PER_DAY;
-        hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
+        int hour, minute, second;
+        decomposeTime(rtc_sec, hour, minute, second);
 
-        // Tear apart hms into h:m:s
-        int hour = hms / SEC_PER_HOUR;
-        int minute = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-        int second = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
-
-        bool isPM = hour >= 12;
         if (config.display.use_12h_clock) {
-            isPM = hour >= 12;
+            bool isPM = hour >= 12;
             display->setFont(FONT_SMALL);
-            int yOffset = isHighResolution ? 1 : 0;
+            int yOffset = (currentResolution == ScreenResolution::High) ? 1 : 0;
 #ifdef USE_EINK
             yOffset += 3;
 #endif
@@ -499,12 +437,13 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                 display->drawStringf(hourStringX, hourStringY, buffer, "%d", hourInt);
 #else
 #ifdef USE_EINK
-                if (isHighResolution) {
+                if (currentResolution == ScreenResolution::High) {
                     // draw hour number
                     display->drawStringf(hourStringX, hourStringY, buffer, "%d", hourInt);
                 }
 #else
-                if (isHighResolution && (hourInt == 3 || hourInt == 6 || hourInt == 9 || hourInt == 12)) {
+                if (currentResolution == ScreenResolution::High &&
+                    (hourInt == 3 || hourInt == 6 || hourInt == 9 || hourInt == 12)) {
                     // draw hour number
                     display->drawStringf(hourStringX, hourStringY, buffer, "%d", hourInt);
                 }
@@ -516,7 +455,7 @@ void drawAnalogClockFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                 double startX = sineAngleInRadians * (secondsTickMarkInnerNoonY - centerY) + noonX;
                 double startY = cosineAngleInRadians * (secondsTickMarkInnerNoonY - centerY) + centerY;
 
-                if (isHighResolution) {
+                if (currentResolution == ScreenResolution::High) {
                     // draw minute tick mark
                     display->drawLine(startX, startY, endX, endY);
                 }
diff --git a/src/graphics/draw/CompassRenderer.cpp b/src/graphics/draw/CompassRenderer.cpp
index 629949ffd..42600ce96 100644
--- a/src/graphics/draw/CompassRenderer.cpp
+++ b/src/graphics/draw/CompassRenderer.cpp
@@ -48,7 +48,7 @@ void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY,
     // This could draw a "N" indicator or north arrow
     // For now, we'll draw a simple north indicator
     // const float radius = 17.0f;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         radius += 4;
     }
     Point north(0, -radius);
@@ -59,7 +59,7 @@ void drawCompassNorth(OLEDDisplay *display, int16_t compassX, int16_t compassY,
     display->setFont(FONT_SMALL);
     display->setTextAlignment(TEXT_ALIGN_CENTER);
     display->setColor(BLACK);
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->fillRect(north.x - 8, north.y - 1, display->getStringWidth("N") + 3, FONT_HEIGHT_SMALL - 6);
     } else {
         display->fillRect(north.x - 4, north.y - 1, display->getStringWidth("N") + 2, FONT_HEIGHT_SMALL - 6);
diff --git a/src/graphics/draw/DebugRenderer.cpp b/src/graphics/draw/DebugRenderer.cpp
index ceb3b83f5..75b65c65f 100644
--- a/src/graphics/draw/DebugRenderer.cpp
+++ b/src/graphics/draw/DebugRenderer.cpp
@@ -282,13 +282,13 @@ void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
     std::string uptime = UIRenderer::drawTimeDelta(days, hours, minutes, seconds);
 
     // Line 1 (Still)
-#if !defined(M5STACK_UNITC6L)
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
-    if (config.display.heading_bold)
-        display->drawString(x - 1 + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
+    if (currentResolution != graphics::ScreenResolution::UltraLow) {
+        display->drawString(x + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
+        if (config.display.heading_bold)
+            display->drawString(x - 1 + SCREEN_WIDTH - display->getStringWidth(uptime.c_str()), y, uptime.c_str());
 
-    display->setColor(WHITE);
-#endif
+        display->setColor(WHITE);
+    }
     // Setup string to assemble analogClock string
     std::string analogClock = "";
 
@@ -301,9 +301,8 @@ void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
         hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
 
         // Tear apart hms into h:m:s
-        int hour = hms / SEC_PER_HOUR;
-        int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-        int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+        int hour, min, sec;
+        graphics::decomposeTime(rtc_sec, hour, min, sec);
 
         char timebuf[12];
 
@@ -379,7 +378,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     int line = 1;
 
     // === Set Title
-    const char *titleStr = (isHighResolution) ? "LoRa Info" : "LoRa";
+    const char *titleStr = (currentResolution == ScreenResolution::High) ? "LoRa Info" : "LoRa";
 
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr);
@@ -391,11 +390,11 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     char shortnameble[35];
     getMacAddr(dmac);
     snprintf(screen->ourId, sizeof(screen->ourId), "%02x%02x", dmac[4], dmac[5]);
-#if defined(M5STACK_UNITC6L)
-    snprintf(shortnameble, sizeof(shortnameble), "%s", screen->ourId);
-#else
-    snprintf(shortnameble, sizeof(shortnameble), "BLE: %s", screen->ourId);
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        snprintf(shortnameble, sizeof(shortnameble), "%s", screen->ourId);
+    } else {
+        snprintf(shortnameble, sizeof(shortnameble), "BLE: %s", screen->ourId);
+    }
     int textWidth = display->getStringWidth(shortnameble);
     int nameX = (SCREEN_WIDTH - textWidth);
     display->drawString(nameX, getTextPositions(display)[line++], shortnameble);
@@ -414,11 +413,11 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     char regionradiopreset[25];
     const char *region = myRegion ? myRegion->name : NULL;
     if (region != nullptr) {
-#if defined(M5STACK_UNITC6L)
-        snprintf(regionradiopreset, sizeof(regionradiopreset), "%s", region);
-#else
-        snprintf(regionradiopreset, sizeof(regionradiopreset), "%s/%s", region, mode);
-#endif
+        if (currentResolution == ScreenResolution::UltraLow) {
+            snprintf(regionradiopreset, sizeof(regionradiopreset), "%s", region);
+        } else {
+            snprintf(regionradiopreset, sizeof(regionradiopreset), "%s/%s", region, mode);
+        }
     }
     textWidth = display->getStringWidth(regionradiopreset);
     nameX = (SCREEN_WIDTH - textWidth) / 2;
@@ -430,17 +429,17 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     float freq = RadioLibInterface::instance->getFreq();
     snprintf(freqStr, sizeof(freqStr), "%.3f", freq);
     if (config.lora.channel_num == 0) {
-#if defined(M5STACK_UNITC6L)
-        snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz", freqStr);
-#else
-        snprintf(frequencyslot, sizeof(frequencyslot), "Freq: %sMHz", freqStr);
-#endif
+        if (currentResolution == ScreenResolution::UltraLow) {
+            snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz", freqStr);
+        } else {
+            snprintf(frequencyslot, sizeof(frequencyslot), "Freq: %sMHz", freqStr);
+        }
     } else {
-#if defined(M5STACK_UNITC6L)
-        snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz (%d)", freqStr, config.lora.channel_num);
-#else
-        snprintf(frequencyslot, sizeof(frequencyslot), "Freq/Ch: %sMHz (%d)", freqStr, config.lora.channel_num);
-#endif
+        if (currentResolution == ScreenResolution::UltraLow) {
+            snprintf(frequencyslot, sizeof(frequencyslot), "%sMHz (%d)", freqStr, config.lora.channel_num);
+        } else {
+            snprintf(frequencyslot, sizeof(frequencyslot), "Freq/Ch: %sMHz (%d)", freqStr, config.lora.channel_num);
+        }
     }
     size_t len = strlen(frequencyslot);
     if (len >= 4 && strcmp(frequencyslot + len - 4, " (0)") == 0) {
@@ -456,12 +455,13 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     char chUtilPercentage[10];
     snprintf(chUtilPercentage, sizeof(chUtilPercentage), "%2.0f%%", airTime->channelUtilizationPercent());
 
-    int chUtil_x = (isHighResolution) ? display->getStringWidth(chUtil) + 10 : display->getStringWidth(chUtil) + 5;
+    int chUtil_x = (currentResolution == ScreenResolution::High) ? display->getStringWidth(chUtil) + 10
+                                                                 : display->getStringWidth(chUtil) + 5;
     int chUtil_y = getTextPositions(display)[line] + 3;
 
-    int chutil_bar_width = (isHighResolution) ? 100 : 50;
-    int chutil_bar_height = (isHighResolution) ? 12 : 7;
-    int extraoffset = (isHighResolution) ? 6 : 3;
+    int chutil_bar_width = (currentResolution == ScreenResolution::High) ? 100 : 50;
+    int chutil_bar_height = (currentResolution == ScreenResolution::High) ? 12 : 7;
+    int extraoffset = (currentResolution == ScreenResolution::High) ? 6 : 3;
     int chutil_percent = airTime->channelUtilizationPercent();
 
     int centerofscreen = SCREEN_WIDTH / 2;
@@ -530,17 +530,18 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
     int line = 1;
     const int barHeight = 6;
     const int labelX = x;
-    int barsOffset = (isHighResolution) ? 24 : 0;
+    int barsOffset = (currentResolution == ScreenResolution::High) ? 24 : 0;
 #ifdef USE_EINK
 #ifndef T_DECK_PRO
     barsOffset -= 12;
 #endif
 #endif
-#if defined(M5STACK_UNITC6L)
-    const int barX = x + 45 + barsOffset;
-#else
-    const int barX = x + 40 + barsOffset;
-#endif
+    int barX = x + barsOffset;
+    if (currentResolution == ScreenResolution::UltraLow) {
+        barX += 45;
+    } else {
+        barX += 40;
+    }
     auto drawUsageRow = [&](const char *label, uint32_t used, uint32_t total, bool isHeap = false) {
         if (total == 0)
             return;
@@ -548,7 +549,7 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
         int percent = (used * 100) / total;
 
         char combinedStr[24];
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             snprintf(combinedStr, sizeof(combinedStr), "%s%3d%%  %u/%uKB", (percent > 80) ? "! " : "", percent, used / 1024,
                      total / 1024);
         } else {
@@ -628,25 +629,33 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
     line += 1;
 
     char appversionstr[35];
-    snprintf(appversionstr, sizeof(appversionstr), "Ver: %s", optstr(APP_VERSION));
     char appversionstr_formatted[40];
-    char *lastDot = strrchr(appversionstr, '.');
-#if defined(M5STACK_UNITC6L)
-    if (lastDot != nullptr) {
-        *lastDot = '\0'; // truncate string
+
+    const char *ver = optstr(APP_VERSION);
+    char verbuf[32];
+    strncpy(verbuf, ver, sizeof(verbuf) - 1);
+    verbuf[sizeof(verbuf) - 1] = '\0';
+
+    char *lastDot = strrchr(verbuf, '.');
+
+    if (currentResolution == ScreenResolution::UltraLow) {
+        if (lastDot != nullptr) {
+            *lastDot = '\0';
+        }
+        snprintf(appversionstr, sizeof(appversionstr), "Ver: %s", verbuf);
+    } else {
+        if (lastDot) {
+            size_t prefixLen = (size_t)(lastDot - verbuf);
+            snprintf(appversionstr_formatted, sizeof(appversionstr_formatted), "Ver: %.*s", (int)prefixLen, verbuf);
+            strncat(appversionstr_formatted, " (", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
+            strncat(appversionstr_formatted, lastDot + 1, sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
+            strncat(appversionstr_formatted, ")", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
+            strncpy(appversionstr, appversionstr_formatted, sizeof(appversionstr) - 1);
+            appversionstr[sizeof(appversionstr) - 1] = '\0';
+        } else {
+            snprintf(appversionstr, sizeof(appversionstr), "Ver: %s", verbuf);
+        }
     }
-#else
-    if (lastDot) {
-        size_t prefixLen = lastDot - appversionstr;
-        strncpy(appversionstr_formatted, appversionstr, prefixLen);
-        appversionstr_formatted[prefixLen] = '\0';
-        strncat(appversionstr_formatted, " (", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
-        strncat(appversionstr_formatted, lastDot + 1, sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
-        strncat(appversionstr_formatted, ")", sizeof(appversionstr_formatted) - strlen(appversionstr_formatted) - 1);
-        strncpy(appversionstr, appversionstr_formatted, sizeof(appversionstr) - 1);
-        appversionstr[sizeof(appversionstr) - 1] = '\0';
-    }
-#endif
     int textWidth = display->getStringWidth(appversionstr);
     int nameX = (SCREEN_WIDTH - textWidth) / 2;
 
@@ -665,7 +674,7 @@ void drawSystemScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x
         const char *clientWord = nullptr;
 
         // Determine if narrow or wide screen
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             clientWord = "Client";
         } else {
             clientWord = "App";
@@ -706,11 +715,23 @@ void drawChirpy(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int1
     int iconX = SCREEN_WIDTH - chirpy_width - (chirpy_width / 3);
     int iconY = (SCREEN_HEIGHT - chirpy_height) / 2;
     int textX_offset = 10;
-    if (isHighResolution) {
-        iconX = SCREEN_WIDTH - chirpy_width_hirez - (chirpy_width_hirez / 3);
-        iconY = (SCREEN_HEIGHT - chirpy_height_hirez) / 2;
+    if (currentResolution == ScreenResolution::High) {
         textX_offset = textX_offset * 4;
-        display->drawXbm(iconX, iconY, chirpy_width_hirez, chirpy_height_hirez, chirpy_hirez);
+        const int scale = 2;
+        const int bytesPerRow = (chirpy_width + 7) / 8;
+
+        for (int yy = 0; yy < chirpy_height; ++yy) {
+            iconX = SCREEN_WIDTH - (chirpy_width * 2) - ((chirpy_width * 2) / 3);
+            iconY = (SCREEN_HEIGHT - (chirpy_height * 2)) / 2;
+            const uint8_t *rowPtr = chirpy + yy * bytesPerRow;
+            for (int xx = 0; xx < chirpy_width; ++xx) {
+                const uint8_t byteVal = pgm_read_byte(rowPtr + (xx >> 3));
+                const uint8_t bitMask = 1U << (xx & 7); // XBM is LSB-first
+                if (byteVal & bitMask) {
+                    display->fillRect(iconX + xx * scale, iconY + yy * scale, scale, scale);
+                }
+            }
+        }
     } else {
         display->drawXbm(iconX, iconY, chirpy_width, chirpy_height, chirpy);
     }
diff --git a/src/graphics/draw/DrawRenderers.h b/src/graphics/draw/DrawRenderers.h
index 6f1929ebd..c55e66ede 100644
--- a/src/graphics/draw/DrawRenderers.h
+++ b/src/graphics/draw/DrawRenderers.h
@@ -11,7 +11,6 @@
 #include "graphics/draw/CompassRenderer.h"
 #include "graphics/draw/DebugRenderer.h"
 #include "graphics/draw/NodeListRenderer.h"
-#include "graphics/draw/ScreenRenderer.h"
 #include "graphics/draw/UIRenderer.h"
 
 namespace graphics
@@ -30,8 +29,6 @@ using namespace ClockRenderer;
 using namespace CompassRenderer;
 using namespace DebugRenderer;
 using namespace NodeListRenderer;
-using namespace ScreenRenderer;
-using namespace UIRenderer;
 
 } // namespace DrawRenderers
 
diff --git a/src/graphics/draw/MenuHandler.cpp b/src/graphics/draw/MenuHandler.cpp
index 586bdd4a6..ac877e150 100644
--- a/src/graphics/draw/MenuHandler.cpp
+++ b/src/graphics/draw/MenuHandler.cpp
@@ -1,14 +1,17 @@
 #include "configuration.h"
 #if HAS_SCREEN
 #include "ClockRenderer.h"
+#include "Default.h"
 #include "GPS.h"
 #include "MenuHandler.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "buzz.h"
 #include "graphics/Screen.h"
 #include "graphics/SharedUIDisplay.h"
+#include "graphics/draw/MessageRenderer.h"
 #include "graphics/draw/UIRenderer.h"
 #include "input/RotaryEncoderInterruptImpl1.h"
 #include "input/UpDownInterruptImpl1.h"
@@ -134,11 +137,10 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
                                          "NP_865",
                                          "BR_902"};
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "LoRa Region";
-#else
     bannerOptions.message = "Set the LoRa region";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "LoRa Region";
+    }
     bannerOptions.durationMs = duration;
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = 27;
@@ -426,60 +428,415 @@ void menuHandler::clockMenu()
     };
     screen->showOverlayBanner(bannerOptions);
 }
-
 void menuHandler::messageResponseMenu()
 {
-    enum optionsNumbers { Back = 0, Dismiss = 1, Preset = 2, Freetext = 3, Aloud = 4, enumEnd = 5 };
-#if defined(M5STACK_UNITC6L)
-    static const char *optionsArray[enumEnd] = {"Back", "Dismiss", "Reply Preset"};
-#else
-    static const char *optionsArray[enumEnd] = {"Back", "Dismiss", "Reply via Preset"};
-#endif
-    static int optionsEnumArray[enumEnd] = {Back, Dismiss, Preset};
-    int options = 3;
+    enum optionsNumbers { Back = 0, ViewMode, DeleteAll, DeleteOldest, ReplyMenu, Aloud, enumEnd };
 
-    if (kb_found) {
-        optionsArray[options] = "Reply via Freetext";
-        optionsEnumArray[options++] = Freetext;
-    }
+    static const char *optionsArray[enumEnd];
+    static int optionsEnumArray[enumEnd];
+    int options = 0;
+
+    auto mode = graphics::MessageRenderer::getThreadMode();
+
+    optionsArray[options] = "Back";
+    optionsEnumArray[options++] = Back;
+
+    // New Reply submenu (replaces Preset and Freetext directly in this menu)
+    optionsArray[options] = "Reply";
+    optionsEnumArray[options++] = ReplyMenu;
+
+    optionsArray[options] = "View Chats";
+    optionsEnumArray[options++] = ViewMode;
+
+    // Delete submenu
+    optionsArray[options] = "Delete";
+    optionsEnumArray[options++] = 900;
 
 #ifdef HAS_I2S
     optionsArray[options] = "Read Aloud";
     optionsEnumArray[options++] = Aloud;
 #endif
+
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Message";
-#else
-    bannerOptions.message = "Message Action";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Message";
+    } else {
+        bannerOptions.message = "Message Action";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsEnumPtr = optionsEnumArray;
     bannerOptions.optionsCount = options;
     bannerOptions.bannerCallback = [](int selected) -> void {
-        if (selected == Dismiss) {
-            screen->hideCurrentFrame();
-        } else if (selected == Preset) {
-            if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
-                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
-            } else {
-                cannedMessageModule->LaunchWithDestination(devicestate.rx_text_message.from);
+        LOG_DEBUG("messageResponseMenu: selected %d", selected);
+
+        auto mode = graphics::MessageRenderer::getThreadMode();
+        int ch = graphics::MessageRenderer::getThreadChannel();
+        uint32_t peer = graphics::MessageRenderer::getThreadPeer();
+
+        LOG_DEBUG("[ReplyCtx] mode=%d ch=%d peer=0x%08x", (int)mode, ch, (unsigned int)peer);
+
+        if (selected == ViewMode) {
+            menuHandler::menuQueue = menuHandler::message_viewmode_menu;
+            screen->runNow();
+
+            // Reply submenu
+        } else if (selected == ReplyMenu) {
+            menuHandler::menuQueue = menuHandler::reply_menu;
+            screen->runNow();
+
+            // Delete submenu
+        } else if (selected == 900) {
+            menuHandler::menuQueue = menuHandler::delete_messages_menu;
+            screen->runNow();
+
+            // Delete oldest FIRST (only change)
+        } else if (selected == DeleteOldest) {
+            auto mode = graphics::MessageRenderer::getThreadMode();
+            int ch = graphics::MessageRenderer::getThreadChannel();
+            uint32_t peer = graphics::MessageRenderer::getThreadPeer();
+
+            if (mode == graphics::MessageRenderer::ThreadMode::ALL) {
+                // Global oldest
+                messageStore.deleteOldestMessage();
+            } else if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+                // Oldest in current channel
+                messageStore.deleteOldestMessageInChannel(ch);
+            } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+                // Oldest in current DM
+                messageStore.deleteOldestMessageWithPeer(peer);
             }
-        } else if (selected == Freetext) {
-            if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
-                cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
-            } else {
-                cannedMessageModule->LaunchFreetextWithDestination(devicestate.rx_text_message.from);
-            }
-        }
+
+            // Delete all messages
+        } else if (selected == DeleteAll) {
+            messageStore.clearAllMessages();
+            graphics::MessageRenderer::clearThreadRegistries();
+            graphics::MessageRenderer::clearMessageCache();
+
 #ifdef HAS_I2S
-        else if (selected == Aloud) {
+        } else if (selected == Aloud) {
             const meshtastic_MeshPacket &mp = devicestate.rx_text_message;
             const char *msg = reinterpret_cast<const char *>(mp.decoded.payload.bytes);
-
             audioThread->readAloud(msg);
-        }
 #endif
+        }
+    };
+    screen->showOverlayBanner(bannerOptions);
+}
+
+void menuHandler::replyMenu()
+{
+    enum replyOptions { Back = 0, ReplyPreset, ReplyFreetext, enumEnd };
+
+    static const char *optionsArray[enumEnd];
+    static int optionsEnumArray[enumEnd];
+    int options = 0;
+
+    // Back
+    optionsArray[options] = "Back";
+    optionsEnumArray[options++] = Back;
+
+    // Preset reply
+    optionsArray[options] = "With Preset";
+    optionsEnumArray[options++] = ReplyPreset;
+
+    // Freetext reply (only when keyboard exists)
+    if (kb_found) {
+        optionsArray[options] = "With Freetext";
+        optionsEnumArray[options++] = ReplyFreetext;
+    }
+
+    BannerOverlayOptions bannerOptions;
+
+    // Dynamic title based on thread mode
+    auto mode = graphics::MessageRenderer::getThreadMode();
+    if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+        bannerOptions.message = "Reply to Channel";
+    } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+        bannerOptions.message = "Reply to DM";
+    } else {
+        // View All
+        bannerOptions.message = "Reply to Last Msg";
+    }
+
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsEnumPtr = optionsEnumArray;
+    bannerOptions.optionsCount = options;
+    bannerOptions.InitialSelected = 1;
+
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        auto mode = graphics::MessageRenderer::getThreadMode();
+        int ch = graphics::MessageRenderer::getThreadChannel();
+        uint32_t peer = graphics::MessageRenderer::getThreadPeer();
+
+        if (selected == Back) {
+            menuHandler::menuQueue = menuHandler::message_response_menu;
+            screen->runNow();
+            return;
+        }
+
+        // Preset reply
+        if (selected == ReplyPreset) {
+
+            if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+                cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, ch);
+
+            } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+                cannedMessageModule->LaunchWithDestination(peer);
+
+            } else {
+                // Fallback for last received message
+                if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
+                    cannedMessageModule->LaunchWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
+                } else {
+                    cannedMessageModule->LaunchWithDestination(devicestate.rx_text_message.from);
+                }
+            }
+
+            return;
+        }
+
+        // Freetext reply
+        if (selected == ReplyFreetext) {
+
+            if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+                cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, ch);
+
+            } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+                cannedMessageModule->LaunchFreetextWithDestination(peer);
+
+            } else {
+                // Fallback for last received message
+                if (devicestate.rx_text_message.to == NODENUM_BROADCAST) {
+                    cannedMessageModule->LaunchFreetextWithDestination(NODENUM_BROADCAST, devicestate.rx_text_message.channel);
+                } else {
+                    cannedMessageModule->LaunchFreetextWithDestination(devicestate.rx_text_message.from);
+                }
+            }
+
+            return;
+        }
+    };
+    screen->showOverlayBanner(bannerOptions);
+}
+void menuHandler::deleteMessagesMenu()
+{
+    enum optionsNumbers { Back = 0, DeleteOldest, DeleteThis, DeleteAll, enumEnd };
+
+    static const char *optionsArray[enumEnd];
+    static int optionsEnumArray[enumEnd];
+    int options = 0;
+
+    auto mode = graphics::MessageRenderer::getThreadMode();
+
+    optionsArray[options] = "Back";
+    optionsEnumArray[options++] = Back;
+
+    optionsArray[options] = "Delete Oldest";
+    optionsEnumArray[options++] = DeleteOldest;
+
+    // If viewing ALL chats → hide “Delete This Chat”
+    if (mode != graphics::MessageRenderer::ThreadMode::ALL) {
+        optionsArray[options] = "Delete This Chat";
+        optionsEnumArray[options++] = DeleteThis;
+    }
+    if (currentResolution == ScreenResolution::UltraLow) {
+        optionsArray[options] = "Delete All";
+    } else {
+        optionsArray[options] = "Delete All Chats";
+    }
+    optionsEnumArray[options++] = DeleteAll;
+
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Delete Messages";
+
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsEnumPtr = optionsEnumArray;
+    bannerOptions.optionsCount = options;
+    bannerOptions.bannerCallback = [mode](int selected) -> void {
+        int ch = graphics::MessageRenderer::getThreadChannel();
+        uint32_t peer = graphics::MessageRenderer::getThreadPeer();
+
+        if (selected == Back) {
+            menuHandler::menuQueue = menuHandler::message_response_menu;
+            screen->runNow();
+            return;
+        }
+
+        if (selected == DeleteAll) {
+            LOG_INFO("Deleting all messages");
+            messageStore.clearAllMessages();
+            graphics::MessageRenderer::clearThreadRegistries();
+            graphics::MessageRenderer::clearMessageCache();
+            return;
+        }
+
+        if (selected == DeleteOldest) {
+            LOG_INFO("Deleting oldest message");
+
+            if (mode == graphics::MessageRenderer::ThreadMode::ALL) {
+                messageStore.deleteOldestMessage();
+            } else if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+                messageStore.deleteOldestMessageInChannel(ch);
+            } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+                messageStore.deleteOldestMessageWithPeer(peer);
+            }
+
+            return;
+        }
+
+        // This only appears in non-ALL modes
+        if (selected == DeleteThis) {
+            LOG_INFO("Deleting all messages in this thread");
+
+            if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL) {
+                messageStore.deleteAllMessagesInChannel(ch);
+            } else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+                messageStore.deleteAllMessagesWithPeer(peer);
+            }
+
+            return;
+        }
+    };
+
+    screen->showOverlayBanner(bannerOptions);
+}
+
+void menuHandler::messageViewModeMenu()
+{
+    auto encodeChannelId = [](int ch) -> int { return 100 + ch; };
+    auto isChannelSel = [](int id) -> bool { return id >= 100 && id < 200; };
+
+    static std::vector<std::string> labels;
+    static std::vector<int> ids;
+    static std::vector<uint32_t> idToPeer; // DM lookup
+
+    labels.clear();
+    ids.clear();
+    idToPeer.clear();
+
+    labels.push_back("Back");
+    ids.push_back(-1);
+    labels.push_back("View All Chats");
+    ids.push_back(-2);
+
+    // Channels with messages
+    for (int ch = 0; ch < 8; ++ch) {
+        auto msgs = messageStore.getChannelMessages((uint8_t)ch);
+        if (!msgs.empty()) {
+            char buf[40];
+            const char *cname = channels.getName(ch);
+            snprintf(buf, sizeof(buf), cname && cname[0] ? "#%s" : "#Ch%d", cname ? cname : "", ch);
+            labels.push_back(buf);
+            ids.push_back(encodeChannelId(ch));
+            LOG_DEBUG("messageViewModeMenu: Added live channel %s (id=%d)", buf, encodeChannelId(ch));
+        }
+    }
+
+    // Registry channels
+    for (int ch : graphics::MessageRenderer::getSeenChannels()) {
+        if (ch < 0 || ch >= 8)
+            continue;
+        auto msgs = messageStore.getChannelMessages((uint8_t)ch);
+        if (msgs.empty())
+            continue;
+        int enc = encodeChannelId(ch);
+        if (std::find(ids.begin(), ids.end(), enc) == ids.end()) {
+            char buf[40];
+            const char *cname = channels.getName(ch);
+            snprintf(buf, sizeof(buf), cname && cname[0] ? "#%s" : "#Ch%d", cname ? cname : "", ch);
+            labels.push_back(buf);
+            ids.push_back(enc);
+            LOG_DEBUG("messageViewModeMenu: Added registry channel %s (id=%d)", buf, enc);
+        }
+    }
+
+    // Gather unique peers
+    auto dms = messageStore.getDirectMessages();
+    std::vector<uint32_t> uniquePeers;
+    for (auto &m : dms) {
+        uint32_t peer = (m.sender == nodeDB->getNodeNum()) ? m.dest : m.sender;
+        if (peer != nodeDB->getNodeNum() && std::find(uniquePeers.begin(), uniquePeers.end(), peer) == uniquePeers.end())
+            uniquePeers.push_back(peer);
+    }
+    for (uint32_t peer : graphics::MessageRenderer::getSeenPeers()) {
+        if (peer != nodeDB->getNodeNum() && std::find(uniquePeers.begin(), uniquePeers.end(), peer) == uniquePeers.end())
+            uniquePeers.push_back(peer);
+    }
+    std::sort(uniquePeers.begin(), uniquePeers.end());
+
+    // Encode peers
+    for (size_t i = 0; i < uniquePeers.size(); ++i) {
+        uint32_t peer = uniquePeers[i];
+        auto node = nodeDB->getMeshNode(peer);
+        std::string name;
+        if (node && node->has_user)
+            name = sanitizeString(node->user.long_name).substr(0, 15);
+        else {
+            char buf[20];
+            snprintf(buf, sizeof(buf), "Node %08X", peer);
+            name = buf;
+        }
+        labels.push_back("@" + name);
+        int encPeer = 1000 + (int)idToPeer.size();
+        ids.push_back(encPeer);
+        idToPeer.push_back(peer);
+        LOG_DEBUG("messageViewModeMenu: Added DM %s peer=0x%08x id=%d", name.c_str(), (unsigned int)peer, encPeer);
+    }
+
+    // Active ID
+    int activeId = -2;
+    auto mode = graphics::MessageRenderer::getThreadMode();
+    if (mode == graphics::MessageRenderer::ThreadMode::CHANNEL)
+        activeId = encodeChannelId(graphics::MessageRenderer::getThreadChannel());
+    else if (mode == graphics::MessageRenderer::ThreadMode::DIRECT) {
+        uint32_t cur = graphics::MessageRenderer::getThreadPeer();
+        for (size_t i = 0; i < idToPeer.size(); ++i)
+            if (idToPeer[i] == cur) {
+                activeId = 1000 + (int)i;
+                break;
+            }
+    }
+
+    LOG_DEBUG("messageViewModeMenu: Active thread id=%d", activeId);
+
+    // Build banner
+    static std::vector<const char *> options;
+    static std::vector<int> optionIds;
+    options.clear();
+    optionIds.clear();
+
+    int initialIndex = 0;
+    for (size_t i = 0; i < labels.size(); i++) {
+        options.push_back(labels[i].c_str());
+        optionIds.push_back(ids[i]);
+        if (ids[i] == activeId)
+            initialIndex = (int)i;
+    }
+
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Select Conversation";
+    bannerOptions.optionsArrayPtr = options.data();
+    bannerOptions.optionsEnumPtr = optionIds.data();
+    bannerOptions.optionsCount = options.size();
+    bannerOptions.InitialSelected = initialIndex;
+
+    bannerOptions.bannerCallback = [=](int selected) -> void {
+        LOG_DEBUG("messageViewModeMenu: selected=%d", selected);
+        if (selected == -1) {
+            menuHandler::menuQueue = menuHandler::message_response_menu;
+            screen->runNow();
+        } else if (selected == -2) {
+            graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::ALL);
+        } else if (isChannelSel(selected)) {
+            int ch = selected - 100;
+            graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::CHANNEL, ch);
+        } else if (selected >= 1000) {
+            int idx = selected - 1000;
+            if (idx >= 0 && (size_t)idx < idToPeer.size()) {
+                uint32_t peer = idToPeer[idx];
+                graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::DIRECT, -1, peer);
+            }
+        }
     };
     screen->showOverlayBanner(bannerOptions);
 }
@@ -505,23 +862,12 @@ void menuHandler::homeBaseMenu()
         optionsArray[options] = "Send Node Info";
     }
     optionsEnumArray[options++] = Position;
-#if defined(M5STACK_UNITC6L)
-    optionsArray[options] = "New Preset";
-#else
-    optionsArray[options] = "New Preset Msg";
-#endif
-    optionsEnumArray[options++] = Preset;
-    if (kb_found) {
-        optionsArray[options] = "New Freetext Msg";
-        optionsEnumArray[options++] = Freetext;
-    }
 
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Home";
-#else
     bannerOptions.message = "Home Action";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Home";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsEnumPtr = optionsEnumArray;
     bannerOptions.optionsCount = options;
@@ -606,21 +952,22 @@ void menuHandler::systemBaseMenu()
     optionsArray[options] = "Display Options";
     optionsEnumArray[options++] = ScreenOptions;
 
-#if defined(M5STACK_UNITC6L)
-    optionsArray[options] = "Bluetooth";
-#else
-    optionsArray[options] = "Bluetooth Toggle";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        optionsArray[options] = "Bluetooth";
+    } else {
+        optionsArray[options] = "Bluetooth Toggle";
+    }
     optionsEnumArray[options++] = Bluetooth;
 #if HAS_WIFI && !defined(ARCH_PORTDUINO)
     optionsArray[options] = "WiFi Toggle";
     optionsEnumArray[options++] = WiFiToggle;
 #endif
-#if defined(M5STACK_UNITC6L)
-    optionsArray[options] = "Power";
-#else
-    optionsArray[options] = "Reboot/Shutdown";
-#endif
+
+    if (currentResolution == ScreenResolution::UltraLow) {
+        optionsArray[options] = "Power";
+    } else {
+        optionsArray[options] = "Reboot/Shutdown";
+    }
     optionsEnumArray[options++] = PowerMenu;
 
     if (test_enabled) {
@@ -629,11 +976,10 @@ void menuHandler::systemBaseMenu()
     }
 
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "System";
-#else
     bannerOptions.message = "System Action";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "System";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = options;
     bannerOptions.optionsEnumPtr = optionsEnumArray;
@@ -670,32 +1016,49 @@ void menuHandler::systemBaseMenu()
 
 void menuHandler::favoriteBaseMenu()
 {
-    enum optionsNumbers { Back, Preset, Freetext, Remove, TraceRoute, enumEnd };
-#if defined(M5STACK_UNITC6L)
-    static const char *optionsArray[enumEnd] = {"Back", "New Preset"};
-#else
-    static const char *optionsArray[enumEnd] = {"Back", "New Preset Msg"};
-#endif
-    static int optionsEnumArray[enumEnd] = {Back, Preset};
-    int options = 2;
+    enum optionsNumbers { Back, Preset, Freetext, GoToChat, Remove, TraceRoute, enumEnd };
+
+    static const char *optionsArray[enumEnd] = {"Back"};
+    static int optionsEnumArray[enumEnd] = {Back};
+    int options = 1;
+
+    // Only show "View Conversation" if a message exists with this node
+    uint32_t peer = graphics::UIRenderer::currentFavoriteNodeNum;
+    bool hasConversation = false;
+    for (const auto &m : messageStore.getMessages()) {
+        if ((m.sender == peer || m.dest == peer)) {
+            hasConversation = true;
+            break;
+        }
+    }
+    if (hasConversation) {
+        optionsArray[options] = "Go To Chat";
+        optionsEnumArray[options++] = GoToChat;
+    }
+    if (currentResolution == ScreenResolution::UltraLow) {
+        optionsArray[options] = "New Preset";
+    } else {
+        optionsArray[options] = "New Preset Msg";
+    }
+    optionsEnumArray[options++] = Preset;
 
     if (kb_found) {
         optionsArray[options] = "New Freetext Msg";
         optionsEnumArray[options++] = Freetext;
     }
-#if !defined(M5STACK_UNITC6L)
-    optionsArray[options] = "Trace Route";
-    optionsEnumArray[options++] = TraceRoute;
-#endif
+
+    if (currentResolution != ScreenResolution::UltraLow) {
+        optionsArray[options] = "Trace Route";
+        optionsEnumArray[options++] = TraceRoute;
+    }
     optionsArray[options] = "Remove Favorite";
     optionsEnumArray[options++] = Remove;
 
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Favorites";
-#else
     bannerOptions.message = "Favorites Action";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Favorites";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsEnumPtr = optionsEnumArray;
     bannerOptions.optionsCount = options;
@@ -704,6 +1067,17 @@ void menuHandler::favoriteBaseMenu()
             cannedMessageModule->LaunchWithDestination(graphics::UIRenderer::currentFavoriteNodeNum);
         } else if (selected == Freetext) {
             cannedMessageModule->LaunchFreetextWithDestination(graphics::UIRenderer::currentFavoriteNodeNum);
+        }
+        // Handle new Go To Thread action
+        else if (selected == GoToChat) {
+            // Switch thread to direct conversation with this node
+            graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::DIRECT, -1,
+                                                     graphics::UIRenderer::currentFavoriteNodeNum);
+
+            // Manually create and send a UIFrameEvent to trigger the jump
+            UIFrameEvent evt;
+            evt.action = UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE;
+            screen->handleUIFrameEvent(&evt);
         } else if (selected == Remove) {
             menuHandler::menuQueue = menuHandler::remove_favorite;
             screen->runNow();
@@ -753,20 +1127,33 @@ void menuHandler::positionBaseMenu()
 
 void menuHandler::nodeListMenu()
 {
-    enum optionsNumbers { Back, Favorite, TraceRoute, Verify, Reset, enumEnd };
-#if defined(M5STACK_UNITC6L)
-    static const char *optionsArray[] = {"Back", "Add Favorite", "Reset Node"};
-#else
-    static const char *optionsArray[] = {"Back", "Add Favorite", "Trace Route", "Key Verification", "Reset NodeDB"};
-#endif
+    enum optionsNumbers { Back, Favorite, TraceRoute, Verify, Reset, NodeNameLength, enumEnd };
+    static const char *optionsArray[enumEnd] = {"Back"};
+    static int optionsEnumArray[enumEnd] = {Back};
+    int options = 1;
+
+    optionsArray[options] = "Add Favorite";
+    optionsEnumArray[options++] = Favorite;
+    optionsArray[options] = "Trace Route";
+    optionsEnumArray[options++] = TraceRoute;
+
+    if (currentResolution != ScreenResolution::UltraLow) {
+        optionsArray[options] = "Key Verification";
+        optionsEnumArray[options++] = Verify;
+    }
+
+    if (currentResolution != ScreenResolution::UltraLow) {
+        optionsArray[options] = "Show Long/Short Name";
+        optionsEnumArray[options++] = NodeNameLength;
+    }
+    optionsArray[options] = "Reset NodeDB";
+    optionsEnumArray[options++] = Reset;
+
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "Node Action";
     bannerOptions.optionsArrayPtr = optionsArray;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.optionsCount = 3;
-#else
-    bannerOptions.optionsCount = 5;
-#endif
+    bannerOptions.optionsCount = options;
+    bannerOptions.optionsEnumPtr = optionsEnumArray;
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected == Favorite) {
             menuQueue = add_favorite;
@@ -780,6 +1167,9 @@ void menuHandler::nodeListMenu()
         } else if (selected == TraceRoute) {
             menuQueue = trace_route_menu;
             screen->runNow();
+        } else if (selected == NodeNameLength) {
+            menuHandler::menuQueue = menuHandler::node_name_length_menu;
+            screen->runNow();
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -803,7 +1193,7 @@ void menuHandler::nodeNameLengthMenu()
             LOG_INFO("Setting names to short");
             config.display.use_long_node_name = false;
         } else if (selected == Back) {
-            menuQueue = screen_options_menu;
+            menuQueue = node_base_menu;
             screen->runNow();
         }
     };
@@ -831,6 +1221,9 @@ void menuHandler::resetNodeDBMenu()
             LOG_INFO("Initiate node-db reset but keeping favorites");
             nodeDB->resetNodes(1);
             rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
+        } else if (selected == 0) {
+            menuQueue = node_base_menu;
+            screen->runNow();
         }
     };
     screen->showOverlayBanner(bannerOptions);
@@ -904,13 +1297,14 @@ void menuHandler::GPSFormatMenu()
 {
 
     static const char *optionsArray[] = {"Back",
-                                         isHighResolution ? "Decimal Degrees" : "DEC",
-                                         isHighResolution ? "Degrees Minutes Seconds" : "DMS",
-                                         isHighResolution ? "Universal Transverse Mercator" : "UTM",
-                                         isHighResolution ? "Military Grid Reference System" : "MGRS",
-                                         isHighResolution ? "Open Location Code" : "OLC",
-                                         isHighResolution ? "Ordnance Survey Grid Ref" : "OSGR",
-                                         isHighResolution ? "Maidenhead Locator" : "MLS"};
+                                         (currentResolution == ScreenResolution::High) ? "Decimal Degrees" : "DEC",
+                                         (currentResolution == ScreenResolution::High) ? "Degrees Minutes Seconds" : "DMS",
+                                         (currentResolution == ScreenResolution::High) ? "Universal Transverse Mercator" : "UTM",
+                                         (currentResolution == ScreenResolution::High) ? "Military Grid Reference System"
+                                                                                       : "MGRS",
+                                         (currentResolution == ScreenResolution::High) ? "Open Location Code" : "OLC",
+                                         (currentResolution == ScreenResolution::High) ? "Ordnance Survey Grid Ref" : "OSGR",
+                                         (currentResolution == ScreenResolution::High) ? "Maidenhead Locator" : "MLS"};
     BannerOverlayOptions bannerOptions;
     bannerOptions.message = "GPS Format";
     bannerOptions.optionsArrayPtr = optionsArray;
@@ -958,11 +1352,10 @@ void menuHandler::BluetoothToggleMenu()
 {
     static const char *optionsArray[] = {"Back", "Enabled", "Disabled"};
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Bluetooth";
-#else
     bannerOptions.message = "Toggle Bluetooth";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Bluetooth";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = 3;
     bannerOptions.bannerCallback = [](int selected) -> void {
@@ -1178,17 +1571,17 @@ void menuHandler::rebootMenu()
 {
     static const char *optionsArray[] = {"Back", "Confirm"};
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Reboot";
-#else
     bannerOptions.message = "Reboot Device?";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Reboot";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = 2;
     bannerOptions.bannerCallback = [](int selected) -> void {
         if (selected == 1) {
             IF_SCREEN(screen->showSimpleBanner("Rebooting...", 0));
             nodeDB->saveToDisk();
+            messageStore.saveToFlash();
             rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000;
         } else {
             menuQueue = power_menu;
@@ -1202,11 +1595,10 @@ void menuHandler::shutdownMenu()
 {
     static const char *optionsArray[] = {"Back", "Confirm"};
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Shutdown";
-#else
     bannerOptions.message = "Shutdown Device?";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Shutdown";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = 2;
     bannerOptions.bannerCallback = [](int selected) -> void {
@@ -1223,12 +1615,13 @@ void menuHandler::shutdownMenu()
 
 void menuHandler::addFavoriteMenu()
 {
-#if defined(M5STACK_UNITC6L)
-    screen->showNodePicker("Node Favorite", 30000, [](uint32_t nodenum) -> void {
-#else
-    screen->showNodePicker("Node To Favorite", 30000, [](uint32_t nodenum) -> void {
-
-#endif
+    const char *NODE_PICKER_TITLE;
+    if (currentResolution == ScreenResolution::UltraLow) {
+        NODE_PICKER_TITLE = "Node Favorite";
+    } else {
+        NODE_PICKER_TITLE = "Node To Favorite";
+    }
+    screen->showNodePicker(NODE_PICKER_TITLE, 30000, [](uint32_t nodenum) -> void {
         LOG_WARN("Nodenum: %u", nodenum);
         nodeDB->set_favorite(true, nodenum);
         screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
@@ -1393,16 +1786,11 @@ void menuHandler::screenOptionsMenu()
     hasSupportBrightness = false;
 #endif
 
-    enum optionsNumbers { Back, NodeNameLength, Brightness, ScreenColor, FrameToggles, DisplayUnits };
+    enum optionsNumbers { Back, Brightness, ScreenColor, FrameToggles, DisplayUnits };
     static const char *optionsArray[5] = {"Back"};
     static int optionsEnumArray[5] = {Back};
     int options = 1;
 
-#if defined(T_DECK) || defined(T_LORA_PAGER) || defined(HACKADAY_COMMUNICATOR)
-    optionsArray[options] = "Show Long/Short Name";
-    optionsEnumArray[options++] = NodeNameLength;
-#endif
-
     // Only show brightness for B&W displays
     if (hasSupportBrightness) {
         optionsArray[options] = "Brightness";
@@ -1416,7 +1804,7 @@ void menuHandler::screenOptionsMenu()
     optionsEnumArray[options++] = ScreenColor;
 #endif
 
-    optionsArray[options] = "Frame Visibility Toggle";
+    optionsArray[options] = "Frame Visibility";
     optionsEnumArray[options++] = FrameToggles;
 
     optionsArray[options] = "Display Units";
@@ -1434,9 +1822,6 @@ void menuHandler::screenOptionsMenu()
         } else if (selected == ScreenColor) {
             menuHandler::menuQueue = menuHandler::tftcolormenupicker;
             screen->runNow();
-        } else if (selected == NodeNameLength) {
-            menuHandler::menuQueue = menuHandler::node_name_length_menu;
-            screen->runNow();
         } else if (selected == FrameToggles) {
             menuHandler::menuQueue = menuHandler::FrameToggles;
             screen->runNow();
@@ -1471,11 +1856,10 @@ void menuHandler::powerMenu()
 #endif
 
     BannerOverlayOptions bannerOptions;
-#if defined(M5STACK_UNITC6L)
-    bannerOptions.message = "Power";
-#else
     bannerOptions.message = "Reboot / Shutdown";
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        bannerOptions.message = "Power";
+    }
     bannerOptions.optionsArrayPtr = optionsArray;
     bannerOptions.optionsCount = options;
     bannerOptions.optionsEnumPtr = optionsEnumArray;
@@ -1532,7 +1916,8 @@ void menuHandler::FrameToggles_menu()
 {
     enum optionsNumbers {
         Finish,
-        nodelist,
+        nodelist_nodes,
+        nodelist_location,
         nodelist_lastheard,
         nodelist_hopsignal,
         nodelist_distance,
@@ -1553,20 +1938,25 @@ void menuHandler::FrameToggles_menu()
     static int lastSelectedIndex = 0;
 
 #ifndef USE_EINK
-    optionsArray[options] = screen->isFrameHidden("nodelist") ? "Show Node List" : "Hide Node List";
-    optionsEnumArray[options++] = nodelist;
-#endif
-#ifdef USE_EINK
+    optionsArray[options] = screen->isFrameHidden("nodelist_nodes") ? "Show Node Lists" : "Hide Node Lists";
+    optionsEnumArray[options++] = nodelist_nodes;
+#else
     optionsArray[options] = screen->isFrameHidden("nodelist_lastheard") ? "Show NL - Last Heard" : "Hide NL - Last Heard";
     optionsEnumArray[options++] = nodelist_lastheard;
     optionsArray[options] = screen->isFrameHidden("nodelist_hopsignal") ? "Show NL - Hops/Signal" : "Hide NL - Hops/Signal";
     optionsEnumArray[options++] = nodelist_hopsignal;
+#endif
+
+#if HAS_GPS
+#ifndef USE_EINK
+    optionsArray[options] = screen->isFrameHidden("nodelist_location") ? "Show Position Lists" : "Hide Position Lists";
+    optionsEnumArray[options++] = nodelist_location;
+#else
     optionsArray[options] = screen->isFrameHidden("nodelist_distance") ? "Show NL - Distance" : "Hide NL - Distance";
     optionsEnumArray[options++] = nodelist_distance;
-#endif
-#if HAS_GPS
-    optionsArray[options] = screen->isFrameHidden("nodelist_bearings") ? "Show Bearings" : "Hide Bearings";
+    optionsArray[options] = screen->isFrameHidden("nodelist_bearings") ? "Show NL - Bearings" : "Hide NL - Bearings";
     optionsEnumArray[options++] = nodelist_bearings;
+#endif
 
     optionsArray[options] = screen->isFrameHidden("gps") ? "Show Position" : "Hide Position";
     optionsEnumArray[options++] = gps;
@@ -1605,8 +1995,12 @@ void menuHandler::FrameToggles_menu()
 
         if (selected == Finish) {
             screen->setFrames(Screen::FOCUS_DEFAULT);
-        } else if (selected == nodelist) {
-            screen->toggleFrameVisibility("nodelist");
+        } else if (selected == nodelist_nodes) {
+            screen->toggleFrameVisibility("nodelist_nodes");
+            menuHandler::menuQueue = menuHandler::FrameToggles;
+            screen->runNow();
+        } else if (selected == nodelist_location) {
+            screen->toggleFrameVisibility("nodelist_location");
             menuHandler::menuQueue = menuHandler::FrameToggles;
             screen->runNow();
         } else if (selected == nodelist_lastheard) {
@@ -1722,6 +2116,9 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case position_base_menu:
         positionBaseMenu();
         break;
+    case node_base_menu:
+        nodeListMenu();
+        break;
 #if !MESHTASTIC_EXCLUDE_GPS
     case gps_toggle_menu:
         GPSToggleMenu();
@@ -1802,6 +2199,18 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case throttle_message:
         screen->showSimpleBanner("Too Many Attempts\nTry again in 60 seconds.", 5000);
         break;
+    case message_response_menu:
+        messageResponseMenu();
+        break;
+    case reply_menu:
+        replyMenu();
+        break;
+    case delete_messages_menu:
+        deleteMessagesMenu();
+        break;
+    case message_viewmode_menu:
+        messageViewModeMenu();
+        break;
     }
     menuQueue = menu_none;
 }
@@ -1813,4 +2222,4 @@ void menuHandler::saveUIConfig()
 
 } // namespace graphics
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/graphics/draw/MenuHandler.h b/src/graphics/draw/MenuHandler.h
index df7c2739b..e53b4baf7 100644
--- a/src/graphics/draw/MenuHandler.h
+++ b/src/graphics/draw/MenuHandler.h
@@ -19,6 +19,7 @@ class menuHandler
         clock_face_picker,
         clock_menu,
         position_base_menu,
+        node_base_menu,
         gps_toggle_menu,
         gps_format_menu,
         compass_point_north_menu,
@@ -43,6 +44,10 @@ class menuHandler
         key_verification_final_prompt,
         trace_route_menu,
         throttle_message,
+        message_response_menu,
+        message_viewmode_menu,
+        reply_menu,
+        delete_messages_menu,
         node_name_length_menu,
         FrameToggles,
         DisplayUnits
@@ -61,6 +66,9 @@ class menuHandler
     static void TwelveHourPicker();
     static void ClockFacePicker();
     static void messageResponseMenu();
+    static void messageViewModeMenu();
+    static void replyMenu();
+    static void deleteMessagesMenu();
     static void homeBaseMenu();
     static void textMessageBaseMenu();
     static void systemBaseMenu();
@@ -119,4 +127,4 @@ template <typename T> struct MenuOption {
 using RadioPresetOption = MenuOption<meshtastic_Config_LoRaConfig_ModemPreset>;
 
 } // namespace graphics
-#endif
\ No newline at end of file
+#endif
diff --git a/src/graphics/draw/MessageRenderer.cpp b/src/graphics/draw/MessageRenderer.cpp
index da6ec7abc..09b798e06 100644
--- a/src/graphics/draw/MessageRenderer.cpp
+++ b/src/graphics/draw/MessageRenderer.cpp
@@ -1,51 +1,27 @@
-/*
-BaseUI
-
-Developed and Maintained By:
-- Ronald Garcia (HarukiToreda) – Lead development and implementation.
-- JasonP (Xaositek)  – Screen layout and icon design, UI improvements and testing.
-- TonyG (Tropho) – Project management, structural planning, and testing
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
 #include "configuration.h"
 #if HAS_SCREEN
 #include "MessageRenderer.h"
 
 // Core includes
+#include "MessageStore.h"
 #include "NodeDB.h"
+#include "UIRenderer.h"
 #include "configuration.h"
 #include "gps/RTC.h"
+#include "graphics/Screen.h"
 #include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
+#include "graphics/TimeFormatters.h"
 #include "graphics/emotes.h"
 #include "main.h"
 #include "meshUtils.h"
-
-// Additional includes for UI rendering
-#include "UIRenderer.h"
-#include "graphics/TimeFormatters.h"
-
-// Additional includes for dependencies
 #include <string>
 #include <vector>
 
 // External declarations
 extern bool hasUnreadMessage;
 extern meshtastic_DeviceState devicestate;
+extern graphics::Screen *screen;
 
 using graphics::Emote;
 using graphics::emotes;
@@ -56,17 +32,105 @@ namespace graphics
 namespace MessageRenderer
 {
 
-// Simple cache based on text hash
-static size_t cachedKey = 0;
 static std::vector<std::string> cachedLines;
 static std::vector<int> cachedHeights;
+static bool manualScrolling = false;
+
+// UTF-8 skip helper
+static inline size_t utf8CharLen(uint8_t c)
+{
+    if ((c & 0xE0) == 0xC0)
+        return 2;
+    if ((c & 0xF0) == 0xE0)
+        return 3;
+    if ((c & 0xF8) == 0xF0)
+        return 4;
+    return 1;
+}
+
+// Remove variation selectors (FE0F) and skin tone modifiers from emoji so they match your labels
+std::string normalizeEmoji(const std::string &s)
+{
+    std::string out;
+    for (size_t i = 0; i < s.size();) {
+        uint8_t c = static_cast<uint8_t>(s[i]);
+        size_t len = utf8CharLen(c);
+
+        if (c == 0xEF && i + 2 < s.size() && (uint8_t)s[i + 1] == 0xB8 && (uint8_t)s[i + 2] == 0x8F) {
+            i += 3;
+            continue;
+        }
+
+        // Skip skin tone modifiers
+        if (c == 0xF0 && i + 3 < s.size() && (uint8_t)s[i + 1] == 0x9F && (uint8_t)s[i + 2] == 0x8F &&
+            ((uint8_t)s[i + 3] >= 0xBB && (uint8_t)s[i + 3] <= 0xBF)) {
+            i += 4;
+            continue;
+        }
+
+        out.append(s, i, len);
+        i += len;
+    }
+    return out;
+}
+
+// Scroll state (file scope so we can reset on new message)
+float scrollY = 0.0f;
+uint32_t lastTime = 0;
+uint32_t scrollStartDelay = 0;
+uint32_t pauseStart = 0;
+bool waitingToReset = false;
+bool scrollStarted = false;
+static bool didReset = false;
+
+void scrollUp()
+{
+    manualScrolling = true;
+    scrollY -= 12;
+    if (scrollY < 0)
+        scrollY = 0;
+}
+
+void scrollDown()
+{
+    manualScrolling = true;
+
+    int totalHeight = 0;
+    for (int h : cachedHeights)
+        totalHeight += h;
+
+    int visibleHeight = screen->getHeight() - (FONT_HEIGHT_SMALL * 2);
+    int maxScroll = totalHeight - visibleHeight;
+    if (maxScroll < 0)
+        maxScroll = 0;
+
+    scrollY += 12;
+    if (scrollY > maxScroll)
+        scrollY = maxScroll;
+}
 
 void drawStringWithEmotes(OLEDDisplay *display, int x, int y, const std::string &line, const Emote *emotes, int emoteCount)
 {
+    std::string renderLine;
+    for (size_t i = 0; i < line.size();) {
+        uint8_t c = (uint8_t)line[i];
+        size_t len = utf8CharLen(c);
+        if (c == 0xEF && i + 2 < line.size() && (uint8_t)line[i + 1] == 0xB8 && (uint8_t)line[i + 2] == 0x8F) {
+            i += 3;
+            continue;
+        }
+        if (c == 0xF0 && i + 3 < line.size() && (uint8_t)line[i + 1] == 0x9F && (uint8_t)line[i + 2] == 0x8F &&
+            ((uint8_t)line[i + 3] >= 0xBB && (uint8_t)line[i + 3] <= 0xBF)) {
+            i += 4;
+            continue;
+        }
+        renderLine.append(line, i, len);
+        i += len;
+    }
     int cursorX = x;
     const int fontHeight = FONT_HEIGHT_SMALL;
 
-    // === Step 1: Find tallest emote in the line ===
+    // Step 1: Find tallest emote in the line
     int maxIconHeight = fontHeight;
     for (size_t i = 0; i < line.length();) {
         bool matched = false;
@@ -81,25 +145,16 @@ void drawStringWithEmotes(OLEDDisplay *display, int x, int y, const std::string
             }
         }
         if (!matched) {
-            uint8_t c = static_cast<uint8_t>(line[i]);
-            if ((c & 0xE0) == 0xC0)
-                i += 2;
-            else if ((c & 0xF0) == 0xE0)
-                i += 3;
-            else if ((c & 0xF8) == 0xF0)
-                i += 4;
-            else
-                i += 1;
+            i += utf8CharLen(static_cast<uint8_t>(line[i]));
         }
     }
 
-    // === Step 2: Baseline alignment ===
+    // Step 2: Baseline alignment
     int lineHeight = std::max(fontHeight, maxIconHeight);
     int baselineOffset = (lineHeight - fontHeight) / 2;
     int fontY = y + baselineOffset;
-    int fontMidline = fontY + fontHeight / 2;
 
-    // === Step 3: Render line in segments ===
+    // Step 3: Render line in segments
     size_t i = 0;
     bool inBold = false;
 
@@ -148,10 +203,12 @@ void drawStringWithEmotes(OLEDDisplay *display, int x, int y, const std::string
 
         // Render the emote (if found)
         if (matchedEmote && i == nextEmotePos) {
-            int iconY = fontMidline - matchedEmote->height / 2 - 1;
+            // Vertically center emote relative to font baseline (not just midline)
+            int iconY = fontY + (fontHeight - matchedEmote->height) / 2;
             display->drawXbm(cursorX, iconY, matchedEmote->width, matchedEmote->height, matchedEmote->bitmap);
             cursorX += matchedEmote->width + 1;
             i += emojiLen;
+            continue;
         } else {
             // No more emotes — render the rest of the line
             std::string remaining = line.substr(i);
@@ -164,235 +221,471 @@ void drawStringWithEmotes(OLEDDisplay *display, int x, int y, const std::string
 #else
             cursorX += display->getStringWidth(remaining.c_str());
 #endif
-
             break;
         }
     }
 }
 
+// Reset scroll state when new messages arrive
+void resetScrollState()
+{
+    scrollY = 0.0f;
+    scrollStarted = false;
+    waitingToReset = false;
+    scrollStartDelay = millis();
+    lastTime = millis();
+    manualScrolling = false;
+    didReset = false;
+}
+
+void nudgeScroll(int8_t direction)
+{
+    if (direction == 0)
+        return;
+
+    if (cachedHeights.empty()) {
+        scrollY = 0.0f;
+        return;
+    }
+
+    OLEDDisplay *display = (screen != nullptr) ? screen->getDisplayDevice() : nullptr;
+    const int displayHeight = display ? display->getHeight() : 64;
+    const int navHeight = FONT_HEIGHT_SMALL;
+    const int usableHeight = std::max(0, displayHeight - navHeight);
+
+    int totalHeight = 0;
+    for (int h : cachedHeights)
+        totalHeight += h;
+
+    if (totalHeight <= usableHeight) {
+        scrollY = 0.0f;
+        return;
+    }
+
+    const int scrollStop = std::max(0, totalHeight - usableHeight + cachedHeights.back());
+    const int step = std::max(FONT_HEIGHT_SMALL, usableHeight / 3);
+
+    float newScroll = scrollY + static_cast<float>(direction) * static_cast<float>(step);
+    if (newScroll < 0.0f)
+        newScroll = 0.0f;
+    if (newScroll > scrollStop)
+        newScroll = static_cast<float>(scrollStop);
+
+    if (newScroll != scrollY) {
+        scrollY = newScroll;
+        waitingToReset = false;
+        scrollStarted = false;
+        scrollStartDelay = millis();
+        lastTime = millis();
+    }
+}
+
+// Fully free cached message data from heap
+void clearMessageCache()
+{
+    std::vector<std::string>().swap(cachedLines);
+    std::vector<int>().swap(cachedHeights);
+
+    // Reset scroll so we rebuild cleanly next time we enter the screen
+    resetScrollState();
+}
+
+// Current thread state
+static ThreadMode currentMode = ThreadMode::ALL;
+static int currentChannel = -1;
+static uint32_t currentPeer = 0;
+
+// Registry of seen threads for manual toggle
+static std::vector<int> seenChannels;
+static std::vector<uint32_t> seenPeers;
+
+// Public helper so menus / store can clear stale registries
+void clearThreadRegistries()
+{
+    seenChannels.clear();
+    seenPeers.clear();
+}
+
+// Setter so other code can switch threads
+void setThreadMode(ThreadMode mode, int channel /* = -1 */, uint32_t peer /* = 0 */)
+{
+    currentMode = mode;
+    currentChannel = channel;
+    currentPeer = peer;
+    didReset = false; // force reset when mode changes
+
+    // Track channels we’ve seen
+    if (mode == ThreadMode::CHANNEL && channel >= 0) {
+        if (std::find(seenChannels.begin(), seenChannels.end(), channel) == seenChannels.end()) {
+            seenChannels.push_back(channel);
+        }
+    }
+
+    // Track DMs we’ve seen
+    if (mode == ThreadMode::DIRECT && peer != 0) {
+        if (std::find(seenPeers.begin(), seenPeers.end(), peer) == seenPeers.end()) {
+            seenPeers.push_back(peer);
+        }
+    }
+}
+
+ThreadMode getThreadMode()
+{
+    return currentMode;
+}
+
+int getThreadChannel()
+{
+    return currentChannel;
+}
+
+uint32_t getThreadPeer()
+{
+    return currentPeer;
+}
+
+// Accessors for menuHandler
+const std::vector<int> &getSeenChannels()
+{
+    return seenChannels;
+}
+const std::vector<uint32_t> &getSeenPeers()
+{
+    return seenPeers;
+}
+
+static int centerYForRow(int y, int size)
+{
+    int midY = y + (FONT_HEIGHT_SMALL / 2);
+    return midY - (size / 2);
+}
+
+// Helpers for drawing status marks (thickened strokes)
+static void drawCheckMark(OLEDDisplay *display, int x, int y, int size)
+{
+    int topY = centerYForRow(y, size);
+    display->setColor(WHITE);
+    display->drawLine(x, topY + size / 2, x + size / 3, topY + size);
+    display->drawLine(x, topY + size / 2 + 1, x + size / 3, topY + size + 1);
+    display->drawLine(x + size / 3, topY + size, x + size, topY);
+    display->drawLine(x + size / 3, topY + size + 1, x + size, topY + 1);
+}
+
+static void drawXMark(OLEDDisplay *display, int x, int y, int size = 8)
+{
+    int topY = centerYForRow(y, size);
+    display->setColor(WHITE);
+    display->drawLine(x, topY, x + size, topY + size);
+    display->drawLine(x, topY + 1, x + size, topY + size + 1);
+    display->drawLine(x + size, topY, x, topY + size);
+    display->drawLine(x + size, topY + 1, x, topY + size + 1);
+}
+
+static void drawRelayMark(OLEDDisplay *display, int x, int y, int size = 8)
+{
+    int r = size / 2;
+    int centerY = centerYForRow(y, size) + r;
+    int centerX = x + r;
+    display->setColor(WHITE);
+    display->drawCircle(centerX, centerY, r);
+    display->drawLine(centerX, centerY - 2, centerX, centerY);
+    display->setPixel(centerX, centerY + 2);
+    display->drawLine(centerX - 1, centerY - 4, centerX + 1, centerY - 4);
+}
+
+static inline int getRenderedLineWidth(OLEDDisplay *display, const std::string &line, const Emote *emotes, int emoteCount)
+{
+    std::string normalized = normalizeEmoji(line);
+    int totalWidth = 0;
+
+    size_t i = 0;
+    while (i < normalized.length()) {
+        bool matched = false;
+        for (int e = 0; e < emoteCount; ++e) {
+            size_t emojiLen = strlen(emotes[e].label);
+            if (normalized.compare(i, emojiLen, emotes[e].label) == 0) {
+                totalWidth += emotes[e].width + 1; // +1 spacing
+                i += emojiLen;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            size_t charLen = utf8CharLen(static_cast<uint8_t>(normalized[i]));
+#if defined(OLED_UA) || defined(OLED_RU)
+            totalWidth += display->getStringWidth(normalized.substr(i, charLen).c_str(), charLen, true);
+#else
+            totalWidth += display->getStringWidth(normalized.substr(i, charLen).c_str());
+#endif
+            i += charLen;
+        }
+    }
+    return totalWidth;
+}
+
+static void drawMessageScrollbar(OLEDDisplay *display, int visibleHeight, int totalHeight, int scrollOffset, int startY)
+{
+    if (totalHeight <= visibleHeight)
+        return; // no scrollbar needed
+
+    int scrollbarX = display->getWidth() - 2;
+    int scrollbarHeight = visibleHeight;
+    int thumbHeight = std::max(6, (scrollbarHeight * visibleHeight) / totalHeight);
+    int maxScroll = std::max(1, totalHeight - visibleHeight);
+    int thumbY = startY + (scrollbarHeight - thumbHeight) * scrollOffset / maxScroll;
+
+    for (int i = 0; i < thumbHeight; i++) {
+        display->setPixel(scrollbarX, thumbY + i);
+    }
+}
+
 void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
+    // Ensure any boot-relative timestamps are upgraded if RTC is valid
+    messageStore.upgradeBootRelativeTimestamps();
+
+    if (!didReset) {
+        resetScrollState();
+        didReset = true;
+    }
+
     // Clear the unread message indicator when viewing the message
     hasUnreadMessage = false;
 
-    const meshtastic_MeshPacket &mp = devicestate.rx_text_message;
-    const char *msg = reinterpret_cast<const char *>(mp.decoded.payload.bytes);
+    // Filter messages based on thread mode
+    std::deque<StoredMessage> filtered;
+    for (const auto &m : messageStore.getLiveMessages()) {
+        bool include = false;
+        switch (currentMode) {
+        case ThreadMode::ALL:
+            include = true;
+            break;
+        case ThreadMode::CHANNEL:
+            if (m.type == MessageType::BROADCAST && (int)m.channelIndex == currentChannel)
+                include = true;
+            break;
+        case ThreadMode::DIRECT:
+            if (m.dest != NODENUM_BROADCAST && (m.sender == currentPeer || m.dest == currentPeer))
+                include = true;
+            break;
+        }
+        if (include)
+            filtered.push_back(m);
+    }
 
     display->clear();
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-#if defined(M5STACK_UNITC6L)
-    const int fixedTopHeight = 24;
-    const int windowX = 0;
-    const int windowY = fixedTopHeight;
-    const int windowWidth = 64;
-    const int windowHeight = SCREEN_HEIGHT - fixedTopHeight;
-#else
     const int navHeight = FONT_HEIGHT_SMALL;
     const int scrollBottom = SCREEN_HEIGHT - navHeight;
     const int usableHeight = scrollBottom;
-    const int textWidth = SCREEN_WIDTH;
+    constexpr int LEFT_MARGIN = 2;
+    constexpr int RIGHT_MARGIN = 2;
+    constexpr int SCROLLBAR_WIDTH = 3;
 
-#endif
-    bool isInverted = (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_INVERTED);
-    bool isBold = config.display.heading_bold;
+    const int leftTextWidth = SCREEN_WIDTH - LEFT_MARGIN - RIGHT_MARGIN;
 
-    // === Set Title
+    const int rightTextWidth = SCREEN_WIDTH - LEFT_MARGIN - RIGHT_MARGIN - SCROLLBAR_WIDTH;
+
+    // Title string depending on mode
+    static char titleBuf[32];
     const char *titleStr = "Messages";
+    switch (currentMode) {
+    case ThreadMode::ALL:
+        titleStr = "Messages";
+        break;
+    case ThreadMode::CHANNEL: {
+        const char *cname = channels.getName(currentChannel);
+        if (cname && cname[0]) {
+            snprintf(titleBuf, sizeof(titleBuf), "#%s", cname);
+        } else {
+            snprintf(titleBuf, sizeof(titleBuf), "Ch%d", currentChannel);
+        }
+        titleStr = titleBuf;
+        break;
+    }
+    case ThreadMode::DIRECT: {
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(currentPeer);
+        if (node && node->has_user) {
+            snprintf(titleBuf, sizeof(titleBuf), "@%s", node->user.short_name);
+        } else {
+            snprintf(titleBuf, sizeof(titleBuf), "@%08x", currentPeer);
+        }
+        titleStr = titleBuf;
+        break;
+    }
+    }
 
-    // Check if we have more than an empty message to show
-    char messageBuf[237];
-    snprintf(messageBuf, sizeof(messageBuf), "%s", msg);
-    if (strlen(messageBuf) == 0) {
-        // === Header ===
+    if (filtered.empty()) {
+        // If current conversation is empty go back to ALL view
+        if (currentMode != ThreadMode::ALL) {
+            setThreadMode(ThreadMode::ALL);
+            resetScrollState();
+            return; // Next draw will rerun in ALL mode
+        }
+
+        // Still in ALL mode and no messages at all → show placeholder
         graphics::drawCommonHeader(display, x, y, titleStr);
+        didReset = false;
         const char *messageString = "No messages";
         int center_text = (SCREEN_WIDTH / 2) - (display->getStringWidth(messageString) / 2);
-#if defined(M5STACK_UNITC6L)
-        display->drawString(center_text, windowY + (windowHeight / 2) - (FONT_HEIGHT_SMALL / 2) - 5, messageString);
-#else
         display->drawString(center_text, getTextPositions(display)[2], messageString);
-#endif
         graphics::drawCommonFooter(display, x, y);
         return;
     }
 
-    // === Header Construction ===
-    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(getFrom(&mp));
-    char headerStr[80];
-    const char *sender = "???";
-#if defined(M5STACK_UNITC6L)
-    if (node && node->has_user)
-        sender = node->user.short_name;
-#else
-    if (node && node->has_user) {
-        if (SCREEN_WIDTH >= 200 && strlen(node->user.long_name) > 0) {
-            sender = node->user.long_name;
-        } else {
-            sender = node->user.short_name;
-        }
-    }
-#endif
-    uint32_t seconds = sinceReceived(&mp), minutes = seconds / 60, hours = minutes / 60, days = hours / 24;
-    uint8_t timestampHours, timestampMinutes;
-    int32_t daysAgo;
-    bool useTimestamp = deltaToTimestamp(seconds, &timestampHours, &timestampMinutes, &daysAgo);
+    // Build lines for filtered messages (newest first)
+    std::vector<std::string> allLines;
+    std::vector<bool> isMine;   // track alignment
+    std::vector<bool> isHeader; // track header lines
+    std::vector<AckStatus> ackForLine;
 
-    if (useTimestamp && minutes >= 15 && daysAgo == 0) {
-        std::string prefix = (daysAgo == 1 && SCREEN_WIDTH >= 200) ? "Yesterday" : "At";
-        if (config.display.use_12h_clock) {
-            bool isPM = timestampHours >= 12;
-            timestampHours = timestampHours % 12;
-            if (timestampHours == 0)
-                timestampHours = 12;
-            snprintf(headerStr, sizeof(headerStr), "%s %d:%02d%s from %s", prefix.c_str(), timestampHours, timestampMinutes,
-                     isPM ? "p" : "a", sender);
-        } else {
-            snprintf(headerStr, sizeof(headerStr), "%s %d:%02d from %s", prefix.c_str(), timestampHours, timestampMinutes,
-                     sender);
-        }
-    } else {
-#if defined(M5STACK_UNITC6L)
-        snprintf(headerStr, sizeof(headerStr), "%s from %s", UIRenderer::drawTimeDelta(days, hours, minutes, seconds).c_str(),
-                 sender);
-#else
-        snprintf(headerStr, sizeof(headerStr), "%s ago from %s", UIRenderer::drawTimeDelta(days, hours, minutes, seconds).c_str(),
-                 sender);
-#endif
-    }
-#if defined(M5STACK_UNITC6L)
-    graphics::drawCommonHeader(display, x, y, titleStr);
-    int headerY = getTextPositions(display)[1];
-    display->drawString(x, headerY, headerStr);
-    for (int separatorX = 0; separatorX < SCREEN_WIDTH; separatorX += 2) {
-        display->setPixel(separatorX, fixedTopHeight - 1);
-    }
-    cachedLines.clear();
-    std::string fullMsg(messageBuf);
-    std::string currentLine;
-    for (size_t i = 0; i < fullMsg.size();) {
-        unsigned char c = fullMsg[i];
-        size_t charLen = 1;
-        if ((c & 0xE0) == 0xC0)
-            charLen = 2;
-        else if ((c & 0xF0) == 0xE0)
-            charLen = 3;
-        else if ((c & 0xF8) == 0xF0)
-            charLen = 4;
-        std::string nextChar = fullMsg.substr(i, charLen);
-        std::string testLine = currentLine + nextChar;
-        if (display->getStringWidth(testLine.c_str()) > windowWidth) {
-            cachedLines.push_back(currentLine);
-            currentLine = nextChar;
-        } else {
-            currentLine = testLine;
-        }
+    for (auto it = filtered.rbegin(); it != filtered.rend(); ++it) {
+        const auto &m = *it;
 
-        i += charLen;
-    }
-    if (!currentLine.empty())
-        cachedLines.push_back(currentLine);
-    cachedHeights = calculateLineHeights(cachedLines, emotes);
-    int yOffset = windowY;
-    int linesDrawn = 0;
-    for (size_t i = 0; i < cachedLines.size(); ++i) {
-        if (linesDrawn >= 2)
-            break;
-        int lineHeight = cachedHeights[i];
-        if (yOffset + lineHeight > windowY + windowHeight)
-            break;
-        drawStringWithEmotes(display, windowX, yOffset, cachedLines[i], emotes, numEmotes);
-        yOffset += lineHeight;
-        linesDrawn++;
-    }
-    screen->forceDisplay();
-#else
-    uint32_t now = millis();
-#ifndef EXCLUDE_EMOJI
-    // === Bounce animation setup ===
-    static uint32_t lastBounceTime = 0;
-    static int bounceY = 0;
-    const int bounceRange = 2;     // Max pixels to bounce up/down
-    const int bounceInterval = 10; // How quickly to change bounce direction (ms)
-
-    if (now - lastBounceTime >= bounceInterval) {
-        lastBounceTime = now;
-        bounceY = (bounceY + 1) % (bounceRange * 2);
-    }
-    for (int i = 0; i < numEmotes; ++i) {
-        const Emote &e = emotes[i];
-        if (strcmp(msg, e.label) == 0) {
-            int headerY = getTextPositions(display)[1]; // same as scrolling header line
-            display->drawString(x + 3, headerY, headerStr);
-            if (isInverted && isBold)
-                display->drawString(x + 4, headerY, headerStr);
-
-            // Draw separator (same as scroll version)
-            for (int separatorX = 1; separatorX <= (display->getStringWidth(headerStr) + 2); separatorX += 2) {
-                display->setPixel(separatorX, headerY + ((isHighResolution) ? 19 : 13));
+        // Channel / destination labeling
+        char chanType[32] = "";
+        if (currentMode == ThreadMode::ALL) {
+            if (m.dest == NODENUM_BROADCAST) {
+                snprintf(chanType, sizeof(chanType), "#%s", channels.getName(m.channelIndex));
+            } else {
+                snprintf(chanType, sizeof(chanType), "(DM)");
             }
+        }
 
-            // Center the emote below the header line + separator + nav
-            int remainingHeight = SCREEN_HEIGHT - (headerY + FONT_HEIGHT_SMALL) - navHeight;
-            int emoteY = headerY + 6 + FONT_HEIGHT_SMALL + (remainingHeight - e.height) / 2 + bounceY - bounceRange;
-            display->drawXbm((SCREEN_WIDTH - e.width) / 2, emoteY, e.width, e.height, e.bitmap);
+        // Calculate how long ago
+        uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+        uint32_t seconds = 0;
+        bool invalidTime = true;
 
-            // Draw header at the end to sort out overlapping elements
-            graphics::drawCommonHeader(display, x, y, titleStr);
-            return;
+        if (m.timestamp > 0 && nowSecs > 0) {
+            if (nowSecs >= m.timestamp) {
+                seconds = nowSecs - m.timestamp;
+                invalidTime = (seconds > 315360000); // >10 years
+            } else {
+                uint32_t ahead = m.timestamp - nowSecs;
+                if (ahead <= 600) { // allow small skew
+                    seconds = 0;
+                    invalidTime = false;
+                }
+            }
+        } else if (m.timestamp > 0 && nowSecs == 0) {
+            // RTC not valid: only trust boot-relative if same boot
+            uint32_t bootNow = millis() / 1000;
+            if (m.isBootRelative && m.timestamp <= bootNow) {
+                seconds = bootNow - m.timestamp;
+                invalidTime = false;
+            } else {
+                invalidTime = true; // old persisted boot-relative, ignore until healed
+            }
+        }
+
+        char timeBuf[16];
+        if (invalidTime) {
+            snprintf(timeBuf, sizeof(timeBuf), "???");
+        } else if (seconds < 60) {
+            snprintf(timeBuf, sizeof(timeBuf), "%us", seconds);
+        } else if (seconds < 3600) {
+            snprintf(timeBuf, sizeof(timeBuf), "%um", seconds / 60);
+        } else if (seconds < 86400) {
+            snprintf(timeBuf, sizeof(timeBuf), "%uh", seconds / 3600);
+        } else {
+            snprintf(timeBuf, sizeof(timeBuf), "%ud", seconds / 86400);
+        }
+
+        // Build header line for this message
+        meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(m.sender);
+        meshtastic_NodeInfoLite *node_recipient = nodeDB->getMeshNode(m.dest);
+
+        char senderBuf[48] = "";
+        if (node && node->has_user) {
+            // Use long name if present
+            strncpy(senderBuf, node->user.long_name, sizeof(senderBuf) - 1);
+            senderBuf[sizeof(senderBuf) - 1] = '\0';
+        } else {
+            // No long/short name → show NodeID in parentheses
+            snprintf(senderBuf, sizeof(senderBuf), "(%08x)", m.sender);
+        }
+
+        // If this is *our own* message, override senderBuf to who the recipient was
+        bool mine = (m.sender == nodeDB->getNodeNum());
+        if (mine && node_recipient && node_recipient->has_user) {
+            strcpy(senderBuf, node_recipient->user.long_name);
+        }
+
+        // Shrink Sender name if needed
+        int availWidth = SCREEN_WIDTH - display->getStringWidth(timeBuf) - display->getStringWidth(chanType) -
+                         display->getStringWidth(" @...") - 10;
+        if (availWidth < 0)
+            availWidth = 0;
+
+        size_t origLen = strlen(senderBuf);
+        while (senderBuf[0] && display->getStringWidth(senderBuf) > availWidth) {
+            senderBuf[strlen(senderBuf) - 1] = '\0';
+        }
+
+        // If we actually truncated, append "..."
+        if (strlen(senderBuf) < origLen) {
+            strcat(senderBuf, "...");
+        }
+
+        // Final header line
+        char headerStr[96];
+        if (mine) {
+            if (currentMode == ThreadMode::ALL) {
+                if (strcmp(chanType, "(DM)") == 0) {
+                    snprintf(headerStr, sizeof(headerStr), "%s to %s", timeBuf, senderBuf);
+                } else {
+                    snprintf(headerStr, sizeof(headerStr), "%s to %s", timeBuf, chanType);
+                }
+            } else {
+                snprintf(headerStr, sizeof(headerStr), "%s", timeBuf);
+            }
+        } else {
+            snprintf(headerStr, sizeof(headerStr), "%s @%s %s", timeBuf, senderBuf, chanType);
+        }
+
+        // Push header line
+        allLines.push_back(std::string(headerStr));
+        isMine.push_back(mine);
+        isHeader.push_back(true);
+        ackForLine.push_back(m.ackStatus);
+
+        const char *msgText = MessageStore::getText(m);
+
+        int wrapWidth = mine ? rightTextWidth : leftTextWidth;
+        std::vector<std::string> wrapped = generateLines(display, "", msgText, wrapWidth);
+        for (auto &ln : wrapped) {
+            allLines.push_back(ln);
+            isMine.push_back(mine);
+            isHeader.push_back(false);
+            ackForLine.push_back(AckStatus::NONE);
         }
     }
-#endif
-    // === Generate the cache key ===
-    size_t currentKey = (size_t)mp.from;
-    currentKey ^= ((size_t)mp.to << 8);
-    currentKey ^= ((size_t)mp.rx_time << 16);
-    currentKey ^= ((size_t)mp.id << 24);
 
-    if (cachedKey != currentKey) {
-        LOG_INFO("Onscreen message scroll cache key needs updating: cachedKey=0x%0x, currentKey=0x%x", cachedKey, currentKey);
+    // Cache lines and heights
+    cachedLines = allLines;
+    cachedHeights = calculateLineHeights(cachedLines, emotes, isHeader);
 
-        // Cache miss - regenerate lines and heights
-        cachedLines = generateLines(display, headerStr, messageBuf, textWidth);
-        cachedHeights = calculateLineHeights(cachedLines, emotes);
-        cachedKey = currentKey;
-    } else {
-        // Cache hit but update the header line with current time information
-        cachedLines[0] = std::string(headerStr);
-        // The header always has a fixed height since it doesn't contain emotes
-        // As per calculateLineHeights logic for lines without emotes:
-        cachedHeights[0] = FONT_HEIGHT_SMALL - 2;
-        if (cachedHeights[0] < 8)
-            cachedHeights[0] = 8; // minimum safety
-    }
-
-    // === Scrolling logic ===
+    // Scrolling logic (unchanged)
     int totalHeight = 0;
-    for (size_t i = 1; i < cachedHeights.size(); ++i) {
+    for (size_t i = 0; i < cachedHeights.size(); ++i)
         totalHeight += cachedHeights[i];
-    }
-    int usableScrollHeight = usableHeight - cachedHeights[0]; // remove header height
+    int usableScrollHeight = usableHeight;
     int scrollStop = std::max(0, totalHeight - usableScrollHeight + cachedHeights.back());
 
-    static float scrollY = 0.0f;
-    static uint32_t lastTime = 0, scrollStartDelay = 0, pauseStart = 0;
-    static bool waitingToReset = false, scrollStarted = false;
-
-    // === Smooth scrolling adjustment ===
-    // You can tweak this divisor to change how smooth it scrolls.
-    // Lower = smoother, but can feel slow.
+#ifndef USE_EINK
+    uint32_t now = millis();
     float delta = (now - lastTime) / 400.0f;
     lastTime = now;
+    const float scrollSpeed = 2.0f;
 
-    const float scrollSpeed = 2.0f; // pixels per second
-
-    // Delay scrolling start by 2 seconds
     if (scrollStartDelay == 0)
         scrollStartDelay = now;
     if (!scrollStarted && now - scrollStartDelay > 2000)
         scrollStarted = true;
 
-    if (totalHeight > usableScrollHeight) {
+    if (!manualScrolling && totalHeight > usableScrollHeight) {
         if (scrollStarted) {
             if (!waitingToReset) {
                 scrollY += delta * scrollSpeed;
@@ -408,29 +701,96 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
                 scrollStartDelay = lastTime;
             }
         }
-    } else {
+    } else if (!manualScrolling) {
         scrollY = 0;
     }
-
-    int scrollOffset = static_cast<int>(scrollY);
-    int yOffset = -scrollOffset + getTextPositions(display)[1];
-    for (int separatorX = 1; separatorX <= (display->getStringWidth(headerStr) + 2); separatorX += 2) {
-        display->setPixel(separatorX, yOffset + ((isHighResolution) ? 19 : 13));
-    }
-
-    // === Render visible lines ===
-    renderMessageContent(display, cachedLines, cachedHeights, x, yOffset, scrollBottom, emotes, numEmotes, isInverted, isBold);
-
-    // Draw header at the end to sort out overlapping elements
-    graphics::drawCommonHeader(display, x, y, titleStr);
+#else
+    // E-Ink: disable autoscroll
+    scrollY = 0.0f;
+    waitingToReset = false;
+    scrollStarted = false;
+    lastTime = millis();
 #endif
+
+    int finalScroll = (int)scrollY;
+    int yOffset = -finalScroll + getTextPositions(display)[1];
+
+    // Render visible lines
+    for (size_t i = 0; i < cachedLines.size(); ++i) {
+        int lineY = yOffset;
+        for (size_t j = 0; j < i; ++j)
+            lineY += cachedHeights[j];
+
+        if (lineY > -cachedHeights[i] && lineY < scrollBottom) {
+            if (isHeader[i]) {
+
+                int w = display->getStringWidth(cachedLines[i].c_str());
+                int headerX;
+                if (isMine[i]) {
+                    // push header left to avoid overlap with scrollbar
+                    headerX = SCREEN_WIDTH - w - SCROLLBAR_WIDTH - RIGHT_MARGIN;
+                    if (headerX < LEFT_MARGIN)
+                        headerX = LEFT_MARGIN;
+                } else {
+                    headerX = x;
+                }
+                display->drawString(headerX, lineY, cachedLines[i].c_str());
+
+                // Draw ACK/NACK mark for our own messages
+                if (isMine[i]) {
+                    int markX = headerX - 10;
+                    int markY = lineY;
+                    if (ackForLine[i] == AckStatus::ACKED) {
+                        // Destination ACK
+                        drawCheckMark(display, markX, markY, 8);
+                    } else if (ackForLine[i] == AckStatus::NACKED || ackForLine[i] == AckStatus::TIMEOUT) {
+                        // Failure or timeout
+                        drawXMark(display, markX, markY, 8);
+                    } else if (ackForLine[i] == AckStatus::RELAYED) {
+                        // Relay ACK
+                        drawRelayMark(display, markX, markY, 8);
+                    }
+                    // AckStatus::NONE → show nothing
+                }
+
+                // Draw underline just under header text
+                int underlineY = lineY + FONT_HEIGHT_SMALL;
+                for (int px = 0; px < w; ++px) {
+                    display->setPixel(headerX + px, underlineY);
+                }
+            } else {
+                // Render message line
+                if (isMine[i]) {
+                    // Calculate actual rendered width including emotes
+                    int renderedWidth = getRenderedLineWidth(display, cachedLines[i], emotes, numEmotes);
+                    int rightX = SCREEN_WIDTH - renderedWidth - SCROLLBAR_WIDTH - RIGHT_MARGIN;
+                    if (rightX < LEFT_MARGIN)
+                        rightX = LEFT_MARGIN;
+
+                    drawStringWithEmotes(display, rightX, lineY, cachedLines[i], emotes, numEmotes);
+                } else {
+                    drawStringWithEmotes(display, x, lineY, cachedLines[i], emotes, numEmotes);
+                }
+            }
+        }
+    }
+    int totalContentHeight = totalHeight;
+    int visibleHeight = usableHeight;
+
+    // Draw scrollbar
+    drawMessageScrollbar(display, visibleHeight, totalContentHeight, finalScroll, getTextPositions(display)[1]);
+    graphics::drawCommonHeader(display, x, y, titleStr);
     graphics::drawCommonFooter(display, x, y);
 }
 
 std::vector<std::string> generateLines(OLEDDisplay *display, const char *headerStr, const char *messageBuf, int textWidth)
 {
     std::vector<std::string> lines;
-    lines.push_back(std::string(headerStr)); // Header line is always first
+
+    // Only push headerStr if it's not empty (prevents extra blank line after headers)
+    if (headerStr && headerStr[0] != '\0') {
+        lines.push_back(std::string(headerStr));
+    }
 
     std::string line, word;
     for (int i = 0; messageBuf[i]; ++i) {
@@ -453,10 +813,6 @@ std::vector<std::string> generateLines(OLEDDisplay *display, const char *headerS
         } else {
             word += ch;
             std::string test = line + word;
-// Keep these lines for diagnostics
-// LOG_INFO("Char: '%c' (0x%02X)", ch, (unsigned char)ch);
-// LOG_INFO("Current String: %s", test.c_str());
-// Note: there are boolean comparison uint16 (getStringWidth) with int (textWidth), hope textWidth is always positive :)
 #if defined(OLED_UA) || defined(OLED_RU)
             uint16_t strWidth = display->getStringWidth(test.c_str(), test.length(), true);
 #else
@@ -478,28 +834,71 @@ std::vector<std::string> generateLines(OLEDDisplay *display, const char *headerS
 
     return lines;
 }
-
-std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, const Emote *emotes)
+std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, const Emote *emotes,
+                                      const std::vector<bool> &isHeaderVec)
 {
+    // Tunables for layout control
+    constexpr int HEADER_UNDERLINE_GAP = 0; // space between underline and first body line
+    constexpr int HEADER_UNDERLINE_PIX = 1; // underline thickness (1px row drawn)
+    constexpr int BODY_LINE_LEADING = -4;   // default vertical leading for normal body lines
+    constexpr int MESSAGE_BLOCK_GAP = 4;    // gap after a message block before a new header
+    constexpr int EMOTE_PADDING_ABOVE = 4;  // space above emote line (added to line above)
+    constexpr int EMOTE_PADDING_BELOW = 3;  // space below emote line (added to emote line)
+
     std::vector<int> rowHeights;
+    rowHeights.reserve(lines.size());
 
-    for (const auto &_line : lines) {
-        int lineHeight = FONT_HEIGHT_SMALL;
+    for (size_t idx = 0; idx < lines.size(); ++idx) {
+        const auto &line = lines[idx];
+        const int baseHeight = FONT_HEIGHT_SMALL;
+
+        // Detect if THIS line or NEXT line contains an emote
         bool hasEmote = false;
-
+        int tallestEmote = baseHeight;
         for (int i = 0; i < numEmotes; ++i) {
-            const Emote &e = emotes[i];
-            if (_line.find(e.label) != std::string::npos) {
-                lineHeight = std::max(lineHeight, e.height);
+            if (line.find(emotes[i].label) != std::string::npos) {
                 hasEmote = true;
+                tallestEmote = std::max(tallestEmote, emotes[i].height);
             }
         }
 
-        // Apply tighter spacing if no emotes on this line
-        if (!hasEmote) {
-            lineHeight -= 2; // reduce by 2px for tighter spacing
-            if (lineHeight < 8)
-                lineHeight = 8; // minimum safety
+        bool nextHasEmote = false;
+        if (idx + 1 < lines.size()) {
+            for (int i = 0; i < numEmotes; ++i) {
+                if (lines[idx + 1].find(emotes[i].label) != std::string::npos) {
+                    nextHasEmote = true;
+                    break;
+                }
+            }
+        }
+
+        int lineHeight = baseHeight;
+
+        if (isHeaderVec[idx]) {
+            // Header line spacing
+            lineHeight = baseHeight + HEADER_UNDERLINE_PIX + HEADER_UNDERLINE_GAP;
+        } else {
+            // Base spacing for normal lines
+            int desiredBody = baseHeight + BODY_LINE_LEADING;
+
+            if (hasEmote) {
+                // Emote line: add overshoot + bottom padding
+                int overshoot = std::max(0, tallestEmote - baseHeight);
+                lineHeight = desiredBody + overshoot + EMOTE_PADDING_BELOW;
+            } else {
+                // Regular line: no emote → standard spacing
+                lineHeight = desiredBody;
+
+                // If next line has an emote → add top padding *here*
+                if (nextHasEmote) {
+                    lineHeight += EMOTE_PADDING_ABOVE;
+                }
+            }
+
+            // Add block gap if next is a header
+            if (idx + 1 < lines.size() && isHeaderVec[idx + 1]) {
+                lineHeight += MESSAGE_BLOCK_GAP;
+            }
         }
 
         rowHeights.push_back(lineHeight);
@@ -508,22 +907,125 @@ std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, con
     return rowHeights;
 }
 
-void renderMessageContent(OLEDDisplay *display, const std::vector<std::string> &lines, const std::vector<int> &rowHeights, int x,
-                          int yOffset, int scrollBottom, const Emote *emotes, int numEmotes, bool isInverted, bool isBold)
+void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const meshtastic_MeshPacket &packet)
 {
-    for (size_t i = 0; i < lines.size(); ++i) {
-        int lineY = yOffset;
-        for (size_t j = 0; j < i; ++j)
-            lineY += rowHeights[j];
-        if (lineY > -rowHeights[i] && lineY < scrollBottom) {
-            if (i == 0 && isInverted) {
-                display->drawString(x, lineY, lines[i].c_str());
-                if (isBold)
-                    display->drawString(x, lineY, lines[i].c_str());
-            } else {
-                drawStringWithEmotes(display, x, lineY, lines[i], emotes, numEmotes);
+    if (packet.from != 0) {
+        hasUnreadMessage = true;
+
+        // Determine if message belongs to a muted channel
+        bool isChannelMuted = false;
+        if (sm.type == MessageType::BROADCAST) {
+            const meshtastic_Channel channel = channels.getByIndex(packet.channel ? packet.channel : channels.getPrimaryIndex());
+            if (channel.settings.has_module_settings && channel.settings.module_settings.is_muted)
+                isChannelMuted = true;
+        }
+
+        // Banner logic
+        const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(packet.from);
+        char longName[48] = "???";
+        if (node && node->user.long_name) {
+            strncpy(longName, node->user.long_name, sizeof(longName) - 1);
+            longName[sizeof(longName) - 1] = '\0';
+        }
+        int availWidth = display->getWidth() - ((currentResolution == ScreenResolution::High) ? 40 : 20);
+        if (availWidth < 0)
+            availWidth = 0;
+
+        size_t origLen = strlen(longName);
+        while (longName[0] && display->getStringWidth(longName) > availWidth) {
+            longName[strlen(longName) - 1] = '\0';
+        }
+        if (strlen(longName) < origLen) {
+            strcat(longName, "...");
+        }
+        const char *msgRaw = reinterpret_cast<const char *>(packet.decoded.payload.bytes);
+
+        char banner[256];
+        bool isAlert = false;
+
+        // Check if alert detection is enabled via external notification module
+        if (moduleConfig.external_notification.alert_bell || moduleConfig.external_notification.alert_bell_vibra ||
+            moduleConfig.external_notification.alert_bell_buzzer) {
+            for (size_t i = 0; i < packet.decoded.payload.size && i < 100; i++) {
+                if (msgRaw[i] == '\x07') {
+                    isAlert = true;
+                    break;
+                }
             }
         }
+
+        if (isAlert) {
+            if (longName && longName[0])
+                snprintf(banner, sizeof(banner), "Alert Received from\n%s", longName);
+            else
+                strcpy(banner, "Alert Received");
+        } else {
+            // Skip muted channels unless it's an alert
+            if (isChannelMuted)
+                return;
+
+            if (longName && longName[0]) {
+                if (currentResolution == ScreenResolution::UltraLow) {
+                    strcpy(banner, "New Message");
+                } else {
+                    snprintf(banner, sizeof(banner), "New Message from\n%s", longName);
+                }
+            } else
+                strcpy(banner, "New Message");
+        }
+
+        // Append context (which channel or DM) so the banner shows where the message arrived
+        {
+            char contextBuf[64] = "";
+            if (sm.type == MessageType::BROADCAST) {
+                const char *cname = channels.getName(sm.channelIndex);
+                if (cname && cname[0])
+                    snprintf(contextBuf, sizeof(contextBuf), "in #%s", cname);
+                else
+                    snprintf(contextBuf, sizeof(contextBuf), "in Ch%d", sm.channelIndex);
+            }
+
+            if (contextBuf[0]) {
+                size_t cur = strlen(banner);
+                if (cur + 1 < sizeof(banner)) {
+                    if (cur > 0 && banner[cur - 1] != '\n') {
+                        banner[cur] = '\n';
+                        banner[cur + 1] = '\0';
+                        cur++;
+                    }
+                    strncat(banner, contextBuf, sizeof(banner) - cur - 1);
+                }
+            }
+        }
+
+        // Shorter banner if already in a conversation (Channel or Direct)
+        bool inThread = (getThreadMode() != ThreadMode::ALL);
+
+        if (shouldWakeOnReceivedMessage()) {
+            screen->setOn(true);
+        }
+
+        screen->showSimpleBanner(banner, inThread ? 1000 : 3000);
+    }
+
+    // Always focus into the correct conversation thread when a message with real text arrives
+    const char *msgText = MessageStore::getText(sm);
+    if (msgText && msgText[0] != '\0') {
+        setThreadFor(sm, packet);
+    }
+
+    // Reset scroll for a clean start
+    resetScrollState();
+}
+
+void setThreadFor(const StoredMessage &sm, const meshtastic_MeshPacket &packet)
+{
+    if (packet.to == 0 || packet.to == NODENUM_BROADCAST) {
+        setThreadMode(ThreadMode::CHANNEL, sm.channelIndex);
+    } else {
+        uint32_t localNode = nodeDB->getNodeNum();
+        uint32_t peer = (sm.sender == localNode) ? packet.to : sm.sender;
+        setThreadMode(ThreadMode::DIRECT, -1, peer);
     }
 }
 
diff --git a/src/graphics/draw/MessageRenderer.h b/src/graphics/draw/MessageRenderer.h
index c15a699f7..7dec6adec 100644
--- a/src/graphics/draw/MessageRenderer.h
+++ b/src/graphics/draw/MessageRenderer.h
@@ -1,7 +1,11 @@
 #pragma once
+#include "MessageStore.h" // for StoredMessage
+#if HAS_SCREEN
 #include "OLEDDisplay.h"
 #include "OLEDDisplayUi.h"
 #include "graphics/emotes.h"
+#include "mesh/generated/meshtastic/mesh.pb.h" // for meshtastic_MeshPacket
+#include <cstdint>
 #include <string>
 #include <vector>
 
@@ -10,6 +14,27 @@ namespace graphics
 namespace MessageRenderer
 {
 
+// Thread filter modes
+enum class ThreadMode { ALL, CHANNEL, DIRECT };
+
+// Setter for switching thread mode
+void setThreadMode(ThreadMode mode, int channel = -1, uint32_t peer = 0);
+
+// Getter for current mode
+ThreadMode getThreadMode();
+
+// Getter for current channel (valid if mode == CHANNEL)
+int getThreadChannel();
+
+// Getter for current peer (valid if mode == DIRECT)
+uint32_t getThreadPeer();
+
+// Registry accessors for menuHandler
+const std::vector<int> &getSeenChannels();
+const std::vector<uint32_t> &getSeenPeers();
+
+void clearThreadRegistries();
+
 // Text and emote rendering
 void drawStringWithEmotes(OLEDDisplay *display, int x, int y, const std::string &line, const Emote *emotes, int emoteCount);
 
@@ -20,11 +45,27 @@ void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
 std::vector<std::string> generateLines(OLEDDisplay *display, const char *headerStr, const char *messageBuf, int textWidth);
 
 // Function to calculate heights for each line
-std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, const Emote *emotes);
+std::vector<int> calculateLineHeights(const std::vector<std::string> &lines, const Emote *emotes,
+                                      const std::vector<bool> &isHeaderVec);
 
-// Function to render the message content
-void renderMessageContent(OLEDDisplay *display, const std::vector<std::string> &lines, const std::vector<int> &rowHeights, int x,
-                          int yOffset, int scrollBottom, const Emote *emotes, int numEmotes, bool isInverted, bool isBold);
+// Reset scroll state when new messages arrive
+void resetScrollState();
+
+// Manual scroll control for encoder-style inputs
+void nudgeScroll(int8_t direction);
+
+// Helper to auto-select the correct thread mode from a message
+void setThreadFor(const StoredMessage &sm, const meshtastic_MeshPacket &packet);
+
+// Handles a new incoming/outgoing message: banner, wake, thread select, scroll reset
+void handleNewMessage(OLEDDisplay *display, const StoredMessage &sm, const meshtastic_MeshPacket &packet);
+
+// Clear Message Line Cache from Message Renderer
+void clearMessageCache();
+
+void scrollUp();
+void scrollDown();
 
 } // namespace MessageRenderer
 } // namespace graphics
+#endif
\ No newline at end of file
diff --git a/src/graphics/draw/NodeListRenderer.cpp b/src/graphics/draw/NodeListRenderer.cpp
index 1a36a6188..e10d8c40a 100644
--- a/src/graphics/draw/NodeListRenderer.cpp
+++ b/src/graphics/draw/NodeListRenderer.cpp
@@ -23,7 +23,6 @@ extern graphics::Screen *screen;
 
 #if defined(M5STACK_UNITC6L)
 static uint32_t lastSwitchTime = 0;
-#else
 #endif
 namespace graphics
 {
@@ -46,79 +45,119 @@ void drawScaledXBitmap16x16(int x, int y, int width, int height, const uint8_t *
 }
 
 // Static variables for dynamic cycling
-static NodeListMode currentMode = MODE_LAST_HEARD;
+static ListMode_Node currentMode_Nodes = MODE_LAST_HEARD;
+static ListMode_Location currentMode_Location = MODE_DISTANCE;
 static int scrollIndex = 0;
+// Popup overlay state
+static uint32_t popupTime = 0;
+static int popupTotal = 0;
+static int popupStart = 0;
+static int popupEnd = 0;
+static int popupPage = 1;
+static int popupMaxPage = 1;
+
+static const uint32_t POPUP_DURATION_MS = 1000; // 1 second visible
+
+// =============================
+// Scrolling Logic
+// =============================
+void scrollUp()
+{
+    if (scrollIndex > 0)
+        scrollIndex--;
+
+    popupTime = millis(); // show popup
+}
+
+void scrollDown()
+{
+    scrollIndex++;
+    popupTime = millis();
+}
 
 // =============================
 // Utility Functions
 // =============================
 
-const char *getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node)
+const char *getSafeNodeName(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int columnWidth)
 {
-    const char *name = NULL;
-    static char nodeName[16] = "?";
-    if (config.display.use_long_node_name == true) {
-        if (node->has_user && strlen(node->user.long_name) > 0) {
-            name = node->user.long_name;
-        } else {
-            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
-        }
-    } else {
-        if (node->has_user && strlen(node->user.short_name) > 0) {
-            name = node->user.short_name;
-        } else {
-            snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
-        }
+    static char nodeName[25]; // single static buffer we return
+    nodeName[0] = '\0';
+
+    auto writeFallbackId = [&] {
+        std::snprintf(nodeName, sizeof(nodeName), "(%04X)", static_cast<uint16_t>(node ? (node->num & 0xFFFF) : 0));
+    };
+
+    // 1) Choose target candidate (long vs short) only if present
+    const char *raw = nullptr;
+    if (node && node->has_user) {
+        raw = config.display.use_long_node_name ? node->user.long_name : node->user.short_name;
     }
 
-    // Use sanitizeString() function and copy directly into nodeName
-    std::string sanitized_name = sanitizeString(name ? name : "");
+    // 2) Sanitize (empty if raw is null/empty)
+    std::string s = (raw && *raw) ? sanitizeString(raw) : std::string{};
 
-    if (!sanitized_name.empty()) {
-        strncpy(nodeName, sanitized_name.c_str(), sizeof(nodeName) - 1);
-        nodeName[sizeof(nodeName) - 1] = '\0';
+    // 3) Fallback if sanitize yields empty; otherwise copy safely (truncate if needed)
+    if (s.empty() || s == "¿" || s.find_first_not_of("¿") == std::string::npos) {
+        writeFallbackId();
     } else {
-        snprintf(nodeName, sizeof(nodeName), "(%04X)", (uint16_t)(node->num & 0xFFFF));
+        // %.*s ensures null-termination and safe truncation to buffer size - 1
+        std::snprintf(nodeName, sizeof(nodeName), "%.*s", static_cast<int>(sizeof(nodeName) - 1), s.c_str());
     }
 
-    if (config.display.use_long_node_name == true) {
-        int availWidth = (SCREEN_WIDTH / 2) - 65;
+    // 4) Width-based truncation + ellipsis (long-name mode only)
+    if (config.display.use_long_node_name && display) {
+        int availWidth = columnWidth - ((currentResolution == ScreenResolution::High) ? 65 : 38);
         if (availWidth < 0)
             availWidth = 0;
 
-        size_t origLen = strlen(nodeName);
-        while (nodeName[0] && display->getStringWidth(nodeName) > availWidth) {
-            nodeName[strlen(nodeName) - 1] = '\0';
+        const size_t beforeLen = std::strlen(nodeName);
+
+        // Trim from the end until it fits or is empty
+        size_t len = beforeLen;
+        while (len && display->getStringWidth(nodeName) > availWidth) {
+            nodeName[--len] = '\0';
         }
 
-        // If we actually truncated, append "..." (ensure space remains in buffer)
-        if (strlen(nodeName) < origLen) {
-            size_t len = strlen(nodeName);
-            size_t maxLen = sizeof(nodeName) - 4; // 3 for "..." and 1 for '\0'
-            if (len > maxLen) {
-                nodeName[maxLen] = '\0';
-                len = maxLen;
+        // If truncated, append "..." (respect buffer size)
+        if (len < beforeLen) {
+            // Make sure there's room for "..." and '\0'
+            const size_t capForText = sizeof(nodeName) - 1; // leaving space for '\0'
+            const size_t needed = 3;                        // "..."
+            if (len > capForText - needed) {
+                len = capForText - needed;
+                nodeName[len] = '\0';
             }
-            strcat(nodeName, "...");
+            std::strcat(nodeName, "...");
         }
     }
 
     return nodeName;
 }
 
-const char *getCurrentModeTitle(int screenWidth)
+const char *getCurrentModeTitle_Nodes(int screenWidth)
 {
-    switch (currentMode) {
+    switch (currentMode_Nodes) {
     case MODE_LAST_HEARD:
         return "Last Heard";
     case MODE_HOP_SIGNAL:
 #ifdef USE_EINK
         return "Hops/Sig";
 #else
-        return (isHighResolution) ? "Hops/Signal" : "Hops/Sig";
+        return (currentResolution == ScreenResolution::High) ? "Hops/Signal" : "Hops/Sig";
 #endif
+    default:
+        return "Nodes";
+    }
+}
+
+const char *getCurrentModeTitle_Location(int screenWidth)
+{
+    switch (currentMode_Location) {
     case MODE_DISTANCE:
         return "Distance";
+    case MODE_BEARING:
+        return "Bearings";
     default:
         return "Nodes";
     }
@@ -137,10 +176,8 @@ int calculateMaxScroll(int totalEntries, int visibleRows)
 
 void drawColumnSeparator(OLEDDisplay *display, int16_t x, int16_t yStart, int16_t yEnd)
 {
-    int columnWidth = display->getWidth() / 2;
-    int separatorX = x + columnWidth - 2;
     for (int y = yStart; y <= yEnd; y += 2) {
-        display->setPixel(separatorX, y);
+        display->setPixel(x, y);
     }
 }
 
@@ -152,7 +189,8 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
     int scrollbarX = display->getWidth() - 2;
     int scrollbarHeight = display->getHeight() - scrollStartY - 10;
     int thumbHeight = std::max(4, (scrollbarHeight * visibleNodeRows * columns) / totalEntries);
-    int maxScroll = calculateMaxScroll(totalEntries, visibleNodeRows);
+    int perPage = visibleNodeRows * columns;
+    int maxScroll = std::max(0, (totalEntries - 1) / perPage);
     int thumbY = scrollStartY + (scrollIndex * (scrollbarHeight - thumbHeight)) / std::max(1, maxScroll);
 
     for (int i = 0; i < thumbHeight; i++) {
@@ -167,9 +205,9 @@ void drawScrollbar(OLEDDisplay *display, int visibleNodeRows, int totalEntries,
 void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
-    int timeOffset = (isHighResolution) ? (isLeftCol ? 7 : 10) : (isLeftCol ? 3 : 7);
+    int timeOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 7 : 10) : (isLeftCol ? 3 : 7);
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
 
     char timeStr[10];
     uint32_t seconds = sinceLastSeen(node);
@@ -188,9 +226,9 @@ void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-    display->drawString(x + ((isHighResolution) ? 6 : 3), y, nodeName);
+    display->drawString(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -209,19 +247,19 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
 
     int nameMaxWidth = columnWidth - 25;
-    int barsOffset = (isHighResolution) ? (isLeftCol ? 20 : 24) : (isLeftCol ? 15 : 19);
-    int hopOffset = (isHighResolution) ? (isLeftCol ? 21 : 29) : (isLeftCol ? 13 : 17);
+    int barsOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 20 : 24) : (isLeftCol ? 15 : 19);
+    int hopOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 21 : 29) : (isLeftCol ? 13 : 17);
 
     int barsXOffset = columnWidth - barsOffset;
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
 
-    display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
+    display->drawStringMaxWidth(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nameMaxWidth, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -256,9 +294,10 @@ void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int
 void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
-    int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
+    int nameMaxWidth =
+        columnWidth - ((currentResolution == ScreenResolution::High) ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
     char distStr[10] = "";
 
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
@@ -311,9 +350,9 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-    display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
+    display->drawStringMaxWidth(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nameMaxWidth, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -321,26 +360,24 @@ void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     }
 
     if (strlen(distStr) > 0) {
-        int offset = (isHighResolution) ? (isLeftCol ? 7 : 10) // Offset for Wide Screens (Left Column:Right Column)
-                                        : (isLeftCol ? 4 : 7); // Offset for Narrow Screens (Left Column:Right Column)
+        int offset = (currentResolution == ScreenResolution::High)
+                         ? (isLeftCol ? 7 : 10) // Offset for Wide Screens (Left Column:Right Column)
+                         : (isLeftCol ? 4 : 7); // Offset for Narrow Screens (Left Column:Right Column)
         int rightEdge = x + columnWidth - offset;
         int textWidth = display->getStringWidth(distStr);
         display->drawString(rightEdge - textWidth, y, distStr);
     }
 }
 
-void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
+void drawEntryDynamic_Nodes(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth)
 {
-    switch (currentMode) {
+    switch (currentMode_Nodes) {
     case MODE_LAST_HEARD:
         drawEntryLastHeard(display, node, x, y, columnWidth);
         break;
     case MODE_HOP_SIGNAL:
         drawEntryHopSignal(display, node, x, y, columnWidth);
         break;
-    case MODE_DISTANCE:
-        drawNodeDistance(display, node, x, y, columnWidth);
-        break;
     default:
         break;
     }
@@ -351,15 +388,16 @@ void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
 
     // Adjust max text width depending on column and screen width
-    int nameMaxWidth = columnWidth - (isHighResolution ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
+    int nameMaxWidth =
+        columnWidth - ((currentResolution == ScreenResolution::High) ? (isLeftCol ? 25 : 28) : (isLeftCol ? 20 : 22));
 
-    const char *nodeName = getSafeNodeName(display, node);
+    const char *nodeName = getSafeNodeName(display, node, columnWidth);
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
-    display->drawStringMaxWidth(x + ((isHighResolution) ? 6 : 3), y, nameMaxWidth, nodeName);
+    display->drawStringMaxWidth(x + ((currentResolution == ScreenResolution::High) ? 6 : 3), y, nameMaxWidth, nodeName);
     if (node->is_favorite) {
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             drawScaledXBitmap16x16(x, y + 6, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint, display);
         } else {
             display->drawXbm(x, y + 5, smallbulletpoint_width, smallbulletpoint_height, smallbulletpoint);
@@ -374,7 +412,7 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
         return;
 
     bool isLeftCol = (x < SCREEN_WIDTH / 2);
-    int arrowXOffset = (isHighResolution) ? (isLeftCol ? 22 : 24) : (isLeftCol ? 12 : 18);
+    int arrowXOffset = (currentResolution == ScreenResolution::High) ? (isLeftCol ? 22 : 24) : (isLeftCol ? 12 : 18);
 
     int centerX = x + columnWidth - arrowXOffset;
     int centerY = y + FONT_HEIGHT_SMALL / 2;
@@ -431,11 +469,6 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
         locationScreen = true;
     else if (strcmp(title, "Distance") == 0)
         locationScreen = true;
-#if defined(M5STACK_UNITC6L)
-    int columnWidth = display->getWidth();
-#else
-    int columnWidth = display->getWidth() / 2;
-#endif
     display->clear();
 
     // Draw the battery/time header
@@ -444,39 +477,74 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
     // Space below header
     y += COMMON_HEADER_HEIGHT;
 
+    int totalColumns = 1; // Default to 1 column
+
+    if (config.display.use_long_node_name) {
+        if (SCREEN_WIDTH <= 240) {
+            totalColumns = 1;
+        } else if (SCREEN_WIDTH > 240) {
+            totalColumns = 2;
+        }
+    } else {
+        if (SCREEN_WIDTH <= 64) {
+            totalColumns = 1;
+        } else if (SCREEN_WIDTH > 64 && SCREEN_WIDTH <= 240) {
+            totalColumns = 2;
+        } else {
+            totalColumns = 3;
+        }
+    }
+
+    int columnWidth = display->getWidth() / totalColumns;
+
     int totalEntries = nodeDB->getNumMeshNodes();
     int totalRowsAvailable = (display->getHeight() - y) / rowYOffset;
     int numskipped = 0;
     int visibleNodeRows = totalRowsAvailable;
-#if defined(M5STACK_UNITC6L)
-    int totalColumns = 1;
-#else
-    int totalColumns = 2;
-#endif
-    int startIndex = scrollIndex * visibleNodeRows * totalColumns;
-    if (nodeDB->getMeshNodeByIndex(startIndex)->num == nodeDB->getNodeNum()) {
-        startIndex++; // skip own node
-    }
-    int endIndex = std::min(startIndex + visibleNodeRows * totalColumns, totalEntries);
 
+    // Build filtered + ordered list
+    std::vector<int> drawList;
+    drawList.reserve(totalEntries);
+    for (int i = 0; i < totalEntries; i++) {
+        auto *n = nodeDB->getMeshNodeByIndex(i);
+
+        if (!n)
+            continue;
+        if (n->num == nodeDB->getNodeNum())
+            continue;
+        if (locationScreen && !n->has_position)
+            continue;
+
+        drawList.push_back(n->num);
+    }
+    totalEntries = drawList.size();
+    int perPage = visibleNodeRows * totalColumns;
+
+    int maxScroll = 0;
+    if (perPage > 0) {
+        maxScroll = std::max(0, (totalEntries - 1) / perPage);
+    }
+
+    if (scrollIndex > maxScroll)
+        scrollIndex = maxScroll;
+    int startIndex = scrollIndex * visibleNodeRows * totalColumns;
+    int endIndex = std::min(startIndex + visibleNodeRows * totalColumns, totalEntries);
     int yOffset = 0;
     int col = 0;
     int lastNodeY = y;
     int shownCount = 0;
     int rowCount = 0;
 
-    for (int i = startIndex; i < endIndex; ++i) {
-        if (locationScreen && !nodeDB->getMeshNodeByIndex(i)->has_position) {
-            numskipped++;
-            continue;
-        }
+    for (int idx = startIndex; idx < endIndex; idx++) {
+        uint32_t nodeNum = drawList[idx];
+        auto *node = nodeDB->getMeshNode(nodeNum);
         int xPos = x + (col * columnWidth);
         int yPos = y + yOffset;
-        renderer(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth);
 
-        if (extras) {
-            extras(display, nodeDB->getMeshNodeByIndex(i), xPos, yPos, columnWidth, heading, lat, lon);
-        }
+        renderer(display, node, xPos, yPos, columnWidth);
+
+        if (extras)
+            extras(display, node, xPos, yPos, columnWidth, heading, lat, lon);
 
         lastNodeY = std::max(lastNodeY, yPos + FONT_HEIGHT_SMALL);
         yOffset += rowYOffset;
@@ -495,17 +563,73 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
     // This should correct the scrollbar
     totalEntries -= numskipped;
 
-#if !defined(M5STACK_UNITC6L)
     // Draw column separator
-    if (shownCount > 0) {
+    if (currentResolution != ScreenResolution::UltraLow && shownCount > 0) {
         const int firstNodeY = y + 3;
-        drawColumnSeparator(display, x, firstNodeY, lastNodeY);
+        for (int horizontal_offset = 1; horizontal_offset < totalColumns; horizontal_offset++) {
+            drawColumnSeparator(display, columnWidth * horizontal_offset, firstNodeY, lastNodeY);
+        }
     }
 
-#endif
     const int scrollStartY = y + 3;
-    drawScrollbar(display, visibleNodeRows, totalEntries, scrollIndex, 2, scrollStartY);
+    drawScrollbar(display, visibleNodeRows, totalEntries, scrollIndex, totalColumns, scrollStartY);
     graphics::drawCommonFooter(display, x, y);
+
+    // Scroll Popup Overlay
+    if (millis() - popupTime < POPUP_DURATION_MS) {
+        popupTotal = totalEntries;
+
+        int perPage = visibleNodeRows * totalColumns;
+
+        popupStart = startIndex + 1;
+        popupEnd = std::min(startIndex + perPage, totalEntries);
+
+        popupPage = (scrollIndex + 1);
+        popupMaxPage = std::max(1, (totalEntries + perPage - 1) / perPage);
+
+        char buf[32];
+        snprintf(buf, sizeof(buf), "%d-%d/%d  Pg %d/%d", popupStart, popupEnd, popupTotal, popupPage, popupMaxPage);
+
+        display->setTextAlignment(TEXT_ALIGN_LEFT);
+
+        // Box padding
+        int padding = 2;
+        int textW = display->getStringWidth(buf);
+        int textH = FONT_HEIGHT_SMALL;
+        int boxWidth = textW + padding * 3;
+        int boxHeight = textH + padding * 2;
+
+        // Center of usable screen area:
+        int headerHeight = FONT_HEIGHT_SMALL - 1;
+        int footerHeight = FONT_HEIGHT_SMALL + 2;
+
+        int usableTop = headerHeight;
+        int usableBottom = display->getHeight() - footerHeight;
+        int usableHeight = usableBottom - usableTop;
+
+        // Center point inside usable area
+        int boxLeft = (display->getWidth() - boxWidth) / 2;
+        int boxTop = usableTop + (usableHeight - boxHeight) / 2;
+
+        // Draw Box
+        display->setColor(BLACK);
+        display->fillRect(boxLeft - 1, boxTop - 1, boxWidth + 2, boxHeight + 2);
+        display->fillRect(boxLeft, boxTop - 2, boxWidth, 1);
+        display->fillRect(boxLeft, boxTop + boxHeight + 1, boxWidth, 1);
+        display->fillRect(boxLeft - 2, boxTop, 1, boxHeight);
+        display->fillRect(boxLeft + boxWidth + 1, boxTop, 1, boxHeight);
+        display->setColor(WHITE);
+        display->drawRect(boxLeft, boxTop, boxWidth, boxHeight);
+        display->setColor(BLACK);
+        display->fillRect(boxLeft, boxTop, 1, 1);
+        display->fillRect(boxLeft + boxWidth - 1, boxTop, 1, 1);
+        display->fillRect(boxLeft, boxTop + boxHeight - 1, 1, 1);
+        display->fillRect(boxLeft + boxWidth - 1, boxTop + boxHeight - 1, 1, 1);
+        display->setColor(WHITE);
+
+        // Text
+        display->drawString(boxLeft + padding, boxTop + padding, buf);
+    }
 }
 
 // =============================
@@ -513,10 +637,11 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 // =============================
 
 #ifndef USE_EINK
-void drawDynamicNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+// Node list for Last Heard and Hop Signal views
+void drawDynamicListScreen_Nodes(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     // Static variables to track mode and duration
-    static NodeListMode lastRenderedMode = MODE_COUNT;
+    static ListMode_Node lastRenderedMode = MODE_COUNT_NODE;
     static unsigned long modeStartTime = 0;
 
     unsigned long now = millis();
@@ -529,23 +654,65 @@ void drawDynamicNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state,
     }
 #endif
     // On very first call (on boot or state enter)
-    if (lastRenderedMode == MODE_COUNT) {
-        currentMode = MODE_LAST_HEARD;
+    if (lastRenderedMode == MODE_COUNT_NODE) {
+        currentMode_Nodes = MODE_LAST_HEARD;
         modeStartTime = now;
     }
 
     // Time to switch to next mode?
     if (now - modeStartTime >= getModeCycleIntervalMs()) {
-        currentMode = static_cast<NodeListMode>((currentMode + 1) % MODE_COUNT);
+        currentMode_Nodes = static_cast<ListMode_Node>((currentMode_Nodes + 1) % MODE_COUNT_NODE);
         modeStartTime = now;
     }
 
     // Render screen based on currentMode
-    const char *title = getCurrentModeTitle(display->getWidth());
-    drawNodeListScreen(display, state, x, y, title, drawEntryDynamic);
+    const char *title = getCurrentModeTitle_Nodes(display->getWidth());
+    drawNodeListScreen(display, state, x, y, title, drawEntryDynamic_Nodes);
 
     // Track the last mode to avoid reinitializing modeStartTime
-    lastRenderedMode = currentMode;
+    lastRenderedMode = currentMode_Nodes;
+}
+
+// Node list for Distance and Bearings views
+void drawDynamicListScreen_Location(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    // Static variables to track mode and duration
+    static ListMode_Location lastRenderedMode = MODE_COUNT_LOCATION;
+    static unsigned long modeStartTime = 0;
+
+    unsigned long now = millis();
+
+#if defined(M5STACK_UNITC6L)
+    display->clear();
+    if (now - lastSwitchTime >= 3000) {
+        display->display();
+        lastSwitchTime = now;
+    }
+#endif
+    // On very first call (on boot or state enter)
+    if (lastRenderedMode == MODE_COUNT_LOCATION) {
+        currentMode_Location = MODE_DISTANCE;
+        modeStartTime = now;
+    }
+
+    // Time to switch to next mode?
+    if (now - modeStartTime >= getModeCycleIntervalMs()) {
+        currentMode_Location = static_cast<ListMode_Location>((currentMode_Location + 1) % MODE_COUNT_LOCATION);
+        modeStartTime = now;
+    }
+
+    // Render screen based on currentMode
+    const char *title = getCurrentModeTitle_Location(display->getWidth());
+
+    // Render screen based on currentMode_Location
+    if (currentMode_Location == MODE_DISTANCE) {
+        drawNodeListScreen(display, state, x, y, title, drawNodeDistance);
+    } else if (currentMode_Location == MODE_BEARING) {
+        drawNodeListWithCompasses(display, state, x, y);
+    }
+
+    // Track the last mode to avoid reinitializing modeStartTime
+    lastRenderedMode = currentMode_Location;
 }
 #endif
 
@@ -566,14 +733,12 @@ void drawHopSignalScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
 #endif
     drawNodeListScreen(display, state, x, y, title, drawEntryHopSignal);
 }
-
 void drawDistanceScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     const char *title = "Distance";
     drawNodeListScreen(display, state, x, y, title, drawNodeDistance);
 }
 #endif
-
 void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     float heading = 0;
diff --git a/src/graphics/draw/NodeListRenderer.h b/src/graphics/draw/NodeListRenderer.h
index ea8df8bd9..e212c031b 100644
--- a/src/graphics/draw/NodeListRenderer.h
+++ b/src/graphics/draw/NodeListRenderer.h
@@ -23,8 +23,11 @@ namespace NodeListRenderer
 typedef void (*EntryRenderer)(OLEDDisplay *, meshtastic_NodeInfoLite *, int16_t, int16_t, int);
 typedef void (*NodeExtrasRenderer)(OLEDDisplay *, meshtastic_NodeInfoLite *, int16_t, int16_t, int, float, double, double);
 
-// Node list mode enumeration
-enum NodeListMode { MODE_LAST_HEARD = 0, MODE_HOP_SIGNAL = 1, MODE_DISTANCE = 2, MODE_COUNT = 3 };
+// Node list mode enumeration for Last Heard and Hop Signal views
+enum ListMode_Node { MODE_LAST_HEARD = 0, MODE_HOP_SIGNAL = 1, MODE_COUNT_NODE = 2 };
+
+// Node list mode enumeration for Distance and Bearings views
+enum ListMode_Location { MODE_DISTANCE = 0, MODE_BEARING = 1, MODE_COUNT_LOCATION = 2 };
 
 // Main node list screen function
 void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *title,
@@ -35,7 +38,7 @@ void drawNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t
 void drawEntryLastHeard(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 void drawEntryHopSignal(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 void drawNodeDistance(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
-void drawEntryDynamic(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
+void drawEntryDynamic_Nodes(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 void drawEntryCompass(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16_t x, int16_t y, int columnWidth);
 
 // Extras renderers
@@ -46,14 +49,20 @@ void drawCompassArrow(OLEDDisplay *display, meshtastic_NodeInfoLite *node, int16
 void drawLastHeardScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 void drawHopSignalScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 void drawDistanceScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
-void drawDynamicNodeListScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+void drawDynamicListScreen_Nodes(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+void drawDynamicListScreen_Location(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 void drawNodeListWithCompasses(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 
 // Utility functions
-const char *getCurrentModeTitle(int screenWidth);
-const char *getSafeNodeName(meshtastic_NodeInfoLite *node);
+const char *getCurrentModeTitle_Nodes(int screenWidth);
+const char *getCurrentModeTitle_Location(int screenWidth);
+const char *getSafeNodeName(meshtastic_NodeInfoLite *node, int columnWidth);
 void drawColumns(OLEDDisplay *display, int16_t x, int16_t y, const char **fields);
 
+// Scrolling controls
+void scrollUp();
+void scrollDown();
+
 // Bitmap drawing function
 void drawScaledXBitmap16x16(int x, int y, int width, int height, const uint8_t *bitmapXBM, OLEDDisplay *display);
 
diff --git a/src/graphics/draw/NotificationRenderer.cpp b/src/graphics/draw/NotificationRenderer.cpp
index e95cc1610..8d76b4592 100644
--- a/src/graphics/draw/NotificationRenderer.cpp
+++ b/src/graphics/draw/NotificationRenderer.cpp
@@ -1,6 +1,6 @@
 #include "configuration.h"
-#if HAS_SCREEN
 
+#if HAS_SCREEN
 #include "DisplayFormatters.h"
 #include "NodeDB.h"
 #include "NotificationRenderer.h"
@@ -38,7 +38,7 @@ extern bool hasUnreadMessage;
 
 namespace graphics
 {
-
+int bannerSignalBars = -1;
 InputEvent NotificationRenderer::inEvent;
 int8_t NotificationRenderer::curSelected = 0;
 char NotificationRenderer::alertBannerMessage[256] = {0};
@@ -321,7 +321,7 @@ void NotificationRenderer::drawNodePicker(OLEDDisplay *display, OLEDDisplayUiSta
         }
         if (i == curSelected) {
             selectedNodenum = nodeDB->getMeshNodeByIndex(i + 1)->num;
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 strncpy(scratchLineBuffer[scratchLineNum], "> ", 3);
                 strncpy(scratchLineBuffer[scratchLineNum] + 2, temp_name, 36);
                 strncpy(scratchLineBuffer[scratchLineNum] + strlen(temp_name) + 2, " <", 3);
@@ -449,7 +449,7 @@ void NotificationRenderer::drawAlertBannerOverlay(OLEDDisplay *display, OLEDDisp
 
     for (int i = firstOptionToShow; i < alertBannerOptions && linesShown < visibleTotalLines; i++, linesShown++) {
         if (i == curSelected) {
-            if (isHighResolution) {
+            if (currentResolution == ScreenResolution::High) {
                 strncpy(lineBuffer, "> ", 3);
                 strncpy(lineBuffer + 2, optionsArrayPtr[i], 36);
                 strncpy(lineBuffer + strlen(optionsArrayPtr[i]) + 2, " <", 3);
@@ -477,7 +477,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
 
     bool is_picker = false;
     uint16_t lineCount = 0;
-    // === Layout Configuration ===
+    // Layout Configuration
     constexpr uint16_t hPadding = 5;
     constexpr uint16_t vPadding = 2;
     bool needs_bell = false;
@@ -491,13 +491,32 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     display->setFont(FONT_SMALL);
     display->setTextAlignment(TEXT_ALIGN_LEFT);
 
+    // Track widest line INCLUDING bars (but don't change per-line widths)
+    uint16_t widestLineWithBars = 0;
+
     while (lines[lineCount] != nullptr) {
         auto newlinePointer = strchr(lines[lineCount], '\n');
         if (newlinePointer)
             lineLengths[lineCount] = (newlinePointer - lines[lineCount]); // Check for newlines first
         else // if the newline wasn't found, then pull string length from strlen
             lineLengths[lineCount] = strlen(lines[lineCount]);
+
         lineWidths[lineCount] = display->getStringWidth(lines[lineCount], lineLengths[lineCount], true);
+
+        // Consider extra width for signal bars on lines that contain "Signal:"
+        uint16_t potentialWidth = lineWidths[lineCount];
+        if (graphics::bannerSignalBars >= 0 && strncmp(lines[lineCount], "Signal:", 7) == 0) {
+            const int totalBars = 5;
+            const int barWidth = 3;
+            const int barSpacing = 2;
+            const int gap = 6; // space between text and bars
+            int barsWidth = totalBars * barWidth + (totalBars - 1) * barSpacing + gap;
+            potentialWidth += barsWidth;
+        }
+
+        if (potentialWidth > widestLineWithBars)
+            widestLineWithBars = potentialWidth;
+
         if (!is_picker) {
             needs_bell |= (strstr(alertBannerMessage, "Alert Received") != nullptr);
             if (lineWidths[lineCount] > maxWidth)
@@ -507,12 +526,16 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     }
     // count lines
 
+    // Ensure box accounts for signal bars if present
+    if (widestLineWithBars > maxWidth)
+        maxWidth = widestLineWithBars;
+
     uint16_t boxWidth = hPadding * 2 + maxWidth;
-#if defined(M5STACK_UNITC6L)
+
     if (needs_bell) {
-        if (isHighResolution && boxWidth <= 150)
+        if ((currentResolution == ScreenResolution::High) && boxWidth <= 150)
             boxWidth += 26;
-        if (!isHighResolution && boxWidth <= 100)
+        if ((currentResolution == ScreenResolution::Low || currentResolution == ScreenResolution::UltraLow) && boxWidth <= 100)
             boxWidth += 20;
     }
 
@@ -521,14 +544,17 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     uint8_t visibleTotalLines = std::min<uint8_t>(lineCount, (screenHeight - vPadding * 2) / effectiveLineHeight);
     uint16_t contentHeight = visibleTotalLines * effectiveLineHeight;
     uint16_t boxHeight = contentHeight + vPadding * 2;
-    if (visibleTotalLines == 1)
-        boxHeight += (isHighResolution ? 4 : 3);
+    if (visibleTotalLines == 1) {
+        boxHeight += (currentResolution == ScreenResolution::High) ? 4 : 3;
+    }
 
     int16_t boxLeft = (display->width() / 2) - (boxWidth / 2);
-    if (totalLines > visibleTotalLines)
-        boxWidth += (isHighResolution ? 4 : 2);
+    if (totalLines > visibleTotalLines) {
+        boxWidth += (currentResolution == ScreenResolution::High) ? 4 : 2;
+    }
     int16_t boxTop = (display->height() / 2) - (boxHeight / 2);
-
+    boxHeight += (currentResolution == ScreenResolution::High) ? 2 : 1;
+#if defined(M5STACK_UNITC6L)
     if (visibleTotalLines == 1) {
         boxTop += 25;
     }
@@ -539,127 +565,9 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
         if (boxTop < 0)
             boxTop = 0;
     }
+#endif
 
-    // === Draw Box ===
-    display->setColor(BLACK);
-    display->fillRect(boxLeft, boxTop, boxWidth, boxHeight);
-    display->setColor(WHITE);
-    display->drawRect(boxLeft, boxTop, boxWidth, boxHeight);
-    display->fillRect(boxLeft, boxTop - 2, boxWidth, 1);
-    display->fillRect(boxLeft - 2, boxTop, 1, boxHeight);
-    display->fillRect(boxLeft + boxWidth + 1, boxTop, 1, boxHeight);
-    display->setColor(BLACK);
-    display->fillRect(boxLeft, boxTop, 1, 1);
-    display->fillRect(boxLeft + boxWidth - 1, boxTop, 1, 1);
-    display->fillRect(boxLeft, boxTop + boxHeight - 1, 1, 1);
-    display->fillRect(boxLeft + boxWidth - 1, boxTop + boxHeight - 1, 1, 1);
-    display->setColor(WHITE);
-    int16_t lineY = boxTop + vPadding;
-    int swingRange = 8;
-    static int swingOffset = 0;
-    static bool swingRight = true;
-    static unsigned long lastSwingTime = 0;
-    unsigned long now = millis();
-    int swingSpeedMs = 10 / (swingRange * 2);
-    if (now - lastSwingTime >= (unsigned long)swingSpeedMs) {
-        lastSwingTime = now;
-        if (swingRight) {
-            swingOffset++;
-            if (swingOffset >= swingRange)
-                swingRight = false;
-        } else {
-            swingOffset--;
-            if (swingOffset <= 0)
-                swingRight = true;
-        }
-    }
-    for (int i = 0; i < lineCount; i++) {
-        bool isTitle = (i == 0);
-        int globalOptionIndex = (i - 1) + firstOptionToShow;
-        bool isSelectedOption = (!isTitle && globalOptionIndex >= 0 && globalOptionIndex == curSelected);
-
-        uint16_t visibleWidth = 64 - hPadding * 2;
-        if (totalLines > visibleTotalLines)
-            visibleWidth -= 6;
-        char lineBuffer[lineLengths[i] + 1];
-        strncpy(lineBuffer, lines[i], lineLengths[i]);
-        lineBuffer[lineLengths[i]] = '\0';
-
-        if (isTitle) {
-            if (visibleTotalLines == 1) {
-                display->setColor(BLACK);
-                display->fillRect(boxLeft, boxTop, boxWidth, effectiveLineHeight);
-                display->setColor(WHITE);
-                display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, boxTop, lineBuffer);
-            } else {
-                display->setColor(WHITE);
-                display->fillRect(boxLeft, boxTop, boxWidth, effectiveLineHeight);
-                display->setColor(BLACK);
-                display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, boxTop, lineBuffer);
-                display->setColor(WHITE);
-                if (needs_bell) {
-                    int bellY = boxTop + (FONT_HEIGHT_SMALL - 8) / 2;
-                    display->drawXbm(boxLeft + (boxWidth - lineWidths[i]) / 2 - 10, bellY, 8, 8, bell_alert);
-                    display->drawXbm(boxLeft + (boxWidth + lineWidths[i]) / 2 + 2, bellY, 8, 8, bell_alert);
-                }
-            }
-            lineY = boxTop + effectiveLineHeight + 1;
-        } else if (isSelectedOption) {
-            display->setColor(WHITE);
-            display->fillRect(boxLeft, lineY, boxWidth, effectiveLineHeight);
-            display->setColor(BLACK);
-            if (lineLengths[i] > 15 && lineWidths[i] > visibleWidth) {
-                int textX = boxLeft + hPadding + swingOffset;
-                display->drawString(textX, lineY - 1, lineBuffer);
-            } else {
-                display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, lineY - 1, lineBuffer);
-            }
-            display->setColor(WHITE);
-            lineY += effectiveLineHeight;
-        } else {
-            display->setColor(BLACK);
-            display->fillRect(boxLeft, lineY, boxWidth, effectiveLineHeight);
-            display->setColor(WHITE);
-            display->drawString(boxLeft + (boxWidth - lineWidths[i]) / 2, lineY, lineBuffer);
-            lineY += effectiveLineHeight;
-        }
-    }
-    if (totalLines > visibleTotalLines) {
-        const uint8_t scrollBarWidth = 5;
-        int16_t scrollBarX = boxLeft + boxWidth - scrollBarWidth - 2;
-        int16_t scrollBarY = boxTop + vPadding + effectiveLineHeight;
-        uint16_t scrollBarHeight = boxHeight - vPadding * 2 - effectiveLineHeight;
-        float ratio = (float)visibleTotalLines / totalLines;
-        uint16_t indicatorHeight = std::max((int)(scrollBarHeight * ratio), 4);
-        float scrollRatio = (float)(firstOptionToShow + lineCount - visibleTotalLines) / (totalLines - visibleTotalLines);
-        uint16_t indicatorY = scrollBarY + scrollRatio * (scrollBarHeight - indicatorHeight);
-        display->drawRect(scrollBarX, scrollBarY, scrollBarWidth, scrollBarHeight);
-        display->fillRect(scrollBarX + 1, indicatorY, scrollBarWidth - 2, indicatorHeight);
-    }
-#else
-    if (needs_bell) {
-        if (isHighResolution && boxWidth <= 150)
-            boxWidth += 26;
-        if (!isHighResolution && boxWidth <= 100)
-            boxWidth += 20;
-    }
-
-    uint16_t screenHeight = display->height();
-    uint8_t effectiveLineHeight = FONT_HEIGHT_SMALL - 3;
-    uint8_t visibleTotalLines = std::min<uint8_t>(lineCount, (screenHeight - vPadding * 2) / effectiveLineHeight);
-    uint16_t contentHeight = visibleTotalLines * effectiveLineHeight;
-    uint16_t boxHeight = contentHeight + vPadding * 2;
-    if (visibleTotalLines == 1) {
-        boxHeight += (isHighResolution) ? 4 : 3;
-    }
-
-    int16_t boxLeft = (display->width() / 2) - (boxWidth / 2);
-    if (totalLines > visibleTotalLines) {
-        boxWidth += (isHighResolution) ? 4 : 2;
-    }
-    int16_t boxTop = (display->height() / 2) - (boxHeight / 2);
-
-    // === Draw Box ===
+    // Draw Box
     display->setColor(BLACK);
     display->fillRect(boxLeft - 1, boxTop - 1, boxWidth + 2, boxHeight + 2);
     display->fillRect(boxLeft, boxTop - 2, boxWidth, 1);
@@ -675,7 +583,7 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
     display->fillRect(boxLeft + boxWidth - 1, boxTop + boxHeight - 1, 1, 1);
     display->setColor(WHITE);
 
-    // === Draw Content ===
+    // Draw Content
     int16_t lineY = boxTop + vPadding;
     for (int i = 0; i < lineCount; i++) {
         int16_t textX = boxLeft + (boxWidth - lineWidths[i]) / 2;
@@ -704,17 +612,47 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
             lineY += (effectiveLineHeight - 2 - background_yOffset);
         } else {
             // Pop-up
-            display->drawString(textX, lineY, lineBuffer);
+            // If this is the Signal line, center text + bars as one group
+            bool isSignalLine = (graphics::bannerSignalBars >= 0 && strstr(lineBuffer, "Signal:") != nullptr);
+            if (isSignalLine) {
+                const int totalBars = 5;
+                const int barWidth = 3;
+                const int barSpacing = 2;
+                const int barHeightStep = 2;
+                const int gap = 6;
+
+                int textWidth = display->getStringWidth(lineBuffer, strlen(lineBuffer), true);
+                int barsWidth = totalBars * barWidth + (totalBars - 1) * barSpacing + gap;
+                int totalWidth = textWidth + barsWidth;
+                int groupStartX = boxLeft + (boxWidth - totalWidth) / 2;
+
+                display->drawString(groupStartX, lineY, lineBuffer);
+
+                int baseX = groupStartX + textWidth + gap;
+                int baseY = lineY + effectiveLineHeight - 1;
+                for (int b = 0; b < totalBars; b++) {
+                    int barHeight = (b + 1) * barHeightStep;
+                    int x = baseX + b * (barWidth + barSpacing);
+                    int y = baseY - barHeight;
+
+                    if (b < graphics::bannerSignalBars) {
+                        display->fillRect(x, y, barWidth, barHeight);
+                    } else {
+                        display->drawRect(x, y, barWidth, barHeight);
+                    }
+                }
+            } else {
+                display->drawString(textX, lineY, lineBuffer);
+            }
             lineY += (effectiveLineHeight);
         }
     }
 
-    // === Scroll Bar (Thicker, inside box, not over title) ===
+    // Scroll Bar (Thicker, inside box, not over title)
     if (totalLines > visibleTotalLines) {
         const uint8_t scrollBarWidth = 5;
-
         int16_t scrollBarX = boxLeft + boxWidth - scrollBarWidth - 2;
-        int16_t scrollBarY = boxTop + vPadding + effectiveLineHeight; // start after title line
+        int16_t scrollBarY = boxTop + vPadding + effectiveLineHeight;
         uint16_t scrollBarHeight = boxHeight - vPadding * 2 - effectiveLineHeight;
 
         float ratio = (float)visibleTotalLines / totalLines;
@@ -725,7 +663,6 @@ void NotificationRenderer::drawNotificationBox(OLEDDisplay *display, OLEDDisplay
         display->drawRect(scrollBarX, scrollBarY, scrollBarWidth, scrollBarHeight);
         display->fillRect(scrollBarX + 1, indicatorY, scrollBarWidth - 2, indicatorHeight);
     }
-#endif
 }
 
 /// Draw the last text message we received
diff --git a/src/graphics/draw/UIRenderer.cpp b/src/graphics/draw/UIRenderer.cpp
index 1f01640bf..7ce9d5afe 100644
--- a/src/graphics/draw/UIRenderer.cpp
+++ b/src/graphics/draw/UIRenderer.cpp
@@ -6,10 +6,7 @@
 #include "NodeListRenderer.h"
 #include "UIRenderer.h"
 #include "airtime.h"
-#include "configuration.h"
 #include "gps/GeoCoord.h"
-#include "graphics/Screen.h"
-#include "graphics/ScreenFonts.h"
 #include "graphics/SharedUIDisplay.h"
 #include "graphics/TimeFormatters.h"
 #include "graphics/images.h"
@@ -29,6 +26,16 @@ namespace graphics
 NodeNum UIRenderer::currentFavoriteNodeNum = 0;
 std::vector<meshtastic_NodeInfoLite *> graphics::UIRenderer::favoritedNodes;
 
+static inline void drawSatelliteIcon(OLEDDisplay *display, int16_t x, int16_t y)
+{
+    int yOffset = (currentResolution == ScreenResolution::High) ? -5 : 1;
+    if (currentResolution == ScreenResolution::High) {
+        NodeListRenderer::drawScaledXBitmap16x16(x, y + yOffset, imgSatellite_width, imgSatellite_height, imgSatellite, display);
+    } else {
+        display->drawXbm(x + 1, y + yOffset, imgSatellite_width, imgSatellite_height, imgSatellite);
+    }
+}
+
 void graphics::UIRenderer::rebuildFavoritedNodes()
 {
     favoritedNodes.clear();
@@ -56,7 +63,7 @@ extern uint32_t dopThresholds[5];
 void UIRenderer::drawGps(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gps)
 {
     // Draw satellite image
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         NodeListRenderer::drawScaledXBitmap16x16(x, y - 2, imgSatellite_width, imgSatellite_height, imgSatellite, display);
     } else {
         display->drawXbm(x + 1, y + 1, imgSatellite_width, imgSatellite_height, imgSatellite);
@@ -76,7 +83,7 @@ void UIRenderer::drawGps(OLEDDisplay *display, int16_t x, int16_t y, const mesht
     } else {
         snprintf(textString, sizeof(textString), "%u sats", gps->getNumSatellites());
     }
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->drawString(x + 18, y, textString);
     } else {
         display->drawString(x + 11, y, textString);
@@ -244,16 +251,16 @@ void UIRenderer::drawGpsCoordinates(OLEDDisplay *display, int16_t x, int16_t y,
 
 // Draw nodes status
 void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::NodeStatus *nodeStatus, int node_offset,
-                           bool show_total, String additional_words)
+                           bool show_total, const char *additional_words)
 {
     char usersString[20];
     int nodes_online = (nodeStatus->getNumOnline() > 0) ? nodeStatus->getNumOnline() + node_offset : 0;
 
-    snprintf(usersString, sizeof(usersString), "%d %s", nodes_online, additional_words.c_str());
+    snprintf(usersString, sizeof(usersString), "%d %s", nodes_online, additional_words);
 
     if (show_total) {
         int nodes_total = (nodeStatus->getNumTotal() > 0) ? nodeStatus->getNumTotal() + node_offset : 0;
-        snprintf(usersString, sizeof(usersString), "%d/%d %s", nodes_online, nodes_total, additional_words.c_str());
+        snprintf(usersString, sizeof(usersString), "%d/%d %s", nodes_online, nodes_total, additional_words);
     }
 
 #if (defined(USE_EINK) || defined(ILI9341_DRIVER) || defined(ILI9342_DRIVER) || defined(ST7701_CS) || defined(ST7735_CS) ||      \
@@ -261,19 +268,19 @@ void UIRenderer::drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const mes
      defined(HACKADAY_COMMUNICATOR) || defined(USE_ST7796)) &&                                                                   \
     !defined(DISPLAY_FORCE_SMALL_FONTS)
 
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         NodeListRenderer::drawScaledXBitmap16x16(x, y - 1, 8, 8, imgUser, display);
     } else {
         display->drawFastImage(x, y + 3, 8, 8, imgUser);
     }
 #else
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         NodeListRenderer::drawScaledXBitmap16x16(x, y - 1, 8, 8, imgUser, display);
     } else {
         display->drawFastImage(x, y + 1, 8, 8, imgUser);
     }
 #endif
-    int string_offset = (isHighResolution) ? 9 : 0;
+    int string_offset = (currentResolution == ScreenResolution::High) ? 9 : 0;
     display->drawString(x + 10 + string_offset, y - 2, usersString);
 }
 
@@ -321,11 +328,12 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
     int line = 1; // which slot to use next
     std::string usernameStr;
     // === 1. Long Name (always try to show first) ===
-#if defined(M5STACK_UNITC6L)
-    const char *username = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
-#else
-    const char *username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
-#endif
+    const char *username;
+    if (currentResolution == ScreenResolution::UltraLow) {
+        username = (node->has_user && node->user.long_name[0]) ? node->user.short_name : nullptr;
+    } else {
+        username = (node->has_user && node->user.long_name[0]) ? node->user.long_name : nullptr;
+    }
 
     if (username) {
         usernameStr = sanitizeString(username); // Sanitize the incoming long_name just in case
@@ -501,7 +509,7 @@ void UIRenderer::drawNodeInfo(OLEDDisplay *display, const OLEDDisplayUiState *st
             const int margin = 4;
 // --------- PATCH FOR EINK NAV BAR (ONLY CHANGE BELOW) -----------
 #if defined(USE_EINK)
-            const int iconSize = (isHighResolution) ? 16 : 8;
+            const int iconSize = (currentResolution == ScreenResolution::High) ? 16 : 8;
             const int navBarHeight = iconSize + 6;
 #else
             const int navBarHeight = 0;
@@ -559,11 +567,11 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
     // === Header ===
-#if defined(M5STACK_UNITC6L)
-    graphics::drawCommonHeader(display, x, y, "Home");
-#else
-    graphics::drawCommonHeader(display, x, y, "");
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        graphics::drawCommonHeader(display, x, y, "Home");
+    } else {
+        graphics::drawCommonHeader(display, x, y, "");
+    }
 
     // === Content below header ===
 
@@ -578,15 +586,15 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     config.display.heading_bold = false;
 
     // Display Region and Channel Utilization
-#if defined(M5STACK_UNITC6L)
-    drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
-#else
-    drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
-#endif
+    if (currentResolution == ScreenResolution::UltraLow) {
+        drawNodes(display, x, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+    } else {
+        drawNodes(display, x + 1, getTextPositions(display)[line] + 2, nodeStatus, -1, false, "online");
+    }
     char uptimeStr[32] = "";
-#if !defined(M5STACK_UNITC6L)
-    getUptimeStr(millis(), "Up", uptimeStr, sizeof(uptimeStr));
-#endif
+    if (currentResolution != ScreenResolution::UltraLow) {
+        getUptimeStr(millis(), "Up", uptimeStr, sizeof(uptimeStr));
+    }
     display->drawString(SCREEN_WIDTH - display->getStringWidth(uptimeStr), getTextPositions(display)[line++], uptimeStr);
 
     // === Second Row: Satellites and Voltage ===
@@ -600,15 +608,8 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
         } else {
             displayLine = config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT ? "No GPS" : "GPS off";
         }
-        int yOffset = (isHighResolution) ? 3 : 1;
-        if (isHighResolution) {
-            NodeListRenderer::drawScaledXBitmap16x16(x, getTextPositions(display)[line] + yOffset - 5, imgSatellite_width,
-                                                     imgSatellite_height, imgSatellite, display);
-        } else {
-            display->drawXbm(x + 1, getTextPositions(display)[line] + yOffset, imgSatellite_width, imgSatellite_height,
-                             imgSatellite);
-        }
-        int xOffset = (isHighResolution) ? 6 : 0;
+        drawSatelliteIcon(display, x, getTextPositions(display)[line]);
+        int xOffset = (currentResolution == ScreenResolution::High) ? 6 : 0;
         display->drawString(x + 11 + xOffset, getTextPositions(display)[line], displayLine);
     } else {
         UIRenderer::drawGps(display, 0, getTextPositions(display)[line], gpsStatus);
@@ -647,21 +648,22 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     char chUtilPercentage[10];
     snprintf(chUtilPercentage, sizeof(chUtilPercentage), "%2.0f%%", airTime->channelUtilizationPercent());
 
-    int chUtil_x = (isHighResolution) ? display->getStringWidth(chUtil) + 10 : display->getStringWidth(chUtil) + 5;
+    int chUtil_x = (currentResolution == ScreenResolution::High) ? display->getStringWidth(chUtil) + 10
+                                                                 : display->getStringWidth(chUtil) + 5;
     int chUtil_y = getTextPositions(display)[line] + 3;
 
-    int chutil_bar_width = (isHighResolution) ? 100 : 50;
+    int chutil_bar_width = (currentResolution == ScreenResolution::High) ? 100 : 50;
     if (!config.bluetooth.enabled) {
 #if defined(USE_EINK)
-        chutil_bar_width = (isHighResolution) ? 50 : 30;
+        chutil_bar_width = (currentResolution == ScreenResolution::High) ? 50 : 30;
 #else
-        chutil_bar_width = (isHighResolution) ? 80 : 40;
+        chutil_bar_width = (currentResolution == ScreenResolution::High) ? 80 : 40;
 #endif
     }
-    int chutil_bar_height = (isHighResolution) ? 12 : 7;
-    int extraoffset = (isHighResolution) ? 6 : 3;
+    int chutil_bar_height = (currentResolution == ScreenResolution::High) ? 12 : 7;
+    int extraoffset = (currentResolution == ScreenResolution::High) ? 6 : 3;
     if (!config.bluetooth.enabled) {
-        extraoffset = (isHighResolution) ? 6 : 1;
+        extraoffset = (currentResolution == ScreenResolution::High) ? 6 : 1;
     }
     int chutil_percent = airTime->channelUtilizationPercent();
 
@@ -721,7 +723,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
     // === Fourth & Fifth Rows: Node Identity ===
     int textWidth = 0;
     int nameX = 0;
-    int yOffset = (isHighResolution) ? 0 : 5;
+    int yOffset = (currentResolution == ScreenResolution::High) ? 0 : 5;
     std::string longNameStr;
 
     if (ourNode && ourNode->has_user && strlen(ourNode->user.long_name) > 0) {
@@ -759,7 +761,7 @@ void UIRenderer::drawDeviceFocused(OLEDDisplay *display, OLEDDisplayUiState *sta
 
 // Start Functions to write date/time to the screen
 // Helper function to check if a year is a leap year
-bool isLeapYear(int year)
+constexpr bool isLeapYear(int year)
 {
     return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
 }
@@ -990,15 +992,8 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
         } else {
             displayLine = config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT ? "No GPS" : "GPS off";
         }
-        int yOffset = (isHighResolution) ? 3 : 1;
-        if (isHighResolution) {
-            NodeListRenderer::drawScaledXBitmap16x16(x, getTextPositions(display)[line] + yOffset - 5, imgSatellite_width,
-                                                     imgSatellite_height, imgSatellite, display);
-        } else {
-            display->drawXbm(x + 1, getTextPositions(display)[line] + yOffset, imgSatellite_width, imgSatellite_height,
-                             imgSatellite);
-        }
-        int xOffset = (isHighResolution) ? 6 : 0;
+        drawSatelliteIcon(display, x, getTextPositions(display)[line]);
+        int xOffset = (currentResolution == ScreenResolution::High) ? 6 : 0;
         display->drawString(x + 11 + xOffset, getTextPositions(display)[line++], displayLine);
     } else {
         // Onboard GPS
@@ -1156,7 +1151,7 @@ void UIRenderer::drawCompassAndLocationScreen(OLEDDisplay *display, OLEDDisplayU
 void UIRenderer::drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     static const uint8_t xbm[] = USERPREFS_OEM_IMAGE_DATA;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->drawXbm(x + (SCREEN_WIDTH - USERPREFS_OEM_IMAGE_WIDTH) / 2,
                          y + (SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM - USERPREFS_OEM_IMAGE_HEIGHT) / 2 + 2, USERPREFS_OEM_IMAGE_WIDTH,
                          USERPREFS_OEM_IMAGE_HEIGHT, xbm);
@@ -1181,7 +1176,7 @@ void UIRenderer::drawOEMIconScreen(const char *upperMsg, OLEDDisplay *display, O
 
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     const char *title = USERPREFS_OEM_TEXT;
-    if (isHighResolution) {
+    if (currentResolution == ScreenResolution::High) {
         display->drawString(x + getStringCenteredX(title), y + SCREEN_HEIGHT - FONT_HEIGHT_MEDIUM, title);
     }
     display->setFont(FONT_SMALL);
@@ -1225,15 +1220,15 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
         lastFrameChangeTime = millis();
     }
 
-    const int iconSize = isHighResolution ? 16 : 8;
-    const int spacing = isHighResolution ? 8 : 4;
-    const int bigOffset = isHighResolution ? 1 : 0;
+    const int iconSize = (currentResolution == ScreenResolution::High) ? 16 : 8;
+    const int spacing = (currentResolution == ScreenResolution::High) ? 8 : 4;
+    const int bigOffset = (currentResolution == ScreenResolution::High) ? 1 : 0;
 
     const size_t totalIcons = screen->indicatorIcons.size();
     if (totalIcons == 0)
         return;
 
-    const int navPadding = isHighResolution ? 24 : 12; // padding per side
+    const int navPadding = (currentResolution == ScreenResolution::High) ? 24 : 12; // padding per side
 
     int usableWidth = SCREEN_WIDTH - (navPadding * 2);
     if (usableWidth < iconSize)
@@ -1300,7 +1295,7 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
             display->setColor(BLACK);
         }
 
-        if (isHighResolution) {
+        if (currentResolution == ScreenResolution::High) {
             NodeListRenderer::drawScaledXBitmap16x16(x, y, 8, 8, icon, display);
         } else {
             display->drawXbm(x, y, iconSize, iconSize, icon);
@@ -1315,7 +1310,7 @@ void UIRenderer::drawNavigationBar(OLEDDisplay *display, OLEDDisplayUiState *sta
     auto drawArrow = [&](bool rightSide) {
         display->setColor(WHITE);
 
-        const int offset = isHighResolution ? 3 : 1;
+        const int offset = (currentResolution == ScreenResolution::High) ? 3 : 1;
         const int halfH = rectHeight / 2;
 
         const int top = (y - 2) + (rectHeight - halfH) / 2;
diff --git a/src/graphics/draw/UIRenderer.h b/src/graphics/draw/UIRenderer.h
index 438d56cc2..6e37b68f2 100644
--- a/src/graphics/draw/UIRenderer.h
+++ b/src/graphics/draw/UIRenderer.h
@@ -34,7 +34,7 @@ class UIRenderer
   public:
     // Common UI elements
     static void drawNodes(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::NodeStatus *nodeStatus,
-                          int node_offset = 0, bool show_total = true, String additional_words = "");
+                          int node_offset = 0, bool show_total = true, const char *additional_words = "");
 
     // GPS status functions
     static void drawGps(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
@@ -43,9 +43,6 @@ class UIRenderer
     static void drawGpsAltitude(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
     static void drawGpsPowerStatus(OLEDDisplay *display, int16_t x, int16_t y, const meshtastic::GPSStatus *gpsStatus);
 
-    // Layout and utility functions
-    static void drawScrollbar(OLEDDisplay *display, int visibleItems, int totalItems, int scrollIndex, int x, int startY);
-
     // Overlay and special screens
     static void drawFrameText(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y, const char *text);
 
@@ -83,8 +80,6 @@ class UIRenderer
     static std::string drawTimeDelta(uint32_t days, uint32_t hours, uint32_t minutes, uint32_t seconds);
     static int formatDateTime(char *buffer, size_t bufferSize, uint32_t rtc_sec, OLEDDisplay *display, bool showTime);
 
-    // Message filtering
-    static bool shouldDrawMessage(const meshtastic_MeshPacket *packet);
     // Check if the display can render a string (detect special chars; emoji)
     static bool haveGlyphs(const char *str);
 }; // namespace UIRenderer
diff --git a/src/graphics/images.h b/src/graphics/images.h
index c268b3269..ef9ffef78 100644
--- a/src/graphics/images.h
+++ b/src/graphics/images.h
@@ -304,58 +304,6 @@ const uint8_t chirpy[] = {
     0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x18, 0x06, 0x18, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01, 0x0c, 0x03, 0x30, 0xe0, 0x01,
     0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0xe0, 0xfe, 0xff, 0xff, 0xff, 0xdf};
 
-#define chirpy_width_hirez 76
-#define chirpy_height_hirez 100
-const uint8_t chirpy_hirez[] = {
-    0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x03,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00,
-    0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc,
-    0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03,
-    0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0,
-    0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f,
-    0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0,
-    0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff,
-    0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f,
-    0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0,
-    0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff,
-    0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00,
-    0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc,
-    0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03,
-    0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0,
-    0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f,
-    0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0,
-    0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0x3f, 0xc0, 0xff, 0x0f, 0xf0, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff,
-    0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xf0, 0xff, 0x3f, 0xfc, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0x00, 0xfc, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f,
-    0x00, 0xfc, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03,
-    0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00,
-    0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
-    0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0, 0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xc0,
-    0x03, 0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00,
-    0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xf0, 0x00, 0x0f,
-    0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c,
-    0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x3c, 0xc0, 0x03, 0x3c, 0x00,
-    0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00,
-    0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0xfc,
-    0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03,
-    0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x03, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0x00,
-    0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0,
-    0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0xf0, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3};
-
 #define chirpy_small_image_width 8
 #define chirpy_small_image_height 8
 const uint8_t chirpy_small[] = {0x7f, 0x41, 0x55, 0x55, 0x55, 0x55, 0x41, 0x7f};
diff --git a/src/input/kbI2cBase.cpp b/src/input/kbI2cBase.cpp
index 0085c806b..12d0822f6 100644
--- a/src/input/kbI2cBase.cpp
+++ b/src/input/kbI2cBase.cpp
@@ -489,8 +489,6 @@ int32_t KbI2cBase::runOnce()
             case 0x90: // fn+r      INPUT_BROKER_MSG_REBOOT
             case 0x91: // fn+t
             case 0xac: // fn+m      INPUT_BROKER_MSG_MUTE_TOGGLE
-
-            case 0x8b: // fn+del    INPUT_BROKEN_MSG_DISMISS_FRAME
             case 0xAA: // fn+b      INPUT_BROKER_MSG_BLUETOOTH_TOGGLE
             case 0x8F: // fn+e      INPUT_BROKER_MSG_EMOTE_LIST
                 // just pass those unmodified
diff --git a/src/mesh/MeshModule.h b/src/mesh/MeshModule.h
index e7178bcfe..63f401d18 100644
--- a/src/mesh/MeshModule.h
+++ b/src/mesh/MeshModule.h
@@ -44,6 +44,7 @@ struct UIFrameEvent {
         REDRAW_ONLY,                    // Don't change which frames are show, just redraw, asap
         REGENERATE_FRAMESET,            // Regenerate (change? add? remove?) screen frames, honoring requestFocus()
         REGENERATE_FRAMESET_BACKGROUND, // Regenerate screen frames, Attempt to remain on the same frame throughout
+        SWITCH_TO_TEXTMESSAGE           // Jump directly to the Text Message screen
     } action = REDRAW_ONLY;
 
     // We might want to pass additional data inside this struct at some point
diff --git a/src/mesh/MeshService.cpp b/src/mesh/MeshService.cpp
index 297404747..c63e6d2d2 100644
--- a/src/mesh/MeshService.cpp
+++ b/src/mesh/MeshService.cpp
@@ -7,10 +7,12 @@
 #include "../concurrency/Periodic.h"
 #include "BluetoothCommon.h" // needed for updateBatteryLevel, FIXME, eventually when we pull mesh out into a lib we shouldn't be whacking bluetooth from here
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "RTC.h"
 #include "TypeConversions.h"
+#include "graphics/draw/MessageRenderer.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
 #include "meshUtils.h"
@@ -192,8 +194,16 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
         p.id = generatePacketId(); // If the phone didn't supply one, then pick one
 
     p.rx_time = getValidTime(RTCQualityFromNet); // Record the time the packet arrived from the phone
-                                                 // (so we update our nodedb for the local node)
 
+#if HAS_SCREEN
+    if (p.decoded.portnum == meshtastic_PortNum_TEXT_MESSAGE_APP && p.decoded.payload.size > 0 && p.to != NODENUM_BROADCAST &&
+        p.to != 0) // DM only
+    {
+        perhapsDecode(&p);
+        const StoredMessage &sm = messageStore.addFromPacket(p);
+        graphics::MessageRenderer::handleNewMessage(nullptr, sm, p); // notify UI
+    }
+#endif
     // Send the packet into the mesh
     DEBUG_HEAP_BEFORE;
     auto a = packetPool.allocCopy(p);
diff --git a/src/modules/CannedMessageModule.cpp b/src/modules/CannedMessageModule.cpp
index 73ee26903..5af9ebaac 100644
--- a/src/modules/CannedMessageModule.cpp
+++ b/src/modules/CannedMessageModule.cpp
@@ -7,12 +7,15 @@
 #include "Channels.h"
 #include "FSCommon.h"
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "SPILock.h"
 #include "buzz.h"
 #include "detect/ScanI2C.h"
+#include "gps/RTC.h"
 #include "graphics/Screen.h"
 #include "graphics/SharedUIDisplay.h"
+#include "graphics/draw/MessageRenderer.h"
 #include "graphics/draw/NotificationRenderer.h"
 #include "graphics/emotes.h"
 #include "graphics/images.h"
@@ -21,6 +24,7 @@
 #include "mesh/generated/meshtastic/cannedmessages.pb.h"
 #include "modules/AdminModule.h"
 #include "modules/ExternalNotificationModule.h" // for buzzer control
+extern MessageStore messageStore;
 #if HAS_TRACKBALL
 #include "input/TrackballInterruptImpl1.h"
 #endif
@@ -41,6 +45,75 @@
 // Remove Canned message screen if no action is taken for some milliseconds
 #define INACTIVATE_AFTER_MS 20000
 
+// Tokenize a message string into emote/text segments
+static std::vector<std::pair<bool, String>> tokenizeMessageWithEmotes(const char *msg)
+{
+    std::vector<std::pair<bool, String>> tokens;
+    int msgLen = strlen(msg);
+    int pos = 0;
+    while (pos < msgLen) {
+        const graphics::Emote *foundEmote = nullptr;
+        int foundLen = 0;
+        for (int j = 0; j < graphics::numEmotes; j++) {
+            const char *label = graphics::emotes[j].label;
+            int labelLen = strlen(label);
+            if (labelLen == 0)
+                continue;
+            if (strncmp(msg + pos, label, labelLen) == 0) {
+                if (!foundEmote || labelLen > foundLen) {
+                    foundEmote = &graphics::emotes[j];
+                    foundLen = labelLen;
+                }
+            }
+        }
+        if (foundEmote) {
+            tokens.emplace_back(true, String(foundEmote->label));
+            pos += foundLen;
+        } else {
+            // Find next emote
+            int nextEmote = msgLen;
+            for (int j = 0; j < graphics::numEmotes; j++) {
+                const char *label = graphics::emotes[j].label;
+                if (!label || !*label)
+                    continue;
+                const char *found = strstr(msg + pos, label);
+                if (found && (found - msg) < nextEmote) {
+                    nextEmote = found - msg;
+                }
+            }
+            int textLen = (nextEmote > pos) ? (nextEmote - pos) : (msgLen - pos);
+            if (textLen > 0) {
+                tokens.emplace_back(false, String(msg + pos).substring(0, textLen));
+                pos += textLen;
+            } else {
+                break;
+            }
+        }
+    }
+    return tokens;
+}
+
+// Render a single emote token centered vertically on a row
+static void renderEmote(OLEDDisplay *display, int &nextX, int lineY, int rowHeight, const String &label)
+{
+    const graphics::Emote *emote = nullptr;
+    for (int j = 0; j < graphics::numEmotes; j++) {
+        if (label == graphics::emotes[j].label) {
+            emote = &graphics::emotes[j];
+            break;
+        }
+    }
+    if (emote) {
+        int emoteYOffset = (rowHeight - emote->height) / 2; // vertically center the emote
+        display->drawXbm(nextX, lineY + emoteYOffset, emote->width, emote->height, emote->bitmap);
+        nextX += emote->width + 2; // spacing between tokens
+    }
+}
+
+namespace graphics
+{
+extern int bannerSignalBars;
+}
 extern ScanI2C::DeviceAddress cardkb_found;
 extern bool graphics::isMuted;
 extern bool osk_found;
@@ -72,18 +145,16 @@ CannedMessageModule::CannedMessageModule()
 
 void CannedMessageModule::LaunchWithDestination(NodeNum newDest, uint8_t newChannel)
 {
-    // Use the requested destination, unless it's "broadcast" and we have a previous node/channel
-    if (newDest == NODENUM_BROADCAST && lastDestSet) {
-        newDest = lastDest;
-        newChannel = lastChannel;
-    }
+    // Do NOT override explicit broadcast replies
+    // Only reuse lastDest in LaunchRepeatDestination()
+
     dest = newDest;
     channel = newChannel;
+
     lastDest = dest;
     lastChannel = channel;
     lastDestSet = true;
 
-    // Rest of function unchanged...
     // Upon activation, highlight "[Select Destination]"
     int selectDestination = 0;
     for (int i = 0; i < messagesCount; ++i) {
@@ -100,6 +171,8 @@ void CannedMessageModule::LaunchWithDestination(NodeNum newDest, uint8_t newChan
     UIFrameEvent e;
     e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
     notifyObservers(&e);
+
+    LOG_DEBUG("[CannedMessage] LaunchWithDestination dest=0x%08x ch=%d", dest, channel);
 }
 
 void CannedMessageModule::LaunchRepeatDestination()
@@ -113,13 +186,12 @@ void CannedMessageModule::LaunchRepeatDestination()
 
 void CannedMessageModule::LaunchFreetextWithDestination(NodeNum newDest, uint8_t newChannel)
 {
-    // Use the requested destination, unless it's "broadcast" and we have a previous node/channel
-    if (newDest == NODENUM_BROADCAST && lastDestSet) {
-        newDest = lastDest;
-        newChannel = lastChannel;
-    }
+    // Do NOT override explicit broadcast replies
+    // Only reuse lastDest in LaunchRepeatDestination()
+
     dest = newDest;
     channel = newChannel;
+
     lastDest = dest;
     lastChannel = channel;
     lastDestSet = true;
@@ -129,6 +201,8 @@ void CannedMessageModule::LaunchFreetextWithDestination(NodeNum newDest, uint8_t
     UIFrameEvent e;
     e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
     notifyObservers(&e);
+
+    LOG_DEBUG("[CannedMessage] LaunchFreetextWithDestination dest=0x%08x ch=%d", dest, channel);
 }
 
 static bool returnToCannedList = false;
@@ -150,7 +224,7 @@ int CannedMessageModule::splitConfiguredMessages()
     String canned_messages = cannedMessageModuleConfig.messages;
 
     // Copy all message parts into the buffer
-    strncpy(this->messageStore, canned_messages.c_str(), sizeof(this->messageStore));
+    strncpy(this->messageBuffer, canned_messages.c_str(), sizeof(this->messageBuffer));
 
     // Temporary array to allow for insertion
     const char *tempMessages[CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT + 3] = {0};
@@ -167,16 +241,16 @@ int CannedMessageModule::splitConfiguredMessages()
 #endif
 
     // First message always starts at buffer start
-    tempMessages[tempCount++] = this->messageStore;
-    int upTo = strlen(this->messageStore) - 1;
+    tempMessages[tempCount++] = this->messageBuffer;
+    int upTo = strlen(this->messageBuffer) - 1;
 
     // Walk buffer, splitting on '|'
     while (i < upTo) {
-        if (this->messageStore[i] == '|') {
-            this->messageStore[i] = '\0'; // End previous message
+        if (this->messageBuffer[i] == '|') {
+            this->messageBuffer[i] = '\0'; // End previous message
             if (tempCount >= CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT)
                 break;
-            tempMessages[tempCount++] = (this->messageStore + i + 1);
+            tempMessages[tempCount++] = (this->messageBuffer + i + 1);
         }
         i += 1;
     }
@@ -194,25 +268,23 @@ int CannedMessageModule::splitConfiguredMessages()
 }
 void CannedMessageModule::drawHeader(OLEDDisplay *display, int16_t x, int16_t y, char *buffer)
 {
-    if (graphics::isHighResolution) {
+    if (graphics::currentResolution == graphics::ScreenResolution::High) {
         if (this->dest == NODENUM_BROADCAST) {
-            display->drawStringf(x, y, buffer, "To: Broadcast@%s", channels.getName(this->channel));
+            display->drawStringf(x, y, buffer, "To: #%s", channels.getName(this->channel));
         } else {
-            display->drawStringf(x, y, buffer, "To: %s", getNodeName(this->dest));
+            display->drawStringf(x, y, buffer, "To: @%s", getNodeName(this->dest));
         }
     } else {
         if (this->dest == NODENUM_BROADCAST) {
-            display->drawStringf(x, y, buffer, "To: Broadc@%.5s", channels.getName(this->channel));
+            display->drawStringf(x, y, buffer, "To: #%.20s", channels.getName(this->channel));
         } else {
-            display->drawStringf(x, y, buffer, "To: %s", getNodeName(this->dest));
+            display->drawStringf(x, y, buffer, "To: @%s", getNodeName(this->dest));
         }
     }
 }
 
 void CannedMessageModule::resetSearch()
 {
-    LOG_INFO("Resetting search, restoring full destination list");
-
     int previousDestIndex = destIndex;
 
     searchQuery = "";
@@ -274,6 +346,10 @@ void CannedMessageModule::updateDestinationSelectionList()
         }
     }
 
+    meshtastic_MeshPacket *p = allocDataPacket();
+    p->pki_encrypted = true;
+    p->channel = 0;
+
     // Populate active channels
     std::vector<String> seenChannels;
     seenChannels.reserve(channels.getNumChannels());
@@ -285,15 +361,6 @@ void CannedMessageModule::updateDestinationSelectionList()
         }
     }
 
-    /* As the nodeDB is sorted, can skip this step
-    // Sort by favorite, then last heard
-    std::sort(this->filteredNodes.begin(), this->filteredNodes.end(), [](const NodeEntry &a, const NodeEntry &b) {
-        if (a.node->is_favorite != b.node->is_favorite)
-            return a.node->is_favorite > b.node->is_favorite;
-        return a.lastHeard < b.lastHeard;
-    });
-    */
-
     scrollIndex = 0; // Show first result at the top
     destIndex = 0;   // Highlight the first entry
     if (nodesChanged && runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) {
@@ -361,16 +428,7 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
         return handleEmotePickerInput(event);
 
     case CANNED_MESSAGE_RUN_STATE_INACTIVE:
-        if (isSelect) {
-            return 0; // Main button press no longer runs through powerFSM
-        }
-        // Let LEFT/RIGHT pass through so frame navigation works
-        if (event->inputEvent == INPUT_BROKER_LEFT || event->inputEvent == INPUT_BROKER_RIGHT) {
-            break;
-        }
-        // Handle UP/DOWN: activate canned message list!
-        if (event->inputEvent == INPUT_BROKER_UP || event->inputEvent == INPUT_BROKER_DOWN ||
-            event->inputEvent == INPUT_BROKER_ALT_LONG) {
+        if (event->inputEvent == INPUT_BROKER_ALT_LONG) {
             LaunchWithDestination(NODENUM_BROADCAST);
             return 1;
         }
@@ -384,6 +442,7 @@ int CannedMessageModule::handleInputEvent(const InputEvent *event)
             // Immediately process the input in the new state (freetext)
             return handleFreeTextInput(event);
         }
+        return 0;
         break;
 
     // (Other states can be added here as needed)
@@ -574,7 +633,7 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
     if (runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION)
         return false;
 
-    // === Handle Cancel key: go inactive, clear UI state ===
+    // Handle Cancel key: go inactive, clear UI state
     if (runState != CANNED_MESSAGE_RUN_STATE_INACTIVE &&
         (event->inputEvent == INPUT_BROKER_CANCEL || event->inputEvent == INPUT_BROKER_ALT_LONG)) {
         runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
@@ -603,7 +662,7 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
     } else if (isSelect) {
         const char *current = messages[currentMessageIndex];
 
-        // === [Select Destination] triggers destination selection UI ===
+        // [Select Destination] triggers destination selection UI
         if (strcmp(current, "[Select Destination]") == 0) {
             returnToCannedList = true;
             runState = CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION;
@@ -614,7 +673,7 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
             return true;
         }
 
-        // === [Exit] returns to the main/inactive screen ===
+        // [Exit] returns to the main/inactive screen
         if (strcmp(current, "[Exit]") == 0) {
             // Set runState to inactive so we return to main UI
             runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
@@ -628,7 +687,7 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
             return true;
         }
 
-        // === [Free Text] triggers the free text input (virtual keyboard) ===
+        // [Free Text] triggers the free text input (virtual keyboard)
 #if defined(USE_VIRTUAL_KEYBOARD)
         if (strcmp(current, "[-- Free Text --]") == 0) {
             runState = CANNED_MESSAGE_RUN_STATE_FREETEXT;
@@ -643,9 +702,9 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
             if (osk_found && screen) {
                 char headerBuffer[64];
                 if (this->dest == NODENUM_BROADCAST) {
-                    snprintf(headerBuffer, sizeof(headerBuffer), "To: Broadcast@%s", channels.getName(this->channel));
+                    snprintf(headerBuffer, sizeof(headerBuffer), "To: #%s", channels.getName(this->channel));
                 } else {
-                    snprintf(headerBuffer, sizeof(headerBuffer), "To: %s", getNodeName(this->dest));
+                    snprintf(headerBuffer, sizeof(headerBuffer), "To: @%s", getNodeName(this->dest));
                 }
                 screen->showTextInput(headerBuffer, "", 300000, [this](const std::string &text) {
                     if (!text.empty()) {
@@ -694,20 +753,12 @@ bool CannedMessageModule::handleMessageSelectorInput(const InputEvent *event, bo
         if (runState == CANNED_MESSAGE_RUN_STATE_INACTIVE || runState == CANNED_MESSAGE_RUN_STATE_DISABLED) {
         } else {
 #if CANNED_MESSAGE_ADD_CONFIRMATION
-            // Show confirmation dialog before sending canned message
-            NodeNum destNode = dest;
-            ChannelIndex chan = channel;
-            graphics::menuHandler::showConfirmationBanner("Send message?", [this, destNode, chan, current]() {
-                this->sendText(destNode, chan, current, false);
-                payload = runState;
-                runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
-                currentMessageIndex = -1;
-
-                // Notify UI to regenerate frame set and redraw
-                UIFrameEvent e;
-                e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
-                notifyObservers(&e);
-                screen->forceDisplay();
+            const int savedIndex = currentMessageIndex;
+            graphics::menuHandler::showConfirmationBanner("Send message?", [this, savedIndex]() {
+                this->currentMessageIndex = savedIndex;
+                this->payload = this->runState;
+                this->runState = CANNED_MESSAGE_RUN_STATE_ACTION_SELECT;
+                this->setIntervalFromNow(0);
             });
 #else
             payload = runState;
@@ -806,7 +857,7 @@ bool CannedMessageModule::handleFreeTextInput(const InputEvent *event)
     }
 #endif // USE_VIRTUAL_KEYBOARD
 
-    // ---- All hardware keys fall through to here (CardKB, physical, etc.) ----
+    // All hardware keys fall through to here (CardKB, physical, etc.)
 
     if (event->kbchar == INPUT_BROKER_MSG_EMOTE_LIST) {
         runState = CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER;
@@ -950,57 +1001,110 @@ void CannedMessageModule::sendText(NodeNum dest, ChannelIndex channel, const cha
     lastDest = dest;
     lastChannel = channel;
     lastDestSet = true;
-    // === Prepare packet ===
+
     meshtastic_MeshPacket *p = allocDataPacket();
     p->to = dest;
     p->channel = channel;
     p->want_ack = true;
+    p->decoded.dest = dest; // Mirror picker: NODENUM_BROADCAST or node->num
 
-    // Save destination for ACK/NACK UI fallback
     this->lastSentNode = dest;
     this->incoming = dest;
 
-    // Copy message payload
+    // Manually find the node by number to check PKI capability
+    meshtastic_NodeInfoLite *node = nullptr;
+    size_t numMeshNodes = nodeDB->getNumMeshNodes();
+    for (size_t i = 0; i < numMeshNodes; ++i) {
+        meshtastic_NodeInfoLite *n = nodeDB->getMeshNodeByIndex(i);
+        if (n && n->num == dest) {
+            node = n;
+            break;
+        }
+    }
+
+    NodeNum myNodeNum = nodeDB->getNodeNum();
+    if (node && node->num != myNodeNum && node->has_user && node->user.public_key.size == 32) {
+        p->pki_encrypted = true;
+        p->channel = 0; // force PKI
+    }
+
+    // Track this packet’s request ID for matching ACKs
+    this->lastRequestId = p->id;
+
+    // Copy payload
     p->decoded.payload.size = strlen(message);
     memcpy(p->decoded.payload.bytes, message, p->decoded.payload.size);
 
-    // Optionally add bell character
     if (moduleConfig.canned_message.send_bell && p->decoded.payload.size < meshtastic_Constants_DATA_PAYLOAD_LEN) {
-        p->decoded.payload.bytes[p->decoded.payload.size++] = 7;  // Bell
-        p->decoded.payload.bytes[p->decoded.payload.size] = '\0'; // Null-terminate
+        p->decoded.payload.bytes[p->decoded.payload.size++] = 7;
+        p->decoded.payload.bytes[p->decoded.payload.size] = '\0';
     }
 
-    // Mark as waiting for ACK to trigger ACK/NACK screen
     this->waitingForAck = true;
 
-    // Log outgoing message
-    LOG_INFO("Send message id=%u, dest=%x, msg=%.*s", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);
-
-    if (p->to != 0xffffffff) {
-        // Only add as favorite if our role is NOT CLIENT_BASE
-        if (config.device.role != 12) {
-            LOG_INFO("Proactively adding %x as favorite node", p->to);
-            nodeDB->set_favorite(true, p->to);
-        } else {
-            LOG_DEBUG("Not favoriting node %x as we are CLIENT_BASE role", p->to);
-        }
-
-        screen->setFrames(graphics::Screen::FOCUS_PRESERVE);
-        p->pki_encrypted = true;
-        p->channel = 0;
-    }
-
-    // Send to mesh and phone (even if no phone connected, to track ACKs)
+    // Send to mesh (PKI-encrypted if conditions above matched)
     service->sendToMesh(p, RX_SRC_LOCAL, true);
 
-    // === Simulate local message to clear unread UI ===
+    // Show banner immediately
     if (screen) {
-        meshtastic_MeshPacket simulatedPacket = {};
-        simulatedPacket.from = 0; // Local device
-        screen->handleTextMessage(&simulatedPacket);
+        graphics::BannerOverlayOptions opts;
+        opts.message = "Sending...";
+        opts.durationMs = 2000;
+        screen->showOverlayBanner(opts);
     }
+
+    // Save outgoing message
+    StoredMessage sm;
+
+    // Always use our local time, consistent with other paths
+    uint32_t nowSecs = getValidTime(RTCQuality::RTCQualityDevice, true);
+    sm.timestamp = (nowSecs > 0) ? nowSecs : millis() / 1000;
+    sm.isBootRelative = (nowSecs == 0);
+
+    sm.sender = nodeDB->getNodeNum(); // us
+    sm.channelIndex = channel;
+    size_t len = strnlen(message, MAX_MESSAGE_SIZE - 1);
+    sm.textOffset = MessageStore::storeText(message, len);
+    sm.textLength = len;
+
+    // Classify broadcast vs DM
+    if (dest == NODENUM_BROADCAST) {
+        sm.dest = NODENUM_BROADCAST;
+        sm.type = MessageType::BROADCAST;
+    } else {
+        sm.dest = dest;
+        sm.type = MessageType::DM_TO_US;
+        // Only add as favorite if our role is NOT CLIENT_BASE
+        if (config.device.role != 12) {
+            LOG_INFO("Proactively adding %x as favorite node", dest);
+            nodeDB->set_favorite(true, dest);
+        } else {
+            LOG_DEBUG("Not favoriting node %x as we are CLIENT_BASE role", dest);
+        }
+    }
+    sm.ackStatus = AckStatus::NONE;
+
+    messageStore.addLiveMessage(std::move(sm));
+
+    // Auto-switch thread view on outgoing message
+    if (sm.type == MessageType::BROADCAST) {
+        graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::CHANNEL, sm.channelIndex);
+    } else {
+        graphics::MessageRenderer::setThreadMode(graphics::MessageRenderer::ThreadMode::DIRECT, -1, sm.dest);
+    }
+
     playComboTune();
+
+    this->runState = CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE;
+    this->payload = wantReplies ? 1 : 0;
+    requestFocus();
+
+    // Tell Screen to switch to TextMessage frame via UIFrameEvent
+    UIFrameEvent e;
+    e.action = UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE;
+    notifyObservers(&e);
 }
+
 int32_t CannedMessageModule::runOnce()
 {
     if (this->runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION && needsUpdate) {
@@ -1021,7 +1125,6 @@ int32_t CannedMessageModule::runOnce()
             graphics::OnScreenKeyboardModule::instance().stop(false);
         }
 
-        temporaryMessage = "";
         return INT32_MAX;
     }
 
@@ -1063,7 +1166,6 @@ int32_t CannedMessageModule::runOnce()
         (this->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) ||
         (this->runState == CANNED_MESSAGE_RUN_STATE_MESSAGE_SELECTION)) {
         this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
-        temporaryMessage = "";
         e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
         this->currentMessageIndex = -1;
         this->freetext = "";
@@ -1072,15 +1174,11 @@ int32_t CannedMessageModule::runOnce()
     }
     // Handle SENDING_ACTIVE state transition after virtual keyboard message
     else if (this->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE && this->payload == 0) {
-        // This happens after virtual keyboard message sending is complete
-        LOG_INFO("Virtual keyboard message sending completed, returning to inactive state");
         this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
-        temporaryMessage = "";
-        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
         this->currentMessageIndex = -1;
         this->freetext = "";
         this->cursor = 0;
-        this->notifyObservers(&e);
+        return INT32_MAX;
     } else if (((this->runState == CANNED_MESSAGE_RUN_STATE_ACTIVE) || (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT)) &&
                !Throttle::isWithinTimespanMs(this->lastTouchMillis, INACTIVATE_AFTER_MS)) {
         // Reset module on inactivity
@@ -1106,7 +1204,21 @@ int32_t CannedMessageModule::runOnce()
         } else if (this->payload == CANNED_MESSAGE_RUN_STATE_FREETEXT) {
             if (this->freetext.length() > 0) {
                 sendText(this->dest, this->channel, this->freetext.c_str(), true);
-                this->runState = CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE;
+
+                // Clean up state but *don’t* deactivate yet
+                this->currentMessageIndex = -1;
+                this->freetext = "";
+                this->cursor = 0;
+
+                // Tell Screen to jump straight to the TextMessage frame
+                UIFrameEvent e;
+                e.action = UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE;
+                this->notifyObservers(&e);
+
+                // Now deactivate this module
+                this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
+
+                return INT32_MAX; // don’t fall back into canned list
             } else {
                 this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
             }
@@ -1120,37 +1232,59 @@ int32_t CannedMessageModule::runOnce()
                     return INT32_MAX;
                 } else {
                     sendText(this->dest, this->channel, this->messages[this->currentMessageIndex], true);
+
+                    // Clean up state
+                    this->currentMessageIndex = -1;
+                    this->freetext = "";
+                    this->cursor = 0;
+
+                    // Tell Screen to jump straight to the TextMessage frame
+                    UIFrameEvent e;
+                    e.action = UIFrameEvent::Action::SWITCH_TO_TEXTMESSAGE;
+                    this->notifyObservers(&e);
+
+                    // Now deactivate this module
+                    this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
+
+                    return INT32_MAX; // don’t fall back into canned list
                 }
-                this->runState = CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE;
             } else {
                 this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
             }
         }
+        // fallback clean-up if nothing above returned
         this->currentMessageIndex = -1;
         this->freetext = "";
         this->cursor = 0;
+
+        UIFrameEvent e;
+        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
         this->notifyObservers(&e);
-        return 2000;
+
+        // Immediately stop, don’t linger on canned screen
+        return INT32_MAX;
     }
     // Highlight [Select Destination] initially when entering the message list
     else if ((this->runState != CANNED_MESSAGE_RUN_STATE_FREETEXT) && (this->currentMessageIndex == -1)) {
-        int selectDestination = 0;
-        for (int i = 0; i < this->messagesCount; ++i) {
-            if (strcmp(this->messages[i], "[Select Destination]") == 0) {
-                selectDestination = i;
-                break;
+        // Only auto-highlight [Select Destination] if we’re ACTIVELY browsing,
+        // not when coming back from a sent message.
+        if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTIVE) {
+            int selectDestination = 0;
+            for (int i = 0; i < this->messagesCount; ++i) {
+                if (strcmp(this->messages[i], "[Select Destination]") == 0) {
+                    selectDestination = i;
+                    break;
+                }
             }
+            this->currentMessageIndex = selectDestination;
+            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
         }
-        this->currentMessageIndex = selectDestination;
-        e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
-        this->runState = CANNED_MESSAGE_RUN_STATE_ACTIVE;
     } else if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_UP) {
         if (this->messagesCount > 0) {
             this->currentMessageIndex = getPrevIndex();
             this->freetext = "";
             this->cursor = 0;
             this->runState = CANNED_MESSAGE_RUN_STATE_ACTIVE;
-            LOG_DEBUG("MOVE UP (%d):%s", this->currentMessageIndex, this->getCurrentMessage());
         }
     } else if (this->runState == CANNED_MESSAGE_RUN_STATE_ACTION_DOWN) {
         if (this->messagesCount > 0) {
@@ -1158,7 +1292,6 @@ int32_t CannedMessageModule::runOnce()
             this->freetext = "";
             this->cursor = 0;
             this->runState = CANNED_MESSAGE_RUN_STATE_ACTIVE;
-            LOG_DEBUG("MOVE DOWN (%d):%s", this->currentMessageIndex, this->getCurrentMessage());
         }
     } else if (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT || this->runState == CANNED_MESSAGE_RUN_STATE_ACTIVE) {
         switch (this->payload) {
@@ -1208,7 +1341,7 @@ int32_t CannedMessageModule::runOnce()
                                          this->freetext.substring(this->cursor);
                     }
                     this->cursor++;
-                    uint16_t maxChars = meshtastic_Constants_DATA_PAYLOAD_LEN - (moduleConfig.canned_message.send_bell ? 1 : 0);
+                    const uint16_t maxChars = 200 - (moduleConfig.canned_message.send_bell ? 1 : 0);
                     if (this->freetext.length() > maxChars) {
                         this->cursor = maxChars;
                         this->freetext = this->freetext.substring(0, maxChars);
@@ -1264,7 +1397,10 @@ const char *CannedMessageModule::getNodeName(NodeNum node)
 
 bool CannedMessageModule::shouldDraw()
 {
-    return (currentMessageIndex != -1) || (this->runState != CANNED_MESSAGE_RUN_STATE_INACTIVE);
+    // Only allow drawing when we're in an interactive UI state.
+    return (this->runState == CANNED_MESSAGE_RUN_STATE_ACTIVE || this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT ||
+            this->runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION ||
+            this->runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER);
 }
 
 // Has the user defined any canned messages?
@@ -1291,16 +1427,6 @@ int CannedMessageModule::getPrevIndex()
         return this->currentMessageIndex - 1;
     }
 }
-void CannedMessageModule::showTemporaryMessage(const String &message)
-{
-    temporaryMessage = message;
-    UIFrameEvent e;
-    e.action = UIFrameEvent::Action::REGENERATE_FRAMESET; // We want to change the list of frames shown on-screen
-    notifyObservers(&e);
-    runState = CANNED_MESSAGE_RUN_STATE_MESSAGE_SELECTION;
-    // run this loop again in 2 seconds, next iteration will clear the display
-    setIntervalFromNow(2000);
-}
 
 #if defined(USE_VIRTUAL_KEYBOARD)
 
@@ -1523,7 +1649,7 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
 
-    // === Header ===
+    // Header
     int titleY = 2;
     String titleText = "Select Destination";
     titleText += searchQuery.length() > 0 ? " [" + searchQuery + "]" : " [ ]";
@@ -1531,7 +1657,7 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
     display->drawString(display->getWidth() / 2, titleY, titleText);
     display->setTextAlignment(TEXT_ALIGN_LEFT);
 
-    // === List Items ===
+    // List Items
     int rowYOffset = titleY + (FONT_HEIGHT_SMALL - 4);
     int numActiveChannels = this->activeChannelIndices.size();
     int totalEntries = numActiveChannels + this->filteredNodes.size();
@@ -1540,7 +1666,7 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
     if (this->visibleRows < 1)
         this->visibleRows = 1;
 
-    // === Clamp scrolling ===
+    // Clamp scrolling
     if (scrollIndex > totalEntries / columns)
         scrollIndex = totalEntries / columns;
     if (scrollIndex < 0)
@@ -1558,26 +1684,44 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
         // Draw Channels First
         if (itemIndex < numActiveChannels) {
             uint8_t channelIndex = this->activeChannelIndices[itemIndex];
-            snprintf(entryText, sizeof(entryText), "@%s", channels.getName(channelIndex));
+            snprintf(entryText, sizeof(entryText), "#%s", channels.getName(channelIndex));
         }
         // Then Draw Nodes
         else {
             int nodeIndex = itemIndex - numActiveChannels;
             if (nodeIndex >= 0 && nodeIndex < static_cast<int>(this->filteredNodes.size())) {
                 meshtastic_NodeInfoLite *node = this->filteredNodes[nodeIndex].node;
+                if (node && node->user.long_name) {
+                    strncpy(entryText, node->user.long_name, sizeof(entryText) - 1);
+                    entryText[sizeof(entryText) - 1] = '\0';
+                }
+                int availWidth = display->getWidth() -
+                                 ((graphics::currentResolution == graphics::ScreenResolution::High) ? 40 : 20) -
+                                 ((node && node->is_favorite) ? 10 : 0);
+                if (availWidth < 0)
+                    availWidth = 0;
+
+                size_t origLen = strlen(entryText);
+                while (entryText[0] && display->getStringWidth(entryText) > availWidth) {
+                    entryText[strlen(entryText) - 1] = '\0';
+                }
+                if (strlen(entryText) < origLen) {
+                    strcat(entryText, "...");
+                }
+
+                // Prepend "* " if this is a favorite
+                if (node && node->is_favorite) {
+                    size_t len = strlen(entryText);
+                    if (len + 2 < sizeof(entryText)) {
+                        memmove(entryText + 2, entryText, len + 1);
+                        entryText[0] = '*';
+                        entryText[1] = ' ';
+                    }
+                }
                 if (node) {
-                    if (node->is_favorite) {
-#if defined(M5STACK_UNITC6L)
-                        snprintf(entryText, sizeof(entryText), "* %s", node->user.short_name);
-                    } else {
+                    if (display->getWidth() <= 64) {
                         snprintf(entryText, sizeof(entryText), "%s", node->user.short_name);
                     }
-#else
-                        snprintf(entryText, sizeof(entryText), "* %s", node->user.long_name);
-                    } else {
-                        snprintf(entryText, sizeof(entryText), "%s", node->user.long_name);
-                    }
-#endif
                 }
             }
         }
@@ -1585,18 +1729,19 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
         if (strlen(entryText) == 0 || strcmp(entryText, "Unknown") == 0)
             strcpy(entryText, "?");
 
-        // === Highlight background (if selected) ===
+        // Highlight background (if selected)
         if (itemIndex == destIndex) {
             int scrollPadding = 8; // Reserve space for scrollbar
             display->fillRect(0, yOffset + 2, display->getWidth() - scrollPadding, FONT_HEIGHT_SMALL - 5);
             display->setColor(BLACK);
         }
 
-        // === Draw entry text ===
+        // Draw entry text
         display->drawString(xOffset + 2, yOffset, entryText);
         display->setColor(WHITE);
 
-        // === Draw key icon (after highlight) ===
+        // Draw key icon (after highlight)
+        /*
         if (itemIndex >= numActiveChannels) {
             int nodeIndex = itemIndex - numActiveChannels;
             if (nodeIndex >= 0 && nodeIndex < static_cast<int>(this->filteredNodes.size())) {
@@ -1614,6 +1759,7 @@ void CannedMessageModule::drawDestinationSelectionScreen(OLEDDisplay *display, O
                 }
             }
         }
+        */
     }
 
     // Scrollbar
@@ -1650,6 +1796,9 @@ void CannedMessageModule::drawEmotePickerScreen(OLEDDisplay *display, OLEDDispla
     int _visibleRows = (display->getHeight() - listTop - 2) / rowHeight;
     int numEmotes = graphics::numEmotes;
 
+    // keep member variable in sync
+    this->visibleRows = _visibleRows;
+
     // Clamp highlight index
     if (emotePickerIndex < 0)
         emotePickerIndex = 0;
@@ -1671,7 +1820,7 @@ void CannedMessageModule::drawEmotePickerScreen(OLEDDisplay *display, OLEDDispla
     // Draw emote rows
     display->setTextAlignment(TEXT_ALIGN_LEFT);
 
-    for (int vis = 0; vis < visibleRows; ++vis) {
+    for (int vis = 0; vis < _visibleRows; ++vis) {
         int emoteIdx = topIndex + vis;
         if (emoteIdx >= numEmotes)
             break;
@@ -1698,11 +1847,11 @@ void CannedMessageModule::drawEmotePickerScreen(OLEDDisplay *display, OLEDDispla
     }
 
     // Draw scrollbar if needed
-    if (numEmotes > visibleRows) {
-        int scrollbarHeight = visibleRows * rowHeight;
+    if (numEmotes > _visibleRows) {
+        int scrollbarHeight = _visibleRows * rowHeight;
         int scrollTrackX = display->getWidth() - 6;
         display->drawRect(scrollTrackX, listTop, 4, scrollbarHeight);
-        int scrollBarLen = std::max(6, (scrollbarHeight * visibleRows) / numEmotes);
+        int scrollBarLen = std::max(6, (scrollbarHeight * _visibleRows) / numEmotes);
         int scrollBarPos = listTop + (scrollbarHeight * topIndex) / numEmotes;
         display->fillRect(scrollTrackX, scrollBarPos, 4, scrollBarLen);
     }
@@ -1715,104 +1864,25 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
     display->setTextAlignment(TEXT_ALIGN_LEFT);
     display->setFont(FONT_SMALL);
 
-    // === Draw temporary message if available ===
-    if (temporaryMessage.length() != 0) {
-        requestFocus(); // Tell Screen::setFrames to move to our module's frame
-        LOG_DEBUG("Draw temporary message: %s", temporaryMessage.c_str());
-        display->setTextAlignment(TEXT_ALIGN_CENTER);
-        display->setFont(FONT_MEDIUM);
-        display->drawString(display->getWidth() / 2 + x, 0 + y + 12, temporaryMessage);
-        return;
+    // Never draw if state is outside our UI modes
+    if (!(runState == CANNED_MESSAGE_RUN_STATE_ACTIVE || runState == CANNED_MESSAGE_RUN_STATE_FREETEXT ||
+          runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION || runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER)) {
+        return; // bail if not in a UI state that should render
     }
 
-    // === Emote Picker Screen ===
+    // Emote Picker Screen
     if (this->runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER) {
         drawEmotePickerScreen(display, state, x, y); // <-- Call your emote picker drawer here
         return;
     }
 
-    // === Destination Selection ===
+    // Destination Selection
     if (this->runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) {
         drawDestinationSelectionScreen(display, state, x, y);
         return;
     }
 
-    // === ACK/NACK Screen ===
-    if (this->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) {
-        requestFocus();
-        EINK_ADD_FRAMEFLAG(display, COSMETIC);
-        display->setTextAlignment(TEXT_ALIGN_CENTER);
-
-#ifdef USE_EINK
-        display->setFont(FONT_SMALL);
-        int yOffset = y + 10;
-#else
-        display->setFont(FONT_MEDIUM);
-#if defined(M5STACK_UNITC6L)
-        int yOffset = y;
-#else
-        int yOffset = y + 10;
-#endif
-#endif
-
-        // --- Delivery Status Message ---
-        if (this->ack) {
-            if (this->lastSentNode == NODENUM_BROADCAST) {
-                snprintf(buffer, sizeof(buffer), "Broadcast Sent to\n%s", channels.getName(this->channel));
-            } else if (this->lastAckHopLimit > this->lastAckHopStart) {
-                snprintf(buffer, sizeof(buffer), "Delivered (%d hops)\nto %s", this->lastAckHopLimit - this->lastAckHopStart,
-                         getNodeName(this->incoming));
-            } else {
-                snprintf(buffer, sizeof(buffer), "Delivered\nto %s", getNodeName(this->incoming));
-            }
-        } else {
-            snprintf(buffer, sizeof(buffer), "Delivery failed\nto %s", getNodeName(this->incoming));
-        }
-
-        // Draw delivery message and compute y-offset after text height
-        int lineCount = 1;
-        for (const char *ptr = buffer; *ptr; ptr++) {
-            if (*ptr == '\n')
-                lineCount++;
-        }
-
-        display->drawString(display->getWidth() / 2 + x, yOffset, buffer);
-#if defined(M5STACK_UNITC6L)
-        yOffset += lineCount * FONT_HEIGHT_MEDIUM - 5; // only 1 line gap, no extra padding
-#else
-        yOffset += lineCount * FONT_HEIGHT_MEDIUM; // only 1 line gap, no extra padding
-#endif
-#ifndef USE_EINK
-        // --- SNR + RSSI Compact Line ---
-        if (this->ack) {
-            display->setFont(FONT_SMALL);
-#if defined(M5STACK_UNITC6L)
-            snprintf(buffer, sizeof(buffer), "SNR: %.1f dB \nRSSI: %d", this->lastRxSnr, this->lastRxRssi);
-#else
-            snprintf(buffer, sizeof(buffer), "SNR: %.1f dB   RSSI: %d", this->lastRxSnr, this->lastRxRssi);
-#endif
-            display->drawString(display->getWidth() / 2 + x, yOffset, buffer);
-        }
-#endif
-
-        return;
-    }
-
-    // === Sending Screen ===
-    if (this->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) {
-        EINK_ADD_FRAMEFLAG(display, COSMETIC);
-        requestFocus();
-#ifdef USE_EINK
-        display->setFont(FONT_SMALL);
-#else
-        display->setFont(FONT_MEDIUM);
-#endif
-        display->setTextAlignment(TEXT_ALIGN_CENTER);
-        display->drawString(display->getWidth() / 2 + x, 0 + y + 12, "Sending...");
-        return;
-    }
-
-    // === Disabled Screen ===
+    // Disabled Screen
     if (this->runState == CANNED_MESSAGE_RUN_STATE_DISABLED) {
         display->setTextAlignment(TEXT_ALIGN_LEFT);
         display->setFont(FONT_SMALL);
@@ -1820,7 +1890,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
         return;
     }
 
-    // === Free Text Input Screen ===
+    // Free Text Input Screen
     if (this->runState == CANNED_MESSAGE_RUN_STATE_FREETEXT) {
         requestFocus();
 #if defined(USE_EINK) && defined(USE_EINK_DYNAMICDISPLAY)
@@ -1833,10 +1903,10 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
         display->setTextAlignment(TEXT_ALIGN_LEFT);
         display->setFont(FONT_SMALL);
 
-        // --- Draw node/channel header at the top ---
+        // Draw node/channel header at the top
         drawHeader(display, x, y, buffer);
 
-        // --- Char count right-aligned ---
+        // Char count right-aligned
         if (runState != CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) {
             uint16_t charsLeft =
                 meshtastic_Constants_DATA_PAYLOAD_LEN - this->freetext.length() - (moduleConfig.canned_message.send_bell ? 1 : 0);
@@ -1932,51 +2002,10 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             String msgWithCursor = this->drawWithCursor(this->freetext, this->cursor);
 
             // Tokenize input into (isEmote, token) pairs
-            std::vector<std::pair<bool, String>> tokens;
             const char *msg = msgWithCursor.c_str();
-            int msgLen = strlen(msg);
-            int pos = 0;
-            while (pos < msgLen) {
-                const graphics::Emote *foundEmote = nullptr;
-                int foundLen = 0;
-                for (int j = 0; j < graphics::numEmotes; j++) {
-                    const char *label = graphics::emotes[j].label;
-                    int labelLen = strlen(label);
-                    if (labelLen == 0)
-                        continue;
-                    if (strncmp(msg + pos, label, labelLen) == 0) {
-                        if (!foundEmote || labelLen > foundLen) {
-                            foundEmote = &graphics::emotes[j];
-                            foundLen = labelLen;
-                        }
-                    }
-                }
-                if (foundEmote) {
-                    tokens.emplace_back(true, String(foundEmote->label));
-                    pos += foundLen;
-                } else {
-                    // Find next emote
-                    int nextEmote = msgLen;
-                    for (int j = 0; j < graphics::numEmotes; j++) {
-                        const char *label = graphics::emotes[j].label;
-                        if (!label || !*label)
-                            continue;
-                        const char *found = strstr(msg + pos, label);
-                        if (found && (found - msg) < nextEmote) {
-                            nextEmote = found - msg;
-                        }
-                    }
-                    int textLen = (nextEmote > pos) ? (nextEmote - pos) : (msgLen - pos);
-                    if (textLen > 0) {
-                        tokens.emplace_back(false, String(msg + pos).substring(0, textLen));
-                        pos += textLen;
-                    } else {
-                        break;
-                    }
-                }
-            }
+            std::vector<std::pair<bool, String>> tokens = tokenizeMessageWithEmotes(msg);
 
-            // ===== Advanced word-wrapping (emotes + text, split by word, wrap by char if needed) =====
+            // Advanced word-wrapping (emotes + text, split by word, wrap inside word if needed)
             std::vector<std::vector<std::pair<bool, String>>> lines;
             std::vector<std::pair<bool, String>> currentLine;
             int lineWidth = 0;
@@ -2001,7 +2030,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
                 } else {
                     // Text: split by words and wrap inside word if needed
                     String text = token.second;
-                    pos = 0;
+                    int pos = 0;
                     while (pos < static_cast<int>(text.length())) {
                         // Find next space (or end)
                         int spacePos = text.indexOf(' ', pos);
@@ -2047,18 +2076,8 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
                 int nextX = x;
                 for (const auto &token : line) {
                     if (token.first) {
-                        const graphics::Emote *emote = nullptr;
-                        for (int j = 0; j < graphics::numEmotes; j++) {
-                            if (token.second == graphics::emotes[j].label) {
-                                emote = &graphics::emotes[j];
-                                break;
-                            }
-                        }
-                        if (emote) {
-                            int emoteYOffset = (rowHeight - emote->height) / 2;
-                            display->drawXbm(nextX, yLine + emoteYOffset, emote->width, emote->height, emote->bitmap);
-                            nextX += emote->width + 2;
-                        }
+                        // Emote rendering centralized in helper
+                        renderEmote(display, nextX, yLine, rowHeight, token.second);
                     } else {
                         display->drawString(nextX, yLine, token.second);
                         nextX += display->getStringWidth(token.second);
@@ -2071,12 +2090,12 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
         return;
     }
 
-    // === Canned Messages List ===
+    // Canned Messages List
     if (this->messagesCount > 0) {
         display->setTextAlignment(TEXT_ALIGN_LEFT);
         display->setFont(FONT_SMALL);
 
-        // ====== Precompute per-row heights based on emotes (centered if present) ======
+        // Precompute per-row heights based on emotes (centered if present)
         const int baseRowSpacing = FONT_HEIGHT_SMALL - 4;
 
         int topMsg;
@@ -2096,7 +2115,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
                      : 0;
         int countRows = std::min(messagesCount, _visibleRows);
 
-        // --- Build per-row max height based on all emotes in line ---
+        // Build per-row max height based on all emotes in line
         for (int i = 0; i < countRows; i++) {
             const char *msg = getMessageByIndex(topMsg + i);
             int maxEmoteHeight = 0;
@@ -2114,7 +2133,7 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             rowHeights.push_back(std::max(baseRowSpacing, maxEmoteHeight + 2));
         }
 
-        // --- Draw all message rows with multi-emote support ---
+        // Draw all message rows with multi-emote support
         int yCursor = listYOffset;
         for (int vis = 0; vis < countRows; vis++) {
             int msgIdx = topMsg + vis;
@@ -2123,52 +2142,8 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             int rowHeight = rowHeights[vis];
             bool _highlight = (msgIdx == currentMessageIndex);
 
-            // --- Multi-emote tokenization ---
-            std::vector<std::pair<bool, String>> tokens; // (isEmote, token)
-            int pos = 0;
-            int msgLen = strlen(msg);
-            while (pos < msgLen) {
-                const graphics::Emote *foundEmote = nullptr;
-                int foundLen = 0;
-
-                // Look for any emote label at this pos (prefer longest match)
-                for (int j = 0; j < graphics::numEmotes; j++) {
-                    const char *label = graphics::emotes[j].label;
-                    int labelLen = strlen(label);
-                    if (labelLen == 0)
-                        continue;
-                    if (strncmp(msg + pos, label, labelLen) == 0) {
-                        if (!foundEmote || labelLen > foundLen) {
-                            foundEmote = &graphics::emotes[j];
-                            foundLen = labelLen;
-                        }
-                    }
-                }
-                if (foundEmote) {
-                    tokens.emplace_back(true, String(foundEmote->label));
-                    pos += foundLen;
-                } else {
-                    // Find next emote
-                    int nextEmote = msgLen;
-                    for (int j = 0; j < graphics::numEmotes; j++) {
-                        const char *label = graphics::emotes[j].label;
-                        if (label[0] == 0)
-                            continue;
-                        const char *found = strstr(msg + pos, label);
-                        if (found && (found - msg) < nextEmote) {
-                            nextEmote = found - msg;
-                        }
-                    }
-                    int textLen = (nextEmote > pos) ? (nextEmote - pos) : (msgLen - pos);
-                    if (textLen > 0) {
-                        tokens.emplace_back(false, String(msg + pos).substring(0, textLen));
-                        pos += textLen;
-                    } else {
-                        break;
-                    }
-                }
-            }
-            // --- End multi-emote tokenization ---
+            // Multi-emote tokenization
+            std::vector<std::pair<bool, String>> tokens = tokenizeMessageWithEmotes(msg);
 
             // Vertically center based on rowHeight
             int textYOffset = (rowHeight - FONT_HEIGHT_SMALL) / 2;
@@ -2189,19 +2164,8 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
             // Draw all tokens left to right
             for (const auto &token : tokens) {
                 if (token.first) {
-                    // Emote
-                    const graphics::Emote *emote = nullptr;
-                    for (int j = 0; j < graphics::numEmotes; j++) {
-                        if (token.second == graphics::emotes[j].label) {
-                            emote = &graphics::emotes[j];
-                            break;
-                        }
-                    }
-                    if (emote) {
-                        int emoteYOffset = (rowHeight - emote->height) / 2;
-                        display->drawXbm(nextX, lineY + emoteYOffset, emote->width, emote->height, emote->bitmap);
-                        nextX += emote->width + 2;
-                    }
+                    // Emote rendering centralized in helper
+                    renderEmote(display, nextX, lineY, rowHeight, token.second);
                 } else {
                     // Text
                     display->drawString(nextX, lineY + textYOffset, token.second);
@@ -2228,43 +2192,166 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
     }
 }
 
+// Return SNR limit based on modem preset
+static float getSnrLimit(meshtastic_Config_LoRaConfig_ModemPreset preset)
+{
+    switch (preset) {
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW:
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE:
+    case meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST:
+        return -6.0f;
+    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW:
+    case meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST:
+        return -5.5f;
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW:
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST:
+    case meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO:
+        return -4.5f;
+    default:
+        return -6.0f;
+    }
+}
+
+// Return Good/Fair/Bad label and set 1–5 bars based on SNR and RSSI
+static const char *getSignalGrade(float snr, int32_t rssi, float snrLimit, int &bars)
+{
+    // 5-bar logic: strength inside Good/Fair/Bad category
+    if (snr > snrLimit && rssi > -10) {
+        bars = 5; // very strong good
+        return "Good";
+    } else if (snr > snrLimit && rssi > -20) {
+        bars = 4; // normal good
+        return "Good";
+    } else if (snr > 0 && rssi > -50) {
+        bars = 3; // weaker good (on edge of fair)
+        return "Good";
+    } else if (snr > -10 && rssi > -100) {
+        bars = 2; // fair
+        return "Fair";
+    } else {
+        bars = 1; // bad
+        return "Bad";
+    }
+}
+
 ProcessMessage CannedMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-    if (mp.decoded.portnum == meshtastic_PortNum_ROUTING_APP && waitingForAck) {
+    // Only process routing ACK/NACK packets that are responses to our own outbound
+    if (mp.decoded.portnum == meshtastic_PortNum_ROUTING_APP && waitingForAck && mp.to == nodeDB->getNodeNum() &&
+        mp.decoded.request_id == this->lastRequestId) // only ACKs for our last sent packet
+    {
         if (mp.decoded.request_id != 0) {
-            // Trigger screen refresh for ACK/NACK feedback
-            UIFrameEvent e;
-            e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;
-            requestFocus();
-            this->runState = CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED;
-
             // Decode the routing response
             meshtastic_Routing decoded = meshtastic_Routing_init_default;
             pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_Routing_fields, &decoded);
 
-            // Track hop metadata
-            this->lastAckWasRelayed = (mp.hop_limit != mp.hop_start);
-            this->lastAckHopStart = mp.hop_start;
-            this->lastAckHopLimit = mp.hop_limit;
-
-            // Determine ACK status
+            // Determine ACK/NACK status
             bool isAck = (decoded.error_reason == meshtastic_Routing_Error_NONE);
             bool isFromDest = (mp.from == this->lastSentNode);
             bool wasBroadcast = (this->lastSentNode == NODENUM_BROADCAST);
 
             // Identify the responding node
             if (wasBroadcast && mp.from != nodeDB->getNodeNum()) {
-                this->incoming = mp.from; // Relayed by another node
+                this->incoming = mp.from; // relayed by another node
             } else {
-                this->incoming = this->lastSentNode; // Direct reply
+                this->incoming = this->lastSentNode; // direct reply
             }
 
-            // Final ACK confirmation logic
-            this->ack = isAck && (wasBroadcast || isFromDest);
+            // Final ACK/NACK logic
+            if (wasBroadcast) {
+                // Any ACK counts for broadcast
+                this->ack = isAck;
+                waitingForAck = false;
+            } else if (isFromDest) {
+                // Only ACK from destination counts as final
+                this->ack = isAck;
+                waitingForAck = false;
+            } else if (isAck) {
+                // Relay ACK → mark as RELAYED, still no final ACK
+                this->ack = false;
+                waitingForAck = false;
+            } else {
+                // Explicit failure
+                this->ack = false;
+                waitingForAck = false;
+            }
 
-            waitingForAck = false;
-            this->notifyObservers(&e);
-            setIntervalFromNow(3000); // Time to show ACK/NACK screen
+            // Update last sent StoredMessage with ACK/NACK/RELAYED result
+            if (!messageStore.getMessages().empty()) {
+                StoredMessage &last = const_cast<StoredMessage &>(messageStore.getMessages().back());
+                if (last.sender == nodeDB->getNodeNum()) { // only update our own messages
+                    if (wasBroadcast && isAck) {
+                        last.ackStatus = AckStatus::ACKED;
+                    } else if (isFromDest && isAck) {
+                        last.ackStatus = AckStatus::ACKED;
+                    } else if (!isFromDest && isAck) {
+                        last.ackStatus = AckStatus::RELAYED;
+                    } else {
+                        last.ackStatus = AckStatus::NACKED;
+                    }
+                }
+            }
+
+            // Capture radio metrics
+            this->lastRxRssi = mp.rx_rssi;
+            this->lastRxSnr = mp.rx_snr;
+
+            // Show overlay banner
+            if (screen) {
+                auto *display = screen->getDisplayDevice();
+                graphics::BannerOverlayOptions opts;
+                static char buf[128];
+
+                const char *channelName = channels.getName(this->channel);
+                const char *src = getNodeName(this->incoming);
+                char nodeName[48];
+                strncpy(nodeName, src, sizeof(nodeName) - 1);
+                nodeName[sizeof(nodeName) - 1] = '\0';
+
+                int availWidth =
+                    display->getWidth() - ((graphics::currentResolution == graphics::ScreenResolution::High) ? 60 : 30);
+                if (availWidth < 0)
+                    availWidth = 0;
+
+                size_t origLen = strlen(nodeName);
+                while (nodeName[0] && display->getStringWidth(nodeName) > availWidth) {
+                    nodeName[strlen(nodeName) - 1] = '\0';
+                }
+                if (strlen(nodeName) < origLen) {
+                    strcat(nodeName, "...");
+                }
+
+                // Calculate signal quality and bars based on preset, SNR, and RSSI
+                float snrLimit = getSnrLimit(config.lora.modem_preset);
+                int bars = 0;
+                const char *qualityLabel = getSignalGrade(this->lastRxSnr, this->lastRxRssi, snrLimit, bars);
+
+                if (this->ack) {
+                    if (this->lastSentNode == NODENUM_BROADCAST) {
+                        snprintf(buf, sizeof(buf), "Message sent to\n#%s\n\nSignal: %s",
+                                 (channelName && channelName[0]) ? channelName : "unknown", qualityLabel);
+                    } else {
+                        snprintf(buf, sizeof(buf), "DM sent to\n@%s\n\nSignal: %s",
+                                 (nodeName && nodeName[0]) ? nodeName : "unknown", qualityLabel);
+                    }
+                } else if (isAck && !isFromDest) {
+                    // Relay ACK banner
+                    snprintf(buf, sizeof(buf), "DM Relayed\n(Status Unknown)\n%s\n\nSignal: %s",
+                             (nodeName && nodeName[0]) ? nodeName : "unknown", qualityLabel);
+                } else {
+                    if (this->lastSentNode == NODENUM_BROADCAST) {
+                        snprintf(buf, sizeof(buf), "Message failed to\n#%s",
+                                 (channelName && channelName[0]) ? channelName : "unknown");
+                    } else {
+                        snprintf(buf, sizeof(buf), "DM failed to\n@%s", (nodeName && nodeName[0]) ? nodeName : "unknown");
+                    }
+                }
+
+                opts.message = buf;
+                opts.durationMs = 3000;
+                graphics::bannerSignalBars = bars; // tell banner renderer how many bars to draw
+                screen->showOverlayBanner(opts);   // this triggers drawNotificationBox()
+            }
         }
     }
 
diff --git a/src/modules/CannedMessageModule.h b/src/modules/CannedMessageModule.h
index 5b0481ac7..3d7c09d87 100644
--- a/src/modules/CannedMessageModule.h
+++ b/src/modules/CannedMessageModule.h
@@ -75,7 +75,6 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     // === State/UI ===
     bool shouldDraw();
     bool hasMessages();
-    void showTemporaryMessage(const String &message);
     void resetSearch();
     void updateDestinationSelectionList();
     void drawDestinationSelectionScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
@@ -153,10 +152,9 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     unsigned long lastUpdateMillis = 0;
     String searchQuery;
     String freetext;
-    String temporaryMessage;
 
     // === Message Storage ===
-    char messageStore[CANNED_MESSAGE_MODULE_MESSAGES_SIZE + 1];
+    char messageBuffer[CANNED_MESSAGE_MODULE_MESSAGES_SIZE + 1];
     char *messages[CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT];
     int messagesCount = 0;
     int currentMessageIndex = -1;
@@ -167,14 +165,11 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
     NodeNum lastSentNode = 0;             // Tracks the most recent node we sent a message to (for UI display)
     ChannelIndex channel = 0;             // Channel index used when sending a message
 
-    bool ack = false;               // True = ACK received, False = NACK or failed
-    bool waitingForAck = false;     // True if we're expecting an ACK and should monitor routing packets
-    bool lastAckWasRelayed = false; // True if the ACK was relayed through intermediate nodes
-    uint8_t lastAckHopStart = 0;    // Hop start value from the received ACK packet
-    uint8_t lastAckHopLimit = 0;    // Hop limit value from the received ACK packet
-
-    float lastRxSnr = 0;    // SNR from last received ACK (used for diagnostics/UI)
-    int32_t lastRxRssi = 0; // RSSI from last received ACK (used for diagnostics/UI)
+    bool ack = false;           // True = ACK received, False = NACK or failed
+    bool waitingForAck = false; // True if we're expecting an ACK and should monitor routing packets
+    float lastRxSnr = 0;        // SNR from last received ACK (used for diagnostics/UI)
+    int32_t lastRxRssi = 0;     // RSSI from last received ACK (used for diagnostics/UI)
+    uint32_t lastRequestId = 0; // tracks the request_id of our last sent packet
 
     // === State Tracking ===
     cannedMessageModuleRunState runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
diff --git a/src/modules/DropzoneModule.cpp b/src/modules/DropzoneModule.cpp
index 6c42af98b..4b8f2fec8 100644
--- a/src/modules/DropzoneModule.cpp
+++ b/src/modules/DropzoneModule.cpp
@@ -60,9 +60,7 @@ meshtastic_MeshPacket *DropzoneModule::sendConditions()
         long hms = rtc_sec % SEC_PER_DAY;
         hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
 
-        hour = hms / SEC_PER_HOUR;
-        min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
-        sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN;
+        graphics::decomposeTime(rtc_sec, hour, min, sec);
     }
 
     // Check if the dropzone is open or closed by reading the analog pin
diff --git a/src/modules/SystemCommandsModule.cpp b/src/modules/SystemCommandsModule.cpp
index 7fa4485c8..b347b2f5d 100644
--- a/src/modules/SystemCommandsModule.cpp
+++ b/src/modules/SystemCommandsModule.cpp
@@ -1,10 +1,13 @@
 #include "SystemCommandsModule.h"
 #include "input/InputBroker.h"
 #include "meshUtils.h"
+
 #if HAS_SCREEN
+#include "MessageStore.h"
 #include "graphics/Screen.h"
 #include "graphics/SharedUIDisplay.h"
 #endif
+
 #include "GPS.h"
 #include "MeshService.h"
 #include "Module.h"
@@ -28,10 +31,7 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     switch (event->kbchar) {
     // Fn key symbols
     case INPUT_BROKER_MSG_FN_SYMBOL_ON:
-        IF_SCREEN(screen->setFunctionSymbol("Fn"));
-        return 0;
     case INPUT_BROKER_MSG_FN_SYMBOL_OFF:
-        IF_SCREEN(screen->removeFunctionSymbol("Fn"));
         return 0;
     // Brightness
     case INPUT_BROKER_MSG_BRIGHTNESS_UP:
@@ -78,6 +78,9 @@ int SystemCommandsModule::handleInputEvent(const InputEvent *event)
     case INPUT_BROKER_MSG_REBOOT:
         IF_SCREEN(screen->showSimpleBanner("Rebooting...", 0));
         nodeDB->saveToDisk();
+#if HAS_SCREEN
+        messageStore.saveToFlash();
+#endif
         rebootAtMsec = millis() + DEFAULT_REBOOT_SECONDS * 1000;
         // runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
         return true;
diff --git a/src/modules/Telemetry/EnvironmentTelemetry.cpp b/src/modules/Telemetry/EnvironmentTelemetry.cpp
index 29e815092..41062662b 100644
--- a/src/modules/Telemetry/EnvironmentTelemetry.cpp
+++ b/src/modules/Telemetry/EnvironmentTelemetry.cpp
@@ -378,7 +378,7 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
     int line = 1;
 
     // === Set Title
-    const char *titleStr = (graphics::isHighResolution) ? "Environment" : "Env.";
+    const char *titleStr = (graphics::currentResolution == graphics::ScreenResolution::High) ? "Environment" : "Env.";
 
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr);
diff --git a/src/modules/Telemetry/PowerTelemetry.cpp b/src/modules/Telemetry/PowerTelemetry.cpp
index 29dd1def8..9047c7cd4 100644
--- a/src/modules/Telemetry/PowerTelemetry.cpp
+++ b/src/modules/Telemetry/PowerTelemetry.cpp
@@ -117,7 +117,7 @@ void PowerTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *s
     int line = 1;
 
     // === Set Title
-    const char *titleStr = (graphics::isHighResolution) ? "Power Telem." : "Power";
+    const char *titleStr = (graphics::currentResolution == graphics::ScreenResolution::High) ? "Power Telem." : "Power";
 
     // === Header ===
     graphics::drawCommonHeader(display, x, y, titleStr);
diff --git a/src/modules/TextMessageModule.cpp b/src/modules/TextMessageModule.cpp
index aee359158..76e063436 100644
--- a/src/modules/TextMessageModule.cpp
+++ b/src/modules/TextMessageModule.cpp
@@ -1,10 +1,14 @@
 #include "TextMessageModule.h"
 #include "MeshService.h"
+#include "MessageStore.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "buzz.h"
 #include "configuration.h"
 #include "graphics/Screen.h"
+#include "graphics/SharedUIDisplay.h"
+#include "graphics/draw/MessageRenderer.h"
+#include "main.h"
 TextMessageModule *textMessageModule;
 
 ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
@@ -15,14 +19,26 @@ ProcessMessage TextMessageModule::handleReceived(const meshtastic_MeshPacket &mp
 #endif
 
     // We only store/display messages destined for us.
-    // Keep a copy of the most recent text message.
     devicestate.rx_text_message = mp;
     devicestate.has_rx_text_message = true;
+#if HAS_SCREEN
+    // Guard against running in MeshtasticUI
+    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_COLOR) {
+        // Store in the central message history
+        const StoredMessage &sm = messageStore.addFromPacket(mp);
 
+        // Pass message to renderer (banner + thread switching + scroll reset)
+        // Use the global Screen singleton to retrieve the current OLED display
+        auto *display = screen ? screen->getDisplayDevice() : nullptr;
+        graphics::MessageRenderer::handleNewMessage(display, sm, mp);
+    }
+#endif
     // Only trigger screen wake if configuration allows it
     if (shouldWakeOnReceivedMessage()) {
         powerFSM.trigger(EVENT_RECEIVED_MSG);
     }
+
+    // Notify any observers (e.g. external modules that care about packets)
     notifyObservers(&mp);
 
     return ProcessMessage::CONTINUE; // Let others look at this message also if they want
diff --git a/src/modules/TextMessageModule.h b/src/modules/TextMessageModule.h
index cc0b0f9d5..e719f1abc 100644
--- a/src/modules/TextMessageModule.h
+++ b/src/modules/TextMessageModule.h
@@ -3,7 +3,13 @@
 #include "SinglePortModule.h"
 
 /**
- * Text message handling for meshtastic - draws on the OLED display the most recent received message
+ * Text message handling for Meshtastic.
+ *
+ * This module is responsible for receiving and storing incoming text messages
+ * from the mesh. It updates device state and notifies observers so that other
+ * components (such as the MessageRenderer) can later display or process them.
+ *
+ * Rendering of messages on screen is no longer done here.
  */
 class TextMessageModule : public SinglePortModule, public Observable<const meshtastic_MeshPacket *>
 {
@@ -15,10 +21,10 @@ class TextMessageModule : public SinglePortModule, public Observable<const mesht
 
   protected:
     /** Called to handle a particular incoming message
-
-    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for
-    it
-    */
+     *
+     * @return ProcessMessage::STOP if you've guaranteed you've handled this
+     *         message and no other handlers should be considered for it.
+     */
     virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
     virtual bool wantPacket(const meshtastic_MeshPacket *p) override;
 };
diff --git a/src/modules/WaypointModule.cpp b/src/modules/WaypointModule.cpp
index 4b05d5fa1..4db80ba18 100644
--- a/src/modules/WaypointModule.cpp
+++ b/src/modules/WaypointModule.cpp
@@ -2,6 +2,7 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "configuration.h"
+#include "graphics/SharedUIDisplay.h"
 #include "graphics/draw/CompassRenderer.h"
 
 #if HAS_SCREEN
@@ -14,6 +15,15 @@
 
 WaypointModule *waypointModule;
 
+static inline float degToRad(float deg)
+{
+    return deg * PI / 180.0f;
+}
+static inline float radToDeg(float rad)
+{
+    return rad * 180.0f / PI;
+}
+
 ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
 #if defined(DEBUG_PORT) && !defined(DEBUG_MUTE)
@@ -52,31 +62,15 @@ ProcessMessage WaypointModule::handleReceived(const meshtastic_MeshPacket &mp)
 bool WaypointModule::shouldDraw()
 {
 #if !MESHTASTIC_EXCLUDE_WAYPOINT
-    if (screen == nullptr)
-        return false;
-    // If no waypoint to show
-    if (!devicestate.has_rx_waypoint)
+    if (!screen || !devicestate.has_rx_waypoint)
         return false;
 
-    // Decode the message, to find the expiration time (is waypoint still valid)
-    // This handles "deletion" as well as expiration
-    meshtastic_Waypoint wp;
-    memset(&wp, 0, sizeof(wp));
+    meshtastic_Waypoint wp{}; // <- replaces memset
     if (pb_decode_from_bytes(devicestate.rx_waypoint.decoded.payload.bytes, devicestate.rx_waypoint.decoded.payload.size,
                              &meshtastic_Waypoint_msg, &wp)) {
-        // Valid waypoint
-        if (wp.expire > getTime())
-            return devicestate.has_rx_waypoint = true;
-
-        // Expired, or deleted
-        else
-            return devicestate.has_rx_waypoint = false;
+        return wp.expire > getTime();
     }
-
-    // If decoding failed
-    LOG_ERROR("Failed to decode waypoint");
-    devicestate.has_rx_waypoint = false;
-    return false;
+    return false; // no LOG_ERROR, no flag writes
 #else
     return false;
 #endif
@@ -85,53 +79,46 @@ bool WaypointModule::shouldDraw()
 /// Draw the last waypoint we received
 void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
-    if (screen == nullptr)
+    if (!screen)
         return;
-    // Prepare to draw
-    display->setFont(FONT_SMALL);
+    display->clear();
     display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_SMALL);
+    int line = 1;
 
-    // Handle inverted display
-    // Unsure of expected behavior: for now, copy drawNodeInfo
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_INVERTED)
-        display->fillRect(0 + x, 0 + y, x + display->getWidth(), y + FONT_HEIGHT_SMALL);
+    // === Set Title
+    const char *titleStr = "Waypoint";
+
+    // === Header ===
+    graphics::drawCommonHeader(display, x, y, titleStr);
+
+    const int w = display->getWidth();
+    const int h = display->getHeight();
 
     // Decode the waypoint
     const meshtastic_MeshPacket &mp = devicestate.rx_waypoint;
-    meshtastic_Waypoint wp;
-    memset(&wp, 0, sizeof(wp));
+    meshtastic_Waypoint wp{};
     if (!pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, &meshtastic_Waypoint_msg, &wp)) {
-        // This *should* be caught by shouldDrawWaypoint, but we'll short-circuit here just in case
-        display->drawStringMaxWidth(0 + x, 0 + y, x + display->getWidth(), "Couldn't decode waypoint");
         devicestate.has_rx_waypoint = false;
         return;
     }
 
     // Get timestamp info. Will pass as a field to drawColumns
-    static char lastStr[20];
+    char lastStr[20];
     getTimeAgoStr(sinceReceived(&mp), lastStr, sizeof(lastStr));
 
     // Will contain distance information, passed as a field to drawColumns
-    static char distStr[20];
+    char distStr[20];
 
     // Get our node, to use our own position
     meshtastic_NodeInfoLite *ourNode = nodeDB->getMeshNode(nodeDB->getNodeNum());
 
-    // Text fields to draw (left of compass)
-    // Last element must be NULL. This signals the end of the char*[] to drawColumns
-    const char *fields[] = {"Waypoint", lastStr, wp.name, distStr, NULL};
-
     // Dimensions / co-ordinates for the compass/circle
-    int16_t compassX = 0, compassY = 0;
-    uint16_t compassDiam = graphics::CompassRenderer::getCompassDiam(display->getWidth(), display->getHeight());
-
-    if (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT) {
-        compassX = x + display->getWidth() - compassDiam / 2 - 5;
-        compassY = y + display->getHeight() / 2;
-    } else {
-        compassX = x + display->getWidth() - compassDiam / 2 - 5;
-        compassY = y + FONT_HEIGHT_SMALL + (display->getHeight() - FONT_HEIGHT_SMALL) / 2;
-    }
+    const uint16_t compassDiam = graphics::CompassRenderer::getCompassDiam(w, h);
+    const int16_t compassX = x + w - (compassDiam / 2) - 5;
+    const int16_t compassY = (config.display.displaymode == meshtastic_Config_DisplayConfig_DisplayMode_DEFAULT)
+                                 ? y + h / 2
+                                 : y + FONT_HEIGHT_SMALL + (h - FONT_HEIGHT_SMALL) / 2;
 
     // If our node has a position:
     if (ourNode && (nodeDB->hasValidPosition(ourNode) || screen->hasHeading())) {
@@ -141,7 +128,7 @@ void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state,
             myHeading = 0;
         } else {
             if (screen->hasHeading())
-                myHeading = (screen->getHeading()) * PI / 180; // gotta convert compass degrees to Radians
+                myHeading = degToRad(screen->getHeading());
             else
                 myHeading = screen->estimatedHeading(DegD(op.latitude_i), DegD(op.longitude_i));
         }
@@ -157,46 +144,35 @@ void WaypointModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state,
         graphics::CompassRenderer::drawNodeHeading(display, compassX, compassY, compassDiam, bearingToOther);
 
         float bearingToOtherDegrees = (bearingToOther < 0) ? bearingToOther + 2 * PI : bearingToOther;
-        bearingToOtherDegrees = bearingToOtherDegrees * 180 / PI;
+        bearingToOtherDegrees = radToDeg(bearingToOtherDegrees);
 
         // Distance to Waypoint
         float d = GeoCoord::latLongToMeter(DegD(wp.latitude_i), DegD(wp.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
         if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) {
-            if (d < (2 * MILES_TO_FEET))
-                snprintf(distStr, sizeof(distStr), "%.0fft   %.0f°", d * METERS_TO_FEET, bearingToOtherDegrees);
-            else
-                snprintf(distStr, sizeof(distStr), "%.1fmi   %.0f°", d * METERS_TO_FEET / MILES_TO_FEET, bearingToOtherDegrees);
+            float feet = d * METERS_TO_FEET;
+            snprintf(distStr, sizeof(distStr), feet < (2 * MILES_TO_FEET) ? "%.0fft   %.0f°" : "%.1fmi   %.0f°",
+                     feet < (2 * MILES_TO_FEET) ? feet : feet / MILES_TO_FEET, bearingToOtherDegrees);
         } else {
-            if (d < 2000)
-                snprintf(distStr, sizeof(distStr), "%.0fm   %.0f°", d, bearingToOtherDegrees);
-            else
-                snprintf(distStr, sizeof(distStr), "%.1fkm   %.0f°", d / 1000, bearingToOtherDegrees);
+            snprintf(distStr, sizeof(distStr), d < 2000 ? "%.0fm   %.0f°" : "%.1fkm   %.0f°", d < 2000 ? d : d / 1000,
+                     bearingToOtherDegrees);
         }
-
     }
 
-    // If our node doesn't have position
     else {
-        // ? in the compass
         display->drawString(compassX - FONT_HEIGHT_SMALL / 4, compassY - FONT_HEIGHT_SMALL / 2, "?");
 
         // ? in the distance field
-        if (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL)
-            strncpy(distStr, "? mi ?°", sizeof(distStr));
-        else
-            strncpy(distStr, "? km ?°", sizeof(distStr));
+        snprintf(distStr, sizeof(distStr), "? %s ?°",
+                 (config.display.units == meshtastic_Config_DisplayConfig_DisplayUnits_IMPERIAL) ? "mi" : "km");
     }
 
     // Draw compass circle
     display->drawCircle(compassX, compassY, compassDiam / 2);
 
-    // Undo color-inversion, if set prior to drawing header
-    // Unsure of expected behavior? For now: copy drawNodeInfo
-    if (config.display.displaymode != meshtastic_Config_DisplayConfig_DisplayMode_INVERTED) {
-        display->setColor(BLACK);
-    }
-
-    // Must be after distStr is populated
-    graphics::NodeListRenderer::drawColumns(display, x, y, fields);
+    display->setTextAlignment(TEXT_ALIGN_LEFT); // Something above me changes to a different alignment, forcing a fix here!
+    display->drawString(0, graphics::getTextPositions(display)[line++], lastStr);
+    display->drawString(0, graphics::getTextPositions(display)[line++], wp.name);
+    display->drawString(0, graphics::getTextPositions(display)[line++], wp.description);
+    display->drawString(0, graphics::getTextPositions(display)[line++], distStr);
 }
 #endif
diff --git a/src/platform/portduino/PortduinoGlue.cpp b/src/platform/portduino/PortduinoGlue.cpp
index 1b601f9b4..dab9e8d8c 100644
--- a/src/platform/portduino/PortduinoGlue.cpp
+++ b/src/platform/portduino/PortduinoGlue.cpp
@@ -427,11 +427,13 @@ void portduinoSetup()
     }
 
     getMacAddr(dmac);
+#ifndef UNIT_TEST
     if (dmac[0] == 0 && dmac[1] == 0 && dmac[2] == 0 && dmac[3] == 0 && dmac[4] == 0 && dmac[5] == 0) {
         std::cout << "*** Blank MAC Address not allowed!" << std::endl;
         std::cout << "Please set a MAC Address in config.yaml using either MACAddress or MACAddressSource." << std::endl;
         exit(EXIT_FAILURE);
     }
+#endif
     printf("MAC ADDRESS: %02X:%02X:%02X:%02X:%02X:%02X\n", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);
     // Rather important to set this, if not running simulated.
     randomSeed(time(NULL));
diff --git a/variants/nrf52840/heltec_mesh_solar/platformio.ini b/variants/nrf52840/heltec_mesh_solar/platformio.ini
index 9e73e745a..fa8965a64 100644
--- a/variants/nrf52840/heltec_mesh_solar/platformio.ini
+++ b/variants/nrf52840/heltec_mesh_solar/platformio.ini
@@ -48,6 +48,14 @@ build_flags = ${heltec_mesh_solar_base.build_flags}
   -DEINK_LIMIT_RATE_RESPONSIVE_SEC=1   ; Minimum interval between RESPONSIVE updates
   -DEINK_BACKGROUND_USES_FAST          ; (Optional) Use FAST refresh for both BACKGROUND and RESPONSIVE, until a limit is reached.
   -DEINK_HASQUIRK_GHOSTING             ; Display model is identified as "prone to ghosting"
+  -DENABLE_MESSAGE_PERSISTENCE=0       ; Disable flash persistence for space-limited build
+  -DMESHTASTIC_EXCLUDE_WIFI=1
+  -DMESHTASTIC_EXCLUDE_EXTERNALNOTIFICATION=1
+  -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
+  -DMESHTASTIC_EXCLUDE_REMOTEHARDWARE=1
+  -DMESHTASTIC_EXCLUDE_STOREFORWARD=1
+  -DMESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
+  -DMESHTASTIC_EXCLUDE_WAYPOINT=1
 lib_deps =
   ${heltec_mesh_solar_base.lib_deps}
   # renovate: datasource=git-refs depName=meshtastic-GxEPD2 packageName=https://github.com/meshtastic/GxEPD2 gitBranch=master

From ef530db44c3567944df3bf5def193328cea5a2e8 Mon Sep 17 00:00:00 2001
From: Jason P <applewiz@mac.com>
Date: Fri, 26 Dec 2025 07:34:25 -0600
Subject: [PATCH 10/10] Implement HAS_PHYSICAL_KEYBOARD for devices with
 physical keyboards (#9071)

- Implement HAS_PHYSICAL_KEYBOARD for devices with physical keyboards
- Add HAS_PHYSICAL_KEYBOARD to variant.h for:
  - TDeck
  - TLora Pager
  - TDeck Pro
---
 src/input/RotaryEncoderInterruptImpl1.cpp | 2 ++
 src/input/TrackballInterruptBase.cpp      | 2 ++
 src/input/UpDownInterruptImpl1.cpp        | 2 ++
 src/main.cpp                              | 2 ++
 variants/esp32s3/t-deck-pro/variant.h     | 2 ++
 variants/esp32s3/t-deck/variant.h         | 1 +
 variants/esp32s3/tlora-pager/variant.h    | 1 +
 7 files changed, 12 insertions(+)

diff --git a/src/input/RotaryEncoderInterruptImpl1.cpp b/src/input/RotaryEncoderInterruptImpl1.cpp
index 12cbc36fb..1da2ea008 100644
--- a/src/input/RotaryEncoderInterruptImpl1.cpp
+++ b/src/input/RotaryEncoderInterruptImpl1.cpp
@@ -27,7 +27,9 @@ bool RotaryEncoderInterruptImpl1::init()
                                      RotaryEncoderInterruptImpl1::handleIntA, RotaryEncoderInterruptImpl1::handleIntB,
                                      RotaryEncoderInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     return true;
 }
 
diff --git a/src/input/TrackballInterruptBase.cpp b/src/input/TrackballInterruptBase.cpp
index d2025c192..bbd07e199 100644
--- a/src/input/TrackballInterruptBase.cpp
+++ b/src/input/TrackballInterruptBase.cpp
@@ -45,7 +45,9 @@ void TrackballInterruptBase::init(uint8_t pinDown, uint8_t pinUp, uint8_t pinLef
 
     LOG_DEBUG("Trackball GPIO initialized - UP:%d DOWN:%d LEFT:%d RIGHT:%d PRESS:%d", this->_pinUp, this->_pinDown,
               this->_pinLeft, this->_pinRight, pinPress);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     this->setInterval(100);
 }
 
diff --git a/src/input/UpDownInterruptImpl1.cpp b/src/input/UpDownInterruptImpl1.cpp
index 9b0b1f39e..906dcd2a8 100644
--- a/src/input/UpDownInterruptImpl1.cpp
+++ b/src/input/UpDownInterruptImpl1.cpp
@@ -29,7 +29,9 @@ bool UpDownInterruptImpl1::init()
                               eventDownLong, UpDownInterruptImpl1::handleIntDown, UpDownInterruptImpl1::handleIntUp,
                               UpDownInterruptImpl1::handleIntPressed);
     inputBroker->registerSource(this);
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
+#endif
     return true;
 }
 
diff --git a/src/main.cpp b/src/main.cpp
index e29736712..d28eb13f0 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1465,8 +1465,10 @@ void setup()
 #endif
 
 #if defined(HAS_TRACKBALL) || (defined(INPUTDRIVER_ENCODER_TYPE) && INPUTDRIVER_ENCODER_TYPE == 2)
+#ifndef HAS_PHYSICAL_KEYBOARD
     osk_found = true;
 #endif
+#endif
 
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WEBSERVER
     // Start web server thread.
diff --git a/variants/esp32s3/t-deck-pro/variant.h b/variants/esp32s3/t-deck-pro/variant.h
index 35cb99435..36a1310f1 100644
--- a/variants/esp32s3/t-deck-pro/variant.h
+++ b/variants/esp32s3/t-deck-pro/variant.h
@@ -100,3 +100,5 @@
 #define MODEM_DTR 8
 #define MODEM_RX 10
 #define MODEM_TX 11
+
+#define HAS_PHYSICAL_KEYBOARD 1
\ No newline at end of file
diff --git a/variants/esp32s3/t-deck/variant.h b/variants/esp32s3/t-deck/variant.h
index ece0cdeaf..8d2996131 100644
--- a/variants/esp32s3/t-deck/variant.h
+++ b/variants/esp32s3/t-deck/variant.h
@@ -23,6 +23,7 @@
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
 #define USE_TFTDISPLAY 1
+#define HAS_PHYSICAL_KEYBOARD 1
 
 #define HAS_TOUCHSCREEN 1
 #define SCREEN_TOUCH_INT 16
diff --git a/variants/esp32s3/tlora-pager/variant.h b/variants/esp32s3/tlora-pager/variant.h
index 5f479dfa6..e6ac2c57e 100644
--- a/variants/esp32s3/tlora-pager/variant.h
+++ b/variants/esp32s3/tlora-pager/variant.h
@@ -21,6 +21,7 @@
 #define SCREEN_TRANSITION_FRAMERATE 5
 #define BRIGHTNESS_DEFAULT 130 // Medium Low Brightness
 #define USE_TFTDISPLAY 1
+#define HAS_PHYSICAL_KEYBOARD 1
 
 #define I2C_SDA SDA
 #define I2C_SCL SCL