From 81a1986ef8ab4e5805922436a7db30f5dd9efb43 Mon Sep 17 00:00:00 2001
From: Kenneth Estanislao <hacksider@gmail.com>
Date: Fri, 15 May 2026 16:33:27 +0800
Subject: [PATCH] Changed to pyqtUI

Standardizing the UI from quickstart to github version
---
 modules/metadata.py |    2 +-
 modules/ui.py       | 2784 +++++++++++++++++++++----------------------
 requirements.txt    |    3 +-
 run.py              |    3 -
 4 files changed, 1376 insertions(+), 1416 deletions(-)

diff --git a/modules/metadata.py b/modules/metadata.py
index bc6598d..9bc9ba9 100644
--- a/modules/metadata.py
+++ b/modules/metadata.py
@@ -1,3 +1,3 @@
 name = 'Deep-Live-Cam'
-version = '2.1.2'
+version = '2.1.5'
 edition = 'GitHub Edition'
\ No newline at end of file
diff --git a/modules/ui.py b/modules/ui.py
index c3c672b..35b0c13 100644
--- a/modules/ui.py
+++ b/modules/ui.py
@@ -1,77 +1,90 @@
+"""PySide6 UI for Deep-Live-Cam.
+
+Public API kept stable for the rest of the codebase:
+    init(start, destroy, lang) -> _Window
+        Returned object has .mainloop() that core.py calls.
+    update_status(text)
+        Thread-safe; routed through Qt signal when called off-UI.
+    check_and_ignore_nsfw(target, destroy=None) -> bool
+"""
+
+from __future__ import annotations
+
 import os
-import webbrowser
-import customtkinter as ctk
-from typing import Callable, Tuple
-import cv2
-from modules.gpu_processing import gpu_cvt_color, gpu_resize, gpu_flip
-from PIL import Image, ImageOps
-import time
-import json
+import platform
 import queue
+import sys
+import tempfile
 import threading
+import time
+import webbrowser
+from typing import Callable, List, Optional, Tuple
+
+import cv2
 import numpy as np
 import requests
-import tempfile
+from PIL import Image, ImageOps
+from PySide6.QtCore import (
+    QObject,
+    QThread,
+    QTimer,
+    Qt,
+    Signal,
+)
+from PySide6.QtGui import QImage, QPixmap
+from PySide6.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QComboBox,
+    QDialog,
+    QFileDialog,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QPushButton,
+    QScrollArea,
+    QSizePolicy,
+    QSlider,
+    QVBoxLayout,
+    QWidget,
+)
+
 import modules.globals
 import modules.metadata
+from modules.capturer import get_video_frame, get_video_frame_total
 from modules.face_analyser import (
-    get_one_face,
-    get_many_faces,
-    detect_one_face_fast,
+    add_blank_map,
     detect_many_faces_fast,
+    detect_one_face_fast,
+    get_one_face,
     get_unique_faces_from_target_image,
     get_unique_faces_from_target_video,
-    add_blank_map,
     has_valid_map,
     simplify_maps,
 )
-from modules.capturer import get_video_frame, get_video_frame_total
+from modules.gettext import LanguageManager
+from modules.gpu_processing import gpu_cvt_color, gpu_flip, gpu_resize
 from modules.processors.frame.core import get_frame_processors_modules
 from modules.utilities import (
+    has_image_extension,
     is_image,
     is_video,
-    resolve_relative_path,
-    has_image_extension,
 )
 from modules.video_capture import VideoCapturer
-from modules.gettext import LanguageManager
-from modules.ui_tooltip import ToolTip
-from modules import globals
-import platform
 
 if platform.system() == "Windows":
     from pygrabber.dshow_graph import FilterGraph
 
-# --- Tk 9.0 compatibility patch ---
-# In Tk 9.0, Menu.index("end") returns "" instead of raising TclError
-# when the menu is empty. CustomTkinter's CTkOptionMenu doesn't handle
-# this, causing crashes. This patch adds the missing guard.
-try:
-    from customtkinter.windows.widgets.core_widget_classes import DropdownMenu as _DropdownMenu
+import json
 
-    _original_add_menu_commands = _DropdownMenu._add_menu_commands
 
-    def _patched_add_menu_commands(self, *args, **kwargs):
-        try:
-            end_index = self._menu.index("end")
-            if end_index == "" or end_index is None:
-                return
-        except Exception:
-            pass
-        _original_add_menu_commands(self, *args, **kwargs)
+# ─── constants ────────────────────────────────────────────────────────────
 
-    _DropdownMenu._add_menu_commands = _patched_add_menu_commands
-except (ImportError, AttributeError):
-    pass  # CustomTkinter version doesn't have this class path
-# --- End Tk 9.0 patch ---
+ROOT_HEIGHT = 820
+ROOT_WIDTH = 640
 
-ROOT = None
-POPUP = None
-POPUP_LIVE = None
-ROOT_HEIGHT = 800
-ROOT_WIDTH = 600
-
-PREVIEW = None
 PREVIEW_MAX_HEIGHT = 700
 PREVIEW_MAX_WIDTH = 1200
 PREVIEW_DEFAULT_WIDTH = 640
@@ -79,52 +92,211 @@ PREVIEW_DEFAULT_HEIGHT = 360
 
 POPUP_WIDTH = 750
 POPUP_HEIGHT = 810
-POPUP_SCROLL_WIDTH = (740,)
+POPUP_SCROLL_WIDTH = 720
 POPUP_SCROLL_HEIGHT = 700
 
 POPUP_LIVE_WIDTH = 900
 POPUP_LIVE_HEIGHT = 820
-POPUP_LIVE_SCROLL_WIDTH = (890,)
+POPUP_LIVE_SCROLL_WIDTH = 870
 POPUP_LIVE_SCROLL_HEIGHT = 700
 
-MAPPER_PREVIEW_MAX_HEIGHT = 100
-MAPPER_PREVIEW_MAX_WIDTH = 100
-
-DEFAULT_BUTTON_WIDTH = 200
-DEFAULT_BUTTON_HEIGHT = 40
-
-RECENT_DIRECTORY_SOURCE = None
-RECENT_DIRECTORY_TARGET = None
-RECENT_DIRECTORY_OUTPUT = None
-
-_ = None
-preview_label = None
-preview_slider = None
-source_label = None
-target_label = None
-status_label = None
-popup_status_label = None
-popup_status_label_live = None
-source_label_dict = {}
-source_label_dict_live = {}
-target_label_dict_live = {}
-
-img_ft, vid_ft = modules.globals.file_types
+MAPPER_PREVIEW_SIZE = 100
+SOURCE_TARGET_PREVIEW_SIZE = 200
 
 
-def init(start: Callable[[], None], destroy: Callable[[], None], lang: str) -> ctk.CTk:
-    global ROOT, PREVIEW, _
+# ─── modern dark stylesheet ───────────────────────────────────────────────
 
-    lang_manager = LanguageManager(lang)
-    _ = lang_manager._
-    ROOT = create_root(start, destroy)
-    PREVIEW = create_preview(ROOT)
+QSS = """
+QMainWindow, QDialog { background-color: #1e1e1e; color: #e6e6e6; }
+QWidget { color: #e6e6e6; font-family: "Segoe UI", "SF Pro Display", "Helvetica Neue", Arial, sans-serif; font-size: 11pt; }
 
-    return ROOT
+QGroupBox {
+    background-color: #262626;
+    border: 1px solid #333333;
+    border-radius: 10px;
+    margin-top: 14px;
+    padding-top: 18px;
+    font-weight: 600;
+}
+QGroupBox::title {
+    subcontrol-origin: margin;
+    subcontrol-position: top left;
+    padding: 0 8px;
+    color: #9ec5ff;
+}
+
+QPushButton {
+    background-color: #2d6cdf;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    padding: 8px 16px;
+    font-weight: 600;
+}
+QPushButton:hover  { background-color: #3a7af0; }
+QPushButton:pressed{ background-color: #1d57c2; }
+QPushButton:disabled { background-color: #444; color: #888; }
+QPushButton#secondary {
+    background-color: #3a3a3a;
+}
+QPushButton#secondary:hover { background-color: #4a4a4a; }
+QPushButton#danger { background-color: #c2412d; }
+QPushButton#danger:hover  { background-color: #d8523c; }
+
+QComboBox {
+    background-color: #2a2a2a;
+    border: 1px solid #404040;
+    border-radius: 6px;
+    padding: 6px 10px;
+    min-height: 24px;
+}
+QComboBox:hover { border-color: #2d6cdf; }
+QComboBox QAbstractItemView {
+    background-color: #2a2a2a;
+    selection-background-color: #2d6cdf;
+    border: 1px solid #404040;
+}
+
+QCheckBox {
+    spacing: 8px;
+    padding: 4px 0;
+}
+QCheckBox::indicator {
+    width: 36px; height: 18px;
+    border-radius: 9px;
+    background-color: #3a3a3a;
+}
+QCheckBox::indicator:checked {
+    background-color: #2d6cdf;
+}
+
+QSlider::groove:horizontal {
+    height: 6px;
+    background: #3a3a3a;
+    border-radius: 3px;
+}
+QSlider::handle:horizontal {
+    background: #ffffff;
+    width: 16px; height: 16px;
+    margin: -5px 0;
+    border-radius: 8px;
+    border: 1px solid #cccccc;
+}
+QSlider::sub-page:horizontal {
+    background: #2d6cdf;
+    border-radius: 3px;
+}
+
+QLabel#imageDrop {
+    background-color: #2a2a2a;
+    border: 2px dashed #444;
+    border-radius: 8px;
+}
+QLabel#statusLabel {
+    color: #b9b9b9;
+    font-size: 10pt;
+    font-style: italic;
+}
+QLabel#linkLabel {
+    color: #6ea8ff;
+    text-decoration: underline;
+}
+
+QScrollArea { border: none; background: transparent; }
+
+QFrame#card {
+    background-color: #262626;
+    border-radius: 10px;
+}
+"""
+
+
+# ─── module-level state ───────────────────────────────────────────────────
+
+_APP: Optional[QApplication] = None
+_MAIN: Optional["MainWindow"] = None
+_PREVIEW: Optional["PreviewWindow"] = None
+_WEBCAM_PREVIEW: Optional["WebcamPreviewWindow"] = None
+_MAPPER: Optional["MapperDialog"] = None
+_LIVE_MAPPER: Optional["LiveMapperDialog"] = None
+_LANG: Optional[LanguageManager] = None
+_BRIDGE: Optional["_UIBridge"] = None
+
+
+def _(text: str) -> str:
+    """Translate via LanguageManager; falls back to identity."""
+    if _LANG is None:
+        return text
+    return _LANG._(text)
+
+
+# Preserve original cwd state for file dialogs.
+_RECENT_SOURCE_DIR: Optional[str] = None
+_RECENT_TARGET_DIR: Optional[str] = None
+_RECENT_OUTPUT_DIR: Optional[str] = None
+
+
+# ─── image utilities ─────────────────────────────────────────────────────
+
+
+def fit_image_to_size(image, width: int, height: int):
+    """BGR ndarray → BGR ndarray scaled to fit within (width, height)."""
+    if width is None and height is None or width <= 0 or height <= 0:
+        return image
+    h, w = image.shape[:2]
+    ratio_w = width / w
+    ratio_h = height / h
+    ratio = min(ratio_w, ratio_h)
+    new_size = (max(1, int(w * ratio)), max(1, int(h * ratio)))
+    return gpu_resize(image, dsize=new_size)
+
+
+def _bgr_to_qpixmap(bgr: np.ndarray) -> QPixmap:
+    """Zero-copy BGR ndarray → QPixmap."""
+    h, w = bgr.shape[:2]
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+    qimg = QImage(rgb.data, w, h, w * 3, QImage.Format.Format_RGB888).copy()
+    return QPixmap.fromImage(qimg)
+
+
+def _pil_to_qpixmap(image: Image.Image) -> QPixmap:
+    """PIL.Image → QPixmap."""
+    image = image.convert("RGBA")
+    data = image.tobytes("raw", "RGBA")
+    qimg = QImage(data, image.width, image.height, QImage.Format.Format_RGBA8888)
+    return QPixmap.fromImage(qimg.copy())
+
+
+def render_image_preview(image_path: str, size: Tuple[int, int]) -> QPixmap:
+    image = Image.open(image_path)
+    if size:
+        image = ImageOps.fit(image, size, Image.LANCZOS)
+    return _pil_to_qpixmap(image)
+
+
+def render_video_preview(
+    video_path: str, size: Tuple[int, int], frame_number: int = 0
+) -> Optional[QPixmap]:
+    capture = cv2.VideoCapture(video_path)
+    try:
+        if frame_number:
+            capture.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+        has_frame, frame = capture.read()
+        if not has_frame:
+            return None
+        image = Image.fromarray(gpu_cvt_color(frame, cv2.COLOR_BGR2RGB))
+        if size:
+            image = ImageOps.fit(image, size, Image.LANCZOS)
+        return _pil_to_qpixmap(image)
+    finally:
+        capture.release()
+
+
+# ─── persistence ─────────────────────────────────────────────────────────
 
 
 def save_switch_states():
