[fix] update MiniRTC: refactor IceAgent to improve stability

[fix] fix Linux audio fallback when audio devices are unavaliable
[fix] fix blocking join() in Linux clipboard monitor thread during shutdown
2026-03-22 15:59:07 +08:00 · 2026-03-20 15:58:59 +08:00 · 2026-03-20 15:14:45 +08:00 · 2026-03-20 15:02:34 +08:00 · 2026-03-20 14:56:40 +08:00 · 2026-03-20 14:50:42 +08:00
40 changed files with 1155 additions and 560 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -58,7 +58,7 @@ jobs:
          echo "BUILD_DATE=${BUILD_DATE}" >> $GITHUB_ENV

      - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: recursive

@@ -76,7 +76,7 @@ jobs:
          ${{ matrix.package_script }} ${LEGAL_VERSION}

      - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: crossdesk-linux-${{ matrix.arch }}-${{ env.LEGAL_VERSION }}
          path: ${{ github.workspace }}/crossdesk-linux-${{ matrix.arch }}-${{ env.LEGAL_VERSION }}.deb
@@ -112,7 +112,7 @@ jobs:
          echo "BUILD_DATE=${BUILD_DATE}" >> $GITHUB_ENV

      - name: Cache xmake dependencies
-        uses: actions/cache@v4
+        uses: actions/cache@v5
        with:
          path: ~/.xmake/packages
          key: ${{ runner.os }}-xmake-deps-${{ matrix.cache-key }}-${{ github.sha }}
@@ -123,7 +123,7 @@ jobs:
        run: brew install xmake

      - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: Initialize submodules
        run: git submodule update --init --recursive
@@ -139,7 +139,7 @@ jobs:
          ${{ matrix.package_script }} ${VERSION_NUM}

      - name: Upload build artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: crossdesk-macos-${{ matrix.arch }}-${{ env.VERSION_NUM }}
          path: crossdesk-macos-${{ matrix.arch }}-${{ env.VERSION_NUM }}.pkg
@@ -169,7 +169,7 @@ jobs:
          echo "BUILD_DATE=$BUILD_DATE" >> $env:GITHUB_ENV

      - name: Cache xmake dependencies
-        uses: actions/cache@v4
+        uses: actions/cache@v5
        with:
          path: D:\xmake_global\.xmake\packages
          key: ${{ runner.os }}-xmake-deps-intel-${{ github.sha }}
@@ -221,7 +221,7 @@ jobs:
          Copy-Item $source $target -Force

      - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: Initialize submodules
        run: git submodule update --init --recursive
@@ -251,13 +251,13 @@ jobs:
          Compress-Archive -Path "$portableDir\*" -DestinationPath "${{ github.workspace }}\crossdesk-win-x64-portable-${{ env.VERSION_NUM }}.zip"

      - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: crossdesk-win-x64-${{ env.VERSION_NUM }}
          path: ${{ github.workspace }}/scripts/windows/crossdesk-win-x64-${{ env.VERSION_NUM }}.exe

      - name: Upload portable artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: crossdesk-win-x64-portable-${{ env.VERSION_NUM }}
          path: ${{ github.workspace }}/crossdesk-win-x64-portable-${{ env.VERSION_NUM }}.zip
@@ -271,10 +271,10 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: Download all artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
        with:
          path: artifacts

--- a/README.md
+++ b/README.md
@@ -181,7 +181,7 @@ sudo docker run -d \
  -e MAX_PORT=xxxxx \
  -v /var/lib/crossdesk:/var/lib/crossdesk \
  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.3
+  crossdesk/crossdesk-server:v1.1.6
 ```

 上述命令中，用户需注意的参数如下：
@@ -208,7 +208,7 @@ sudo docker run -d \
  -e MAX_PORT=60000 \
  -v /var/lib/crossdesk:/var/lib/crossdesk \
  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.3
+  crossdesk/crossdesk-server:v1.1.6
 ```

 **注意**：
--- a/README_EN.md
+++ b/README_EN.md
@@ -189,7 +189,7 @@ sudo docker run -d \
  -e MAX_PORT=xxxxx \
  -v /var/lib/crossdesk:/var/lib/crossdesk \
  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.3
+  crossdesk/crossdesk-server:v1.1.6
 ```

 The parameters you need to pay attention to are as follows:
@@ -216,7 +216,7 @@ sudo docker run -d \
  -e MAX_PORT=60000 \
  -v /var/lib/crossdesk:/var/lib/crossdesk \
  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.3
+  crossdesk/crossdesk-server:v1.1.6
 ```

 **Notes**
--- a/src/app/daemon.cpp
+++ b/src/app/daemon.cpp
@@ -34,9 +34,16 @@
 #endif

 #ifndef _WIN32
-Daemon* Daemon::instance_ = nullptr;
+volatile std::sig_atomic_t Daemon::stop_requested_ = 0;
 #endif

