From 36b04b6dbc7ba6b16206e10095133f8a000f0479 Mon Sep 17 00:00:00 2001
From: Kaustubh Patange <DeveloperKP16@gmail.com>
Date: Sat, 14 Feb 2026 15:38:59 +0530
Subject: [PATCH 01/10] Add simulator for local development (#1)

* Simulator that works on macos

* fork simulator from https://github.com/ltcmweb/seedsigner

* Fix camera exposure and screen size

* resize and crop + revert rbga in read_capture

* remove padding

* move gpio to different module

* restore modules for dev mode

* merge camera

* extract local display

---------

Co-authored-by: Hector Chu <hectorchu@gmail.com>
Co-authored-by: Nick Klockenga <nick@klockenga.net>
---
 .gitignore                                    |   3 +-
 README.md                                     |   1 +
 requirements.txt                              |  10 +-
 src/gui.py                                    | 149 +++++++++++++++
 src/seedsigner/controller.py                  |  13 +-
 src/seedsigner/extras/dev.py                  |   4 +
 src/seedsigner/extras/gpio.py                 |  49 +++++
 src/seedsigner/extras/local_camera.py         | 164 ++++++++++++++++
 src/seedsigner/extras/local_display.py        |   8 +
 src/seedsigner/gui/components.py              |   2 +-
 src/seedsigner/gui/renderer.py                |   1 -
 src/seedsigner/hardware/buttons.py            |  10 +-
 src/seedsigner/hardware/camera.py             | 177 +++++++++---------
 .../hardware/displays/display_driver.py       |  10 +-
 src/seedsigner/models/decode_qr.py            |   3 +
 src/seedsigner/models/encode_qr.py            |   5 +-
 src/seedsigner/models/psbt_parser.py          |   2 +-
 17 files changed, 505 insertions(+), 106 deletions(-)
 create mode 100644 src/gui.py
 create mode 100644 src/seedsigner/extras/dev.py
 create mode 100644 src/seedsigner/extras/gpio.py
 create mode 100644 src/seedsigner/extras/local_camera.py
 create mode 100644 src/seedsigner/extras/local_display.py

diff --git a/.gitignore b/.gitignore
index 9c70709f3..5239a8763 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,4 +8,5 @@ src/seedsigner/models/settings_definition.json
 .coverage*
 
 *.po
-*.mo
\ No newline at end of file
+*.mo
+*.bmp
diff --git a/README.md b/README.md
index 171bd6713..05a730e41 100644
--- a/README.md
+++ b/README.md
@@ -358,3 +358,4 @@ See the [SeedSigner OS repo](https://github.com/SeedSigner/seedsigner-os/) for i
 
 # Developer Local Build Instructions
 Raspberry Pi OS is commonly used for development. See the [Raspberry Pi OS Build Instructions](docs/raspberry_pi_os_build_instructions.md)
+Desktop build for development on macos. See the [TODO]
diff --git a/requirements.txt b/requirements.txt
index d7a20d593..c0b75601e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,7 @@
-embit==0.8.0
-Pillow==10.0.1
+embit
+Pillow
 pyzbar @ git+https://github.com/seedsigner/pyzbar.git@c3c237821c6a20b17953efe59b90df0b514a1c03
-qrcode==7.3.1
-urtypes==1.0.1
+qrcode
+urtypes
+numpy
+opencv-python
diff --git a/src/gui.py b/src/gui.py
new file mode 100644
index 000000000..d10c0d01f
--- /dev/null
+++ b/src/gui.py
@@ -0,0 +1,149 @@
+import os
+import numpy as np
+import socket
+import threading
+import time
+
+from tkinter import *
+from PIL import Image, ImageTk
+
+from seedsigner.hardware.buttons import HardwareButtons
+
+
+class Display:
+    def __init__(self, width: int = 240, height: int = 240):
+        self.width = width
+        self.height = height
+
+        self.setup_sock()
+        self.run()
+
+    def run(self):
+        self.root = Tk()
+        self.root.title("SeedSigner")
+
+        self.root.geometry(f"{self.width*2}x{self.height}+240+240")
+        self.root.resizable(False, False)
+        self.root.configure(bg='orange')
+        self.root.attributes("-topmost", True)
+
+        self.label=Label(self.root)
+        self.label.pack()
+
+        self.joystick=Frame(self.root)
+        self.joystick.pack()
+        self.joystick.place(x=20, y=85)
+        self.joystick.configure(bg='orange')
+
+        pixel = PhotoImage(width=1, height=1)
+
+        self.btnL = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_LEFT_PIN)
+        self.btnL.grid(row=1, column=0)
+        self.bindButtonClick(self.btnL)
+
+        self.btnR = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_RIGHT_PIN)
+        self.btnR.grid(row=1, column=2)
+        self.bindButtonClick(self.btnR)
+
+        self.btnC = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_PRESS_PIN)
+        self.btnC.grid(row=1, column=1)
+        self.bindButtonClick(self.btnC)
+
+        self.btnU = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_UP_PIN)
+        self.btnU.grid(row=0, column=1)
+        self.bindButtonClick(self.btnU)
+
+        self.btnD = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_DOWN_PIN)
+        self.btnD.grid(row=2, column=1)
+        self.bindButtonClick(self.btnD)
+
+        self.btn1 = Button(self.root, image=pixel, width=40, height=20, command=HardwareButtons.KEY1_PIN)
+        self.btn1.place(x=self.width+160, y=60)
+        self.bindButtonClick(self.btn1)
+
+        self.btn2 = Button(self.root, image=pixel, width=40, height=20, command=HardwareButtons.KEY2_PIN)
+        self.btn2.place(x=self.width+160, y=116)
+        self.bindButtonClick(self.btn2)
+
+        self.btn3 = Button(self.root, image=pixel, width=40, height=20, command=HardwareButtons.KEY3_PIN)
+        self.btn3.place(x=self.width+160, y=172)
+        self.bindButtonClick(self.btn3)
+
+        def key_handler(event):
+            if event.keysym == "Up": self.key_press(HardwareButtons.KEY_UP_PIN)
+            if event.keysym == "Down": self.key_press(HardwareButtons.KEY_DOWN_PIN)
+            if event.keysym == "Left": self.key_press(HardwareButtons.KEY_LEFT_PIN)
+            if event.keysym == "Right": self.key_press(HardwareButtons.KEY_RIGHT_PIN)
+
+            if event.keysym in ("1", "KP_1"): self.key_press(HardwareButtons.KEY1_PIN)
+            if event.keysym in ("2", "KP_2"): self.key_press(HardwareButtons.KEY2_PIN)
+            if event.keysym in ("3", "KP_3"): self.key_press(HardwareButtons.KEY3_PIN)
+
+            if event.keysym == "Return": self.key_press(HardwareButtons.KEY_PRESS_PIN)
+
+        self.root.bind("<Key>", key_handler)
+
+        self.periodic_update()
+        self.root.mainloop()
+
+    def key_press(self, key):
+        self.set_input(key, 0)
+        time.sleep(0.1)
+        self.set_input(key, 1)
+
+    def bindButtonClick(self, btn):
+        btn.bind("<Button>", self.buttonDown)
+        btn.bind("<ButtonRelease>", self.buttonUp)
+
+    def buttonDown(self, btn):
+        key = btn.widget.config('command')[-1]
+        self.set_input(key, 0)
+
+    def buttonUp(self, btn):
+        key = btn.widget.config('command')[-1]
+        self.set_input(key, 1)
+
+    def load_raw_rgb(self, filename):
+        if not os.path.exists(filename):
+            return None
+        with open(filename, "rb") as f:
+            data = f.read()
+        img_array = np.frombuffer(data, dtype=np.uint8)
+        try:
+            img_array = img_array.reshape((self.height, self.width, 3))
+        except ValueError:
+            return None
+        return Image.fromarray(img_array, 'RGB')
+
+    def periodic_update(self, filename="display.bmp", interval=10):
+        img = self.load_raw_rgb(filename)
+        if img:
+            self.tkimage = ImageTk.PhotoImage(img, master=self.root)
+            self.label.configure(image=self.tkimage)
+            self.label.image = self.tkimage
+        self.root.after(interval, lambda: self.periodic_update(filename, interval))
+
+    def set_input(self, key, val):
+        try:
+            msg = f"{key} {val}\n"
+            self.conn.sendall(msg.encode())
+        except Exception:
+            pass
+
+    def setup_sock(self, path = 'gpio.sock'):
+        if os.path.exists(path):
+            os.remove(path)
+
+        self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.server.bind(path)
+        self.server.listen(1)
+
+        threading.Thread(target=self.handle_sock, daemon=True).start()
+
+    def handle_sock(self):
+        while True:
+            self.conn, _ = self.server.accept()
+
+
+if __name__ == "__main__":
+    Display()
diff --git a/src/seedsigner/controller.py b/src/seedsigner/controller.py
index 5b3f22e8d..e548db8ef 100644
--- a/src/seedsigner/controller.py
+++ b/src/seedsigner/controller.py
@@ -6,6 +6,7 @@
 from embit.psbt import PSBT
 from PIL.Image import Image
 
+from seedsigner.extras.dev import DEV_MODE
 from seedsigner.gui.toast import BaseToastOverlayManagerThread
 from seedsigner.models.psbt_parser import PSBTParser
 from seedsigner.models.seed import Seed
@@ -72,7 +73,8 @@ def time_import(module_name):
         Controller.get_instance()._storage = SeedStorage()
 
         time_import('numpy')  # used by PiVideoStream; by far the slowest import (2.29s)
-        time_import('seedsigner.hardware.pivideostream') 
+        if not DEV_MODE:
+            time_import('seedsigner.hardware.pivideostream')
 
         # Get MainMenuView ready to respond quickly
         time_import('seedsigner.views.scan_views')
@@ -291,10 +293,11 @@ def run(self):
                 next_destination = Destination(MainMenuView)
             
             # Set up our one-time toast notification tip to remove the SD card
-            if self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FIVE_SECONDS:
-                self.activate_toast(RemoveSDCardToastManagerThread())
-            elif self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FOREVER:
-                next_destination = Destination(RemoveMicroSDWarningView)
+            if not DEV_MODE:
+                if self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FIVE_SECONDS:
+                    self.activate_toast(RemoveSDCardToastManagerThread())
+                elif self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FOREVER:
+                    next_destination = Destination(RemoveMicroSDWarningView)
 
             while True:
                 # Destination(None) is a special case; render the Home screen
