StreamController · Core447 · Feb 19, 2026 · Oct 14, 2025 · Oct 14, 2025 · Feb 19, 2026
diff --git a/src/backend/DeckManagement/BetterDeck.py b/src/backend/DeckManagement/BetterDeck.py
@@ -2,7 +2,7 @@
 
 class BetterDeck():
     def __init__(self, deck: StreamDeck, rotation: int = 0):
-        self.deck = deck
+        self.deck: StreamDeck = deck
         self.rotation: int = rotation # [0, 90, 180, 270]
 
 

diff --git a/src/backend/DeckManagement/DeckManager.py b/src/backend/DeckManagement/DeckManager.py
@@ -27,6 +27,8 @@
 
 
 # Import own modules
+from src.backend.DeckManagement.Subclasses.RemoteDeckManager import RemoteDeckManager
+from src.backend.DeckManagement.Subclasses.RemoteDeck import RemoteDeck
 from src.backend.DeckManagement.BetterDeck import BetterDeck
 from src.backend.DeckManagement.DeckController import DeckController
 from src.backend.PageManagement.PageManagerBackend import PageManagerBackend
@@ -74,12 +76,42 @@ def __init__(self):
         if not self.beta_resume_mode:
             resume_thread.start()
 
+        self.remote_deck_manager = RemoteDeckManager(self)
+        if gl.settings_manager.get_app_settings().get("dev", {}).get("n-remote-decks", 0) > 0:
+            self.load_remote_decks()
+
+
+    def load_remote_decks(self):
+        print(" load remote decks")
+        self.remote_deck_manager.start()
+        for controller in self.remote_deck_manager.deck_controllers:
+            if controller in self.deck_controller:
+                continue
+
+            self.deck_controller.append(controller)
+            if recursive_hasattr(gl, "app.main_win.leftArea.deck_stack"):
+                # Add to deck stack
+                for controller in self.remote_deck_manager.deck_controllers:
+                    GLib.idle_add(gl.app.main_win.leftArea.deck_stack.add_page, controller)
+
+        if recursive_hasattr(gl, "app.main_win.sidebar.page_selector"):
+            GLib.idle_add(gl.app.main_win.sidebar.page_selector.update)
+
+        if recursive_hasattr(gl, "app.main_win"):
+            gl.app.main_win.check_for_errors()
+
+    def remove_remote_decks(self):
+        for controller in self.remote_deck_manager.deck_controllers:
+            self.remove_controller(controller)
+        gl.app.main_win.check_for_errors()
+        self.remote_deck_manager.stop()
+
     def load_decks(self):
         if not gl.argparser.parse_args().skip_load_hardware_decks:
             self.load_hardware_decks()
 
         self.load_fake_decks()
-
+    
     def load_hardware_decks(self):
         decks=DeviceManager().enumerate()
         for deck in decks:

diff --git a/src/backend/DeckManagement/Subclasses/RemoteDeck.py b/src/backend/DeckManagement/Subclasses/RemoteDeck.py
@@ -0,0 +1,113 @@
+"""
+Author: Core447
+Year: 2025
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+any later version.
+
+This programm comes with ABSOLUTELY NO WARRANTY!
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+"""
+
+from io import BytesIO
+import uuid
+from StreamDeck.Devices import StreamDeck
+from PIL import Image
+
+import globals as gl
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from src.backend.DeckManagement.Subclasses.RemoteDeckManager import RemoteDeckManager
+
+class RemoteDeck:
+    def __init__(self, remote_deck_manager: "RemoteDeckManager", serial_number = None, deck_type = None):
+        self.remote_deck_manager: "RemoteDeckManager" = remote_deck_manager
+        self.serial_number = serial_number
+        self._deck_type = deck_type
+
+        self.is_fake = True
+
+        self._key_layout = [3, 5]
+
+        self._is_touch = False
+        self._dial_count = 0
+
+        key_callback: callable = None
+
+    def deck_type(self):
+        return self._deck_type
+    def get_serial_number(self):
+        return self.serial_number
+    def key_layout(self):
+        return self._key_layout
+    def is_open(self):
+        return True
+    def reset(self):
+        return
+    def key_count(self):
+        return self.key_layout()[0] * self.key_layout()[1]
+    def set_key_callback(self, callback: callable):
+        self.key_callback = callback
+    def set_dial_callback(self, *args, **kwargs):
+        return
+    def set_touchscreen_callback(self, *args, **kwargs):
+        return
+    def set_brightness(self, *args, **kwargs):
+        return
+    def set_key_image(self, key: int, image: bytes):
+        pillow_image = Image.open(BytesIO(image))
+        pillow_image = pillow_image.rotate(180)
+        self.remote_deck_manager.send_button_image(key, pillow_image)
+    def key_states(self):
+        return [False] * self.key_count()
+    def key_image_format(self):
+        return {'size': (72, 72), 'format': 'JPEG', 'flip': (True, True), 'rotation': 0}
+    def id(self):
+        return str(uuid.uuid4())
+    def connected(self):
+        return True
+    def __enter__(self):
+        return self
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return True
+
+    def set_key_layout(self, layout: list[int]):
+        """
+        Sets and saves a new key layout
+        """
+        self._key_layout = layout
+
+        settings = gl.settings_manager.get_deck_settings(self.serial_number)
+        settings["key-layout"] = layout
+        gl.settings_manager.save_deck_settings(self.serial_number, settings)
+
+    def open(self, *args, **kwargs):
+        return
+
+    def close(self):
+        return
+
+    def is_visual(self) -> bool:
+        return True
+
+    def is_touch(self) -> bool:
+        return self.is_touch
+
+    def dial_count(self) -> int:
+        return self._dial_count
+
+    def touchscreen_image_format(self) -> dict:
+        return{
+            "size": (800, 100),
+            "format": "JPEG",
+            "flip": (False, False),
+            "rotation": 0
+        }
+
+    def set_touchscreen_image(self, *args, **kwargs):
+        return
diff --git a/src/backend/DeckManagement/Subclasses/RemoteDeckManager.py b/src/backend/DeckManagement/Subclasses/RemoteDeckManager.py
@@ -0,0 +1,97 @@
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import json
+import time
+import threading
+from datetime import datetime
+
+from src.backend.DeckManagement.DeckController import DeckController
+from src.backend.DeckManagement.Subclasses.RemoteDeck import RemoteDeck
+from src.backend.DeckManagement.Subclasses.RemoteDecksLocalServerHandler import create_handler
+
+PORT = 8765
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from src.backend.DeckManagement.DeckManager import DeckManager
+
+class RemoteDeckManager:
+    def __init__(self, deck_manager: "DeckManager"):
+        self.deck_manager = deck_manager
+        self.deck_controllers = []
+        self.httpd = None
+        self.server_thread = None
+        self.handler_class = None
+        self._is_running = False
+
+    def start(self):
+        if self._is_running:
+            return
+        self._is_running = True
+        # Start the webserver
+        self.start_server()
+
+        deck = RemoteDeck(self, serial_number="remote-deck-1", deck_type="Remote Deck 1")
+        self.deck_controllers.append(DeckController(self.deck_manager, deck))
+
+    def stop(self):
+        if not self._is_running:
+            return
+        self._is_running = False
+        # Stop the webserver
+        self.stop_server()
+
+        self.deck_controllers.clear()
+
+
+    def start_server(self):
+        """Start the HTTP server in a separate thread."""
+        server_address = ('0.0.0.0', PORT)
+        # Create a handler class with access to this RemoteDeckManager instance
+        self.handler_class = create_handler(self)
+        self.httpd = HTTPServer(server_address, self.handler_class)
+
+        print("=" * 60)
+        print("Local Network Python Server")
+        print("=" * 60)
+        print(f"Server started on port {PORT}")
+        print(f"Server time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        print("\nEndpoints:")
+        print(f"  GET  http://localhost:{PORT}/status")
+        print(f"  GET  http://localhost:{PORT}/images")
+        print(f"  GET  http://localhost:{PORT}/images/{{button_id}}")
+        print(f"  POST http://localhost:{PORT}/message")
+        print(f"  POST http://localhost:{PORT}/button")
+        print("\nWaiting for connections from Next.js web app...")
+        print("Press Ctrl+C to stop the server")
+        print("=" * 60)
+        print()
+
+        # Run server in a separate thread so it doesn't block
+        self.server_thread = threading.Thread(target=self.httpd.serve_forever, daemon=True)
+        self.server_thread.start()
+
+    def stop_server(self):
+        """Stop the HTTP server."""
+        if self.httpd:
+            print("\n\nStopping Remote Deck Server...")
+            self.httpd.shutdown()
+            self.httpd = None
+            if self.server_thread:
+                self.server_thread.join(timeout=5)
+                self.server_thread = None
+
+    def on_key_event(self, key: int, state: bool):
+        print(f"Remote Deck Manager: Key event: {key}, {state}")
+        print(self.deck_controllers)
+        for deck_controller in self.deck_controllers:
+            deck_controller.deck.deck.key_callback(deck_controller.deck.deck, key, state)
+
+    def send_button_image(self, button_id: int, image):
+        """
+        Send a PIL image for a specific button to the browser.
+
+        Args:
+            button_id: The button identifier (e.g., row * 5 + col)
+            image: PIL Image object
+        """
+        if self.handler_class:
+            self.handler_class.send_button_image(button_id, image)