-    switch_states = {
+    state = {
         "keep_fps": modules.globals.keep_fps,
         "keep_audio": modules.globals.keep_audio,
         "keep_frames": modules.globals.keep_frames,
@@ -141,1424 +313,1216 @@ def save_switch_states():
         "show_mouth_mask_box": modules.globals.show_mouth_mask_box,
         "mouth_mask_size": modules.globals.mouth_mask_size,
     }
-    with open("switch_states.json", "w") as f:
-        json.dump(switch_states, f)
+    try:
+        with open("switch_states.json", "w") as f:
+            json.dump(state, f)
+    except OSError:
+        pass
 
 
 def load_switch_states():
     try:
         with open("switch_states.json", "r") as f:
-            switch_states = json.load(f)
-        modules.globals.keep_fps = switch_states.get("keep_fps", True)
-        modules.globals.keep_audio = switch_states.get("keep_audio", True)
-        modules.globals.keep_frames = switch_states.get("keep_frames", False)
-        modules.globals.many_faces = switch_states.get("many_faces", False)
-        modules.globals.map_faces = switch_states.get("map_faces", False)
-        modules.globals.poisson_blend = switch_states.get("poisson_blend", False)
-        modules.globals.color_correction = switch_states.get("color_correction", False)
-        modules.globals.nsfw_filter = switch_states.get("nsfw_filter", False)
-        modules.globals.live_mirror = switch_states.get("live_mirror", False)
-        modules.globals.live_resizable = switch_states.get("live_resizable", False)
-        modules.globals.fp_ui = switch_states.get("fp_ui", {"face_enhancer": False})
-        modules.globals.show_fps = switch_states.get("show_fps", False)
-        modules.globals.mouth_mask_size = switch_states.get("mouth_mask_size", 0.0)
-        # mouth_mask is driven by the slider: on if size > 0, off if 0
+            state = json.load(f)
+        modules.globals.keep_fps = state.get("keep_fps", True)
+        modules.globals.keep_audio = state.get("keep_audio", True)
+        modules.globals.keep_frames = state.get("keep_frames", False)
+        modules.globals.many_faces = state.get("many_faces", False)
+        modules.globals.map_faces = state.get("map_faces", False)
+        modules.globals.poisson_blend = state.get("poisson_blend", False)
+        modules.globals.color_correction = state.get("color_correction", False)
+        modules.globals.nsfw_filter = state.get("nsfw_filter", False)
+        modules.globals.live_mirror = state.get("live_mirror", False)
+        modules.globals.live_resizable = state.get("live_resizable", False)
+        modules.globals.fp_ui = state.get("fp_ui", {"face_enhancer": False})
+        modules.globals.show_fps = state.get("show_fps", False)
+        modules.globals.mouth_mask_size = state.get("mouth_mask_size", 0.0)
         modules.globals.mouth_mask = modules.globals.mouth_mask_size > 0
-        modules.globals.show_mouth_mask_box = False  # always start hidden
+        modules.globals.show_mouth_mask_box = False
     except FileNotFoundError:
-        # If the file doesn't exist, use default values
+        pass
+    except (OSError, json.JSONDecodeError):
         pass
 
 
-def create_root(start: Callable[[], None], destroy: Callable[[], None]) -> ctk.CTk:
-    global source_label, target_label, status_label, show_fps_switch
-
-    load_switch_states()
-
-    ctk.deactivate_automatic_dpi_awareness()
-    ctk.set_appearance_mode("system")
-    ctk.set_default_color_theme(resolve_relative_path("ui.json"))
-
-    root = ctk.CTk()
-    root.minsize(ROOT_WIDTH, ROOT_HEIGHT)
-    root.title(
-        f"{modules.metadata.name} {modules.metadata.version} {modules.metadata.edition}"
-    )
-    root.configure()
-    root.protocol("WM_DELETE_WINDOW", lambda: destroy())
-
-    source_label = ctk.CTkLabel(root, text=None)
-    source_label.place(relx=0.1, rely=0.05, relwidth=0.275, relheight=0.225)
-
-    target_label = ctk.CTkLabel(root, text=None)
-    target_label.place(relx=0.6, rely=0.05, relwidth=0.275, relheight=0.225)
-
-    select_face_button = ctk.CTkButton(
-        root, text=_("Select a face"), cursor="hand2", command=lambda: select_source_path()
-    )
-    select_face_button.place(relx=0.1, rely=0.30, relwidth=0.24, relheight=0.1)
-    ToolTip(select_face_button, _("Choose the source face image to swap onto the target"))
-
-    random_face_button = ctk.CTkButton(
-        root, text="🔄", cursor="hand2", width=30, command=lambda: fetch_random_face()
-    )
-    random_face_button.place(relx=0.35, rely=0.30, relwidth=0.05, relheight=0.1)
-    ToolTip(random_face_button, _("Get a random face from thispersondoesnotexist.com"))
-
-    swap_faces_button = ctk.CTkButton(
-        root, text="↔", cursor="hand2", command=lambda: swap_faces_paths()
-    )
-    swap_faces_button.place(relx=0.45, rely=0.30, relwidth=0.1, relheight=0.1)
-    ToolTip(swap_faces_button, _("Swap source and target images"))
-
-    select_target_button = ctk.CTkButton(
-        root,
-        text=_("Select a target"),
-        cursor="hand2",
-        command=lambda: select_target_path(),
-    )
-    select_target_button.place(relx=0.6, rely=0.30, relwidth=0.3, relheight=0.1)
-    ToolTip(select_target_button, _("Choose the target image or video to apply face swap to"))
-
-    keep_fps_value = ctk.BooleanVar(value=modules.globals.keep_fps)
-    keep_fps_checkbox = ctk.CTkSwitch(
-        root,
-        text=_("Keep fps"),
-        variable=keep_fps_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "keep_fps", keep_fps_value.get()),
-            save_switch_states(),
-        ),
-    )
-    keep_fps_checkbox.place(relx=0.1, rely=0.42)
-    ToolTip(keep_fps_checkbox, _("Output video keeps the original frame rate"))
-
-    keep_frames_value = ctk.BooleanVar(value=modules.globals.keep_frames)
-    keep_frames_switch = ctk.CTkSwitch(
-        root,
-        text=_("Keep frames"),
-        variable=keep_frames_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "keep_frames", keep_frames_value.get()),
-            save_switch_states(),
-        ),
-    )
-    keep_frames_switch.place(relx=0.1, rely=0.47)
-    ToolTip(keep_frames_switch, _("Keep extracted frames on disk after processing"))
-
-    keep_audio_value = ctk.BooleanVar(value=modules.globals.keep_audio)
-    keep_audio_switch = ctk.CTkSwitch(
-        root,
-        text=_("Keep audio"),
-        variable=keep_audio_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "keep_audio", keep_audio_value.get()),
-            save_switch_states(),
-        ),
-    )
-    keep_audio_switch.place(relx=0.6, rely=0.42)
-    ToolTip(keep_audio_switch, _("Copy audio track from the source video to output"))
-
-    many_faces_value = ctk.BooleanVar(value=modules.globals.many_faces)
-    many_faces_switch = ctk.CTkSwitch(
-        root,
-        text=_("Many faces"),
-        variable=many_faces_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "many_faces", many_faces_value.get()),
-            save_switch_states(),
-        ),
-    )
-    many_faces_switch.place(relx=0.6, rely=0.47)
-    ToolTip(many_faces_switch, _("Swap every detected face, not just the primary one"))
-
-    color_correction_value = ctk.BooleanVar(value=modules.globals.color_correction)
-    color_correction_switch = ctk.CTkSwitch(
-        root,
-        text=_("Fix Blueish Cam"),
-        variable=color_correction_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "color_correction", color_correction_value.get()),
-            save_switch_states(),
-        ),
-    )
-    color_correction_switch.place(relx=0.6, rely=0.57)
-    ToolTip(color_correction_switch, _("Fix blue/green color cast from some webcams"))
-
-    #    nsfw_value = ctk.BooleanVar(value=modules.globals.nsfw_filter)
-    #    nsfw_switch = ctk.CTkSwitch(root, text='NSFW filter', variable=nsfw_value, cursor='hand2', command=lambda: setattr(modules.globals, 'nsfw_filter', nsfw_value.get()))
-    #    nsfw_switch.place(relx=0.6, rely=0.7)
-
-    map_faces = ctk.BooleanVar(value=modules.globals.map_faces)
-    map_faces_switch = ctk.CTkSwitch(
-        root,
-        text=_("Map faces"),
-        variable=map_faces,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "map_faces", map_faces.get()),
-            save_switch_states(),
-            close_mapper_window() if not map_faces.get() else None
-        ),
-    )
-    map_faces_switch.place(relx=0.1, rely=0.52)
-    ToolTip(map_faces_switch, _("Manually assign which source face maps to which target face"))
-
-    poisson_blend_value = ctk.BooleanVar(value=modules.globals.poisson_blend)
-    poisson_blend_switch = ctk.CTkSwitch(
-        root,
-        text=_("Poisson Blend"),
-        variable=poisson_blend_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "poisson_blend", poisson_blend_value.get()),
-            save_switch_states(),
-        ),
-    )
-    poisson_blend_switch.place(relx=0.1, rely=0.57)
-    ToolTip(poisson_blend_switch, _("Blend face edges smoothly using Poisson blending"))
-
-    show_fps_value = ctk.BooleanVar(value=modules.globals.show_fps)
-    show_fps_switch = ctk.CTkSwitch(
-        root,
-        text=_("Show FPS"),
-        variable=show_fps_value,
-        cursor="hand2",
-        command=lambda: (
-            setattr(modules.globals, "show_fps", show_fps_value.get()),
-            save_switch_states(),
-        ),
-    )
-    show_fps_switch.place(relx=0.6, rely=0.52)
-    ToolTip(show_fps_switch, _("Display frames-per-second counter on the live preview"))
-
-    # mouth_mask and show_mouth_mask_box are auto-controlled by the Mouth Mask slider
-    mouth_mask_var = ctk.BooleanVar(value=modules.globals.mouth_mask)
-    show_mouth_mask_box_var = ctk.BooleanVar(value=modules.globals.show_mouth_mask_box)
-
-    start_button = ctk.CTkButton(
-        root, text=_("Start"), cursor="hand2", command=lambda: analyze_target(start, root)
-    )
-    start_button.place(relx=0.15, rely=0.78, relwidth=0.2, relheight=0.04)
-    ToolTip(start_button, _("Begin processing the target image/video with selected face"))
-
-    stop_button = ctk.CTkButton(
-        root, text=_("Destroy"), cursor="hand2", command=lambda: destroy()
-    )
-    stop_button.place(relx=0.4, rely=0.78, relwidth=0.2, relheight=0.04)
-    ToolTip(stop_button, _("Stop processing and close the application"))
-
-    preview_button = ctk.CTkButton(
-        root, text=_("Preview"), cursor="hand2", command=lambda: toggle_preview()
-    )
-    preview_button.place(relx=0.65, rely=0.78, relwidth=0.2, relheight=0.04)
-    ToolTip(preview_button, _("Show/hide a preview of the processed output"))
-
-    # --- Camera Selection ---
-    camera_label = ctk.CTkLabel(root, text=_("Select Camera:"))
-    camera_label.place(relx=0.1, rely=0.83, relwidth=0.2, relheight=0.03)
-
-    available_cameras = get_available_cameras()
-    camera_indices, camera_names = available_cameras
-
-    if not camera_names or camera_names[0] == "No cameras found":
-        camera_variable = ctk.StringVar(value="No cameras found")
-        camera_optionmenu = ctk.CTkOptionMenu(
-            root,
-            variable=camera_variable,
-            values=["No cameras found"],
-            state="disabled",
-        )
-    else:
-        camera_variable = ctk.StringVar(value=camera_names[0])
-        camera_optionmenu = ctk.CTkOptionMenu(
-            root, variable=camera_variable, values=camera_names
-        )
-
-    camera_optionmenu.place(relx=0.35, rely=0.83, relwidth=0.25, relheight=0.03)
-    ToolTip(camera_optionmenu, _("Select which camera to use for live mode"))
-
-    live_button = ctk.CTkButton(
-        root,
-        text=_("Live"),
-        cursor="hand2",
-        command=lambda: webcam_preview(
-            root,
-            (
-                camera_indices[camera_names.index(camera_variable.get())]
-                if camera_names and camera_names[0] != "No cameras found"
-                else None
-            ),
-        ),
-        state=(
-            "normal"
-            if camera_names and camera_names[0] != "No cameras found"
-            else "disabled"
-        ),
-    )
-    live_button.place(relx=0.65, rely=0.83, relwidth=0.2, relheight=0.03)
-    ToolTip(live_button, _("Start real-time face swap using webcam"))
-    # --- End Camera Selection ---
-
-    # --- Face Enhancer Dropdown ---
-    enhancer_options = ["None", "GFPGAN", "GPEN-512", "GPEN-256"]
-    enhancer_key_map = {
-        "None": None,
-        "GFPGAN": "face_enhancer",
-        "GPEN-512": "face_enhancer_gpen512",
-        "GPEN-256": "face_enhancer_gpen256",
-    }
-
-    # Determine initial value from current fp_ui state
-    initial_enhancer = "None"
-    if modules.globals.fp_ui.get("face_enhancer", False):
-        initial_enhancer = "GFPGAN"
-    elif modules.globals.fp_ui.get("face_enhancer_gpen512", False):
-        initial_enhancer = "GPEN-512"
-    elif modules.globals.fp_ui.get("face_enhancer_gpen256", False):
-        initial_enhancer = "GPEN-256"
-
-    enhancer_variable = ctk.StringVar(value=initial_enhancer)
-
-    def on_enhancer_change(choice: str):
-        # Disable all enhancers first
-        for key in ["face_enhancer", "face_enhancer_gpen256", "face_enhancer_gpen512"]:
-            update_tumbler(key, False)
-        # Enable the selected one
-        selected_key = enhancer_key_map.get(choice)
-        if selected_key:
-            update_tumbler(selected_key, True)
-        save_switch_states()
-
-    enhancer_label = ctk.CTkLabel(root, text="Face Enhancer:")
-    enhancer_label.place(relx=0.1, rely=0.62, relwidth=0.2, relheight=0.03)
-
-    enhancer_dropdown = ctk.CTkOptionMenu(
-        root,
-        variable=enhancer_variable,
-        values=enhancer_options,
-        command=on_enhancer_change,
-    )
-    enhancer_dropdown.place(relx=0.35, rely=0.62, relwidth=0.3, relheight=0.03)
-    ToolTip(enhancer_dropdown, _("Select a face enhancement model (None = no enhancement)"))
-
-    # 1) Define a DoubleVar for transparency (0 = fully transparent, 1 = fully opaque)
-    transparency_var = ctk.DoubleVar(value=1.0)
-
-    def on_transparency_change(value: float):
-        # Convert slider value to float
-        val = float(value)
-        modules.globals.opacity = val  # Set global opacity
-        percentage = int(val * 100)
-
-        if percentage == 0:
-            modules.globals.fp_ui["face_enhancer"] = False
-            update_status("Transparency set to 0% - Face swapping disabled.")
-        elif percentage == 100:
-            modules.globals.face_swapper_enabled = True
-            update_status("Transparency set to 100%.")
-        else:
-            modules.globals.face_swapper_enabled = True
-            update_status(f"Transparency set to {percentage}%")
-
-    # 2) Transparency label and slider
-    transparency_label = ctk.CTkLabel(root, text="Transparency:")
-    transparency_label.place(relx=0.15, rely=0.66, relwidth=0.2, relheight=0.03)
-
-    transparency_slider = ctk.CTkSlider(
-        root,
-        from_=0.0,
-        to=1.0,
-        variable=transparency_var,
-        command=on_transparency_change,
-        fg_color="#E0E0E0",
-        progress_color="#007BFF",
-        button_color="#FFFFFF",
-        button_hover_color="#CCCCCC",
-        height=5,
-        border_width=1,
-        corner_radius=3,
-    )
-    transparency_slider.place(relx=0.35, rely=0.67, relwidth=0.5, relheight=0.02)
-    ToolTip(transparency_slider, _("Blend between original and swapped face (0% = original, 100% = fully swapped)"))
-
-    # 3) Sharpness label & slider
-    sharpness_var = ctk.DoubleVar(value=0.0)  # start at 0.0
-    def on_sharpness_change(value: float):
-        modules.globals.sharpness = float(value)
-        update_status(f"Sharpness set to {value:.1f}")
-
-    sharpness_label = ctk.CTkLabel(root, text="Sharpness:")
-    sharpness_label.place(relx=0.15, rely=0.69, relwidth=0.2, relheight=0.03)
-
-    sharpness_slider = ctk.CTkSlider(
-        root,
-        from_=0.0,
-        to=5.0,
-        variable=sharpness_var,
-        command=on_sharpness_change,
-        fg_color="#E0E0E0",
-        progress_color="#007BFF",
-        button_color="#FFFFFF",
-        button_hover_color="#CCCCCC",
-        height=5,
-        border_width=1,
-        corner_radius=3,
-    )
-    sharpness_slider.place(relx=0.35, rely=0.70, relwidth=0.5, relheight=0.02)
-    ToolTip(sharpness_slider, _("Sharpen the enhanced face output"))
-
-    # 4) Mouth Mask Size slider
-    mouth_mask_size_var = ctk.DoubleVar(value=modules.globals.mouth_mask_size)
-
-    def on_mouth_mask_size_change(value: float):
-        val = float(value)
-        modules.globals.mouth_mask_size = val
-        # Auto-enable/disable mouth mask based on slider position
-        if val > 0:
-            modules.globals.mouth_mask = True
-            mouth_mask_var.set(True)
-        else:
-            modules.globals.mouth_mask = False
-            mouth_mask_var.set(False)
-            modules.globals.show_mouth_mask_box = False
-
-    def on_mouth_mask_slider_release(event):
-        # Hide bounding box when user releases the slider
-        modules.globals.show_mouth_mask_box = False
-
-    def on_mouth_mask_slider_press(event):
-        # Show bounding box while dragging
-        if modules.globals.mouth_mask_size > 0:
-            modules.globals.show_mouth_mask_box = True
-
-    mouth_mask_size_label = ctk.CTkLabel(root, text="Mouth Mask:")
-    mouth_mask_size_label.place(relx=0.15, rely=0.72, relwidth=0.2, relheight=0.03)
-
-    mouth_mask_size_slider = ctk.CTkSlider(
-        root,
-        from_=0.0,
-        to=100.0,
-        variable=mouth_mask_size_var,
-        command=on_mouth_mask_size_change,
-        fg_color="#E0E0E0",
-        progress_color="#007BFF",
-        button_color="#FFFFFF",
-        button_hover_color="#CCCCCC",
-        height=5,
-        border_width=1,
-        corner_radius=3,
-    )
-    mouth_mask_size_slider.place(relx=0.35, rely=0.73, relwidth=0.5, relheight=0.02)
-    mouth_mask_size_slider.bind("<ButtonPress-1>", on_mouth_mask_slider_press)
-    mouth_mask_size_slider.bind("<ButtonRelease-1>", on_mouth_mask_slider_release)
-    ToolTip(mouth_mask_size_slider, _("0 = use swapped mouth, 100 = expose original mouth to chin area"))
-
-    # Status and link at the bottom
-    global status_label
-    status_label = ctk.CTkLabel(root, text=None, justify="center")
-    status_label.place(relx=0.1, rely=0.75, relwidth=0.8)
-
-    donate_label = ctk.CTkLabel(
-        root, text="Deep Live Cam", justify="center", cursor="hand2"
-    )
-    donate_label.place(relx=0.1, rely=0.87, relwidth=0.8)
-    donate_label.configure(
-        text_color=ctk.ThemeManager.theme.get("URL").get("text_color")
-    )
-    donate_label.bind(
-        "<Button>", lambda event: webbrowser.open("https://deeplivecam.net")
-    )
-
-    return root
+# ─── thread-safe status bridge ───────────────────────────────────────────
 
 
-def close_mapper_window():
-    global POPUP, POPUP_LIVE
-    if POPUP and POPUP.winfo_exists():
-        POPUP.destroy()
-        POPUP = None
-    if POPUP_LIVE and POPUP_LIVE.winfo_exists():
-        POPUP_LIVE.destroy()
-        POPUP_LIVE = None
+class _UIBridge(QObject):
+    """Single QObject that owns cross-thread signals."""
+
+    statusChanged = Signal(str)
 
 
-def analyze_target(start: Callable[[], None], root: ctk.CTk):
-    if POPUP != None and POPUP.winfo_exists():
-        update_status("Please complete pop-up or close it.")
+def _emit_status(text: str) -> None:
+    if _BRIDGE is None:
+        print(text)
         return