diff --git a/src/seedsigner/extras/dev.py b/src/seedsigner/extras/dev.py
new file mode 100644
index 000000000..9a70d7b94
--- /dev/null
+++ b/src/seedsigner/extras/dev.py
@@ -0,0 +1,4 @@
+import os
+from typing import Final
+
+DEV_MODE: Final = os.environ.get("LOCAL_DEV")
diff --git a/src/seedsigner/extras/gpio.py b/src/seedsigner/extras/gpio.py
new file mode 100644
index 000000000..bb71ed055
--- /dev/null
+++ b/src/seedsigner/extras/gpio.py
@@ -0,0 +1,49 @@
+import socket
+import threading
+from typing import Final
+
+class _GPIO:
+    LOW: Final = 0
+    HIGH: Final = 1
+
+    # Fake constants
+    BOARD: Final = 10
+    IN: Final = 1
+    PUD_UP: Final = 22
+    RPI_INFO: Final = {"P1_REVISION": 3}
+
+    def setmode(self, a: int):
+        pass
+
+    def setup(self, a: int, b: int, *,  pull_up_down: int):
+        pass
+
+    def init(self, socket_path="gpio.sock"):
+        self._states = {}
+        self.lock = threading.Lock()
+        self.socket_path = socket_path
+
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.connect(self.socket_path)
+
+        threading.Thread(target=self._read_loop, daemon=True).start()
+
+    def _read_loop(self):
+        f = self.sock.makefile("r")
+        while True:
+            line = f.readline()
+            if not line:
+                break
+            try:
+                pin, val = line.strip().split()
+                with self.lock:
+                    self._states[int(pin)] = int(val)
+            except Exception:
+                pass
+
+    def input(self, pin):
+        with self.lock:
+            return self._states.get(pin, self.HIGH)
+
+
+GPIO = _GPIO()
diff --git a/src/seedsigner/extras/local_camera.py b/src/seedsigner/extras/local_camera.py
new file mode 100644
index 000000000..5254f9c65
--- /dev/null
+++ b/src/seedsigner/extras/local_camera.py
@@ -0,0 +1,164 @@
+from PIL import Image
+
+from seedsigner.models.settings import Settings, SettingsConstants
+from seedsigner.models.singleton import Singleton
+
+from threading import Thread
+import time
+import cv2
+import numpy as np
+
+
+class Camera(Singleton):
+    _video_stream = None
+    _picamera = None
+    _camera_rotation = None
+
+    @classmethod
+    def get_instance(cls):
+        # This is the only way to access the one and only Controller
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+        cls._instance._camera_rotation = int( Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
+        cls._instance._camera_rotation += 90
+        return cls._instance
+
+    def start_video_stream_mode(
+        self, resolution=(512, 384), framerate=12, format="bgr"
+    ):
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+
+        try:
+            self._video_stream = WebcamVideoStream(
+                resolution=resolution, framerate=framerate, format=format
+            )
+            self._video_stream.start()
+        except Exception as e:
+            raise e
+
+    def read_video_stream(self, as_image=False):
+        if not self._video_stream:
+            raise Exception("Must call start_video_stream first.")
+        frame = self._video_stream.read()
+        if not as_image:
+            return frame
+        else:
+            if frame is not None:
+                return Image.fromarray(frame.astype("uint8"), "RGB").rotate(
+                    90 + self._camera_rotation
+                )
+        return None
+
+    def stop_video_stream_mode(self):
+        if self._video_stream is not None:
+            self._video_stream.stop()
+            self._video_stream = None
+
+    def start_single_frame_mode(self, resolution=(720, 480)):
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+        if self._picamera is not None:
+            self._picamera.close()
+
+    def capture_frame(self):
+        frame = WebcamVideoStream.single_frame()
+        return Image.fromarray(frame).rotate(90 + self._camera_rotation)
+
+    def stop_single_frame_mode(self):
+        if self._picamera is not None:
+            self._picamera.close()
+            self._picamera = None
+
+
+def resize_and_center_crop_240(frame_bgr: np.ndarray) -> np.ndarray:
+    target = 240
+    h, w = frame_bgr.shape[:2]
+
+    # resize to 240
+    if w < h:
+        scale = target / w
+    else:
+        scale = target / h
+
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+
+    resized = cv2.resize(frame_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+    # center crop
+    x1 = (new_w - target) // 2
+    y1 = (new_h - target) // 2
+
+    cropped = resized[y1 : y1 + target, x1 : x1 + target]
+
+    return cropped
+
+
+class WebcamVideoStream:
+    def __init__(self, resolution=(320, 240), framerate=32, format="bgr", **kwargs):
+        # initialize the camera
+        self.camera = cv2.VideoCapture(0)
+        self.set_resolution(resolution)
+
+        # initialize the frame and the variable used to indicate
+        # if the thread should be stopped
+        self.frame = None
+        self.should_stop = False
+        self.is_stopped = True
+
+    def start(self):
+        # start the thread to read frames from the video stream
+        t = Thread(target=self.update, args=())
+        t.daemon = True
+        t.start()
+        self.is_stopped = False
+        return self
+
+    def update(self):
+        if self.camera.isOpened():
+            # keep looping infinitely until the thread is stopped
+            while not self.should_stop:
+                # grab the frame from the stream and clear the stream in
+                # preparation for the next frame
+                ret, stream = self.camera.read()
+                stream = cv2.resize(stream, (240, 240))
+                stream = cv2.cvtColor(stream, cv2.COLOR_BGR2RGB)
+                time.sleep(0.05)
+                self.frame = stream
+        self.is_stopped = True
+        self.should_stop = False
+
+    def read(self):
+        return self.frame
+
+    def stop(self):
+        # indicate that the thread should be stopped
+        self.should_stop = True
+
+        # Block in this thread until stopped
+        while not self.is_stopped:
+            pass
+
+    def set_resolution(self, resolution):
+        self.camera.set(3, resolution[0])
+        self.camera.set(4, resolution[1])
+
+    @staticmethod
+    def single_frame():
+        cap = cv2.VideoCapture(0)
+
+        # Warm-up, let auto-exposure settle in
+        for _ in range(30):
+            cap.read()
+            time.sleep(0.01)
+
+        ret, frame = cap.read()
+        cap.release()
+
+        if not ret:
+            raise RuntimeError("Camera capture failed")
+
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frame = resize_and_center_crop_240(frame)
+        return frame
diff --git a/src/seedsigner/extras/local_display.py b/src/seedsigner/extras/local_display.py
new file mode 100644
index 000000000..e8d65a12d
--- /dev/null
+++ b/src/seedsigner/extras/local_display.py
@@ -0,0 +1,8 @@
+class ST7789:
+    def __init__(self, width = 240, height = 240):
+        self.width = width
+        self.height = height
+
+    def show_image(self, image, x, y):
+        with open('display.bmp', 'wb') as f:
+            f.write(image.tobytes())
diff --git a/src/seedsigner/gui/components.py b/src/seedsigner/gui/components.py
index 9c82c17d7..565be8de3 100644
--- a/src/seedsigner/gui/components.py
+++ b/src/seedsigner/gui/components.py
@@ -1989,4 +1989,4 @@ def resize_image_to_fill(img: Image, target_size_x: int, target_size_y: int, sam
         (target_size_x, target_size_y),
         resample=sampling_method,
         box=box,
-    )
\ No newline at end of file
+    )
diff --git a/src/seedsigner/gui/renderer.py b/src/seedsigner/gui/renderer.py
index d0e2381d0..49aec17ef 100644
--- a/src/seedsigner/gui/renderer.py
+++ b/src/seedsigner/gui/renderer.py
@@ -3,7 +3,6 @@
 
 # from seedsigner.hardware.st7789_mpy import ST7789
 from seedsigner.hardware.displays.display_driver import ALL_DISPLAY_TYPES, DISPLAY_TYPE__ILI9341, DISPLAY_TYPE__ILI9486, DISPLAY_TYPE__ST7789, DisplayDriver
-from seedsigner.hardware.displays.ili9341 import ILI9341, ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT
 from seedsigner.models.settings import Settings
 from seedsigner.models.settings_definition import SettingsConstants
 from seedsigner.models.singleton import ConfigurableSingleton
diff --git a/src/seedsigner/hardware/buttons.py b/src/seedsigner/hardware/buttons.py
index abe18c5c0..1b144df3e 100644
--- a/src/seedsigner/hardware/buttons.py
+++ b/src/seedsigner/hardware/buttons.py
@@ -1,6 +1,12 @@
 import logging
 from typing import List
-import RPi.GPIO as GPIO
+
+from seedsigner.extras.dev import DEV_MODE
+if DEV_MODE:
+    from seedsigner.extras.gpio import GPIO
+else:
+    import RPi.GPIO as GPIO
+
 import time
 
 from seedsigner.models.singleton import Singleton
@@ -41,6 +47,8 @@ def get_instance(cls):
             cls._instance = cls.__new__(cls)
 
             #init GPIO
+            if DEV_MODE:
+                GPIO.init()
             GPIO.setmode(GPIO.BOARD)
             GPIO.setup(HardwareButtons.KEY_UP_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)    # Input with pull-up
             GPIO.setup(HardwareButtons.KEY_DOWN_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Input with pull-up
diff --git a/src/seedsigner/hardware/camera.py b/src/seedsigner/hardware/camera.py
index 44919fa4b..7843373f2 100644
--- a/src/seedsigner/hardware/camera.py
+++ b/src/seedsigner/hardware/camera.py
@@ -3,98 +3,99 @@
 from gettext import gettext as _
 from PIL import Image
 
+from seedsigner.extras.dev import DEV_MODE
 from seedsigner.models.settings import Settings, SettingsConstants
 from seedsigner.models.singleton import Singleton
 
 
-
 class CameraConnectionError(Exception):
     pass
 
-
-
-class Camera(Singleton):
-    _video_stream = None
-    _picamera = None
-    _camera_rotation = None
-
-    @classmethod
-    def get_instance(cls):
-        # This is the only way to access the one and only Controller
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-        cls._instance._camera_rotation = int(Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
-        return cls._instance
-
-
-    def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="bgr"):
-        from picamera import PiCameraError
-        from seedsigner.hardware.pivideostream import PiVideoStream
-        if self._video_stream is not None:
-            self.stop_video_stream_mode()
-
-        try:
-            self._video_stream = PiVideoStream(resolution=resolution,framerate=framerate, format=format)
-            self._video_stream.start()
-        except PiCameraError:
-            # This error most often occurs because the camera connection is loose
-            raise CameraConnectionError()
-
-
-    def read_video_stream(self, as_image=False):
-        if not self._video_stream:
-            raise Exception("Must call start_video_stream first.")
-        frame = self._video_stream.read()
-        if not as_image:
-            return frame
-        else:
-            if frame is not None:
-                return Image.fromarray(frame.astype('uint8'), 'RGB').convert('RGBA').rotate(90 + self._camera_rotation)
-        return None
-
-
-    def stop_video_stream_mode(self):
-        if self._video_stream is not None:
-            self._video_stream.stop()
-            self._video_stream = None
-
-
-    def start_single_frame_mode(self, resolution=(720, 480)):
-        from picamera import PiCamera, PiCameraError
-        if self._video_stream is not None:
-            self.stop_video_stream_mode()
-        if self._picamera is not None:
-            self._picamera.close()
-
-        try:
-            self._picamera = PiCamera(resolution=resolution, framerate=24)
-            self._picamera.start_preview()
-        except PiCameraError:
-            # This error most often occurs because the camera connection is loose
-            raise CameraConnectionError()
-
-
-    def capture_frame(self):
-        if self._picamera is None:
-            raise Exception("Must call start_single_frame_mode first.")
-
-        # Set auto-exposure values
-        self._picamera.shutter_speed = self._picamera.exposure_speed
-        self._picamera.exposure_mode = 'off'
-        g = self._picamera.awb_gains
-        self._picamera.awb_mode = 'off'
-        self._picamera.awb_gains = g
-
-        stream = io.BytesIO()
-        self._picamera.capture(stream, format='jpeg')
-
-        # "Rewind" the stream to the beginning so we can read its content
-        stream.seek(0)
-        return Image.open(stream).rotate(90 + self._camera_rotation)
-
-
-    def stop_single_frame_mode(self):
-        if self._picamera is not None:
-            self._picamera.close()
-            self._picamera = None
-
+if DEV_MODE:
+   import seedsigner.extras.local_camera
+   Camera = seedsigner.extras.local_camera.Camera
+else:
+    class Camera(Singleton):
+        _video_stream = None
+        _picamera = None
+        _camera_rotation = None
+
+        @classmethod
+        def get_instance(cls):
+            # This is the only way to access the one and only Controller
+            if cls._instance is None:
+                cls._instance = cls.__new__(cls)
+            cls._instance._camera_rotation = int(Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
+            return cls._instance
+
+
+        def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="bgr"):
+            from picamera import PiCameraError
+            from seedsigner.hardware.pivideostream import PiVideoStream
+            if self._video_stream is not None:
+                self.stop_video_stream_mode()
+
+            try:
+                self._video_stream = PiVideoStream(resolution=resolution,framerate=framerate, format=format)
+                self._video_stream.start()
+            except PiCameraError:
+                # This error most often occurs because the camera connection is loose
+                raise CameraConnectionError()
+
+
+        def read_video_stream(self, as_image=False):
+            if not self._video_stream:
+                raise Exception("Must call start_video_stream first.")
+            frame = self._video_stream.read()
+            if not as_image:
+                return frame
+            else:
+                if frame is not None:
+                    return Image.fromarray(frame.astype('uint8'), 'RGB').convert('RGBA').rotate(90 + self._camera_rotation)
+            return None
+
+
+        def stop_video_stream_mode(self):
+            if self._video_stream is not None:
+                self._video_stream.stop()
+                self._video_stream = None
+
+
+        def start_single_frame_mode(self, resolution=(720, 480)):
+            from picamera import PiCamera, PiCameraError
+            if self._video_stream is not None:
+                self.stop_video_stream_mode()
+            if self._picamera is not None:
+                self._picamera.close()
+
+            try:
+                self._picamera = PiCamera(resolution=resolution, framerate=24)
+                self._picamera.start_preview()
+            except PiCameraError:
+                # This error most often occurs because the camera connection is loose
+                raise CameraConnectionError()
+
+
+        def capture_frame(self):
+            if self._picamera is None:
+                raise Exception("Must call start_single_frame_mode first.")
+
+            # Set auto-exposure values
+            self._picamera.shutter_speed = self._picamera.exposure_speed
+            self._picamera.exposure_mode = 'off'
+            g = self._picamera.awb_gains
+            self._picamera.awb_mode = 'off'
+            self._picamera.awb_gains = g
+
+            stream = io.BytesIO()
+            self._picamera.capture(stream, format='jpeg')
+
+            # "Rewind" the stream to the beginning so we can read its content
+            stream.seek(0)
+            return Image.open(stream).rotate(90 + self._camera_rotation)
+
+
+        def stop_single_frame_mode(self):
+            if self._picamera is not None:
+                self._picamera.close()
+                self._picamera = None
diff --git a/src/seedsigner/hardware/displays/display_driver.py b/src/seedsigner/hardware/displays/display_driver.py
index a41bb3214..987234fb8 100644
--- a/src/seedsigner/hardware/displays/display_driver.py
+++ b/src/seedsigner/hardware/displays/display_driver.py
@@ -1,3 +1,6 @@
+from seedsigner.extras.dev import DEV_MODE
+
+
 DISPLAY_TYPE__ST7789 = "st7789"
 DISPLAY_TYPE__ILI9341 = "ili9341"
 DISPLAY_TYPE__ILI9486 = "ili9486"
@@ -19,7 +22,10 @@ def __init__(self, display_type: str = DISPLAY_TYPE__ST7789, width: int = None,
                 # TODO: For now the original ST7789 driver has to be used for 240x240.
                 # The mpy version below renders incorrectly (almost like each row of pixels
                 # is one pixel short, so the entire screen exhibits a diagonal skew).
-                from seedsigner.hardware.displays.ST7789 import ST7789
+                if not DEV_MODE:
+                    from seedsigner.hardware.displays.ST7789 import ST7789
+                else:
+                    from seedsigner.extras.local_display import ST7789
                 self.display = ST7789()
 
             elif width == 320:
@@ -57,4 +63,4 @@ def invert(self, enabled: bool = True):
 
 
     def show_image(self, image, x_start: int = 0, y_start: int = 0):
-        self.display.show_image(image, x_start, y_start)
\ No newline at end of file
+        self.display.show_image(image, x_start, y_start)
diff --git a/src/seedsigner/models/decode_qr.py b/src/seedsigner/models/decode_qr.py
index 6a2b2d232..c4096cab3 100644
--- a/src/seedsigner/models/decode_qr.py
+++ b/src/seedsigner/models/decode_qr.py
@@ -348,6 +348,9 @@ def detect_segment_type(s, wordlist_language_code=None):
             if re.search("^UR:CRYPTO-PSBT/", s, re.IGNORECASE):
                 return QRType.PSBT__UR2
 
+            elif re.search("^UR:PSBT/", s, re.IGNORECASE):
+                return QRType.PSBT__UR2
+
             elif re.search("^UR:CRYPTO-OUTPUT/", s, re.IGNORECASE):
                 return QRType.OUTPUT__UR
 
diff --git a/src/seedsigner/models/encode_qr.py b/src/seedsigner/models/encode_qr.py
index 86be8c66d..32d03157f 100644
--- a/src/seedsigner/models/encode_qr.py
+++ b/src/seedsigner/models/encode_qr.py
@@ -311,7 +311,8 @@ def seq_len(self):
 
 
     def next_part(self) -> str:
-        return self.ur2_encode.next_part().upper()
+        if self.is_complete: self.restart()
+        return self.ur2_encode.next_part()
 
 
     def cur_part(self) -> str:
@@ -402,5 +403,5 @@ class UrPsbtQrEncoder(BaseFountainQrEncoder):
 
     def __post_init__(self):
         super().__post_init__()
-        qr_ur_bytes = UR("crypto-psbt", UR_PSBT(self.psbt.serialize()).to_cbor())
+        qr_ur_bytes = UR("psbt", UR_PSBT(self.psbt.serialize()).to_cbor())
         self.ur2_encode = UREncoder(ur=qr_ur_bytes, max_fragment_len=self.qr_max_fragment_size)
diff --git a/src/seedsigner/models/psbt_parser.py b/src/seedsigner/models/psbt_parser.py
index 6f1260998..30c1e65f3 100644
--- a/src/seedsigner/models/psbt_parser.py
+++ b/src/seedsigner/models/psbt_parser.py
@@ -470,4 +470,4 @@ def _get_updated_fingerprint(public_key: PublicKey, derivation_path_obj: Derivat
             _fill_scope(inp)
 
         for out in self.psbt.outputs:
-            _fill_scope(out)
\ No newline at end of file
+            _fill_scope(out)

From 3f8aa36540489eb2d4e2cbc84d4f15bc96fb10ed Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sat, 14 Feb 2026 16:39:31 +0530
Subject: [PATCH 02/10] simulator: default method in display

---
 src/seedsigner/extras/local_display.py             | 3 +++
 src/seedsigner/hardware/displays/display_driver.py | 5 ++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/seedsigner/extras/local_display.py b/src/seedsigner/extras/local_display.py
index e8d65a12d..7f68af289 100644
--- a/src/seedsigner/extras/local_display.py
+++ b/src/seedsigner/extras/local_display.py
@@ -6,3 +6,6 @@ def __init__(self, width = 240, height = 240):
     def show_image(self, image, x, y):
         with open('display.bmp', 'wb') as f:
             f.write(image.tobytes())
+
+    def invert(self, enabled: bool = True):
+        pass
diff --git a/src/seedsigner/hardware/displays/display_driver.py b/src/seedsigner/hardware/displays/display_driver.py
index 987234fb8..69faa6769 100644
--- a/src/seedsigner/hardware/displays/display_driver.py
+++ b/src/seedsigner/hardware/displays/display_driver.py
@@ -29,7 +29,10 @@ def __init__(self, display_type: str = DISPLAY_TYPE__ST7789, width: int = None,
                 self.display = ST7789()
 
             elif width == 320:
-                from seedsigner.hardware.displays.st7789_mpy import ST7789
+                if not DEV_MODE:
+                    from seedsigner.hardware.displays.st7789_mpy import ST7789
+                else:
+                    from seedsigner.extras.local_display import ST7789
                 # Have to swap width and height; screen is natively 240x320
                 self.display = ST7789(width=height, height=width)
         

From 5b3ca540c5d5db6276f98c8f3a0def9dcfe00a9e Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sat, 14 Feb 2026 20:09:32 +0530
Subject: [PATCH 03/10] single gui launcher and readme

---
 README.md                                  |   4 +-
 docs/img/simulator.png                     | Bin 0 -> 89071 bytes
 docs/local_simulator_setup_instructions.md |  86 ++++++++++
 src/gui.py                                 | 179 +++++++++++++++++----
 src/seedsigner/extras/dev.py               |   2 +-
 5 files changed, 238 insertions(+), 33 deletions(-)
 create mode 100644 docs/img/simulator.png
 create mode 100644 docs/local_simulator_setup_instructions.md

diff --git a/README.md b/README.md
index 05a730e41..1e5b273cd 100644
--- a/README.md
+++ b/README.md
@@ -357,5 +357,5 @@ Letter templates(8.5in * 11in):
 See the [SeedSigner OS repo](https://github.com/SeedSigner/seedsigner-os/) for instructions.
 
 # Developer Local Build Instructions
-Raspberry Pi OS is commonly used for development. See the [Raspberry Pi OS Build Instructions](docs/raspberry_pi_os_build_instructions.md)
-Desktop build for development on macos. See the [TODO]
+* Raspberry Pi OS is commonly used for development. See the [Raspberry Pi OS Build Instructions](docs/raspberry_pi_os_build_instructions.md)
+* Desktop build for development and simulation. See the [Local SeedSigner Simulator Setup](docs/local_simulator_setup_instructions.md)
diff --git a/docs/img/simulator.png b/docs/img/simulator.png
new file mode 100644
index 0000000000000000000000000000000000000000..b525bf90875d08b2bdbdc5ca9292055f31506c97
GIT binary patch
literal 89071
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

literal 0
HcmV?d00001

diff --git a/docs/local_simulator_setup_instructions.md b/docs/local_simulator_setup_instructions.md
new file mode 100644
index 000000000..27ef32644
--- /dev/null
+++ b/docs/local_simulator_setup_instructions.md
@@ -0,0 +1,86 @@
+# Local SeedSigner Simulator Setup
+
+This guide adds a method to setup SeedSigner testing locally through a simulator GUI for easy development.
+
+It was tested on macOS (26) using Homebrew and Python 3.14. With additional effort it would work on other operating systems and python version or it may still way directly I've not tested it as I don't own any other devices.
+
+<img src="img/simulator.png" width=320 />
+
+---
+
+### Prerequisites
+
+- A desktop / laptop with webcam
+
+---
+
+### Installing system dependencies
+
+SeedSigner’s simulator depends on native libraries for QR scanning and camera access.
+
+```bash
+brew install opencv zbar
+```
+
+These provide:
+
+- Camera capture backend (OpenCV)
+- QR decoding backend (zbar, used by `pyzbar`)
+
+
+
+### Setting up dev environment
+
+The GUI uses tkinter that usually bundles with python installation, but for any reason it is not present follow the guide to setup tkinter https://coderivers.org/blog/installing-tkinter-in-python
+
+```bash
+git clone https://github.com/SeedSigner/seedsigner
+
+python3.14 -m venv env
+source env/bin/activate
+
+# should not fail loading tkinter
+python3.14 -m tkinter
+
+pip install -r requirements.txt
+```
+
+#### Camera Permissions (macOS Security)
+
+On first run, macOS will block camera access. You may see logs like:
+
+```
+OpenCV: not authorized to capture video
+OpenCV: camera failed to properly initialize
+```
+
+#### Grant Camera Permission
+
+Go to: System Settings → Privacy & Security → Camera
+
+Enable camera access for:
+
+- Terminal (if you run from Terminal)
+- VS Code (if you run from VS Code)
+
+Then restart Terminal and rerun the simulator.
+
+You can also reset permissions if macOS didn’t prompt:
+
+```bash
+tccutil reset Camera
+```
+
+### Running the Simulator
+
+From the simulator directory:
+
+```bash
+python src/gui.py
+```
+
+### Notes
+
+- The simulator environment is **not security-hardened** and should never be used with real funds.
+- Camera access, QR decoding, and GUI rendering are all platform-dependent; macOS quirks differ from Raspberry Pi OS.
+- For hardware deployment, follow the official Raspberry Pi OS instructions in the main project README.
diff --git a/src/gui.py b/src/gui.py
index d10c0d01f..f3f6e4b0f 100644
--- a/src/gui.py
+++ b/src/gui.py
@@ -1,8 +1,15 @@
 import os
+
+os.environ.setdefault("LOCAL_DEV", "true")
+
 import numpy as np
 import socket
 import threading
 import time
+import multiprocessing
+import sys
+import signal
+
 
 from tkinter import *
 from PIL import Image, ImageTk
@@ -24,62 +31,118 @@ def run(self):
 
         self.root.geometry(f"{self.width*2}x{self.height}+240+240")
         self.root.resizable(False, False)
-        self.root.configure(bg='orange')
+        self.root.configure(bg="orange")
         self.root.attributes("-topmost", True)
 
-        self.label=Label(self.root)
+        self.label = Label(self.root)
         self.label.pack()
 
-        self.joystick=Frame(self.root)
+        self.joystick = Frame(self.root)
         self.joystick.pack()
         self.joystick.place(x=20, y=85)
-        self.joystick.configure(bg='orange')
+        self.joystick.configure(bg="orange")
 
         pixel = PhotoImage(width=1, height=1)
 
-        self.btnL = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_LEFT_PIN)
+        self.btnL = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=HardwareButtons.KEY_LEFT_PIN,
+        )
         self.btnL.grid(row=1, column=0)
         self.bindButtonClick(self.btnL)
 
-        self.btnR = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_RIGHT_PIN)
+        self.btnR = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=HardwareButtons.KEY_RIGHT_PIN,
+        )
         self.btnR.grid(row=1, column=2)
         self.bindButtonClick(self.btnR)
 
-        self.btnC = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_PRESS_PIN)
+        self.btnC = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=HardwareButtons.KEY_PRESS_PIN,
+        )
         self.btnC.grid(row=1, column=1)
         self.bindButtonClick(self.btnC)
 
-        self.btnU = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_UP_PIN)
+        self.btnU = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=HardwareButtons.KEY_UP_PIN,
+        )
         self.btnU.grid(row=0, column=1)
         self.bindButtonClick(self.btnU)
 
-        self.btnD = Button(self.joystick, image=pixel, width=20, height=20, command=HardwareButtons.KEY_DOWN_PIN)
+        self.btnD = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=HardwareButtons.KEY_DOWN_PIN,
+        )
         self.btnD.grid(row=2, column=1)
         self.bindButtonClick(self.btnD)
 
-        self.btn1 = Button(self.root, image=pixel, width=40, height=20, command=HardwareButtons.KEY1_PIN)
-        self.btn1.place(x=self.width+160, y=60)
+        self.btn1 = Button(
+            self.root,
+            image=pixel,
+            width=40,
+            height=20,
+            command=HardwareButtons.KEY1_PIN,
+        )
+        self.btn1.place(x=self.width + 160, y=60)
         self.bindButtonClick(self.btn1)
 
-        self.btn2 = Button(self.root, image=pixel, width=40, height=20, command=HardwareButtons.KEY2_PIN)
-        self.btn2.place(x=self.width+160, y=116)
+        self.btn2 = Button(
+            self.root,
+            image=pixel,
+            width=40,
+            height=20,
+            command=HardwareButtons.KEY2_PIN,
+        )
+        self.btn2.place(x=self.width + 160, y=116)
         self.bindButtonClick(self.btn2)
 
-        self.btn3 = Button(self.root, image=pixel, width=40, height=20, command=HardwareButtons.KEY3_PIN)
-        self.btn3.place(x=self.width+160, y=172)
+        self.btn3 = Button(
+            self.root,
+            image=pixel,
+            width=40,
+            height=20,
+            command=HardwareButtons.KEY3_PIN,
+        )
+        self.btn3.place(x=self.width + 160, y=172)
         self.bindButtonClick(self.btn3)
 
         def key_handler(event):
-            if event.keysym == "Up": self.key_press(HardwareButtons.KEY_UP_PIN)
-            if event.keysym == "Down": self.key_press(HardwareButtons.KEY_DOWN_PIN)
-            if event.keysym == "Left": self.key_press(HardwareButtons.KEY_LEFT_PIN)
-            if event.keysym == "Right": self.key_press(HardwareButtons.KEY_RIGHT_PIN)
-
-            if event.keysym in ("1", "KP_1"): self.key_press(HardwareButtons.KEY1_PIN)
-            if event.keysym in ("2", "KP_2"): self.key_press(HardwareButtons.KEY2_PIN)
-            if event.keysym in ("3", "KP_3"): self.key_press(HardwareButtons.KEY3_PIN)
-
-            if event.keysym == "Return": self.key_press(HardwareButtons.KEY_PRESS_PIN)
+            if event.keysym == "Up":
+                self.key_press(HardwareButtons.KEY_UP_PIN)
+            if event.keysym == "Down":
+                self.key_press(HardwareButtons.KEY_DOWN_PIN)
+            if event.keysym == "Left":
+                self.key_press(HardwareButtons.KEY_LEFT_PIN)
+            if event.keysym == "Right":
+                self.key_press(HardwareButtons.KEY_RIGHT_PIN)
+
+            if event.keysym in ("1", "KP_1"):
+                self.key_press(HardwareButtons.KEY1_PIN)
+            if event.keysym in ("2", "KP_2"):
+                self.key_press(HardwareButtons.KEY2_PIN)
+            if event.keysym in ("3", "KP_3"):
+                self.key_press(HardwareButtons.KEY3_PIN)
+
+            if event.keysym == "Return":
+                self.key_press(HardwareButtons.KEY_PRESS_PIN)
 
         self.root.bind("<Key>", key_handler)
 
@@ -96,11 +159,11 @@ def bindButtonClick(self, btn):
         btn.bind("<ButtonRelease>", self.buttonUp)
 
     def buttonDown(self, btn):
-        key = btn.widget.config('command')[-1]
+        key = btn.widget.config("command")[-1]
         self.set_input(key, 0)
 
     def buttonUp(self, btn):
-        key = btn.widget.config('command')[-1]
+        key = btn.widget.config("command")[-1]
         self.set_input(key, 1)
 
     def load_raw_rgb(self, filename):
@@ -113,7 +176,7 @@ def load_raw_rgb(self, filename):
             img_array = img_array.reshape((self.height, self.width, 3))
         except ValueError:
             return None
-        return Image.fromarray(img_array, 'RGB')
+        return Image.fromarray(img_array, "RGB")
 
     def periodic_update(self, filename="display.bmp", interval=10):
         img = self.load_raw_rgb(filename)
@@ -130,7 +193,7 @@ def set_input(self, key, val):
         except Exception:
             pass
 
-    def setup_sock(self, path = 'gpio.sock'):
+    def setup_sock(self, path="gpio.sock"):
         if os.path.exists(path):
             os.remove(path)
 
@@ -145,5 +208,61 @@ def handle_sock(self):
             self.conn, _ = self.server.accept()
 
 
-if __name__ == "__main__":
+def run_gui():
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+
     Display()
+
+
+def run_main():
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+    from main import main
+
+    # Give GUI a moment to start up and create socket
+    time.sleep(0.5)
+
+    main()
+
+
+def signal_handler(sig, frame):
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    # Handle Ctrl+C
+    signal.signal(signal.SIGINT, signal_handler)
+
+    shutdown_event = multiprocessing.Event()
+
+    gui_process = multiprocessing.Process(target=run_gui, name="GUI")
+    main_process = multiprocessing.Process(target=run_main, name="Main")
+
+    try:
+        print("Starting GUI simulator...")
+        gui_process.start()
+
+        print("Starting SeedSigner main application...")
+        main_process.start()
+
+        while gui_process.is_alive() and main_process.is_alive():
+            try:
+                gui_process.join(timeout=0.1)
+                main_process.join(timeout=0.1)
+            except KeyboardInterrupt:
+                break
+
+    except KeyboardInterrupt:
+        pass
+
+    if main_process.is_alive():
+        main_process.terminate()
+        main_process.join(timeout=2)
+        if main_process.is_alive():
+            main_process.kill()
+
+    if gui_process.is_alive():
+        gui_process.terminate()
+        gui_process.join(timeout=2)
+        if gui_process.is_alive():
+            gui_process.kill()
diff --git a/src/seedsigner/extras/dev.py b/src/seedsigner/extras/dev.py
index 9a70d7b94..0fef2f291 100644
--- a/src/seedsigner/extras/dev.py
+++ b/src/seedsigner/extras/dev.py
@@ -1,4 +1,4 @@
 import os
 from typing import Final
 
-DEV_MODE: Final = os.environ.get("LOCAL_DEV")
+DEV_MODE: Final = os.environ.get("LOCAL_DEV") == "true"

