@@ -5,7 +5,9 @@
 from __future__ import annotations
 
 import glob
+import logging
 import os
+import threading
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
 from enum import Enum, auto
@@ -18,6 +20,125 @@ class GenTLDiscoveryPolicy(Enum):
     RAISE_IF_MULTIPLE = auto()  # if > N candidates, raise an error to avoid ambiguity (forces explicit config)
 
 
+try:  # pragma: no cover - optional dependency
+    from harvesters.core import Harvester  # type: ignore
+except Exception:  # pragma: no cover - optional dependency
+    Harvester = None  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+
+class SharedHarvesterEntry:
+    """
+    A shared Harvester instance keyed by a canonical tuple of CTI files.
+    """
+
+    def __init__(self, cti_files: list[str]):
+        if Harvester is None:  # pragma: no cover
+            raise RuntimeError(
+                "The 'harvesters' package is required for the GenTL backend. Install it via 'pip install harvesters'."
+            )
+
+        self.lock = threading.RLock()
+        self.key = tuple(sorted(_normalize_path(p, casefold_windows=True) for p in cti_files))
+        self.refcount = 0
+        self.harvester = Harvester()
+        self.loaded_files: list[str] = []
+        self.failed_files: dict[str, str] = {}
+
+        for cti in self.key:
+            try:
+                self.harvester.add_file(cti)
+                self.loaded_files.append(cti)
+            except Exception as e:
+                logger.warning(f"Failed to load CTI file: {cti}. Skipping.")
+                self.failed_files[cti] = str(e)
+
+        if not self.loaded_files:
+            e = RuntimeError("No GenTL producer (.cti) could be loaded by shared Harvester.")
+            self._raise_and_reset_harvester(e)
+
+        # Initial device enumeration.
+        try:
+            self.harvester.update()
+        except Exception as e:
+            self._raise_and_reset_harvester(e)
+
+    def _raise_and_reset_harvester(self, exc: Exception) -> None:
+        exc.loaded_files = self.loaded_files[:]
+        exc.failed_files = dict(self.failed_files)
+        try:
+            self.harvester.reset()
+        except Exception:
+            pass
+        raise exc
+
+
+class SharedHarvesterPool:
+    """
+    Process-local pool of shared Harvester instances.
+
+    Keyed by the canonicalized CTI file set.
+    """
+
+    _lock = threading.RLock()
+    _entries: dict[tuple[str, ...], SharedHarvesterEntry] = {}
+
+    @classmethod
+    def acquire(cls, cti_files: list[str]) -> SharedHarvesterEntry:
+        key = tuple(sorted(_normalize_path(p, casefold_windows=True) for p in cti_files))
+        with cls._lock:
+            entry = cls._entries.get(key)
+            if entry is None:
+                entry = SharedHarvesterEntry(list(key))
+                cls._entries[key] = entry
+            entry.refcount += 1
+            return entry
+
+    @classmethod
+    def release(cls, entry: SharedHarvesterEntry | None) -> None:
+        if entry is None:
+            return
+
+        with cls._lock:
+            current = cls._entries.get(entry.key)
+            if current is None:
+                # Already released/reset.
+                return
+
+            current.refcount -= 1
+            if current.refcount > 0:
+                return
+
+            try:
+                with current.lock:
+                    try:
+                        current.harvester.reset()
+                    except Exception:
+                        pass
+            finally:
+                cls._entries.pop(entry.key, None)
+
+    @classmethod
+    def refresh(cls, entry: SharedHarvesterEntry | None) -> None:
+        """
+        Optional helper when callers want to re-enumerate the device list
+        on an already-shared Harvester instance.
+        """
+        if entry is None:
+            return
+        with entry.lock:
+            entry.harvester.update()
+
+    @classmethod
+    def get_refcount(cls, entry: SharedHarvesterEntry | None) -> int:
+        if entry is None:
+            return 0
+        with cls._lock:
+            current = cls._entries.get(entry.key)
+            return int(current.refcount) if current is not None else 0
+
+
 @dataclass
 class CTIDiscoveryDiagnostics:
     explicit_files: list[str] = field(default_factory=list)
@@ -81,18 +202,18 @@ def _expand_user_and_env(value: str) -> str:
     return s
 
 
-def _normalize_path(p: str) -> str:
-    """
-    Normalize a filesystem path in a cross-platform way:
-    - expands ~ and environment variables
-    - resolves to absolute where possible (without requiring existence)
-    """
+def _normalize_path(p: str, *, casefold_windows: bool = False) -> str:
     expanded = _expand_user_and_env(p)
     pp = Path(expanded)
     try:
-        return str(pp.resolve(strict=False))
+        out = str(pp.resolve(strict=False))
     except Exception:
-        return str(pp.absolute())
+        out = str(pp.absolute())
+
+    if casefold_windows:
+        out = os.path.normcase(out)
+
+    return out
 
 
 def _iter_cti_files_in_dir(directory: str, recursive: bool = False) -> Iterable[str]:
 
@@ -454,10 +454,14 @@ def apply_detected_identity(cam: CameraSettings, detected: DetectedCamera, backe
 def camera_identity_key(cam: CameraSettings) -> tuple:
     backend = (cam.backend or "").lower()
     props = cam.properties if isinstance(cam.properties, dict) else {}
-    ns = props.get(backend, {}) if isinstance(props, dict) else {}
-    device_id = ns.get("device_id")
+    ns = props.get(backend, {}) if isinstance(props.get(backend), dict) else {}
 
-    # Prefer stable identity if present, otherwise fallback
+    device_id = ns.get("device_id")
     if device_id:
-        return (backend, "device_id", device_id)
+        return (backend, "device_id", str(device_id))
+
+    serial = ns.get("serial_number") or ns.get("device_serial_number") or ns.get("serial")
+    if serial:
+        return (backend, "serial", str(serial))
+
     return (backend, "index", int(cam.index))
@@ -3,6 +3,7 @@
 
 import argparse
 import logging
+import os
 import signal
 import sys
 
@@ -54,6 +55,32 @@ def _sigint_handler(_signum, _frame) -> None:
     app._sig_timer = sig_timer  # Store on app to keep it alive and allow cleanup on exit
 
 
+def configure_logging(debug: bool = False) -> None:
+    """Configure local application logging."""
+    env_debug = os.environ.get("DLCLIVEGUI_DEBUG_LOGGING", "").strip().lower() in (
+        "1",
+        "true",
+        "yes",
+        "on",
+        "debug",
+    )
+
+    enabled = bool(debug or env_debug)
+    level = logging.DEBUG if enabled else logging.INFO
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s.%(msecs)03d %(levelname)-8s [%(threadName)s] %(name)s:%(lineno)d - %(message)s",
+        datefmt="%H:%M:%S",
+        force=True,
+    )
+
+    logging.getLogger("dlclivegui").setLevel(level)
+
+    if enabled:
+        logging.debug("Debug logging enabled.")
+
+
 def parse_args(argv=None):
     if argv is None:
         argv = sys.argv[1:]
@@ -77,12 +104,13 @@ def parse_args(argv=None):
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument("--no-art", action="store_true", help="Disable ASCII art in help and when launching.")
+    parser.add_argument("--debug-log", action="store_true", help="Enable debug logging.")
     return parser.parse_known_args(argv)
 
 
 def main() -> None:
     args, _unknown = parse_args()
-
+    configure_logging(debug=args.debug_log)
     logging.info("Starting DeepLabCut-Live GUI...")
 
     # If you want a startup banner, PRINT it (not log), and only in TTY contexts.