-
-    if modules.globals.map_faces:
-        modules.globals.source_target_map = []
-
-        if is_image(modules.globals.target_path):
-            update_status("Getting unique faces")
-            get_unique_faces_from_target_image()
-        elif is_video(modules.globals.target_path):
-            update_status("Getting unique faces")
-            get_unique_faces_from_target_video()
-
-        if len(modules.globals.source_target_map) > 0:
-            create_source_target_popup(start, root, modules.globals.source_target_map)
-        else:
-            update_status("No faces found in target")
-    else:
-        select_output_path(start)
+    _BRIDGE.statusChanged.emit(text)
 
 
-def create_source_target_popup(
-        start: Callable[[], None], root: ctk.CTk, map: list
-) -> None:
-    global POPUP, popup_status_label
-
-    POPUP = ctk.CTkToplevel(root)
-    POPUP.title(_("Source x Target Mapper"))
-    POPUP.geometry(f"{POPUP_WIDTH}x{POPUP_HEIGHT}")
-    POPUP.focus()
-
-    def on_submit_click(start):
-        if has_valid_map():
-            POPUP.destroy()
-            select_output_path(start)
-        else:
-            update_pop_status("Atleast 1 source with target is required!")
-
-    scrollable_frame = ctk.CTkScrollableFrame(
-        POPUP, width=POPUP_SCROLL_WIDTH, height=POPUP_SCROLL_HEIGHT
-    )
-    scrollable_frame.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
-
-    def on_button_click(map, button_num):
-        map = update_popup_source(scrollable_frame, map, button_num)
-
-    for item in map:
-        id = item["id"]
-
-        button = ctk.CTkButton(
-            scrollable_frame,
-            text=_("Select source image"),
-            command=lambda id=id: on_button_click(map, id),
-            width=DEFAULT_BUTTON_WIDTH,
-            height=DEFAULT_BUTTON_HEIGHT,
-        )
-        button.grid(row=id, column=0, padx=50, pady=10)
-
-        x_label = ctk.CTkLabel(
-            scrollable_frame,
-            text=f"X",
-            width=MAPPER_PREVIEW_MAX_WIDTH,
-            height=MAPPER_PREVIEW_MAX_HEIGHT,
-        )
-        x_label.grid(row=id, column=2, padx=10, pady=10)
-
-        image = Image.fromarray(gpu_cvt_color(item["target"]["cv2"], cv2.COLOR_BGR2RGB))
-        image = image.resize(
-            (MAPPER_PREVIEW_MAX_WIDTH, MAPPER_PREVIEW_MAX_HEIGHT), Image.LANCZOS
-        )
-        tk_image = ctk.CTkImage(image, size=image.size)
-
-        target_image = ctk.CTkLabel(
-            scrollable_frame,
-            text=f"T-{id}",
-            width=MAPPER_PREVIEW_MAX_WIDTH,
-            height=MAPPER_PREVIEW_MAX_HEIGHT,
-        )
-        target_image.grid(row=id, column=3, padx=10, pady=10)
-        target_image.configure(image=tk_image)
-
-    popup_status_label = ctk.CTkLabel(POPUP, text=None, justify="center")
-    popup_status_label.grid(row=1, column=0, pady=15)
-
-    close_button = ctk.CTkButton(
-        POPUP, text=_("Submit"), command=lambda: on_submit_click(start)
-    )
-    close_button.grid(row=2, column=0, pady=10)
-
-
-def update_popup_source(
-        scrollable_frame: ctk.CTkScrollableFrame, map: list, button_num: int
-) -> list:
-    global source_label_dict
-
-    source_path = ctk.filedialog.askopenfilename(
-        title=_("select an source image"),
-        initialdir=RECENT_DIRECTORY_SOURCE,
-        filetypes=[img_ft],
-    )
-
-    if "source" in map[button_num]:
-        map[button_num].pop("source")
-        source_label_dict[button_num].destroy()
-        del source_label_dict[button_num]
-
-    if source_path == "":
-        return map
-    else:
-        cv2_img = cv2.imread(source_path)
-        face = get_one_face(cv2_img)
-
-        if face:
-            x_min, y_min, x_max, y_max = face["bbox"]
-
-            map[button_num]["source"] = {
-                "cv2": cv2_img[int(y_min): int(y_max), int(x_min): int(x_max)],
-                "face": face,
-            }
-
-            image = Image.fromarray(
-                gpu_cvt_color(map[button_num]["source"]["cv2"], cv2.COLOR_BGR2RGB)
-            )
-            image = image.resize(
-                (MAPPER_PREVIEW_MAX_WIDTH, MAPPER_PREVIEW_MAX_HEIGHT), Image.LANCZOS
-            )
-            tk_image = ctk.CTkImage(image, size=image.size)
-
-            source_image = ctk.CTkLabel(
-                scrollable_frame,
-                text=f"S-{button_num}",
-                width=MAPPER_PREVIEW_MAX_WIDTH,
-                height=MAPPER_PREVIEW_MAX_HEIGHT,
-            )
-            source_image.grid(row=button_num, column=1, padx=10, pady=10)
-            source_image.configure(image=tk_image)
-            source_label_dict[button_num] = source_image
-        else:
-            update_pop_status("Face could not be detected in last upload!")
-        return map
-
-
-def create_preview(parent: ctk.CTkToplevel) -> ctk.CTkToplevel:
-    global preview_label, preview_slider
-
-    preview = ctk.CTkToplevel(parent)
-    preview.withdraw()
-    preview.title(_("Preview"))
-    preview.configure()
-    preview.protocol("WM_DELETE_WINDOW", lambda: toggle_preview())
-    preview.resizable(width=True, height=True)
-
-    preview_label = ctk.CTkLabel(preview, text=None)
-    preview_label.pack(fill="both", expand=True)
-
-    preview_slider = ctk.CTkSlider(
-        preview, from_=0, to=0, command=lambda frame_value: update_preview(frame_value)
-    )
-
-    return preview
+# ─── public API ──────────────────────────────────────────────────────────
 
 
 def update_status(text: str) -> None:
-    status_label.configure(text=_(text))
-    ROOT.update()
+    """Thread-safe status update — uses signal if called off-UI thread."""
+    _emit_status(_(text))
+    if _APP is not None and QThread.currentThread() is _APP.thread():
+        # On UI thread — flush events so the user sees the update during
+        # long synchronous start() runs.
+        _APP.processEvents()
 
 
-def update_pop_status(text: str) -> None:
-    popup_status_label.configure(text=_(text))
-
-
-def update_pop_live_status(text: str) -> None:
-    popup_status_label_live.configure(text=_(text))
-
-
-def update_tumbler(var: str, value: bool) -> None:
-    modules.globals.fp_ui[var] = value
-    save_switch_states()
-    # If we're currently in a live preview, update the frame processors
-    if PREVIEW.state() == "normal":
-        global frame_processors
-        frame_processors = get_frame_processors_modules(
-            modules.globals.frame_processors
-        )
-
-
-def fetch_random_face() -> None:
-    PREVIEW.withdraw()
-    try:
-        response = requests.get(
-            "https://thispersondoesnotexist.com/",
-            headers={"User-Agent": "Mozilla/5.0"},
-            timeout=10,
-        )
-        response.raise_for_status()
-        temp_dir = tempfile.gettempdir()
-        temp_path = os.path.join(temp_dir, "deep_live_cam_random_face.jpg")
-        with open(temp_path, "wb") as f:
-            f.write(response.content)
-        modules.globals.source_path = temp_path
-        image = render_image_preview(temp_path, (200, 200))
-        source_label.configure(image=image)
-    except Exception as e:
-        print(f"Failed to fetch random face: {e}")
-
-
-def select_source_path() -> None:
-    global RECENT_DIRECTORY_SOURCE, img_ft, vid_ft
-
-    PREVIEW.withdraw()
-    source_path = ctk.filedialog.askopenfilename(
-        title=_("select an source image"),
-        initialdir=RECENT_DIRECTORY_SOURCE,
-        filetypes=[img_ft],
-    )
-    if is_image(source_path):
-        modules.globals.source_path = source_path
-        RECENT_DIRECTORY_SOURCE = os.path.dirname(modules.globals.source_path)
-        image = render_image_preview(modules.globals.source_path, (200, 200))
-        source_label.configure(image=image)
-    else:
-        modules.globals.source_path = None
-        source_label.configure(image=None)
-
-
-def swap_faces_paths() -> None:
-    global RECENT_DIRECTORY_SOURCE, RECENT_DIRECTORY_TARGET
-
-    source_path = modules.globals.source_path
-    target_path = modules.globals.target_path
-
-    if not is_image(source_path) or not is_image(target_path):
-        return
-
-    modules.globals.source_path = target_path
-    modules.globals.target_path = source_path
-
-    RECENT_DIRECTORY_SOURCE = os.path.dirname(modules.globals.source_path)
-    RECENT_DIRECTORY_TARGET = os.path.dirname(modules.globals.target_path)
-
-    PREVIEW.withdraw()
-
-    source_image = render_image_preview(modules.globals.source_path, (200, 200))
-    source_label.configure(image=source_image)
-
-    target_image = render_image_preview(modules.globals.target_path, (200, 200))
-    target_label.configure(image=target_image)
-
-
-def select_target_path() -> None:
-    global RECENT_DIRECTORY_TARGET, img_ft, vid_ft
-
-    PREVIEW.withdraw()
-    target_path = ctk.filedialog.askopenfilename(
-        title=_("select an target image or video"),
-        initialdir=RECENT_DIRECTORY_TARGET,
-        filetypes=[img_ft, vid_ft],
-    )
-    if is_image(target_path):
-        modules.globals.target_path = target_path
-        RECENT_DIRECTORY_TARGET = os.path.dirname(modules.globals.target_path)
-        image = render_image_preview(modules.globals.target_path, (200, 200))
-        target_label.configure(image=image)
-    elif is_video(target_path):
-        modules.globals.target_path = target_path
-        RECENT_DIRECTORY_TARGET = os.path.dirname(modules.globals.target_path)
-        video_frame = render_video_preview(target_path, (200, 200))
-        target_label.configure(image=video_frame)
-    else:
-        modules.globals.target_path = None
-        target_label.configure(image=None)
-
-
-def select_output_path(start: Callable[[], None]) -> None:
-    global RECENT_DIRECTORY_OUTPUT, img_ft, vid_ft
-
-    if is_image(modules.globals.target_path):
-        output_path = ctk.filedialog.asksaveasfilename(
-            title=_("save image output file"),
-            filetypes=[img_ft],
-            defaultextension=".png",
-            initialfile="output.png",
-            initialdir=RECENT_DIRECTORY_OUTPUT,
-        )
-    elif is_video(modules.globals.target_path):
-        output_path = ctk.filedialog.asksaveasfilename(
-            title=_("save video output file"),
-            filetypes=[vid_ft],
-            defaultextension=".mp4",
-            initialfile="output.mp4",
-            initialdir=RECENT_DIRECTORY_OUTPUT,
-        )
-    else:
-        output_path = None
-    if output_path:
-        modules.globals.output_path = output_path
-        RECENT_DIRECTORY_OUTPUT = os.path.dirname(modules.globals.output_path)
-        start()
-
-
-def check_and_ignore_nsfw(target, destroy: Callable = None) -> bool:
-    """Check if the target is NSFW.
-    TODO: Consider to make blur the target.
-    """
+def check_and_ignore_nsfw(target, destroy: Optional[Callable] = None) -> bool:
     from numpy import ndarray