From 821dc8077ab2417300c0ef0fbe6ecc7fad1873b5 Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sat, 14 Feb 2026 20:14:44 +0530
Subject: [PATCH 04/10] rename variable

---
 src/seedsigner/controller.py                       | 6 +++---
 src/seedsigner/extras/dev.py                       | 2 +-
 src/seedsigner/hardware/buttons.py                 | 6 +++---
 src/seedsigner/hardware/camera.py                  | 4 ++--
 src/seedsigner/hardware/displays/display_driver.py | 6 +++---
 src/seedsigner/models/decode_qr.py                 | 3 ---
 src/seedsigner/models/encode_qr.py                 | 5 ++---
 7 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/src/seedsigner/controller.py b/src/seedsigner/controller.py
index e548db8ef..d42dee4b5 100644
--- a/src/seedsigner/controller.py
+++ b/src/seedsigner/controller.py
@@ -6,7 +6,7 @@
 from embit.psbt import PSBT
 from PIL.Image import Image
 
-from seedsigner.extras.dev import DEV_MODE
+from seedsigner.extras.dev import SIMULATE_MODE
 from seedsigner.gui.toast import BaseToastOverlayManagerThread
 from seedsigner.models.psbt_parser import PSBTParser
 from seedsigner.models.seed import Seed
@@ -73,7 +73,7 @@ def time_import(module_name):
         Controller.get_instance()._storage = SeedStorage()
 
         time_import('numpy')  # used by PiVideoStream; by far the slowest import (2.29s)
-        if not DEV_MODE:
+        if not SIMULATE_MODE:
             time_import('seedsigner.hardware.pivideostream')
 
         # Get MainMenuView ready to respond quickly
@@ -293,7 +293,7 @@ def run(self):
                 next_destination = Destination(MainMenuView)
             
             # Set up our one-time toast notification tip to remove the SD card
-            if not DEV_MODE:
+            if not SIMULATE_MODE:
                 if self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FIVE_SECONDS:
                     self.activate_toast(RemoveSDCardToastManagerThread())
                 elif self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FOREVER:
diff --git a/src/seedsigner/extras/dev.py b/src/seedsigner/extras/dev.py
index 0fef2f291..d0f227adf 100644
--- a/src/seedsigner/extras/dev.py
+++ b/src/seedsigner/extras/dev.py
@@ -1,4 +1,4 @@
 import os
 from typing import Final
 
-DEV_MODE: Final = os.environ.get("LOCAL_DEV") == "true"
+SIMULATE_MODE: Final = os.environ.get("LOCAL_DEV") == "true"
diff --git a/src/seedsigner/hardware/buttons.py b/src/seedsigner/hardware/buttons.py
index 1b144df3e..187bc3746 100644
--- a/src/seedsigner/hardware/buttons.py
+++ b/src/seedsigner/hardware/buttons.py
@@ -1,8 +1,8 @@
 import logging
 from typing import List
 
-from seedsigner.extras.dev import DEV_MODE
-if DEV_MODE:
+from seedsigner.extras.dev import SIMULATE_MODE
+if SIMULATE_MODE:
     from seedsigner.extras.gpio import GPIO
 else:
     import RPi.GPIO as GPIO
@@ -47,7 +47,7 @@ def get_instance(cls):
             cls._instance = cls.__new__(cls)
 
             #init GPIO
-            if DEV_MODE:
+            if SIMULATE_MODE:
                 GPIO.init()
             GPIO.setmode(GPIO.BOARD)
             GPIO.setup(HardwareButtons.KEY_UP_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)    # Input with pull-up
diff --git a/src/seedsigner/hardware/camera.py b/src/seedsigner/hardware/camera.py
index 7843373f2..4648a090a 100644
--- a/src/seedsigner/hardware/camera.py
+++ b/src/seedsigner/hardware/camera.py
@@ -3,7 +3,7 @@
 from gettext import gettext as _
 from PIL import Image
 
-from seedsigner.extras.dev import DEV_MODE
+from seedsigner.extras.dev import SIMULATE_MODE
 from seedsigner.models.settings import Settings, SettingsConstants
 from seedsigner.models.singleton import Singleton
 
@@ -11,7 +11,7 @@
 class CameraConnectionError(Exception):
     pass
 
-if DEV_MODE:
+if SIMULATE_MODE:
    import seedsigner.extras.local_camera
    Camera = seedsigner.extras.local_camera.Camera
 else:
diff --git a/src/seedsigner/hardware/displays/display_driver.py b/src/seedsigner/hardware/displays/display_driver.py
index 69faa6769..ccf3fe312 100644
--- a/src/seedsigner/hardware/displays/display_driver.py
+++ b/src/seedsigner/hardware/displays/display_driver.py
@@ -1,4 +1,4 @@
-from seedsigner.extras.dev import DEV_MODE
+from seedsigner.extras.dev import SIMULATE_MODE
 
 
 DISPLAY_TYPE__ST7789 = "st7789"
@@ -22,14 +22,14 @@ def __init__(self, display_type: str = DISPLAY_TYPE__ST7789, width: int = None,
                 # TODO: For now the original ST7789 driver has to be used for 240x240.
                 # The mpy version below renders incorrectly (almost like each row of pixels
                 # is one pixel short, so the entire screen exhibits a diagonal skew).
-                if not DEV_MODE:
+                if not SIMULATE_MODE:
                     from seedsigner.hardware.displays.ST7789 import ST7789
                 else:
                     from seedsigner.extras.local_display import ST7789
                 self.display = ST7789()
 
             elif width == 320:
-                if not DEV_MODE:
+                if not SIMULATE_MODE:
                     from seedsigner.hardware.displays.st7789_mpy import ST7789
                 else:
                     from seedsigner.extras.local_display import ST7789
diff --git a/src/seedsigner/models/decode_qr.py b/src/seedsigner/models/decode_qr.py
index c4096cab3..6a2b2d232 100644
--- a/src/seedsigner/models/decode_qr.py
+++ b/src/seedsigner/models/decode_qr.py
@@ -348,9 +348,6 @@ def detect_segment_type(s, wordlist_language_code=None):
             if re.search("^UR:CRYPTO-PSBT/", s, re.IGNORECASE):
                 return QRType.PSBT__UR2
 
-            elif re.search("^UR:PSBT/", s, re.IGNORECASE):
-                return QRType.PSBT__UR2
-
             elif re.search("^UR:CRYPTO-OUTPUT/", s, re.IGNORECASE):
                 return QRType.OUTPUT__UR
 
diff --git a/src/seedsigner/models/encode_qr.py b/src/seedsigner/models/encode_qr.py
index 32d03157f..86be8c66d 100644
--- a/src/seedsigner/models/encode_qr.py
+++ b/src/seedsigner/models/encode_qr.py
@@ -311,8 +311,7 @@ def seq_len(self):
 
 
     def next_part(self) -> str:
-        if self.is_complete: self.restart()
-        return self.ur2_encode.next_part()
+        return self.ur2_encode.next_part().upper()
 
 
     def cur_part(self) -> str:
@@ -403,5 +402,5 @@ class UrPsbtQrEncoder(BaseFountainQrEncoder):
 
     def __post_init__(self):
         super().__post_init__()
-        qr_ur_bytes = UR("psbt", UR_PSBT(self.psbt.serialize()).to_cbor())
+        qr_ur_bytes = UR("crypto-psbt", UR_PSBT(self.psbt.serialize()).to_cbor())
         self.ur2_encode = UREncoder(ur=qr_ur_bytes, max_fragment_len=self.qr_max_fragment_size)

From 9b44829f64ed0cfefa3b14e28485bf1cc03c5f99 Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sun, 15 Feb 2026 22:10:37 +0530
Subject: [PATCH 05/10] restore file formatting

---
 src/seedsigner/gui/components.py     | 219 +++++++++++++++------------
 src/seedsigner/models/psbt_parser.py |   2 +-
 2 files changed, 124 insertions(+), 97 deletions(-)

diff --git a/src/seedsigner/gui/components.py b/src/seedsigner/gui/components.py
index 565be8de3..d9a2e0b4d 100644
--- a/src/seedsigner/gui/components.py
+++ b/src/seedsigner/gui/components.py
@@ -35,7 +35,7 @@ class GUIConstants:
     ERROR_COLOR = "#FF1B0A"
     SUCCESS_COLOR = "#30D158"
     INFO_COLOR = "#409CFF"
-    # BITCOIN_ORANGE = "#FF9416"  # not used
+    BITCOIN_ORANGE = "#FF9416"
     TESTNET_COLOR = "#00F100"
     REGTEST_COLOR = "#00CAF1"
     GREEN_INDICATOR_COLOR = "#00FF00"
@@ -52,7 +52,7 @@ class GUIConstants:
         "default": "OpenSans-Regular",
         SettingsConstants.LOCALE__ARABIC: "NotoSansAR-Regular",
         SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: "NotoSansSC-Regular",
-        SettingsConstants.LOCALE__HINDI: "NotoSansDevanagari-Regular",
+        # SettingsConstants.LOCALE__CHINESE_TRADITIONAL: "NotoSansTC-Regular",
         SettingsConstants.LOCALE__JAPANESE: "NotoSansJP-Regular",
         SettingsConstants.LOCALE__KOREAN: "NotoSansKR-Regular",
         SettingsConstants.LOCALE__PERSIAN: "NotoSansAR-Regular",  # Uses the Arabic font
@@ -63,10 +63,9 @@ class GUIConstants:
     TOP_NAV_TITLE_FONT_NAME["default"] = "OpenSans-SemiBold"
     TOP_NAV_TITLE_FONT_SIZE = {
         "default": 20,
-        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 23,  # Some chars won't render below 23px
-        SettingsConstants.LOCALE__HINDI: 22,
         SettingsConstants.LOCALE__JAPANESE: 22,  # Titles won't render below 22px
         SettingsConstants.LOCALE__KOREAN: 23,    # Titles won't render below 23px
+        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 23,  # Some chars won't render below 23px
     }
     TOP_NAV_HEIGHT = 48
     TOP_NAV_BUTTON_SIZE = 32
@@ -74,10 +73,9 @@ class GUIConstants:
     BODY_FONT_NAME = BASE_LOCALE_FONTS.copy()
     BODY_FONT_SIZE = {
         "default": 17,
-        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 18,
-        SettingsConstants.LOCALE__HINDI: 18,
         SettingsConstants.LOCALE__JAPANESE: 18,
         SettingsConstants.LOCALE__KOREAN: 18,
+        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 18,
     }
     BODY_FONT_MAX_SIZE = TOP_NAV_TITLE_FONT_SIZE["default"]
     BODY_FONT_MIN_SIZE = 15
@@ -87,7 +85,6 @@ class GUIConstants:
     FIXED_WIDTH_FONT_NAME = "Inconsolata-Regular"
     FIXED_WIDTH_EMPHASIS_FONT_NAME = "Inconsolata-SemiBold"
 
-    # TODO: this should have a get_label_font_size() method like the others for l10n
     LABEL_FONT_SIZE = BODY_FONT_MIN_SIZE
     LABEL_FONT_COLOR = "#777777"
 
@@ -97,7 +94,6 @@ class GUIConstants:
         "default": 18,
         "ar": 18,
         "fa": 18,
-        SettingsConstants.LOCALE__HINDI: 20,
         SettingsConstants.LOCALE__JAPANESE: 20,
         SettingsConstants.LOCALE__KOREAN: 20,
         SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 20,
@@ -171,9 +167,14 @@ def get_button_font_size(locale=None):
 
 class FontAwesomeIconConstants:
     ANGLE_DOWN = "\uf107"
+    ANGLE_LEFT = "\uf104"
+    ANGLE_RIGHT = "\uf105"
     ANGLE_UP = "\uf106"
     CAMERA = "\uf030"
+    CHEVRON_UP = "\uf077"
+    CHEVRON_DOWN = "\uf078"
     CIRCLE = "\uf111"
+    CIRCLE_CHEVRON_RIGHT = "\uf138"
     DICE = "\uf522"
     DICE_ONE = "\uf525"
     DICE_TWO = "\uf528"
@@ -182,7 +183,15 @@ class FontAwesomeIconConstants:
     DICE_FIVE = "\uf523"
     DICE_SIX = "\uf526"
     KEYBOARD = "\uf11c"
+    LOCK = "\uf023"
     MAP = "\uf279"
+    PAPER_PLANE = "\uf1d8"
+    PEN = "\uf304"
+    SQUARE_CARET_DOWN = "\uf150"
+    SQUARE_CARET_LEFT = "\uf191"
+    SQUARE_CARET_RIGHT = "\uf152"
+    SQUARE_CARET_UP = "\uf151"
+    UNLOCK = "\uf09c"
     X = "\u0058"
 
 
@@ -203,9 +212,9 @@ class SeedSignerIconConstants:
     CHEVRON_LEFT = "\ue909"
     CHEVRON_RIGHT = "\ue90a"
     CHEVRON_UP = "\ue90b"
-    # CLOSE = "\ue90c"  # Unused icons
-    # PAGE_DOWN = "\ue90d"
-    # PAGE_UP = "\ue90e"
+    CLOSE = "\ue90c"
+    PAGE_DOWN = "\ue90d"
+    PAGE_UP = "\ue90e"
     PLUS = "\ue90f"
     POWER = "\ue910"
     RESTART = "\ue911"
@@ -217,17 +226,17 @@ class SeedSignerIconConstants:
     ERROR = "\ue915"
 
     # Informational icons
-    # ADDRESS = "\ue916"
+    ADDRESS = "\ue916"
     CHANGE = "\ue917"
     DERIVATION = "\ue918"
-    # FEE = "\ue919"
+    FEE = "\ue919"
     FINGERPRINT = "\ue91a"
     PASSPHRASE = "\ue91b"
 
     # Misc icons
-    # BITCOIN = "\ue91c"
+    BITCOIN = "\ue91c"
     BITCOIN_ALT = "\ue91d"
-    # BRIGHTNESS = "\ue91e"
+    BRIGHTNESS = "\ue91e"
     MICROSD = "\ue91f"
     QRCODE = "\ue920"
     SIGN = "\ue921"
@@ -242,6 +251,40 @@ class SeedSignerIconConstants:
 
 
 
+def calc_text_centering(font: ImageFont,
+                        text: str,
+                        is_text_centered: bool,
+                        total_width: int,
+                        total_height: int,
+                        start_x: int = 0,
+                        start_y: int = 0) -> Tuple[int, int]:
+    # see: https://pillow.readthedocs.io/en/stable/handbook/text-anchors.html#text-anchors
+
+    # Gap between the starting coordinate and the first marking.
+    offset_x, offset_y = font.getoffset(text)
+
+    # Bounding box of the actual pixels rendered.
+    (box_left, box_top, box_right, box_bottom) = font.getbbox(text, anchor='lt')
+
+    # Ascender/descender are oversized ranges baked into the font.
+    ascent, descent = font.getmetrics()
+
+    # print(f"""----- "{text}" / {font.getname()} -----""")
+    # print(f"offset_x: {offset_x} | offset_y: {offset_y})")
+    # print(f"box_left: {box_left} |  box_top: {box_top} | box_right: {box_right} | box_bottom: {box_bottom}")
+    # print(f"ascent: {ascent} | descent: {descent})")
+
+    if is_text_centered:
+        text_x = int((total_width - (box_right - offset_x)) / 2) - offset_x
+    else:
+        text_x = GUIConstants.COMPONENT_PADDING
+
+    text_y = int((total_height - (ascent - offset_y)) / 2) - offset_y
+
+    return (start_x + text_x, start_y + text_y)
+
+
+
 def load_image(image_name: str) -> Image.Image:
     image_url = os.path.join(pathlib.Path(__file__).parent.resolve(), "..", "resources", "img", image_name)
     image = Image.open(image_url).convert("RGB")
@@ -347,6 +390,7 @@ class TextArea(BaseComponent):
     is_text_centered: bool = True
     supersampling_factor: int = 2  # 1 = disabled; 2 = default, double sample (4px square rendered for 1px)
     auto_line_break: bool = True
+    allow_text_overflow: bool = False
     is_horizontal_scrolling_enabled: bool = False
     horizontal_scroll_speed: int = 40  # px per sec
     horizontal_scroll_begin_hold_secs: float = 2.0
@@ -358,6 +402,10 @@ def __post_init__(self):
         if self.is_horizontal_scrolling_enabled and self.auto_line_break:
             raise Exception("TextArea: Cannot have auto_line_break and horizontal scrolling enabled at the same time")
 
+        if self.is_horizontal_scrolling_enabled and not self.allow_text_overflow:
+            self.allow_text_overflow = True
+            logger.warning("TextArea: allow_text_overflow gets overridden to True when horizontal scrolling is enabled")
+
         if not self.font_name:
             self.font_name = GUIConstants.get_body_font_name()
         if not self.font_size:
@@ -392,13 +440,7 @@ def __post_init__(self):
             # Guaranteed to be a single line of text, possibly wider than self.width
             self.text_lines = [{"text": self.text, "text_width": full_text_width}]
             self.text_width = full_text_width
-
-            # Technically, the math says that we should enable scrolling for as little as
-            # 1px beyond the available width, but it's not worth having the text twitch
-            # back and forth by such a small amount.
-            min_scrollable_diff = 1
-
-            if self.text_width > self.visible_width + min_scrollable_diff:
+            if self.text_width > self.visible_width:
                 # We'll have to left justify the text and scroll it (if scrolling is enabled,
                 # otherwise it'll just run off the right edge).
                 self.is_text_centered = False
@@ -416,6 +458,7 @@ def __post_init__(self):
                 width=self.width - 2*self.edge_padding,
                 font_name=self.font_name,
                 font_size=self.font_size,
+                allow_text_overflow=self.allow_text_overflow,
             )
 
             # Other components, like IconTextLine will need to know how wide the actual
@@ -442,9 +485,14 @@ def __post_init__(self):
 
         else:
             if total_text_height > self.height:
-                # Let it render past the bottom edge. Will be up to the dev or translator
-                # to review the screenshot and revise the text as needed.
-                logger.warning(f"Text cannot fit in target rect with this font/size\n\ttotal_text_height: {total_text_height} | self.height: {self.height}")
+                if not self.allow_text_overflow:
+                    # For now, early into the l10n rollout, we can't enforce strict
+                    # conformance here. Too many screens will just break if this is were
+                    # to raise an exception.
+                    logger.warning(f"Text cannot fit in target rect with this font/size\n\ttotal_text_height: {total_text_height} | self.height: {self.height}")
+                else:
+                    # Just let it render past the bottom edge
+                    pass
 
             else:
                 # Vertically center the text's starting point
@@ -575,7 +623,7 @@ def __init__(self, rendered_text_img: Image, screen_x: int, screen_y: int, visib
             self.horizontal_scroll_position = 0
             self.scroll_increment_sign = 1  # flip to negative to scroll text to the right
 
-            self.renderer = Renderer.get_instance()
+            self.renderer = Renderer.get_instance()        
 
 
         def stop_scrolling(self):
@@ -596,57 +644,45 @@ def run(self):
             readability. 45px/sec is better but still perceptually a bit stuttery.
             """
             max_scroll = self.rendered_text_img.width - self.visible_width
-            last_render_time = None
-
-            # The scrolling pauses at the start and end of the text line. These vars track
-            # when we started holding and how long we should hold for.
-            hold_started_at = None
-            cur_hold_duration = None
 
             while self.keep_running:
                 if not self.scrolling_active:
                     time.sleep(0.1)
                     continue
 
-                if cur_hold_duration is not None:
-                    # We're currently holding; see if we've held long enough
-                    hold_time_elapsed = time.time() - hold_started_at
-                    if hold_time_elapsed < cur_hold_duration:
-                        # Still have to hold longer; skip scrolling logic
-                        time.sleep(0.1)
+                with self.renderer.lock:
+                    if not self.scrolling_active:
+                        # We were stopped while waiting for the lock
                         continue
-                    else:
-                        # We've held long enough; reset the vars and resume scrolling
-                        hold_started_at = None
-                        cur_hold_duration = None
 
-                else:
-                    # We're not holding, but if we've reached either end, we need to start
-                    # holding.
-                    if self.horizontal_scroll_position == 0:
-                        # Pause on initial (left-justified) position...
-                        hold_started_at = time.time()
-                        cur_hold_duration = self.begin_hold_secs
-
-                        # Next scroll direction will be left
-                        self.scroll_increment_sign = 1
-
-                        # Don't count those pause seconds
-                        last_render_time = None
-                        continue
+                    img = self.rendered_text_img.crop((self.horizontal_scroll_position, 0, self.horizontal_scroll_position + self.visible_width, self.rendered_text_img.height))
+                    self.renderer.canvas.paste(img, (self.screen_x, self.screen_y - self.scroll_y))
+                    self.renderer.show_image()
 
-                    elif self.horizontal_scroll_position == max_scroll:
-                        # ...and slight pause at end of scroll
-                        hold_started_at = time.time()
-                        cur_hold_duration = self.end_hold_secs
+                if self.horizontal_scroll_position == 0:
+                    # Pause on initial (left-justified) position...                
+                    time.sleep(self.begin_hold_secs)
 
-                        # Don't count those pause seconds
-                        last_render_time = None
+                    # Don't count those pause seconds
+                    last_render_time = None
 
-                        # Scroll will be to the right
-                        self.scroll_increment_sign = -1
-                        continue
+                    # Scroll the text left
+                    self.scroll_increment_sign = 1
 
+                elif self.horizontal_scroll_position == max_scroll:
+                    # ...and slight pause at end of scroll
+                    time.sleep(self.end_hold_secs)
+
+                    # Don't count those pause seconds
+                    last_render_time = None
+
+                    # Scroll the text right
+                    self.scroll_increment_sign = -1
+                
+                else:
+                    # No need to CPU limit when running in its own thread?
+                    time.sleep(0.02)
+                
                 next_render_time = time.time()
 
                 if not last_render_time:
@@ -654,39 +690,18 @@ def run(self):
                     # "get off zero" for the real increment calc logic to kick in.
                     scroll_position_increment = 1 * self.scroll_increment_sign
                 else:
-                    # Calculate how far to scroll based on time elapsed since last render
                     scroll_position_increment = int(self.horizontal_scroll_speed * (next_render_time - last_render_time) * self.scroll_increment_sign)
 
-                # Only render an update if we're going to move at least 1px
                 if abs(scroll_position_increment) > 0:
-                    # max: Don't over-scroll when returning to the left edge (0)
-                    # min: Don't over-scroll when revealing the right edge (max_scroll)
-                    self.horizontal_scroll_position = max(
-                        0,
-                        min(self.horizontal_scroll_position + scroll_position_increment, max_scroll)
-                    )
-
-                    # Render the scroll update
-                    with self.renderer.lock:
-                        if not self.scrolling_active:
-                            # We were stopped while waiting for the lock
-                            continue
-
-                        # The pre-rendered text img slides within a cropping window
-                        img = self.rendered_text_img.crop((self.horizontal_scroll_position, 0, self.horizontal_scroll_position + self.visible_width, self.rendered_text_img.height))
-                        self.renderer.canvas.paste(img, (self.screen_x, self.screen_y - self.scroll_y))
-                        self.renderer.show_image()
+                    self.horizontal_scroll_position += scroll_position_increment
+                    self.horizontal_scroll_position = max(0, min(self.horizontal_scroll_position, max_scroll))
 
                     last_render_time = next_render_time
-
                 else:
-                    # Wait to accumulate more time so we can scroll at least 1px
+                    # Wait to accumulate more time before scrolling
                     pass
 
-                # Free up the processor for a bit each loop
-                time.sleep(0.02)
 
- 
     def render(self):
         """
             Even if we need to animate for scrolling, all instances should explicitly render
@@ -726,6 +741,7 @@ class ScrollableTextLine(TextArea):
     def __post_init__(self):
         self.auto_line_break = False
         self.is_horizontal_scrolling_enabled = True
+        self.allow_text_overflow = True
         super().__post_init__()
 
 
@@ -787,6 +803,7 @@ class IconTextLine(BaseComponent):
     font_size: int = None
     is_text_centered: bool = False
     auto_line_break: bool = False
+    allow_text_overflow: bool = True
     screen_x: int = 0
     screen_y: int = 0
 
@@ -829,6 +846,7 @@ def __post_init__(self):
                 auto_line_break=False,
                 screen_x=text_screen_x,
                 screen_y=self.screen_y,
+                allow_text_overflow=False,
             )
         else:
             self.label_textarea = None        