+namespace {
+constexpr int kRestartDelayMs = 1000;
+#ifndef _WIN32
+constexpr int kWaitPollIntervalMs = 200;
+#endif
+}  // namespace
+
 // get executable file path
 static std::string GetExecutablePath() {
 #ifdef _WIN32
@@ -66,33 +73,35 @@ static std::string GetExecutablePath() {
  return "";
 }

-Daemon::Daemon(const std::string& name)
-    : name_(name)
-#ifdef _WIN32
-      ,
-      running_(false)
-#else
-      ,
-      running_(true)
+Daemon::Daemon(const std::string& name) : name_(name), running_(false) {}
+
+void Daemon::stop() {
+  running_.store(false);
+#ifndef _WIN32
+  stop_requested_ = 1;
 #endif
-{
 }

-void Daemon::stop() { running_ = false; }
-
-bool Daemon::isRunning() const { return running_; }
+bool Daemon::isRunning() const {
+#ifndef _WIN32
+  return running_.load() && (stop_requested_ == 0);
+#else
+  return running_.load();
+#endif
+}

 bool Daemon::start(MainLoopFunc loop) {
 #ifdef _WIN32
-  running_ = true;
+  running_.store(true);
  return runWithRestart(loop);
 #elif __APPLE__
  // macOS: Use child process monitoring (like Windows) to preserve GUI
-  running_ = true;
+  stop_requested_ = 0;
+  running_.store(true);
  return runWithRestart(loop);
 #else
  // linux: Daemonize first, then run with restart monitoring
-  instance_ = this;
+  stop_requested_ = 0;

  // check if running from terminal before fork
  bool from_terminal =
@@ -134,29 +143,13 @@ bool Daemon::start(MainLoopFunc loop) {
  }

  // set up signal handlers
-  signal(SIGTERM, [](int) {
-    if (instance_) instance_->stop();
-  });
-  signal(SIGINT, [](int) {
-    if (instance_) instance_->stop();
-  });
+  signal(SIGTERM, [](int) { stop_requested_ = 1; });
+  signal(SIGINT, [](int) { stop_requested_ = 1; });

  // ignore SIGPIPE
  signal(SIGPIPE, SIG_IGN);

-  // set up SIGCHLD handler to reap zombie processes
-  struct sigaction sa_chld;
-  sa_chld.sa_handler = [](int) {
-    // reap zombie processes
-    while (waitpid(-1, nullptr, WNOHANG) > 0) {
-      // continue until no more zombie children
-    }
-  };
-  sigemptyset(&sa_chld.sa_mask);
-  sa_chld.sa_flags = SA_RESTART | SA_NOCLDSTOP;
-  sigaction(SIGCHLD, &sa_chld, nullptr);
-
-  running_ = true;
+  running_.store(true);
  return runWithRestart(loop);
 #endif
 }
@@ -204,8 +197,7 @@ bool Daemon::runWithRestart(MainLoopFunc loop) {
        restart_count++;
        std::cerr << "Exception caught, restarting... (attempt "
                  << restart_count << ")" << std::endl;
-        std::this_thread::sleep_for(
-            std::chrono::milliseconds(DAEMON_DEFAULT_RESTART_DELAY_MS));
+        std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
      }
    }
    return true;
@@ -237,27 +229,41 @@ bool Daemon::runWithRestart(MainLoopFunc loop) {
    if (!success) {
      std::cerr << "Failed to create child process, error: " << GetLastError()
                << std::endl;
-      std::this_thread::sleep_for(
-          std::chrono::milliseconds(DAEMON_DEFAULT_RESTART_DELAY_MS));
+      std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
      restart_count++;
      continue;
    }

+    while (isRunning()) {
+      DWORD wait_result = WaitForSingleObject(pi.hProcess, 200);
+      if (wait_result == WAIT_OBJECT_0) {
+        break;
+      }
+      if (wait_result == WAIT_FAILED) {
+        std::cerr << "Failed waiting child process, error: " << GetLastError()
+                  << std::endl;
+        break;
+      }
+    }
+
+    if (!isRunning()) {
+      TerminateProcess(pi.hProcess, 1);
+      WaitForSingleObject(pi.hProcess, 3000);
+    }
+
    DWORD exit_code = 0;
-    WaitForSingleObject(pi.hProcess, INFINITE);
    GetExitCodeProcess(pi.hProcess, &exit_code);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

-    if (exit_code == 0) {
+    if (!isRunning() || exit_code == 0) {
      break;  // normal exit
    }
    restart_count++;
    std::cerr << "Child process exited with code " << exit_code
              << ", restarting... (attempt " << restart_count << ")"
              << std::endl;
-    std::this_thread::sleep_for(
-        std::chrono::milliseconds(DAEMON_DEFAULT_RESTART_DELAY_MS));
+    std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
 #else
    // linux: use fork + exec to create child process
    pid_t pid = fork();
@@ -266,21 +272,39 @@ bool Daemon::runWithRestart(MainLoopFunc loop) {
      _exit(1);  // exec failed
    } else if (pid > 0) {
      int status = 0;
-      pid_t waited_pid = waitpid(pid, &status, 0);
+      pid_t waited_pid = -1;
+      while (isRunning()) {
+        waited_pid = waitpid(pid, &status, WNOHANG);
+        if (waited_pid == pid) {
+          break;
+        }
+        if (waited_pid < 0 && errno != EINTR) {
+          break;
+        }
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(kWaitPollIntervalMs));
+      }
+
+      if (!isRunning() && waited_pid != pid) {
+        kill(pid, SIGTERM);
+        waited_pid = waitpid(pid, &status, 0);
+      }

      if (waited_pid < 0) {
+        if (!isRunning()) {
+          break;
+        }
        restart_count++;
        std::cerr << "waitpid failed, errno: " << errno
                  << ", restarting... (attempt " << restart_count << ")"
                  << std::endl;
-        std::this_thread::sleep_for(
-            std::chrono::milliseconds(DAEMON_DEFAULT_RESTART_DELAY_MS));
+        std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
        continue;
      }

      if (WIFEXITED(status)) {
        int exit_code = WEXITSTATUS(status);
-        if (exit_code == 0) {
+        if (!isRunning() || exit_code == 0) {
          break;  // normal exit
        }
        restart_count++;
@@ -288,6 +312,9 @@ bool Daemon::runWithRestart(MainLoopFunc loop) {
                  << ", restarting... (attempt " << restart_count << ")"
                  << std::endl;
      } else if (WIFSIGNALED(status)) {
+        if (!isRunning()) {
+          break;
+        }
        restart_count++;
        std::cerr << "Child process crashed with signal " << WTERMSIG(status)
                  << ", restarting... (attempt " << restart_count << ")"
@@ -298,12 +325,10 @@ bool Daemon::runWithRestart(MainLoopFunc loop) {
                     "(attempt "
                  << restart_count << ")" << std::endl;
      }
-      std::this_thread::sleep_for(
-          std::chrono::milliseconds(DAEMON_DEFAULT_RESTART_DELAY_MS));
+      std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
    } else {
      std::cerr << "Failed to fork child process" << std::endl;
-      std::this_thread::sleep_for(
-          std::chrono::milliseconds(DAEMON_DEFAULT_RESTART_DELAY_MS));
+      std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
      restart_count++;
    }
 #endif
--- a/src/app/daemon.h
+++ b/src/app/daemon.h
@@ -7,11 +7,11 @@
 #ifndef _DAEMON_H_
 #define _DAEMON_H_

+#include <atomic>
+#include <csignal>
 #include <functional>
 #include <string>

-#define DAEMON_DEFAULT_RESTART_DELAY_MS 1000
-
 class Daemon {
 public:
  using MainLoopFunc = std::function<void()>;
@@ -28,12 +28,10 @@ class Daemon {
  std::string name_;
  bool runWithRestart(MainLoopFunc loop);

-#ifdef _WIN32
-  bool running_;
-#else
-  static Daemon* instance_;
-  volatile bool running_;
+#ifndef _WIN32
+  static volatile std::sig_atomic_t stop_requested_;
 #endif
+  std::atomic<bool> running_;
 };

-#endif
+#endif
--- a/src/common/platform.cpp
+++ b/src/common/platform.cpp
@@ -108,7 +108,7 @@ std::string GetHostName() {
 #ifdef _WIN32
  WSADATA wsaData;
  if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
-    std::cerr << "WSAStartup failed." << std::endl;
+    LOG_ERROR("WSAStartup failed");
    return "";
  }
  if (gethostname(hostname, sizeof(hostname)) == SOCKET_ERROR) {
--- a/src/config_center/config_center.cpp
+++ b/src/config_center/config_center.cpp
@@ -20,8 +20,14 @@ int ConfigCenter::Load() {
    return -1;
  }

-  language_ = static_cast<LANGUAGE>(
-      ini_.GetLongValue(section_, "language", static_cast<long>(language_)));
+  const long language_value =
+      ini_.GetLongValue(section_, "language", static_cast<long>(language_));
+  if (language_value < static_cast<long>(LANGUAGE::CHINESE) ||
+      language_value > static_cast<long>(LANGUAGE::RUSSIAN)) {
+    language_ = LANGUAGE::ENGLISH;
+  } else {
+    language_ = static_cast<LANGUAGE>(language_value);
+  }

  video_quality_ = static_cast<VIDEO_QUALITY>(ini_.GetLongValue(
      section_, "video_quality", static_cast<long>(video_quality_)));
@@ -385,4 +391,4 @@ int ConfigCenter::SetFileTransferSavePath(const std::string& path) {
 std::string ConfigCenter::GetFileTransferSavePath() const {
  return file_transfer_save_path_;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/config_center/config_center.h
+++ b/src/config_center/config_center.h
@@ -15,7 +15,7 @@ namespace crossdesk {

 class ConfigCenter {
 public:
-  enum class LANGUAGE { CHINESE = 0, ENGLISH = 1 };
+  enum class LANGUAGE { CHINESE = 0, ENGLISH = 1, RUSSIAN = 2 };
  enum class VIDEO_QUALITY { LOW = 0, MEDIUM = 1, HIGH = 2 };
  enum class VIDEO_FRAME_RATE { FPS_30 = 0, FPS_60 = 1 };
  enum class VIDEO_ENCODE_FORMAT { H264 = 0, AV1 = 1 };
@@ -90,4 +90,4 @@ class ConfigCenter {
  std::string file_transfer_save_path_ = "";
 };
 }  // namespace crossdesk
-#endif
+#endif
--- a/src/device_controller/keyboard/linux/keyboard_capturer.cpp
+++ b/src/device_controller/keyboard/linux/keyboard_capturer.cpp
@@ -1,5 +1,8 @@
 #include "keyboard_capturer.h"

+#include <errno.h>
+#include <poll.h>
+
 #include "keyboard_converter.h"
 #include "rd_log.h"

@@ -10,7 +13,7 @@ static void* g_user_ptr = nullptr;

 static int KeyboardEventHandler(Display* display, XEvent* event) {
  if (event->xkey.type == KeyPress || event->xkey.type == KeyRelease) {
-    KeySym keySym = XKeycodeToKeysym(display, event->xkey.keycode, 0);
+    KeySym keySym = XLookupKeysym(&event->xkey, 0);
    int key_code = XKeysymToKeycode(display, keySym);
    bool is_key_down = (event->xkey.type == KeyPress);

@@ -21,7 +24,9 @@ static int KeyboardEventHandler(Display* display, XEvent* event) {
  return 0;
 }

-KeyboardCapturer::KeyboardCapturer() : display_(nullptr), running_(true) {
+KeyboardCapturer::KeyboardCapturer()
+    : display_(nullptr), root_(0), running_(false) {
+  XInitThreads();
  display_ = XOpenDisplay(nullptr);
  if (!display_) {
    LOG_ERROR("Failed to open X display.");
@@ -29,35 +34,87 @@ KeyboardCapturer::KeyboardCapturer() : display_(nullptr), running_(true) {
 }

 KeyboardCapturer::~KeyboardCapturer() {
+  Unhook();
+
  if (display_) {
    XCloseDisplay(display_);
+    display_ = nullptr;
  }
 }

 int KeyboardCapturer::Hook(OnKeyAction on_key_action, void* user_ptr) {
+  if (!display_) {
+    LOG_ERROR("Display not initialized.");
+    return -1;
+  }
+
  g_on_key_action = on_key_action;
  g_user_ptr = user_ptr;

-  XSelectInput(display_, DefaultRootWindow(display_),
-               KeyPressMask | KeyReleaseMask);
-
-  while (running_) {
-    XEvent event;
-    XNextEvent(display_, &event);
-    KeyboardEventHandler(display_, &event);
+  if (running_) {
+    return 0;
  }

+  root_ = DefaultRootWindow(display_);
+  XSelectInput(display_, root_, KeyPressMask | KeyReleaseMask);
+  XFlush(display_);
+
+  running_ = true;
+  const int x11_fd = ConnectionNumber(display_);
+  event_thread_ = std::thread([this, x11_fd]() {
+    while (running_) {
+      while (running_ && XPending(display_) > 0) {
+        XEvent event;
+        XNextEvent(display_, &event);
+        KeyboardEventHandler(display_, &event);
+      }
+
+      if (!running_) {
+        break;
+      }
+
+      struct pollfd pfd = {x11_fd, POLLIN, 0};
+      int poll_ret = poll(&pfd, 1, 50);
+      if (poll_ret < 0) {
+        if (errno == EINTR) {
+          continue;
+        }
+        LOG_ERROR("poll for X11 events failed.");
+        running_ = false;
+        break;
+      }
+
+      if (poll_ret == 0) {
+        continue;
+      }
+
+      if ((pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) != 0) {
+        LOG_ERROR("poll got invalid X11 event fd state.");
+        running_ = false;
+        break;
+      }
+
+      if ((pfd.revents & POLLIN) == 0) {
+        continue;
+      }
+    }
+  });
+
  return 0;
 }

 int KeyboardCapturer::Unhook() {
+  running_ = false;
+
+  if (event_thread_.joinable()) {
+    event_thread_.join();
+  }
+
  g_on_key_action = nullptr;
  g_user_ptr = nullptr;

-  running_ = false;
-
-  if (display_) {
-    XSelectInput(display_, DefaultRootWindow(display_), 0);
+  if (display_ && root_ != 0) {
+    XSelectInput(display_, root_, 0);
    XFlush(display_);
  }

--- a/src/device_controller/keyboard/linux/keyboard_capturer.h
+++ b/src/device_controller/keyboard/linux/keyboard_capturer.h
@@ -11,6 +11,9 @@
 #include <X11/extensions/XTest.h>
 #include <X11/keysym.h>

+#include <atomic>
+#include <thread>
+
 #include "device_controller.h"

 namespace crossdesk {
@@ -28,7 +31,8 @@ class KeyboardCapturer : public DeviceController {
 private:
  Display* display_;
  Window root_;
-  bool running_;
+  std::atomic<bool> running_;
+  std::thread event_thread_;
 };
 }  // namespace crossdesk
 #endif
--- a/src/gui/assets/localization/localization.h
+++ b/src/gui/assets/localization/localization.h
@@ -1,244 +1,156 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2024-05-29
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
- */
-#ifndef _LOCALIZATION_H_
-#define _LOCALIZATION_H_
-
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2024-05-29
+ * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
+ */
+#ifndef _LOCALIZATION_H_
+#define _LOCALIZATION_H_
+
 #include <string>
+#include <unordered_map>
 #include <vector>

+#include "localization_data.h"
+
 #if _WIN32
 #include <Windows.h>
 #endif
+
+namespace crossdesk {
+namespace localization {
+
+struct LanguageOption {
+  std::string code;
+  std::string display_name;
+};

-namespace crossdesk {
+class LocalizedString {
+ public:
+  constexpr explicit LocalizedString(const char* key) : key_(key) {}
+  const std::string& operator[](int language_index) const;
+
+ private:
+  const char* key_;
+};
+
+inline const std::vector<LanguageOption>& GetSupportedLanguages() {
+  static const std::vector<LanguageOption> kSupportedLanguages = {
+      {"zh-CN", reinterpret_cast<const char*>(u8"中文")},
+      {"en-US", "English"},
+      {"ru-RU", reinterpret_cast<const char*>(u8"Русский")}};
+  return kSupportedLanguages;
+}
+
+namespace detail {

-namespace localization {
+inline int ClampLanguageIndex(int language_index) {
+  if (language_index >= 0 &&
+      language_index < static_cast<int>(GetSupportedLanguages().size())) {
+    return language_index;
+  }
+  return 0;
+}

-static std::vector<std::string> local_desktop = {
-    reinterpret_cast<const char*>(u8"本桌面"), "Local Desktop"};
-static std::vector<std::string> local_id = {
-    reinterpret_cast<const char*>(u8"本机ID"), "Local ID"};
-static std::vector<std::string> local_id_copied_to_clipboard = {
-    reinterpret_cast<const char*>(u8"已复制到剪贴板"), "Copied to clipboard"};
-static std::vector<std::string> password = {
-    reinterpret_cast<const char*>(u8"密码"), "Password"};
-static std::vector<std::string> max_password_len = {
-    reinterpret_cast<const char*>(u8"最大6个字符"), "Max 6 chars"};
+using TranslationTable =
+    std::unordered_map<std::string,
+                       std::unordered_map<std::string, std::string>>;

-static std::vector<std::string> remote_desktop = {
-    reinterpret_cast<const char*>(u8"控制远程桌面"), "Control Remote Desktop"};
-static std::vector<std::string> remote_id = {
-    reinterpret_cast<const char*>(u8"对端ID"), "Remote ID"};
-static std::vector<std::string> connect = {
-    reinterpret_cast<const char*>(u8"连接"), "Connect"};
-static std::vector<std::string> recent_connections = {
-    reinterpret_cast<const char*>(u8"近期连接"), "Recent Connections"};
-static std::vector<std::string> disconnect = {
-    reinterpret_cast<const char*>(u8"断开连接"), "Disconnect"};
-static std::vector<std::string> fullscreen = {
-    reinterpret_cast<const char*>(u8"全屏"), " Fullscreen"};
-static std::vector<std::string> show_net_traffic_stats = {
-    reinterpret_cast<const char*>(u8"显示流量统计"), "Show Net Traffic Stats"};
-static std::vector<std::string> hide_net_traffic_stats = {
-    reinterpret_cast<const char*>(u8"隐藏流量统计"), "Hide Net Traffic Stats"};
-static std::vector<std::string> video = {
-    reinterpret_cast<const char*>(u8"视频"), "Video"};
-static std::vector<std::string> audio = {
-    reinterpret_cast<const char*>(u8"音频"), "Audio"};
-static std::vector<std::string> data = {reinterpret_cast<const char*>(u8"数据"),
-                                        "Data"};
-static std::vector<std::string> total = {
-    reinterpret_cast<const char*>(u8"总计"), "Total"};
-static std::vector<std::string> in = {reinterpret_cast<const char*>(u8"输入"),
-                                      "In"};
-static std::vector<std::string> out = {reinterpret_cast<const char*>(u8"输出"),
-                                       "Out"};
-static std::vector<std::string> loss_rate = {
-    reinterpret_cast<const char*>(u8"丢包率"), "Loss Rate"};
-static std::vector<std::string> exit_fullscreen = {
-    reinterpret_cast<const char*>(u8"退出全屏"), "Exit fullscreen"};
-static std::vector<std::string> control_mouse = {
-    reinterpret_cast<const char*>(u8"控制"), "Control"};
-static std::vector<std::string> release_mouse = {
-    reinterpret_cast<const char*>(u8"释放"), "Release"};
-static std::vector<std::string> audio_capture = {
-    reinterpret_cast<const char*>(u8"声音"), "Audio"};
-static std::vector<std::string> mute = {
-    reinterpret_cast<const char*>(u8" 静音"), " Mute"};
-static std::vector<std::string> settings = {
-    reinterpret_cast<const char*>(u8"设置"), "Settings"};
-static std::vector<std::string> language = {
-    reinterpret_cast<const char*>(u8"语言:"), "Language:"};
-static std::vector<std::string> language_zh = {
-    reinterpret_cast<const char*>(u8"中文"), "Chinese"};
-static std::vector<std::string> language_en = {
-    reinterpret_cast<const char*>(u8"英文"), "English"};
-static std::vector<std::string> video_quality = {
-    reinterpret_cast<const char*>(u8"视频质量:"), "Video Quality:"};
-static std::vector<std::string> video_frame_rate = {
-    reinterpret_cast<const char*>(u8"画面采集帧率:"),
-    "Video Capture Frame Rate:"};
-static std::vector<std::string> video_quality_high = {
-    reinterpret_cast<const char*>(u8"高"), "High"};
-static std::vector<std::string> video_quality_medium = {
-    reinterpret_cast<const char*>(u8"中"), "Medium"};
-static std::vector<std::string> video_quality_low = {
-    reinterpret_cast<const char*>(u8"低"), "Low"};
-static std::vector<std::string> video_encode_format = {
-    reinterpret_cast<const char*>(u8"视频编码格式:"), "Video Encode Format:"};
-static std::vector<std::string> av1 = {reinterpret_cast<const char*>(u8"AV1"),
-                                       "AV1"};
-static std::vector<std::string> h264 = {
-    reinterpret_cast<const char*>(u8"H.264"), "H.264"};
-static std::vector<std::string> enable_hardware_video_codec = {
-    reinterpret_cast<const char*>(u8"启用硬件编解码器:"),
-    "Enable Hardware Video Codec:"};
-static std::vector<std::string> enable_turn = {
-    reinterpret_cast<const char*>(u8"启用中继服务:"), "Enable TURN Service:"};
-static std::vector<std::string> enable_srtp = {
-    reinterpret_cast<const char*>(u8"启用SRTP:"), "Enable SRTP:"};
-static std::vector<std::string> self_hosted_server_config = {
-    reinterpret_cast<const char*>(u8"自托管服务器配置"),
-    "Self-Hosted Server Config"};
-static std::vector<std::string> self_hosted_server_settings = {
-    reinterpret_cast<const char*>(u8"自托管服务器设置"),
-    "Self-Hosted Server Settings"};
-static std::vector<std::string> self_hosted_server_address = {
-    reinterpret_cast<const char*>(u8"服务器地址:"), "Server Address:"};
-static std::vector<std::string> self_hosted_server_port = {
-    reinterpret_cast<const char*>(u8"信令服务端口:"), "Signal Service Port:"};
-static std::vector<std::string> self_hosted_server_coturn_server_port = {
-    reinterpret_cast<const char*>(u8"中继服务端口:"), "Relay Service Port:"};
-static std::vector<std::string> select_a_file = {
-    reinterpret_cast<const char*>(u8"请选择文件"), "Please select a file"};
-static std::vector<std::string> ok = {reinterpret_cast<const char*>(u8"确认"),
-                                      "OK"};
-static std::vector<std::string> cancel = {
-    reinterpret_cast<const char*>(u8"取消"), "Cancel"};
+inline std::unordered_map<std::string, std::string> MakeLocalizedValues(
+    const TranslationRow& row) {
+  return {{"zh-CN", reinterpret_cast<const char*>(row.zh)},
+          {"en-US", row.en},
+          {"ru-RU", reinterpret_cast<const char*>(row.ru)}};
+}

-static std::vector<std::string> new_password = {
-    reinterpret_cast<const char*>(u8"请输入六位密码:"),
-    "Please input a six-char password:"};
+inline TranslationTable BuildTranslationTable() {
+  TranslationTable table;
+  for (const auto& row : kTranslationRows) {
+    table[row.key] = MakeLocalizedValues(row);
+  }

-static std::vector<std::string> input_password = {
-    reinterpret_cast<const char*>(u8"请输入密码:"), "Please input password:"};
-static std::vector<std::string> validate_password = {
-    reinterpret_cast<const char*>(u8"验证密码中..."), "Validate password ..."};
-static std::vector<std::string> reinput_password = {
-    reinterpret_cast<const char*>(u8"请重新输入密码"),
-    "Please input password again"};
-
-static std::vector<std::string> remember_password = {
-    reinterpret_cast<const char*>(u8"记住密码"), "Remember password"};
-
-static std::vector<std::string> signal_connected = {
-    reinterpret_cast<const char*>(u8"已连接服务器"), "Connected"};
-static std::vector<std::string> signal_disconnected = {
-    reinterpret_cast<const char*>(u8"未连接服务器"), "Disconnected"};
-
-static std::vector<std::string> p2p_connected = {
-    reinterpret_cast<const char*>(u8"对等连接已建立"), "P2P Connected"};
-static std::vector<std::string> p2p_disconnected = {
-    reinterpret_cast<const char*>(u8"对等连接已断开"), "P2P Disconnected"};
-static std::vector<std::string> p2p_connecting = {
-    reinterpret_cast<const char*>(u8"正在建立对等连接..."),
-    "P2P Connecting ..."};
-static std::vector<std::string> p2p_failed = {
-    reinterpret_cast<const char*>(u8"对等连接失败"), "P2P Failed"};
-static std::vector<std::string> p2p_closed = {
-    reinterpret_cast<const char*>(u8"对等连接已关闭"), "P2P closed"};
-
-static std::vector<std::string> no_such_id = {
-    reinterpret_cast<const char*>(u8"无此ID"), "No such ID"};
-
-static std::vector<std::string> about = {
-    reinterpret_cast<const char*>(u8"关于"), "About"};
-static std::vector<std::string> notification = {
-    reinterpret_cast<const char*>(u8"通知"), "Notification"};
-static std::vector<std::string> new_version_available = {
-    reinterpret_cast<const char*>(u8"新版本可用"), "New Version Available"};
-static std::vector<std::string> version = {
-    reinterpret_cast<const char*>(u8"版本"), "Version"};
-static std::vector<std::string> release_date = {
-    reinterpret_cast<const char*>(u8"发布日期: "), "Release Date: "};
-static std::vector<std::string> access_website = {
-    reinterpret_cast<const char*>(u8"访问官网: "), "Access Website: "};
-static std::vector<std::string> update = {
-    reinterpret_cast<const char*>(u8"更新"), "Update"};
-
-static std::vector<std::string> confirm_delete_connection = {
-    reinterpret_cast<const char*>(u8"确认删除此连接"),
-    "Confirm to delete this connection"};
-
-static std::vector<std::string> enable_autostart = {
-    reinterpret_cast<const char*>(u8"开机自启:"), "Auto Start:"};
-static std::vector<std::string> enable_daemon = {
-    reinterpret_cast<const char*>(u8"启用守护进程:"), "Enable Daemon:"};
-static std::vector<std::string> takes_effect_after_restart = {
-    reinterpret_cast<const char*>(u8"重启后生效"),
-    "Takes effect after restart"};
-static std::vector<std::string> select_file = {
-    reinterpret_cast<const char*>(u8"选择文件"), "Select File"};
-static std::vector<std::string> file_transfer_progress = {
-    reinterpret_cast<const char*>(u8"文件传输进度"), "File Transfer Progress"};
-static std::vector<std::string> queued = {
-    reinterpret_cast<const char*>(u8"队列中"), "Queued"};
-static std::vector<std::string> sending = {
-    reinterpret_cast<const char*>(u8"正在传输"), "Sending"};
-static std::vector<std::string> completed = {
-    reinterpret_cast<const char*>(u8"已完成"), "Completed"};
-static std::vector<std::string> failed = {
-    reinterpret_cast<const char*>(u8"失败"), "Failed"};
-static std::vector<std::string> controller = {
-    reinterpret_cast<const char*>(u8"控制端:"), "Controller:"};
-static std::vector<std::string> file_transfer = {
-    reinterpret_cast<const char*>(u8"文件传输:"), "File Transfer:"};
-static std::vector<std::string> connection_status = {
-    reinterpret_cast<const char*>(u8"连接状态:"), "Connection Status:"};
-static std::vector<std::string> file_transfer_save_path = {
-    reinterpret_cast<const char*>(u8"文件接收保存路径:"),
-    "File Transfer Save Path:"};
-static std::vector<std::string> browse = {
-    reinterpret_cast<const char*>(u8"浏览"), "Browse"};
-static std::vector<std::string> default_desktop = {
-    reinterpret_cast<const char*>(u8"桌面"), "Desktop"};
-static std::vector<std::string> minimize_to_tray = {
-    reinterpret_cast<const char*>(u8"退出时最小化到系统托盘:"),
-    "Minimize to system tray when exit:"};
-static std::vector<std::string> resolution = {
-    reinterpret_cast<const char*>(u8"分辨率"), "Res"};
-static std::vector<std::string> connection_mode = {
-    reinterpret_cast<const char*>(u8"连接模式"), "Mode"};
-static std::vector<std::string> connection_mode_direct = {
-    reinterpret_cast<const char*>(u8"直连"), "Direct"};
-static std::vector<std::string> connection_mode_relay = {
-    reinterpret_cast<const char*>(u8"中继"), "Relay"};
-static std::vector<std::string> online = {
-    reinterpret_cast<const char*>(u8"在线"), "Online"};
-static std::vector<std::string> offline = {
-    reinterpret_cast<const char*>(u8"离线"), "Offline"};
-static std::vector<std::string> device_offline = {
-    reinterpret_cast<const char*>(u8"设备离线"), "Device Offline"};
-
-#if _WIN32
-static std::vector<LPCWSTR> exit_program = {L"退出", L"Exit"};
-#endif
-#ifdef __APPLE__
-static std::vector<std::string> request_permissions = {
-    reinterpret_cast<const char*>(u8"权限请求"), "Request Permissions"};
-static std::vector<std::string> screen_recording_permission = {
-    reinterpret_cast<const char*>(u8"屏幕录制权限"),
-    "Screen Recording Permission"};
-static std::vector<std::string> accessibility_permission = {
-    reinterpret_cast<const char*>(u8"辅助功能权限"),
-    "Accessibility Permission"};
-static std::vector<std::string> permission_required_message = {
-    reinterpret_cast<const char*>(u8"该应用需要授权以下权限:"),
-    "The application requires the following permissions:"};
-#endif
-}  // namespace localization
-}  // namespace crossdesk
-#endif
+  return table;
+}
+
+inline const TranslationTable& GetTranslationTable() {
+  static const TranslationTable table = BuildTranslationTable();
+  return table;
+}
+
+inline const std::string& GetTranslatedText(const std::string& key,
+                                            int language_index) {
+  static const std::string kEmptyText = "";
+
+  const auto& table = GetTranslationTable();
+  const auto key_it = table.find(key);
+  if (key_it == table.end()) {
+    return kEmptyText;
+  }
+
+  const auto& localized_values = key_it->second;
+  const std::string& language_code =
+      GetSupportedLanguages()[ClampLanguageIndex(language_index)].code;
+
+  const auto exact_it = localized_values.find(language_code);
+  if (exact_it != localized_values.end()) {
+    return exact_it->second;
+  }
+
+  const auto english_it = localized_values.find("en-US");
+  if (english_it != localized_values.end()) {
+    return english_it->second;
+  }
+
+  const auto chinese_it = localized_values.find("zh-CN");
+  if (chinese_it != localized_values.end()) {
+    return chinese_it->second;
+  }
+
+  return kEmptyText;
+}
+
+}  // namespace detail
+
+inline const std::string& LocalizedString::operator[](
+    int language_index) const {
+  return detail::GetTranslatedText(key_, language_index);
+}
+
+#define CROSSDESK_DECLARE_LOCALIZED_STRING(name, zh, en, ru) \
+  inline const LocalizedString name(#name);
+CROSSDESK_LOCALIZATION_ALL(CROSSDESK_DECLARE_LOCALIZED_STRING)
+#undef CROSSDESK_DECLARE_LOCALIZED_STRING
+
+#if _WIN32
+inline const wchar_t* GetExitProgramLabel(int language_index) {
+  static std::vector<std::wstring> cache(GetSupportedLanguages().size());
+  const int normalized_index = detail::ClampLanguageIndex(language_index);
+  std::wstring& cached_text = cache[normalized_index];
+  if (!cached_text.empty()) {
+    return cached_text.c_str();
+  }
+
+  const std::string& utf8_text =
+      detail::GetTranslatedText("exit_program", normalized_index);
+  if (utf8_text.empty()) {
+    cached_text = L"Exit";
+    return cached_text.c_str();
+  }
+
+  int wide_length =
+      MultiByteToWideChar(CP_UTF8, 0, utf8_text.c_str(), -1, nullptr, 0);
+  if (wide_length <= 0) {
+    cached_text = L"Exit";
+    return cached_text.c_str();
+  }
+
+  cached_text.resize(static_cast<size_t>(wide_length - 1));
+  MultiByteToWideChar(CP_UTF8, 0, utf8_text.c_str(), -1, cached_text.data(),
+                      wide_length);
+  return cached_text.c_str();
+}
+#endif
+
+}  // namespace localization
+}  // namespace crossdesk
+
+#endif
--- a/src/gui/assets/localization/localization_data.h
+++ b/src/gui/assets/localization/localization_data.h
@@ -0,0 +1,166 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2024-05-29
+ * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
+ */
+#ifndef _LOCALIZATION_DATA_H_
+#define _LOCALIZATION_DATA_H_
+
+namespace crossdesk {
+namespace localization {
+
+namespace detail {
+
+struct TranslationRow {
+  const char* key;
+  const char* zh;
+  const char* en;
+  const char* ru;
+};
+
+// Single source of truth for all UI strings.
+#define CROSSDESK_LOCALIZATION_ALL(X)                                          \
+  X(local_desktop, u8"本桌面", "Local Desktop", u8"Локальный рабочий стол")    \
+  X(local_id, u8"本机ID", "Local ID", u8"Локальный ID")                        \
+  X(local_id_copied_to_clipboard, u8"已复制到剪贴板", "Copied to clipboard",   \
+    u8"Скопировано в буфер обмена")                                            \
+  X(password, u8"密码", "Password", u8"Пароль")                                \
+  X(max_password_len, u8"最大6个字符", "Max 6 chars", u8"Макс. 6 символов")    \
+  X(remote_desktop, u8"远程桌面", "Remote Desktop",                            \
+    u8"Удаленный рабочий стол")                                                \
+  X(remote_id, u8"对端ID", "Remote ID", u8"Удаленный ID")                      \
+  X(connect, u8"连接", "Connect", u8"Подключиться")                            \
+  X(recent_connections, u8"近期连接", "Recent Connections",                    \
+    u8"Недавние подключения")                                                  \
+  X(disconnect, u8"断开连接", "Disconnect", u8"Отключить")                     \
+  X(fullscreen, u8"全屏", " Fullscreen", u8"Полный экран")                     \
+  X(show_net_traffic_stats, u8"显示流量统计", "Show Net Traffic Stats",        \
+    u8"Показать статистику трафика")                                           \
+  X(hide_net_traffic_stats, u8"隐藏流量统计", "Hide Net Traffic Stats",        \
+    u8"Скрыть статистику трафика")                                             \
+  X(video, u8"视频", "Video", u8"Видео")                                       \
+  X(audio, u8"音频", "Audio", u8"Аудио")                                       \
+  X(data, u8"数据", "Data", u8"Данные")                                        \
+  X(total, u8"总计", "Total", u8"Итого")                                       \
+  X(in, u8"输入", "In", u8"Вход")                                              \
+  X(out, u8"输出", "Out", u8"Выход")                                           \
+  X(loss_rate, u8"丢包率", "Loss Rate", u8"Потери пакетов")                    \
+  X(exit_fullscreen, u8"退出全屏", "Exit fullscreen",                          \
+    u8"Выйти из полноэкранного режима")                                        \
+  X(control_mouse, u8"控制", "Control", u8"Управление")                        \
+  X(release_mouse, u8"释放", "Release", u8"Освободить")                        \
+  X(audio_capture, u8"声音", "Audio", u8"Звук")                                \
+  X(mute, u8" 静音", " Mute", u8"Без звука")                                   \
+  X(settings, u8"设置", "Settings", u8"Настройки")                             \
+  X(language, u8"语言:", "Language:", u8"Язык:")                               \
+  X(video_quality, u8"视频质量:", "Video Quality:", u8"Качество видео:")       \
+  X(video_frame_rate, u8"画面采集帧率:",                                       \
+    "Video Capture Frame Rate:", u8"Частота захвата видео:")                   \
+  X(video_quality_high, u8"高", "High", u8"Высокое")                           \
+  X(video_quality_medium, u8"中", "Medium", u8"Среднее")                       \
+  X(video_quality_low, u8"低", "Low", u8"Низкое")                              \
+  X(video_encode_format, u8"视频编码格式:",                                    \
+    "Video Encode Format:", u8"Формат кодека видео:")                          \
+  X(av1, u8"AV1", "AV1", "AV1")                                                \
+  X(h264, u8"H.264", "H.264", "H.264")                                         \
+  X(enable_hardware_video_codec, u8"启用硬件编解码器:",                        \
+    "Enable Hardware Video Codec:", u8"Использовать аппаратный кодек:")        \
+  X(enable_turn, u8"启用中继服务:",                                            \
+    "Enable TURN Service:", u8"Включить TURN-сервис:")                         \
+  X(enable_srtp, u8"启用SRTP:", "Enable SRTP:", u8"Включить SRTP:")            \
+  X(self_hosted_server_config, u8"自托管配置", "Self-Hosted Config",           \
+    u8"Конфигурация self-hosted")                                              \
+  X(self_hosted_server_settings, u8"自托管设置", "Self-Hosted Settings",       \
+    u8"Настройки self-hosted")                                                 \
+  X(self_hosted_server_address, u8"服务器地址:",                               \
+    "Server Address:", u8"Адрес сервера:")                                     \
+  X(self_hosted_server_port, u8"信令服务端口:",                                \
+    "Signal Service Port:", u8"Порт сигнального сервиса:")                     \
+  X(self_hosted_server_coturn_server_port, u8"中继服务端口:",                  \
+    "Relay Service Port:", u8"Порт реле-сервиса:")                             \
+  X(ok, u8"确认", "OK", u8"ОК")                                                \
+  X(cancel, u8"取消", "Cancel", u8"Отмена")                                    \
+  X(new_password, u8"请输入六位密码:",                                         \
+    "Please input a six-char password:", u8"Введите шестизначный пароль:")     \
+  X(input_password, u8"请输入密码:",                                           \
+    "Please input password:", u8"Введите пароль:")                             \
+  X(validate_password, u8"验证密码中...", "Validate password ...",             \
+    u8"Проверка пароля...")                                                    \
+  X(reinput_password, u8"请重新输入密码", "Please input password again",       \
+    u8"Повторно введите пароль")                                               \
+  X(remember_password, u8"记住密码", "Remember password",                      \
+    u8"Запомнить пароль")                                                      \
+  X(signal_connected, u8"已连接服务器", "Connected", u8"Подключено к серверу") \
+  X(signal_disconnected, u8"未连接服务器", "Disconnected",                     \
+    u8"Нет подключения к серверу")                                             \
+  X(p2p_connected, u8"对等连接已建立", "P2P Connected", u8"P2P подключено")    \
+  X(p2p_disconnected, u8"对等连接已断开", "P2P Disconnected",                  \
+    u8"P2P отключено")                                                         \
+  X(p2p_connecting, u8"正在建立对等连接...", "P2P Connecting ...",             \
+    u8"Подключение P2P...")                                                    \
+  X(receiving_screen, u8"画面接收中...", "Receiving screen...",                \
+    u8"Получение изображения...")                                              \
+  X(p2p_failed, u8"对等连接失败", "P2P Failed", u8"Сбой P2P")                  \
+  X(p2p_closed, u8"对等连接已关闭", "P2P closed", u8"P2P закрыто")             \
+  X(no_such_id, u8"无此ID", "No such ID", u8"ID не найден")                    \
+  X(about, u8"关于", "About", u8"О программе")                                 \
+  X(notification, u8"通知", "Notification", u8"Уведомление")                   \
+  X(new_version_available, u8"新版本可用", "New Version Available",            \
+    u8"Доступна новая версия")                                                 \
+  X(version, u8"版本", "Version", u8"Версия")                                  \
+  X(release_date, u8"发布日期: ", "Release Date: ", u8"Дата релиза: ")         \
+  X(access_website, u8"访问官网: ",                                            \
+    "Access Website: ", u8"Официальный сайт: ")                                \
+  X(update, u8"更新", "Update", u8"Обновить")                                  \
+  X(confirm_delete_connection, u8"确认删除此连接",                             \
+    "Confirm to delete this connection", u8"Удалить это подключение?")         \
+  X(enable_autostart, u8"开机自启:", "Auto Start:", u8"Автозапуск:")           \
+  X(enable_daemon, u8"启用守护进程:", "Enable Daemon:", u8"Включить демон:")   \
+  X(takes_effect_after_restart, u8"重启后生效", "Takes effect after restart",  \
+    u8"Вступит в силу после перезапуска")                                      \
+  X(select_file, u8"选择文件", "Select File", u8"Выбрать файл")                \
+  X(file_transfer_progress, u8"文件传输进度", "File Transfer Progress",        \
+    u8"Прогресс передачи файлов")                                              \
+  X(queued, u8"队列中", "Queued", u8"В очереди")                               \
+  X(sending, u8"正在传输", "Sending", u8"Передача")                            \
+  X(completed, u8"已完成", "Completed", u8"Завершено")                         \
+  X(failed, u8"失败", "Failed", u8"Ошибка")                                    \
+  X(controller, u8"控制端:", "Controller:", u8"Контроллер:")                   \
+  X(file_transfer, u8"文件传输:", "File Transfer:", u8"Передача файлов:")      \
+  X(connection_status, u8"连接状态:",                                          \
+    "Connection Status:", u8"Состояние соединения:")                           \
+  X(file_transfer_save_path, u8"文件接收保存路径:",                            \
+    "File Transfer Save Path:", u8"Путь сохранения файлов:")                   \
+  X(default_desktop, u8"桌面", "Desktop", u8"Рабочий стол")                    \
+  X(minimize_to_tray, u8"退出时最小化到系统托盘:",                             \
+    "Minimize on Exit:", u8"Сворачивать в трей при выходе:")                   \
+  X(resolution, u8"分辨率", "Res", u8"Разрешение")                             \
+  X(connection_mode, u8"连接模式", "Mode", u8"Режим")                          \
+  X(connection_mode_direct, u8"直连", "Direct", u8"Прямой")                    \
+  X(connection_mode_relay, u8"中继", "Relay", u8"Релейный")                    \
+  X(online, u8"在线", "Online", u8"Онлайн")                                    \
+  X(offline, u8"离线", "Offline", u8"Офлайн")                                  \
+  X(device_offline, u8"设备离线", "Device Offline", u8"Устройство офлайн")     \
+  X(request_permissions, u8"权限请求", "Request Permissions",                  \
+    u8"Запрос разрешений")                                                     \
+  X(screen_recording_permission, u8"屏幕录制权限",                             \
+    "Screen Recording Permission", u8"Разрешение на запись экрана")            \
+  X(accessibility_permission, u8"辅助功能权限", "Accessibility Permission",    \
+    u8"Разрешение специальных возможностей")                                   \
+  X(permission_required_message, u8"该应用需要授权以下权限:",                  \
+    "The application requires the following permissions:",                     \
+    u8"Для работы приложения требуются следующие разрешения:")                 \
+  X(exit_program, u8"退出", "Exit", u8"Выход")
+
+inline constexpr TranslationRow kTranslationRows[] = {
+#define CROSSDESK_DECLARE_TRANSLATION_ROW(name, zh, en, ru) {#name, zh, en, ru},
+    CROSSDESK_LOCALIZATION_ALL(CROSSDESK_DECLARE_TRANSLATION_ROW)
+#undef CROSSDESK_DECLARE_TRANSLATION_ROW
+};
+
+}  // namespace detail
+
+}  // namespace localization
+}  // namespace crossdesk
+
+#endif
--- a/src/gui/panels/local_peer_panel.cpp
+++ b/src/gui/panels/local_peer_panel.cpp
@@ -46,7 +46,7 @@ int Render::LocalWindow() {
    ImGui::BeginChild(
        "LocalDesktopPanel",
        ImVec2(local_window_width * 0.8f, local_window_height * 0.43f),
-        ImGuiChildFlags_Border,
+        ImGuiChildFlags_Borders,
        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
            ImGuiWindowFlags_NoBringToFrontOnFocus);
    ImGui::PopStyleVar();
@@ -300,4 +300,4 @@ int Render::LocalWindow() {

  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/panels/recent_connections_panel.cpp
+++ b/src/gui/panels/recent_connections_panel.cpp
@@ -17,7 +17,7 @@ int Render::RecentConnectionsWindow() {
  ImGui::BeginChild(
      "RecentConnectionsWindow",
      ImVec2(recent_connection_window_width, recent_connection_window_height),
-      ImGuiChildFlags_Border,
+      ImGuiChildFlags_Borders,
      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
          ImGuiWindowFlags_NoBringToFrontOnFocus);
  ImGui::PopStyleVar();
@@ -64,7 +64,7 @@ int Render::ShowRecentConnections() {
  ImGui::BeginChild(
      "RecentConnectionsContainer",
      ImVec2(recent_connection_panel_width, recent_connection_panel_height),
-      ImGuiChildFlags_Border,
+      ImGuiChildFlags_Borders,
      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
          ImGuiWindowFlags_NoBringToFrontOnFocus |
          ImGuiWindowFlags_AlwaysHorizontalScrollbar |
@@ -227,14 +227,8 @@ int Render::ShowRecentConnections() {
      if (ImGui::Button(connect_to_this_connection_button_name.c_str(),
                        ImVec2(recent_connection_button_width,
                               recent_connection_button_height))) {
-        if (online) {
-          ConnectTo(it.second.remote_id, it.second.password.c_str(),
-                    it.second.remember_password);
-        } else {
-          show_offline_warning_window_ = true;
-          offline_warning_text_ =
-              localization::device_offline[localization_language_index_];
-        }
+        ConnectTo(it.second.remote_id, it.second.password.c_str(),
+                  it.second.remember_password);
      }
    }
    ImGui::SetWindowFontScale(1.0f);
@@ -366,4 +360,4 @@ int Render::OfflineWarningWindow() {
  ImGui::PopStyleVar();
  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/panels/remote_peer_panel.cpp
+++ b/src/gui/panels/remote_peer_panel.cpp
@@ -48,7 +48,7 @@ int Render::RemoteWindow() {
    ImGui::BeginChild(
        "RemoteDesktopWindow_1",
        ImVec2(remote_window_width * 0.8f, remote_window_height * 0.43f),
-        ImGuiChildFlags_Border,
+        ImGuiChildFlags_Borders,
        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
            ImGuiWindowFlags_NoBringToFrontOnFocus);
    ImGui::PopStyleVar();
@@ -165,7 +165,21 @@ static int InputTextCallback(ImGuiInputTextCallbackData* data) {
 }

 int Render::ConnectTo(const std::string& remote_id, const char* password,
-                      bool remember_password) {
+                      bool remember_password, bool bypass_presence_check) {
+  if (!bypass_presence_check && !device_presence_.IsOnline(remote_id)) {
+    int ret =
+        RequestSingleDevicePresence(remote_id, password, remember_password);
+    if (ret != 0) {
+      offline_warning_text_ =
+          localization::device_offline[localization_language_index_];
+      show_offline_warning_window_ = true;
+      LOG_WARN("Presence probe failed for [{}], ret={}", remote_id, ret);
+    } else {
+      LOG_INFO("Presence probe requested for [{}] before connect", remote_id);
+    }
+    return -1;
+  }
+
  LOG_INFO("Connect to [{}]", remote_id);
  focused_remote_id_ = remote_id;

@@ -197,6 +211,9 @@ int Render::ConnectTo(const std::string& remote_id, const char* password,
        props->control_window_max_width_ = title_bar_height_ * 9.0f;
        props->control_window_max_height_ = title_bar_height_ * 7.0f;

+        props->connection_status_ = ConnectionStatus::Connecting;
+        show_connection_status_window_ = true;
+
        if (!props->peer_) {
          LOG_INFO("Create peer [{}] instance failed", props->local_id_);
          return -1;
@@ -253,4 +270,4 @@ int Render::ConnectTo(const std::string& remote_id, const char* password,

  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/render.cpp
+++ b/src/gui/render.cpp
@@ -7,6 +7,7 @@
 #include <X11/Xlib.h>
 #endif

+#include <cstdlib>
 #include <cstring>
 #include <filesystem>
 #include <fstream>
@@ -14,7 +15,6 @@
 #include <string>
 #include <thread>

-#include "OPPOSans_Regular.h"
 #include "clipboard.h"
 #include "device_controller_factory.h"
 #include "fa_regular_400.h"
@@ -36,6 +36,32 @@
 namespace crossdesk {

 namespace {
+const ImWchar* GetMultilingualGlyphRanges() {
+  static std::vector<ImWchar> glyph_ranges;
+  if (glyph_ranges.empty()) {
+    ImGuiIO& io = ImGui::GetIO();
+    ImFontGlyphRangesBuilder builder;
+    builder.AddRanges(io.Fonts->GetGlyphRangesDefault());
+    builder.AddRanges(io.Fonts->GetGlyphRangesChineseFull());
+    builder.AddRanges(io.Fonts->GetGlyphRangesCyrillic());
+
+    ImVector<ImWchar> built_ranges;
+    builder.BuildRanges(&built_ranges);
+    glyph_ranges.assign(built_ranges.Data,
+                        built_ranges.Data + built_ranges.Size);
+  }
+  return glyph_ranges.empty() ? nullptr : glyph_ranges.data();
+}
+
+bool CanReadFontFile(const char* font_path) {
+  if (!font_path) {
+    return false;
+  }
+
+  std::ifstream font_file(font_path, std::ios::binary);
+  return font_file.good();
+}
+
 #if defined(__linux__) && !defined(__APPLE__)
 inline bool X11GetDisplayAndWindow(SDL_Window* window, Display** display_out,
                                   ::Window* x11_window_out) {
@@ -479,7 +505,8 @@ int Render::LoadSettingsFromCacheFile() {
  thumbnail_ = std::make_shared<Thumbnail>(cache_path_ + "/thumbnails/",
                                           aes128_key_, aes128_iv_);

-  language_button_value_ = (int)config_center_->GetLanguage();
+  language_button_value_ = localization::detail::ClampLanguageIndex(
+      (int)config_center_->GetLanguage());
  video_quality_button_value_ = (int)config_center_->GetVideoQuality();
  video_frame_rate_button_value_ = (int)config_center_->GetVideoFrameRate();
  video_encode_format_button_value_ =
@@ -848,11 +875,38 @@ int Render::AudioDeviceInit() {
  desired_out.format = SDL_AUDIO_S16;
  desired_out.channels = 1;

-  output_stream_ = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
-                                             &desired_out, nullptr, nullptr);
-  if (!output_stream_) {
+  auto open_stream = [&]() -> bool {
+    output_stream_ = SDL_OpenAudioDeviceStream(
+        SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &desired_out, nullptr, nullptr);
+    return output_stream_ != nullptr;
+  };
+
+  if (!open_stream()) {
+#if defined(__linux__) && !defined(__APPLE__)
+    LOG_WARN(
+        "Failed to open output stream with driver [{}]: {}",
+        getenv("SDL_AUDIODRIVER") ? getenv("SDL_AUDIODRIVER") : "(default)",
+        SDL_GetError());
+
+    setenv("SDL_AUDIODRIVER", "dummy", 1);
+    SDL_QuitSubSystem(SDL_INIT_AUDIO);
+    if (!SDL_InitSubSystem(SDL_INIT_AUDIO)) {
+      LOG_ERROR("Failed to reinitialize SDL audio with dummy driver: {}",
+                SDL_GetError());
+      return -1;
+    }
+
+    if (!open_stream()) {
+      LOG_ERROR("Failed to open output stream with dummy driver: {}",
+                SDL_GetError());
+      return -1;
+    }
+
+    LOG_WARN("Audio output disabled, using SDL dummy audio driver");
+#else
    LOG_ERROR("Failed to open output stream: {}", SDL_GetError());
    return -1;
+#endif
  }

  SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(output_stream_));
@@ -1060,13 +1114,18 @@ int Render::DestroyStreamWindow() {

  if (stream_renderer_) {
    SDL_DestroyRenderer(stream_renderer_);
+    stream_renderer_ = nullptr;
  }

  if (stream_window_) {
    SDL_DestroyWindow(stream_window_);
+    stream_window_ = nullptr;
  }

  stream_window_created_ = false;
+  focus_on_stream_window_ = false;
+  stream_window_grabbed_ = false;
+  control_mouse_ = false;

  return 0;
 }
@@ -1168,13 +1227,16 @@ int Render::DestroyServerWindow() {

  if (server_renderer_) {
    SDL_DestroyRenderer(server_renderer_);
+    server_renderer_ = nullptr;
  }

  if (server_window_) {
    SDL_DestroyWindow(server_window_);
+    server_window_ = nullptr;
  }

  server_window_created_ = false;
+  server_window_inited_ = false;

  return 0;
 }
@@ -1187,78 +1249,68 @@ int Render::SetupFontAndStyle(ImFont** system_chinese_font_out) {

  io.IniFilename = NULL;  // disable imgui.ini

-  // Load Fonts
+  // Build one merged atlas: UI font + icon font + multilingual fallback fonts.
  ImFontConfig config;
  config.FontDataOwnedByAtlas = false;
-  io.Fonts->AddFontFromMemoryTTF(OPPOSans_Regular_ttf, OPPOSans_Regular_ttf_len,
-                                 font_size, &config,
-                                 io.Fonts->GetGlyphRangesChineseFull());
-  config.MergeMode = true;
-  static const ImWchar icon_ranges[] = {ICON_MIN_FA, ICON_MAX_FA, 0};
-  io.Fonts->AddFontFromMemoryTTF(fa_solid_900_ttf, fa_solid_900_ttf_len, 30.0f,
-                                 &config, icon_ranges);
-
-  // Load system Chinese font as fallback
  config.MergeMode = false;
-  config.FontDataOwnedByAtlas = false;
+
  if (system_chinese_font_out) {
    *system_chinese_font_out = nullptr;
  }

+  ImFont* ui_font = nullptr;
+  const ImWchar* multilingual_ranges = GetMultilingualGlyphRanges();
+
 #if defined(_WIN32)
-  // Windows: Try Microsoft YaHei (微软雅黑) first, then SimSun (宋体)
-  const char* font_paths[] = {"C:/Windows/Fonts/msyh.ttc",
-                              "C:/Windows/Fonts/msyhbd.ttc",
-                              "C:/Windows/Fonts/simsun.ttc", nullptr};
+  const char* base_font_paths[] = {
+      "C:/Windows/Fonts/msyh.ttc",    "C:/Windows/Fonts/msyhbd.ttc",
+      "C:/Windows/Fonts/segoeui.ttf", "C:/Windows/Fonts/arial.ttf",
+      "C:/Windows/Fonts/simsun.ttc",  nullptr};
 #elif defined(__APPLE__)
-  // macOS: Try PingFang SC first, then STHeiti
-  const char* font_paths[] = {"/System/Library/Fonts/PingFang.ttc",
-                              "/System/Library/Fonts/STHeiti Light.ttc",
-                              "/System/Library/Fonts/STHeiti Medium.ttc",
-                              nullptr};
+  const char* base_font_paths[] = {
+      "/System/Library/Fonts/PingFang.ttc",
+      "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
+      "/System/Library/Fonts/Supplemental/Arial.ttf",
+      "/System/Library/Fonts/SFNS.ttf", nullptr};
 #else
-  // Linux: Try common Chinese fonts
-  const char* font_paths[] = {
-      "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",
-      "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
-      "/usr/share/fonts/truetype/arphic/uming.ttc",
-      "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc", nullptr};
+  const char* base_font_paths[] = {
+      "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+      "/usr/share/fonts/opentype/noto/NotoSans-Regular.ttf",
+      "/usr/share/fonts/opentype/wqy/wqy-microhei.ttc",
+      "/usr/share/fonts/opentype/wqy/wqy-zenhei.ttc",
+      "/usr/share/fonts/opentype/dejavu/DejaVuSans.ttf",
+      nullptr};
 #endif

-  for (int i = 0; font_paths[i] != nullptr; i++) {
-    std::ifstream font_file(font_paths[i], std::ios::binary);
-    if (font_file.good()) {
-      font_file.close();
-      if (!system_chinese_font_out) {
-        break;
-      }
-
-      *system_chinese_font_out =
-          io.Fonts->AddFontFromFileTTF(font_paths[i], font_size, &config,
-                                       io.Fonts->GetGlyphRangesChineseFull());
-      if (*system_chinese_font_out != nullptr) {
-        // Merge FontAwesome icons into the Chinese font
-        config.MergeMode = true;
-        static const ImWchar icon_ranges[] = {ICON_MIN_FA, ICON_MAX_FA, 0};
-        io.Fonts->AddFontFromMemoryTTF(fa_solid_900_ttf, fa_solid_900_ttf_len,
-                                       font_size, &config, icon_ranges);
-        config.MergeMode = false;
-        LOG_INFO("Loaded system Chinese font with icons: {}", font_paths[i]);
-        break;
-      }
+  for (int i = 0; base_font_paths[i] != nullptr && ui_font == nullptr; ++i) {
+    if (!CanReadFontFile(base_font_paths[i])) {
+      continue;
+    }
+    ui_font = io.Fonts->AddFontFromFileTTF(base_font_paths[i], font_size,
+                                           &config, multilingual_ranges);
+    if (ui_font != nullptr) {
+      LOG_INFO("Loaded base UI font: {}", base_font_paths[i]);
    }
  }
+  if (!ui_font) {
+    ui_font = io.Fonts->AddFontDefault(&config);
+  }

-  // If no system font found, use default font
-  if (system_chinese_font_out && *system_chinese_font_out == nullptr) {
-    *system_chinese_font_out = io.Fonts->AddFontDefault(&config);
-    // Merge FontAwesome icons into the default font
-    config.MergeMode = true;
-    static const ImWchar icon_ranges[] = {ICON_MIN_FA, ICON_MAX_FA, 0};
-    io.Fonts->AddFontFromMemoryTTF(fa_solid_900_ttf, fa_solid_900_ttf_len,
-                                   font_size, &config, icon_ranges);
-    config.MergeMode = false;
-    LOG_WARN("System Chinese font not found, using default font with icons");
+  if (!ui_font) {
+    LOG_WARN("Failed to initialize base UI font");
+    ImGui::StyleColorsLight();
+    return 0;
+  }
+
+  ImFontConfig icon_config = config;
+  icon_config.MergeMode = true;
+  static const ImWchar icon_ranges[] = {ICON_MIN_FA, ICON_MAX_FA, 0};
+  io.Fonts->AddFontFromMemoryTTF(fa_solid_900_ttf, fa_solid_900_ttf_len,
+                                 font_size, &icon_config, icon_ranges);
+
+  io.FontDefault = ui_font;
+  if (system_chinese_font_out) {
+    *system_chinese_font_out = ui_font;
  }

  ImGui::StyleColorsLight();
@@ -1431,10 +1483,10 @@ int Render::Run() {
  if (!latest_version_info_.empty() &&
      latest_version_info_.contains("version") &&
      latest_version_info_["version"].is_string()) {
-    latest_version_ = latest_version_info_["version"];
+    latest_version_ = 'v' + latest_version_info_["version"].get<std::string>();
    if (latest_version_info_.contains("releaseNotes") &&
        latest_version_info_["releaseNotes"].is_string()) {
-      release_notes_ = latest_version_info_["releaseNotes"];
+      release_notes_ = latest_version_info_["releaseNotes"].get<std::string>();
    } else {
      release_notes_ = "";
    }
@@ -1495,16 +1547,27 @@ void Render::InitializeLogger() { InitLogger(exec_log_path_); }
 void Render::InitializeSettings() {
  LoadSettingsFromCacheFile();

-  localization_language_ = (ConfigCenter::LANGUAGE)language_button_value_;
-  localization_language_index_ = language_button_value_;
-  if (localization_language_index_ != 0 && localization_language_index_ != 1) {
-    localization_language_index_ = 0;
-    LOG_ERROR("Invalid language index: [{}], use [0] by default",
-              localization_language_index_);
+  localization_language_index_ =
+      localization::detail::ClampLanguageIndex(language_button_value_);
+  language_button_value_ = localization_language_index_;
+
+  if (localization_language_index_ == 0) {
+    localization_language_ = ConfigCenter::LANGUAGE::CHINESE;
+  } else if (localization_language_index_ == 1) {
+    localization_language_ = ConfigCenter::LANGUAGE::ENGLISH;
+  } else {
+    localization_language_ = ConfigCenter::LANGUAGE::RUSSIAN;
  }
 }

 void Render::InitializeSDL() {
+#if defined(__linux__) && !defined(__APPLE__)
+  if (!getenv("SDL_AUDIODRIVER")) {
+    // Prefer PulseAudio first on Linux to avoid hard ALSA plugin dependency.
+    setenv("SDL_AUDIODRIVER", "pulseaudio", 0);
+  }
+#endif
+
  if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
    LOG_ERROR("Error: {}", SDL_GetError());
    return;
@@ -1541,7 +1604,8 @@ void Render::InitializeModules() {
          std::shared_lock lock(client_properties_mutex_);
          int ret = -1;
          for (const auto& [remote_id, props] : client_properties_) {
-            if (props && props->peer_ && props->connection_established_) {
+            if (props && props->peer_ && props->connection_established_ &&
+                props->enable_mouse_control_) {
              ret = SendReliableDataFrame(props->peer_, data, size,
                                          props->clipboard_label_.c_str());
              if (ret != 0) {
@@ -1596,6 +1660,7 @@ void Render::MainLoop() {
    UpdateLabels();
    HandleRecentConnections();
    HandleConnectionStatusChange();
+    HandlePendingPresenceProbe();
    HandleStreamWindow();
    HandleServerWindow();

@@ -1675,6 +1740,84 @@ void Render::HandleConnectionStatusChange() {
  need_to_send_recent_connections_ = false;
 }

+void Render::HandlePendingPresenceProbe() {
+  bool has_action = false;
+  bool should_connect = false;
+  bool remember_password = false;
+  std::string remote_id;
+  std::string password;
+
+  {
+    std::lock_guard<std::mutex> lock(pending_presence_probe_mutex_);
+    if (!pending_presence_probe_ || !pending_presence_result_ready_) {
+      return;
+    }
+
+    has_action = true;
+    should_connect = pending_presence_online_;
+    remote_id = pending_presence_remote_id_;
+    password = pending_presence_password_;
+    remember_password = pending_presence_remember_password_;
+
+    pending_presence_probe_ = false;
+    pending_presence_result_ready_ = false;
+    pending_presence_online_ = false;
+    pending_presence_remote_id_.clear();
+    pending_presence_password_.clear();
+    pending_presence_remember_password_ = false;
+  }
+
+  if (!has_action) {
+    return;
+  }
+
+  if (should_connect) {
+    ConnectTo(remote_id, password.c_str(), remember_password, true);
+    return;
+  }
+
+  offline_warning_text_ =
+      localization::device_offline[localization_language_index_];
+  show_offline_warning_window_ = true;
+}
+
+int Render::RequestSingleDevicePresence(const std::string& remote_id,
+                                        const char* password,
+                                        bool remember_password) {
+  if (!signal_connected_ || !peer_) {
+    return -1;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(pending_presence_probe_mutex_);
+    pending_presence_probe_ = true;
+    pending_presence_result_ready_ = false;
+    pending_presence_online_ = false;
+    pending_presence_remote_id_ = remote_id;
+    pending_presence_password_ = password ? password : "";
+    pending_presence_remember_password_ = remember_password;
+  }
+
+  nlohmann::json j;
+  j["type"] = "recent_connections_presence";
+  j["user_id"] = client_id_;
+  j["devices"] = nlohmann::json::array({remote_id});
+  auto s = j.dump();
+
+  int ret = SendSignalMessage(peer_, s.data(), s.size());
+  if (ret != 0) {
+    std::lock_guard<std::mutex> lock(pending_presence_probe_mutex_);
+    pending_presence_probe_ = false;
+    pending_presence_result_ready_ = false;
+    pending_presence_online_ = false;
+    pending_presence_remote_id_.clear();
+    pending_presence_password_.clear();
+    pending_presence_remember_password_ = false;
+  }
+
+  return ret;
+}
+
 void Render::HandleStreamWindow() {
  if (need_to_create_stream_window_) {
    CreateStreamWindow();
@@ -2247,7 +2390,8 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
    case SDL_EVENT_MOUSE_BUTTON_DOWN:
    case SDL_EVENT_MOUSE_BUTTON_UP:
    case SDL_EVENT_MOUSE_WHEEL:
-      if (focus_on_stream_window_) {
+      if (focus_on_stream_window_ && stream_window_ &&
+          SDL_GetWindowID(stream_window_) == event.motion.windowID) {
        ProcessMouseEvent(event);
      }
      break;
@@ -2470,4 +2614,4 @@ void Render::ProcessFileDropEvent(const SDL_Event& event) {
    // Handle the dropped file on server window as needed
  }
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/render.h
+++ b/src/gui/render.h
@@ -95,7 +95,7 @@ class Render {
    bool connection_established_ = false;
    bool rejoin_ = false;
    bool net_traffic_stats_button_pressed_ = false;
-    bool mouse_control_button_pressed_ = true;
+    bool enable_mouse_control_ = true;
    bool mouse_controller_is_started_ = false;
    bool audio_capture_button_pressed_ = true;
    bool control_mouse_ = true;
@@ -194,6 +194,7 @@ class Render {
  void UpdateInteractions();
  void HandleRecentConnections();
  void HandleConnectionStatusChange();
+  void HandlePendingPresenceProbe();
  void HandleStreamWindow();
  void HandleServerWindow();
  void Cleanup();
@@ -235,6 +236,7 @@ class Render {
  bool ConnectionStatusWindow(
      std::shared_ptr<SubStreamWindowProperties>& props);
  int ShowRecentConnections();
+  bool OpenUrl(const std::string& url);
  void Hyperlink(const std::string& label, const std::string& url,
                 const float window_width);
  int FileTransferWindow(std::shared_ptr<SubStreamWindowProperties>& props);
@@ -242,7 +244,9 @@ class Render {

 private:
  int ConnectTo(const std::string& remote_id, const char* password,
-                bool remember_password);
+                bool remember_password, bool bypass_presence_check = false);
+  int RequestSingleDevicePresence(const std::string& remote_id,
+                                  const char* password, bool remember_password);
  int CreateMainWindow();
  int DestroyMainWindow();
  int CreateStreamWindow();
@@ -261,6 +265,8 @@ class Render {
  int NetTrafficStats(std::shared_ptr<SubStreamWindowProperties>& props);
  void DrawConnectionStatusText(
      std::shared_ptr<SubStreamWindowProperties>& props);
+  void DrawReceivingScreenText(
+      std::shared_ptr<SubStreamWindowProperties>& props);
 #ifdef __APPLE__
  int RequestPermissionWindow();
  bool CheckScreenRecordingPermission();
@@ -439,7 +445,7 @@ class Render {
  bool screen_capturer_is_started_ = false;
  bool start_speaker_capturer_ = false;
  bool speaker_capturer_is_started_ = false;
-  bool start_keyboard_capturer_ = true;
+  bool start_keyboard_capturer_ = false;
  bool show_cursor_ = false;
  bool keyboard_capturer_is_started_ = false;
  bool foucs_on_main_window_ = false;
@@ -687,6 +693,13 @@ class Render {
  std::unordered_map<std::string, std::string> connection_host_names_;
  std::string selected_server_remote_id_ = "";
  std::string selected_server_remote_hostname_ = "";
+  std::mutex pending_presence_probe_mutex_;
+  bool pending_presence_probe_ = false;
+  bool pending_presence_result_ready_ = false;
+  bool pending_presence_online_ = false;
+  std::string pending_presence_remote_id_ = "";
+  std::string pending_presence_password_ = "";
+  bool pending_presence_remember_password_ = false;
  FileTransferState file_transfer_;
 };
 }  // namespace crossdesk
--- a/src/gui/render_callback.cpp
+++ b/src/gui/render_callback.cpp
@@ -48,6 +48,15 @@ void Render::OnSignalMessageCb(const char* message, size_t size,
        std::string id = dev["id"].get<std::string>();
        bool online = dev["online"].get<bool>();
        render->device_presence_.SetOnline(id, online);
+        {
+          std::lock_guard<std::mutex> lock(
+              render->pending_presence_probe_mutex_);
+          if (render->pending_presence_probe_ &&
+              render->pending_presence_remote_id_ == id) {
+            render->pending_presence_result_ready_ = true;
+            render->pending_presence_online_ = online;
+          }
+        }
      }
    }
  } else if (type == "presence_update") {
@@ -57,6 +66,15 @@ void Render::OnSignalMessageCb(const char* message, size_t size,
      bool online = j["online"].get<bool>();
      if (!id.empty()) {
        render->device_presence_.SetOnline(id, online);
+        {
+          std::lock_guard<std::mutex> lock(
+              render->pending_presence_probe_mutex_);
+          if (render->pending_presence_probe_ &&
+              render->pending_presence_remote_id_ == id) {
+            render->pending_presence_result_ready_ = true;
+            render->pending_presence_online_ = online;
+          }
+        }
      }
    }
  }
@@ -72,17 +90,16 @@ int Render::SendKeyCommand(int key_code, bool is_down) {
  }
  remote_action.k.key_value = key_code;

-  if (!controlled_remote_id_.empty()) {
-    // std::shared_lock lock(client_properties_mutex_);
-    if (client_properties_.find(controlled_remote_id_) !=
-        client_properties_.end()) {
-      auto props = client_properties_[controlled_remote_id_];
-      if (props->connection_status_ == ConnectionStatus::Connected) {
+  std::string target_id = controlled_remote_id_.empty() ? focused_remote_id_
+                                                        : controlled_remote_id_;
+  if (!target_id.empty()) {
+    if (client_properties_.find(target_id) != client_properties_.end()) {
+      auto props = client_properties_[target_id];
+      if (props->connection_status_ == ConnectionStatus::Connected &&
+          props->peer_) {
        std::string msg = remote_action.to_json();
-        if (props->peer_) {
-          SendDataFrame(props->peer_, msg.c_str(), msg.size(),
-                        props->data_label_.c_str());
-        }
+        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+                      props->data_label_.c_str());
      }
    }
  }
@@ -396,6 +413,13 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
    return;
  } else if (source_id == render->clipboard_label_) {
    if (size > 0) {
+      std::string remote_user_id(user_id, user_id_size);
+      auto props =
+          render->GetSubStreamWindowPropertiesByRemoteId(remote_user_id);
+      if (props && !props->enable_mouse_control_) {
+        return;
+      }
+
      std::string clipboard_text(data, size);
      if (!Clipboard::SetText(clipboard_text)) {
        LOG_ERROR("Failed to set clipboard content from remote");
@@ -649,6 +673,7 @@ void Render::OnSignalStatusCb(SignalStatus status, const char* user_id,
      render->signal_connected_ = false;
    } else if (SignalStatus::SignalConnected == status) {
      render->signal_connected_ = true;
+      render->need_to_send_recent_connections_ = true;
      LOG_INFO("[{}] connected to signal server", client_id);
    } else if (SignalStatus::SignalFailed == status) {
      render->signal_connected_ = false;
@@ -758,13 +783,14 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
            0, (int)render->title_bar_height_,
            (int)render->stream_window_width_,
            (int)(render->stream_window_height_ - render->title_bar_height_)};
+        render->start_keyboard_capturer_ = true;
        break;
      }
      case ConnectionStatus::Disconnected:
      case ConnectionStatus::Failed:
      case ConnectionStatus::Closed: {
        props->connection_established_ = false;
-        props->mouse_control_button_pressed_ = false;
+        props->enable_mouse_control_ = false;

        {
          std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
@@ -782,6 +808,8 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
        event.user.data1 = props.get();
        SDL_PushEvent(&event);

+        render->focus_on_stream_window_ = false;
+
        break;
      }
      case ConnectionStatus::IncorrectPassword: {
@@ -861,12 +889,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
        render->start_screen_capturer_ = true;
        render->start_speaker_capturer_ = true;
        render->remote_client_id_ = remote_id;
-#ifdef CROSSDESK_DEBUG
-        render->start_mouse_controller_ = false;
-        render->start_keyboard_capturer_ = false;
-#else
        render->start_mouse_controller_ = true;
-#endif
        if (std::all_of(render->connection_status_.begin(),
                        render->connection_status_.end(), [](const auto& kv) {
                          return kv.first.find("web") != std::string::npos;
@@ -876,6 +899,8 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,

        break;
      }
+      case ConnectionStatus::Disconnected:
+      case ConnectionStatus::Failed:
      case ConnectionStatus::Closed: {
        if (std::all_of(render->connection_status_.begin(),
                        render->connection_status_.end(), [](const auto& kv) {
@@ -897,6 +922,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
          }

          render->connection_status_.erase(remote_id);
+          render->connection_host_names_.erase(remote_id);
          if (render->screen_capturer_) {
            render->screen_capturer_->ResetToInitialMonitor();
          }
--- a/src/gui/toolbars/control_bar.cpp
+++ b/src/gui/toolbars/control_bar.cpp
@@ -198,24 +198,21 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
    float mouse_y = ImGui::GetCursorScreenPos().y;
    float disable_mouse_x = mouse_x + line_padding;
    float disable_mouse_y = mouse_y + line_padding;
-    std::string mouse = props->mouse_control_button_pressed_
-                            ? ICON_FA_COMPUTER_MOUSE
-                            : ICON_FA_COMPUTER_MOUSE;
+    std::string mouse = ICON_FA_COMPUTER_MOUSE;
    ImGui::SetWindowFontScale(0.5f);
    if (ImGui::Button(mouse.c_str(), ImVec2(button_width, button_height))) {
      if (props->connection_established_) {
        start_keyboard_capturer_ = !start_keyboard_capturer_;
        props->control_mouse_ = !props->control_mouse_;
-        props->mouse_control_button_pressed_ =
-            !props->mouse_control_button_pressed_;
+        props->enable_mouse_control_ = !props->enable_mouse_control_;
        props->mouse_control_button_label_ =
-            props->mouse_control_button_pressed_
+            props->enable_mouse_control_
                ? localization::release_mouse[localization_language_index_]
                : localization::control_mouse[localization_language_index_];
      }
    }

-    if (!props->mouse_control_button_pressed_) {
+    if (!props->enable_mouse_control_) {
      draw_list->AddLine(ImVec2(disable_mouse_x, disable_mouse_y),
                         ImVec2(mouse_x + button_width - line_padding,
                                mouse_y + button_height - line_padding),
--- a/src/gui/toolbars/status_bar.cpp
+++ b/src/gui/toolbars/status_bar.cpp
@@ -16,7 +16,7 @@ int Render::StatusBar() {
  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
  ImGui::BeginChild("StatusBar", ImVec2(status_bar_width, status_bar_height),
-                    ImGuiChildFlags_Border,
+                    ImGuiChildFlags_Borders,
                    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
                        ImGuiWindowFlags_NoBringToFrontOnFocus);
  ImGui::PopStyleColor(2);
@@ -45,4 +45,4 @@ int Render::StatusBar() {
  ImGui::EndChild();
  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/toolbars/title_bar.cpp
+++ b/src/gui/toolbars/title_bar.cpp
@@ -51,7 +51,7 @@ int Render::TitleBar(bool main_window) {
  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
  ImGui::BeginChild(main_window ? "MainTitleBar" : "StreamTitleBar",
                    ImVec2(title_bar_width, title_bar_height_padding),
-                    ImGuiChildFlags_Border,
+                    ImGuiChildFlags_Borders,
                    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
                        ImGuiWindowFlags_NoBringToFrontOnFocus);
  ImGui::PopStyleVar();
@@ -329,4 +329,4 @@ int Render::TitleBar(bool main_window) {
  ImGui::EndChild();
  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/tray/win_tray.cpp
+++ b/src/gui/tray/win_tray.cpp
@@ -89,7 +89,7 @@ bool WinTray::HandleTrayMessage(MSG* msg) {
      GetCursorPos(&pt);
      HMENU menu = CreatePopupMenu();
      AppendMenuW(menu, MF_STRING, 1001,
-                  localization::exit_program[language_index_]);
+                  localization::GetExitProgramLabel(language_index_));

      SetForegroundWindow(hwnd_message_only_);
      int cmd =
@@ -112,4 +112,4 @@ bool WinTray::HandleTrayMessage(MSG* msg) {
  }
  return true;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/windows/about_window.cpp
+++ b/src/gui/windows/about_window.cpp
@@ -12,11 +12,44 @@

 namespace crossdesk {

+bool Render::OpenUrl(const std::string& url) {
+#if defined(_WIN32)
+  int wide_len = MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, nullptr, 0);
+  if (wide_len <= 0) {
+    return false;
+  }
+
+  std::wstring wide_url(static_cast<size_t>(wide_len), L'\0');
+  MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, &wide_url[0], wide_len);
+  if (!wide_url.empty() && wide_url.back() == L'\0') {
+    wide_url.pop_back();
+  }
+
+  std::wstring cmd = L"cmd.exe /c start \"\" \"" + wide_url + L"\"";
+  STARTUPINFOW startup_info = {sizeof(startup_info)};
+  PROCESS_INFORMATION process_info = {};
+  if (!CreateProcessW(nullptr, &cmd[0], nullptr, nullptr, FALSE,
+                      CREATE_NO_WINDOW, nullptr, nullptr, &startup_info,
+                      &process_info)) {
+    return false;
+  }
+
+  CloseHandle(process_info.hThread);
+  CloseHandle(process_info.hProcess);
+  return true;
+#elif defined(__APPLE__)
+  std::string cmd = "open " + url;
+  return system(cmd.c_str()) == 0;
+#else
+  std::string cmd = "xdg-open " + url;
+  return system(cmd.c_str()) == 0;
+#endif
+}
+
 void Render::Hyperlink(const std::string& label, const std::string& url,
                       const float window_width) {
  ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(0, 0, 255, 255));
-  ImGui::SetCursorPosX(window_width * 0.1f);
-  ImGui::Text("%s", label.c_str());
+  ImGui::TextUnformatted(label.c_str());
  ImGui::PopStyleColor();

  if (ImGui::IsItemHovered()) {
@@ -27,35 +60,7 @@ void Render::Hyperlink(const std::string& label, const std::string& url,
    ImGui::SetWindowFontScale(1.0f);
    ImGui::EndTooltip();
    if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
-#if defined(_WIN32)
-      int wide_len =
-          MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, nullptr, 0);
-      if (wide_len > 0) {
-        std::wstring wide_url(static_cast<size_t>(wide_len), L'\0');
-        MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, &wide_url[0],
-                            wide_len);
-        if (!wide_url.empty() && wide_url.back() == L'\0') {
-          wide_url.pop_back();
-        }
-
-        std::wstring cmd = L"cmd.exe /c start \"\" \"" + wide_url + L"\"";
-        STARTUPINFOW startup_info = {sizeof(startup_info)};
-        PROCESS_INFORMATION process_info = {};
-        if (CreateProcessW(nullptr, &cmd[0], nullptr, nullptr, FALSE,
-                           CREATE_NO_WINDOW, nullptr, nullptr, &startup_info,
-                           &process_info)) {
-          CloseHandle(process_info.hThread);
-          CloseHandle(process_info.hProcess);
-        }
-      }
-#elif defined(__APPLE__)
-      std::string cmd = "open " + url;
-#else
-      std::string cmd = "xdg-open " + url;
-#endif
-#if !defined(_WIN32)
-      system(cmd.c_str());  // open browser
-#endif
+      OpenUrl(url);
    }
  }
 }
@@ -65,7 +70,7 @@ int Render::AboutWindow() {
    float about_window_width = title_bar_button_width_ * 7.5f;
    float about_window_height = latest_version_.empty()
                                    ? title_bar_button_width_ * 4.0f
-                                    : title_bar_button_width_ * 4.6f;
+                                    : title_bar_button_width_ * 4.9f;

    const ImGuiViewport* viewport = ImGui::GetMainViewport();
    ImGui::SetNextWindowPos(ImVec2(
@@ -99,16 +104,23 @@ int Render::AboutWindow() {
    ImGui::SetCursorPosX(about_window_width * 0.1f);
    ImGui::Text("%s", text.c_str());

-    if (update_available_) {
-      std::string latest_version =
+    if (0) {
+      std::string new_version_available =
          localization::new_version_available[localization_language_index_] +
-          ": " + latest_version_;
+          ": ";
+      ImGui::SetCursorPosX(about_window_width * 0.1f);
+      ImGui::Text("%s", new_version_available.c_str());
      std::string access_website =
          localization::access_website[localization_language_index_];
-      Hyperlink(latest_version, "https://crossdesk.cn", about_window_width);
-    }
+      ImGui::SetCursorPosX((about_window_width -
+                            ImGui::CalcTextSize(latest_version_.c_str()).x) /
+                           2.0f);
+      Hyperlink(latest_version_, "https://crossdesk.cn", about_window_width);

-    ImGui::Text("");
+      ImGui::Spacing();
+    } else {
+      ImGui::Text("%s", "");
+    }

    std::string copyright_text = "© 2025 by JUNKUN DI. All rights reserved.";
    std::string license_text = "Licensed under GNU LGPL v3.";
@@ -118,7 +130,7 @@ int Render::AboutWindow() {
    ImGui::Text("%s", license_text.c_str());

    ImGui::SetCursorPosX(about_window_width * 0.445f);
-    ImGui::SetCursorPosY(about_window_height * 0.75f);
+    ImGui::SetCursorPosY(about_window_height * 0.8f);
    // OK
    if (ImGui::Button(localization::ok[localization_language_index_].c_str())) {
      show_about_window_ = false;
--- a/src/gui/windows/connection_status_window.cpp
+++ b/src/gui/windows/connection_status_window.cpp
@@ -36,6 +36,18 @@ bool Render::ConnectionStatusWindow(
    text = localization::p2p_connecting[localization_language_index_];
    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
+    // cancel
+    if (ImGui::Button(
+            localization::cancel[localization_language_index_].c_str()) ||
+        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+      show_connection_status_window_ = false;
+      re_enter_remote_id_ = true;
+      LOG_INFO("User cancelled connecting to [{}]", props->remote_id_);
+      if (props->peer_) {
+        LeaveConnection(props->peer_, props->remote_id_.c_str());
+      }
+      ret_flag = true;
+    }
  } else if (ConnectionStatus::Connected == props->connection_status_) {
    text = localization::p2p_connected[localization_language_index_];
    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
--- a/src/gui/windows/control_window.cpp
+++ b/src/gui/windows/control_window.cpp
@@ -224,7 +224,7 @@ int Render::ControlWindow(std::shared_ptr<SubStreamWindowProperties>& props) {
  ImGui::BeginChild(
      control_child_window_title.c_str(),
      ImVec2(props->control_window_width_, props->control_window_height_),
-      ImGuiChildFlags_Border, ImGuiWindowFlags_NoDecoration);
+      ImGuiChildFlags_Borders, ImGuiWindowFlags_NoDecoration);
  ImGui::PopStyleColor();

  props->control_window_pos_ = ImGui::GetWindowPos();
@@ -257,3 +257,4 @@ int Render::ControlWindow(std::shared_ptr<SubStreamWindowProperties>& props) {
  return 0;
 }
 }  // namespace crossdesk
+
--- a/src/gui/windows/file_transfer_window.cpp
+++ b/src/gui/windows/file_transfer_window.cpp
@@ -130,7 +130,7 @@ int Render::FileTransferWindow(
      ImGui::SetWindowFontScale(0.5f);
      ImGui::BeginChild(
          "FileList", ImVec2(0, file_transfer_window_height * 0.75f),
-          ImGuiChildFlags_Border, ImGuiWindowFlags_HorizontalScrollbar);
+          ImGuiChildFlags_Borders, ImGuiWindowFlags_HorizontalScrollbar);
      ImGui::SetWindowFontScale(1.0f);
      ImGui::SetWindowFontScale(0.5f);

@@ -242,3 +242,4 @@ int Render::FileTransferWindow(
 }

 }  // namespace crossdesk
+
--- a/src/gui/windows/main_settings_window.cpp
+++ b/src/gui/windows/main_settings_window.cpp
@@ -60,9 +60,9 @@ int Render::SettingWindow() {
      ImGui::SetWindowFontScale(0.5f);
      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
      {
-        const char* language_items[] = {
-            localization::language_zh[localization_language_index_].c_str(),
-            localization::language_en[localization_language_index_].c_str()};
+        const auto& supported_languages = localization::GetSupportedLanguages();
+        language_button_value_ =
+            localization::detail::ClampLanguageIndex(language_button_value_);

        settings_items_offset += settings_items_padding;
        ImGui::SetCursorPosY(settings_items_offset);
@@ -77,13 +77,23 @@ int Render::SettingWindow() {
        }

        ImGui::SetNextItemWidth(title_bar_button_width_ * 1.8f);
-        if (ImGui::BeginCombo("##language",
-                              language_items[language_button_value_])) {
+        if (ImGui::BeginCombo(
+                "##language",
+                localization::GetSupportedLanguages()
+                    [localization::detail::ClampLanguageIndex(
+                        language_button_value_)]
+                    .display_name
+                    .c_str())) {
          ImGui::SetWindowFontScale(0.5f);
-          for (int i = 0; i < IM_ARRAYSIZE(language_items); i++) {
+          for (int i = 0; i < static_cast<int>(supported_languages.size());
+               ++i) {
            bool selected = (i == language_button_value_);
-            if (ImGui::Selectable(language_items[i], selected))
+            if (ImGui::Selectable(
+                    supported_languages[i].display_name.c_str(), selected))
              language_button_value_ = i;
+            if (selected) {
+              ImGui::SetItemDefaultFocus();
+            }
          }

          ImGui::EndCombo();
@@ -438,16 +448,24 @@ int Render::SettingWindow() {
        show_self_hosted_server_config_window_ = false;

        // Language
+        language_button_value_ =
+            localization::detail::ClampLanguageIndex(language_button_value_);
        if (language_button_value_ == 0) {
-          config_center_->SetLanguage(ConfigCenter::LANGUAGE::CHINESE);
+          localization_language_ = ConfigCenter::LANGUAGE::CHINESE;
+        } else if (language_button_value_ == 1) {
+          localization_language_ = ConfigCenter::LANGUAGE::ENGLISH;
        } else {
-          config_center_->SetLanguage(ConfigCenter::LANGUAGE::ENGLISH);
+          localization_language_ = ConfigCenter::LANGUAGE::RUSSIAN;
        }
+        config_center_->SetLanguage(localization_language_);
        language_button_value_last_ = language_button_value_;
-        localization_language_ = (ConfigCenter::LANGUAGE)language_button_value_;
        localization_language_index_ = language_button_value_;
        LOG_INFO("Set localization language: {}",
-                 localization_language_index_ == 0 ? "zh" : "en");
+                 localization::GetSupportedLanguages()
+                     [localization::detail::ClampLanguageIndex(
+                         localization_language_index_)]
+                     .code
+                     .c_str());

        // Video quality
        if (video_quality_button_value_ == 0) {
@@ -602,4 +620,4 @@ int Render::SettingWindow() {

  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/windows/main_window.cpp
+++ b/src/gui/windows/main_window.cpp
@@ -19,7 +19,7 @@ int Render::MainWindow() {
  ImGui::BeginChild(
      "DeskWindow",
      ImVec2(local_remote_window_width, local_remote_window_height),
-      ImGuiChildFlags_Border,
+      ImGuiChildFlags_Borders,
      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
          ImGuiWindowFlags_NoBringToFrontOnFocus);
  ImGui::PopStyleVar();
@@ -57,4 +57,4 @@ int Render::MainWindow() {

  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/windows/server_window.cpp
+++ b/src/gui/windows/server_window.cpp
@@ -66,7 +66,7 @@ int Render::ServerWindow() {
  ImGui::BeginChild(
      "ServerTitleBar",
      ImVec2(server_window_width_, server_window_title_bar_height_),
-      ImGuiChildFlags_Border,
+      ImGuiChildFlags_Borders,
      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
          ImGuiWindowFlags_NoBringToFrontOnFocus);

@@ -140,7 +140,7 @@ int Render::RemoteClientInfoWindow() {
  ImGui::BeginChild(
      "RemoteClientInfoWindow",
      ImVec2(remote_client_info_window_width, remote_client_info_window_height),
-      ImGuiChildFlags_Border,
+      ImGuiChildFlags_Borders,
      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
          ImGuiWindowFlags_NoBringToFrontOnFocus);
  ImGui::PopStyleVar();
@@ -148,33 +148,38 @@ int Render::RemoteClientInfoWindow() {

  float font_scale = localization_language_index_ == 0 ? 0.5f : 0.45f;

-  std::vector<std::string> remote_hostnames;
-  remote_hostnames.reserve(connection_host_names_.size());
-  for (const auto& kv : connection_host_names_) {
-    remote_hostnames.push_back(kv.second);
+  std::vector<std::pair<std::string, std::string>> remote_entries;
+  remote_entries.reserve(connection_status_.size());
+  for (const auto& kv : connection_status_) {
+    const auto host_it = connection_host_names_.find(kv.first);
+    const std::string display_name =
+        (host_it != connection_host_names_.end() && !host_it->second.empty())
+            ? host_it->second
+            : kv.first;
+    remote_entries.emplace_back(kv.first, display_name);
  }

-  auto find_remote_id_by_hostname =
-      [this](const std::string& hostname) -> std::string {
-    for (const auto& kv : connection_host_names_) {
-      if (kv.second == hostname) {
-        return kv.first;
+  auto find_display_name_by_remote_id =
+      [&remote_entries](const std::string& remote_id) -> std::string {
+    for (const auto& entry : remote_entries) {
+      if (entry.first == remote_id) {
+        return entry.second;
      }
    }
    return {};
  };

-  if (!selected_server_remote_hostname_.empty()) {
-    if (std::find(remote_hostnames.begin(), remote_hostnames.end(),
-                  selected_server_remote_hostname_) == remote_hostnames.end()) {
-      selected_server_remote_hostname_.clear();
-      selected_server_remote_id_.clear();
-    }
+  if (!selected_server_remote_id_.empty() &&
+      find_display_name_by_remote_id(selected_server_remote_id_).empty()) {
+    selected_server_remote_id_.clear();
+    selected_server_remote_hostname_.clear();
  }
-  if (selected_server_remote_hostname_.empty() && !remote_hostnames.empty()) {
-    selected_server_remote_hostname_ = remote_hostnames.front();
-    selected_server_remote_id_ =
-        find_remote_id_by_hostname(selected_server_remote_hostname_);
+  if (selected_server_remote_id_.empty() && !remote_entries.empty()) {
+    selected_server_remote_id_ = remote_entries.front().first;
+  }
+  if (!selected_server_remote_id_.empty()) {
+    selected_server_remote_hostname_ =
+        find_display_name_by_remote_id(selected_server_remote_id_);
  }

  ImGui::SetWindowFontScale(font_scale);
@@ -196,13 +201,12 @@ int Render::RemoteClientInfoWindow() {
  ImGui::AlignTextToFramePadding();
  if (ImGui::BeginCombo("##server_remote_id", selected_preview)) {
    ImGui::SetWindowFontScale(localization_language_index_ == 0 ? 0.45f : 0.4f);
-    for (int i = 0; i < static_cast<int>(remote_hostnames.size()); i++) {
+    for (int i = 0; i < static_cast<int>(remote_entries.size()); i++) {
      const bool selected =
-          (remote_hostnames[i] == selected_server_remote_hostname_);
-      if (ImGui::Selectable(remote_hostnames[i].c_str(), selected)) {
-        selected_server_remote_hostname_ = remote_hostnames[i];
-        selected_server_remote_id_ =
-            find_remote_id_by_hostname(selected_server_remote_hostname_);
+          (remote_entries[i].first == selected_server_remote_id_);
+      if (ImGui::Selectable(remote_entries[i].second.c_str(), selected)) {
+        selected_server_remote_id_ = remote_entries[i].first;
+        selected_server_remote_hostname_ = remote_entries[i].second;
      }
      if (selected) {
        ImGui::SetItemDefaultFocus();
@@ -372,4 +376,4 @@ int Render::RemoteClientInfoWindow() {

  return 0;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/gui/windows/stream_window.cpp
+++ b/src/gui/windows/stream_window.cpp
@@ -31,6 +31,34 @@ void Render::DrawConnectionStatusText(
  }
 }

+void Render::DrawReceivingScreenText(
+    std::shared_ptr<SubStreamWindowProperties>& props) {
+  if (!props->connection_established_ ||
+      props->connection_status_ != ConnectionStatus::Connected) {
+    return;
+  }
+
+  bool has_valid_frame = false;
+  {
+    std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
+    has_valid_frame = props->stream_texture_ != nullptr &&
+                      props->video_width_ > 0 && props->video_height_ > 0 &&
+                      props->front_frame_ && !props->front_frame_->empty();
+  }
+
+  if (has_valid_frame) {
+    return;
+  }
+
+  const std::string& text =
+      localization::receiving_screen[localization_language_index_];
+  ImVec2 size = ImGui::GetWindowSize();
+  ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
+  ImGui::SetCursorPos(
+      ImVec2((size.x - text_size.x) * 0.5f, (size.y - text_size.y) * 0.5f));
+  ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.92f), "%s", text.c_str());
+}
+
 void Render::CloseTab(decltype(client_properties_)::iterator& it) {
  // std::unique_lock lock(client_properties_mutex_);
  if (it != client_properties_.end()) {
@@ -144,6 +172,8 @@ int Render::StreamWindow() {
          // Show file transfer window if needed
          FileTransferWindow(props);

+          DrawReceivingScreenText(props);
+
          focused_remote_id_ = props->remote_id_;

          if (!props->peer_) {
@@ -244,6 +274,8 @@ int Render::StreamWindow() {
        // Show file transfer window if needed
        FileTransferWindow(props);

+        DrawReceivingScreenText(props);
+
        ImGui::End();

        if (!props->peer_) {
--- a/src/gui/windows/update_notification_window.cpp
+++ b/src/gui/windows/update_notification_window.cpp
@@ -1,5 +1,4 @@
 #include <algorithm>
-#include <cstdlib>
 #include <string>

 #include "layout.h"
@@ -104,6 +103,7 @@ int Render::UpdateNotificationWindow() {
        localization::access_website[localization_language_index_] +
        "https://crossdesk.cn";
    ImGui::SetWindowFontScale(0.5f);
+    ImGui::SetCursorPosX(update_notification_window_width * 0.1f);
    Hyperlink(download_text, "https://crossdesk.cn",
              update_notification_window_width);
    ImGui::SetWindowFontScale(1.0f);
@@ -121,7 +121,7 @@ int Render::UpdateNotificationWindow() {
    ImGui::BeginChild(
        "ScrollableContent",
        ImVec2(update_notification_window_width * 0.9f, scrollable_height),
-        ImGuiChildFlags_Border, ImGuiWindowFlags_None);
+        ImGuiChildFlags_Borders, ImGuiWindowFlags_None);
    ImGui::SetWindowFontScale(0.5f);
    // set text wrap position to current available width (accounts for
    // scrollbar)
@@ -184,14 +184,7 @@ int Render::UpdateNotificationWindow() {
            localization::update[localization_language_index_].c_str())) {
      // open download page
      std::string url = "https://crossdesk.cn";
-#if defined(_WIN32)
-      std::string cmd = "start " + url;
-#elif defined(__APPLE__)
-      std::string cmd = "open " + url;
-#else
-      std::string cmd = "xdg-open " + url;
-#endif
-      system(cmd.c_str());
+      OpenUrl(url);
      show_update_notification_window_ = false;
    }

--- a/src/log/rd_log.cpp
+++ b/src/log/rd_log.cpp
@@ -62,4 +62,4 @@ std::shared_ptr<spdlog::logger> get_logger() {

  return g_logger;
 }
-}  // namespace crossdesk
+}  // namespace crossdesk
--- a/src/screen_capturer/windows/screen_capturer_win.cpp
+++ b/src/screen_capturer/windows/screen_capturer_win.cpp
@@ -1,17 +1,108 @@
 #include "screen_capturer_win.h"

+#include <Windows.h>
+
 #include <cmath>
+#include <filesystem>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>

 #include "rd_log.h"
 #include "screen_capturer_dxgi.h"
 #include "screen_capturer_gdi.h"
-#include "screen_capturer_wgc.h"
+#include "wgc_plugin_api.h"

 namespace crossdesk {

+namespace {
+
+class WgcPluginCapturer final : public ScreenCapturer {
+ public:
+  using CreateFn = ScreenCapturer* (*)();
+  using DestroyFn = void (*)(ScreenCapturer*);
+
+  static std::unique_ptr<ScreenCapturer> Create() {
+    std::filesystem::path plugin_path;
+    wchar_t module_path[MAX_PATH] = {0};
+    const DWORD len = GetModuleFileNameW(nullptr, module_path, MAX_PATH);
+    if (len == 0 || len >= MAX_PATH) {
+      return nullptr;
+    }
+    plugin_path =
+        std::filesystem::path(module_path).parent_path() / L"wgc_plugin.dll";
+
+    HMODULE module = LoadLibraryW(plugin_path.c_str());
+    if (!module) {
+      return nullptr;
+    }
+
+    auto create_fn = reinterpret_cast<CreateFn>(
+        GetProcAddress(module, "CrossDeskCreateWgcCapturer"));
+    auto destroy_fn = reinterpret_cast<DestroyFn>(
+        GetProcAddress(module, "CrossDeskDestroyWgcCapturer"));
+    if (!create_fn || !destroy_fn) {
+      FreeLibrary(module);
+      return nullptr;
+    }
+
+    ScreenCapturer* impl = create_fn();
+    if (!impl) {
+      FreeLibrary(module);
+      return nullptr;
+    }
+
+    return std::unique_ptr<ScreenCapturer>(
+        new WgcPluginCapturer(module, impl, destroy_fn));
+  }
+
+  ~WgcPluginCapturer() override {
+    if (impl_) {
+      destroy_fn_(impl_);
+      impl_ = nullptr;
+    }
+    if (module_) {
+      FreeLibrary(module_);
+      module_ = nullptr;
+    }
+  }
+
+  int Init(const int fps, cb_desktop_data cb) override {
+    return impl_ ? impl_->Init(fps, std::move(cb)) : -1;
+  }
+  int Destroy() override { return impl_ ? impl_->Destroy() : 0; }
+  int Start(bool show_cursor) override {
+    return impl_ ? impl_->Start(show_cursor) : -1;
+  }
+  int Stop() override { return impl_ ? impl_->Stop() : 0; }
+  int Pause(int monitor_index) override {
+    return impl_ ? impl_->Pause(monitor_index) : -1;
+  }
+  int Resume(int monitor_index) override {
+    return impl_ ? impl_->Resume(monitor_index) : -1;
+  }
+  std::vector<DisplayInfo> GetDisplayInfoList() override {
+    return impl_ ? impl_->GetDisplayInfoList() : std::vector<DisplayInfo>{};
+  }
+  int SwitchTo(int monitor_index) override {
+    return impl_ ? impl_->SwitchTo(monitor_index) : -1;
+  }
+  int ResetToInitialMonitor() override {
+    return impl_ ? impl_->ResetToInitialMonitor() : -1;
+  }
+
+ private:
+  WgcPluginCapturer(HMODULE module, ScreenCapturer* impl, DestroyFn destroy_fn)
+      : module_(module), impl_(impl), destroy_fn_(destroy_fn) {}
+
+  HMODULE module_ = nullptr;
+  ScreenCapturer* impl_ = nullptr;
+  DestroyFn destroy_fn_ = nullptr;
+};
+
+}  // namespace
+
 ScreenCapturerWin::ScreenCapturerWin() {}
 ScreenCapturerWin::~ScreenCapturerWin() { Destroy(); }

@@ -40,18 +131,21 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {

  int ret = -1;

-  impl_ = std::make_unique<ScreenCapturerWgc>();
-  ret = impl_->Init(fps_, cb_);
+  impl_ = WgcPluginCapturer::Create();
+  impl_is_wgc_plugin_ = (impl_ != nullptr);
+  ret = impl_ ? impl_->Init(fps_, cb_) : -1;
  if (ret == 0) {
-    LOG_INFO("Windows capturer: using WGC");
+    LOG_INFO("Windows capturer: using WGC plugin");
    BuildCanonicalFromImpl();
    return 0;
  }

-  LOG_WARN("Windows capturer: WGC init failed (ret={}), try DXGI", ret);
+  LOG_WARN("Windows capturer: WGC plugin init failed (ret={}), try DXGI", ret);
  impl_.reset();
+  impl_is_wgc_plugin_ = false;

  impl_ = std::make_unique<ScreenCapturerDxgi>();
+  impl_is_wgc_plugin_ = false;
  ret = impl_->Init(fps_, cb_);
  if (ret == 0) {
    LOG_INFO("Windows capturer: using DXGI Desktop Duplication");
@@ -63,6 +157,7 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
  impl_.reset();

  impl_ = std::make_unique<ScreenCapturerGdi>();
+  impl_is_wgc_plugin_ = false;
  ret = impl_->Init(fps_, cb_);
  if (ret == 0) {
    LOG_INFO("Windows capturer: using GDI BitBlt");
@@ -79,6 +174,7 @@ int ScreenCapturerWin::Destroy() {
  if (impl_) {
    impl_->Destroy();
    impl_.reset();
+    impl_is_wgc_plugin_ = false;
  }
  {
    std::lock_guard<std::mutex> lock(alias_mutex_);
@@ -102,13 +198,14 @@ int ScreenCapturerWin::Start(bool show_cursor) {
    int s = cand->Start(show_cursor);
    if (s == 0) {
      impl_ = std::move(cand);
+      impl_is_wgc_plugin_ = false;
      RebuildAliasesFromImpl();
      return true;
    }
    return false;
  };

-  if (dynamic_cast<ScreenCapturerWgc*>(impl_.get())) {
+  if (impl_is_wgc_plugin_) {
    if (try_init_start(std::make_unique<ScreenCapturerDxgi>())) {
      LOG_INFO("Windows capturer: fallback to DXGI");
      return 0;
--- a/src/screen_capturer/windows/screen_capturer_win.h
+++ b/src/screen_capturer/windows/screen_capturer_win.h
@@ -38,6 +38,7 @@ class ScreenCapturerWin : public ScreenCapturer {

 private:
  std::unique_ptr<ScreenCapturer> impl_;
+  bool impl_is_wgc_plugin_ = false;
  int fps_ = 60;
  cb_desktop_data cb_;
  cb_desktop_data cb_orig_;
--- a/src/screen_capturer/windows/wgc_plugin_api.h
+++ b/src/screen_capturer/windows/wgc_plugin_api.h
@@ -0,0 +1,29 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-03-20
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _WGC_PLUGIN_API_H_
+#define _WGC_PLUGIN_API_H_
+
+#include "screen_capturer.h"
+
+namespace crossdesk {
+class ScreenCapturer;
+}
+
+#if defined(_WIN32) && defined(CROSSDESK_WGC_PLUGIN_BUILD)
+#define CROSSDESK_WGC_PLUGIN_API __declspec(dllexport)
+#else
+#define CROSSDESK_WGC_PLUGIN_API
+#endif
+
+extern "C" {
+CROSSDESK_WGC_PLUGIN_API crossdesk::ScreenCapturer*
+CrossDeskCreateWgcCapturer();
+CROSSDESK_WGC_PLUGIN_API void CrossDeskDestroyWgcCapturer(
+    crossdesk::ScreenCapturer* capturer);
+}
+
+#endif
--- a/src/screen_capturer/windows/wgc_plugin_entry.cpp
+++ b/src/screen_capturer/windows/wgc_plugin_entry.cpp
@@ -0,0 +1,13 @@
+#include "screen_capturer_wgc.h"
+#include "wgc_plugin_api.h"
+
+extern "C" {
+
+crossdesk::ScreenCapturer* CrossDeskCreateWgcCapturer() {
+  return new crossdesk::ScreenCapturerWgc();
+}
+
+void CrossDeskDestroyWgcCapturer(crossdesk::ScreenCapturer* capturer) {
+  delete capturer;
+}
+}
--- a/src/screen_capturer/windows/wgc_session_impl.cpp
+++ b/src/screen_capturer/windows/wgc_session_impl.cpp
@@ -4,15 +4,14 @@

 #include <atomic>
 #include <functional>
-#include <iostream>
 #include <memory>

 #include "rd_log.h"

-#define CHECK_INIT                            \
-  if (!is_initialized_) {                     \
-    std::cout << "AE_NEED_INIT" << std::endl; \
-    return 4;                                 \
+#define CHECK_INIT             \
+  if (!is_initialized_) {      \
+    LOG_ERROR("AE_NEED_INIT"); \
+    return 4;                  \
  }

 #define CHECK_CLOSED                         \
@@ -324,7 +323,7 @@ int WgcSessionImpl::Initialize() {
  if (is_initialized_) return 0;

  if (!(d3d11_direct_device_ = CreateD3D11Device())) {
-    std::cout << "AE_D3D_CREATE_DEVICE_FAILED" << std::endl;
+    LOG_ERROR("AE_D3D_CREATE_DEVICE_FAILED");
    return 1;
  }

--- a/src/tools/clipboard.cpp
+++ b/src/tools/clipboard.cpp
@@ -452,11 +452,17 @@ static void MonitorThreadFunc() {
  LOG_INFO("Clipboard event monitoring started (Linux XFixes)");

  XEvent event;
+  constexpr int kEventPollIntervalMs = 20;
  while (g_monitoring.load()) {
-    XNextEvent(g_x11_display, &event);
-    if (event.type == event_base + XFixesSelectionNotify) {
-      HandleClipboardChange();
+    // Avoid blocking on XNextEvent so StopMonitoring() can stop quickly.
+    while (g_monitoring.load() && XPending(g_x11_display) > 0) {
+      XNextEvent(g_x11_display, &event);
+      if (event.type == event_base + XFixesSelectionNotify) {
+        HandleClipboardChange();
+      }
    }
+    std::this_thread::sleep_for(
+        std::chrono::milliseconds(kEventPollIntervalMs));
  }

  XFixesSelectSelectionInput(g_x11_display, event_window, g_clipboard_atom, 0);
--- a/submodules/minirtc
+++ b/submodules/minirtc
--- a/xmake.lua
+++ b/xmake.lua
@@ -28,6 +28,7 @@ if is_mode("debug") then
    add_defines("CROSSDESK_DEBUG")
 end

+add_requireconfs("*.python", {version = "3.12", override = true, configs = {pgo = false}})
 add_requires("spdlog 1.14.1", {system = false})
 add_requires("imgui v1.92.1-docking", {configs = {sdl3 = true, sdl3_renderer = true}})
 add_requires("openssl3 3.3.2", {system = false})
@@ -37,7 +38,7 @@ add_requires("tinyfiledialogs 3.15.1")

 if is_os("windows") then
    add_requires("libyuv", "miniaudio 0.11.21")
-    add_links("Shell32", "windowsapp", "dwmapi", "User32", "kernel32",
+    add_links("Shell32", "dwmapi", "User32", "kernel32",
        "SDL3-static", "gdi32", "winmm", "setupapi", "version",
        "Imm32", "iphlpapi", "d3d11", "dxgi")
    add_cxflags("/WX")
@@ -88,7 +89,9 @@ target("screen_capturer")
    add_includedirs("src/screen_capturer", {public = true})
    if is_os("windows") then
        add_packages("libyuv")
-        add_files("src/screen_capturer/windows/*.cpp")
+        add_files("src/screen_capturer/windows/screen_capturer_dxgi.cpp",
+            "src/screen_capturer/windows/screen_capturer_gdi.cpp",
+            "src/screen_capturer/windows/screen_capturer_win.cpp")
        add_includedirs("src/screen_capturer/windows", {public = true})
    elseif is_os("macosx") then
        add_files("src/screen_capturer/macosx/*.cpp",
@@ -199,11 +202,26 @@ target("gui")
        add_files("src/gui/windows/*.mm")
    end

+if is_os("windows") then
+target("wgc_plugin")
+    set_kind("shared")
+    add_packages("libyuv")
+    add_deps("rd_log")
+    add_defines("CROSSDESK_WGC_PLUGIN_BUILD=1")
+    add_links("windowsapp")
+    add_files("src/screen_capturer/windows/screen_capturer_wgc.cpp",
+        "src/screen_capturer/windows/wgc_session_impl.cpp",
+        "src/screen_capturer/windows/wgc_plugin_entry.cpp")
+    add_includedirs("src/common", "src/screen_capturer",
+        "src/screen_capturer/windows")
+end
+
 target("crossdesk")
    set_kind("binary")
    add_deps("rd_log", "common", "gui")
    add_files("src/app/*.cpp")
    add_includedirs("src/app", {public = true})
    if is_os("windows") then
+        add_deps("wgc_plugin")
        add_files("scripts/windows/crossdesk.rc")
-    end
+    end
Author	SHA1	Message	Date
dijunkun	f7f62c5fe0	[fix] update MiniRTC: refactor IceAgent to improve stability	2026-03-20 15:58:59 +08:00
dijunkun	2bbddbca6b	[fix] fix Linux audio fallback when audio devices are unavaliable	2026-03-20 15:14:45 +08:00
dijunkun	f0f8f27f4c	[fix] fix blocking join() in Linux clipboard monitor thread during shutdown	2026-03-20 15:02:34 +08:00
dijunkun	262af263f2	[fix] move keyboard capturer to a background thread and use poll-based X11 event handling to avoid main-thread blocking	2026-03-20 14:56:40 +08:00
dijunkun	38b7775b1b	[fix] fix restart/shutdown races in process monitor	2026-03-20 14:50:42 +08:00
dijunkun	56c0bca62f	[chore] adjust hyperlink spacing and alignment	2026-03-20 14:47:33 +08:00
dijunkun	4b1b09fd5b	[fix] fix Linux fonts: use opentype instead of truetype	2026-03-20 13:01:13 +08:00
dijunkun	1d6425bbf4	[fix] update MiniRTC: fix compiler warnings by adding missing override specifiers	2026-03-20 04:36:58 +08:00
dijunkun	5ec6552d25	[fix] fix macOS intel CI build failure caused by python 3.13 PGO mismatch	2026-03-20 03:50:19 +08:00
dijunkun	79e4a0790a	[fix] fix issue where wgc_plugin was not compiled	2026-03-20 02:59:31 +08:00
dijunkun	1d3cac54ab	[feat] load wgc from wgc_plugin.dll at runtime and drop direct'windowsapp' linking, refs #74	2026-03-20 01:36:36 +08:00
dijunkun	2f26334775	[feat] unify UI font loading across platforms and prefer PingFang on macOS	2026-03-19 21:58:14 +08:00
dijunkun	9270d528e3	[feat] update miniRTC: fix compiler warnings caused by missing override specifiers	2026-03-19 21:57:52 +08:00
dijunkun	91db3a7e34	[feat] add Russian language support	2026-03-19 20:04:30 +08:00
dijunkun	d017561e54	[fix] fix typo ImGuiChildFlags_Border to ImGuiChildFlags_Borders	2026-03-19 16:16:51 +08:00
dijunkun	8e8a85bae3	[feat] upgrade actions/checkout and actions/cache to v5 for Node 24 compatibility	2026-03-19 15:03:58 +08:00
dijunkun	bea89e9111	[feat] crossdesk server image supports Linux ARM64, refs #72	2026-03-19 10:06:57 +08:00
dijunkun	499ce0190a	[fix] process mouse events only from the stream window	2026-03-11 16:00:29 +08:00
dijunkun	91bde91238	[feat] probe presence before connect and show warning if offline	2026-03-10 17:46:44 +08:00
dijunkun	3e31ba102d	[fix] prevent sending connection requests to offline devices	2026-03-10 10:53:58 +08:00
dijunkun	263c5eefd3	[fix] fix update button lag in release mode by using non-blocking URL opener.	2026-03-10 10:39:05 +08:00
dijunkun	b230b851e4	[fix] fix cannot close connection from Server Window when the peer is a web client	2026-03-10 00:39:00 +08:00
dijunkun	ff32477ffe	[fix] update MiniRTC: fix crash on disconnect	2026-03-10 00:35:33 +08:00
dijunkun	c6c60decdb	[fix] fix incorrect online status of recently connections	2026-03-09 22:52:05 +08:00
dijunkun	7505adeca8	[feat] update MiniRTC	2026-03-09 22:50:42 +08:00
dijunkun	754f1fba88	[feat] show 'Receiving screen' text before the remote frame arrives	2026-03-09 22:37:50 +08:00
dijunkun	8be46b870a	[feat] add cancel button during connecting	2026-03-09 21:35:21 +08:00
dijunkun	81cb1d6c0b	[fix] disable clipboard sharing when not in control mode	2026-03-05 17:46:27 +08:00
dijunkun	319416f1b7	[feat] update MiniRTC: optimize video quality and smoothness	2026-03-05 17:30:05 +08:00
dijunkun	d679c6251b	[feat] update MiniRTC	2026-03-04 10:46:21 +08:00
dijunkun	a14baafda7	[fix] fix keyboard event loss due to start_keyboard_capturer_ flag improper setting, fixes #65	2026-03-04 10:36:39 +08:00
dijunkun	cfdc7d3106	[fix] update MiniRTC: fix bandwidth degradation caused by ALR-triggered resolution downgrade during static frames	2026-03-03 10:58:38 +08:00