-    from modules.predicter import predict_image, predict_video, predict_frame
+    from modules.predicter import predict_frame, predict_image, predict_video
 
-    if type(target) is str:  # image/video file path
+    check_nsfw = None
+    if isinstance(target, str):
         check_nsfw = predict_image if has_image_extension(target) else predict_video
-    elif type(target) is ndarray:  # frame object
+    elif isinstance(target, ndarray):
         check_nsfw = predict_frame
+
     if check_nsfw and check_nsfw(target):
         if destroy:
-            destroy(
-                to_quit=False
-            )  # Do not need to destroy the window frame if the target is NSFW
+            destroy(to_quit=False)
         update_status("Processing ignored!")
         return True
-    else:
-        return False
+    return False
 
 
-def fit_image_to_size(image, width: int, height: int):
-    if width is None and height is None:
-        return image
-    h, w, _ = image.shape
-    ratio_h = 0.0
-    ratio_w = 0.0
-    if width > height:
-        ratio_h = height / h
-    else:
-        ratio_w = width / w
-    ratio = max(ratio_w, ratio_h)
-    new_size = (int(ratio * w), int(ratio * h))
-    return gpu_resize(image, dsize=new_size)
+# ─── camera enumeration (unchanged from tk version) ──────────────────────
 
 
-def render_image_preview(image_path: str, size: Tuple[int, int]) -> ctk.CTkImage:
-    image = Image.open(image_path)
-    if size:
-        image = ImageOps.fit(image, size, Image.LANCZOS)
-    return ctk.CTkImage(image, size=image.size)
-
-
-def render_video_preview(
-        video_path: str, size: Tuple[int, int], frame_number: int = 0
-) -> ctk.CTkImage:
-    capture = cv2.VideoCapture(video_path)
-    if frame_number:
-        capture.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
-    has_frame, frame = capture.read()
-    if has_frame:
-        image = Image.fromarray(gpu_cvt_color(frame, cv2.COLOR_BGR2RGB))
-        if size:
-            image = ImageOps.fit(image, size, Image.LANCZOS)
-        return ctk.CTkImage(image, size=image.size)
-    capture.release()
-    cv2.destroyAllWindows()
-
-
-def toggle_preview() -> None:
-    if PREVIEW.state() == "normal":
-        PREVIEW.withdraw()
-    elif modules.globals.source_path and modules.globals.target_path:
-        init_preview()
-        update_preview()
-
-
-def init_preview() -> None:
-    if is_image(modules.globals.target_path):
-        preview_slider.pack_forget()
-    if is_video(modules.globals.target_path):
-        video_frame_total = get_video_frame_total(modules.globals.target_path)
-        preview_slider.configure(to=video_frame_total)
-        preview_slider.pack(fill="x")
-        preview_slider.set(0)
-
-
-def update_preview(frame_number: int = 0) -> None:
-    if modules.globals.source_path and modules.globals.target_path:
-        update_status("Processing...")
-        temp_frame = get_video_frame(modules.globals.target_path, frame_number)
-        if modules.globals.nsfw_filter and check_and_ignore_nsfw(temp_frame):
-            return
-        for frame_processor in get_frame_processors_modules(
-                modules.globals.frame_processors
-        ):
-            temp_frame = frame_processor.process_frame(
-                get_one_face(cv2.imread(modules.globals.source_path)), temp_frame
-            )
-        image = Image.fromarray(gpu_cvt_color(temp_frame, cv2.COLOR_BGR2RGB))
-        image = ImageOps.contain(
-            image, (PREVIEW_MAX_WIDTH, PREVIEW_MAX_HEIGHT), Image.LANCZOS
-        )
-        image = ctk.CTkImage(image, size=image.size)
-        preview_label.configure(image=image)
-        update_status("Processing succeed!")
-        PREVIEW.deiconify()
-
-
-def webcam_preview(root: ctk.CTk, camera_index: int):
-    global POPUP_LIVE
-
-    if POPUP_LIVE and POPUP_LIVE.winfo_exists():
-        update_status("Source x Target Mapper is already open.")
-        POPUP_LIVE.focus()
-        return
-
-    if not modules.globals.map_faces:
-        if modules.globals.source_path is None:
-            update_status("Please select a source image first")
-            return
-        from modules.processors.frame.face_swapper import get_face_swapper
-        from modules.face_analyser import get_face_analyser
-        get_face_analyser()
-        get_face_swapper()
-        create_webcam_preview(camera_index)
-    else:
-        modules.globals.source_target_map = []
-        create_source_target_popup_for_webcam(
-            root, modules.globals.source_target_map, camera_index
-        )
-
-
-
-def get_available_cameras():
-    """Returns a list of available camera names and indices."""
+def get_available_cameras() -> Tuple[List[int], List[str]]:
     if platform.system() == "Windows":
         try:
             graph = FilterGraph()
             devices = graph.get_input_devices()
-
-            # Create list of indices and names
-            camera_indices = list(range(len(devices)))
-            camera_names = devices
-
-            # If no cameras found through DirectShow, try OpenCV fallback
-            if not camera_names:
-                # Try to open camera with index -1 and 0
-                test_indices = [-1, 0]
-                working_cameras = []
-
-                for idx in test_indices:
-                    cap = cv2.VideoCapture(idx)
-                    if cap.isOpened():
-                        working_cameras.append(f"Camera {idx}")
-                        cap.release()
-
-                if working_cameras:
-                    return test_indices[: len(working_cameras)], working_cameras
-
-            # If still no cameras found, return empty lists
-            if not camera_names:
-                return [], ["No cameras found"]
-
-            return camera_indices, camera_names
-
-        except Exception as e:
-            print(f"Error detecting cameras: {str(e)}")
+            if devices:
+                return list(range(len(devices))), devices
+            return [], ["No cameras found"]
+        except Exception as exc:
+            print(f"Error detecting cameras: {exc}")
             return [], ["No cameras found"]
-    else:
-        # Unix-like systems (Linux/Mac) camera detection
-        camera_indices = []
-        camera_names = []
 