@@ -848,6 +866,7 @@ def __post_init__(self):
             edge_padding=0,
             is_text_centered=self.is_text_centered if not self.icon_name else False,
             auto_line_break=self.auto_line_break,
+            allow_text_overflow=self.allow_text_overflow,
             screen_x=text_screen_x,
             screen_y=value_textarea_screen_y,
         )
@@ -1079,6 +1098,7 @@ class BtcAmount(BaseComponent):
 
     def __post_init__(self):
         super().__post_init__()
+        self.sub_components: List[BaseComponent] = []
         self.paste_image: Image.Image = None
         self.paste_coords = None
         denomination = Settings.get_instance().get_value(SettingsConstants.SETTING__BTC_DENOMINATION)
@@ -1496,6 +1516,7 @@ def __post_init__(self):
             button_kwargs["text"] = self.text
             button_kwargs["font_color"] = self.font_color
             button_kwargs["background_color"] = self.background_color
+            button_kwargs["allow_text_overflow"] = True
             button_kwargs["auto_line_break"] = False
             del button_kwargs["horizontal_scroll_begin_hold_secs"]
             del button_kwargs["horizontal_scroll_end_hold_secs"]
@@ -1800,7 +1821,8 @@ def calc_bezier_curve(p1: Tuple[int,int], p2: Tuple[int,int], p3: Tuple[int,int]
 def reflow_text_for_width(text: str,
                           width: int,
                           font_name=GUIConstants.get_body_font_name(),
-                          font_size=GUIConstants.get_body_font_size()) -> list[dict]:
+                          font_size=GUIConstants.get_body_font_size(),
+                          allow_text_overflow: bool=False) -> list[dict]:
     """
     Reflows text to fit within `width` by breaking long lines up.
 
@@ -1823,6 +1845,9 @@ def reflow_text_for_width(text: str,
         SettingsConstants.LOCALE__JAPANESE,
         SettingsConstants.LOCALE__KOREAN,
     ]
+    if treat_chars_as_words:
+        # Relax UI constraints even if the result isn't optimal
+        allow_text_overflow = True
 
     # Stores each line of text and its rendering starting x-coord
     text_lines = []
@@ -1866,9 +1891,9 @@ def _binary_len_search(min_index, max_index, word_spacer):
                 # Candidate line is possibly shorter than necessary.
                 return _binary_len_search(min_index=index, max_index=max_index, word_spacer=word_spacer)
 
-        if len(text.split()) == 1 and not treat_chars_as_words:
-            # No whitespace chars to split on! Warn but proceed anyway.
-            logger.warning("Text cannot fit in target rect with this font+size")
+        if len(text.split()) == 1 and not allow_text_overflow and not treat_chars_as_words:
+            # No whitespace chars to split on!
+            raise TextDoesNotFitException("Text cannot fit in target rect with this font+size")
 
         # Now we're ready to go line-by-line into our line break binary search!
         for line in text.split("\n"):
@@ -1908,7 +1933,8 @@ def reflow_text_into_pages(text: str,
                            height: int,
                            font_name=GUIConstants.get_body_font_name(),
                            font_size=GUIConstants.get_body_font_size(),
-                           line_spacer: int = GUIConstants.BODY_LINE_SPACING) -> list[str]:
+                           line_spacer: int = GUIConstants.BODY_LINE_SPACING,
+                           allow_text_overflow: bool=False) -> list[str]:
     """
     Invokes `reflow_text_for_width` above to convert long text into width-limited
     individual text lines and then calculates how many lines will fit on a "page" and
@@ -1919,7 +1945,8 @@ def reflow_text_into_pages(text: str,
     reflowed_lines_dicts = reflow_text_for_width(text=text,
                                            width=width,
                                            font_name=font_name,
-                                           font_size=font_size)
+                                           font_size=font_size,
+                                           allow_text_overflow=allow_text_overflow)
 
     lines = []
     for line_dict in reflowed_lines_dicts:
@@ -1989,4 +2016,4 @@ def resize_image_to_fill(img: Image, target_size_x: int, target_size_y: int, sam
         (target_size_x, target_size_y),
         resample=sampling_method,
         box=box,
-    )
+    )
\ No newline at end of file
diff --git a/src/seedsigner/models/psbt_parser.py b/src/seedsigner/models/psbt_parser.py
index 30c1e65f3..6f1260998 100644
--- a/src/seedsigner/models/psbt_parser.py
+++ b/src/seedsigner/models/psbt_parser.py
@@ -470,4 +470,4 @@ def _get_updated_fingerprint(public_key: PublicKey, derivation_path_obj: Derivat
             _fill_scope(inp)
 
         for out in self.psbt.outputs:
-            _fill_scope(out)
+            _fill_scope(out)
\ No newline at end of file

From 124e8d02bdb7c1d89a0c306a11afbaa480598b2b Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sun, 15 Feb 2026 22:48:36 +0530
Subject: [PATCH 06/10] restore

restore
---
 src/seedsigner/controller.py                  |  13 +-
 src/seedsigner/extras/dev.py                  |   4 -
 src/seedsigner/extras/gpio.py                 |  49 ----
 src/seedsigner/extras/local_camera.py         | 164 -------------
 src/seedsigner/extras/local_display.py        |  11 -
 src/seedsigner/gui/components.py              | 217 +++++++---------
 src/seedsigner/gui/renderer.py                |   1 +
 src/seedsigner/hardware/buttons.py            |  10 +-
 src/seedsigner/hardware/camera.py             | 177 +++++++-------
 .../hardware/displays/display_driver.py       |  15 +-
 src/gui.py => tools/run_emulator.py           | 231 +++++++++++++++---
 11 files changed, 393 insertions(+), 499 deletions(-)
 delete mode 100644 src/seedsigner/extras/dev.py
 delete mode 100644 src/seedsigner/extras/gpio.py
 delete mode 100644 src/seedsigner/extras/local_camera.py
 delete mode 100644 src/seedsigner/extras/local_display.py
 rename src/gui.py => tools/run_emulator.py (50%)

diff --git a/src/seedsigner/controller.py b/src/seedsigner/controller.py
index d42dee4b5..5b3f22e8d 100644
--- a/src/seedsigner/controller.py
+++ b/src/seedsigner/controller.py
@@ -6,7 +6,6 @@
 from embit.psbt import PSBT
 from PIL.Image import Image
 
-from seedsigner.extras.dev import SIMULATE_MODE
 from seedsigner.gui.toast import BaseToastOverlayManagerThread
 from seedsigner.models.psbt_parser import PSBTParser
 from seedsigner.models.seed import Seed
@@ -73,8 +72,7 @@ def time_import(module_name):
         Controller.get_instance()._storage = SeedStorage()
 
         time_import('numpy')  # used by PiVideoStream; by far the slowest import (2.29s)
-        if not SIMULATE_MODE:
-            time_import('seedsigner.hardware.pivideostream')
+        time_import('seedsigner.hardware.pivideostream') 
 
         # Get MainMenuView ready to respond quickly
         time_import('seedsigner.views.scan_views')
@@ -293,11 +291,10 @@ def run(self):
                 next_destination = Destination(MainMenuView)
             
             # Set up our one-time toast notification tip to remove the SD card
-            if not SIMULATE_MODE:
-                if self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FIVE_SECONDS:
-                    self.activate_toast(RemoveSDCardToastManagerThread())
-                elif self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FOREVER:
-                    next_destination = Destination(RemoveMicroSDWarningView)
+            if self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FIVE_SECONDS:
+                self.activate_toast(RemoveSDCardToastManagerThread())
+            elif self.settings.get_value(SettingsConstants.SETTING__MICROSD_TOAST_TIMER) == SettingsConstants.MICROSD_TOAST_TIMER_FOREVER:
+                next_destination = Destination(RemoveMicroSDWarningView)
 
             while True:
                 # Destination(None) is a special case; render the Home screen
diff --git a/src/seedsigner/extras/dev.py b/src/seedsigner/extras/dev.py
deleted file mode 100644
index d0f227adf..000000000
--- a/src/seedsigner/extras/dev.py
+++ /dev/null
@@ -1,4 +0,0 @@
-import os
-from typing import Final
-
-SIMULATE_MODE: Final = os.environ.get("LOCAL_DEV") == "true"
diff --git a/src/seedsigner/extras/gpio.py b/src/seedsigner/extras/gpio.py
deleted file mode 100644
index bb71ed055..000000000
--- a/src/seedsigner/extras/gpio.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import socket
-import threading
-from typing import Final
-
-class _GPIO:
-    LOW: Final = 0
-    HIGH: Final = 1
-
-    # Fake constants
-    BOARD: Final = 10
-    IN: Final = 1
-    PUD_UP: Final = 22
-    RPI_INFO: Final = {"P1_REVISION": 3}
-
-    def setmode(self, a: int):
-        pass
-
-    def setup(self, a: int, b: int, *,  pull_up_down: int):
-        pass
-
-    def init(self, socket_path="gpio.sock"):
-        self._states = {}
-        self.lock = threading.Lock()
-        self.socket_path = socket_path
-
-        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.sock.connect(self.socket_path)
-
-        threading.Thread(target=self._read_loop, daemon=True).start()
-
-    def _read_loop(self):
-        f = self.sock.makefile("r")
-        while True:
-            line = f.readline()
-            if not line:
-                break
-            try:
-                pin, val = line.strip().split()
-                with self.lock:
-                    self._states[int(pin)] = int(val)
-            except Exception:
-                pass
-
-    def input(self, pin):
-        with self.lock:
-            return self._states.get(pin, self.HIGH)
-
-
-GPIO = _GPIO()
diff --git a/src/seedsigner/extras/local_camera.py b/src/seedsigner/extras/local_camera.py
deleted file mode 100644
index 5254f9c65..000000000
--- a/src/seedsigner/extras/local_camera.py
+++ /dev/null
@@ -1,164 +0,0 @@
-from PIL import Image
-
-from seedsigner.models.settings import Settings, SettingsConstants
-from seedsigner.models.singleton import Singleton
-
-from threading import Thread
-import time
-import cv2
-import numpy as np
-
-
-class Camera(Singleton):
-    _video_stream = None
-    _picamera = None
-    _camera_rotation = None
-
-    @classmethod
-    def get_instance(cls):
-        # This is the only way to access the one and only Controller
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-        cls._instance._camera_rotation = int( Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
-        cls._instance._camera_rotation += 90
-        return cls._instance
-
-    def start_video_stream_mode(
-        self, resolution=(512, 384), framerate=12, format="bgr"
-    ):
-        if self._video_stream is not None:
-            self.stop_video_stream_mode()
-
-        try:
-            self._video_stream = WebcamVideoStream(
-                resolution=resolution, framerate=framerate, format=format
-            )
-            self._video_stream.start()
-        except Exception as e:
-            raise e
-
-    def read_video_stream(self, as_image=False):
-        if not self._video_stream:
-            raise Exception("Must call start_video_stream first.")
-        frame = self._video_stream.read()
-        if not as_image:
-            return frame
-        else:
-            if frame is not None:
-                return Image.fromarray(frame.astype("uint8"), "RGB").rotate(
-                    90 + self._camera_rotation
-                )
-        return None
-
-    def stop_video_stream_mode(self):
-        if self._video_stream is not None:
-            self._video_stream.stop()
-            self._video_stream = None
-
-    def start_single_frame_mode(self, resolution=(720, 480)):
-        if self._video_stream is not None:
-            self.stop_video_stream_mode()
-        if self._picamera is not None:
-            self._picamera.close()
-
-    def capture_frame(self):
-        frame = WebcamVideoStream.single_frame()
-        return Image.fromarray(frame).rotate(90 + self._camera_rotation)
-
-    def stop_single_frame_mode(self):
-        if self._picamera is not None:
-            self._picamera.close()
-            self._picamera = None
-
-
-def resize_and_center_crop_240(frame_bgr: np.ndarray) -> np.ndarray:
-    target = 240
-    h, w = frame_bgr.shape[:2]
-
-    # resize to 240
-    if w < h:
-        scale = target / w
-    else:
-        scale = target / h
-
-    new_w = int(w * scale)
-    new_h = int(h * scale)
-
-    resized = cv2.resize(frame_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
-
-    # center crop
-    x1 = (new_w - target) // 2
-    y1 = (new_h - target) // 2
-
-    cropped = resized[y1 : y1 + target, x1 : x1 + target]
-
-    return cropped
-
-
-class WebcamVideoStream:
-    def __init__(self, resolution=(320, 240), framerate=32, format="bgr", **kwargs):
-        # initialize the camera
-        self.camera = cv2.VideoCapture(0)
-        self.set_resolution(resolution)
-
-        # initialize the frame and the variable used to indicate
-        # if the thread should be stopped
-        self.frame = None
-        self.should_stop = False
-        self.is_stopped = True
-
-    def start(self):
-        # start the thread to read frames from the video stream
-        t = Thread(target=self.update, args=())
-        t.daemon = True
-        t.start()
-        self.is_stopped = False
-        return self
-
-    def update(self):
-        if self.camera.isOpened():
-            # keep looping infinitely until the thread is stopped
-            while not self.should_stop:
-                # grab the frame from the stream and clear the stream in
-                # preparation for the next frame
-                ret, stream = self.camera.read()
-                stream = cv2.resize(stream, (240, 240))
-                stream = cv2.cvtColor(stream, cv2.COLOR_BGR2RGB)
-                time.sleep(0.05)
-                self.frame = stream
-        self.is_stopped = True
-        self.should_stop = False
-
-    def read(self):
-        return self.frame
-
-    def stop(self):
-        # indicate that the thread should be stopped
-        self.should_stop = True
-
-        # Block in this thread until stopped
-        while not self.is_stopped:
-            pass
-
-    def set_resolution(self, resolution):
-        self.camera.set(3, resolution[0])
-        self.camera.set(4, resolution[1])
-
-    @staticmethod
-    def single_frame():
-        cap = cv2.VideoCapture(0)
-
-        # Warm-up, let auto-exposure settle in
-        for _ in range(30):
-            cap.read()
-            time.sleep(0.01)
-
-        ret, frame = cap.read()
-        cap.release()
-
-        if not ret:
-            raise RuntimeError("Camera capture failed")
-
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        frame = resize_and_center_crop_240(frame)
-        return frame
diff --git a/src/seedsigner/extras/local_display.py b/src/seedsigner/extras/local_display.py
deleted file mode 100644
index 7f68af289..000000000
--- a/src/seedsigner/extras/local_display.py
+++ /dev/null
@@ -1,11 +0,0 @@
-class ST7789:
-    def __init__(self, width = 240, height = 240):
-        self.width = width
-        self.height = height
-
-    def show_image(self, image, x, y):
-        with open('display.bmp', 'wb') as f:
-            f.write(image.tobytes())
-
-    def invert(self, enabled: bool = True):
-        pass
diff --git a/src/seedsigner/gui/components.py b/src/seedsigner/gui/components.py
index d9a2e0b4d..9c82c17d7 100644
--- a/src/seedsigner/gui/components.py
+++ b/src/seedsigner/gui/components.py
@@ -35,7 +35,7 @@ class GUIConstants:
     ERROR_COLOR = "#FF1B0A"
     SUCCESS_COLOR = "#30D158"
     INFO_COLOR = "#409CFF"
-    BITCOIN_ORANGE = "#FF9416"
+    # BITCOIN_ORANGE = "#FF9416"  # not used
     TESTNET_COLOR = "#00F100"
     REGTEST_COLOR = "#00CAF1"
     GREEN_INDICATOR_COLOR = "#00FF00"
@@ -52,7 +52,7 @@ class GUIConstants:
         "default": "OpenSans-Regular",
         SettingsConstants.LOCALE__ARABIC: "NotoSansAR-Regular",
         SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: "NotoSansSC-Regular",
-        # SettingsConstants.LOCALE__CHINESE_TRADITIONAL: "NotoSansTC-Regular",
+        SettingsConstants.LOCALE__HINDI: "NotoSansDevanagari-Regular",
         SettingsConstants.LOCALE__JAPANESE: "NotoSansJP-Regular",
         SettingsConstants.LOCALE__KOREAN: "NotoSansKR-Regular",
         SettingsConstants.LOCALE__PERSIAN: "NotoSansAR-Regular",  # Uses the Arabic font
@@ -63,9 +63,10 @@ class GUIConstants:
     TOP_NAV_TITLE_FONT_NAME["default"] = "OpenSans-SemiBold"
     TOP_NAV_TITLE_FONT_SIZE = {
         "default": 20,
+        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 23,  # Some chars won't render below 23px
+        SettingsConstants.LOCALE__HINDI: 22,
         SettingsConstants.LOCALE__JAPANESE: 22,  # Titles won't render below 22px
         SettingsConstants.LOCALE__KOREAN: 23,    # Titles won't render below 23px
-        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 23,  # Some chars won't render below 23px
     }
     TOP_NAV_HEIGHT = 48
     TOP_NAV_BUTTON_SIZE = 32
@@ -73,9 +74,10 @@ class GUIConstants:
     BODY_FONT_NAME = BASE_LOCALE_FONTS.copy()
     BODY_FONT_SIZE = {
         "default": 17,
+        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 18,
+        SettingsConstants.LOCALE__HINDI: 18,
         SettingsConstants.LOCALE__JAPANESE: 18,
         SettingsConstants.LOCALE__KOREAN: 18,
-        SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 18,
     }
     BODY_FONT_MAX_SIZE = TOP_NAV_TITLE_FONT_SIZE["default"]
     BODY_FONT_MIN_SIZE = 15
@@ -85,6 +87,7 @@ class GUIConstants:
     FIXED_WIDTH_FONT_NAME = "Inconsolata-Regular"
     FIXED_WIDTH_EMPHASIS_FONT_NAME = "Inconsolata-SemiBold"
 
+    # TODO: this should have a get_label_font_size() method like the others for l10n
     LABEL_FONT_SIZE = BODY_FONT_MIN_SIZE
     LABEL_FONT_COLOR = "#777777"
 
@@ -94,6 +97,7 @@ class GUIConstants:
         "default": 18,
         "ar": 18,
         "fa": 18,
+        SettingsConstants.LOCALE__HINDI: 20,
         SettingsConstants.LOCALE__JAPANESE: 20,
         SettingsConstants.LOCALE__KOREAN: 20,
         SettingsConstants.LOCALE__CHINESE_SIMPLIFIED: 20,
@@ -167,14 +171,9 @@ def get_button_font_size(locale=None):
 
 class FontAwesomeIconConstants:
     ANGLE_DOWN = "\uf107"
-    ANGLE_LEFT = "\uf104"
-    ANGLE_RIGHT = "\uf105"
     ANGLE_UP = "\uf106"
     CAMERA = "\uf030"
-    CHEVRON_UP = "\uf077"
-    CHEVRON_DOWN = "\uf078"
     CIRCLE = "\uf111"
-    CIRCLE_CHEVRON_RIGHT = "\uf138"
     DICE = "\uf522"
     DICE_ONE = "\uf525"
     DICE_TWO = "\uf528"
@@ -183,15 +182,7 @@ class FontAwesomeIconConstants:
     DICE_FIVE = "\uf523"
     DICE_SIX = "\uf526"
     KEYBOARD = "\uf11c"
-    LOCK = "\uf023"
     MAP = "\uf279"
-    PAPER_PLANE = "\uf1d8"
-    PEN = "\uf304"
-    SQUARE_CARET_DOWN = "\uf150"
-    SQUARE_CARET_LEFT = "\uf191"
-    SQUARE_CARET_RIGHT = "\uf152"
-    SQUARE_CARET_UP = "\uf151"
-    UNLOCK = "\uf09c"
     X = "\u0058"
 
 
@@ -212,9 +203,9 @@ class SeedSignerIconConstants:
     CHEVRON_LEFT = "\ue909"
     CHEVRON_RIGHT = "\ue90a"
     CHEVRON_UP = "\ue90b"
-    CLOSE = "\ue90c"
-    PAGE_DOWN = "\ue90d"
-    PAGE_UP = "\ue90e"
+    # CLOSE = "\ue90c"  # Unused icons
+    # PAGE_DOWN = "\ue90d"
+    # PAGE_UP = "\ue90e"
     PLUS = "\ue90f"
     POWER = "\ue910"
     RESTART = "\ue911"
@@ -226,17 +217,17 @@ class SeedSignerIconConstants:
     ERROR = "\ue915"
 
     # Informational icons
-    ADDRESS = "\ue916"
+    # ADDRESS = "\ue916"
     CHANGE = "\ue917"
     DERIVATION = "\ue918"
-    FEE = "\ue919"
+    # FEE = "\ue919"
     FINGERPRINT = "\ue91a"
     PASSPHRASE = "\ue91b"
 
     # Misc icons
-    BITCOIN = "\ue91c"
+    # BITCOIN = "\ue91c"
     BITCOIN_ALT = "\ue91d"
-    BRIGHTNESS = "\ue91e"
+    # BRIGHTNESS = "\ue91e"
     MICROSD = "\ue91f"
     QRCODE = "\ue920"
     SIGN = "\ue921"
@@ -251,40 +242,6 @@ class SeedSignerIconConstants:
 
 
 
-def calc_text_centering(font: ImageFont,
-                        text: str,
-                        is_text_centered: bool,
-                        total_width: int,
-                        total_height: int,
-                        start_x: int = 0,
-                        start_y: int = 0) -> Tuple[int, int]:
-    # see: https://pillow.readthedocs.io/en/stable/handbook/text-anchors.html#text-anchors
-
-    # Gap between the starting coordinate and the first marking.
-    offset_x, offset_y = font.getoffset(text)
-
-    # Bounding box of the actual pixels rendered.
-    (box_left, box_top, box_right, box_bottom) = font.getbbox(text, anchor='lt')
-
-    # Ascender/descender are oversized ranges baked into the font.
-    ascent, descent = font.getmetrics()
-
-    # print(f"""----- "{text}" / {font.getname()} -----""")
-    # print(f"offset_x: {offset_x} | offset_y: {offset_y})")
-    # print(f"box_left: {box_left} |  box_top: {box_top} | box_right: {box_right} | box_bottom: {box_bottom}")
-    # print(f"ascent: {ascent} | descent: {descent})")
-
-    if is_text_centered:
-        text_x = int((total_width - (box_right - offset_x)) / 2) - offset_x
-    else:
-        text_x = GUIConstants.COMPONENT_PADDING
-
-    text_y = int((total_height - (ascent - offset_y)) / 2) - offset_y
-
-    return (start_x + text_x, start_y + text_y)
-
-
-
 def load_image(image_name: str) -> Image.Image:
     image_url = os.path.join(pathlib.Path(__file__).parent.resolve(), "..", "resources", "img", image_name)
     image = Image.open(image_url).convert("RGB")
@@ -390,7 +347,6 @@ class TextArea(BaseComponent):
     is_text_centered: bool = True
     supersampling_factor: int = 2  # 1 = disabled; 2 = default, double sample (4px square rendered for 1px)
     auto_line_break: bool = True
-    allow_text_overflow: bool = False
     is_horizontal_scrolling_enabled: bool = False
     horizontal_scroll_speed: int = 40  # px per sec
     horizontal_scroll_begin_hold_secs: float = 2.0
@@ -402,10 +358,6 @@ def __post_init__(self):
         if self.is_horizontal_scrolling_enabled and self.auto_line_break:
             raise Exception("TextArea: Cannot have auto_line_break and horizontal scrolling enabled at the same time")
 
-        if self.is_horizontal_scrolling_enabled and not self.allow_text_overflow:
-            self.allow_text_overflow = True
-            logger.warning("TextArea: allow_text_overflow gets overridden to True when horizontal scrolling is enabled")
-
         if not self.font_name:
             self.font_name = GUIConstants.get_body_font_name()
         if not self.font_size:
@@ -440,7 +392,13 @@ def __post_init__(self):
             # Guaranteed to be a single line of text, possibly wider than self.width
             self.text_lines = [{"text": self.text, "text_width": full_text_width}]
             self.text_width = full_text_width
-            if self.text_width > self.visible_width:
+
+            # Technically, the math says that we should enable scrolling for as little as
+            # 1px beyond the available width, but it's not worth having the text twitch
+            # back and forth by such a small amount.
+            min_scrollable_diff = 1
+
+            if self.text_width > self.visible_width + min_scrollable_diff:
                 # We'll have to left justify the text and scroll it (if scrolling is enabled,
                 # otherwise it'll just run off the right edge).
                 self.is_text_centered = False
@@ -458,7 +416,6 @@ def __post_init__(self):
                 width=self.width - 2*self.edge_padding,
                 font_name=self.font_name,
                 font_size=self.font_size,
-                allow_text_overflow=self.allow_text_overflow,
             )
 
             # Other components, like IconTextLine will need to know how wide the actual
@@ -485,14 +442,9 @@ def __post_init__(self):
 
         else:
             if total_text_height > self.height:
-                if not self.allow_text_overflow:
-                    # For now, early into the l10n rollout, we can't enforce strict
-                    # conformance here. Too many screens will just break if this is were
-                    # to raise an exception.
-                    logger.warning(f"Text cannot fit in target rect with this font/size\n\ttotal_text_height: {total_text_height} | self.height: {self.height}")
-                else:
-                    # Just let it render past the bottom edge
-                    pass
+                # Let it render past the bottom edge. Will be up to the dev or translator
+                # to review the screenshot and revise the text as needed.
+                logger.warning(f"Text cannot fit in target rect with this font/size\n\ttotal_text_height: {total_text_height} | self.height: {self.height}")
 
             else:
                 # Vertically center the text's starting point
@@ -623,7 +575,7 @@ def __init__(self, rendered_text_img: Image, screen_x: int, screen_y: int, visib
             self.horizontal_scroll_position = 0
             self.scroll_increment_sign = 1  # flip to negative to scroll text to the right
 
-            self.renderer = Renderer.get_instance()        
+            self.renderer = Renderer.get_instance()
 
 
         def stop_scrolling(self):
@@ -644,45 +596,57 @@ def run(self):
             readability. 45px/sec is better but still perceptually a bit stuttery.
             """
             max_scroll = self.rendered_text_img.width - self.visible_width
+            last_render_time = None
+
+            # The scrolling pauses at the start and end of the text line. These vars track
+            # when we started holding and how long we should hold for.
+            hold_started_at = None
+            cur_hold_duration = None
 
             while self.keep_running:
                 if not self.scrolling_active:
                     time.sleep(0.1)
                     continue
 
-                with self.renderer.lock:
-                    if not self.scrolling_active:
-                        # We were stopped while waiting for the lock
+                if cur_hold_duration is not None:
+                    # We're currently holding; see if we've held long enough
+                    hold_time_elapsed = time.time() - hold_started_at
+                    if hold_time_elapsed < cur_hold_duration:
+                        # Still have to hold longer; skip scrolling logic
+                        time.sleep(0.1)
                         continue
+                    else:
+                        # We've held long enough; reset the vars and resume scrolling
+                        hold_started_at = None
+                        cur_hold_duration = None
 
-                    img = self.rendered_text_img.crop((self.horizontal_scroll_position, 0, self.horizontal_scroll_position + self.visible_width, self.rendered_text_img.height))
-                    self.renderer.canvas.paste(img, (self.screen_x, self.screen_y - self.scroll_y))
-                    self.renderer.show_image()
-
-                if self.horizontal_scroll_position == 0:
-                    # Pause on initial (left-justified) position...                
-                    time.sleep(self.begin_hold_secs)
-
-                    # Don't count those pause seconds
-                    last_render_time = None
+                else:
+                    # We're not holding, but if we've reached either end, we need to start
+                    # holding.
+                    if self.horizontal_scroll_position == 0:
+                        # Pause on initial (left-justified) position...
+                        hold_started_at = time.time()
+                        cur_hold_duration = self.begin_hold_secs
+
+                        # Next scroll direction will be left
+                        self.scroll_increment_sign = 1
+
+                        # Don't count those pause seconds
+                        last_render_time = None
+                        continue
 
-                    # Scroll the text left
-                    self.scroll_increment_sign = 1
+                    elif self.horizontal_scroll_position == max_scroll:
+                        # ...and slight pause at end of scroll
+                        hold_started_at = time.time()
+                        cur_hold_duration = self.end_hold_secs
 
-                elif self.horizontal_scroll_position == max_scroll:
-                    # ...and slight pause at end of scroll
-                    time.sleep(self.end_hold_secs)
+                        # Don't count those pause seconds
+                        last_render_time = None
 
-                    # Don't count those pause seconds
-                    last_render_time = None
+                        # Scroll will be to the right
+                        self.scroll_increment_sign = -1
+                        continue
 
-                    # Scroll the text right
-                    self.scroll_increment_sign = -1
-                
-                else:
-                    # No need to CPU limit when running in its own thread?
-                    time.sleep(0.02)
-                
                 next_render_time = time.time()
 
                 if not last_render_time:
@@ -690,18 +654,39 @@ def run(self):
                     # "get off zero" for the real increment calc logic to kick in.
                     scroll_position_increment = 1 * self.scroll_increment_sign
                 else:
+                    # Calculate how far to scroll based on time elapsed since last render
                     scroll_position_increment = int(self.horizontal_scroll_speed * (next_render_time - last_render_time) * self.scroll_increment_sign)
 
+                # Only render an update if we're going to move at least 1px
                 if abs(scroll_position_increment) > 0:
-                    self.horizontal_scroll_position += scroll_position_increment
-                    self.horizontal_scroll_position = max(0, min(self.horizontal_scroll_position, max_scroll))
+                    # max: Don't over-scroll when returning to the left edge (0)
+                    # min: Don't over-scroll when revealing the right edge (max_scroll)
+                    self.horizontal_scroll_position = max(
+                        0,
+                        min(self.horizontal_scroll_position + scroll_position_increment, max_scroll)
+                    )
+
+                    # Render the scroll update
+                    with self.renderer.lock:
+                        if not self.scrolling_active:
+                            # We were stopped while waiting for the lock
+                            continue
+
+                        # The pre-rendered text img slides within a cropping window
+                        img = self.rendered_text_img.crop((self.horizontal_scroll_position, 0, self.horizontal_scroll_position + self.visible_width, self.rendered_text_img.height))
+                        self.renderer.canvas.paste(img, (self.screen_x, self.screen_y - self.scroll_y))
+                        self.renderer.show_image()
 
                     last_render_time = next_render_time
+
                 else:
-                    # Wait to accumulate more time before scrolling
+                    # Wait to accumulate more time so we can scroll at least 1px
                     pass
 
+                # Free up the processor for a bit each loop
+                time.sleep(0.02)
 
+ 
     def render(self):
         """
             Even if we need to animate for scrolling, all instances should explicitly render
@@ -741,7 +726,6 @@ class ScrollableTextLine(TextArea):
     def __post_init__(self):
         self.auto_line_break = False
         self.is_horizontal_scrolling_enabled = True
-        self.allow_text_overflow = True
         super().__post_init__()
 
 
@@ -803,7 +787,6 @@ class IconTextLine(BaseComponent):
     font_size: int = None
     is_text_centered: bool = False
     auto_line_break: bool = False
-    allow_text_overflow: bool = True
     screen_x: int = 0
     screen_y: int = 0
 
@@ -846,7 +829,6 @@ def __post_init__(self):
                 auto_line_break=False,
                 screen_x=text_screen_x,
                 screen_y=self.screen_y,
-                allow_text_overflow=False,
             )
         else:
             self.label_textarea = None        
@@ -866,7 +848,6 @@ def __post_init__(self):
             edge_padding=0,
             is_text_centered=self.is_text_centered if not self.icon_name else False,
             auto_line_break=self.auto_line_break,
-            allow_text_overflow=self.allow_text_overflow,
             screen_x=text_screen_x,
             screen_y=value_textarea_screen_y,
         )
@@ -1098,7 +1079,6 @@ class BtcAmount(BaseComponent):
 
     def __post_init__(self):
         super().__post_init__()
-        self.sub_components: List[BaseComponent] = []
         self.paste_image: Image.Image = None
         self.paste_coords = None
         denomination = Settings.get_instance().get_value(SettingsConstants.SETTING__BTC_DENOMINATION)
@@ -1516,7 +1496,6 @@ def __post_init__(self):
             button_kwargs["text"] = self.text
             button_kwargs["font_color"] = self.font_color
             button_kwargs["background_color"] = self.background_color
-            button_kwargs["allow_text_overflow"] = True
             button_kwargs["auto_line_break"] = False
             del button_kwargs["horizontal_scroll_begin_hold_secs"]
             del button_kwargs["horizontal_scroll_end_hold_secs"]
@@ -1821,8 +1800,7 @@ def calc_bezier_curve(p1: Tuple[int,int], p2: Tuple[int,int], p3: Tuple[int,int]
 def reflow_text_for_width(text: str,
                           width: int,
                           font_name=GUIConstants.get_body_font_name(),
-                          font_size=GUIConstants.get_body_font_size(),
-                          allow_text_overflow: bool=False) -> list[dict]:
+                          font_size=GUIConstants.get_body_font_size()) -> list[dict]:
     """
     Reflows text to fit within `width` by breaking long lines up.
 
@@ -1845,9 +1823,6 @@ def reflow_text_for_width(text: str,
         SettingsConstants.LOCALE__JAPANESE,
         SettingsConstants.LOCALE__KOREAN,
     ]
-    if treat_chars_as_words:
-        # Relax UI constraints even if the result isn't optimal
-        allow_text_overflow = True
 
     # Stores each line of text and its rendering starting x-coord
     text_lines = []
@@ -1891,9 +1866,9 @@ def _binary_len_search(min_index, max_index, word_spacer):
                 # Candidate line is possibly shorter than necessary.
                 return _binary_len_search(min_index=index, max_index=max_index, word_spacer=word_spacer)
 
-        if len(text.split()) == 1 and not allow_text_overflow and not treat_chars_as_words:
-            # No whitespace chars to split on!
-            raise TextDoesNotFitException("Text cannot fit in target rect with this font+size")
+        if len(text.split()) == 1 and not treat_chars_as_words:
+            # No whitespace chars to split on! Warn but proceed anyway.
+            logger.warning("Text cannot fit in target rect with this font+size")
 
         # Now we're ready to go line-by-line into our line break binary search!
         for line in text.split("\n"):
@@ -1933,8 +1908,7 @@ def reflow_text_into_pages(text: str,
                            height: int,
                            font_name=GUIConstants.get_body_font_name(),
                            font_size=GUIConstants.get_body_font_size(),
-                           line_spacer: int = GUIConstants.BODY_LINE_SPACING,
-                           allow_text_overflow: bool=False) -> list[str]:
+                           line_spacer: int = GUIConstants.BODY_LINE_SPACING) -> list[str]:
     """
     Invokes `reflow_text_for_width` above to convert long text into width-limited
     individual text lines and then calculates how many lines will fit on a "page" and
@@ -1945,8 +1919,7 @@ def reflow_text_into_pages(text: str,
     reflowed_lines_dicts = reflow_text_for_width(text=text,
                                            width=width,
                                            font_name=font_name,
-                                           font_size=font_size,
-                                           allow_text_overflow=allow_text_overflow)
+                                           font_size=font_size)
 
     lines = []
     for line_dict in reflowed_lines_dicts:
diff --git a/src/seedsigner/gui/renderer.py b/src/seedsigner/gui/renderer.py
index 49aec17ef..d0e2381d0 100644
--- a/src/seedsigner/gui/renderer.py
+++ b/src/seedsigner/gui/renderer.py
@@ -3,6 +3,7 @@
 
 # from seedsigner.hardware.st7789_mpy import ST7789
 from seedsigner.hardware.displays.display_driver import ALL_DISPLAY_TYPES, DISPLAY_TYPE__ILI9341, DISPLAY_TYPE__ILI9486, DISPLAY_TYPE__ST7789, DisplayDriver
+from seedsigner.hardware.displays.ili9341 import ILI9341, ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT
 from seedsigner.models.settings import Settings
 from seedsigner.models.settings_definition import SettingsConstants
 from seedsigner.models.singleton import ConfigurableSingleton
diff --git a/src/seedsigner/hardware/buttons.py b/src/seedsigner/hardware/buttons.py
index 187bc3746..abe18c5c0 100644
--- a/src/seedsigner/hardware/buttons.py
+++ b/src/seedsigner/hardware/buttons.py
@@ -1,12 +1,6 @@
 import logging
 from typing import List
-
-from seedsigner.extras.dev import SIMULATE_MODE
-if SIMULATE_MODE:
-    from seedsigner.extras.gpio import GPIO
-else:
-    import RPi.GPIO as GPIO
-
+import RPi.GPIO as GPIO
 import time
 
 from seedsigner.models.singleton import Singleton
@@ -47,8 +41,6 @@ def get_instance(cls):
             cls._instance = cls.__new__(cls)
 
             #init GPIO
-            if SIMULATE_MODE:
-                GPIO.init()
             GPIO.setmode(GPIO.BOARD)
             GPIO.setup(HardwareButtons.KEY_UP_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)    # Input with pull-up
             GPIO.setup(HardwareButtons.KEY_DOWN_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)  # Input with pull-up
diff --git a/src/seedsigner/hardware/camera.py b/src/seedsigner/hardware/camera.py
index 4648a090a..44919fa4b 100644
--- a/src/seedsigner/hardware/camera.py
+++ b/src/seedsigner/hardware/camera.py
@@ -3,99 +3,98 @@
 from gettext import gettext as _
 from PIL import Image
 
-from seedsigner.extras.dev import SIMULATE_MODE
 from seedsigner.models.settings import Settings, SettingsConstants
 from seedsigner.models.singleton import Singleton
 
 
+
 class CameraConnectionError(Exception):
     pass
 
-if SIMULATE_MODE:
-   import seedsigner.extras.local_camera
-   Camera = seedsigner.extras.local_camera.Camera
-else:
-    class Camera(Singleton):
-        _video_stream = None
-        _picamera = None
-        _camera_rotation = None
-
-        @classmethod
-        def get_instance(cls):
-            # This is the only way to access the one and only Controller
-            if cls._instance is None:
-                cls._instance = cls.__new__(cls)
-            cls._instance._camera_rotation = int(Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
-            return cls._instance
-
-
-        def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="bgr"):
-            from picamera import PiCameraError
-            from seedsigner.hardware.pivideostream import PiVideoStream
-            if self._video_stream is not None:
-                self.stop_video_stream_mode()
-
-            try:
-                self._video_stream = PiVideoStream(resolution=resolution,framerate=framerate, format=format)
-                self._video_stream.start()
-            except PiCameraError:
-                # This error most often occurs because the camera connection is loose
-                raise CameraConnectionError()
-
-
-        def read_video_stream(self, as_image=False):
-            if not self._video_stream:
-                raise Exception("Must call start_video_stream first.")
-            frame = self._video_stream.read()
-            if not as_image:
-                return frame
-            else:
-                if frame is not None:
-                    return Image.fromarray(frame.astype('uint8'), 'RGB').convert('RGBA').rotate(90 + self._camera_rotation)
-            return None
-
-
-        def stop_video_stream_mode(self):
-            if self._video_stream is not None:
-                self._video_stream.stop()
-                self._video_stream = None
-
-
-        def start_single_frame_mode(self, resolution=(720, 480)):
-            from picamera import PiCamera, PiCameraError
-            if self._video_stream is not None:
-                self.stop_video_stream_mode()
-            if self._picamera is not None:
-                self._picamera.close()
-
-            try:
-                self._picamera = PiCamera(resolution=resolution, framerate=24)
-                self._picamera.start_preview()
-            except PiCameraError:
-                # This error most often occurs because the camera connection is loose
-                raise CameraConnectionError()
-
-
-        def capture_frame(self):
-            if self._picamera is None:
-                raise Exception("Must call start_single_frame_mode first.")
-
-            # Set auto-exposure values
-            self._picamera.shutter_speed = self._picamera.exposure_speed
-            self._picamera.exposure_mode = 'off'
-            g = self._picamera.awb_gains
-            self._picamera.awb_mode = 'off'
-            self._picamera.awb_gains = g
-
-            stream = io.BytesIO()
-            self._picamera.capture(stream, format='jpeg')
-
-            # "Rewind" the stream to the beginning so we can read its content
-            stream.seek(0)
-            return Image.open(stream).rotate(90 + self._camera_rotation)
-
-
-        def stop_single_frame_mode(self):
-            if self._picamera is not None:
-                self._picamera.close()
-                self._picamera = None
+
+
+class Camera(Singleton):
+    _video_stream = None
+    _picamera = None
+    _camera_rotation = None
+
+    @classmethod
+    def get_instance(cls):
+        # This is the only way to access the one and only Controller
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+        cls._instance._camera_rotation = int(Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
+        return cls._instance
+
+
+    def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="bgr"):
+        from picamera import PiCameraError
+        from seedsigner.hardware.pivideostream import PiVideoStream
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+
+        try:
+            self._video_stream = PiVideoStream(resolution=resolution,framerate=framerate, format=format)
+            self._video_stream.start()
+        except PiCameraError:
+            # This error most often occurs because the camera connection is loose
+            raise CameraConnectionError()
+
+
+    def read_video_stream(self, as_image=False):
+        if not self._video_stream:
+            raise Exception("Must call start_video_stream first.")
+        frame = self._video_stream.read()
+        if not as_image:
+            return frame
+        else:
+            if frame is not None:
+                return Image.fromarray(frame.astype('uint8'), 'RGB').convert('RGBA').rotate(90 + self._camera_rotation)
+        return None
+
+
+    def stop_video_stream_mode(self):
+        if self._video_stream is not None:
+            self._video_stream.stop()
+            self._video_stream = None
+
+
+    def start_single_frame_mode(self, resolution=(720, 480)):
+        from picamera import PiCamera, PiCameraError
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+        if self._picamera is not None:
+            self._picamera.close()
+
+        try:
+            self._picamera = PiCamera(resolution=resolution, framerate=24)
+            self._picamera.start_preview()
+        except PiCameraError:
+            # This error most often occurs because the camera connection is loose
+            raise CameraConnectionError()
+
+
+    def capture_frame(self):
+        if self._picamera is None:
+            raise Exception("Must call start_single_frame_mode first.")
+
+        # Set auto-exposure values
+        self._picamera.shutter_speed = self._picamera.exposure_speed
+        self._picamera.exposure_mode = 'off'
+        g = self._picamera.awb_gains
+        self._picamera.awb_mode = 'off'
+        self._picamera.awb_gains = g
+
+        stream = io.BytesIO()
+        self._picamera.capture(stream, format='jpeg')
+
+        # "Rewind" the stream to the beginning so we can read its content
+        stream.seek(0)
+        return Image.open(stream).rotate(90 + self._camera_rotation)
+
+
+    def stop_single_frame_mode(self):
+        if self._picamera is not None:
+            self._picamera.close()
+            self._picamera = None
+
diff --git a/src/seedsigner/hardware/displays/display_driver.py b/src/seedsigner/hardware/displays/display_driver.py
index ccf3fe312..a41bb3214 100644
--- a/src/seedsigner/hardware/displays/display_driver.py
+++ b/src/seedsigner/hardware/displays/display_driver.py
@@ -1,6 +1,3 @@
-from seedsigner.extras.dev import SIMULATE_MODE
-
-
 DISPLAY_TYPE__ST7789 = "st7789"
 DISPLAY_TYPE__ILI9341 = "ili9341"
 DISPLAY_TYPE__ILI9486 = "ili9486"
@@ -22,17 +19,11 @@ def __init__(self, display_type: str = DISPLAY_TYPE__ST7789, width: int = None,
                 # TODO: For now the original ST7789 driver has to be used for 240x240.
                 # The mpy version below renders incorrectly (almost like each row of pixels
                 # is one pixel short, so the entire screen exhibits a diagonal skew).
-                if not SIMULATE_MODE:
-                    from seedsigner.hardware.displays.ST7789 import ST7789
-                else:
-                    from seedsigner.extras.local_display import ST7789
+                from seedsigner.hardware.displays.ST7789 import ST7789
                 self.display = ST7789()
 
             elif width == 320:
-                if not SIMULATE_MODE:
-                    from seedsigner.hardware.displays.st7789_mpy import ST7789
-                else:
-                    from seedsigner.extras.local_display import ST7789
+                from seedsigner.hardware.displays.st7789_mpy import ST7789
                 # Have to swap width and height; screen is natively 240x320
                 self.display = ST7789(width=height, height=width)
         
@@ -66,4 +57,4 @@ def invert(self, enabled: bool = True):
 
 
     def show_image(self, image, x_start: int = 0, y_start: int = 0):
-        self.display.show_image(image, x_start, y_start)
+        self.display.show_image(image, x_start, y_start)
\ No newline at end of file
diff --git a/src/gui.py b/tools/run_emulator.py
similarity index 50%
rename from src/gui.py
rename to tools/run_emulator.py
index f3f6e4b0f..442001940 100644
--- a/src/gui.py
+++ b/tools/run_emulator.py
@@ -1,26 +1,188 @@
 import os
-
-os.environ.setdefault("LOCAL_DEV", "true")
-
-import numpy as np
-import socket
-import threading
-import time
-import multiprocessing
 import sys
 import signal
-
-
+import time
+import multiprocessing
+import threading
+import socket
+from unittest.mock import MagicMock, Mock, patch
+import numpy as np
 from tkinter import *
 from PIL import Image, ImageTk
 
-from seedsigner.hardware.buttons import HardwareButtons
+class MockCamera:
+    def __init__(self):
+        self._video_stream = None
+        self._picamera = None
+        self._camera_rotation = 0
+
+    @classmethod
+    def get_instance(cls):
+        if not hasattr(cls, '_instance'):
+            cls._instance = cls()
+        return cls._instance
+
+    def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="bgr"):
+        self._video_stream = MockVideoStream()
+        self._video_stream.start()
+
+    def read_video_stream(self, as_image=False):
+        if not self._video_stream:
+            raise Exception("Must call start_video_stream first.")
+        frame = self._video_stream.read()
+        if as_image and frame is not None:
+            return Image.fromarray(frame.astype('uint8'), 'RGB').rotate(90 + self._camera_rotation)
+        return frame
+
+    def stop_video_stream_mode(self):
+        if self._video_stream:
+            self._video_stream.stop()
+            self._video_stream = None
+
+    def start_single_frame_mode(self, resolution=(720, 480)):
+        if self._video_stream:
+            self.stop_video_stream_mode()
+
+    def capture_frame(self):
+        # Return a simple test image
+        frame = np.random.randint(0, 255, (240, 240, 3), dtype=np.uint8)
+        return Image.fromarray(frame).rotate(90 + self._camera_rotation)
+
+    def stop_single_frame_mode(self):
+        pass
+
+class MockVideoStream:
+    def __init__(self):
+        self.frame = np.random.randint(0, 255, (240, 240, 3), dtype=np.uint8)
+
+    def start(self):
+        pass
+
+    def read(self):
+        return self.frame
+
+    def stop(self):
+        pass
+
+class MockST7789:
+    def __init__(self, width=240, height=240):
+        self.width = width
+        self.height = height
+
+    def show_image(self, image, x=0, y=0):
+        # Save image for the GUI to display
+        with open('display.bmp', 'wb') as f:
+            f.write(image.tobytes())
+
+    def invert(self, enabled: bool = True):
+        pass
 
+class MockGPIO:
+    LOW = 0
+    HIGH = 1
+    BOARD = 10
+    IN = 1
+    PUD_UP = 22
+    RPI_INFO = {"P1_REVISION": 3}
+
+    def __init__(self):
+        self._states = {}
+        self.lock = threading.Lock()
+        self._initialized = False
+
+    def setmode(self, mode):
+        pass
+
+    def setup(self, pin, mode, pull_up_down=None):
+        pass
 
-class Display:
-    def __init__(self, width: int = 240, height: int = 240):
+    def init(self, socket_path="gpio.sock"):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._states = {}
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.connect(socket_path)
+        threading.Thread(target=self._read_loop, daemon=True).start()
+
+    def _read_loop(self):
+        f = self.sock.makefile("r")
+        while True:
+            line = f.readline()
+            if not line:
+                break
+            try:
+                pin, val = line.strip().split()
+                with self.lock:
+                    self._states[int(pin)] = int(val)
+            except Exception:
+                pass
+
+    def input(self, pin):
+        with self.lock:
+            return self._states.get(pin, self.HIGH)
+
+# Mock patches to apply
+MOCK_PATCHES = [
+    ('seedsigner.hardware.displays.ST7789.ST7789', MockST7789),
+    ('seedsigner.hardware.displays.st7789_mpy.ST7789', MockST7789),
+    ('seedsigner.extras.local_display.ST7789', MockST7789),
+    ('seedsigner.hardware.pivideostream.PiVideoStream', MockVideoStream),
+]
+
+def setup_mocks():
+    """Apply all mock patches"""
+    patches = []
+    
+    import sys
+    
+    # Mock the entire picamera module before anything imports it
+    picamera_mock = Mock()
+    picamera_mock.PiCamera = Mock()
+    picamera_mock.array = Mock()
+    picamera_mock.array.PiRGBArray = Mock()
+    picamera_mock.PiCameraError = Exception
+    sys.modules['picamera'] = Mock()
+    sys.modules['picamera.array'] = picamera_mock.array
+    
+    # Mock the RPi module and its components
+    rpi_mock = Mock()
+    rpi_mock.GPIO = MockGPIO()
+    sys.modules['RPi'] = rpi_mock
+    sys.modules['RPi.GPIO'] = rpi_mock.GPIO
+    
+    # Mock spidev module
+    spidev_mock = Mock()
+    spidev_mock.SpiDev = Mock()
+    sys.modules['spidev'] = spidev_mock
+    
+    for module_path, mock_obj in MOCK_PATCHES:
+        try:
+            patcher = patch(module_path, mock_obj)
+            patches.append(patcher)
+            patcher.start()
+        except (ImportError, AttributeError):
+            # Module doesn't exist or can't be patched, skip
+            continue
+    
+    # Special handling for Camera class replacement
+    try:
+        import seedsigner.hardware.camera
+        seedsigner.hardware.camera.Camera = MockCamera
+    except ImportError:
+        pass
+    
+    return patches
+
+# Set LOCAL_DEV environment variable - emulator works independently of this now
+# os.environ.setdefault("LOCAL_DEV", "true")
+
+
+class Window:
+    def __init__(self, HardwareButtons, width: int = 240, height: int = 240):
         self.width = width
         self.height = height
+        self.HardwareButtons = HardwareButtons
 
         self.setup_sock()
         self.run()
@@ -49,7 +211,7 @@ def run(self):
             image=pixel,
             width=20,
             height=20,
-            command=HardwareButtons.KEY_LEFT_PIN,
+            command=self.HardwareButtons.KEY_LEFT_PIN,
         )
         self.btnL.grid(row=1, column=0)
         self.bindButtonClick(self.btnL)