-        if platform.system() == "Darwin":
-            # Do NOT probe cameras with cv2.VideoCapture on macOS — probing
-            # invalid indices triggers the OBSENSOR backend and causes SIGSEGV.
-            # Default to indices 0 and 1 (covers FaceTime + one USB camera).
-            # The user can select the correct index from the UI dropdown.
-            camera_indices = [0, 1]
-            camera_names = ["Camera 0", "Camera 1"]
+    if platform.system() == "Darwin":
+        return [0, 1], ["Camera 0", "Camera 1"]
+
+    # Linux probe
+    indices: List[int] = []
+    names: List[str] = []
+    for i in range(10):
+        cap = cv2.VideoCapture(i)
+        if cap.isOpened():
+            indices.append(i)
+            names.append(f"Camera {i}")
+            cap.release()
+    return (indices, names) if names else ([], ["No cameras found"])
+
+
+# ─── main window ─────────────────────────────────────────────────────────
+
+
+def _make_image_drop(text: str, size: Tuple[int, int]) -> QLabel:
+    label = QLabel(text)
+    label.setObjectName("imageDrop")
+    label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    label.setFixedSize(size[0], size[1])
+    label.setText(text)
+    return label
+
+
+class _Switch(QWidget):
+    """Compact toggle switch with label + optional tooltip."""
+
+    toggled = Signal(bool)
+
+    def __init__(self, text: str, initial: bool, tooltip: str = ""):
+        super().__init__()
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self._checkbox = QCheckBox(text)
+        self._checkbox.setChecked(initial)
+        self._checkbox.toggled.connect(self.toggled.emit)
+        if tooltip:
+            self._checkbox.setToolTip(tooltip)
+        layout.addWidget(self._checkbox)
+        layout.addStretch(1)
+
+    def isChecked(self) -> bool:
+        return self._checkbox.isChecked()
+
+    def setChecked(self, value: bool) -> None:
+        self._checkbox.setChecked(value)
+
+
+class MainWindow(QMainWindow):
+    def __init__(self, start_cb: Callable, destroy_cb: Callable):
+        super().__init__()
+        load_switch_states()
+        self._start_cb = start_cb
+        self._destroy_cb = destroy_cb
+
+        self.setWindowTitle(
+            f"{modules.metadata.name} {modules.metadata.version} {modules.metadata.edition}"
+        )
+        self.setMinimumSize(ROOT_WIDTH, ROOT_HEIGHT)
+        self.resize(ROOT_WIDTH, ROOT_HEIGHT)
+
+        root = QWidget()
+        self.setCentralWidget(root)
+        layout = QVBoxLayout(root)
+        layout.setContentsMargins(16, 16, 16, 16)
+        layout.setSpacing(12)
+
+        # Source/Target row
+        layout.addLayout(self._build_image_row())
+
+        # Options grid
+        layout.addWidget(self._build_options_card())
+
+        # Sliders card
+        layout.addWidget(self._build_sliders_card())
+
+        # Action buttons
+        layout.addLayout(self._build_action_row())
+
+        # Camera selection
+        layout.addWidget(self._build_camera_card())
+
+        # Status & footer
+        self._status_label = QLabel("")
+        self._status_label.setObjectName("statusLabel")
+        self._status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self._status_label)
+
+        footer = QLabel("Deep Live Cam")
+        footer.setObjectName("linkLabel")
+        footer.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        footer.setCursor(Qt.CursorShape.PointingHandCursor)
+        footer.mousePressEvent = lambda _e: webbrowser.open("https://deeplivecam.net")
+        layout.addWidget(footer)
+
+    # ── image row ────────────────────────────────────────────────────────
+
+    def _build_image_row(self) -> QHBoxLayout:
+        row = QHBoxLayout()
+        row.setSpacing(16)
+
+        # Source column
+        src_col = QVBoxLayout()
+        self.source_label = _make_image_drop(_("Source face"), (200, 200))
+        src_col.addWidget(self.source_label, alignment=Qt.AlignmentFlag.AlignCenter)
+        src_row = QHBoxLayout()
+        self.btn_select_source = QPushButton(_("Select a face"))
+        self.btn_select_source.setToolTip(
+            _("Choose the source face image to swap onto the target")
+        )
+        self.btn_select_source.clicked.connect(self._on_select_source)
+        self.btn_random_face = QPushButton("🔄")
+        self.btn_random_face.setObjectName("secondary")
+        self.btn_random_face.setFixedWidth(40)
+        self.btn_random_face.setToolTip(
+            _("Get a random face from thispersondoesnotexist.com")
+        )
+        self.btn_random_face.clicked.connect(self._on_random_face)
+        src_row.addWidget(self.btn_select_source)
+        src_row.addWidget(self.btn_random_face)
+        src_col.addLayout(src_row)
+
+        # Swap button column
+        swap_col = QVBoxLayout()
+        swap_col.addStretch(1)
+        self.btn_swap = QPushButton("↔")
+        self.btn_swap.setObjectName("secondary")
+        self.btn_swap.setFixedSize(44, 44)
+        self.btn_swap.setToolTip(_("Swap source and target images"))
+        self.btn_swap.clicked.connect(self._on_swap_paths)
+        swap_col.addWidget(self.btn_swap, alignment=Qt.AlignmentFlag.AlignCenter)
+        swap_col.addStretch(1)
+
+        # Target column
+        tgt_col = QVBoxLayout()
+        self.target_label = _make_image_drop(_("Target"), (200, 200))
+        tgt_col.addWidget(self.target_label, alignment=Qt.AlignmentFlag.AlignCenter)
+        self.btn_select_target = QPushButton(_("Select a target"))
+        self.btn_select_target.setToolTip(
+            _("Choose the target image or video to apply face swap to")
+        )
+        self.btn_select_target.clicked.connect(self._on_select_target)
+        tgt_col.addWidget(self.btn_select_target)
+
+        row.addLayout(src_col)
+        row.addLayout(swap_col)
+        row.addLayout(tgt_col)
+        return row
+
+    # ── options card ─────────────────────────────────────────────────────
+
+    def _build_options_card(self) -> QGroupBox:
+        card = QGroupBox(_("Options"))
+        grid = QGridLayout(card)
+        grid.setHorizontalSpacing(20)
+        grid.setVerticalSpacing(6)
+
+        def make(field, label, tip):
+            sw = _Switch(_(label), getattr(modules.globals, field), _(tip))
+            sw.toggled.connect(
+                lambda v, f=field: (
+                    setattr(modules.globals, f, v),
+                    save_switch_states(),
+                )
+            )
+            return sw
+
+        self.sw_keep_fps = make("keep_fps", "Keep fps",
+                                "Output video keeps the original frame rate")
+        self.sw_keep_audio = make("keep_audio", "Keep audio",
+                                  "Copy audio track from the source video to output")
+        self.sw_keep_frames = make("keep_frames", "Keep frames",
+                                   "Keep extracted frames on disk after processing")
+        self.sw_many_faces = make("many_faces", "Many faces",
+                                  "Swap every detected face, not just the primary one")
+        self.sw_poisson = make("poisson_blend", "Poisson Blend",
+                               "Blend face edges smoothly using Poisson blending")
+        self.sw_color_fix = make("color_correction", "Fix Blueish Cam",
+                                 "Fix blue/green color cast from some webcams")
+        self.sw_show_fps = make("show_fps", "Show FPS",
+                                "Display frames-per-second counter on the live preview")
+
+        # Map faces is special — closes mapper when toggled off.
+        self.sw_map_faces = _Switch(_("Map faces"), modules.globals.map_faces,
+                                    _("Manually assign which source face maps to which target face"))
+        self.sw_map_faces.toggled.connect(self._on_map_faces_toggled)
+
+        # Layout: 2 columns of switches
+        items = [
+            self.sw_keep_fps, self.sw_keep_audio,
+            self.sw_keep_frames, self.sw_many_faces,
+            self.sw_map_faces, self.sw_show_fps,
+            self.sw_poisson, self.sw_color_fix,
+        ]
+        for i, w in enumerate(items):
+            grid.addWidget(w, i // 2, i % 2)
+
+        # Face enhancer dropdown
+        enhancer_label = QLabel(_("Face Enhancer:"))
+        grid.addWidget(enhancer_label, len(items) // 2, 0)
+
+        self.cb_enhancer = QComboBox()
+        self.cb_enhancer.addItems(["None", "GFPGAN", "GPEN-512", "GPEN-256"])
+        initial = "None"
+        if modules.globals.fp_ui.get("face_enhancer", False):
+            initial = "GFPGAN"
+        elif modules.globals.fp_ui.get("face_enhancer_gpen512", False):
+            initial = "GPEN-512"
+        elif modules.globals.fp_ui.get("face_enhancer_gpen256", False):
+            initial = "GPEN-256"
+        self.cb_enhancer.setCurrentText(initial)
+        self.cb_enhancer.currentTextChanged.connect(self._on_enhancer_change)
+        self.cb_enhancer.setToolTip(_("Select a face enhancement model (None = no enhancement)"))
+        grid.addWidget(self.cb_enhancer, len(items) // 2, 1)
+
+        return card
+
+    # ── sliders card ─────────────────────────────────────────────────────
+
+    def _build_sliders_card(self) -> QGroupBox:
+        card = QGroupBox(_("Refinement"))
+        grid = QGridLayout(card)
+        grid.setHorizontalSpacing(12)
+        grid.setVerticalSpacing(10)
+
+        def slider(min_v, max_v, default, denom, on_change):
+            s = QSlider(Qt.Orientation.Horizontal)
+            s.setRange(int(min_v * denom), int(max_v * denom))
+            s.setValue(int(default * denom))
+            s.valueChanged.connect(lambda iv: on_change(iv / denom))
+            return s
+
+        # Transparency
+        grid.addWidget(QLabel(_("Transparency")), 0, 0)
+        self.s_transparency = slider(0.0, 1.0, 1.0, 100, self._on_transparency_change)
+        self.s_transparency.setToolTip(
+            _("Blend between original and swapped face (0% = original, 100% = fully swapped)")
+        )
+        grid.addWidget(self.s_transparency, 0, 1)
+
+        # Sharpness
+        grid.addWidget(QLabel(_("Sharpness")), 1, 0)
+        self.s_sharpness = slider(0.0, 5.0, 0.0, 10, self._on_sharpness_change)
+        self.s_sharpness.setToolTip(_("Sharpen the enhanced face output"))
+        grid.addWidget(self.s_sharpness, 1, 1)
+
+        # Mouth mask
+        grid.addWidget(QLabel(_("Mouth Mask")), 2, 0)
+        self.s_mouth = slider(0.0, 100.0, modules.globals.mouth_mask_size, 1,
+                              self._on_mouth_mask_change)
+        self.s_mouth.sliderPressed.connect(self._on_mouth_mask_pressed)
+        self.s_mouth.sliderReleased.connect(self._on_mouth_mask_released)
+        self.s_mouth.setToolTip(
+            _("0 = use swapped mouth, 100 = expose original mouth to chin area")
+        )
+        grid.addWidget(self.s_mouth, 2, 1)
+        return card
+
+    # ── action row ───────────────────────────────────────────────────────
+
+    def _build_action_row(self) -> QHBoxLayout:
+        row = QHBoxLayout()
+        self.btn_start = QPushButton(_("Start"))
+        self.btn_start.setToolTip(_("Begin processing the target image/video with selected face"))
+        self.btn_start.clicked.connect(self._on_start)
+
+        self.btn_destroy = QPushButton(_("Destroy"))
+        self.btn_destroy.setObjectName("danger")
+        self.btn_destroy.setToolTip(_("Stop processing and close the application"))
+        self.btn_destroy.clicked.connect(lambda: self._destroy_cb())
+
+        self.btn_preview = QPushButton(_("Preview"))
+        self.btn_preview.setObjectName("secondary")
+        self.btn_preview.setToolTip(_("Show/hide a preview of the processed output"))
+        self.btn_preview.clicked.connect(self._on_toggle_preview)
+
+        row.addWidget(self.btn_start)
+        row.addWidget(self.btn_destroy)
+        row.addWidget(self.btn_preview)
+        return row
+
+    # ── camera card ──────────────────────────────────────────────────────
+
+    def _build_camera_card(self) -> QGroupBox:
+        card = QGroupBox(_("Camera"))
+        layout = QHBoxLayout(card)
+
+        layout.addWidget(QLabel(_("Select Camera:")))
+        self._camera_indices, self._camera_names = get_available_cameras()
+
+        self.cb_camera = QComboBox()
+        if not self._camera_names or self._camera_names[0] == "No cameras found":
+            self.cb_camera.addItem("No cameras found")
+            self.cb_camera.setEnabled(False)
+            cam_ok = False
         else:
-            # Linux camera detection - test first 10 indices
-            for i in range(10):
-                cap = cv2.VideoCapture(i)
-                if cap.isOpened():
-                    camera_indices.append(i)
-                    camera_names.append(f"Camera {i}")
-                    cap.release()
+            self.cb_camera.addItems(self._camera_names)
+            cam_ok = True
+        self.cb_camera.setToolTip(_("Select which camera to use for live mode"))
+        layout.addWidget(self.cb_camera, 1)
 
-        if not camera_names:
-            return [], ["No cameras found"]
+        self.btn_live = QPushButton(_("Live"))
+        self.btn_live.setEnabled(cam_ok)
+        self.btn_live.setToolTip(_("Start real-time face swap using webcam"))
+        self.btn_live.clicked.connect(self._on_live)
+        layout.addWidget(self.btn_live)
 
-        return camera_indices, camera_names
+        return card
 
+    # ── slot handlers ────────────────────────────────────────────────────
 
-def _capture_thread_func(cap, capture_queue, stop_event):
-    """Capture thread: reads frames from camera and puts them into the queue.
-    Drops frames when the queue is full to avoid backpressure on the camera."""
-    while not stop_event.is_set():
-        ret, frame = cap.read()
-        if not ret:
-            stop_event.set()
-            break
-        try:
-            capture_queue.put_nowait(frame)
-        except queue.Full:
-            # Drop the oldest frame and enqueue the new one
-            try:
-                capture_queue.get_nowait()
-            except queue.Empty:
-                pass
-            try:
-                capture_queue.put_nowait(frame)
-            except queue.Full:
-                pass
+    def set_status(self, text: str) -> None:
+        self._status_label.setText(text)
 
+    def _on_select_source(self) -> None:
+        global _RECENT_SOURCE_DIR
+        if _PREVIEW is not None:
+            _PREVIEW.hide()
+        path, _filter = QFileDialog.getOpenFileName(
+            self, _("select an source image"),
+            _RECENT_SOURCE_DIR or "",
+            "Images (*.png *.jpg *.jpeg *.gif *.bmp)",
+        )
+        if path and is_image(path):
+            modules.globals.source_path = path
+            _RECENT_SOURCE_DIR = os.path.dirname(path)
+            self.source_label.setPixmap(render_image_preview(path, (200, 200)))
+            self.source_label.setText("")
+        elif not path:
+            return
+        else:
+            modules.globals.source_path = None
+            self.source_label.clear()
+            self.source_label.setText(_("Source face"))
 
-def _processing_thread_func(capture_queue, processed_queue, stop_event,
-                            camera_fps: float = 30.0):
-    """Processing thread: takes raw frames from capture_queue, runs face
-    detection (throttled), applies face swap/enhancement, and puts results
-    into processed_queue.
-
-    Args:
-        camera_fps: Actual camera frame rate — used to compute how many
-            frames to skip between face detections (~80ms target).
-    """
-    frame_processors = get_frame_processors_modules(modules.globals.frame_processors)
-    source_image = None
-    last_source_path = None
-    prev_time = time.time()
-    fps_update_interval = 0.5
-    frame_count = 0
-    fps = 0
-    det_count = 0
-    cached_target_face = None
-    cached_many_faces = None
-    # Detect every N frames ≈ 80ms.  At 60fps → every 5 frames (83ms),
-    # at 30fps → every 3 frames (100ms), at 15fps → every frame.
-    det_interval = max(1, round(camera_fps * 0.08))
-
-    while not stop_event.is_set():
-        try:
-            frame = capture_queue.get(timeout=0.05)
-        except queue.Empty:
-            continue
-
-        temp_frame = frame
-
-        if modules.globals.live_mirror:
-            temp_frame = gpu_flip(temp_frame, 1)
-
-        if not modules.globals.map_faces:
-            if modules.globals.source_path and modules.globals.source_path != last_source_path:
-                last_source_path = modules.globals.source_path
-                source_image = get_one_face(cv2.imread(modules.globals.source_path))
-
-            # Run detection every det_interval frames (~80ms).
-            # Use fast detection (det-only, no landmark/recognition) for live mode.
-            det_count += 1
-            if det_count % det_interval == 0:
-                if modules.globals.many_faces:
-                    cached_target_face = None
-                    cached_many_faces = detect_many_faces_fast(temp_frame)
-                else:
-                    cached_target_face = detect_one_face_fast(temp_frame)
-                    cached_many_faces = None
-
-            # Build face list for enhancers from cached detection
-            _cached_faces = None
-            if cached_many_faces:
-                _cached_faces = cached_many_faces
-            elif cached_target_face is not None:
-                _cached_faces = [cached_target_face]
-
-            for frame_processor in frame_processors:
-                if frame_processor.NAME == "DLC.FACE-ENHANCER":
-                    if modules.globals.fp_ui["face_enhancer"]:
-                        temp_frame = frame_processor.process_frame(
-                            None, temp_frame, detected_faces=_cached_faces)
-                elif frame_processor.NAME == "DLC.FACE-ENHANCER-GPEN256":
-                    if modules.globals.fp_ui.get("face_enhancer_gpen256", False):
-                        temp_frame = frame_processor.process_frame(
-                            None, temp_frame, detected_faces=_cached_faces)
-                elif frame_processor.NAME == "DLC.FACE-ENHANCER-GPEN512":
-                    if modules.globals.fp_ui.get("face_enhancer_gpen512", False):
-                        temp_frame = frame_processor.process_frame(
-                            None, temp_frame, detected_faces=_cached_faces)
-                elif frame_processor.NAME == "DLC.FACE-SWAPPER":
-                    # Use cached face positions from detection thread
-                    swapped_bboxes = []
-                    if modules.globals.many_faces and cached_many_faces:
-                        result = temp_frame.copy()
-                        for t_face in cached_many_faces:
-                            result = frame_processor.swap_face(source_image, t_face, result)
-                            if hasattr(t_face, 'bbox') and t_face.bbox is not None:
-                                swapped_bboxes.append(t_face.bbox.astype(int))
-                        temp_frame = result
-                    elif cached_target_face is not None:
-                        temp_frame = frame_processor.swap_face(source_image, cached_target_face, temp_frame)
-                        if hasattr(cached_target_face, 'bbox') and cached_target_face.bbox is not None:
-                            swapped_bboxes.append(cached_target_face.bbox.astype(int))
-                    # Apply post-processing (sharpening, interpolation)
-                    temp_frame = frame_processor.apply_post_processing(temp_frame, swapped_bboxes)
-                else:
-                    temp_frame = frame_processor.process_frame(source_image, temp_frame)
+    def _on_select_target(self) -> None:
+        global _RECENT_TARGET_DIR
+        if _PREVIEW is not None:
+            _PREVIEW.hide()
+        path, _filter = QFileDialog.getOpenFileName(
+            self, _("select an target image or video"),
+            _RECENT_TARGET_DIR or "",
+            "Media (*.png *.jpg *.jpeg *.gif *.bmp *.mp4 *.mkv)",
+        )
+        if not path:
+            return
+        if is_image(path):
+            modules.globals.target_path = path
+            _RECENT_TARGET_DIR = os.path.dirname(path)
+            self.target_label.setPixmap(render_image_preview(path, (200, 200)))
+            self.target_label.setText("")
+        elif is_video(path):
+            modules.globals.target_path = path
+            _RECENT_TARGET_DIR = os.path.dirname(path)
+            pm = render_video_preview(path, (200, 200))
+            if pm:
+                self.target_label.setPixmap(pm)
+                self.target_label.setText("")
         else:
             modules.globals.target_path = None
-            for frame_processor in frame_processors:
-                if frame_processor.NAME == "DLC.FACE-ENHANCER":
-                    if modules.globals.fp_ui["face_enhancer"]:
-                        temp_frame = frame_processor.process_frame_v2(temp_frame)
-                elif frame_processor.NAME in ("DLC.FACE-ENHANCER-GPEN256", "DLC.FACE-ENHANCER-GPEN512"):
-                    fp_key = frame_processor.NAME.split(".")[-1].lower().replace("-", "_")
-                    if modules.globals.fp_ui.get(fp_key, False):
-                        temp_frame = frame_processor.process_frame_v2(temp_frame)
-                else:
-                    temp_frame = frame_processor.process_frame_v2(temp_frame)
+            self.target_label.clear()
+            self.target_label.setText(_("Target"))
 
-        # Calculate and display FPS
-        current_time = time.time()
-        frame_count += 1
-        if current_time - prev_time >= fps_update_interval:
-            fps = frame_count / (current_time - prev_time)
-            frame_count = 0
-            prev_time = current_time
-
-        if modules.globals.show_fps:
-            cv2.putText(
-                temp_frame,
-                f"FPS: {fps:.1f}",
-                (10, 30),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 255, 0),
-                2,
+    def _on_random_face(self) -> None:
+        if _PREVIEW is not None:
+            _PREVIEW.hide()
+        try:
+            response = requests.get(
+                "https://thispersondoesnotexist.com/",
+                headers={"User-Agent": "Mozilla/5.0"},
+                timeout=10,
             )
+            response.raise_for_status()
+            temp_path = os.path.join(tempfile.gettempdir(), "deep_live_cam_random_face.jpg")
+            with open(temp_path, "wb") as f:
+                f.write(response.content)
+            modules.globals.source_path = temp_path
+            self.source_label.setPixmap(render_image_preview(temp_path, (200, 200)))
+            self.source_label.setText("")
+        except Exception as exc:
+            print(f"Failed to fetch random face: {exc}")
 
-        # Queue the processed frame as BGR; the display thread resizes to the
-        # preview window first and then runs cvtColor on the (much smaller)
-        # buffer — cheaper than converting the full 1080p frame here.
-        try:
-            processed_queue.put_nowait(temp_frame)
-        except queue.Full:
+    def _on_swap_paths(self) -> None:
+        global _RECENT_SOURCE_DIR, _RECENT_TARGET_DIR
+        sp = modules.globals.source_path
+        tp = modules.globals.target_path
+        if not (sp and tp and is_image(sp) and is_image(tp)):
+            return
+        modules.globals.source_path, modules.globals.target_path = tp, sp
+        _RECENT_SOURCE_DIR = os.path.dirname(tp)
+        _RECENT_TARGET_DIR = os.path.dirname(sp)
+        if _PREVIEW is not None:
+            _PREVIEW.hide()
+        self.source_label.setPixmap(render_image_preview(tp, (200, 200)))
+        self.target_label.setPixmap(render_image_preview(sp, (200, 200)))
+        self.source_label.setText("")
+        self.target_label.setText("")
+
+    def _on_map_faces_toggled(self, value: bool) -> None:
+        modules.globals.map_faces = value
+        save_switch_states()
+        if not value:
+            close_mapper_window()
+
+    def _on_enhancer_change(self, choice: str) -> None:
+        key_map = {
+            "None": None,
+            "GFPGAN": "face_enhancer",
+            "GPEN-512": "face_enhancer_gpen512",
+            "GPEN-256": "face_enhancer_gpen256",
+        }
+        for key in ("face_enhancer", "face_enhancer_gpen256", "face_enhancer_gpen512"):
+            _update_tumbler(key, False)
+        selected = key_map.get(choice)
+        if selected:
+            _update_tumbler(selected, True)
+        save_switch_states()
+
+    def _on_transparency_change(self, value: float) -> None:
+        modules.globals.opacity = value
+        pct = int(value * 100)
+        if pct == 0:
+            modules.globals.fp_ui["face_enhancer"] = False
+            update_status("Transparency set to 0% - Face swapping disabled.")
+        elif pct == 100:
+            modules.globals.face_swapper_enabled = True
+            update_status("Transparency set to 100%.")
+        else:
+            modules.globals.face_swapper_enabled = True
+            update_status(f"Transparency set to {pct}%")
+
+    def _on_sharpness_change(self, value: float) -> None:
+        modules.globals.sharpness = value
+        update_status(f"Sharpness set to {value:.1f}")
+
+    def _on_mouth_mask_change(self, value: float) -> None:
+        modules.globals.mouth_mask_size = value
+        modules.globals.mouth_mask = value > 0
+        if value <= 0:
+            modules.globals.show_mouth_mask_box = False
+
+    def _on_mouth_mask_pressed(self) -> None:
+        if modules.globals.mouth_mask_size > 0:
+            modules.globals.show_mouth_mask_box = True
+
+    def _on_mouth_mask_released(self) -> None:
+        modules.globals.show_mouth_mask_box = False
+
+    def _on_start(self) -> None:
+        if _MAPPER is not None and _MAPPER.isVisible():
+            update_status("Please complete pop-up or close it.")
+            return
+        if modules.globals.map_faces:
+            modules.globals.source_target_map = []
+            if is_image(modules.globals.target_path):
+                update_status("Getting unique faces")
+                get_unique_faces_from_target_image()
+            elif is_video(modules.globals.target_path):
+                update_status("Getting unique faces")
+                get_unique_faces_from_target_video()
+            if modules.globals.source_target_map:
+                _open_mapper_dialog(self._start_cb, modules.globals.source_target_map)
+            else:
+                update_status("No faces found in target")
+        else:
+            self._select_output_and_start()
+
+    def _select_output_and_start(self) -> None:
+        global _RECENT_OUTPUT_DIR
+        if is_image(modules.globals.target_path):
+            path, _f = QFileDialog.getSaveFileName(
+                self, _("save image output file"),
+                os.path.join(_RECENT_OUTPUT_DIR or "", "output.png"),
+                "Images (*.png *.jpg *.jpeg *.bmp)",
+            )
+        elif is_video(modules.globals.target_path):
+            path, _f = QFileDialog.getSaveFileName(
+                self, _("save video output file"),
+                os.path.join(_RECENT_OUTPUT_DIR or "", "output.mp4"),
+                "Videos (*.mp4 *.mkv)",
+            )
+        else:
+            return
+        if path:
+            modules.globals.output_path = path
+            _RECENT_OUTPUT_DIR = os.path.dirname(path)
+            self._start_cb()
+
+    def _on_toggle_preview(self) -> None:
+        if _PREVIEW is None:
+            return
+        if _PREVIEW.isVisible():
+            _PREVIEW.hide()
+        elif modules.globals.source_path and modules.globals.target_path:
+            _PREVIEW.init_for_target()
+            _PREVIEW.refresh_frame(0)
+            _PREVIEW.show()
+
+    def _on_live(self) -> None:
+        idx = self.cb_camera.currentIndex()
+        if idx < 0 or idx >= len(self._camera_indices):
+            update_status("No camera available")
+            return
+        camera_index = self._camera_indices[idx]
+        if _LIVE_MAPPER is not None and _LIVE_MAPPER.isVisible():
+            update_status("Source x Target Mapper is already open.")
+            _LIVE_MAPPER.raise_()
+            return
+        if not modules.globals.map_faces:
+            if modules.globals.source_path is None:
+                update_status("Please select a source image first")
+                return
+            from modules.face_analyser import get_face_analyser
+            from modules.processors.frame.face_swapper import get_face_swapper
+            get_face_analyser()
+            get_face_swapper()
+            _open_webcam_preview(camera_index)
+        else:
+            modules.globals.source_target_map = []
+            _open_live_mapper_dialog(camera_index, modules.globals.source_target_map)
+
+    def closeEvent(self, event):
+        # Treat OS-level close as Destroy click
+        self._destroy_cb()
+        event.accept()
+
+
+def _update_tumbler(var: str, value: bool) -> None:
+    modules.globals.fp_ui[var] = value
+    save_switch_states()
+    # If we're currently in a live preview, refresh frame processors so
+    # toggling enhancers takes effect immediately.
+    if _WEBCAM_PREVIEW is not None and _WEBCAM_PREVIEW.isVisible():
+        get_frame_processors_modules(modules.globals.frame_processors)
+
+
+# ─── preview window (still-image / video scrub) ──────────────────────────
+
+
+class PreviewWindow(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle(_("Preview"))
+        self.resize(PREVIEW_DEFAULT_WIDTH, PREVIEW_DEFAULT_HEIGHT)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self._image_label = QLabel()
+        self._image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._image_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        layout.addWidget(self._image_label, 1)
+
+        self._slider = QSlider(Qt.Orientation.Horizontal)
+        self._slider.setRange(0, 0)
+        self._slider.valueChanged.connect(self.refresh_frame)
+        layout.addWidget(self._slider)
+
+    def init_for_target(self) -> None:
+        if is_image(modules.globals.target_path):
+            self._slider.hide()
+        elif is_video(modules.globals.target_path):
+            total = get_video_frame_total(modules.globals.target_path)
+            self._slider.setRange(0, max(0, total - 1))
+            self._slider.setValue(0)
+            self._slider.show()
+
+    def refresh_frame(self, frame_number: int = 0) -> None:
+        if not (modules.globals.source_path and modules.globals.target_path):
+            return
+        update_status("Processing...")
+        temp_frame = get_video_frame(modules.globals.target_path, frame_number)
+        if modules.globals.nsfw_filter and check_and_ignore_nsfw(temp_frame):
+            return
+        from modules.processors.frame.core import get_frame_processors_modules as _gfpm
+        for fp in _gfpm(modules.globals.frame_processors):
+            temp_frame = fp.process_frame(
+                get_one_face(cv2.imread(modules.globals.source_path)), temp_frame
+            )
+        # Fit to current widget size while preserving aspect ratio.
+        h, w = temp_frame.shape[:2]
+        bound_w = min(PREVIEW_MAX_WIDTH, max(self.width(), PREVIEW_DEFAULT_WIDTH))
+        bound_h = min(PREVIEW_MAX_HEIGHT, max(self.height(), PREVIEW_DEFAULT_HEIGHT))
+        ratio = min(bound_w / w, bound_h / h)
+        new_size = (max(1, int(w * ratio)), max(1, int(h * ratio)))
+        temp_frame = cv2.resize(temp_frame, new_size, interpolation=cv2.INTER_LANCZOS4)
+        self._image_label.setPixmap(_bgr_to_qpixmap(temp_frame))
+        update_status("Processing succeed!")
+
+
+# ─── webcam preview window ───────────────────────────────────────────────
+
+
+class _CaptureWorker(QThread):
+    """Reads frames from the camera into a bounded queue. Drops on overflow."""
+
+    def __init__(self, cap, capture_queue: queue.Queue, stop_event: threading.Event):
+        super().__init__()
+        self._cap = cap
+        self._queue = capture_queue
+        self._stop = stop_event
+
+    def run(self) -> None:
+        while not self._stop.is_set():
+            ret, frame = self._cap.read()
+            if not ret:
+                self._stop.set()
+                break
             try:
-                processed_queue.get_nowait()
-            except queue.Empty:
-                pass
-            try:
-                processed_queue.put_nowait(temp_frame)
+                self._queue.put_nowait(frame)
             except queue.Full:
-                pass
+                try:
+                    self._queue.get_nowait()
+                except queue.Empty:
+                    pass
+                try:
+                    self._queue.put_nowait(frame)
+                except queue.Full:
+                    pass
 
 
-def create_webcam_preview(camera_index: int):
-    global preview_label, PREVIEW
+class _ProcessingWorker(QThread):
+    """Pulls raw frames, runs detect/swap/enhance, pushes processed frames."""
 
-    cap = VideoCapturer(camera_index)
-    # Capture at preview window size — drops USB bandwidth and processing cost
-    # vs. capturing at 1080p and downscaling. The camera negotiates the closest
-    # mode it supports, which is usually a clean 16:9 resolution at least this
-    # size; cv2 downscales the rest on the fly.
-    if not cap.start(PREVIEW_DEFAULT_WIDTH, PREVIEW_DEFAULT_HEIGHT, 60):
-        update_status("Failed to start camera")
-        return
+    def __init__(self, capture_queue, processed_queue, stop_event, camera_fps: float):
+        super().__init__()
+        self._cq = capture_queue
+        self._pq = processed_queue
+        self._stop = stop_event
+        self._fps = camera_fps
 
-    camera_fps = cap.actual_fps
-    print(f"[webcam] Camera running at {cap.actual_width}x{cap.actual_height}@{camera_fps:.0f}fps")
+    def run(self) -> None:
+        frame_processors = get_frame_processors_modules(modules.globals.frame_processors)
+        source_image = None
+        last_source_path = None
+        prev_time = time.time()
+        fps_update_interval = 0.5
+        frame_count = 0
+        fps = 0.0
+        det_count = 0
+        cached_target_face = None
+        cached_many_faces = None
+        det_interval = max(1, round(self._fps * 0.08))
 
-    preview_label.configure(width=PREVIEW_DEFAULT_WIDTH, height=PREVIEW_DEFAULT_HEIGHT)
-    PREVIEW.deiconify()
+        while not self._stop.is_set():
+            try:
+                frame = self._cq.get(timeout=0.05)
+            except queue.Empty:
+                continue
 
-    # Queues for decoupling capture from processing and processing from display.
-    # Small maxsize ensures we always work on recent frames and drop stale ones.
-    capture_queue = queue.Queue(maxsize=2)
-    processed_queue = queue.Queue(maxsize=2)
-    stop_event = threading.Event()
+            temp_frame = frame
+            if modules.globals.live_mirror:
+                temp_frame = gpu_flip(temp_frame, 1)
 
-    # Start capture thread
-    cap_thread = threading.Thread(
-        target=_capture_thread_func,
-        args=(cap, capture_queue, stop_event),
-        daemon=True,
-    )
-    cap_thread.start()
+            if not modules.globals.map_faces:
+                if (
+                    modules.globals.source_path
+                    and modules.globals.source_path != last_source_path
+                ):
+                    last_source_path = modules.globals.source_path
+                    source_image = get_one_face(cv2.imread(modules.globals.source_path))
 
-    # Start processing thread
-    proc_thread = threading.Thread(
-        target=_processing_thread_func,
-        args=(capture_queue, processed_queue, stop_event, camera_fps),
-        daemon=True,
-    )
-    proc_thread.start()
+                det_count += 1
+                if det_count % det_interval == 0:
+                    if modules.globals.many_faces:
+                        cached_target_face = None
+                        cached_many_faces = detect_many_faces_fast(temp_frame)
+                    else:
+                        cached_target_face = detect_one_face_fast(temp_frame)
+                        cached_many_faces = None
 
-    # Cleanup helper called from the display loop when preview closes
-    def _cleanup():
-        stop_event.set()
-        cap_thread.join(timeout=2.0)
-        proc_thread.join(timeout=2.0)
-        cap.release()
-        PREVIEW.withdraw()
+                cached_faces = None
+                if cached_many_faces:
+                    cached_faces = cached_many_faces
+                elif cached_target_face is not None:
+                    cached_faces = [cached_target_face]
 
-    # Poll at ~2x camera FPS (Nyquist) so we pick up frames promptly
-    # without burning CPU.  Clamped to [1, 16] ms.
-    poll_ms = max(1, min(16, int(500 / camera_fps)))
+                for fp in frame_processors:
+                    if fp.NAME == "DLC.FACE-ENHANCER":
+                        if modules.globals.fp_ui["face_enhancer"]:
+                            temp_frame = fp.process_frame(
+                                None, temp_frame, detected_faces=cached_faces
+                            )
+                    elif fp.NAME == "DLC.FACE-ENHANCER-GPEN256":
+                        if modules.globals.fp_ui.get("face_enhancer_gpen256", False):
+                            temp_frame = fp.process_frame(
+                                None, temp_frame, detected_faces=cached_faces
+                            )
+                    elif fp.NAME == "DLC.FACE-ENHANCER-GPEN512":
+                        if modules.globals.fp_ui.get("face_enhancer_gpen512", False):
+                            temp_frame = fp.process_frame(
+                                None, temp_frame, detected_faces=cached_faces
+                            )
+                    elif fp.NAME == "DLC.FACE-SWAPPER":
+                        swapped_bboxes = []
+                        if modules.globals.many_faces and cached_many_faces:
+                            result = temp_frame.copy()
+                            for t_face in cached_many_faces:
+                                result = fp.swap_face(source_image, t_face, result)
+                                if hasattr(t_face, "bbox") and t_face.bbox is not None:
+                                    swapped_bboxes.append(t_face.bbox.astype(int))
+                            temp_frame = result
+                        elif cached_target_face is not None:
+                            temp_frame = fp.swap_face(
+                                source_image, cached_target_face, temp_frame
+                            )
+                            if (
+                                hasattr(cached_target_face, "bbox")
+                                and cached_target_face.bbox is not None
+                            ):
+                                swapped_bboxes.append(cached_target_face.bbox.astype(int))
+                        temp_frame = fp.apply_post_processing(temp_frame, swapped_bboxes)
+                    else:
+                        temp_frame = fp.process_frame(source_image, temp_frame)
+            else:
+                modules.globals.target_path = None
+                for fp in frame_processors:
+                    if fp.NAME == "DLC.FACE-ENHANCER":
+                        if modules.globals.fp_ui["face_enhancer"]:
+                            temp_frame = fp.process_frame_v2(temp_frame)
+                    elif fp.NAME in ("DLC.FACE-ENHANCER-GPEN256", "DLC.FACE-ENHANCER-GPEN512"):
+                        fp_key = fp.NAME.split(".")[-1].lower().replace("-", "_")
+                        if modules.globals.fp_ui.get(fp_key, False):
+                            temp_frame = fp.process_frame_v2(temp_frame)
+                    else:
+                        temp_frame = fp.process_frame_v2(temp_frame)
 
-    # Non-blocking display loop using ROOT.after() — avoids blocking the
-    # Tk event loop which could cause UI freezes or re-entrancy issues.
-    def _display_next_frame():
-        if stop_event.is_set() or PREVIEW.state() == "withdrawn":
-            _cleanup()
+            current_time = time.time()
+            frame_count += 1
+            if current_time - prev_time >= fps_update_interval:
+                fps = frame_count / (current_time - prev_time)
+                frame_count = 0
+                prev_time = current_time
+
+            if modules.globals.show_fps:
+                cv2.putText(
+                    temp_frame, f"FPS: {fps:.1f}", (10, 30),
+                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2,
+                )
+
+            try:
+                self._pq.put_nowait(temp_frame)
+            except queue.Full:
+                try:
+                    self._pq.get_nowait()
+                except queue.Empty:
+                    pass
+                try:
+                    self._pq.put_nowait(temp_frame)
+                except queue.Full:
+                    pass
+
+
+class WebcamPreviewWindow(QWidget):
+    def __init__(self, camera_index: int):
+        super().__init__()
+        self.setWindowTitle("Live Preview")
+        self.resize(PREVIEW_DEFAULT_WIDTH, PREVIEW_DEFAULT_HEIGHT)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self._image_label = QLabel()
+        self._image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._image_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        layout.addWidget(self._image_label, 1)
+
+        self._cap = VideoCapturer(camera_index)
+        if not self._cap.start(PREVIEW_DEFAULT_WIDTH, PREVIEW_DEFAULT_HEIGHT, 60):
+            update_status("Failed to start camera")
+            QTimer.singleShot(0, self.close)
             return
 
-        try:
-            bgr_frame = processed_queue.get_nowait()
-        except queue.Empty:
-            ROOT.after(poll_ms, _display_next_frame)
-            return
-
-        # Resize the full-resolution BGR frame to the preview window first,
-        # then convert colour on the smaller buffer.
-        bgr_frame = fit_image_to_size(
-            bgr_frame, PREVIEW.winfo_width(), PREVIEW.winfo_height()
+        camera_fps = self._cap.actual_fps
+        print(
+            f"[webcam] Camera running at {self._cap.actual_width}x"
+            f"{self._cap.actual_height}@{camera_fps:.0f}fps"
         )
-        rgb_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2RGB)
-        image = Image.fromarray(rgb_frame)
-        image = ctk.CTkImage(image, size=image.size)
-        preview_label.configure(image=image)
 
-        ROOT.after(poll_ms, _display_next_frame)
+        self._capture_queue: queue.Queue = queue.Queue(maxsize=2)
+        self._processed_queue: queue.Queue = queue.Queue(maxsize=2)
+        self._stop_event = threading.Event()
 
-    # Kick off the non-blocking display loop
-    ROOT.after(0, _display_next_frame)
+        self._capture_worker = _CaptureWorker(
+            self._cap, self._capture_queue, self._stop_event
+        )
+        self._processing_worker = _ProcessingWorker(
+            self._capture_queue, self._processed_queue, self._stop_event, camera_fps
+        )
+        self._capture_worker.start()
+        self._processing_worker.start()
+
+        # Poll at ~2x camera fps so we never block but also don't burn CPU.
+        poll_ms = max(1, min(16, int(500 / max(camera_fps, 1))))
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._tick)
+        self._timer.start(poll_ms)
+
+    def _tick(self) -> None:
+        if self._stop_event.is_set():
+            self.close()
+            return
+        try:
+            bgr_frame = self._processed_queue.get_nowait()
+        except queue.Empty:
+            return
+        bgr_frame = fit_image_to_size(bgr_frame, self.width(), self.height())
+        self._image_label.setPixmap(_bgr_to_qpixmap(bgr_frame))
+
+    def closeEvent(self, event) -> None:
+        self._stop_event.set()
+        try:
+            self._timer.stop()
+        except Exception:
+            pass
+        for worker in (self._capture_worker, self._processing_worker):
+            try:
+                worker.wait(2000)
+            except Exception:
+                pass
+        try:
+            self._cap.release()
+        except Exception:
+            pass
+        global _WEBCAM_PREVIEW
+        if _WEBCAM_PREVIEW is self:
+            _WEBCAM_PREVIEW = None
+        event.accept()
 
 
-def create_source_target_popup_for_webcam(
-        root: ctk.CTk, map: list, camera_index: int
-) -> None:
-    global POPUP_LIVE, popup_status_label_live
+def _open_webcam_preview(camera_index: int) -> None:
+    global _WEBCAM_PREVIEW
+    if _WEBCAM_PREVIEW is not None:
+        _WEBCAM_PREVIEW.close()
+    _WEBCAM_PREVIEW = WebcamPreviewWindow(camera_index)
+    _WEBCAM_PREVIEW.show()
 
-    POPUP_LIVE = ctk.CTkToplevel(root)
-    POPUP_LIVE.title(_("Source x Target Mapper"))
-    POPUP_LIVE.geometry(f"{POPUP_LIVE_WIDTH}x{POPUP_LIVE_HEIGHT}")
-    POPUP_LIVE.focus()
 
-    def on_submit_click():
+# ─── mapper dialogs (image/video + live) ────────────────────────────────
+
+
+def _make_thumb(cv2_img: np.ndarray) -> QPixmap:
+    rgb = gpu_cvt_color(cv2_img, cv2.COLOR_BGR2RGB)
+    image = Image.fromarray(rgb).resize(
+        (MAPPER_PREVIEW_SIZE, MAPPER_PREVIEW_SIZE), Image.LANCZOS
+    )
+    return _pil_to_qpixmap(image)
+
+
+class MapperDialog(QDialog):
+    """Source × Target mapper for image / video processing."""
+
+    def __init__(self, start_cb: Callable, mapping: list):
+        super().__init__(_MAIN)
+        self._start_cb = start_cb
+        self._map = mapping
+        self.setWindowTitle(_("Source x Target Mapper"))
+        self.resize(POPUP_WIDTH, POPUP_HEIGHT)
+        layout = QVBoxLayout(self)
+
+        self._scroll = QScrollArea()
+        self._scroll.setWidgetResizable(True)
+        layout.addWidget(self._scroll, 1)
+
+        self._status = QLabel("")
+        self._status.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self._status)
+
+        btn_submit = QPushButton(_("Submit"))
+        btn_submit.clicked.connect(self._on_submit)
+        layout.addWidget(btn_submit, alignment=Qt.AlignmentFlag.AlignCenter)
+
+        self._rebuild()
+
+    def set_status(self, text: str) -> None:
+        self._status.setText(_(text))
+
+    def _rebuild(self) -> None:
+        body = QWidget()
+        grid = QGridLayout(body)
+        grid.setHorizontalSpacing(10)
+        grid.setVerticalSpacing(10)
+        for item in self._map:
+            row = item["id"]
+            btn = QPushButton(_("Select source image"))
+            btn.setFixedWidth(200)
+            btn.clicked.connect(lambda _c, n=row: self._select_source(n))
+            grid.addWidget(btn, row, 0)
+
+            src_label = QLabel(f"S-{row}")
+            src_label.setFixedSize(MAPPER_PREVIEW_SIZE, MAPPER_PREVIEW_SIZE)
+            src_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            src_label.setStyleSheet("border: 1px dashed #555;")
+            grid.addWidget(src_label, row, 1)
+            if "source" in item:
+                src_label.setPixmap(_make_thumb(item["source"]["cv2"]))
+                src_label.setText("")
+
+            x_label = QLabel("×")
+            x_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            grid.addWidget(x_label, row, 2)
+
+            tgt_label = QLabel(f"T-{row}")
+            tgt_label.setFixedSize(MAPPER_PREVIEW_SIZE, MAPPER_PREVIEW_SIZE)
+            tgt_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            tgt_label.setStyleSheet("border: 1px solid #555;")
+            grid.addWidget(tgt_label, row, 3)
+            if "target" in item:
+                tgt_label.setPixmap(_make_thumb(item["target"]["cv2"]))
+                tgt_label.setText("")
+
+        grid.setRowStretch(grid.rowCount(), 1)
+        self._scroll.setWidget(body)
+
+    def _select_source(self, row: int) -> None:
+        path, _f = QFileDialog.getOpenFileName(
+            self, _("select an source image"),
+            _RECENT_SOURCE_DIR or "",
+            "Images (*.png *.jpg *.jpeg *.gif *.bmp)",
+        )
+        if not path:
+            return
+        cv2_img = cv2.imread(path)
+        face = get_one_face(cv2_img)
+        if face is None:
+            self.set_status("Face could not be detected in last upload!")
+            return
+        x_min, y_min, x_max, y_max = face["bbox"]
+        self._map[row]["source"] = {
+            "cv2": cv2_img[int(y_min):int(y_max), int(x_min):int(x_max)],
+            "face": face,
+        }
+        self._rebuild()
+
+    def _on_submit(self) -> None:
+        if has_valid_map():
+            self.accept()
+            _MAIN._select_output_and_start()
+        else:
+            self.set_status("Atleast 1 source with target is required!")
+
+
+class LiveMapperDialog(QDialog):
+    """Source × Target mapper for live webcam mode."""
+
+    def __init__(self, camera_index: int, mapping: list):
+        super().__init__(_MAIN)
+        self._camera_index = camera_index
+        self._map = mapping
+        self.setWindowTitle(_("Source x Target Mapper"))
+        self.resize(POPUP_LIVE_WIDTH, POPUP_LIVE_HEIGHT)
+        layout = QVBoxLayout(self)
+
+        self._scroll = QScrollArea()
+        self._scroll.setWidgetResizable(True)
+        layout.addWidget(self._scroll, 1)
+
+        self._status = QLabel("")
+        self._status.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self._status)
+
+        btn_row = QHBoxLayout()
+        for text, slot in (
+            (_("Add"), self._on_add),
+            (_("Clear"), self._on_clear),
+            (_("Submit"), self._on_submit),
+        ):
+            b = QPushButton(text)
+            b.clicked.connect(slot)
+            btn_row.addWidget(b)
+        layout.addLayout(btn_row)
+
+        self._rebuild()
+
+    def set_status(self, text: str) -> None:
+        self._status.setText(_(text))
+
+    def _rebuild(self) -> None:
+        body = QWidget()
+        grid = QGridLayout(body)
+        grid.setHorizontalSpacing(10)
+        grid.setVerticalSpacing(10)
+        for item in self._map:
+            row = item["id"]
+            btn_s = QPushButton(_("Select source image"))
+            btn_s.setFixedWidth(200)
+            btn_s.clicked.connect(lambda _c, n=row: self._select_face(n, "source"))
+            grid.addWidget(btn_s, row, 0)
+
+            src_label = QLabel(f"S-{row}")
+            src_label.setFixedSize(MAPPER_PREVIEW_SIZE, MAPPER_PREVIEW_SIZE)
+            src_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            src_label.setStyleSheet("border: 1px dashed #555;")
+            grid.addWidget(src_label, row, 1)
+            if "source" in item:
+                src_label.setPixmap(_make_thumb(item["source"]["cv2"]))
+                src_label.setText("")
+
+            x_label = QLabel("×")
+            x_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            grid.addWidget(x_label, row, 2)
+
+            btn_t = QPushButton(_("Select target image"))
+            btn_t.setFixedWidth(200)
+            btn_t.clicked.connect(lambda _c, n=row: self._select_face(n, "target"))
+            grid.addWidget(btn_t, row, 3)
+
+            tgt_label = QLabel(f"T-{row}")
+            tgt_label.setFixedSize(MAPPER_PREVIEW_SIZE, MAPPER_PREVIEW_SIZE)
+            tgt_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            tgt_label.setStyleSheet("border: 1px dashed #555;")
+            grid.addWidget(tgt_label, row, 4)
+            if "target" in item:
+                tgt_label.setPixmap(_make_thumb(item["target"]["cv2"]))
+                tgt_label.setText("")
+
+        grid.setRowStretch(grid.rowCount(), 1)
+        self._scroll.setWidget(body)
+
+    def _select_face(self, row: int, kind: str) -> None:
+        path, _f = QFileDialog.getOpenFileName(
+            self, _("select an source image"),
+            _RECENT_SOURCE_DIR or "",
+            "Images (*.png *.jpg *.jpeg *.gif *.bmp)",
+        )
+        if not path:
+            return
+        cv2_img = cv2.imread(path)
+        face = get_one_face(cv2_img)
+        if face is None:
+            self.set_status("Face could not be detected in last upload!")
+            return
+        x_min, y_min, x_max, y_max = face["bbox"]
+        self._map[row][kind] = {
+            "cv2": cv2_img[int(y_min):int(y_max), int(x_min):int(x_max)],
+            "face": face,
+        }
+        self._rebuild()
+
+    def _on_add(self) -> None:
+        add_blank_map()
+        self._rebuild()
+        self.set_status("Please provide mapping!")
+
+    def _on_clear(self) -> None:
+        for item in self._map:
+            item.pop("source", None)
+            item.pop("target", None)
+        self._rebuild()
+        self.set_status("All mappings cleared!")
+
+    def _on_submit(self) -> None:
         if has_valid_map():
             simplify_maps()
-            update_pop_live_status("Mappings successfully submitted!")
-            create_webcam_preview(camera_index)  # Open the preview window
+            self.set_status("Mappings successfully submitted!")
+            self.accept()
+            _open_webcam_preview(self._camera_index)
         else:
-            update_pop_live_status("At least 1 source with target is required!")
-
-    def on_add_click():
-        add_blank_map()
-        refresh_data(map)
-        update_pop_live_status("Please provide mapping!")
-
-    def on_clear_click():
-        clear_source_target_images(map)
-        refresh_data(map)
-        update_pop_live_status("All mappings cleared!")
-
-    popup_status_label_live = ctk.CTkLabel(POPUP_LIVE, text=None, justify="center")
-    popup_status_label_live.grid(row=1, column=0, pady=15)
-
-    add_button = ctk.CTkButton(POPUP_LIVE, text=_("Add"), command=lambda: on_add_click())
-    add_button.place(relx=0.1, rely=0.92, relwidth=0.2, relheight=0.05)
-
-    clear_button = ctk.CTkButton(POPUP_LIVE, text=_("Clear"), command=lambda: on_clear_click())
-    clear_button.place(relx=0.4, rely=0.92, relwidth=0.2, relheight=0.05)
-
-    close_button = ctk.CTkButton(
-        POPUP_LIVE, text=_("Submit"), command=lambda: on_submit_click()
-    )
-    close_button.place(relx=0.7, rely=0.92, relwidth=0.2, relheight=0.05)
+            self.set_status("At least 1 source with target is required!")
 
 
-
-def clear_source_target_images(map: list):
-    global source_label_dict_live, target_label_dict_live
-
-    for item in map:
-        if "source" in item:
-            del item["source"]
-        if "target" in item:
-            del item["target"]
-
-    for button_num in list(source_label_dict_live.keys()):
-        source_label_dict_live[button_num].destroy()
-        del source_label_dict_live[button_num]
-
-    for button_num in list(target_label_dict_live.keys()):
-        target_label_dict_live[button_num].destroy()
-        del target_label_dict_live[button_num]
+def _open_mapper_dialog(start_cb: Callable, mapping: list) -> None:
+    global _MAPPER
+    close_mapper_window()
+    _MAPPER = MapperDialog(start_cb, mapping)
+    _MAPPER.show()
 
 
-def refresh_data(map: list):
-    global POPUP_LIVE
-
-    scrollable_frame = ctk.CTkScrollableFrame(
-        POPUP_LIVE, width=POPUP_LIVE_SCROLL_WIDTH, height=POPUP_LIVE_SCROLL_HEIGHT
-    )
-    scrollable_frame.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
-
-    def on_sbutton_click(map, button_num):
-        map = update_webcam_source(scrollable_frame, map, button_num)
-
-    def on_tbutton_click(map, button_num):
-        map = update_webcam_target(scrollable_frame, map, button_num)
-
-    for item in map:
-        id = item["id"]
-
-        button = ctk.CTkButton(
-            scrollable_frame,
-            text=_("Select source image"),
-            command=lambda id=id: on_sbutton_click(map, id),
-            width=DEFAULT_BUTTON_WIDTH,
-            height=DEFAULT_BUTTON_HEIGHT,
-        )
-        button.grid(row=id, column=0, padx=30, pady=10)
-
-        x_label = ctk.CTkLabel(
-            scrollable_frame,
-            text=f"X",
-            width=MAPPER_PREVIEW_MAX_WIDTH,
-            height=MAPPER_PREVIEW_MAX_HEIGHT,
-        )
-        x_label.grid(row=id, column=2, padx=10, pady=10)
-
-        button = ctk.CTkButton(
-            scrollable_frame,
-            text=_("Select target image"),
-            command=lambda id=id: on_tbutton_click(map, id),
-            width=DEFAULT_BUTTON_WIDTH,
-            height=DEFAULT_BUTTON_HEIGHT,
-        )
-        button.grid(row=id, column=3, padx=20, pady=10)
-
-        if "source" in item:
-            image = Image.fromarray(
-                gpu_cvt_color(item["source"]["cv2"], cv2.COLOR_BGR2RGB)
-            )
-            image = image.resize(
-                (MAPPER_PREVIEW_MAX_WIDTH, MAPPER_PREVIEW_MAX_HEIGHT), Image.LANCZOS
-            )
-            tk_image = ctk.CTkImage(image, size=image.size)
-
-            source_image = ctk.CTkLabel(
-                scrollable_frame,
-                text=f"S-{id}",
-                width=MAPPER_PREVIEW_MAX_WIDTH,
-                height=MAPPER_PREVIEW_MAX_HEIGHT,
-            )
-            source_image.grid(row=id, column=1, padx=10, pady=10)
-            source_image.configure(image=tk_image)
-
-        if "target" in item:
-            image = Image.fromarray(
-                gpu_cvt_color(item["target"]["cv2"], cv2.COLOR_BGR2RGB)
-            )
-            image = image.resize(
-                (MAPPER_PREVIEW_MAX_WIDTH, MAPPER_PREVIEW_MAX_HEIGHT), Image.LANCZOS
-            )
-            tk_image = ctk.CTkImage(image, size=image.size)
-
-            target_image = ctk.CTkLabel(
-                scrollable_frame,
-                text=f"T-{id}",
-                width=MAPPER_PREVIEW_MAX_WIDTH,
-                height=MAPPER_PREVIEW_MAX_HEIGHT,
-            )
-            target_image.grid(row=id, column=4, padx=20, pady=10)
-            target_image.configure(image=tk_image)
+def _open_live_mapper_dialog(camera_index: int, mapping: list) -> None:
+    global _LIVE_MAPPER
+    close_mapper_window()
+    _LIVE_MAPPER = LiveMapperDialog(camera_index, mapping)
+    _LIVE_MAPPER.show()
 
 
-def update_webcam_source(
-        scrollable_frame: ctk.CTkScrollableFrame, map: list, button_num: int
-) -> list:
-    global source_label_dict_live
+def close_mapper_window() -> None:
+    global _MAPPER, _LIVE_MAPPER
+    if _MAPPER is not None:
+        _MAPPER.close()
+        _MAPPER = None
+    if _LIVE_MAPPER is not None:
+        _LIVE_MAPPER.close()
+        _LIVE_MAPPER = None
 
-    source_path = ctk.filedialog.askopenfilename(
-        title=_("select an source image"),
-        initialdir=RECENT_DIRECTORY_SOURCE,
-        filetypes=[img_ft],
-    )
 
-    if "source" in map[button_num]:
-        map[button_num].pop("source")
-        source_label_dict_live[button_num].destroy()
-        del source_label_dict_live[button_num]
+# ─── entry point ─────────────────────────────────────────────────────────
 
-    if source_path == "":
-        return map
+
+class _Window:
+    """Thin wrapper exposing .mainloop() for core.py compatibility."""
+
+    def __init__(self, app: QApplication, main_window: MainWindow):
+        self._app = app
+        self._main = main_window
+
+    def mainloop(self) -> None:
+        self._main.show()
+        self._app.exec()
+
+
+def init(
+    start: Callable[[], None], destroy: Callable[[], None], lang: str
+) -> _Window:
+    global _APP, _MAIN, _PREVIEW, _LANG, _BRIDGE
+
+    _LANG = LanguageManager(lang)
+    if QApplication.instance() is None:
+        _APP = QApplication(sys.argv)
     else:
-        cv2_img = cv2.imread(source_path)
-        face = get_one_face(cv2_img)
+        _APP = QApplication.instance()
+    _APP.setStyleSheet(QSS)
 
-        if face:
-            x_min, y_min, x_max, y_max = face["bbox"]
+    _BRIDGE = _UIBridge()
+    _MAIN = MainWindow(start, destroy)
+    _PREVIEW = PreviewWindow()
 
-            map[button_num]["source"] = {
-                "cv2": cv2_img[int(y_min): int(y_max), int(x_min): int(x_max)],
-                "face": face,
-            }
-
-            image = Image.fromarray(
-                gpu_cvt_color(map[button_num]["source"]["cv2"], cv2.COLOR_BGR2RGB)
-            )
-            image = image.resize(
-                (MAPPER_PREVIEW_MAX_WIDTH, MAPPER_PREVIEW_MAX_HEIGHT), Image.LANCZOS
-            )
-            tk_image = ctk.CTkImage(image, size=image.size)
-
-            source_image = ctk.CTkLabel(
-                scrollable_frame,
-                text=f"S-{button_num}",
-                width=MAPPER_PREVIEW_MAX_WIDTH,
-                height=MAPPER_PREVIEW_MAX_HEIGHT,
-            )
-            source_image.grid(row=button_num, column=1, padx=10, pady=10)
-            source_image.configure(image=tk_image)
-            source_label_dict_live[button_num] = source_image
-        else:
-            update_pop_live_status("Face could not be detected in last upload!")
-        return map
-
-
-def update_webcam_target(
-        scrollable_frame: ctk.CTkScrollableFrame, map: list, button_num: int
-) -> list:
-    global target_label_dict_live
-
-    target_path = ctk.filedialog.askopenfilename(
-        title=_("select an target image"),
-        initialdir=RECENT_DIRECTORY_SOURCE,
-        filetypes=[img_ft],
-    )
-
-    if "target" in map[button_num]:
-        map[button_num].pop("target")
-        target_label_dict_live[button_num].destroy()
-        del target_label_dict_live[button_num]
-
-    if target_path == "":
-        return map
-    else:
-        cv2_img = cv2.imread(target_path)
-        face = get_one_face(cv2_img)
-
-        if face:
-            x_min, y_min, x_max, y_max = face["bbox"]
-
-            map[button_num]["target"] = {
-                "cv2": cv2_img[int(y_min): int(y_max), int(x_min): int(x_max)],
-                "face": face,
-            }
-
-            image = Image.fromarray(
-                gpu_cvt_color(map[button_num]["target"]["cv2"], cv2.COLOR_BGR2RGB)
-            )
-            image = image.resize(
-                (MAPPER_PREVIEW_MAX_WIDTH, MAPPER_PREVIEW_MAX_HEIGHT), Image.LANCZOS
-            )
-            tk_image = ctk.CTkImage(image, size=image.size)
-
-            target_image = ctk.CTkLabel(
-                scrollable_frame,
-                text=f"T-{button_num}",
-                width=MAPPER_PREVIEW_MAX_WIDTH,
-                height=MAPPER_PREVIEW_MAX_HEIGHT,
-            )
-            target_image.grid(row=button_num, column=4, padx=20, pady=10)
-            target_image.configure(image=tk_image)
-            target_label_dict_live[button_num] = target_image
-        else:
-            update_pop_live_status("Face could not be detected in last upload!")
-        return map
+    # Route status updates onto the UI thread regardless of caller.
+    _BRIDGE.statusChanged.connect(_MAIN.set_status)
 
+    return _Window(_APP, _MAIN)
diff --git a/requirements.txt b/requirements.txt
index 21d4830..3383d46 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,8 +5,7 @@ cv2_enumerate_cameras==1.1.15
 onnx==1.18.0
 insightface==0.7.3
 psutil==5.9.8
-tk==0.1.0
-customtkinter==5.2.2
+PySide6>=6.7,<7
 pillow==12.1.1
 tqdm>=4.65.0
 onnxruntime-silicon==1.16.3; sys_platform == 'darwin' and platform_machine == 'arm64'
diff --git a/run.py b/run.py
index 7d22660..b7927df 100644
--- a/run.py
+++ b/run.py
@@ -31,9 +31,6 @@ if sys.platform == "win32":
             except (OSError, AttributeError):
                 pass
 
-# Import the tkinter fix to patch the ScreenChanged error
-import tkinter_fix
-
 from modules import platform_info
 platform_info.print_banner()