@@ -59,7 +221,7 @@ def run(self):
             image=pixel,
             width=20,
             height=20,
-            command=HardwareButtons.KEY_RIGHT_PIN,
+            command=self.HardwareButtons.KEY_RIGHT_PIN,
         )
         self.btnR.grid(row=1, column=2)
         self.bindButtonClick(self.btnR)
@@ -69,7 +231,7 @@ def run(self):
             image=pixel,
             width=20,
             height=20,
-            command=HardwareButtons.KEY_PRESS_PIN,
+            command=self.HardwareButtons.KEY_PRESS_PIN,
         )
         self.btnC.grid(row=1, column=1)
         self.bindButtonClick(self.btnC)
@@ -79,7 +241,7 @@ def run(self):
             image=pixel,
             width=20,
             height=20,
-            command=HardwareButtons.KEY_UP_PIN,
+            command=self.HardwareButtons.KEY_UP_PIN,
         )
         self.btnU.grid(row=0, column=1)
         self.bindButtonClick(self.btnU)
@@ -89,7 +251,7 @@ def run(self):
             image=pixel,
             width=20,
             height=20,
-            command=HardwareButtons.KEY_DOWN_PIN,
+            command=self.HardwareButtons.KEY_DOWN_PIN,
         )
         self.btnD.grid(row=2, column=1)
         self.bindButtonClick(self.btnD)
@@ -99,7 +261,7 @@ def run(self):
             image=pixel,
             width=40,
             height=20,
-            command=HardwareButtons.KEY1_PIN,
+            command=self.HardwareButtons.KEY1_PIN,
         )
         self.btn1.place(x=self.width + 160, y=60)
         self.bindButtonClick(self.btn1)
@@ -109,7 +271,7 @@ def run(self):
             image=pixel,
             width=40,
             height=20,
-            command=HardwareButtons.KEY2_PIN,
+            command=self.HardwareButtons.KEY2_PIN,
         )
         self.btn2.place(x=self.width + 160, y=116)
         self.bindButtonClick(self.btn2)
@@ -119,30 +281,30 @@ def run(self):
             image=pixel,
             width=40,
             height=20,
-            command=HardwareButtons.KEY3_PIN,
+            command=self.HardwareButtons.KEY3_PIN,
         )
         self.btn3.place(x=self.width + 160, y=172)
         self.bindButtonClick(self.btn3)
 
         def key_handler(event):
             if event.keysym == "Up":
-                self.key_press(HardwareButtons.KEY_UP_PIN)
+                self.key_press(self.HardwareButtons.KEY_UP_PIN)
             if event.keysym == "Down":
-                self.key_press(HardwareButtons.KEY_DOWN_PIN)
+                self.key_press(self.HardwareButtons.KEY_DOWN_PIN)
             if event.keysym == "Left":
-                self.key_press(HardwareButtons.KEY_LEFT_PIN)
+                self.key_press(self.HardwareButtons.KEY_LEFT_PIN)
             if event.keysym == "Right":
-                self.key_press(HardwareButtons.KEY_RIGHT_PIN)
+                self.key_press(self.HardwareButtons.KEY_RIGHT_PIN)
 
             if event.keysym in ("1", "KP_1"):
-                self.key_press(HardwareButtons.KEY1_PIN)
+                self.key_press(self.HardwareButtons.KEY1_PIN)
             if event.keysym in ("2", "KP_2"):
-                self.key_press(HardwareButtons.KEY2_PIN)
+                self.key_press(self.HardwareButtons.KEY2_PIN)
             if event.keysym in ("3", "KP_3"):
-                self.key_press(HardwareButtons.KEY3_PIN)
+                self.key_press(self.HardwareButtons.KEY3_PIN)
 
             if event.keysym == "Return":
-                self.key_press(HardwareButtons.KEY_PRESS_PIN)
+                self.key_press(self.HardwareButtons.KEY_PRESS_PIN)
 
         self.root.bind("<Key>", key_handler)
 
@@ -210,12 +372,19 @@ def handle_sock(self):
 
 def run_gui():
     signal.signal(signal.SIGINT, signal.SIG_DFL)
-
-    Display()
+    
+    # Setup mocks and import HardwareButtons after environment is set
+    setup_mocks()
+    from seedsigner.hardware.buttons import HardwareButtons
+    
+    Window(HardwareButtons)
 
 
 def run_main():
     signal.signal(signal.SIGINT, signal.SIG_DFL)
+    
+    # Setup mocks before importing the main module
+    setup_mocks()
 
     from main import main
 

From c54bf9d793f99e10860d4b4624cd6a6682a4d633 Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sun, 15 Feb 2026 23:02:45 +0530
Subject: [PATCH 07/10] add emulator

---
 tools/run_emulator.py | 221 ++++++++++++++++++++++++++++++++----------
 1 file changed, 172 insertions(+), 49 deletions(-)

diff --git a/tools/run_emulator.py b/tools/run_emulator.py
index 442001940..38f3b877b 100644
--- a/tools/run_emulator.py
+++ b/tools/run_emulator.py
@@ -5,51 +5,178 @@
 import multiprocessing
 import threading
 import socket
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import Mock, patch
 import numpy as np
 from tkinter import *
 from PIL import Image, ImageTk
 
-class MockCamera:
-    def __init__(self):
-        self._video_stream = None
-        self._picamera = None
-        self._camera_rotation = 0
+from PIL import Image
+
+from seedsigner.models.settings import Settings, SettingsConstants
+from seedsigner.models.singleton import Singleton
+
+from threading import Thread
+import time
+import cv2
+import numpy as np
+
+
+class MockCamera(Singleton):
+    _video_stream = None
+    _picamera = None
+    _camera_rotation = None
 
     @classmethod
     def get_instance(cls):
-        if not hasattr(cls, '_instance'):
-            cls._instance = cls()
+        # This is the only way to access the one and only Controller
+        print("INSTANCE")
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+        cls._instance._camera_rotation = int( Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
+        cls._instance._camera_rotation += 90
         return cls._instance
 
-    def start_video_stream_mode(self, resolution=(512, 384), framerate=12, format="bgr"):
-        self._video_stream = MockVideoStream()
-        self._video_stream.start()
+    def start_video_stream_mode(
+        self, resolution=(512, 384), framerate=12, format="bgr"
+    ):
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+
+        try:
+            self._video_stream = WebcamVideoStream(
+                resolution=resolution, framerate=framerate, format=format
+            )
+            self._video_stream.start()
+        except Exception as e:
+            raise e
 
     def read_video_stream(self, as_image=False):
         if not self._video_stream:
             raise Exception("Must call start_video_stream first.")
         frame = self._video_stream.read()
-        if as_image and frame is not None:
-            return Image.fromarray(frame.astype('uint8'), 'RGB').rotate(90 + self._camera_rotation)
-        return frame
+        if not as_image:
+            return frame
+        else:
+            if frame is not None:
+                return Image.fromarray(frame.astype("uint8"), "RGB").rotate(
+                    90 + self._camera_rotation
+                )
+        return None
 
     def stop_video_stream_mode(self):
-        if self._video_stream:
+        if self._video_stream is not None:
             self._video_stream.stop()
             self._video_stream = None
 
     def start_single_frame_mode(self, resolution=(720, 480)):
-        if self._video_stream:
+        if self._video_stream is not None:
             self.stop_video_stream_mode()
+        if self._picamera is not None:
+            self._picamera.close()
 
     def capture_frame(self):
-        # Return a simple test image
-        frame = np.random.randint(0, 255, (240, 240, 3), dtype=np.uint8)
+        print("CAPTURE")
+        frame = WebcamVideoStream.single_frame()
         return Image.fromarray(frame).rotate(90 + self._camera_rotation)
 
     def stop_single_frame_mode(self):
-        pass
+        if self._picamera is not None:
+            self._picamera.close()
+            self._picamera = None
+
+
+def resize_and_center_crop_240(frame_bgr: np.ndarray) -> np.ndarray:
+    target = 240
+    h, w = frame_bgr.shape[:2]
+
+    # resize to 240
+    if w < h:
+        scale = target / w
+    else:
+        scale = target / h
+
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+
+    resized = cv2.resize(frame_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+    # center crop
+    x1 = (new_w - target) // 2
+    y1 = (new_h - target) // 2
+
+    cropped = resized[y1 : y1 + target, x1 : x1 + target]
+
+    return cropped
+
+
+class WebcamVideoStream:
+    def __init__(self, resolution=(320, 240), framerate=32, format="bgr", **kwargs):
+        # initialize the camera
+        self.camera = cv2.VideoCapture(0)
+        self.set_resolution(resolution)
+
+        # initialize the frame and the variable used to indicate
+        # if the thread should be stopped
+        self.frame = None
+        self.should_stop = False
+        self.is_stopped = True
+
+    def start(self):
+        # start the thread to read frames from the video stream
+        t = Thread(target=self.update, args=())
+        t.daemon = True
+        t.start()
+        self.is_stopped = False
+        return self
+
+    def update(self):
+        if self.camera.isOpened():
+            # keep looping infinitely until the thread is stopped
+            while not self.should_stop:
+                # grab the frame from the stream and clear the stream in
+                # preparation for the next frame
+                ret, stream = self.camera.read()
+                stream = cv2.resize(stream, (240, 240))
+                stream = cv2.cvtColor(stream, cv2.COLOR_BGR2RGB)
+                time.sleep(0.05)
+                self.frame = stream
+        self.is_stopped = True
+        self.should_stop = False
+
+    def read(self):
+        return self.frame
+
+    def stop(self):
+        # indicate that the thread should be stopped
+        self.should_stop = True
+
+        # Block in this thread until stopped
+        while not self.is_stopped:
+            pass
+
+    def set_resolution(self, resolution):
+        self.camera.set(3, resolution[0])
+        self.camera.set(4, resolution[1])
+
+    @staticmethod
+    def single_frame():
+        cap = cv2.VideoCapture(0)
+
+        # Warm-up, let auto-exposure settle in
+        for _ in range(30):
+            cap.read()
+            time.sleep(0.01)
+
+        ret, frame = cap.read()
+        cap.release()
+
+        if not ret:
+            raise RuntimeError("Camera capture failed")
+
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frame = resize_and_center_crop_240(frame)
+        return frame
+
 
 class MockVideoStream:
     def __init__(self):
@@ -64,6 +191,7 @@ def read(self):
     def stop(self):
         pass
 
+
 class MockST7789:
     def __init__(self, width=240, height=240):
         self.width = width
@@ -71,12 +199,13 @@ def __init__(self, width=240, height=240):
 
     def show_image(self, image, x=0, y=0):
         # Save image for the GUI to display
-        with open('display.bmp', 'wb') as f:
+        with open("display.bmp", "wb") as f:
             f.write(image.tobytes())
 
     def invert(self, enabled: bool = True):
         pass
 
+
 class MockGPIO:
     LOW = 0
     HIGH = 1
@@ -94,7 +223,8 @@ def setmode(self, mode):
         pass
 
     def setup(self, pin, mode, pull_up_down=None):
-        pass
+        if not self._initialized:
+            self.init()
 
     def init(self, socket_path="gpio.sock"):
         if self._initialized:
@@ -122,40 +252,43 @@ def input(self, pin):
         with self.lock:
             return self._states.get(pin, self.HIGH)
 
+
 # Mock patches to apply
 MOCK_PATCHES = [
-    ('seedsigner.hardware.displays.ST7789.ST7789', MockST7789),
-    ('seedsigner.hardware.displays.st7789_mpy.ST7789', MockST7789),
-    ('seedsigner.extras.local_display.ST7789', MockST7789),
-    ('seedsigner.hardware.pivideostream.PiVideoStream', MockVideoStream),
+    ("seedsigner.hardware.displays.ST7789.ST7789", MockST7789),
+    ("seedsigner.hardware.displays.st7789_mpy.ST7789", MockST7789),
+    ("seedsigner.extras.local_display.ST7789", MockST7789),
+    ("seedsigner.hardware.pivideostream.PiVideoStream", MockVideoStream),
+    ("seedsigner.hardware.camera.Camera", MockCamera),
 ]
 
+
 def setup_mocks():
     """Apply all mock patches"""
     patches = []
-    
+
     import sys
-    
+
     # Mock the entire picamera module before anything imports it
     picamera_mock = Mock()
     picamera_mock.PiCamera = Mock()
     picamera_mock.array = Mock()
     picamera_mock.array.PiRGBArray = Mock()
     picamera_mock.PiCameraError = Exception
-    sys.modules['picamera'] = Mock()
-    sys.modules['picamera.array'] = picamera_mock.array
-    
+    sys.modules["picamera"] = Mock()
+    sys.modules["picamera.array"] = picamera_mock.array
+
     # Mock the RPi module and its components
     rpi_mock = Mock()
     rpi_mock.GPIO = MockGPIO()
-    sys.modules['RPi'] = rpi_mock
-    sys.modules['RPi.GPIO'] = rpi_mock.GPIO
-    
+    sys.modules["RPi"] = rpi_mock
+    sys.modules["RPi.GPIO"] = rpi_mock.GPIO
+
     # Mock spidev module
     spidev_mock = Mock()
     spidev_mock.SpiDev = Mock()
-    sys.modules['spidev'] = spidev_mock
-    
+    sys.modules["spidev"] = spidev_mock
+
     for module_path, mock_obj in MOCK_PATCHES:
         try:
             patcher = patch(module_path, mock_obj)
@@ -164,18 +297,8 @@ def setup_mocks():
         except (ImportError, AttributeError):
             # Module doesn't exist or can't be patched, skip
             continue
-    
-    # Special handling for Camera class replacement
-    try:
-        import seedsigner.hardware.camera
-        seedsigner.hardware.camera.Camera = MockCamera
-    except ImportError:
-        pass
-    
-    return patches
 
-# Set LOCAL_DEV environment variable - emulator works independently of this now
-# os.environ.setdefault("LOCAL_DEV", "true")
+    return patches
 
 
 class Window:
@@ -372,17 +495,17 @@ def handle_sock(self):
 
 def run_gui():
     signal.signal(signal.SIGINT, signal.SIG_DFL)
-    
+
     # Setup mocks and import HardwareButtons after environment is set
     setup_mocks()
     from seedsigner.hardware.buttons import HardwareButtons
-    
+
     Window(HardwareButtons)
 
 
 def run_main():
     signal.signal(signal.SIGINT, signal.SIG_DFL)
-    
+
     # Setup mocks before importing the main module
     setup_mocks()
 

From f78a4e011c4826cabb00293d51b5aac99bce1feb Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sun, 15 Feb 2026 23:10:34 +0530
Subject: [PATCH 08/10] restore requirements.txt

---
 requirements-simulator.txt |  7 +++++++
 requirements.txt           | 10 ++++------
 2 files changed, 11 insertions(+), 6 deletions(-)
 create mode 100644 requirements-simulator.txt

diff --git a/requirements-simulator.txt b/requirements-simulator.txt
new file mode 100644
index 000000000..80a02f322
--- /dev/null
+++ b/requirements-simulator.txt
@@ -0,0 +1,7 @@
+embit==0.8.0
+Pillow>=10.0.1
+pyzbar @ git+https://github.com/seedsigner/pyzbar.git@c3c237821c6a20b17953efe59b90df0b514a1c03
+qrcode==7.3.1
+urtypes==1.0.1
+numpy
+opencv-python
diff --git a/requirements.txt b/requirements.txt
index c0b75601e..d7a20d593 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,5 @@
-embit
-Pillow
+embit==0.8.0
+Pillow==10.0.1
 pyzbar @ git+https://github.com/seedsigner/pyzbar.git@c3c237821c6a20b17953efe59b90df0b514a1c03
-qrcode
-urtypes
-numpy
-opencv-python
+qrcode==7.3.1
+urtypes==1.0.1

From de2fdffd2e40a7f3af736ec0d946d4cdf7779484 Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Sun, 15 Feb 2026 23:38:54 +0530
Subject: [PATCH 09/10] update readme

---
 docs/local_simulator_setup_instructions.md | 38 ++++++++++------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/docs/local_simulator_setup_instructions.md b/docs/local_simulator_setup_instructions.md
index 27ef32644..929867512 100644
--- a/docs/local_simulator_setup_instructions.md
+++ b/docs/local_simulator_setup_instructions.md
@@ -1,8 +1,8 @@
 # Local SeedSigner Simulator Setup
 
-This guide adds a method to setup SeedSigner testing locally through a simulator GUI for easy development.
+This guide adds a method to setup SeedSigner testing locally through a simulator GUI for easy development. You can either interact with the buttons at the window or use keyboard arrows, Enter, Numpad_1, Numpad_2, Numpad_3
 
-It was tested on macOS (26) using Homebrew and Python 3.14. With additional effort it would work on other operating systems and python version or it may still way directly I've not tested it as I don't own any other devices.
+Note: The has only been tested on macOS (26) using Homebrew and Python 3.14.
 
 <img src="img/simulator.png" width=320 />
 
@@ -16,33 +16,33 @@ It was tested on macOS (26) using Homebrew and Python 3.14. With additional effo
 
 ### Installing system dependencies
 
-SeedSigner’s simulator depends on native libraries for QR scanning and camera access.
+SeedSigner’s simulator depends on Python with `tkinter` support, native libraries for QR scanning and camera access.
+- `tkinter` is Python's built-in library for creating desktop GUI applications.
+- `pyzbar` library requires a backend to be running on the system called `zbar`.
 
+#### MacOS (Homebrew)
 ```bash
-brew install opencv zbar
+brew install python@3.14 # includes tkinter support
+brew install zbar
+```
+#### Linux
+```bash
+sudo apt-get install python3-tk
+sudo apt install libzbar0
 ```
-
-These provide:
-
-- Camera capture backend (OpenCV)
-- QR decoding backend (zbar, used by `pyzbar`)
-
-
 
 ### Setting up dev environment
 
-The GUI uses tkinter that usually bundles with python installation, but for any reason it is not present follow the guide to setup tkinter https://coderivers.org/blog/installing-tkinter-in-python
-
 ```bash
 git clone https://github.com/SeedSigner/seedsigner
 
-python3.14 -m venv env
+python3 -m venv env
 source env/bin/activate
 
 # should not fail loading tkinter
-python3.14 -m tkinter
+python3 -m tkinter
 
-pip install -r requirements.txt
+pip install -r requirements-simulator.txt
 ```
 
 #### Camera Permissions (macOS Security)
@@ -54,7 +54,7 @@ OpenCV: not authorized to capture video
 OpenCV: camera failed to properly initialize
 ```
 
-#### Grant Camera Permission
+#### Grant Camera Permission (macOS)
 
 Go to: System Settings → Privacy & Security → Camera
 
@@ -73,10 +73,8 @@ tccutil reset Camera
 
 ### Running the Simulator
 
-From the simulator directory:
-
 ```bash
-python src/gui.py
+python tools/run_emulator.py
 ```
 
 ### Notes

From ef7072c12c8640ff7dbd2d75d65ae8908c0ff35b Mon Sep 17 00:00:00 2001
From: KaustubhPatange <developerkp16@gmail.com>
Date: Tue, 17 Feb 2026 22:28:52 +0530
Subject: [PATCH 10/10] refactor and credits

---
 docs/local_simulator_setup_instructions.md    |   9 +-
 tools/emulator/patches/camera.py              | 173 ++++++
 tools/emulator/patches/gpio.py                |  52 ++
 tools/emulator/patches/window.py              | 206 +++++++
 .../emulator/requirements-simulator.txt       |   0
 tools/emulator/run_emulator.py                | 160 +++++
 tools/run_emulator.py                         | 560 ------------------
 7 files changed, 598 insertions(+), 562 deletions(-)
 create mode 100644 tools/emulator/patches/camera.py
 create mode 100644 tools/emulator/patches/gpio.py
 create mode 100644 tools/emulator/patches/window.py
 rename requirements-simulator.txt => tools/emulator/requirements-simulator.txt (100%)
 create mode 100644 tools/emulator/run_emulator.py
 delete mode 100644 tools/run_emulator.py

diff --git a/docs/local_simulator_setup_instructions.md b/docs/local_simulator_setup_instructions.md
index 929867512..9e804c80f 100644
--- a/docs/local_simulator_setup_instructions.md
+++ b/docs/local_simulator_setup_instructions.md
@@ -42,7 +42,7 @@ source env/bin/activate
 # should not fail loading tkinter
 python3 -m tkinter
 
-pip install -r requirements-simulator.txt
+pip install -r tools/emulator/requirements-simulator.txt
 ```
 
 #### Camera Permissions (macOS Security)
@@ -74,7 +74,7 @@ tccutil reset Camera
 ### Running the Simulator
 
 ```bash
-python tools/run_emulator.py
+python tools/emulator/run_emulator.py
 ```
 
 ### Notes
@@ -82,3 +82,8 @@ python tools/run_emulator.py
 - The simulator environment is **not security-hardened** and should never be used with real funds.
 - Camera access, QR decoding, and GUI rendering are all platform-dependent; macOS quirks differ from Raspberry Pi OS.
 - For hardware deployment, follow the official Raspberry Pi OS instructions in the main project README.
+
+### Credits
+
+- The original work is inspired by https://github.com/enteropositivo/seedsigner-emulator, which was the first working emulator POC that directly replaced files in the SeedSigner source code for the camera, buttons, and renderer using Tkinter-based implementations.
+- The modified work from https://github.com/ltcmweb/seedsigner based on @enteropositivo's work added macOS support with local emulation of the GPIO socket.
diff --git a/tools/emulator/patches/camera.py b/tools/emulator/patches/camera.py
new file mode 100644
index 000000000..ed44a0b62
--- /dev/null
+++ b/tools/emulator/patches/camera.py
@@ -0,0 +1,173 @@
+# Forked and modified from @enteropositivo
+# https://github.com/enteropositivo/seedsigner-emulator/blob/master/seedsigner/hardware/camera.py
+# https://github.com/enteropositivo/seedsigner-emulator/blob/master/seedsigner/emulator/webcamvideostream.py
+
+from threading import Thread
+import time
+import cv2
+import numpy as np
+from PIL import Image
+
+from seedsigner.models.settings import Settings, SettingsConstants
+from seedsigner.models.singleton import Singleton
+
+
+class MockCamera(Singleton):
+    _video_stream = None
+    _picamera = None
+    _camera_rotation = None
+
+    @classmethod
+    def get_instance(cls):
+        # This is the only way to access the one and only Controller
+        print("INSTANCE")
+        if cls._instance is None:
+            cls._instance = cls.__new__(cls)
+        cls._instance._camera_rotation = int(
+            Settings.get_instance().get_value(
+                SettingsConstants.SETTING__CAMERA_ROTATION
+            )
+        )
+        cls._instance._camera_rotation += 90
+        return cls._instance
+
+    def start_video_stream_mode(
+        self, resolution=(512, 384), framerate=12, format="bgr"
+    ):
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+
+        try:
+            self._video_stream = WebcamVideoStream(
+                resolution=resolution, framerate=framerate, format=format
+            )
+            self._video_stream.start()
+        except Exception as e:
+            raise e
+
+    def read_video_stream(self, as_image=False):
+        if not self._video_stream:
+            raise Exception("Must call start_video_stream first.")
+        frame = self._video_stream.read()
+        if not as_image:
+            return frame
+        else:
+            if frame is not None:
+                return Image.fromarray(frame.astype("uint8"), "RGB").rotate(
+                    90 + self._camera_rotation
+                )
+        return None
+
+    def stop_video_stream_mode(self):
+        if self._video_stream is not None:
+            self._video_stream.stop()
+            self._video_stream = None
+
+    def start_single_frame_mode(self, resolution=(720, 480)):
+        if self._video_stream is not None:
+            self.stop_video_stream_mode()
+        if self._picamera is not None:
+            self._picamera.close()
+
+    def capture_frame(self):
+        print("CAPTURE")
+        frame = WebcamVideoStream.single_frame()
+        return Image.fromarray(frame).rotate(90 + self._camera_rotation)
+
+    def stop_single_frame_mode(self):
+        if self._picamera is not None:
+            self._picamera.close()
+            self._picamera = None
+
+
+def resize_and_center_crop_240(frame_bgr: np.ndarray) -> np.ndarray:
+    target = 240
+    h, w = frame_bgr.shape[:2]
+
+    # resize to 240
+    if w < h:
+        scale = target / w
+    else:
+        scale = target / h
+
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+
+    resized = cv2.resize(frame_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+    # center crop
+    x1 = (new_w - target) // 2
+    y1 = (new_h - target) // 2
+
+    cropped = resized[y1 : y1 + target, x1 : x1 + target]
+
+    return cropped
+
+
+class WebcamVideoStream:
+    def __init__(self, resolution=(320, 240), framerate=32, format="bgr", **kwargs):
+        # initialize the camera
+        self.camera = cv2.VideoCapture(0)
+        self.set_resolution(resolution)
+
+        # initialize the frame and the variable used to indicate
+        # if the thread should be stopped
+        self.frame = None
+        self.should_stop = False
+        self.is_stopped = True
+
+    def start(self):
+        # start the thread to read frames from the video stream
+        t = Thread(target=self.update, args=())
+        t.daemon = True
+        t.start()
+        self.is_stopped = False
+        return self
+
+    def update(self):
+        if self.camera.isOpened():
+            # keep looping infinitely until the thread is stopped
+            while not self.should_stop:
+                # grab the frame from the stream and clear the stream in
+                # preparation for the next frame
+                ret, stream = self.camera.read()
+                stream = cv2.resize(stream, (240, 240))
+                stream = cv2.cvtColor(stream, cv2.COLOR_BGR2RGB)
+                time.sleep(0.05)
+                self.frame = stream
+        self.is_stopped = True
+        self.should_stop = False
+
+    def read(self):
+        return self.frame
+
+    def stop(self):
+        # indicate that the thread should be stopped
+        self.should_stop = True
+
+        # Block in this thread until stopped
+        while not self.is_stopped:
+            pass
+
+    def set_resolution(self, resolution):
+        self.camera.set(3, resolution[0])
+        self.camera.set(4, resolution[1])
+
+    @staticmethod
+    def single_frame():
+        cap = cv2.VideoCapture(0)
+
+        # Warm-up, let auto-exposure settle in
+        for _ in range(30):
+            cap.read()
+            time.sleep(0.01)
+
+        ret, frame = cap.read()
+        cap.release()
+
+        if not ret:
+            raise RuntimeError("Camera capture failed")
+
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frame = resize_and_center_crop_240(frame)
+        return frame
diff --git a/tools/emulator/patches/gpio.py b/tools/emulator/patches/gpio.py
new file mode 100644
index 000000000..9f64bab1d
--- /dev/null
+++ b/tools/emulator/patches/gpio.py
@@ -0,0 +1,52 @@
+# Forked and modifed from @ltcmweb
+# https://github.com/ltcmweb/seedsigner/blob/3d321d50d488919d94fe407f538d8e655ba13eb4/src/seedsigner/hardware/buttons.py#L198
+
+import threading
+import socket
+
+
+class MockGPIO:
+    LOW = 0
+    HIGH = 1
+    BOARD = 10
+    IN = 1
+    PUD_UP = 22
+    RPI_INFO = {"P1_REVISION": 3}
+
+    def __init__(self):
+        self._states = {}
+        self.lock = threading.Lock()
+        self._initialized = False
+
+    def setmode(self, mode):
+        pass
+
+    def setup(self, pin, mode, pull_up_down=None):
+        if not self._initialized:
+            self.init()
+
+    def init(self, socket_path="gpio.sock"):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._states = {}
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.connect(socket_path)
+        threading.Thread(target=self._read_loop, daemon=True).start()
+
+    def _read_loop(self):
+        f = self.sock.makefile("r")
+        while True:
+            line = f.readline()
+            if not line:
+                break
+            try:
+                pin, val = line.strip().split()
+                with self.lock:
+                    self._states[int(pin)] = int(val)
+            except Exception:
+                pass
+
+    def input(self, pin):
+        with self.lock:
+            return self._states.get(pin, self.HIGH)
diff --git a/tools/emulator/patches/window.py b/tools/emulator/patches/window.py
new file mode 100644
index 000000000..55d8f9923
--- /dev/null
+++ b/tools/emulator/patches/window.py
@@ -0,0 +1,206 @@
+# Forked and modified from @enteropositivo, @ltcmweb
+# https://github.com/enteropositivo/seedsigner-emulator/blob/master/seedsigner/emulator/desktopDisplay.py
+# https://github.com/ltcmweb/seedsigner/blob/3d321d50d488919d94fe407f538d8e655ba13eb4/src/gui.py
+
+import os
+import time
+import threading
+import socket
+import numpy as np
+from tkinter import *
+from PIL import Image, ImageTk
+
+import time
+import numpy as np
+
+
+class Window:
+    def __init__(self, HardwareButtons, width: int = 240, height: int = 240):
+        self.width = width
+        self.height = height
+        self.HardwareButtons = HardwareButtons
+
+        self.setup_sock()
+        self.run()
+
+    def run(self):
+        self.root = Tk()
+        self.root.title("SeedSigner")
+
+        self.root.geometry(f"{self.width*2}x{self.height}+240+240")
+        self.root.resizable(False, False)
+        self.root.configure(bg="orange")
+        self.root.attributes("-topmost", True)
+
+        self.label = Label(self.root)
+        self.label.pack()
+
+        self.joystick = Frame(self.root)
+        self.joystick.pack()
+        self.joystick.place(x=20, y=85)
+        self.joystick.configure(bg="orange")
+
+        pixel = PhotoImage(width=1, height=1)
+
+        self.btnL = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=self.HardwareButtons.KEY_LEFT_PIN,
+        )
+        self.btnL.grid(row=1, column=0)
+        self.bindButtonClick(self.btnL)
+
+        self.btnR = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=self.HardwareButtons.KEY_RIGHT_PIN,
+        )
+        self.btnR.grid(row=1, column=2)
+        self.bindButtonClick(self.btnR)
+
+        self.btnC = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=self.HardwareButtons.KEY_PRESS_PIN,
+        )
+        self.btnC.grid(row=1, column=1)
+        self.bindButtonClick(self.btnC)
+
+        self.btnU = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=self.HardwareButtons.KEY_UP_PIN,
+        )
+        self.btnU.grid(row=0, column=1)
+        self.bindButtonClick(self.btnU)
+
+        self.btnD = Button(
+            self.joystick,
+            image=pixel,
+            width=20,
+            height=20,
+            command=self.HardwareButtons.KEY_DOWN_PIN,
+        )
+        self.btnD.grid(row=2, column=1)
+        self.bindButtonClick(self.btnD)
+
+        self.btn1 = Button(
+            self.root,
+            image=pixel,
+            width=40,
+            height=20,
+            command=self.HardwareButtons.KEY1_PIN,
+        )
+        self.btn1.place(x=self.width + 160, y=60)
+        self.bindButtonClick(self.btn1)
+
+        self.btn2 = Button(
+            self.root,
+            image=pixel,
+            width=40,
+            height=20,
+            command=self.HardwareButtons.KEY2_PIN,
+        )
+        self.btn2.place(x=self.width + 160, y=116)
+        self.bindButtonClick(self.btn2)
+
+        self.btn3 = Button(
+            self.root,
+            image=pixel,
+            width=40,
+            height=20,
+            command=self.HardwareButtons.KEY3_PIN,
+        )
+        self.btn3.place(x=self.width + 160, y=172)
+        self.bindButtonClick(self.btn3)
+
+        def key_handler(event):
+            if event.keysym == "Up":
+                self.key_press(self.HardwareButtons.KEY_UP_PIN)
+            if event.keysym == "Down":
+                self.key_press(self.HardwareButtons.KEY_DOWN_PIN)
+            if event.keysym == "Left":
+                self.key_press(self.HardwareButtons.KEY_LEFT_PIN)
+            if event.keysym == "Right":
+                self.key_press(self.HardwareButtons.KEY_RIGHT_PIN)
+
+            if event.keysym in ("1", "KP_1"):
+                self.key_press(self.HardwareButtons.KEY1_PIN)
+            if event.keysym in ("2", "KP_2"):
+                self.key_press(self.HardwareButtons.KEY2_PIN)
+            if event.keysym in ("3", "KP_3"):
+                self.key_press(self.HardwareButtons.KEY3_PIN)
+
+            if event.keysym == "Return":
+                self.key_press(self.HardwareButtons.KEY_PRESS_PIN)
+
+        self.root.bind("<Key>", key_handler)
+
+        self.periodic_update()
+        self.root.mainloop()
+
+    def key_press(self, key):
+        self.set_input(key, 0)
+        time.sleep(0.1)
+        self.set_input(key, 1)
+
+    def bindButtonClick(self, btn):
+        btn.bind("<Button>", self.buttonDown)
+        btn.bind("<ButtonRelease>", self.buttonUp)
+
+    def buttonDown(self, btn):
+        key = btn.widget.config("command")[-1]
+        self.set_input(key, 0)
+
+    def buttonUp(self, btn):
+        key = btn.widget.config("command")[-1]
+        self.set_input(key, 1)
+
+    def load_raw_rgb(self, filename):
+        if not os.path.exists(filename):
+            return None
+        with open(filename, "rb") as f:
+            data = f.read()
+        img_array = np.frombuffer(data, dtype=np.uint8)
+        try:
+            img_array = img_array.reshape((self.height, self.width, 3))
+        except ValueError:
+            return None
+        return Image.fromarray(img_array, "RGB")
+
+    def periodic_update(self, filename="display.bmp", interval=10):
+        img = self.load_raw_rgb(filename)
+        if img:
+            self.tkimage = ImageTk.PhotoImage(img, master=self.root)
+            self.label.configure(image=self.tkimage)
+            self.label.image = self.tkimage
+        self.root.after(interval, lambda: self.periodic_update(filename, interval))
+
+    def set_input(self, key, val):
+        try:
+            msg = f"{key} {val}\n"
+            self.conn.sendall(msg.encode())
+        except Exception:
+            pass
+
+    def setup_sock(self, path="gpio.sock"):
+        if os.path.exists(path):
+            os.remove(path)
+
+        self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.server.bind(path)
+        self.server.listen(1)
+
+        threading.Thread(target=self.handle_sock, daemon=True).start()
+
+    def handle_sock(self):
+        while True:
+            self.conn, _ = self.server.accept()
diff --git a/requirements-simulator.txt b/tools/emulator/requirements-simulator.txt
similarity index 100%
rename from requirements-simulator.txt
rename to tools/emulator/requirements-simulator.txt
diff --git a/tools/emulator/run_emulator.py b/tools/emulator/run_emulator.py
new file mode 100644
index 000000000..5c6fe9681
--- /dev/null
+++ b/tools/emulator/run_emulator.py
@@ -0,0 +1,160 @@
+import sys
+import os
+import signal
+import time
+import multiprocessing
+from unittest.mock import Mock, patch
+import time
+import numpy as np
+
+# Add the emulator directory to sys.path to enable imports
+emulator_dir = os.path.dirname(os.path.abspath(__file__))
+if emulator_dir not in sys.path:
+    sys.path.insert(0, emulator_dir)
+
+from patches.camera import MockCamera
+from patches.gpio import MockGPIO
+from patches.window import Window
+
+
+class MockST7789:
+    def __init__(self, width=240, height=240):
+        self.width = width
+        self.height = height
+
+    def show_image(self, image, x=0, y=0):
+        # Save image for the GUI to display
+        with open("display.bmp", "wb") as f:
+            f.write(image.tobytes())
+
+    def invert(self, enabled: bool = True):
+        pass
+
+
+class MockVideoStream:
+    def __init__(self):
+        self.frame = np.random.randint(0, 255, (240, 240, 3), dtype=np.uint8)
+
+    def start(self):
+        pass
+
+    def read(self):
+        return self.frame
+
+    def stop(self):
+        pass
+
+
+# Mock patches to apply
+MOCK_PATCHES = [
+    ("seedsigner.hardware.displays.ST7789.ST7789", MockST7789),
+    ("seedsigner.hardware.displays.st7789_mpy.ST7789", MockST7789),
+    ("seedsigner.extras.local_display.ST7789", MockST7789),
+    ("seedsigner.hardware.pivideostream.PiVideoStream", MockVideoStream),
+    ("seedsigner.hardware.camera.Camera", MockCamera),
+]
+
+
+def setup_mocks():
+    """Apply all mock patches"""
+    patches = []
+
+    import sys
+
+    # Mock the entire picamera module before anything imports it
+    picamera_mock = Mock()
+    picamera_mock.PiCamera = Mock()
+    picamera_mock.array = Mock()
+    picamera_mock.array.PiRGBArray = Mock()
+    picamera_mock.PiCameraError = Exception
+    sys.modules["picamera"] = Mock()
+    sys.modules["picamera.array"] = picamera_mock.array
+
+    # Mock the RPi module and its components
+    rpi_mock = Mock()
+    rpi_mock.GPIO = MockGPIO()
+    sys.modules["RPi"] = rpi_mock
+    sys.modules["RPi.GPIO"] = rpi_mock.GPIO
+
+    # Mock spidev module
+    spidev_mock = Mock()
+    spidev_mock.SpiDev = Mock()
+    sys.modules["spidev"] = spidev_mock
+
+    for module_path, mock_obj in MOCK_PATCHES:
+        try:
+            patcher = patch(module_path, mock_obj)
+            patches.append(patcher)
+            patcher.start()
+        except (ImportError, AttributeError):
+            # Module doesn't exist or can't be patched, skip
+            continue
+
+    return patches
+
+
+def run_gui():
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+    # Setup mocks and import HardwareButtons after environment is set
+    setup_mocks()
+    from seedsigner.hardware.buttons import HardwareButtons
+
+    Window(HardwareButtons)
+
+
+def run_main():
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+    # Setup mocks before importing the main module
+    setup_mocks()
+
+    from main import main
+
+    # Give GUI a moment to start up and create socket
+    time.sleep(0.5)
+
+    main()
+
+
+def signal_handler(sig, frame):
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    # Handle Ctrl+C
+    signal.signal(signal.SIGINT, signal_handler)
+
+    shutdown_event = multiprocessing.Event()
+
+    gui_process = multiprocessing.Process(target=run_gui, name="GUI")
+    main_process = multiprocessing.Process(target=run_main, name="Main")
+
+    try:
+        print("Starting GUI simulator...")
+        gui_process.start()
+
+        print("Starting SeedSigner main application...")
+        main_process.start()
+
+        while gui_process.is_alive() and main_process.is_alive():
+            try:
+                gui_process.join(timeout=0.1)
+                main_process.join(timeout=0.1)
+            except KeyboardInterrupt:
+                break
+
+    except KeyboardInterrupt:
+        pass
+
+    if main_process.is_alive():
+        main_process.terminate()
+        main_process.join(timeout=2)
+        if main_process.is_alive():
+            main_process.kill()
+
+    if gui_process.is_alive():
+        gui_process.terminate()
+        gui_process.join(timeout=2)
+        if gui_process.is_alive():
+            gui_process.kill()
diff --git a/tools/run_emulator.py b/tools/run_emulator.py
deleted file mode 100644
index 38f3b877b..000000000
--- a/tools/run_emulator.py
+++ /dev/null
@@ -1,560 +0,0 @@
-import os
-import sys
-import signal
-import time
-import multiprocessing
-import threading
-import socket
-from unittest.mock import Mock, patch
-import numpy as np
-from tkinter import *
-from PIL import Image, ImageTk
-
-from PIL import Image
-
-from seedsigner.models.settings import Settings, SettingsConstants
-from seedsigner.models.singleton import Singleton
-
-from threading import Thread
-import time
-import cv2
-import numpy as np
-
-
-class MockCamera(Singleton):
-    _video_stream = None
-    _picamera = None
-    _camera_rotation = None
-
-    @classmethod
-    def get_instance(cls):
-        # This is the only way to access the one and only Controller
-        print("INSTANCE")
-        if cls._instance is None:
-            cls._instance = cls.__new__(cls)
-        cls._instance._camera_rotation = int( Settings.get_instance().get_value(SettingsConstants.SETTING__CAMERA_ROTATION))
-        cls._instance._camera_rotation += 90
-        return cls._instance
-
-    def start_video_stream_mode(
-        self, resolution=(512, 384), framerate=12, format="bgr"
-    ):
-        if self._video_stream is not None:
-            self.stop_video_stream_mode()
-
-        try:
-            self._video_stream = WebcamVideoStream(
-                resolution=resolution, framerate=framerate, format=format
-            )
-            self._video_stream.start()
-        except Exception as e:
-            raise e
-
-    def read_video_stream(self, as_image=False):
-        if not self._video_stream:
-            raise Exception("Must call start_video_stream first.")
-        frame = self._video_stream.read()
-        if not as_image:
-            return frame
-        else:
-            if frame is not None:
-                return Image.fromarray(frame.astype("uint8"), "RGB").rotate(
-                    90 + self._camera_rotation
-                )
-        return None
-
-    def stop_video_stream_mode(self):
-        if self._video_stream is not None:
-            self._video_stream.stop()
-            self._video_stream = None
-
-    def start_single_frame_mode(self, resolution=(720, 480)):
-        if self._video_stream is not None:
-            self.stop_video_stream_mode()
-        if self._picamera is not None:
-            self._picamera.close()
-
-    def capture_frame(self):
-        print("CAPTURE")
-        frame = WebcamVideoStream.single_frame()
-        return Image.fromarray(frame).rotate(90 + self._camera_rotation)
-
-    def stop_single_frame_mode(self):
-        if self._picamera is not None:
-            self._picamera.close()
-            self._picamera = None
-
-
-def resize_and_center_crop_240(frame_bgr: np.ndarray) -> np.ndarray:
-    target = 240
-    h, w = frame_bgr.shape[:2]
-
-    # resize to 240
-    if w < h:
-        scale = target / w
-    else:
-        scale = target / h
-
-    new_w = int(w * scale)
-    new_h = int(h * scale)
-
-    resized = cv2.resize(frame_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
-
-    # center crop
-    x1 = (new_w - target) // 2
-    y1 = (new_h - target) // 2
-
-    cropped = resized[y1 : y1 + target, x1 : x1 + target]
-
-    return cropped
-
-
-class WebcamVideoStream:
-    def __init__(self, resolution=(320, 240), framerate=32, format="bgr", **kwargs):
-        # initialize the camera
-        self.camera = cv2.VideoCapture(0)
-        self.set_resolution(resolution)
-
-        # initialize the frame and the variable used to indicate
-        # if the thread should be stopped
-        self.frame = None
-        self.should_stop = False
-        self.is_stopped = True
-
-    def start(self):
-        # start the thread to read frames from the video stream
-        t = Thread(target=self.update, args=())
-        t.daemon = True
-        t.start()
-        self.is_stopped = False
-        return self
-
-    def update(self):
-        if self.camera.isOpened():
-            # keep looping infinitely until the thread is stopped
-            while not self.should_stop:
-                # grab the frame from the stream and clear the stream in
-                # preparation for the next frame
-                ret, stream = self.camera.read()
-                stream = cv2.resize(stream, (240, 240))
-                stream = cv2.cvtColor(stream, cv2.COLOR_BGR2RGB)
-                time.sleep(0.05)
-                self.frame = stream
-        self.is_stopped = True
-        self.should_stop = False
-
-    def read(self):
-        return self.frame
-
-    def stop(self):
-        # indicate that the thread should be stopped
-        self.should_stop = True
-
-        # Block in this thread until stopped
-        while not self.is_stopped:
-            pass
-
-    def set_resolution(self, resolution):
-        self.camera.set(3, resolution[0])
-        self.camera.set(4, resolution[1])
-
-    @staticmethod
-    def single_frame():
-        cap = cv2.VideoCapture(0)
-
-        # Warm-up, let auto-exposure settle in
-        for _ in range(30):
-            cap.read()
-            time.sleep(0.01)
-
-        ret, frame = cap.read()
-        cap.release()
-
-        if not ret:
-            raise RuntimeError("Camera capture failed")
-
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        frame = resize_and_center_crop_240(frame)
-        return frame
-
-
-class MockVideoStream:
-    def __init__(self):
-        self.frame = np.random.randint(0, 255, (240, 240, 3), dtype=np.uint8)
-
-    def start(self):
-        pass
-
-    def read(self):
-        return self.frame
-
-    def stop(self):
-        pass
-
-
-class MockST7789:
-    def __init__(self, width=240, height=240):
-        self.width = width
-        self.height = height
-
-    def show_image(self, image, x=0, y=0):
-        # Save image for the GUI to display
-        with open("display.bmp", "wb") as f:
-            f.write(image.tobytes())
-
-    def invert(self, enabled: bool = True):
-        pass
-
-
-class MockGPIO:
-    LOW = 0
-    HIGH = 1
-    BOARD = 10
-    IN = 1
-    PUD_UP = 22
-    RPI_INFO = {"P1_REVISION": 3}
-
-    def __init__(self):
-        self._states = {}
-        self.lock = threading.Lock()
-        self._initialized = False
-
-    def setmode(self, mode):
-        pass
-
-    def setup(self, pin, mode, pull_up_down=None):
-        if not self._initialized:
-            self.init()
-
-    def init(self, socket_path="gpio.sock"):
-        if self._initialized:
-            return
-        self._initialized = True
-        self._states = {}
-        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.sock.connect(socket_path)
-        threading.Thread(target=self._read_loop, daemon=True).start()
-
-    def _read_loop(self):
-        f = self.sock.makefile("r")
-        while True:
-            line = f.readline()
-            if not line:
-                break
-            try:
-                pin, val = line.strip().split()
-                with self.lock:
-                    self._states[int(pin)] = int(val)
-            except Exception:
-                pass
-
-    def input(self, pin):
-        with self.lock:
-            return self._states.get(pin, self.HIGH)
-
-
-# Mock patches to apply
-MOCK_PATCHES = [
-    ("seedsigner.hardware.displays.ST7789.ST7789", MockST7789),
-    ("seedsigner.hardware.displays.st7789_mpy.ST7789", MockST7789),
-    ("seedsigner.extras.local_display.ST7789", MockST7789),
-    ("seedsigner.hardware.pivideostream.PiVideoStream", MockVideoStream),
-    ("seedsigner.hardware.camera.Camera", MockCamera),
-]
-
-
-def setup_mocks():
-    """Apply all mock patches"""
-    patches = []
-
-    import sys
-
-    # Mock the entire picamera module before anything imports it
-    picamera_mock = Mock()
-    picamera_mock.PiCamera = Mock()
-    picamera_mock.array = Mock()
-    picamera_mock.array.PiRGBArray = Mock()
-    picamera_mock.PiCameraError = Exception
-    sys.modules["picamera"] = Mock()
-    sys.modules["picamera.array"] = picamera_mock.array
-
-    # Mock the RPi module and its components
-    rpi_mock = Mock()
-    rpi_mock.GPIO = MockGPIO()
-    sys.modules["RPi"] = rpi_mock
-    sys.modules["RPi.GPIO"] = rpi_mock.GPIO
-
-    # Mock spidev module
-    spidev_mock = Mock()
-    spidev_mock.SpiDev = Mock()
-    sys.modules["spidev"] = spidev_mock
-
-    for module_path, mock_obj in MOCK_PATCHES:
-        try:
-            patcher = patch(module_path, mock_obj)
-            patches.append(patcher)
-            patcher.start()
-        except (ImportError, AttributeError):
-            # Module doesn't exist or can't be patched, skip
-            continue
-
-    return patches
-
-
-class Window:
-    def __init__(self, HardwareButtons, width: int = 240, height: int = 240):
-        self.width = width
-        self.height = height
-        self.HardwareButtons = HardwareButtons
-
-        self.setup_sock()
-        self.run()
-
-    def run(self):
-        self.root = Tk()
-        self.root.title("SeedSigner")
-
-        self.root.geometry(f"{self.width*2}x{self.height}+240+240")
-        self.root.resizable(False, False)
-        self.root.configure(bg="orange")
-        self.root.attributes("-topmost", True)
-
-        self.label = Label(self.root)
-        self.label.pack()
-
-        self.joystick = Frame(self.root)
-        self.joystick.pack()
-        self.joystick.place(x=20, y=85)
-        self.joystick.configure(bg="orange")
-
-        pixel = PhotoImage(width=1, height=1)
-
-        self.btnL = Button(
-            self.joystick,
-            image=pixel,
-            width=20,
-            height=20,
-            command=self.HardwareButtons.KEY_LEFT_PIN,
-        )
-        self.btnL.grid(row=1, column=0)
-        self.bindButtonClick(self.btnL)
-
-        self.btnR = Button(
-            self.joystick,
-            image=pixel,
-            width=20,
-            height=20,
-            command=self.HardwareButtons.KEY_RIGHT_PIN,
-        )
-        self.btnR.grid(row=1, column=2)
-        self.bindButtonClick(self.btnR)
-
-        self.btnC = Button(
-            self.joystick,
-            image=pixel,
-            width=20,
-            height=20,
-            command=self.HardwareButtons.KEY_PRESS_PIN,
-        )
-        self.btnC.grid(row=1, column=1)
-        self.bindButtonClick(self.btnC)
-
-        self.btnU = Button(
-            self.joystick,
-            image=pixel,
-            width=20,
-            height=20,
-            command=self.HardwareButtons.KEY_UP_PIN,
-        )
-        self.btnU.grid(row=0, column=1)
-        self.bindButtonClick(self.btnU)
-
-        self.btnD = Button(
-            self.joystick,
-            image=pixel,
-            width=20,
-            height=20,
-            command=self.HardwareButtons.KEY_DOWN_PIN,
-        )
-        self.btnD.grid(row=2, column=1)
-        self.bindButtonClick(self.btnD)
-
-        self.btn1 = Button(
-            self.root,
-            image=pixel,
-            width=40,
-            height=20,
-            command=self.HardwareButtons.KEY1_PIN,
-        )
-        self.btn1.place(x=self.width + 160, y=60)
-        self.bindButtonClick(self.btn1)
-
-        self.btn2 = Button(
-            self.root,
-            image=pixel,
-            width=40,
-            height=20,
-            command=self.HardwareButtons.KEY2_PIN,
-        )
-        self.btn2.place(x=self.width + 160, y=116)
-        self.bindButtonClick(self.btn2)
-
-        self.btn3 = Button(
-            self.root,
-            image=pixel,
-            width=40,
-            height=20,
-            command=self.HardwareButtons.KEY3_PIN,
-        )
-        self.btn3.place(x=self.width + 160, y=172)
-        self.bindButtonClick(self.btn3)
-
-        def key_handler(event):
-            if event.keysym == "Up":
-                self.key_press(self.HardwareButtons.KEY_UP_PIN)
-            if event.keysym == "Down":
-                self.key_press(self.HardwareButtons.KEY_DOWN_PIN)
-            if event.keysym == "Left":
-                self.key_press(self.HardwareButtons.KEY_LEFT_PIN)
-            if event.keysym == "Right":
-                self.key_press(self.HardwareButtons.KEY_RIGHT_PIN)
-
-            if event.keysym in ("1", "KP_1"):
-                self.key_press(self.HardwareButtons.KEY1_PIN)
-            if event.keysym in ("2", "KP_2"):
-                self.key_press(self.HardwareButtons.KEY2_PIN)
-            if event.keysym in ("3", "KP_3"):
-                self.key_press(self.HardwareButtons.KEY3_PIN)
-
-            if event.keysym == "Return":
-                self.key_press(self.HardwareButtons.KEY_PRESS_PIN)
-
-        self.root.bind("<Key>", key_handler)
-
-        self.periodic_update()
-        self.root.mainloop()
-
-    def key_press(self, key):
-        self.set_input(key, 0)
-        time.sleep(0.1)
-        self.set_input(key, 1)
-
-    def bindButtonClick(self, btn):
-        btn.bind("<Button>", self.buttonDown)
-        btn.bind("<ButtonRelease>", self.buttonUp)
-
-    def buttonDown(self, btn):
-        key = btn.widget.config("command")[-1]
-        self.set_input(key, 0)
-
-    def buttonUp(self, btn):
-        key = btn.widget.config("command")[-1]
-        self.set_input(key, 1)
-
-    def load_raw_rgb(self, filename):
-        if not os.path.exists(filename):
-            return None
-        with open(filename, "rb") as f:
-            data = f.read()
-        img_array = np.frombuffer(data, dtype=np.uint8)
-        try:
-            img_array = img_array.reshape((self.height, self.width, 3))
-        except ValueError:
-            return None
-        return Image.fromarray(img_array, "RGB")
-
-    def periodic_update(self, filename="display.bmp", interval=10):
-        img = self.load_raw_rgb(filename)
-        if img:
-            self.tkimage = ImageTk.PhotoImage(img, master=self.root)
-            self.label.configure(image=self.tkimage)
-            self.label.image = self.tkimage
-        self.root.after(interval, lambda: self.periodic_update(filename, interval))
-
-    def set_input(self, key, val):
-        try:
-            msg = f"{key} {val}\n"
-            self.conn.sendall(msg.encode())
-        except Exception:
-            pass
-
-    def setup_sock(self, path="gpio.sock"):
-        if os.path.exists(path):
-            os.remove(path)
-
-        self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.server.bind(path)
-        self.server.listen(1)
-
-        threading.Thread(target=self.handle_sock, daemon=True).start()
-
-    def handle_sock(self):
-        while True:
-            self.conn, _ = self.server.accept()
-
-
-def run_gui():
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
-
-    # Setup mocks and import HardwareButtons after environment is set
-    setup_mocks()
-    from seedsigner.hardware.buttons import HardwareButtons
-
-    Window(HardwareButtons)
-
-
-def run_main():
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
-
-    # Setup mocks before importing the main module
-    setup_mocks()
-
-    from main import main
-
-    # Give GUI a moment to start up and create socket
-    time.sleep(0.5)
-
-    main()
-
-
-def signal_handler(sig, frame):
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    # Handle Ctrl+C
-    signal.signal(signal.SIGINT, signal_handler)
-
-    shutdown_event = multiprocessing.Event()
-
-    gui_process = multiprocessing.Process(target=run_gui, name="GUI")
-    main_process = multiprocessing.Process(target=run_main, name="Main")
-
-    try:
-        print("Starting GUI simulator...")
-        gui_process.start()
-
-        print("Starting SeedSigner main application...")
-        main_process.start()
-
-        while gui_process.is_alive() and main_process.is_alive():
-            try:
-                gui_process.join(timeout=0.1)
-                main_process.join(timeout=0.1)
-            except KeyboardInterrupt:
-                break
-
-    except KeyboardInterrupt:
-        pass
-
-    if main_process.is_alive():
-        main_process.terminate()
-        main_process.join(timeout=2)
-        if main_process.is_alive():
-            main_process.kill()
-
-    if gui_process.is_alive():
-        gui_process.terminate()
-        gui_process.join(timeout=2)
-        if gui_process.is_alive():
-            gui_process.kill()