ci: add Linux build image workflow

.dockerignore

@@ -0,0 +1,20 @@
+**
+
+!.dockerignore
+!docker/
+!docker/linux-build/
+!docker/linux-build/**
+
+# Dependency manifests and local xmake package recipes are the only project
+# files needed while pre-warming the build image.
+!xmake.lua
+!xmake/
+!xmake/**
+!thirdparty/
+!thirdparty/**
+!submodules/
+!submodules/xmake.lua
+!submodules/minirtc/
+!submodules/minirtc/xmake.lua
+!submodules/minirtc/thirdparty/
+!submodules/minirtc/thirdparty/**

.github/workflows/build-linux-image.yml

@@ -0,0 +1,155 @@
+name: Build Linux Build Image
+
+on:
+  push:
+    branches:
+      - ci/linux-build-image
+    paths:
+      - .dockerignore
+      - .gitmodules
+      - .github/workflows/build-linux-image.yml
+      - docker/linux-build/**
+      - xmake.lua
+      - xmake/**
+      - thirdparty/**
+      - submodules/xmake.lua
+      - submodules/minirtc
+      - submodules/minirtc/xmake.lua
+      - submodules/minirtc/thirdparty/**
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: linux-build-image-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  IMAGE_NAME: crossdesk/ubuntu22.04
+  STACK_TAG: buildenv-cuda12.6.3-xmake3.0.9-rust1.92.0
+  XMAKE_VERSION: 3.0.9
+  RUST_VERSION: 1.92.0
+  RUSTUP_VERSION: 1.28.2
+
+jobs:
+  build:
+    name: Build candidate (${{ matrix.arch }})
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 180
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: amd64
+            platform: linux/amd64
+            runner: ubuntu-24.04
+            base_image: nvidia/cuda:12.6.3-devel-ubuntu22.04
+          - arch: arm64
+            platform: linux/arm64
+            runner: ubuntu-24.04-arm
+            base_image: ubuntu:22.04
+    steps:
+      - name: Set candidate tag
+        id: image
+        run: |
+          CANDIDATE_TAG="${IMAGE_NAME}:${STACK_TAG}-${GITHUB_SHA}-${{ matrix.arch }}"
+          echo "CANDIDATE_TAG=${CANDIDATE_TAG}" >> "${GITHUB_ENV}"
+          echo "candidate=${CANDIDATE_TAG}" >> "${GITHUB_OUTPUT}"
+
+      - name: Checkout source
+        uses: actions/checkout@v5
+        with:
+          submodules: recursive
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push candidate
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: docker/linux-build/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: true
+          pull: true
+          tags: ${{ steps.image.outputs.candidate }}
+          cache-from: type=registry,ref=${{ env.IMAGE_NAME }}:${{ env.STACK_TAG }}
+          cache-to: type=inline
+          provenance: false
+          sbom: false
+          build-args: |
+            BASE_IMAGE=${{ matrix.base_image }}
+            XMAKE_VERSION=${{ env.XMAKE_VERSION }}
+            RUST_VERSION=${{ env.RUST_VERSION }}
+            RUSTUP_VERSION=${{ env.RUSTUP_VERSION }}
+
+  verify:
+    name: Verify candidate (${{ matrix.arch }})
+    needs: build
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: amd64
+            runner: ubuntu-24.04
+          - arch: arm64
+            runner: ubuntu-24.04-arm
+    steps:
+      - name: Set candidate tag
+        run: |
+          CANDIDATE_TAG="${IMAGE_NAME}:${STACK_TAG}-${GITHUB_SHA}-${{ matrix.arch }}"
+          echo "CANDIDATE_TAG=${CANDIDATE_TAG}" >> "${GITHUB_ENV}"
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Verify tools, architecture, and Ubuntu baseline
+        run: |
+          docker pull "${CANDIDATE_TAG}"
+          docker run --rm \
+            --env EXPECTED_ARCH="${{ matrix.arch }}" \
+            "${CANDIDATE_TAG}" \
+            verify-crossdesk-build-image
+
+  publish:
+    name: Publish multi-arch image
+    needs: verify
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Promote verified candidates
+        run: |
+          AMD64_IMAGE="${IMAGE_NAME}:${STACK_TAG}-${GITHUB_SHA}-amd64"
+          ARM64_IMAGE="${IMAGE_NAME}:${STACK_TAG}-${GITHUB_SHA}-arm64"
+
+          docker buildx imagetools create \
+            --tag "${IMAGE_NAME}:${STACK_TAG}" \
+            --tag "${IMAGE_NAME}:sha-${GITHUB_SHA}" \
+            --tag "${IMAGE_NAME}:latest" \
+            "${AMD64_IMAGE}" \
+            "${ARM64_IMAGE}"
+
+      - name: Inspect published manifest
+        run: |
+          docker buildx imagetools inspect "${IMAGE_NAME}:${STACK_TAG}"

.github/workflows/build.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - "**"
+      - "!ci/linux-build-image"
     tags:
       - "*"
   workflow_dispatch:
@@ -27,13 +28,13 @@ jobs:
       matrix:
         include:
           - arch: amd64
-            runner: ubuntu-22.04
-            image: crossdesk/ubuntu20.04:latest
+            runner: ubuntu-24.04
+            image: crossdesk/ubuntu22.04:buildenv-cuda12.6.3-xmake3.0.9-rust1.92.0
             package_script: ./scripts/linux/pkg_amd64.sh
 
           - arch: arm64
-            runner: ubuntu-22.04-arm
-            image: crossdesk/ubuntu20.04-arm64v8:latest
+            runner: ubuntu-24.04-arm
+            image: crossdesk/ubuntu22.04:buildenv-cuda12.6.3-xmake3.0.9-rust1.92.0
             package_script: ./scripts/linux/pkg_arm64.sh
 
     container:
@@ -99,12 +100,14 @@ jobs:
         with:
           submodules: recursive
 
+      - name: Verify Linux build image
+        run: verify-crossdesk-build-image
+
       - name: Build CrossDesk
         env:
           CUDA_PATH: /usr/local/cuda
           XMAKE_GLOBALDIR: /data
         run: |
-          apt install -y libxft-dev
           xmake f --CROSSDESK_VERSION=${LEGAL_VERSION} --USE_CUDA=true --root -y
           xmake b -vy --root crossdesk
 
@@ -113,6 +116,14 @@ jobs:
           chmod +x ${{ matrix.package_script }}
           ${{ matrix.package_script }} ${LEGAL_VERSION}
 
+      - name: Verify packaged Ubuntu 22.04 glibc baseline
+        run: |
+          PACKAGE_FILE="${GITHUB_WORKSPACE}/crossdesk-linux-${{ matrix.arch }}-${LEGAL_VERSION}.deb"
+          VERIFY_DIR="${RUNNER_TEMP}/crossdesk-glibc-${{ matrix.arch }}"
+          install -d "${VERIFY_DIR}"
+          dpkg-deb --extract "${PACKAGE_FILE}" "${VERIFY_DIR}"
+          verify-crossdesk-glibc-baseline "${VERIFY_DIR}" 2.35
+
       - name: Upload artifact
         uses: actions/upload-artifact@v6
         with:
@@ -189,6 +200,9 @@ jobs:
       - name: Install xmake
         run: brew install xmake
 
+      - name: Update xmake repositories
+        run: xmake repo -u
+
       - name: Checkout code
         uses: actions/checkout@v5
 
@@ -275,6 +289,7 @@ jobs:
         run: |
           Invoke-Expression (Invoke-Webrequest 'https://raw.githubusercontent.com/tboox/xmake/master/scripts/get.ps1' -UseBasicParsing).Content
           echo "C:\Users\runneradmin\xmake" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          xmake repo -u
           xmake create cuda
           Set-Location cuda
           xmake g --theme=plain

LICENSE

@@ -1,165 +1,674 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
+                            Preamble
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
-  0. Additional Definitions.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
 
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
 
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
 
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
 
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
 
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
 
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
 
-  1. Exception to Section 3 of the GNU GPL.
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
 
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
+  The precise terms and conditions for copying, distribution and
+modification follow.
 
-  2. Conveying Modified Versions.
+                       TERMS AND CONDITIONS
 
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
+  0. Definitions.
 
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
+  "This License" refers to version 3 of the GNU General Public License.
 
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
 
-  3. Object Code Incorporating Material from Library Header Files.
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
 
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
 
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
 
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
 
-  4. Combined Works.
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
 
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
 
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
+  1. Source Code.
 
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
 
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
 
-   d) Do one of the following:
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
 
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
 
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
 
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
+  The Corresponding Source for a work in source code form is that
+same work.
 
-  5. Combined Libraries.
+  2. Basic Permissions.
 
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
 
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
 
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
 
-  6. Revised Versions of the GNU Lesser General Public License.
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
 
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
 
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
 
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -2,7 +2,7 @@
 
 <a href="https://hellogithub.com/repository/kunkundi/crossdesk" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=55d41367570345f1838e02fd12be7961&claim_uid=cb0OpZRrBuGVAfL&theme=small" alt="Featured｜HelloGitHub" /></a>
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-brightgreen.svg)]()
-[![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![GitHub last commit](https://img.shields.io/github/last-commit/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/commits/web-client)
 [![Build Status](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions)  
 [![Docker Pulls](https://img.shields.io/docker/pulls/crossdesk/crossdesk-server)](https://hub.docker.com/r/crossdesk/crossdesk-server/tags)
@@ -82,34 +82,77 @@ Windows 安装包会自动打包 `crossdesk_service.exe` 和 `crossdesk_session_
 - [xmake](https://xmake.io/#/guide/installation)
 - [cmake](https://cmake.org/download/)
 
-Linux环境下需安装以下包：
+### Linux
 
-```
-sudo apt-get install -y software-properties-common git curl unzip build-essential libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxfixes-dev libxv-dev libxtst-dev libasound2-dev libsndio-dev libxcb-shm0-dev libasound2-dev libpulse-dev
+Linux 构建目前支持 Ubuntu 22.04 及以上版本的 amd64 和 arm64。先安装基础编译依赖：
+
+```bash
+sudo apt-get update
+sudo apt-get install -y \
+  git curl unzip build-essential cmake pkg-config binutils dpkg-dev \
+  libx11-dev libxext-dev libxrender-dev libxft-dev libxrandr-dev \
+  libxinerama-dev libxcursor-dev libxi-dev libxfixes-dev libxv-dev \
+  libxtst-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev \
+  libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev \
+  libasound2-dev libsndio-dev libpulse-dev
 ```
 
-编译
-```
-git clone https://github.com/kunkundi/crossdesk.git
+需要启用 Wayland 捕获或 DRM 捕获时，再安装对应依赖：
 
+```bash
+sudo apt-get install -y libdbus-1-dev libpipewire-0.3-dev libdrm-dev
+```
+
+下载子模块并编译 Release 版本：
+
+```bash
+git clone --recurse-submodules https://github.com/kunkundi/crossdesk.git
 cd crossdesk
 
-git submodule init 
-
-git submodule update
+# 已经克隆过仓库时执行这一行
+git submodule update --init --recursive
 
+xmake f -m release --USE_CUDA=false -y
 xmake b -vy crossdesk
 ```
-编译选项
+
+amd64 构建结果位于 `build/linux/x86_64/release/crossdesk`，arm64 构建结果位于 `build/linux/arm64/release/crossdesk`。
+
+启用 Wayland 和 DRM 的配置示例：
+
+```bash
+xmake f -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false -y
+xmake b -vy crossdesk
 ```
+
+生成 Debian 安装包（必须在对应架构上先完成 Release 编译）：
+
+```bash
+# amd64
+./scripts/linux/pkg_amd64.sh 1.0.0
+
+# arm64
+./scripts/linux/pkg_arm64.sh 1.0.0
+```
+
+打包脚本会将 Slint 共享运行库安装到软件包私有目录 `/usr/lib/crossdesk`，无需用户另外安装 `libslint_cpp.so`。
+
+### 通用编译选项
+
+```text
 --USE_CUDA=true/false: 启用 CUDA 硬件编解码，默认不启用
+--USE_WAYLAND=true/false: 在 Linux 上启用 Wayland/PipeWire 捕获，默认不启用
+--USE_DRM=true/false: 在 Linux 上启用 DRM 捕获，默认不启用
+--CROSSDESK_PORTABLE=true/false: 构建便携版本，默认不启用
 --CROSSDESK_VERSION=xxx: 指定 CrossDesk 的版本
 
 # 示例
 xmake f --CROSSDESK_VERSION=1.0.0 --USE_CUDA=true
 ```
-运行
-```
+
+运行：
+
+```bash
 xmake r crossdesk
 ```
 

README_EN.md

@@ -2,7 +2,7 @@
 
 <a href="https://hellogithub.com/repository/kunkundi/crossdesk" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=55d41367570345f1838e02fd12be7961&claim_uid=cb0OpZRrBuGVAfL&theme=small" alt="Featured｜HelloGitHub" /></a>
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-brightgreen.svg)]()
-[![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![GitHub last commit](https://img.shields.io/github/last-commit/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/commits/web-client)
 [![Build Status](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions)  
 [![Docker Pulls](https://img.shields.io/docker/pulls/crossdesk/crossdesk-server)](https://hub.docker.com/r/crossdesk/crossdesk-server/tags)
@@ -87,34 +87,77 @@ Requirements:
 - [xmake](https://xmake.io/#/guide/installation)
 - [cmake](https://cmake.org/download/)
 
-Following packages need to be installed on Linux:
+### Linux
 
-```
-sudo apt-get install -y software-properties-common git curl unzip build-essential libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxfixes-dev libxv-dev libxtst-dev libasound2-dev libsndio-dev libxcb-shm0-dev libasound2-dev libpulse-dev
+Linux builds currently support Ubuntu 22.04 or later on amd64 and arm64. Install the base build dependencies first:
+
+```bash
+sudo apt-get update
+sudo apt-get install -y \
+  git curl unzip build-essential cmake pkg-config binutils dpkg-dev \
+  libx11-dev libxext-dev libxrender-dev libxft-dev libxrandr-dev \
+  libxinerama-dev libxcursor-dev libxi-dev libxfixes-dev libxv-dev \
+  libxtst-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev \
+  libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev \
+  libasound2-dev libsndio-dev libpulse-dev
 ```
 
-Build:
-```
-git clone https://github.com/kunkundi/crossdesk.git
+Install the optional dependencies when Wayland capture or DRM capture is enabled:
 
+```bash
+sudo apt-get install -y libdbus-1-dev libpipewire-0.3-dev libdrm-dev
+```
+
+Clone the submodules and build a release binary:
+
+```bash
+git clone --recurse-submodules https://github.com/kunkundi/crossdesk.git
 cd crossdesk
 
-git submodule init 
-
-git submodule update
+# Run this when the repository has already been cloned
+git submodule update --init --recursive
 
+xmake f -m release --USE_CUDA=false -y
 xmake b -vy crossdesk
 ```
-Build options:
-```
---USE_CUDA=true/false: enable CUDA acceleration codec, default: false
---CROSSDESK_VERSION=xxx: set the version number
 
-# example:
+The amd64 binary is written to `build/linux/x86_64/release/crossdesk`; the arm64 binary is written to `build/linux/arm64/release/crossdesk`.
+
+Example configuration with Wayland and DRM capture enabled:
+
+```bash
+xmake f -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false -y
+xmake b -vy crossdesk
+```
+
+Build a Debian package after compiling a release binary on the matching architecture:
+
+```bash
+# amd64
+./scripts/linux/pkg_amd64.sh 1.0.0
+
+# arm64
+./scripts/linux/pkg_arm64.sh 1.0.0
+```
+
+The package scripts install the shared Slint runtime in the private `/usr/lib/crossdesk` directory, so users do not need to install `libslint_cpp.so` separately.
+
+### Common build options
+
+```text
+--USE_CUDA=true/false: Enable CUDA hardware codec acceleration, disabled by default
+--USE_WAYLAND=true/false: Enable Wayland/PipeWire capture on Linux, disabled by default
+--USE_DRM=true/false: Enable DRM capture on Linux, disabled by default
+--CROSSDESK_PORTABLE=true/false: Build the portable variant, disabled by default
+--CROSSDESK_VERSION=xxx: Set the CrossDesk version
+
+# Example
 xmake f --CROSSDESK_VERSION=1.0.0 --USE_CUDA=true
 ```
+
 Run:
-```
+
+```bash
 xmake r crossdesk
 ```
 

docker/linux-build/Dockerfile

@@ -0,0 +1,153 @@
+# syntax=docker/dockerfile:1.7
+
+ARG BASE_IMAGE=nvidia/cuda:12.6.3-devel-ubuntu22.04
+FROM ${BASE_IMAGE}
+
+ARG TARGETARCH
+ARG XMAKE_VERSION=3.0.9
+ARG RUST_VERSION=1.92.0
+ARG RUSTUP_VERSION=1.28.2
+
+LABEL org.opencontainers.image.title="CrossDesk Linux build environment" \
+      org.opencontainers.image.description="Ubuntu 22.04 build environment for CrossDesk" \
+      org.opencontainers.image.source="https://github.com/kunkundi/crossdesk" \
+      org.opencontainers.image.licenses="GPL-3.0-only"
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    TZ=Etc/UTC \
+    LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    RUSTUP_HOME=/opt/rustup \
+    CARGO_HOME=/opt/cargo \
+    XMAKE_GLOBALDIR=/data \
+    XMAKE_ROOT=y \
+    CUDA_PATH=/usr/local/cuda \
+    PATH=/root/.local/bin:/opt/cargo/bin:/usr/local/bin:${PATH}
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        autoconf \
+        automake \
+        binutils \
+        bison \
+        build-essential \
+        ca-certificates \
+        ccache \
+        cmake \
+        curl \
+        dbus \
+        dpkg-dev \
+        file \
+        flex \
+        gettext \
+        git \
+        libasound2-dev \
+        libdbus-1-dev \
+        libdrm-dev \
+        libegl1-mesa-dev \
+        libffi-dev \
+        libfontconfig1-dev \
+        libfreetype6-dev \
+        libgl1-mesa-dev \
+        libmount-dev \
+        libpulse-dev \
+        libreadline-dev \
+        libsndio-dev \
+        libssl-dev \
+        libtool \
+        libx11-dev \
+        libxcb-xfixes0-dev \
+        libxcb-randr0-dev \
+        libxcb-shape0-dev \
+        libxcb-shm0-dev \
+        libxcb-xinerama0-dev \
+        libxcb-xkb-dev \
+        libxcb-xtest0-dev \
+        libxcursor-dev \
+        libxext-dev \
+        libxfixes-dev \
+        libxft-dev \
+        libxi-dev \
+        libxinerama-dev \
+        libxkbcommon-dev \
+        libxrandr-dev \
+        libxrender-dev \
+        libxtst-dev \
+        libxv-dev \
+        make \
+        nasm \
+        ninja-build \
+        patch \
+        patchelf \
+        perl \
+        pkg-config \
+        python3 \
+        python3-pip \
+        unzip \
+        xutils-dev \
+        xz-utils \
+        yasm \
+        zip \
+        zlib1g-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN export GITHUB_ACTIONS=true \
+    && curl -fsSL https://xmake.io/shget.text \
+        | bash -s -- "v${XMAKE_VERSION}" \
+    && source ~/.xmake/profile \
+    && xmake --version | grep -F "v${XMAKE_VERSION}"
+
+RUN case "${TARGETARCH}" in \
+        amd64) \
+            rustup_arch="x86_64-unknown-linux-gnu"; \
+            rustup_sha256="20a06e644b0d9bd2fbdbfd52d42540bdde820ea7df86e92e533c073da0cdd43c" \
+            ;; \
+        arm64) \
+            rustup_arch="aarch64-unknown-linux-gnu"; \
+            rustup_sha256="e3853c5a252fca15252d07cb23a1bdd9377a8c6f3efa01531109281ae47f841c" \
+            ;; \
+        *) echo "Unsupported architecture: ${TARGETARCH}" >&2; exit 1 ;; \
+    esac \
+    && curl --proto '=https' --tlsv1.2 --fail --show-error --location \
+        "https://static.rust-lang.org/rustup/archive/${RUSTUP_VERSION}/${rustup_arch}/rustup-init" \
+        -o /tmp/rustup-init \
+    && echo "${rustup_sha256}  /tmp/rustup-init" | sha256sum --check - \
+    && chmod 0755 /tmp/rustup-init \
+    && /tmp/rustup-init -y --no-modify-path --profile minimal \
+        --default-toolchain "${RUST_VERSION}" \
+    && rm -f /tmp/rustup-init \
+    && rustc --version \
+    && cargo --version
+
+WORKDIR /tmp/crossdesk-dependencies
+
+COPY xmake.lua ./xmake.lua
+COPY xmake ./xmake
+COPY thirdparty ./thirdparty
+COPY submodules/xmake.lua ./submodules/xmake.lua
+COPY submodules/minirtc/xmake.lua ./submodules/minirtc/xmake.lua
+COPY submodules/minirtc/thirdparty ./submodules/minirtc/thirdparty
+
+# Configure the real project manifests so the image cache stays aligned with
+# CrossDesk's exact dependency graph. Source files are intentionally excluded
+# from the Docker context; source-only changes therefore reuse this layer.
+RUN xmake repo -u --root \
+    && xmake f -m release --USE_CUDA=true --root -y \
+    && rm -rf /data/.xmake/cache /tmp/crossdesk-dependencies \
+    && mkdir -p /workspace
+
+WORKDIR /workspace
+
+COPY docker/linux-build/verify-build-image.sh \
+    /usr/local/bin/verify-crossdesk-build-image
+COPY docker/linux-build/verify-glibc-baseline.sh \
+    /usr/local/bin/verify-crossdesk-glibc-baseline
+
+RUN chmod 0755 \
+        /usr/local/bin/verify-crossdesk-build-image \
+        /usr/local/bin/verify-crossdesk-glibc-baseline \
+    && verify-crossdesk-build-image
+
+CMD ["bash"]

docker/linux-build/README.md

@@ -0,0 +1,41 @@
+# CrossDesk Linux 构建镜像
+
+这个目录维护 CrossDesk 专用的 Ubuntu 22.04 构建环境。镜像包含 xmake、
+Rust、Linux 开发库以及根据项目 `xmake.lua` 提前编译好的依赖。
+
+## 发布方式
+
+推送影响镜像的文件到 `ci/linux-build-image` 分支时，
+`build-linux-image.yml` 会在 GitHub 原生 amd64/arm64 runner 上分别构建和验证，
+全部通过后再合并为同一个 multi-arch 镜像：
+
+```text
+crossdesk/ubuntu22.04:buildenv-cuda12.6.3-xmake3.0.9-rust1.92.0
+```
+
+Docker 会根据运行机器自动选择正确架构。amd64 变体以
+`nvidia/cuda:12.6.3-devel-ubuntu22.04` 为基础；arm64 变体不包含当前构建
+用不到的 CUDA SDK。两个变体都使用 Ubuntu 22.04/glibc 2.35。
+因此该镜像生成的 Linux 安装包最低支持 Ubuntu 22.04，不再保证兼容
+Ubuntu 20.04。
+
+每次成功发布还会生成 `sha-<完整提交 SHA>`，用于精确回滚；`latest` 和上面的
+工具链版本 tag 只会在两个架构都验证成功后更新。
+
+## GitHub 配置
+
+在仓库的 Actions secrets 中配置：
+
+- `DOCKERHUB_USERNAME`：有权推送 `crossdesk/ubuntu22.04` 的 Docker Hub 用户名
+- `DOCKERHUB_TOKEN`：该用户的 Docker Hub access token
+
+工作流文件进入默认分支后，也可以从 Actions 页面手动运行。为了避免首次发布
+新 tag 时应用构建先于镜像完成，常规 `build.yml` 不响应
+`ci/linux-build-image` 分支的 push。第一次启用时，应先推送该分支并等待镜像
+发布成功，再把应用构建工作流的修改合并到 `main`。
+
+## 更新依赖
+
+修改 Dockerfile、xmake 清单、本地包配方或子模块中的包配方后，推送该分支即可。
+升级工具链时应同时修改 Dockerfile 的版本参数、工作流中的 `STACK_TAG`，以及
+常规构建工作流引用的镜像 tag。

docker/linux-build/verify-build-image.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXPECTED_ARCH="${EXPECTED_ARCH:-}"
+EXPECTED_XMAKE_VERSION="${EXPECTED_XMAKE_VERSION:-3.0.9}"
+EXPECTED_RUST_VERSION="${EXPECTED_RUST_VERSION:-1.92.0}"
+
+# shellcheck disable=SC1091
+source /etc/os-release
+if [[ "${ID}" != "ubuntu" || "${VERSION_ID}" != "22.04" ]]; then
+    echo "Expected Ubuntu 22.04, found ${ID:-unknown} ${VERSION_ID:-unknown}" >&2
+    exit 1
+fi
+
+GLIBC_VERSION="$(getconf GNU_LIBC_VERSION | awk '{print $2}')"
+if [[ "${GLIBC_VERSION}" != "2.35" ]]; then
+    echo "Expected glibc 2.35, found ${GLIBC_VERSION}" >&2
+    exit 1
+fi
+
+ACTUAL_ARCH="$(dpkg --print-architecture)"
+if [[ -n "${EXPECTED_ARCH}" && "${ACTUAL_ARCH}" != "${EXPECTED_ARCH}" ]]; then
+    echo "Expected architecture ${EXPECTED_ARCH}, found ${ACTUAL_ARCH}" >&2
+    exit 1
+fi
+
+XMAKE_VERSION_OUTPUT="$(xmake --version 2>&1)"
+grep -F "v${EXPECTED_XMAKE_VERSION}" <<<"${XMAKE_VERSION_OUTPUT}" >/dev/null
+rustc --version | grep -F "rustc ${EXPECTED_RUST_VERSION}" >/dev/null
+cargo --version >/dev/null
+cmake --version >/dev/null
+g++ --version >/dev/null
+pkg-config --exists xft
+
+for package_path in \
+    "s/slint" \
+    "l/libdatachannel" \
+    "o/openssl3" \
+    "s/spdlog"; do
+    if [[ ! -d "${XMAKE_GLOBALDIR}/.xmake/packages/${package_path}" ]]; then
+        echo "Prebuilt xmake package is missing: ${package_path}" >&2
+        exit 1
+    fi
+done
+
+if ! find "${XMAKE_GLOBALDIR}/.xmake/packages/s/slint" \
+    -type f -name 'slint-compiler*' -print -quit | grep -q .; then
+    echo "The prebuilt Slint compiler is missing" >&2
+    exit 1
+fi
+
+if [[ "${ACTUAL_ARCH}" == "amd64" && ! -f "${CUDA_PATH}/include/cuda.h" ]]; then
+    echo "The amd64 image is missing CUDA headers under ${CUDA_PATH}" >&2
+    exit 1
+fi
+
+echo "Verified CrossDesk build image: Ubuntu ${VERSION_ID}, ${ACTUAL_ARCH}, glibc ${GLIBC_VERSION}"

docker/linux-build/verify-glibc-baseline.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -lt 1 || $# -gt 2 ]]; then
+    echo "Usage: $0 <ELF-file-or-directory> [maximum-glibc-version]" >&2
+    exit 2
+fi
+
+INPUT_PATH="$1"
+MAXIMUM_VERSION="${2:-2.35}"
+
+verify_elf() {
+    local elf_file="$1"
+    local version=""
+    local highest_version="none"
+    local -a required_versions=()
+
+    mapfile -t required_versions < <(
+        readelf --version-info "${elf_file}" \
+            | grep -oE 'GLIBC_[0-9]+(\.[0-9]+)+' \
+            | sed 's/^GLIBC_//' \
+            | sort -Vu \
+            || true
+    )
+
+    for version in "${required_versions[@]}"; do
+        if dpkg --compare-versions "${version}" gt "${MAXIMUM_VERSION}"; then
+            echo "${elf_file} requires GLIBC_${version}; maximum allowed is GLIBC_${MAXIMUM_VERSION}" >&2
+            return 1
+        fi
+    done
+
+    if [[ ${#required_versions[@]} -gt 0 ]]; then
+        highest_version="${required_versions[-1]}"
+    fi
+    echo "Verified ${elf_file}: highest required glibc version is ${highest_version}"
+}
+
+if [[ -f "${INPUT_PATH}" ]]; then
+    if ! readelf -h "${INPUT_PATH}" >/dev/null 2>&1; then
+        echo "Not an ELF file: ${INPUT_PATH}" >&2
+        exit 1
+    fi
+    verify_elf "${INPUT_PATH}"
+    exit 0
+fi
+
+if [[ ! -d "${INPUT_PATH}" ]]; then
+    echo "File or directory does not exist: ${INPUT_PATH}" >&2
+    exit 1
+fi
+
+ELF_COUNT=0
+while IFS= read -r -d '' candidate; do
+    if readelf -h "${candidate}" >/dev/null 2>&1; then
+        verify_elf "${candidate}"
+        ELF_COUNT=$((ELF_COUNT + 1))
+    fi
+done < <(find "${INPUT_PATH}" -type f -print0)
+
+if [[ ${ELF_COUNT} -eq 0 ]]; then
+    echo "No ELF files found under ${INPUT_PATH}" >&2
+    exit 1
+fi

scripts/linux/package_deb.sh

@@ -0,0 +1,183 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -lt 3 || $# -gt 4 ]]; then
+    echo "Usage: $0 <debian-arch> <xmake-arch> <version> [extra-recommendation]" >&2
+    exit 2
+fi
+
+DEBIAN_ARCH="$1"
+XMAKE_ARCH="$2"
+INPUT_VERSION="$3"
+EXTRA_RECOMMENDATION="${4:-}"
+
+PKG_NAME="crossdesk"
+APP_NAME="CrossDesk"
+MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
+DESCRIPTION="A simple cross-platform remote desktop client."
+ALSA_RUNTIME_DEP="libasound2 | libasound2t64"
+PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+normalize_app_version() {
+    local input="$1"
+    local prefix=""
+    local body="$input"
+
+    if [[ "$body" == v* ]]; then
+        prefix="v"
+        body="${body#v}"
+    fi
+
+    if [[ "$body" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]{8})-([0-9]+)$ ]]; then
+        echo "${prefix}${BASH_REMATCH[1]}-${BASH_REMATCH[4]}-${BASH_REMATCH[3]}"
+    else
+        echo "$input"
+    fi
+}
+
+find_slint_runtime() {
+    local needed="$1"
+    local resolved=""
+
+    resolved="$(ldd "$BUILD_BINARY" 2>/dev/null | awk -v needed="$needed" \
+        '$1 == needed && $2 == "=>" && $3 ~ /^\// { print $3; exit }')"
+    if [[ -n "$resolved" && -f "$resolved" ]]; then
+        echo "$resolved"
+        return 0
+    fi
+
+    local package_roots=()
+    if [[ -n "${XMAKE_GLOBALDIR:-}" ]]; then
+        package_roots+=("$XMAKE_GLOBALDIR/.xmake/packages")
+    fi
+    package_roots+=("$HOME/.xmake/packages" "/data/.xmake/packages")
+
+    local package_root=""
+    local candidate=""
+    for package_root in "${package_roots[@]}"; do
+        [[ -d "$package_root/s/slint" ]] || continue
+        candidate="$(find "$package_root/s/slint" -path "*/lib/$needed" -print -quit 2>/dev/null || true)"
+        if [[ -n "$candidate" ]]; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+
+    return 1
+}
+
+APP_VERSION="$(normalize_app_version "$INPUT_VERSION")"
+DEB_VERSION="${APP_VERSION#v}"
+if [[ ! "$DEB_VERSION" =~ ^[0-9][0-9A-Za-z.+:~_-]*$ ]]; then
+    echo "Invalid Debian version: $DEB_VERSION" >&2
+    exit 2
+fi
+
+BUILD_BINARY="$PROJECT_ROOT/build/linux/$XMAKE_ARCH/release/crossdesk"
+if [[ ! -x "$BUILD_BINARY" ]]; then
+    echo "Missing release binary: $BUILD_BINARY" >&2
+    echo "Build it first with: xmake f -m release -y && xmake b -vy crossdesk" >&2
+    exit 1
+fi
+
+for command_name in readelf ldd dpkg-deb; do
+    if ! command -v "$command_name" >/dev/null 2>&1; then
+        echo "Required packaging command is missing: $command_name" >&2
+        exit 1
+    fi
+done
+
+WORK_DIR="$(mktemp -d "${TMPDIR:-/tmp}/crossdesk-deb.XXXXXX")"
+trap 'rm -rf "$WORK_DIR"' EXIT
+
+DEB_DIR="$WORK_DIR/${PKG_NAME}-${DEB_VERSION}"
+DEBIAN_DIR="$DEB_DIR/DEBIAN"
+BIN_DIR="$DEB_DIR/usr/bin"
+PRIVATE_DIR="$DEB_DIR/usr/lib/$PKG_NAME"
+ICON_BASE_DIR="$DEB_DIR/usr/share/icons/hicolor"
+DESKTOP_DIR="$DEB_DIR/usr/share/applications"
+OUTPUT_FILE="$PROJECT_ROOT/${PKG_NAME}-linux-${DEBIAN_ARCH}-${APP_VERSION}.deb"
+
+install -d "$DEBIAN_DIR" "$BIN_DIR" "$PRIVATE_DIR" "$DESKTOP_DIR"
+install -m 0755 "$BUILD_BINARY" "$PRIVATE_DIR/crossdesk-bin"
+
+# Slint is intentionally built as a shared library. Keep that runtime private
+# to CrossDesk instead of relying on a non-existent distribution package.
+SLINT_NEEDED="$(readelf -d "$BUILD_BINARY" | sed -n \
+    's/.*Shared library: \[\(libslint_cpp[^]]*\)\].*/\1/p' | head -n 1)"
+if [[ -n "$SLINT_NEEDED" ]]; then
+    SLINT_LIBRARY="$(find_slint_runtime "$SLINT_NEEDED" || true)"
+    if [[ -z "$SLINT_LIBRARY" ]]; then
+        echo "Unable to locate the required Slint runtime: $SLINT_NEEDED" >&2
+        exit 1
+    fi
+    install -m 0755 "$SLINT_LIBRARY" "$PRIVATE_DIR/$SLINT_NEEDED"
+fi
+
+cat > "$BIN_DIR/$PKG_NAME" <<'EOF'
+#!/bin/sh
+private_lib_dir="/usr/lib/crossdesk"
+if [ -n "${LD_LIBRARY_PATH:-}" ]; then
+    export LD_LIBRARY_PATH="$private_lib_dir:$LD_LIBRARY_PATH"
+else
+    export LD_LIBRARY_PATH="$private_lib_dir"
+fi
+exec /usr/lib/crossdesk/crossdesk-bin "$@"
+EOF
+chmod 0755 "$BIN_DIR/$PKG_NAME"
+ln -s "$PKG_NAME" "$BIN_DIR/$APP_NAME"
+
+for size in 16 24 32 48 64 96 128 256; do
+    install -d "$ICON_BASE_DIR/${size}x${size}/apps"
+    install -m 0644 "$PROJECT_ROOT/icons/linux/crossdesk_${size}x${size}.png" \
+        "$ICON_BASE_DIR/${size}x${size}/apps/${PKG_NAME}.png"
+done
+
+RECOMMENDS="$PORTAL_RUNTIME_RECOMMENDS"
+if [[ -n "$EXTRA_RECOMMENDATION" ]]; then
+    RECOMMENDS="$RECOMMENDS, $EXTRA_RECOMMENDATION"
+fi
+
+cat > "$DEBIAN_DIR/control" <<EOF
+Package: $PKG_NAME
+Version: $DEB_VERSION
+Architecture: $DEBIAN_ARCH
+Maintainer: $MAINTAINER
+Description: $DESCRIPTION
+Depends: libc6 (>= 2.35), libstdc++6 (>= 9), libx11-6, libxext6,
+ libxrender1, libxft2, libxrandr2, libxfixes3, libxcb1, libxcb-randr0,
+ libxcb-xtest0, libxcb-xinerama0, libxcb-shape0, libxcb-xkb1,
+ libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP, libsndio7.0,
+ libxcb-shm0, libpulse0, libdrm2, libdbus-1-3
+Recommends: $RECOMMENDS
+Priority: optional
+Section: utils
+EOF
+
+cat > "$DESKTOP_DIR/$PKG_NAME.desktop" <<EOF
+[Desktop Entry]
+Version=$DEB_VERSION
+Name=$APP_NAME
+Comment=$DESCRIPTION
+Exec=/usr/bin/$PKG_NAME
+Icon=$PKG_NAME
+Terminal=false
+Type=Application
+Categories=Utility;
+EOF
+
+rm -f "$OUTPUT_FILE"
+dpkg-deb --root-owner-group --build "$DEB_DIR" "$OUTPUT_FILE"
+dpkg-deb --info "$OUTPUT_FILE" >/dev/null
+dpkg-deb --contents "$OUTPUT_FILE" > "$WORK_DIR/package-contents.txt"
+
+if [[ -n "$SLINT_NEEDED" ]] && \
+   ! grep -q "usr/lib/$PKG_NAME/$SLINT_NEEDED" "$WORK_DIR/package-contents.txt"; then
+    echo "Packaged artifact is missing $SLINT_NEEDED" >&2
+    exit 1
+fi
+
+echo "Deb package created: $OUTPUT_FILE"

scripts/linux/pkg_amd64.sh

@@ -1,116 +1,11 @@
-#!/bin/bash
-set -e
+#!/usr/bin/env bash
+set -euo pipefail
 
-PKG_NAME="crossdesk"
-APP_NAME="CrossDesk"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-ARCHITECTURE="amd64"
-MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
-DESCRIPTION="A simple cross-platform remote desktop client."
-ALSA_RUNTIME_DEP="libasound2 | libasound2t64"
-PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr"
-
-normalize_app_version() {
-    local input="$1"
-    local prefix=""
-    local body="$input"
-
-    if [[ "$body" == v* ]]; then
-        prefix="v"
-        body="${body#v}"
-    fi
-
-    if [[ "$body" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]{8})-([0-9]+)$ ]]; then
-        echo "${prefix}${BASH_REMATCH[1]}-${BASH_REMATCH[4]}-${BASH_REMATCH[3]}"
-    else
-        echo "$input"
-    fi
-}
-
-APP_VERSION="$(normalize_app_version "$1")"
-
-# Remove 'v' prefix from version for Debian package (Debian version must start with digit)
-DEB_VERSION="${APP_VERSION#v}"
-
-DEB_DIR="${PKG_NAME}-${DEB_VERSION}"
-DEBIAN_DIR="$DEB_DIR/DEBIAN"
-BIN_DIR="$DEB_DIR/usr/bin"
-ICON_BASE_DIR="$DEB_DIR/usr/share/icons/hicolor"
-DESKTOP_DIR="$DEB_DIR/usr/share/applications"
-
-rm -rf "$DEB_DIR"
-
-mkdir -p "$DEBIAN_DIR" "$BIN_DIR" "$DESKTOP_DIR"
-
-cp build/linux/x86_64/release/crossdesk "$BIN_DIR/$PKG_NAME"
-chmod +x "$BIN_DIR/$PKG_NAME"
-
-ln -s "$PKG_NAME" "$BIN_DIR/$APP_NAME"
-
-for size in 16 24 32 48 64 96 128 256; do
-    mkdir -p "$ICON_BASE_DIR/${size}x${size}/apps"
-    cp "icons/linux/crossdesk_${size}x${size}.png" \
-       "$ICON_BASE_DIR/${size}x${size}/apps/${PKG_NAME}.png"
-done
-
-cat > "$DEBIAN_DIR/control" << EOF
-Package: $PKG_NAME
-Version: $DEB_VERSION
-Architecture: $ARCHITECTURE
-Maintainer: $MAINTAINER
-Description: $DESCRIPTION
-Depends: libc6 (>= 2.29), libstdc++6 (>= 9), libx11-6, libxcb1,
- libxcb-randr0, libxcb-xtest0, libxcb-xinerama0, libxcb-shape0,
- libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP,
- libsndio7.0, libxcb-shm0, libpulse0, libdrm2, libdbus-1-3
-Recommends: $PORTAL_RUNTIME_RECOMMENDS, nvidia-cuda-toolkit
-Priority: optional
-Section: utils
-EOF
-
-cat > "$DESKTOP_DIR/$PKG_NAME.desktop" << EOF
-[Desktop Entry]
-Version=$DEB_VERSION
-Name=$APP_NAME
-Comment=$DESCRIPTION
-Exec=/usr/bin/$PKG_NAME
-Icon=$PKG_NAME
-Terminal=false
-Type=Application
-Categories=Utility;
-EOF
-
-cat > "$DEBIAN_DIR/postrm" << EOF
-#!/bin/bash
-set -e
-
-if [ "\$1" = "remove" ] || [ "\$1" = "purge" ]; then
-    rm -f /usr/bin/$PKG_NAME || true
-    rm -f /usr/bin/$APP_NAME || true
-    rm -f /usr/share/applications/$PKG_NAME.desktop || true
-    for size in 16 24 32 48 64 96 128 256; do
-        rm -f /usr/share/icons/hicolor/\${size}x\${size}/apps/$PKG_NAME.png || true
-    done
+if [[ $# -ne 1 ]]; then
+    echo "Usage: $0 <version>" >&2
+    exit 2
 fi
 
-exit 0
-EOF
-chmod +x "$DEBIAN_DIR/postrm"
-
-cat > "$DEBIAN_DIR/postinst" << 'EOF'
-#!/bin/bash
-set -e
-
-exit 0
-EOF
-
-chmod +x "$DEBIAN_DIR/postinst"
-
-dpkg-deb --build "$DEB_DIR"
-
-OUTPUT_FILE="${PKG_NAME}-linux-${ARCHITECTURE}-${APP_VERSION}.deb"
-mv "$DEB_DIR.deb" "$OUTPUT_FILE"
-
-rm -rf "$DEB_DIR"
-
-echo "✅ Deb package created: $OUTPUT_FILE"
+exec bash "$SCRIPT_DIR/package_deb.sh" amd64 x86_64 "$1" nvidia-cuda-toolkit

scripts/linux/pkg_arm64.sh

@@ -1,116 +1,11 @@
-#!/bin/bash
-set -e
+#!/usr/bin/env bash
+set -euo pipefail
 
-PKG_NAME="crossdesk"
-APP_NAME="CrossDesk"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-ARCHITECTURE="arm64"
-MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
-DESCRIPTION="A simple cross-platform remote desktop client."
-ALSA_RUNTIME_DEP="libasound2 | libasound2t64"
-PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr"
-
-normalize_app_version() {
-    local input="$1"
-    local prefix=""
-    local body="$input"
-
-    if [[ "$body" == v* ]]; then
-        prefix="v"
-        body="${body#v}"
-    fi
-
-    if [[ "$body" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]{8})-([0-9]+)$ ]]; then
-        echo "${prefix}${BASH_REMATCH[1]}-${BASH_REMATCH[4]}-${BASH_REMATCH[3]}"
-    else
-        echo "$input"
-    fi
-}
-
-APP_VERSION="$(normalize_app_version "$1")"
-
-# Remove 'v' prefix from version for Debian package (Debian version must start with digit)
-DEB_VERSION="${APP_VERSION#v}"
-
-DEB_DIR="${PKG_NAME}-${DEB_VERSION}"
-DEBIAN_DIR="$DEB_DIR/DEBIAN"
-BIN_DIR="$DEB_DIR/usr/bin"
-ICON_BASE_DIR="$DEB_DIR/usr/share/icons/hicolor"
-DESKTOP_DIR="$DEB_DIR/usr/share/applications"
-
-rm -rf "$DEB_DIR"
-
-mkdir -p "$DEBIAN_DIR" "$BIN_DIR" "$DESKTOP_DIR"
-
-cp build/linux/arm64/release/crossdesk "$BIN_DIR"
-chmod +x "$BIN_DIR/$PKG_NAME"
-
-ln -s "$PKG_NAME" "$BIN_DIR/$APP_NAME"
-
-for size in 16 24 32 48 64 96 128 256; do
-    mkdir -p "$ICON_BASE_DIR/${size}x${size}/apps"
-    cp "icons/linux/crossdesk_${size}x${size}.png" \
-       "$ICON_BASE_DIR/${size}x${size}/apps/${PKG_NAME}.png"
-done
-
-cat > "$DEBIAN_DIR/control" << EOF
-Package: $PKG_NAME
-Version: $DEB_VERSION
-Architecture: $ARCHITECTURE
-Maintainer: $MAINTAINER
-Description: $DESCRIPTION
-Depends: libc6 (>= 2.29), libstdc++6 (>= 9), libx11-6, libxcb1,
- libxcb-randr0, libxcb-xtest0, libxcb-xinerama0, libxcb-shape0,
- libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP,
- libsndio7.0, libxcb-shm0, libpulse0, libdrm2, libdbus-1-3
-Recommends: $PORTAL_RUNTIME_RECOMMENDS
-Priority: optional
-Section: utils
-EOF
-
-cat > "$DESKTOP_DIR/$PKG_NAME.desktop" << EOF
-[Desktop Entry]
-Version=$DEB_VERSION
-Name=$APP_NAME
-Comment=$DESCRIPTION
-Exec=/usr/bin/$PKG_NAME
-Icon=$PKG_NAME
-Terminal=false
-Type=Application
-Categories=Utility;
-EOF
-
-cat > "$DEBIAN_DIR/postrm" << EOF
-#!/bin/bash
-set -e
-
-if [ "\$1" = "remove" ] || [ "\$1" = "purge" ]; then
-    rm -f /usr/bin/$PKG_NAME || true
-    rm -f /usr/bin/$APP_NAME || true
-    rm -f /usr/share/applications/$PKG_NAME.desktop || true
-    for size in 16 24 32 48 64 96 128 256; do
-        rm -f /usr/share/icons/hicolor/\${size}x\${size}/apps/$PKG_NAME.png || true
-    done
+if [[ $# -ne 1 ]]; then
+    echo "Usage: $0 <version>" >&2
+    exit 2
 fi
 
-exit 0
-EOF
-chmod +x "$DEBIAN_DIR/postrm"
-
-cat > "$DEBIAN_DIR/postinst" << 'EOF'
-#!/bin/bash
-set -e
-
-exit 0
-EOF
-
-chmod +x "$DEBIAN_DIR/postinst"
-
-dpkg-deb --build "$DEB_DIR"
-
-OUTPUT_FILE="crossdesk-linux-arm64-$APP_VERSION.deb"
-mv "$DEB_DIR.deb" "$OUTPUT_FILE"
-
-rm -rf "$DEB_DIR"
-
-echo "✅ Deb package created: $OUTPUT_FILE"
+exec bash "$SCRIPT_DIR/package_deb.sh" arm64 arm64 "$1"

src/common/filesystem_utf8.h

@@ -0,0 +1,21 @@
+#ifndef CROSSDESK_COMMON_FILESYSTEM_UTF8_H_
+#define CROSSDESK_COMMON_FILESYSTEM_UTF8_H_
+
+#include <filesystem>
+#include <string>
+#include <string_view>
+
+namespace crossdesk {
+
+inline std::filesystem::path PathFromUtf8(std::string_view value) {
+#if defined(__cpp_char8_t)
+  const auto *begin = reinterpret_cast<const char8_t *>(value.data());
+  return std::filesystem::path(std::u8string(begin, begin + value.size()));
+#else
+  return std::filesystem::u8path(value.begin(), value.end());
+#endif
+}
+
+} // namespace crossdesk
+
+#endif // CROSSDESK_COMMON_FILESYSTEM_UTF8_H_

src/gui/application/application_state.h

@@ -1,24 +1,12 @@
 #ifndef CROSSDESK_GUI_APPLICATION_STATE_H_
 #define CROSSDESK_GUI_APPLICATION_STATE_H_
 
-#include <SDL3/SDL.h>
-
 #include <chrono>
 #include <cstdint>
 #include <memory>
 #include <nlohmann/json.hpp>
 #include <string>
 
-#include "imgui.h"
-
-#if _WIN32
-#include "platform/tray/win_tray.h"
-#elif defined(__APPLE__)
-#include "platform/tray/mac_tray.h"
-#elif defined(__linux__)
-#include "platform/tray/linux_tray.h"
-#endif
-
 namespace crossdesk::gui_detail {
 
 struct MainWindowState {
@@ -27,25 +15,10 @@ struct MainWindowState {
   float title_bar_button_width_ = 30;
   float title_bar_button_height_ = 30;
 
-  SDL_Window *main_window_ = nullptr;
-  SDL_Renderer *main_renderer_ = nullptr;
-  ImGuiContext *main_ctx_ = nullptr;
-  ImFont *main_windows_system_chinese_font_ = nullptr;
-  ImFont *stream_windows_system_chinese_font_ = nullptr;
-  ImFont *server_windows_system_chinese_font_ = nullptr;
   bool exit_ = false;
   const int sdl_refresh_ms_ = 16;
-#if _WIN32
-  std::unique_ptr<WinTray> tray_;
-#elif defined(__APPLE__)
-  std::unique_ptr<MacTray> tray_;
-#elif defined(__linux__)
-  std::unique_ptr<LinuxTray> tray_;
-#endif
 
   bool main_window_minimized_ = false;
-  uint32_t last_main_minimize_request_tick_ = 0;
-  uint32_t last_stream_minimize_request_tick_ = 0;
   int main_window_width_real_ = 720;
   int main_window_height_real_ = 540;
   float main_window_dpi_scaling_w_ = 1.0f;
@@ -77,8 +50,6 @@ struct MainWindowState {
   float about_window_height_ = 170;
   float update_notification_window_width_ = 400;
   float update_notification_window_height_ = 320;
-  uint32_t STREAM_REFRESH_EVENT = 0;
-  uint32_t APP_EXIT_EVENT = 0;
 };
 
 // Application-global interaction flags that coordinate SDL events with media
@@ -116,14 +87,15 @@ struct InteractionState {
   std::string controlled_remote_id_;
   std::string focused_remote_id_;
   std::string remote_client_id_;
-  SDL_Event last_mouse_event{};
 };
 
 struct UpdateState {
   nlohmann::json latest_version_info_ = nlohmann::json{};
   bool update_available_ = false;
   std::string latest_version_;
+  std::string release_name_;
   std::string release_notes_;
+  std::string release_date_;
   bool show_new_version_icon_ = false;
   bool show_new_version_icon_in_menu_ = true;
   double new_version_icon_last_trigger_time_ = 0.0;
@@ -131,20 +103,15 @@ struct UpdateState {
 };
 
 struct StreamWindowState {
-  SDL_Window *stream_window_ = nullptr;
-  SDL_Renderer *stream_renderer_ = nullptr;
-  ImGuiContext *stream_ctx_ = nullptr;
   bool need_to_create_stream_window_ = false;
   bool stream_window_created_ = false;
   bool stream_window_inited_ = false;
   bool window_maximized_ = false;
-  bool stream_window_grabbed_ = false;
   bool control_mouse_ = false;
   int stream_window_width_default_ = 1280;
   int stream_window_height_default_ = 720;
   float stream_window_width_ = 1280;
   float stream_window_height_ = 720;
-  SDL_PixelFormat stream_pixformat_ = SDL_PIXELFORMAT_NV12;
   int stream_window_width_real_ = 1280;
   int stream_window_height_real_ = 720;
   float stream_window_dpi_scaling_w_ = 1.0f;
@@ -152,9 +119,6 @@ struct StreamWindowState {
 };
 
 struct ServerWindowState {
-  SDL_Window *server_window_ = nullptr;
-  SDL_Renderer *server_renderer_ = nullptr;
-  ImGuiContext *server_ctx_ = nullptr;
   bool need_to_create_server_window_ = false;
   bool need_to_destroy_server_window_ = false;
   bool server_window_created_ = false;
@@ -164,7 +128,6 @@ struct ServerWindowState {
   float server_window_width_ = 250;
   float server_window_height_ = 150;
   float server_window_title_bar_height_ = 30.0f;
-  SDL_PixelFormat server_pixformat_ = SDL_PIXELFORMAT_NV12;
   int server_window_normal_width_ = 250;
   int server_window_normal_height_ = 150;
   float server_window_dpi_scaling_w_ = 1.0f;

src/gui/application/gui_application.h

@@ -1,20 +1,15 @@
 #ifndef CROSSDESK_GUI_APPLICATION_H_
 #define CROSSDESK_GUI_APPLICATION_H_
 
-#include <filesystem>
+#include <memory>
 #include <string>
-#include <vector>
 
-#include "IconsFontAwesome6.h"
-#include "imgui_impl_sdl3.h"
-#include "imgui_impl_sdlrenderer3.h"
-#include "imgui_internal.h"
 #include "runtime/gui_runtime.h"
 
 namespace crossdesk {
 
-// SDL/ImGui application shell. Feature state and protocol behavior live in
-// GuiRuntime and its composed controllers.
+// Slint application shell. GuiRuntime remains the owner of transport, media,
+// device, clipboard, transfer and settings behavior.
 class GuiApplication final : private GuiRuntime {
 public:
   GuiApplication();
@@ -23,88 +18,47 @@ public:
   int Run();
 
 private:
-  // Native window integration.
-  static SDL_HitTestResult HitTestCallback(SDL_Window *window,
-                                           const SDL_Point *area, void *data);
+  struct SlintUi;
 
-  // Application lifecycle.
   void InitializeLogger();
   void InitializeSettings();
-  void InitializeSDL();
+  bool InitializeSDL();
   void InitializeModules();
-  void InitializeMainWindow();
-  void MainLoop();
-  void HandleStreamWindow();
-  void HandleServerWindow();
-  void Cleanup();
-
-  // Window lifecycle and rendering.
-  int CreateMainWindow();
-  int DestroyMainWindow();
-  int CreateStreamWindow();
-  int DestroyStreamWindow();
-  int CreateServerWindow();
-  int DestroyServerWindow();
-  int SetupFontAndStyle(ImFont **system_chinese_font_out);
-  int DestroyMainWindowContext();
-  int DestroyStreamWindowContext();
-  int DestroyServerWindowContext();
-  int DrawMainWindow();
-  int DrawStreamWindow();
-  int DrawServerWindow();
-
-  // Views and dialogs.
-  int TitleBar(bool main_window);
-  int MainWindow();
-  int UpdateNotificationWindow();
-  int StreamWindow();
-  int ServerWindow();
-  int RemoteClientInfoWindow();
-  int LocalWindow();
-  int RemoteWindow();
-  int RecentConnectionsWindow();
-  int SettingWindow();
-  int SelfHostedServerWindow();
-  int ControlWindow(std::shared_ptr<RemoteSession> &props);
-  int ControlBar(std::shared_ptr<RemoteSession> &props);
-  int AboutWindow();
-  int StatusBar();
-  bool
-  ConnectionStatusWindow(std::shared_ptr<RemoteSession> &props);
-  int ShowRecentConnections();
-  int ConfirmDeleteConnection();
-  int EditRecentConnectionAliasWindow();
-  int OfflineWarningWindow();
-  int NetTrafficStats(std::shared_ptr<RemoteSession> &props);
-  int FileTransferWindow(std::shared_ptr<RemoteSession> &props);
-  void
-  DrawConnectionStatusText(std::shared_ptr<RemoteSession> &props);
-  void
-  DrawReceivingScreenText(std::shared_ptr<RemoteSession> &props);
-  bool OpenUrl(const std::string &url);
-  void Hyperlink(const std::string &label, const std::string &url,
-                 float window_width);
-  std::string OpenFileDialog(std::string title);
+  void InitializeUi();
+  void InitializeSystemTray();
   bool MinimizeMainWindowToTray();
-
-  // SDL event dispatch and input translation.
-  void UpdateRenderRect();
-  void ProcessSdlEvent(const SDL_Event &event);
-  int ProcessKeyboardEvent(const SDL_Event &event);
-  int ProcessMouseEvent(const SDL_Event &event);
-  void CloseTab(decltype(remote_sessions_)::iterator &it);
-
+  void BindMainCallbacks();
+  void BindStreamCallbacks();
+  void BindServerCallbacks();
+  void Tick();
+  void SyncMainWindow();
+  void SyncConnectionDialog();
+  void SyncPlatformDialogs();
+  void SyncStreamWindow();
+  void SyncServerWindow();
+  void UpdateLocalization();
+  void ResetSettingsUi();
+  void SaveSettingsFromUi();
 #if _WIN32 && CROSSDESK_PORTABLE
   void CheckPortableWindowsService();
-  int PortableServiceInstallWindow();
   void StartPortableWindowsServiceInstall();
   void JoinPortableWindowsServiceInstallThread();
 #endif
+  void ConnectFromUi(const std::string &remote_id);
+  void SelectStreamTab(int index);
+  void ReorderStreamTab(int from, float drop_x, float tab_width);
+  void CloseStreamTab(const std::string &remote_id);
+  void SendPointerInput(int button, int kind, float x, float y);
+  void SendScrollInput(float delta_x, float delta_y, float x, float y);
+  void SendKeyInput(const std::string &text, bool pressed, bool control,
+                    bool alt, bool shift, bool meta);
+  void Cleanup();
 
-#ifdef __APPLE__
-  int RequestPermissionWindow();
-  bool DrawToggleSwitch(const char *id, bool active, bool enabled);
-#endif
+  std::shared_ptr<RemoteSession> SelectedSession();
+  std::string OpenFileDialog(const std::string &title);
+  bool OpenUrl(const std::string &url);
+
+  std::unique_ptr<SlintUi> ui_;
 };
 
 } // namespace crossdesk

src/gui/application/portable_service_integration.cpp

@@ -0,0 +1,144 @@
+#include "application/gui_application.h"
+
+#if _WIN32 && CROSSDESK_PORTABLE
+
+#include <Windows.h>
+#include <shellapi.h>
+
+#include <filesystem>
+#include <vector>
+
+#include "rd_log.h"
+#include "service_host.h"
+
+namespace crossdesk {
+namespace {
+
+std::filesystem::path GetCurrentExecutablePath() {
+  std::vector<wchar_t> buffer(MAX_PATH);
+  while (true) {
+    const DWORD length = GetModuleFileNameW(
+        nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
+    if (length == 0) {
+      return {};
+    }
+    if (length < buffer.size()) {
+      return std::filesystem::path(buffer.data(), buffer.data() + length);
+    }
+    if (buffer.size() >= 32768) {
+      return {};
+    }
+    buffer.resize(buffer.size() * 2);
+  }
+}
+
+bool InstallServiceWithElevation() {
+  const std::filesystem::path executable_path = GetCurrentExecutablePath();
+  if (executable_path.empty()) {
+    LOG_ERROR("Portable service install failed: current executable not found");
+    return false;
+  }
+
+  const std::filesystem::path service_path =
+      executable_path.parent_path() / L"crossdesk_service.exe";
+  const std::filesystem::path helper_path =
+      executable_path.parent_path() / L"crossdesk_session_helper.exe";
+  if (!std::filesystem::exists(service_path) ||
+      !std::filesystem::exists(helper_path)) {
+    LOG_ERROR("Portable service install failed: service binaries missing, "
+              "service={}, helper={}",
+              service_path.string(), helper_path.string());
+    return false;
+  }
+
+  const std::wstring executable = executable_path.wstring();
+  const std::wstring working_dir = executable_path.parent_path().wstring();
+  constexpr wchar_t parameters[] = L"--service-install";
+
+  SHELLEXECUTEINFOW execute_info{};
+  execute_info.cbSize = sizeof(execute_info);
+  execute_info.fMask = SEE_MASK_NOCLOSEPROCESS;
+  execute_info.lpVerb = L"runas";
+  execute_info.lpFile = executable.c_str();
+  execute_info.lpParameters = parameters;
+  execute_info.lpDirectory = working_dir.c_str();
+  execute_info.nShow = SW_HIDE;
+
+  if (!ShellExecuteExW(&execute_info)) {
+    LOG_ERROR("Portable service install failed: ShellExecuteExW error={}",
+              GetLastError());
+    return false;
+  }
+
+  const DWORD wait_result =
+      WaitForSingleObject(execute_info.hProcess, INFINITE);
+  DWORD exit_code = 1;
+  if (wait_result == WAIT_OBJECT_0) {
+    GetExitCodeProcess(execute_info.hProcess, &exit_code);
+  } else {
+    LOG_ERROR("Portable service install wait failed, result={}", wait_result);
+  }
+  CloseHandle(execute_info.hProcess);
+
+  if (exit_code != 0) {
+    LOG_ERROR("Portable service install command failed, exit_code={}",
+              exit_code);
+    return false;
+  }
+
+  const bool started = StartCrossDeskService();
+  if (!started) {
+    LOG_WARN("Portable service installed but start failed");
+  }
+  return IsCrossDeskServiceInstalled() && started;
+}
+
+} // namespace
+
+void GuiApplication::CheckPortableWindowsService() {
+  if (portable_service_prompt_checked_) {
+    return;
+  }
+  portable_service_prompt_checked_ = true;
+  portable_service_installed_ = IsCrossDeskServiceInstalled();
+  if (portable_service_installed_ || portable_service_prompt_suppressed_) {
+    return;
+  }
+
+  portable_service_install_state_.store(PortableServiceInstallState::idle,
+                                        std::memory_order_relaxed);
+  show_portable_service_install_window_ = true;
+}
+
+void GuiApplication::StartPortableWindowsServiceInstall() {
+  portable_service_do_not_remind_ = false;
+  PortableServiceInstallState expected = PortableServiceInstallState::idle;
+  if (!portable_service_install_state_.compare_exchange_strong(
+          expected, PortableServiceInstallState::installing,
+          std::memory_order_acq_rel)) {
+    if (expected != PortableServiceInstallState::failed) {
+      return;
+    }
+    portable_service_install_state_.store(
+        PortableServiceInstallState::installing, std::memory_order_release);
+  }
+
+  JoinPortableWindowsServiceInstallThread();
+  portable_service_install_thread_ = std::thread([this]() {
+    const bool installed = InstallServiceWithElevation();
+    portable_service_install_state_.store(
+        installed ? PortableServiceInstallState::succeeded
+                  : PortableServiceInstallState::failed,
+        std::memory_order_release);
+  });
+}
+
+void GuiApplication::JoinPortableWindowsServiceInstallThread() {
+  if (portable_service_install_thread_.joinable()) {
+    portable_service_install_thread_.join();
+  }
+}
+
+} // namespace crossdesk
+
+#endif

src/gui/assets/localization/localization.h

@@ -58,7 +58,7 @@ using TranslationTable =
 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},
+          {"en-US", reinterpret_cast<const char*>(row.en)},
           {"ru-RU", reinterpret_cast<const char*>(row.ru)}};
 }
 

src/gui/assets/localization/localization_data.h

@@ -13,9 +13,9 @@ namespace detail {
 
 struct TranslationRow {
   const char* key;
-  const char* zh;
-  const char* en;
-  const char* ru;
+  const void* zh;
+  const void* en;
+  const void* ru;
 };
 
 // Single source of truth for all UI strings.

src/gui/features/clipboard/clipboard_controller.cpp

@@ -33,11 +33,6 @@ void ClipboardController::Initialize() {
     SDL_free(clipboard_text);
   }
 
-  if (event_type_ == 0) {
-    LOG_ERROR("Clipboard synchronization disabled: SDL event is unavailable");
-    return;
-  }
-
   events_enabled_.store(true, std::memory_order_release);
 }
 
@@ -75,7 +70,7 @@ void ClipboardController::QueueRemoteText(const char *data, size_t size) {
 
   SDL_Event event{};
   event.type = event_type_;
-  if (!SDL_PushEvent(&event)) {
+  if (event_type_ != 0 && !SDL_PushEvent(&event)) {
     // MainLoop also drains the pending value after its wait timeout.
     LOG_WARN("Failed to wake SDL loop for remote clipboard text: {}",
              SDL_GetError());

src/gui/features/file_transfer/file_transfer_manager.cpp

@@ -13,6 +13,7 @@
 #include <utility>
 
 #include "file_transfer.h"
+#include "filesystem_utf8.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
 
@@ -40,7 +41,7 @@ void FileTransferManager::ProcessSelectedFile(
   FileTransferState &state = state_for(props);
   LOG_INFO("Selected file: {}", path.c_str());
 
-  const std::filesystem::path file_path = std::filesystem::u8path(path);
+  const std::filesystem::path file_path = PathFromUtf8(path);
   std::error_code ec;
   if (!std::filesystem::is_regular_file(file_path, ec)) {
     LOG_ERROR("Selected path is not a regular file: {}", path);
@@ -55,7 +56,9 @@ void FileTransferManager::ProcessSelectedFile(
   {
     std::lock_guard<std::mutex> lock(state.file_transfer_list_mutex_);
     FileTransferState::FileTransferInfo info;
-    info.file_name = file_path.filename().u8string();
+    const auto utf8_name = file_path.filename().u8string();
+    info.file_name.assign(reinterpret_cast<const char *>(utf8_name.data()),
+                          utf8_name.size());
     info.file_path = file_path;
     info.file_size = file_size;
     info.status = FileTransferState::FileTransferStatus::Queued;
@@ -341,39 +344,4 @@ void FileTransferManager::HandleAck(const char *data, size_t size) {
   ProcessQueue(props);
 }
 
-void FileTransferManager::HandleDropEvent(const SDL_Event &event) {
-  if (event.type != SDL_EVENT_DROP_FILE ||
-      !((owner_.stream_window_ &&
-         SDL_GetWindowID(owner_.stream_window_) == event.window.windowID) ||
-        (owner_.server_window_ &&
-         SDL_GetWindowID(owner_.server_window_) == event.window.windowID))) {
-    return;
-  }
-
-  if (owner_.stream_window_ &&
-      SDL_GetWindowID(owner_.stream_window_) == event.window.windowID) {
-    if (!owner_.stream_window_inited_ || !event.drop.data) {
-      return;
-    }
-    std::shared_lock lock(owner_.remote_sessions_mutex_);
-    for (const auto &[remote_id, props] : owner_.remote_sessions_) {
-      if (props && props->tab_selected_ && props->peer_) {
-        ProcessSelectedFile(static_cast<const char *>(event.drop.data), props,
-                            props->file_label_);
-        break;
-      }
-    }
-    return;
-  }
-
-  if (owner_.server_window_inited_ && event.drop.data) {
-    const auto file_path = std::filesystem::u8path(event.drop.data);
-    std::error_code ec;
-    if (std::filesystem::is_regular_file(file_path, ec)) {
-      LOG_INFO("Drop file [{}] on server window (size: {} bytes)",
-               event.drop.data, std::filesystem::file_size(file_path, ec));
-    }
-  }
-}
-
 } // namespace crossdesk

src/gui/features/file_transfer/file_transfer_manager.h

@@ -1,8 +1,6 @@
 #ifndef CROSSDESK_GUI_FILE_TRANSFER_MANAGER_H_
 #define CROSSDESK_GUI_FILE_TRANSFER_MANAGER_H_
 
-#include <SDL3/SDL.h>
-
 #include <cstddef>
 #include <cstdint>
 #include <filesystem>
@@ -33,7 +31,6 @@ public:
                       const std::shared_ptr<RemoteSession> &props,
                       const std::string &file_label,
                       const std::string &remote_id = "");
-  void HandleDropEvent(const SDL_Event &event);
   void HandleAck(const char *data, size_t size);
 
 private:

src/gui/platform/tray/linux_tray.cpp

@@ -190,6 +190,18 @@ struct LinuxTrayImpl {
         menu_label(GetMenuLabel(language_index_value)),
         menu_ascii_label(IsAsciiPrintable(menu_label) ? menu_label : "Exit") {}
 
+  explicit LinuxTrayImpl(std::function<void()> show_window_callback,
+                         std::function<void()> hide_window_callback,
+                         std::function<void()> exit_callback,
+                         std::string tray_tooltip, int language_index_value)
+      : show_window(std::move(show_window_callback)),
+        hide_window(std::move(hide_window_callback)),
+        exit_app(std::move(exit_callback)),
+        tooltip(std::move(tray_tooltip)),
+        language_index(language_index_value),
+        menu_label(GetMenuLabel(language_index_value)),
+        menu_ascii_label(IsAsciiPrintable(menu_label) ? menu_label : "Exit") {}
+
   ~LinuxTrayImpl() { RemoveTrayIcon(); }
 
   bool MinimizeToTray() {
@@ -197,7 +209,9 @@ struct LinuxTrayImpl {
       return false;
     }
 
-    if (app_window) {
+    if (hide_window) {
+      hide_window();
+    } else if (app_window) {
       SDL_HideWindow(app_window);
     }
     return true;
@@ -939,16 +953,20 @@ struct LinuxTrayImpl {
   }
 
   void ShowWindow() {
-    if (!app_window) {
-      return;
+    if (show_window) {
+      show_window();
+    } else if (app_window) {
+      SDL_ShowWindow(app_window);
+      SDL_RestoreWindow(app_window);
+      SDL_RaiseWindow(app_window);
     }
-
-    SDL_ShowWindow(app_window);
-    SDL_RestoreWindow(app_window);
-    SDL_RaiseWindow(app_window);
   }
 
   void RequestExit() {
+    if (exit_app) {
+      exit_app();
+      return;
+    }
     SDL_Event event{};
     event.type =
         exit_event_type == 0 || exit_event_type == static_cast<uint32_t>(-1)
@@ -958,6 +976,9 @@ struct LinuxTrayImpl {
   }
 
   ::SDL_Window* app_window = nullptr;
+  std::function<void()> show_window;
+  std::function<void()> hide_window;
+  std::function<void()> exit_app;
   std::string tooltip;
   int language_index = 0;
   uint32_t exit_event_type = 0;
@@ -1005,6 +1026,14 @@ LinuxTray::LinuxTray(::SDL_Window* app_window, const std::string& tooltip,
     : impl_(std::make_unique<LinuxTrayImpl>(app_window, tooltip, language_index,
                                             exit_event_type)) {}
 
+LinuxTray::LinuxTray(std::function<void()> show_window,
+                     std::function<void()> hide_window,
+                     std::function<void()> exit_app,
+                     const std::string& tooltip, int language_index)
+    : impl_(std::make_unique<LinuxTrayImpl>(
+          std::move(show_window), std::move(hide_window), std::move(exit_app),
+          tooltip, language_index)) {}
+
 LinuxTray::~LinuxTray() = default;
 
 bool LinuxTray::MinimizeToTray() { return impl_->MinimizeToTray(); }

src/gui/platform/tray/linux_tray.h

@@ -10,6 +10,7 @@
 #if defined(__linux__) && !defined(__APPLE__)
 
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -23,6 +24,9 @@ class LinuxTray {
  public:
   LinuxTray(::SDL_Window* app_window, const std::string& tooltip,
             int language_index, uint32_t exit_event_type);
+  LinuxTray(std::function<void()> show_window,
+            std::function<void()> hide_window, std::function<void()> exit_app,
+            const std::string& tooltip, int language_index);
   ~LinuxTray();
 
   bool MinimizeToTray();

src/gui/platform/tray/mac_tray.h

@@ -7,6 +7,7 @@
 #ifndef _MAC_TRAY_H_
 #define _MAC_TRAY_H_
 
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -20,6 +21,11 @@ class MacTray {
  public:
   MacTray(::SDL_Window* app_window, const std::string& tooltip,
           int language_index);
+  MacTray(std::function<void()> show_window,
+          std::function<void()> hide_window,
+          std::function<void()> open_settings,
+          std::function<void()> exit_app,
+          const std::string& tooltip, int language_index);
   ~MacTray();
 
   void MinimizeToTray();

src/gui/platform/tray/mac_tray.mm

@@ -13,6 +13,7 @@
 @interface CrossDeskMacTrayTarget : NSObject
 - (instancetype)initWithOwner:(crossdesk::MacTrayImpl *)owner;
 - (void)statusItemClicked:(id)sender;
+- (void)openSettings:(id)sender;
 - (void)exitApplication:(id)sender;
 @end
 
@@ -24,7 +25,24 @@ struct MacTrayImpl {
       : app_window(window),
         tooltip(std::move(tray_tooltip)),
         language_index(language_index_value),
-        target([[CrossDeskMacTrayTarget alloc] initWithOwner:this]) {}
+        target([[CrossDeskMacTrayTarget alloc] initWithOwner:this]) {
+    EnsureStatusItem();
+  }
+
+  explicit MacTrayImpl(std::function<void()> show_window_callback,
+                       std::function<void()> hide_window_callback,
+                       std::function<void()> open_settings_callback,
+                       std::function<void()> exit_callback,
+                       std::string tray_tooltip, int language_index_value)
+      : show_window(std::move(show_window_callback)),
+        hide_window(std::move(hide_window_callback)),
+        open_settings(std::move(open_settings_callback)),
+        exit_app(std::move(exit_callback)),
+        tooltip(std::move(tray_tooltip)),
+        language_index(language_index_value),
+        target([[CrossDeskMacTrayTarget alloc] initWithOwner:this]) {
+    EnsureStatusItem();
+  }
 
   ~MacTrayImpl() {
     RemoveTrayIcon();
@@ -33,7 +51,9 @@ struct MacTrayImpl {
 
   void MinimizeToTray() {
     EnsureStatusItem();
-    if (app_window) {
+    if (hide_window) {
+      hide_window();
+    } else if (app_window) {
       SDL_HideWindow(app_window);
     }
   }
@@ -48,12 +68,12 @@ struct MacTrayImpl {
   }
 
   void ShowWindow() {
-    if (!app_window) {
-      return;
+    if (show_window) {
+      show_window();
+    } else if (app_window) {
+      SDL_ShowWindow(app_window);
+      SDL_RaiseWindow(app_window);
     }
-
-    SDL_ShowWindow(app_window);
-    SDL_RaiseWindow(app_window);
     [NSApp activateIgnoringOtherApps:YES];
   }
 
@@ -64,6 +84,18 @@ struct MacTrayImpl {
     }
 
     NSMenu *menu = [[NSMenu alloc] initWithTitle:@"CrossDesk"];
+    NSString *settings_title =
+        NSStringFromUtf8(localization::settings
+                             [localization::detail::ClampLanguageIndex(
+                                 language_index)]);
+    NSMenuItem *settings_item =
+        [[NSMenuItem alloc] initWithTitle:settings_title
+                                  action:@selector(openSettings:)
+                           keyEquivalent:@""];
+    [settings_item setTarget:target];
+    [menu addItem:settings_item];
+    [menu addItem:[NSMenuItem separatorItem]];
+
     NSString *exit_title =
         NSStringFromUtf8(localization::exit_program
                              [localization::detail::ClampLanguageIndex(
@@ -86,11 +118,25 @@ struct MacTrayImpl {
   }
 
   void RequestExit() {
+    if (exit_app) {
+      exit_app();
+      return;
+    }
     SDL_Event event;
     event.type = SDL_EVENT_QUIT;
     SDL_PushEvent(&event);
   }
 
+  void OpenSettings() {
+    if (open_settings) {
+      open_settings();
+    } else {
+      ShowWindow();
+      return;
+    }
+    [NSApp activateIgnoringOtherApps:YES];
+  }
+
  private:
   void EnsureStatusItem() {
     if (status_item) {
@@ -191,6 +237,10 @@ struct MacTrayImpl {
   }
 
   ::SDL_Window *app_window = nullptr;
+  std::function<void()> show_window;
+  std::function<void()> hide_window;
+  std::function<void()> open_settings;
+  std::function<void()> exit_app;
   std::string tooltip;
   int language_index = 0;
   NSStatusItem *status_item = nil;
@@ -202,6 +252,16 @@ MacTray::MacTray(::SDL_Window *app_window, const std::string &tooltip,
     : impl_(
           std::make_unique<MacTrayImpl>(app_window, tooltip, language_index)) {}
 
+MacTray::MacTray(std::function<void()> show_window,
+                 std::function<void()> hide_window,
+                 std::function<void()> open_settings,
+                 std::function<void()> exit_app, const std::string &tooltip,
+                 int language_index)
+    : impl_(std::make_unique<MacTrayImpl>(
+          std::move(show_window), std::move(hide_window),
+          std::move(open_settings), std::move(exit_app), tooltip,
+          language_index)) {}
+
 MacTray::~MacTray() = default;
 
 void MacTray::MinimizeToTray() { impl_->MinimizeToTray(); }
@@ -244,6 +304,13 @@ void MacTray::RemoveTrayIcon() { impl_->RemoveTrayIcon(); }
   }
 }
 
+- (void)openSettings:(id)sender {
+  (void)sender;
+  if (owner_) {
+    owner_->OpenSettings();
+  }
+}
+
 @end
 
 #endif  // __APPLE__

src/gui/platform/tray/win_tray.cpp

@@ -4,6 +4,8 @@
 
 #include "localization.h"
 
+#include <utility>
+
 namespace crossdesk {
 
 // callback for the message-only window that handles tray icon messages
@@ -60,6 +62,16 @@ WinTray::WinTray(HWND app_hwnd, HICON icon, const std::wstring& tooltip,
   wcsncpy_s(nid_.szTip, tip_.c_str(), _TRUNCATE);
 }
 
+WinTray::WinTray(std::function<void()> show_window,
+                 std::function<void()> hide_window,
+                 std::function<void()> exit_app, HICON icon,
+                 const std::wstring& tooltip, int language_index)
+    : WinTray(nullptr, icon, tooltip, language_index) {
+  show_window_ = std::move(show_window);
+  hide_window_ = std::move(hide_window);
+  exit_app_ = std::move(exit_app);
+}
+
 WinTray::~WinTray() {
   RemoveTrayIcon();
   if (hwnd_message_only_) DestroyWindow(hwnd_message_only_);
@@ -67,20 +79,31 @@ WinTray::~WinTray() {
 
 void WinTray::MinimizeToTray() {
   Shell_NotifyIcon(NIM_ADD, &nid_);
-  // hide application window
-  ShowWindow(app_hwnd_, SW_HIDE);
+  if (hide_window_) {
+    hide_window_();
+  } else if (app_hwnd_) {
+    ShowWindow(app_hwnd_, SW_HIDE);
+  }
 }
 
 void WinTray::RemoveTrayIcon() { Shell_NotifyIcon(NIM_DELETE, &nid_); }
 
+void WinTray::ShowApplicationWindow() {
+  if (show_window_) {
+    show_window_();
+  } else if (app_hwnd_) {
+    ShowWindow(app_hwnd_, SW_SHOW);
+    SetForegroundWindow(app_hwnd_);
+  }
+}
+
 bool WinTray::HandleTrayMessage(MSG* msg) {
   if (!msg || msg->message != WM_TRAY_CALLBACK) return false;
 
   switch (LOWORD(msg->lParam)) {
     case WM_LBUTTONDBLCLK:
     case WM_LBUTTONUP: {
-      ShowWindow(app_hwnd_, SW_SHOW);
-      SetForegroundWindow(app_hwnd_);
+      ShowApplicationWindow();
       break;
     }
 
@@ -99,13 +122,15 @@ bool WinTray::HandleTrayMessage(MSG* msg) {
 
       // handle menu command
       if (cmd == 1001) {
-        // exit application
-        SDL_Event event;
-        event.type = SDL_EVENT_QUIT;
-        SDL_PushEvent(&event);
+        if (exit_app_) {
+          exit_app_();
+        } else {
+          SDL_Event event;
+          event.type = SDL_EVENT_QUIT;
+          SDL_PushEvent(&event);
+        }
       } else if (cmd == 1002) {
-        ShowWindow(app_hwnd_, SW_SHOW);  // show main window
-        SetForegroundWindow(app_hwnd_);
+        ShowApplicationWindow();
       }
       break;
     }

src/gui/platform/tray/win_tray.h

@@ -10,6 +10,7 @@
 #include <Windows.h>
 #include <shellapi.h>
 
+#include <functional>
 #include <string>
 
 #define WM_TRAY_CALLBACK (WM_USER + 1)
@@ -20,6 +21,9 @@ class WinTray {
  public:
   WinTray(HWND app_hwnd, HICON icon, const std::wstring& tooltip,
           int language_index);
+  WinTray(std::function<void()> show_window,
+          std::function<void()> hide_window, std::function<void()> exit_app,
+          HICON icon, const std::wstring& tooltip, int language_index);
   ~WinTray();
 
   void MinimizeToTray();
@@ -27,12 +31,17 @@ class WinTray {
   bool HandleTrayMessage(MSG* msg);
 
  private:
+  void ShowApplicationWindow();
+
   HWND app_hwnd_;
   HWND hwnd_message_only_;
   HICON icon_;
   std::wstring tip_;
   int language_index_;
   NOTIFYICONDATA nid_;
+  std::function<void()> show_window_;
+  std::function<void()> hide_window_;
+  std::function<void()> exit_app_;
 };
 }  // namespace crossdesk
-#endif
+#endif

src/gui/platform/window_drag.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+namespace crossdesk {
+
+// Starts the platform's native move loop for the window receiving the current
+// left-mouse-down event. Returns false when no suitable native event exists.
+bool StartNativeWindowDrag();
+
+// Hides the disabled native zoom button on CrossDesk's fixed-size main
+// window. Returns true once the matching AppKit window has been configured.
+bool HideDisabledMainWindowZoomButton();
+
+// Configures live resize and replaces the stream window's native Space
+// fullscreen action with an immediate, single-window fullscreen transition.
+bool ConfigureStreamWindowLiveResize();
+
+// Enters or leaves the stream window's animation-free fullscreen mode.
+bool SetStreamWindowFullscreen(bool fullscreen);
+bool IsStreamWindowFullscreen();
+
+// Opens an application-modal macOS file picker. The panel is made key before
+// entering its modal loop so it receives keyboard input immediately.
+std::string OpenNativeFileDialog(const std::string &title);
+
+} // namespace crossdesk

src/gui/platform/window_drag_mac.mm

@@ -0,0 +1,265 @@
+#include "platform/window_drag.h"
+
+#import <AppKit/AppKit.h>
+
+@interface CrossDeskStreamFullscreenTarget : NSObject
+- (void)toggleStreamFullscreen:(id)sender;
+@end
+
+@implementation CrossDeskStreamFullscreenTarget
+- (void)toggleStreamFullscreen:(id)sender {
+  (void)sender;
+  crossdesk::SetStreamWindowFullscreen(
+      !crossdesk::IsStreamWindowFullscreen());
+}
+@end
+
+namespace crossdesk {
+namespace {
+
+NSWindow *stream_window = nil;
+CrossDeskStreamFullscreenTarget *stream_fullscreen_target = nil;
+bool stream_fullscreen = false;
+NSRect stream_restore_frame = NSZeroRect;
+NSWindowStyleMask stream_restore_style_mask = NSWindowStyleMaskTitled;
+NSWindowTitleVisibility stream_restore_title_visibility =
+    NSWindowTitleVisible;
+BOOL stream_restore_titlebar_transparent = NO;
+BOOL stream_restore_movable = YES;
+BOOL stream_restore_close_hidden = NO;
+BOOL stream_restore_miniaturize_hidden = NO;
+BOOL stream_restore_zoom_hidden = NO;
+NSApplicationPresentationOptions stream_restore_presentation_options =
+    NSApplicationPresentationDefault;
+
+void InstallStreamFullscreenButton(NSWindow *window) {
+  if (window == nil) {
+    return;
+  }
+  if (stream_fullscreen_target == nil) {
+    stream_fullscreen_target =
+        [[CrossDeskStreamFullscreenTarget alloc] init];
+  }
+  NSButton *zoom_button =
+      [window standardWindowButton:NSWindowZoomButton];
+  zoom_button.target = stream_fullscreen_target;
+  zoom_button.action = @selector(toggleStreamFullscreen:);
+}
+
+void SetTitlebarButtonsHidden(NSWindow *window, BOOL hidden) {
+  [window standardWindowButton:NSWindowCloseButton].hidden = hidden;
+  [window standardWindowButton:NSWindowMiniaturizeButton].hidden = hidden;
+  [window standardWindowButton:NSWindowZoomButton].hidden = hidden;
+}
+
+void CenterWindowOnScreen(NSWindow *window, NSScreen *screen) {
+  if (window == nil || screen == nil) {
+    return;
+  }
+  const NSRect available_frame = screen.visibleFrame;
+  const NSRect window_frame = window.frame;
+  const NSPoint centered_origin = NSMakePoint(
+      NSMidX(available_frame) - NSWidth(window_frame) * 0.5,
+      NSMidY(available_frame) - NSHeight(window_frame) * 0.5);
+  [window setFrameOrigin:centered_origin];
+}
+
+} // namespace
+
+bool StartNativeWindowDrag() {
+  @autoreleasepool {
+    NSEvent *event = [[NSApplication sharedApplication] currentEvent];
+    if (event == nil || event.type != NSEventTypeLeftMouseDown ||
+        event.window == nil) {
+      return false;
+    }
+
+    [event.window performWindowDragWithEvent:event];
+    return true;
+  }
+}
+
+bool HideDisabledMainWindowZoomButton() {
+  @autoreleasepool {
+    for (NSWindow *window in [NSApp windows]) {
+      if (![window.title isEqualToString:@"CrossDesk"]) {
+        continue;
+      }
+
+      NSButton *zoom_button =
+          [window standardWindowButton:NSWindowZoomButton];
+      // The main window has a fixed size, so AppKit disables its zoom button.
+      // Stream windows remain resizable and must keep their native button.
+      if (zoom_button == nil || zoom_button.enabled) {
+        continue;
+      }
+
+      zoom_button.hidden = YES;
+      return true;
+    }
+    return false;
+  }
+}
+
+bool ConfigureStreamWindowLiveResize() {
+  @autoreleasepool {
+    for (NSWindow *window in [NSApp windows]) {
+      if (![window.title isEqualToString:@"CrossDesk"]) {
+        continue;
+      }
+
+      NSButton *zoom_button =
+          [window standardWindowButton:NSWindowZoomButton];
+      // The stream window is resizable and therefore keeps an enabled native
+      // zoom button. The fixed-size main window's zoom button is disabled.
+      if (zoom_button == nil || !zoom_button.enabled) {
+        continue;
+      }
+
+      NSView *content_view = window.contentView;
+      if (content_view == nil) {
+        return false;
+      }
+
+      // During an ordinary edge resize, scale one cached frame and redraw once
+      // the new window size has settled.
+      window.preservesContentDuringLiveResize = YES;
+      content_view.layerContentsRedrawPolicy =
+          NSViewLayerContentsRedrawBeforeViewResize;
+      content_view.layerContentsPlacement =
+          NSViewLayerContentsPlacementScaleProportionallyToFit;
+      stream_window = window;
+      // Native Space fullscreen cross-fades an AppKit source snapshot over a
+      // separately rendered destination window. Disable that path for the
+      // stream window and route the green button to the immediate transition.
+      window.collectionBehavior =
+          (window.collectionBehavior &
+           ~(NSWindowCollectionBehaviorFullScreenPrimary |
+             NSWindowCollectionBehaviorFullScreenAuxiliary |
+             NSWindowCollectionBehaviorFullScreenAllowsTiling)) |
+          NSWindowCollectionBehaviorFullScreenNone;
+      InstallStreamFullscreenButton(window);
+      content_view.needsDisplay = YES;
+      return true;
+    }
+    return false;
+  }
+}
+
+bool SetStreamWindowFullscreen(bool fullscreen) {
+  @autoreleasepool {
+    if (stream_window == nil || stream_fullscreen == fullscreen) {
+      return stream_window != nil;
+    }
+
+    if (fullscreen) {
+      NSScreen *screen = stream_window.screen ?: NSScreen.mainScreen;
+      if (screen == nil) {
+        return false;
+      }
+
+      stream_restore_frame = stream_window.frame;
+      stream_restore_style_mask = stream_window.styleMask;
+      stream_restore_title_visibility = stream_window.titleVisibility;
+      stream_restore_titlebar_transparent =
+          stream_window.titlebarAppearsTransparent;
+      stream_restore_movable = stream_window.movable;
+      stream_restore_close_hidden =
+          [stream_window standardWindowButton:NSWindowCloseButton].hidden;
+      stream_restore_miniaturize_hidden =
+          [stream_window standardWindowButton:NSWindowMiniaturizeButton].hidden;
+      stream_restore_zoom_hidden =
+          [stream_window standardWindowButton:NSWindowZoomButton].hidden;
+      stream_restore_presentation_options = NSApp.presentationOptions;
+
+      stream_fullscreen = true;
+      stream_window.styleMask =
+          stream_restore_style_mask | NSWindowStyleMaskFullSizeContentView;
+      stream_window.titleVisibility = NSWindowTitleHidden;
+      stream_window.titlebarAppearsTransparent = YES;
+      stream_window.movable = NO;
+      SetTitlebarButtonsHidden(stream_window, YES);
+
+      NSApplicationPresentationOptions presentation_options =
+          stream_restore_presentation_options;
+      if ((presentation_options & (NSApplicationPresentationHideDock |
+                                   NSApplicationPresentationAutoHideDock)) ==
+          0) {
+        presentation_options |= NSApplicationPresentationAutoHideDock;
+      }
+      if ((presentation_options & (NSApplicationPresentationHideMenuBar |
+                                   NSApplicationPresentationAutoHideMenuBar)) ==
+          0) {
+        presentation_options |= NSApplicationPresentationAutoHideMenuBar;
+      }
+      NSApp.presentationOptions = presentation_options;
+      [stream_window setFrame:screen.frame display:YES animate:NO];
+      [stream_window makeKeyAndOrderFront:nil];
+    } else {
+      stream_fullscreen = false;
+      NSApp.presentationOptions = stream_restore_presentation_options;
+      stream_window.styleMask = stream_restore_style_mask;
+      stream_window.titleVisibility = stream_restore_title_visibility;
+      stream_window.titlebarAppearsTransparent =
+          stream_restore_titlebar_transparent;
+      stream_window.movable = stream_restore_movable;
+      [stream_window setFrame:stream_restore_frame display:YES animate:NO];
+      [stream_window standardWindowButton:NSWindowCloseButton].hidden =
+          stream_restore_close_hidden;
+      [stream_window standardWindowButton:NSWindowMiniaturizeButton].hidden =
+          stream_restore_miniaturize_hidden;
+      [stream_window standardWindowButton:NSWindowZoomButton].hidden =
+          stream_restore_zoom_hidden;
+      InstallStreamFullscreenButton(stream_window);
+      [stream_window makeKeyAndOrderFront:nil];
+    }
+
+    stream_window.contentView.alphaValue = 1.0;
+    stream_window.contentView.needsDisplay = YES;
+    [stream_window displayIfNeeded];
+    return true;
+  }
+}
+
+bool IsStreamWindowFullscreen() {
+  return stream_fullscreen;
+}
+
+std::string OpenNativeFileDialog(const std::string &title) {
+  @autoreleasepool {
+    NSOpenPanel *panel = [NSOpenPanel openPanel];
+    panel.canChooseFiles = YES;
+    panel.canChooseDirectories = NO;
+    panel.allowsMultipleSelection = NO;
+    panel.resolvesAliases = YES;
+
+    NSString *prompt =
+        [[NSString alloc] initWithBytes:title.data()
+                                 length:title.size()
+                               encoding:NSUTF8StringEncoding];
+    if (prompt != nil && prompt.length > 0) {
+      panel.title = prompt;
+      panel.message = prompt;
+    }
+
+    // tinyfiledialogs uses an external osascript process on macOS, so its
+    // chooser can appear without becoming the active window. Keep the picker
+    // inside CrossDesk and explicitly activate both the app and panel.
+    [NSApp activateIgnoringOtherApps:YES];
+    NSWindow *owner = stream_window ?: NSApp.keyWindow ?: NSApp.mainWindow;
+    if (owner != nil) {
+      [owner makeKeyAndOrderFront:nil];
+    }
+    NSScreen *target_screen = owner.screen ?: NSScreen.mainScreen;
+    CenterWindowOnScreen(panel, target_screen);
+    [panel makeKeyAndOrderFront:nil];
+
+    if ([panel runModal] != NSModalResponseOK || panel.URL == nil) {
+      return {};
+    }
+    const char *path = panel.URL.fileSystemRepresentation;
+    return path != nullptr ? std::string(path) : std::string{};
+  }
+}
+
+} // namespace crossdesk

src/gui/runtime/connection_runtime.cpp

@@ -200,8 +200,6 @@ int GuiRuntime::RequestSingleDevicePresence(const std::string &remote_id,
 }
 
 void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
-  SDL_FlushEvent(STREAM_REFRESH_EVENT);
-
   std::shared_ptr<std::vector<unsigned char>> frame_snapshot;
   int video_width = 0;
   int video_height = 0;
@@ -290,11 +288,6 @@ void GuiRuntime::WaitForThumbnailSaveTasks() {
 
 void GuiRuntime::ResetRemoteSessionResources(
     std::shared_ptr<RemoteSession> props) {
-  if (props->stream_texture_) {
-    SDL_DestroyTexture(props->stream_texture_);
-    props->stream_texture_ = nullptr;
-  }
-
   {
     std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
     props->front_frame_.reset();

src/gui/runtime/gui_runtime.cpp

@@ -168,10 +168,10 @@ void GuiRuntime::UpdateLabels() {
 
 
 void GuiRuntime::HandleRecentConnections() {
-  if (reload_recent_connections_ && main_renderer_) {
+  if (reload_recent_connections_ && thumbnail_) {
     uint32_t now_time = SDL_GetTicks();
     if (now_time - recent_connection_image_save_time_ >= 50) {
-      int ret = thumbnail_->LoadThumbnail(main_renderer_, recent_connections_,
+      int ret = thumbnail_->LoadThumbnail(recent_connections_,
                                           &recent_connection_image_width_,
                                           &recent_connection_image_height_);
       if (!ret) {

src/gui/runtime/peer_data_callbacks.cpp

@@ -14,6 +14,7 @@
 #include "device_controller.h"
 #include "file_transfer.h"
 #include "localization.h"
+#include "filesystem_utf8.h"
 #include "platform.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
@@ -90,7 +91,7 @@ void PeerEventHandler::OnReceiveDataBuffer(
     std::string configured_path =
         runtime->config_center_->GetFileTransferSavePath();
     if (!configured_path.empty()) {
-      receiver.SetOutputDir(std::filesystem::u8path(configured_path));
+      receiver.SetOutputDir(PathFromUtf8(configured_path));
     } else if (receiver.OutputDir().empty()) {
       receiver = FileReceiver(); // re-init with default desktop path
     }

src/gui/runtime/peer_event_handler.cpp

@@ -230,12 +230,6 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
         runtime->need_to_create_stream_window_ = true;
       }
       props->connection_established_ = true;
-      props->stream_render_rect_ = {
-          0, (int)runtime->title_bar_height_, (int)runtime->stream_window_width_,
-          (int)(runtime->stream_window_height_ - runtime->title_bar_height_)};
-      props->stream_render_rect_f_ = {
-          0.0f, runtime->title_bar_height_, runtime->stream_window_width_,
-          runtime->stream_window_height_ - runtime->title_bar_height_};
       runtime->start_keyboard_capturer_ = true;
       break;
     }
@@ -259,11 +253,6 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
         props->stream_cleanup_pending_ = true;
       }
 
-      SDL_Event event;
-      event.type = runtime->STREAM_REFRESH_EVENT;
-      event.user.data1 = props.get();
-      SDL_PushEvent(&event);
-
       runtime->focus_on_stream_window_ = false;
 
       break;

src/gui/runtime/peer_media_callbacks.cpp

@@ -70,12 +70,9 @@ void PeerEventHandler::OnReceiveVideoBuffer(
       props->video_size_ = video_frame->size;
 
       props->front_frame_.swap(props->back_frame_);
+      ++props->video_frame_sequence_;
     }
 
-    SDL_Event event;
-    event.type = runtime->STREAM_REFRESH_EVENT;
-    event.user.data1 = props;
-    SDL_PushEvent(&event);
     props->streaming_ = true;
 
     if (props->net_traffic_stats_button_pressed_) {

src/gui/runtime/remote_session.h

@@ -1,8 +1,6 @@
 #ifndef CROSSDESK_GUI_REMOTE_SESSION_H_
 #define CROSSDESK_GUI_REMOTE_SESSION_H_
 
-#include <SDL3/SDL.h>
-
 #include <atomic>
 #include <chrono>
 #include <cstddef>
@@ -16,7 +14,6 @@
 #include <vector>
 
 #include "display_info.h"
-#include "imgui.h"
 #include "minirtc.h"
 
 namespace crossdesk::gui_detail {
@@ -111,7 +108,7 @@ struct RemoteSession {
   double control_bar_button_pressed_time_ = 0;
   double net_traffic_stats_button_pressed_time_ = 0;
 
-  // Written by the decode callback thread and consumed by the SDL thread.
+  // Written by the decode callback thread and consumed by the UI thread.
   std::mutex video_frame_mutex_;
   std::shared_ptr<std::vector<unsigned char>> front_frame_;
   std::shared_ptr<std::vector<unsigned char>> back_frame_;
@@ -129,6 +126,7 @@ struct RemoteSession {
   int video_height_last_ = 0;
   int selected_display_ = 0;
   size_t video_size_ = 0;
+  uint64_t video_frame_sequence_ = 0;
   bool tab_selected_ = false;
   bool tab_opened_ = true;
   std::optional<float> pos_x_before_docked_;
@@ -146,15 +144,7 @@ struct RemoteSession {
   bool remote_service_available_ = false;
   std::string remote_interactive_stage_;
   std::vector<DisplayInfo> display_info_list_;
-  SDL_Texture *stream_texture_ = nullptr;
-  uint8_t *argb_buffer_ = nullptr;
-  int argb_buffer_size_ = 0;
-  SDL_FRect stream_render_rect_f_ = {0.0f, 0.0f, 0.0f, 0.0f};
-  SDL_Rect stream_render_rect_{};
-  SDL_Rect stream_render_rect_last_{};
-  ImVec2 control_window_pos_{};
-
-  // Shared by minirtc callbacks, SDL rendering and SDL audio callbacks.
+  // Shared by minirtc callbacks, Slint rendering and SDL audio callbacks.
   std::atomic<ConnectionStatus> connection_status_ = ConnectionStatus::Closed;
   TraversalMode traversal_mode_ = TraversalMode::UnknownMode;
   int fps_ = 0;

src/gui/runtime/runtime_state.h

@@ -91,6 +91,7 @@ struct PlatformIntegrationState {
   bool show_portable_service_prompt_suppressed_window_ = false;
   bool portable_service_do_not_remind_ = false;
   bool portable_service_prompt_suppressed_ = false;
+  bool portable_service_installed_ = false;
   std::atomic<PortableServiceInstallState> portable_service_install_state_{
       PortableServiceInstallState::idle};
   std::thread portable_service_install_thread_;

src/gui/ui/common.slint

@@ -0,0 +1,458 @@
+// The legacy client uses ImGui::StyleColorsLight(). Keep the structural line
+// colors in one place so the Slint renderer produces the same visual weight.
+export global ImGuiLineStyle {
+    out property <color> border: #0000004d;
+    out property <color> separator: #6363639e;
+    out property <color> divider: #0000007a;
+    out property <color> control-separator: #b2b2b2;
+}
+
+// ImGui loads a 32px font atlas and applies per-window font scales. These
+// logical sizes reproduce those visual tiers on Slint's HiDPI renderer.
+export global ImGuiFontStyle {
+    out property <length> base: 12px;
+    out property <length> section-title: 18px;
+    out property <length> panel-label: 17px;
+    out property <length> field-value: 22px;
+    out property <length> prominent: 16px;
+    out property <length> body: 11px;
+    out property <length> small: 10px;
+}
+
+// Font Awesome 6 Free Solid glyphs used by the legacy ImGui client. The font
+// data is registered for every Slint window by GuiApplication before show().
+export global FontAwesomeIcons {
+    out property <string> angle-down: "\u{f107}";
+    out property <string> angle-left: "\u{f104}";
+    out property <string> angle-right: "\u{f105}";
+    out property <string> angle-up: "\u{f106}";
+    out property <string> arrow-right-long: "\u{f178}";
+    out property <string> bars: "\u{f0c9}";
+    out property <string> check: "\u{f00c}";
+    out property <string> circle-arrow-up: "\u{f0aa}";
+    out property <string> compress: "\u{f066}";
+    out property <string> computer-mouse: "\u{f8cc}";
+    out property <string> copy: "\u{f0c5}";
+    out property <string> display: "\u{e163}";
+    out property <string> expand: "\u{f065}";
+    out property <string> eye: "\u{f06e}";
+    out property <string> eye-slash: "\u{f070}";
+    out property <string> folder-open: "\u{f07c}";
+    out property <string> keyboard: "\u{f11c}";
+    out property <string> minus: "\u{f068}";
+    out property <string> pen: "\u{f304}";
+    out property <string> signal: "\u{f012}";
+    out property <string> shield-halved: "\u{f3ed}";
+    out property <string> square-full: "\u{f45c}";
+    out property <string> trash-can: "\u{f2ed}";
+    out property <string> volume-high: "\u{f028}";
+    out property <string> volume-xmark: "\u{f6a9}";
+    out property <string> xmark: "\u{f00d}";
+}
+
+export component IconButton inherits Rectangle {
+    in property <string> icon;
+    in property <string> tooltip;
+    in property <bool> danger: false;
+    in property <length> icon-size: 16px;
+    in property <color> icon-color: #24272d;
+    in property <color> normal-background: transparent;
+    in property <color> hover-background: #edf0f5;
+    in property <color> pressed-background: #d9dde5;
+    in property <bool> slashed: false;
+    callback clicked;
+
+    width: 30px;
+    height: 30px;
+    background: touch.pressed ? (danger ? #d92d20 : root.pressed-background)
+                              : touch.has-hover ? (danger ? #f04438 : root.hover-background)
+                                                : root.normal-background;
+    border-radius: 4px;
+
+    Text {
+        text: root.icon;
+        color: touch.has-hover && root.danger ? white : root.icon-color;
+        font-family: "Font Awesome 6 Free";
+        font-weight: 900;
+        font-size: root.icon-size;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+
+    if root.slashed: Text {
+        text: "／";
+        color: touch.has-hover && root.danger ? white : root.icon-color;
+        font-size: root.icon-size + 7px;
+        font-weight: 700;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+
+    touch := TouchArea {
+        clicked => { root.clicked(); }
+    }
+
+    if touch.has-hover && root.tooltip != "": Rectangle {
+        x: min(root.width - self.width, 0px);
+        y: root.height + 3px;
+        width: tip.preferred-width + 12px;
+        height: 24px;
+        background: #22252be8;
+        border-radius: 4px;
+        z: 20;
+        tip := Text {
+            text: root.tooltip;
+            color: white;
+            font-size: ImGuiFontStyle.small;
+            horizontal-alignment: center;
+            vertical-alignment: center;
+        }
+    }
+}
+
+// Retained for non-font artwork. UI action icons use IconButton so the Slint
+// and ImGui clients share Font Awesome's glyph geometry.
+export component ImageButton inherits Rectangle {
+    in property <image> icon;
+    in property <string> tooltip;
+    in property <bool> danger: false;
+    in property <length> icon-width: 16px;
+    in property <length> icon-height: 16px;
+    callback clicked;
+
+    width: 30px;
+    height: 30px;
+    background: touch.pressed ? (danger ? #d92d20 : #d9dde5)
+                              : touch.has-hover ? (danger ? #f04438 : #edf0f5)
+                                                : transparent;
+    border-radius: 4px;
+
+    Image {
+        x: (parent.width - self.width) / 2;
+        y: (parent.height - self.height) / 2;
+        width: root.icon-width;
+        height: root.icon-height;
+        source: root.icon;
+        image-fit: contain;
+    }
+
+    touch := TouchArea {
+        clicked => { root.clicked(); }
+    }
+
+    if touch.has-hover && root.tooltip != "": Rectangle {
+        x: min(root.width - self.width, 0px);
+        y: root.height + 3px;
+        width: tip.preferred-width + 12px;
+        height: 24px;
+        background: #22252be8;
+        border-radius: 4px;
+        z: 20;
+        tip := Text {
+            text: root.tooltip;
+            color: white;
+            font-size: ImGuiFontStyle.small;
+            horizontal-alignment: center;
+            vertical-alignment: center;
+        }
+    }
+}
+
+export component CompactComboBox inherits Rectangle {
+    in property <[string]> model;
+    in-out property <int> current-index: 0;
+    in property <bool> enabled: true;
+    property <bool> popup-animation-enabled: false;
+    property <float> popup-progress: 0.0;
+    callback selected(int);
+
+    animate popup-progress {
+        duration: 160ms;
+        easing: ease-out;
+        enabled: root.popup-animation-enabled;
+    }
+
+    width: 73px;
+    height: 24px;
+    background: root.enabled ? white : #f1f1f1;
+    border-width: 1px;
+    border-color: #bfc2c7;
+    border-radius: 3px;
+
+    Text {
+        x: 5px;
+        width: parent.width - 24px;
+        text: root.model[root.current-index];
+        color: root.enabled ? #202124 : #8b8f95;
+        font-size: ImGuiFontStyle.body;
+        overflow: elide;
+        vertical-alignment: center;
+    }
+    Rectangle {
+        x: parent.width - 21px;
+        width: 20px;
+        height: parent.height - 2px;
+        y: 1px;
+        background: root.enabled ? #9bc9f8 : #d7d9dc;
+        Text {
+            text: FontAwesomeIcons.angle-down;
+            color: #202124;
+            font-family: "Font Awesome 6 Free";
+            font-weight: 900;
+            font-size: 10px;
+            horizontal-alignment: center;
+            vertical-alignment: center;
+            transform-rotation: combo-popup.is-open ? 180deg : 0deg;
+            animate transform-rotation {
+                duration: 140ms;
+                easing: ease-out;
+                enabled: combo-popup.is-open;
+            }
+        }
+    }
+    TouchArea {
+        enabled: root.enabled;
+        clicked => {
+            root.popup-animation-enabled = false;
+            root.popup-progress = 0.0;
+            combo-popup.show();
+            popup-open-timer.running = true;
+        }
+    }
+
+    // Start on the next frame so the native popup first renders at zero
+    // height, making the downward expansion visible on every backend.
+    popup-open-timer := Timer {
+        interval: 16ms;
+        running: false;
+        triggered => {
+            self.running = false;
+            if combo-popup.is-open {
+                root.popup-animation-enabled = true;
+                root.popup-progress = 1.0;
+            }
+        }
+    }
+
+    combo-popup := PopupWindow {
+        x: 0px;
+        y: root.height;
+        width: root.width;
+        height: root.model.length * 23px;
+        close-policy: close-on-click-outside;
+
+        Rectangle {
+            // Keep the reveal anchored to the popup's top edge while the
+            // content settles downward into its final position.
+            y: (1.0 - root.popup-progress) * -8px;
+            width: parent.width;
+            height: parent.height * root.popup-progress;
+            opacity: root.popup-progress;
+            background: white;
+            border-width: 1px;
+            border-color: #bfc2c7;
+            border-radius: 3px;
+            clip: true;
+            for choice[index] in root.model: Rectangle {
+                y: index * 23px;
+                width: parent.width;
+                height: 23px;
+                background: option-touch.has-hover ? #dbeafb : index == root.current-index ? #eef5fd : white;
+                Text { x: 5px; width: parent.width - 10px; text: choice; color: #202124; font-size: ImGuiFontStyle.body; overflow: elide; vertical-alignment: center; }
+                option-touch := TouchArea {
+                    clicked => {
+                        popup-open-timer.running = false;
+                        root.popup-animation-enabled = false;
+                        root.popup-progress = 0.0;
+                        root.current-index = index;
+                        root.selected(index);
+                        combo-popup.close();
+                    }
+                }
+            }
+            Rectangle {
+                width: parent.width;
+                height: parent.height;
+                background: transparent;
+                border-width: 1px;
+                border-color: #bfc2c7;
+                border-radius: 3px;
+                z: 2;
+            }
+        }
+    }
+}
+
+export component ImGuiCheckBox inherits Rectangle {
+    in-out property <bool> checked;
+    in property <bool> enabled: true;
+
+    width: 21px;
+    height: 21px;
+    background: root.enabled ? white : #f1f1f1;
+    border-width: 1px;
+    border-color: check-touch.has-hover && root.enabled ? #8cbef2 : #b9bdc2;
+    border-radius: 4px;
+    if root.checked: Text {
+        text: FontAwesomeIcons.check;
+        color: #2e86de;
+        font-family: "Font Awesome 6 Free";
+        font-weight: 900;
+        font-size: 16px;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+    check-touch := TouchArea {
+        enabled: root.enabled;
+        clicked => { root.checked = !root.checked; }
+    }
+}
+
+export component MiniToggleSwitch inherits Rectangle {
+    in-out property <bool> checked;
+    in property <bool> enabled: true;
+    callback toggled(bool);
+
+    width: 29px;
+    height: 16px;
+    background: !root.enabled ? (root.checked ? #6e9ddacc : #9a9a9acc)
+              : root.checked ? #2463c7 : #9a9a9a;
+    border-radius: 8px;
+    Rectangle {
+        x: root.checked ? parent.width - self.width - 2px : 2px;
+        y: 2px;
+        width: 12px;
+        height: 12px;
+        border-radius: 6px;
+        background: white;
+    }
+    TouchArea {
+        enabled: root.enabled;
+        clicked => { root.checked = !root.checked; root.toggled(root.checked); }
+    }
+}
+
+export component CompactButton inherits Rectangle {
+    in property <string> text;
+    in property <bool> primary: false;
+    in property <bool> enabled: true;
+    callback clicked;
+
+    width: 34px;
+    height: 24px;
+    background: !root.enabled ? #eceef0
+              : button-touch.pressed ? (root.primary ? #82b8f2 : #d8dadd)
+              : button-touch.has-hover ? (root.primary ? #b8d9fb : #f0f1f2)
+              : root.primary ? #a8d0fa : #e2e4e7;
+    border-width: 1px;
+    border-color: root.primary ? #9bc3ed : #c8cbd0;
+    border-radius: 3px;
+    Text {
+        text: root.text;
+        color: root.enabled ? #24272d : #8e9298;
+        font-size: ImGuiFontStyle.body;
+        overflow: elide;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+    button-touch := TouchArea { enabled: root.enabled; clicked => { root.clicked(); } }
+}
+
+export component PrimaryButton inherits Rectangle {
+    in property <string> text;
+    in property <bool> enabled: true;
+    callback clicked;
+
+    min-width: 72px;
+    height: 30px;
+    background: !root.enabled ? #b8c1d1
+              : touch.pressed ? #1849a9
+              : touch.has-hover ? #2970d6
+              : #2463c7;
+    border-radius: 5px;
+
+    Text {
+        text: root.text;
+        color: white;
+        font-size: ImGuiFontStyle.body;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+
+    touch := TouchArea {
+        enabled: root.enabled;
+        clicked => { root.clicked(); }
+    }
+}
+
+export component SecondaryButton inherits Rectangle {
+    in property <string> text;
+    in property <bool> enabled: true;
+    callback clicked;
+
+    min-width: 72px;
+    height: 30px;
+    background: !root.enabled ? #f1f2f4
+              : touch.pressed ? #dfe3e9
+              : touch.has-hover ? #f3f4f6 : white;
+    border-width: 1px;
+    border-color: #c9ced7;
+    border-radius: 5px;
+    clip: true;
+
+    Text {
+        text: root.text;
+        color: root.enabled ? #24272d : #949aa5;
+        font-size: ImGuiFontStyle.body;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+
+    touch := TouchArea {
+        enabled: root.enabled;
+        clicked => { root.clicked(); }
+    }
+}
+
+export component ToggleSwitch inherits Rectangle {
+    in-out property <bool> checked;
+    in property <bool> enabled: true;
+    callback toggled(bool);
+
+    width: 36px;
+    height: 20px;
+    background: !root.enabled ? #d0d5dd : root.checked ? #2463c7 : #98a2b3;
+    border-radius: self.height / 2;
+
+    Rectangle {
+        x: root.checked ? parent.width - self.width - 3px : 3px;
+        y: 3px;
+        width: 14px;
+        height: 14px;
+        border-radius: 7px;
+        background: white;
+        animate x { duration: 100ms; easing: ease-in-out; }
+    }
+
+    TouchArea {
+        enabled: root.enabled;
+        clicked => {
+            root.checked = !root.checked;
+            root.toggled(root.checked);
+        }
+    }
+}
+
+export component SectionTitle inherits Text {
+    color: #00000080;
+    font-size: ImGuiFontStyle.section-title;
+    font-weight: 500;
+    vertical-alignment: center;
+}
+
+export component DialogSurface inherits Rectangle {
+    background: white;
+    border-width: 1px;
+    border-color: ImGuiLineStyle.border;
+    border-radius: 8px;
+}

src/gui/ui/crossdesk_ui.slint

@@ -0,0 +1,5 @@
+// Single AOT entry point. Generating one header for the entire UI avoids
+// duplicate imported-component definitions when C++ uses all three windows.
+export { MainWindow, RecentConnection, UiStrings } from "main_window.slint";
+export { StreamWindow, StreamTab, FileTransferEntry, NetworkStatsRow, StreamStrings } from "stream_window.slint";
+export { ServerWindow, ControllerEntry } from "server_window.slint";

src/gui/ui/icons/arrow-right-white.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M2 9h13m-5-5 5 5-5 5" fill="none" stroke="#fff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/arrow-right.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 34 22"><path d="M3 11h25M20 3l8 8-8 8" fill="none" stroke="#050505" stroke-width="3.2" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/check.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="m2 8 3.2 3.2L14 2.8" fill="none" stroke="#2389e8" stroke-width="2.3" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/chevron-down.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 8"><path d="M1 2l4 4 4-4" fill="none" stroke="#111" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/chevron-left.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 14"><path d="m8 1-6 6 6 6" fill="none" stroke="#202124" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/chevron-right.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 14"><path d="m2 1 6 6-6 6" fill="none" stroke="#202124" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/chevron-up.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 12 9"><path d="m1 7 5-5 5 5" fill="none" stroke="#202124" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/></svg>

src/gui/ui/icons/close-white.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="M3 3l10 10M13 3L3 13" fill="none" stroke="#fff" stroke-width="1.7"/></svg>

src/gui/ui/icons/close.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="M3 3l10 10M13 3L3 13" fill="none" stroke="#000000" stroke-width="1"/></svg>

src/gui/ui/icons/compress.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M7 7H2m5 0V2m4 5h5m-5 0V2M7 11H2m5 0v5m4-5h5m-5 0v5" fill="none" stroke="#202124" stroke-width="1.5"/></svg>

src/gui/ui/icons/copy.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><rect x="6" y="3" width="9" height="11" rx="1.2" fill="#111"/><rect x="3" y="6" width="9" height="10" rx="1.2" fill="#111" stroke="#eff0f2" stroke-width="1.4"/></svg>

src/gui/ui/icons/expand.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M7 2H2v5M11 2h5v5M7 16H2v-5m9 5h5v-5" fill="none" stroke="#202124" stroke-width="1.5"/><path d="M2 2l5 5m9-5-5 5M2 16l5-5m9 5-5-5" stroke="#202124" stroke-width="1.3"/></svg>

src/gui/ui/icons/eye-slash.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M1.5 9s2.7-4.5 7.5-4.5S16.5 9 16.5 9 13.8 13.5 9 13.5 1.5 9 1.5 9Z" fill="none" stroke="#111" stroke-width="1.6"/><path d="M2 2l14 14" stroke="#111" stroke-width="2"/></svg>

src/gui/ui/icons/eye.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M1.5 9s2.7-4.5 7.5-4.5S16.5 9 16.5 9 13.8 13.5 9 13.5 1.5 9 1.5 9Z" fill="none" stroke="#111" stroke-width="1.8"/><circle cx="9" cy="9" r="2.4" fill="#111"/></svg>

src/gui/ui/icons/file-up.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M4 1h7l3 3v13H4V1Z" fill="none" stroke="#202124" stroke-width="1.4"/><path d="M11 1v4h4M9 14V8m-3 3 3-3 3 3" fill="none" stroke="#202124" stroke-width="1.4"/></svg>

src/gui/ui/icons/keyboard.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 16"><rect x="1" y="3" width="16" height="11" rx="1.5" fill="none" stroke="#202124" stroke-width="1.4"/><path d="M4 6h1m2 0h1m2 0h1m2 0h1M4 9h1m2 0h1m2 0h1m2 0h1M5 12h8" stroke="#202124" stroke-width="1.2" stroke-linecap="round"/></svg>

src/gui/ui/icons/maximize.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><rect x="3" y="3" width="10" height="10" fill="none" stroke="#000000" stroke-width="1"/></svg>

src/gui/ui/icons/menu.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="M2 4h12M2 8h12M2 12h12" fill="none" stroke="#000000" stroke-width="1" stroke-linecap="square"/></svg>

src/gui/ui/icons/minimize.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="M2 8h12" fill="none" stroke="#000000" stroke-width="1"/></svg>

src/gui/ui/icons/monitor.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><rect x="2" y="3" width="14" height="10" rx="1" fill="none" stroke="#202124" stroke-width="1.5"/><path d="M6 16h6M9 13v3" stroke="#202124" stroke-width="1.5"/></svg>

src/gui/ui/icons/mouse-off.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><rect x="4" y="1" width="10" height="16" rx="5" fill="none" stroke="#202124" stroke-width="1.4"/><path d="M2 2l14 14" stroke="#202124" stroke-width="1.7"/></svg>

src/gui/ui/icons/mouse.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 18"><rect x="3" y="1" width="10" height="16" rx="5" fill="none" stroke="#202124" stroke-width="1.5"/><path d="M8 2v5" stroke="#202124" stroke-width="1.5"/></svg>

src/gui/ui/icons/pen-white.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M3 12.8 11.9 4l2.2 2.2-8.8 8.9-3.1.7.8-3Zm9.7-9.6 1-1a1.4 1.4 0 0 1 2 0l.2.2a1.4 1.4 0 0 1 0 2l-1 1-2.2-2.2Z" fill="#fff"/></svg>

src/gui/ui/icons/pen.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M3 12.8 11.9 4l2.2 2.2-8.8 8.9-3.1.7.8-3Z" fill="#111"/><path d="m12.7 3.2 1-1a1.4 1.4 0 0 1 2 0l.2.2a1.4 1.4 0 0 1 0 2l-1 1-2.2-2.2Z" fill="#111"/></svg>

src/gui/ui/icons/stats.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M2 16V9h3v7H2Zm5 0V5h3v11H7Zm5 0V2h3v14h-3Z" fill="#202124"/></svg>

src/gui/ui/icons/trash-white.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M5 5h8l-.6 10H5.6L5 5Zm2-2h4l1 1H6l1-1ZM4 4h10v1H4V4Z" fill="#fff"/></svg>

src/gui/ui/icons/trash.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M5 5h8l-.6 10H5.6L5 5Zm2-2h4l1 1H6l1-1ZM4 4h10v1H4V4Z" fill="#111"/></svg>

src/gui/ui/icons/volume-off.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M2 7h3l4-4v12l-4-4H2V7Z" fill="#202124"/><path d="M12 6l4 6m0-6-4 6" stroke="#202124" stroke-width="1.5"/></svg>

src/gui/ui/icons/volume.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><path d="M2 7h3l4-4v12l-4-4H2V7Z" fill="#202124"/><path d="M12 6a4 4 0 0 1 0 6m2-8a7 7 0 0 1 0 10" fill="none" stroke="#202124" stroke-width="1.4" stroke-linecap="round"/></svg>

src/gui/ui/server_window.slint

@@ -0,0 +1,149 @@
+import { CompactComboBox, FontAwesomeIcons, IconButton, SecondaryButton, ImGuiLineStyle, ImGuiFontStyle } from "common.slint";
+
+export struct ControllerEntry {
+    remote-id: string,
+    display-name: string,
+}
+
+export component ServerWindow inherits Window {
+    title: "CrossDesk";
+    preferred-width: root.language-index == 0 ? 250px : root.language-index == 1 ? 330px : 430px;
+    preferred-height: 150px;
+    min-width: root.language-index == 0 ? 250px : root.language-index == 1 ? 330px : 430px;
+    max-width: root.language-index == 0 ? 250px : root.language-index == 1 ? 330px : 430px;
+    no-frame: true;
+    always-on-top: true;
+    background: transparent;
+    default-font-size: ImGuiFontStyle.base;
+
+    in property <[ControllerEntry]> controllers;
+    in property <[string]> controller-names;
+    in property <int> language-index: 0;
+    in-out property <int> selected-controller: 0;
+    in property <string> connection-label: "Connection status";
+    in property <string> connection-status: "";
+    in property <string> controller-label: "Controller";
+    in property <string> file-transfer-label: "File transfer";
+    in property <string> select-file-label: "Select file";
+    in property <bool> sending-file: false;
+    in property <bool> file-transfer-visible: false;
+    in property <float> file-progress: 0;
+    in property <string> file-progress-text: "";
+    in property <string> current-file-name: "";
+    in property <string> file-size-text: "";
+
+    callback title-drag(int, length, length);
+    callback toggle-collapsed(bool);
+    callback controller-selected(int);
+    callback select-file;
+    callback disconnect-controller;
+
+    private property <bool> collapsed: false;
+    private property <bool> transfer-hovered: false;
+
+    Rectangle {
+        width: root.width;
+        height: root.height;
+        background: white;
+        border-width: 1px;
+        border-color: ImGuiLineStyle.border;
+        border-radius: 8px;
+        clip: true;
+
+        Rectangle {
+            x: 0px;
+            y: 0px;
+            width: parent.width;
+            height: 30px;
+            background: #f8f9fb;
+            Rectangle { y: parent.height - 1px; height: 1px; background: ImGuiLineStyle.border; }
+            IconButton {
+                x: 0px;
+                y: 0px;
+                width: 30px; height: 30px;
+                icon: root.collapsed ? FontAwesomeIcons.angle-down : FontAwesomeIcons.angle-up;
+                icon-size: 12px;
+                clicked => { root.collapsed = !root.collapsed; root.toggle-collapsed(root.collapsed); }
+            }
+            drag := TouchArea {
+                x: 30px; width: parent.width - 30px;
+                property <int> phase: self.pressed ? 1 : 0;
+                changed phase => { root.title-drag(phase, self.mouse-x, self.mouse-y); }
+                moved => { if (self.pressed) { root.title-drag(2, self.mouse-x, self.mouse-y); } }
+            }
+        }
+
+        if !root.collapsed: Rectangle {
+            x: 12px; y: 38px; width: parent.width - 52px; height: 101px;
+            background: white; border-width: 1px; border-color: ImGuiLineStyle.border; border-radius: 5px;
+            VerticalLayout {
+                padding: 8px; spacing: 3px; alignment: start;
+                HorizontalLayout {
+                    height: 24px; spacing: 5px;
+                    Text { width: root.language-index == 0 ? 69px : 110px; text: root.controller-label; color: #434953; font-size: ImGuiFontStyle.body; vertical-alignment: center; overflow: elide; }
+                    CompactComboBox {
+                        width: root.language-index == 0 ? 108px : root.language-index == 1 ? 147px : 247px;
+                        model: root.controller-names;
+                        current-index <=> root.selected-controller;
+                        selected(index) => { root.controller-selected(index); }
+                    }
+                }
+                Rectangle { height: 1px; background: ImGuiLineStyle.separator; }
+                HorizontalLayout {
+                    height: 24px; spacing: 5px;
+                    Text { width: root.language-index == 0 ? 69px : 110px; text: root.connection-label; color: #434953; font-size: ImGuiFontStyle.body; vertical-alignment: center; overflow: elide; }
+                    Text { text: root.connection-status; color: #2463c7; font-size: ImGuiFontStyle.body; horizontal-alignment: left; vertical-alignment: center; overflow: elide; }
+                }
+                Rectangle { height: 1px; background: ImGuiLineStyle.separator; }
+                Rectangle {
+                    height: 24px;
+                    HorizontalLayout {
+                        y: 0px;
+                        width: parent.width;
+                        height: 24px;
+                        spacing: 5px;
+                        Text { width: root.language-index == 0 ? 69px : 110px; text: root.file-transfer-label; color: #434953; font-size: ImGuiFontStyle.body; vertical-alignment: center; overflow: elide; }
+                        SecondaryButton { width: root.language-index == 0 ? 78px : root.language-index == 1 ? 140px : 205px; height: 24px; text: root.select-file-label; clicked => { root.select-file(); } }
+                        Rectangle {
+                            visible: root.file-transfer-visible;
+                            width: 35px;
+                            Text {
+                                text: root.sending-file ? "↑ " + round(root.file-progress * 100) + "%" : "✓";
+                                color: root.sending-file ? #2463c7 : #25874b;
+                                font-size: ImGuiFontStyle.small;
+                                horizontal-alignment: center;
+                                vertical-alignment: center;
+                            }
+                            transfer-touch := TouchArea {
+                                changed has-hover => { root.transfer-hovered = self.has-hover; }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if !root.collapsed: IconButton {
+            x: parent.width - 34px; y: 38px; width: 24px; height: 101px;
+            icon: FontAwesomeIcons.xmark;
+            icon-size: 13px;
+            icon-color: white;
+            normal-background: #ef2b2d;
+            hover-background: #d92d20;
+            pressed-background: #b42318;
+            border-radius: 5px;
+            clicked => { root.disconnect-controller(); }
+        }
+        if root.file-transfer-visible && root.transfer-hovered: Rectangle {
+            x: 15px; y: 67px; width: root.width - 30px; height: 70px;
+            background: #22252bf2;
+            border-radius: 5px;
+            z: 20;
+            VerticalLayout {
+                padding: 8px; spacing: 3px;
+                Text { text: root.current-file-name; color: white; font-size: ImGuiFontStyle.small; overflow: elide; }
+                Text { text: root.file-size-text; color: #e1e4e8; font-size: ImGuiFontStyle.small; }
+                Text { text: round(root.file-progress * 100) + "%  " + root.file-progress-text; color: #e1e4e8; font-size: ImGuiFontStyle.small; }
+            }
+        }
+    }
+}

src/gui/ui/stream_window.slint

@@ -0,0 +1,649 @@
+import { ComboBox, ScrollView } from "std-widgets.slint";
+import { FontAwesomeIcons, IconButton, PrimaryButton, ImGuiLineStyle, ImGuiFontStyle } from "common.slint";
+
+export struct StreamTab {
+    remote-id: string,
+    title: string,
+    connected: bool,
+}
+
+export struct FileTransferEntry {
+    name: string,
+    status: string,
+    progress: float,
+    speed: string,
+    size: string,
+}
+
+export struct NetworkStatsRow {
+    label: string,
+    inbound: string,
+    outbound: string,
+    loss-rate: string,
+}
+
+export global StreamStrings {
+    in-out property <string> select-display: "Select Display";
+    in-out property <string> send-shortcut: "Send Shortcut";
+    in-out property <string> control-mouse: "Control Mouse";
+    in-out property <string> release-mouse: "Release Mouse";
+    in-out property <string> audio: "Audio Capture";
+    in-out property <string> mute: "Mute";
+    in-out property <string> select-file: "Select File to Send";
+    in-out property <string> show-stats: "Show Net Traffic Stats";
+    in-out property <string> hide-stats: "Hide Net Traffic Stats";
+    in-out property <string> fullscreen: "Fullscreen";
+    in-out property <string> exit-fullscreen: "Exit fullscreen";
+    in-out property <string> disconnect: "Disconnect";
+    in-out property <string> file-transfer: "File Transfer Progress";
+    in-out property <string> expand-control: "Expand Control Bar";
+    in-out property <string> collapse-control: "Collapse Control Bar";
+    in-out property <string> stats-in: "In";
+    in-out property <string> stats-out: "Out";
+    in-out property <string> stats-loss-rate: "Loss Rate";
+    in-out property <string> stats-resolution: "Res";
+    in-out property <string> stats-connection-mode: "Mode";
+}
+
+// The legacy ImGui control bar uses 24px buttons with Font Awesome rendered
+// at half of the 32px atlas size.  Keep this local to the stream window: the
+// shared IconButton is intentionally larger and is used by the other windows.
+component ControlBarButton inherits Rectangle {
+    in property <string> icon;
+    in property <string> badge: "";
+    in property <string> tooltip: "";
+    in property <bool> selected: false;
+    in property <bool> slashed: false;
+    in property <length> icon-size: 16px;
+    callback clicked;
+
+    width: 24px;
+    height: 24px;
+    background: touch.pressed ? #0f87fa
+                              : touch.has-hover ? #4296fa
+                                                : root.selected ? #4296fa : #4296fa66;
+    border-radius: 3px;
+
+    Text {
+        text: root.icon;
+        color: #24272d;
+        font-family: "Font Awesome 6 Free";
+        font-weight: 900;
+        font-size: root.icon-size;
+        horizontal-alignment: center;
+        vertical-alignment: center;
+    }
+
+    // Draw the selected display number over the center of the monitor glyph.
+    if root.badge != "": Text {
+        // Use the rendered badge size so one- and multi-digit IDs share the
+        // exact horizontal and vertical center of the button.
+        x: (parent.width - self.preferred-width) / 2 + 0.5px;
+        y: (parent.height - self.preferred-height) / 2 - 0.5px;
+        text: root.badge;
+        color: black;
+        font-size: 11px;
+    }
+
+    // Match the two offset diagonal strokes used by the ImGui mouse/audio
+    // disabled state instead of covering the glyph with a full-width slash.
+    if root.slashed: Rectangle {
+        x: 11px;
+        y: 0px;
+        width: 2px;
+        height: 24px;
+        background: black;
+        transform-rotation: -45deg;
+    }
+    if root.slashed: Rectangle {
+        x: 9.5px;
+        y: 1.5px;
+        width: 2px;
+        height: 24px;
+        background: touch.has-hover ? #4296fa : #b3d5fd;
+        transform-rotation: -45deg;
+    }
+
+    touch := TouchArea {
+        clicked => { root.clicked(); }
+    }
+}
+
+export component StreamWindow inherits Window {
+    title: "CrossDesk";
+    preferred-width: 1280px;
+    preferred-height: 720px;
+    min-width: 640px;
+    min-height: 360px;
+    no-frame: false;
+    background: black;
+    default-font-size: ImGuiFontStyle.base;
+
+    in property <[StreamTab]> tabs;
+    in-out property <int> selected-tab: 0;
+    in property <image> frame;
+    in property <bool> has-frame: false;
+    in property <string> status-text: "";
+    in property <string> receiving-text: "";
+    in property <[string]> displays;
+    in-out property <int> selected-display: 0;
+    in property <bool> mouse-control-enabled: true;
+    in property <bool> audio-enabled: true;
+    in property <bool> srtp-enabled: false;
+    in property <bool> fullscreen-enabled: false;
+    in property <bool> stats-visible: false;
+    in property <[NetworkStatsRow]> stats-rows;
+    in property <string> stats-fps: "0";
+    in property <string> stats-resolution: "";
+    in property <string> stats-connection-mode: "";
+    in property <bool> file-transfer-visible: false;
+    in property <[FileTransferEntry]> file-transfers;
+
+    callback select-tab(int);
+    callback reorder-tab(int, length, length);
+    callback close-tab(string);
+    callback switch-display(int);
+    callback send-shortcut(string);
+    callback toggle-mouse-control;
+    callback toggle-audio;
+    callback select-file;
+    callback close-file-transfer;
+    pure callback can-drop-file(data-transfer) -> bool;
+    callback file-dropped(data-transfer);
+    callback toggle-stats;
+    callback toggle-fullscreen;
+    callback disconnect;
+    callback pointer-input(PointerEventButton, PointerEventKind, length, length);
+    callback scroll-input(length, length, length, length);
+    callback key-input(string, bool, bool, bool, bool, bool);
+
+    private property <bool> control-expanded: true;
+    private property <bool> display-menu-open: false;
+    private property <bool> shortcut-menu-open: false;
+    private property <bool> control-docked-left: true;
+    private property <bool> control-dragging: false;
+    private property <length> control-drag-x: 0px;
+    // Start flush against the title/tab strip. This remains mutable so a
+    // manually dragged control bar keeps its chosen vertical position.
+    private property <length> control-pos-y: 0px;
+    private property <length> control-press-x: 0px;
+    private property <length> control-press-y: 0px;
+    private property <int> dragging-tab: -1;
+    callback begin-control-drag(length, length);
+    callback move-control-drag(length, length);
+    callback end-control-drag;
+
+    begin-control-drag(press-x, press-y) => {
+        // Capture the snapped position before switching x to control-drag-x.
+        // Otherwise a second press briefly restores the previous drag target
+        // and makes a plain click move the control bar.
+        let current-x = control.x;
+        let current-y = control.y;
+        root.control-drag-x = current-x;
+        // Store the pointer offset in the control bar, while all following
+        // pointer positions remain relative to the stationary video surface.
+        root.control-press-x = press-x - current-x;
+        root.control-press-y = press-y - current-y;
+        root.display-menu-open = false;
+        root.shortcut-menu-open = false;
+        root.control-dragging = true;
+    }
+    move-control-drag(pointer-x, pointer-y) => {
+        if root.control-dragging {
+            root.control-drag-x = min(max(0px, pointer-x - root.control-press-x), video.width - control.width);
+            root.control-pos-y = min(max(0px, pointer-y - root.control-press-y), video.height - control.height);
+        }
+    }
+    end-control-drag() => {
+        if root.control-dragging {
+            root.control-docked-left = root.control-drag-x + control.width / 2 < video.width / 2;
+            root.control-pos-y = min(max(0px, control.y), video.height - control.height);
+            root.control-dragging = false;
+        }
+    }
+
+    Rectangle {
+        width: root.width;
+        height: root.height;
+        background: black;
+
+        // Keep the ImGui tab strip behavior, including pointer-drag reordering.
+        Rectangle {
+            y: 0px;
+            height: root.tabs.length > 1 ? 30px : 0px;
+            visible: !root.fullscreen-enabled && root.tabs.length > 1;
+            background: #f1f2f4;
+            z: 10;
+            HorizontalLayout {
+                spacing: 1px;
+                for tab[index] in root.tabs: tab-item := Rectangle {
+                    width: min(190px, max(110px, (parent.width - 12px) / root.tabs.length));
+                    background: index == root.selected-tab ? white : tab-touch.has-hover || root.dragging-tab == index ? #e5e7eb : #d8dbe0;
+                    border-width: root.dragging-tab == index ? 1px : 0px;
+                    border-color: #2463c7;
+                    Rectangle {
+                        width: parent.width - 27px;
+                        height: parent.height;
+                        background: transparent;
+                        if root.srtp-enabled: Text {
+                            x: 0px;
+                            width: 12px;
+                            height: parent.height;
+                            text: FontAwesomeIcons.shield-halved;
+                            color: #30343b;
+                            font-family: "Font Awesome 6 Free";
+                            font-weight: 900;
+                            font-size: ImGuiFontStyle.base;
+                            horizontal-alignment: center;
+                            vertical-alignment: center;
+                        }
+                        Text {
+                            x: root.srtp-enabled ? 16px : 0px;
+                            width: parent.width - self.x;
+                            height: parent.height;
+                            text: tab.title;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.base;
+                            overflow: elide;
+                            vertical-alignment: center;
+                        }
+                    }
+                    Rectangle {
+                        y: parent.height - 2px;
+                        height: 2px;
+                        background: index == root.selected-tab ? #3b82f6 : transparent;
+                    }
+                    tab-touch := TouchArea {
+                        width: parent.width - 27px;
+                        changed pressed => {
+                            if (self.pressed) {
+                                root.dragging-tab = index;
+                            } else if (root.dragging-tab == index) {
+                                root.reorder-tab(index, tab-item.x + self.mouse-x, tab-item.width);
+                                root.dragging-tab = -1;
+                            }
+                        }
+                        clicked => { root.selected-tab = index; root.select-tab(index); }
+                    }
+                    IconButton {
+                        x: parent.width - 27px;
+                        y: 1px;
+                        width: 27px;
+                        height: 27px;
+                        z: 2;
+                        icon: FontAwesomeIcons.xmark;
+                        icon-size: 11px;
+                        icon-color: #555c66;
+                        danger: true;
+                        clicked => { root.close-tab(tab.remote-id); }
+                    }
+                }
+            }
+        }
+
+        video := Rectangle {
+            y: root.fullscreen-enabled ? 0px : (root.tabs.length > 1 ? 30px : 0px);
+            height: parent.height - self.y;
+            background: black;
+            clip: true;
+
+            frame-image := Image {
+                width: parent.width;
+                height: parent.height;
+                source: root.frame;
+                image-fit: contain;
+                visible: root.has-frame;
+            }
+
+            Text {
+                // A connection state and the frame-waiting state may change in
+                // the same UI tick. Render them through one text item so two
+                // independent labels can never occupy the center together.
+                visible: !root.has-frame && (root.receiving-text != "" || root.status-text != "");
+                text: root.receiving-text != "" ? root.receiving-text : root.status-text;
+                color: root.receiving-text != "" ? #ffffffea : white;
+                font-size: root.receiving-text != "" ? 14px : ImGuiFontStyle.prominent;
+                horizontal-alignment: center;
+                vertical-alignment: center;
+            }
+
+            drop-zone := DropArea {
+                can-drop(event) => {
+                    return root.can-drop-file(event.data) ? DragAction.copy : DragAction.none;
+                }
+                dropped(event) => {
+                    root.file-dropped(event.data);
+                    return DragAction.copy;
+                }
+            }
+
+            input-focus := FocusScope {
+                focus-on-click: true;
+                key-pressed(event) => {
+                    root.key-input(event.text, true, event.modifiers.control, event.modifiers.alt, event.modifiers.shift, event.modifiers.meta);
+                    accept
+                }
+                key-released(event) => {
+                    root.key-input(event.text, false, event.modifiers.control, event.modifiers.alt, event.modifiers.shift, event.modifiers.meta);
+                    accept
+                }
+                pointer := TouchArea {
+                    pointer-event(event) => {
+                        let over-control = self.mouse-x >= control.x
+                            && self.mouse-x <= control.x + control.width
+                            && self.mouse-y >= control.y
+                            && self.mouse-y <= control.y + control.height;
+                        if event.kind == PointerEventKind.down
+                            && event.button == PointerEventButton.left
+                            && over-control {
+                            root.begin-control-drag(self.mouse-x, self.mouse-y);
+                        } else if root.control-dragging
+                            && (event.kind == PointerEventKind.up
+                                || event.kind == PointerEventKind.cancel) {
+                            root.end-control-drag();
+                        } else if !root.control-dragging {
+                            root.pointer-input(event.button, event.kind, self.mouse-x, self.mouse-y);
+                        }
+                    }
+                    moved => {
+                        if root.control-dragging {
+                            root.move-control-drag(self.mouse-x, self.mouse-y);
+                        }
+                    }
+                    scroll-event(event) => {
+                        if self.mouse-x < control.x
+                            || self.mouse-x > control.x + control.width
+                            || self.mouse-y < control.y
+                            || self.mouse-y > control.y + control.height {
+                            root.scroll-input(event.delta-x, event.delta-y, self.mouse-x, self.mouse-y);
+                        }
+                        accept
+                    }
+                }
+            }
+
+            // Floating control bar, matching the original top-left overlay.
+            control := Rectangle {
+                x: root.control-dragging ? root.control-drag-x : root.control-docked-left ? 0px : parent.width - self.width;
+                y: min(max(0px, root.control-pos-y), parent.height - self.height);
+                width: root.control-expanded ? min(300px, parent.width) : 20px;
+                height: root.stats-visible && root.control-expanded ? min(180px, parent.height) : 38px;
+                background: white;
+                border-width: 1px;
+                border-color: ImGuiLineStyle.border;
+                border-radius: 6px;
+                z: 8;
+                clip: true;
+                // Keep width changes atomic. When docked right, animating both
+                // x and the clip width can leave newly revealed buttons outside
+                // Slint's damage region until they receive a hover repaint.
+                animate height { duration: 60ms; easing: ease-out; }
+
+                if root.control-expanded && !root.control-docked-left: Rectangle {
+                    x: 31px; y: 12px; width: 2px; height: 15px;
+                    background: ImGuiLineStyle.control-separator;
+                }
+
+                if root.control-expanded: display-button := ControlBarButton {
+                    x: root.control-docked-left ? 9px : 42px; y: 7px;
+                    icon: FontAwesomeIcons.display;
+                    badge: root.selected-display + 1;
+                    tooltip: StreamStrings.select-display;
+                    clicked => { root.display-menu-open = !root.display-menu-open; root.shortcut-menu-open = false; }
+                }
+                if root.control-expanded: shortcut-button := ControlBarButton {
+                    x: root.control-docked-left ? 41px : 74px; y: 7px;
+                    icon: FontAwesomeIcons.keyboard; tooltip: StreamStrings.send-shortcut;
+                    clicked => { root.shortcut-menu-open = !root.shortcut-menu-open; root.display-menu-open = false; }
+                }
+                if root.control-expanded: mouse-button := ControlBarButton {
+                    x: root.control-docked-left ? 73px : 106px; y: 7px;
+                    icon: FontAwesomeIcons.computer-mouse; slashed: !root.mouse-control-enabled;
+                    tooltip: root.mouse-control-enabled ? StreamStrings.release-mouse : StreamStrings.control-mouse;
+                    clicked => { root.toggle-mouse-control(); }
+                }
+                if root.control-expanded: audio-button := ControlBarButton {
+                    x: root.control-docked-left ? 105px : 138px; y: 7px;
+                    icon: FontAwesomeIcons.volume-high; slashed: !root.audio-enabled;
+                    tooltip: root.audio-enabled ? StreamStrings.mute : StreamStrings.audio;
+                    clicked => { root.toggle-audio(); }
+                }
+                if root.control-expanded: file-button := ControlBarButton {
+                    x: root.control-docked-left ? 137px : 170px; y: 7px;
+                    icon: FontAwesomeIcons.folder-open; tooltip: StreamStrings.select-file;
+                    clicked => { root.select-file(); }
+                }
+                if root.control-expanded: stats-button := ControlBarButton {
+                    x: root.control-docked-left ? 169px : 202px; y: 7px;
+                    icon: FontAwesomeIcons.signal; selected: root.stats-visible;
+                    tooltip: root.stats-visible ? StreamStrings.hide-stats : StreamStrings.show-stats;
+                    clicked => { root.toggle-stats(); }
+                }
+                if root.control-expanded: fullscreen-button := ControlBarButton {
+                    x: root.control-docked-left ? 201px : 234px; y: 7px;
+                    icon: root.fullscreen-enabled ? FontAwesomeIcons.compress : FontAwesomeIcons.expand;
+                    tooltip: root.fullscreen-enabled ? StreamStrings.exit-fullscreen : StreamStrings.fullscreen;
+                    clicked => { root.toggle-fullscreen(); }
+                }
+                if root.control-expanded: close-button := ControlBarButton {
+                    x: root.control-docked-left ? 233px : 266px; y: 7px;
+                    icon: FontAwesomeIcons.xmark; tooltip: StreamStrings.disconnect;
+                    clicked => { root.disconnect(); }
+                }
+
+                if root.control-expanded && root.control-docked-left: Rectangle {
+                    x: 267px; y: 12px; width: 2px; height: 15px;
+                    background: ImGuiLineStyle.control-separator;
+                }
+                collapse-button := ControlBarButton {
+                    x: root.control-expanded ? (root.control-docked-left ? 275px : 10px) : 2px;
+                    y: 7px;
+                    width: 15px;
+                    icon: root.control-expanded
+                          ? (root.control-docked-left ? FontAwesomeIcons.angle-left : FontAwesomeIcons.angle-right)
+                          : (root.control-docked-left ? FontAwesomeIcons.angle-right : FontAwesomeIcons.angle-left);
+                    tooltip: root.control-expanded ? StreamStrings.collapse-control : StreamStrings.expand-control;
+                    clicked => { root.control-expanded = !root.control-expanded; }
+                }
+
+                if root.stats-visible && root.control-expanded: stats-table := Rectangle {
+                    x: 14px;
+                    y: 38px;
+                    width: parent.width - 28px;
+                    height: 128px;
+                    background: transparent;
+                    private property <length> row-height: 16px;
+                    private property <length> label-column-width: 60px;
+                    private property <length> loss-column-width: 66px;
+                    private property <length> value-column-width:
+                        (self.width - self.label-column-width - self.loss-column-width) / 2;
+
+                    Rectangle {
+                        y: 0px;
+                        height: 1px;
+                        background: ImGuiLineStyle.border;
+                    }
+
+                    Rectangle {
+                        y: 0px;
+                        height: stats-table.row-height;
+                        Text {
+                            x: stats-table.label-column-width + 4px;
+                            width: stats-table.value-column-width - 8px;
+                            text: StreamStrings.stats-in;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                        }
+                        Text {
+                            x: stats-table.label-column-width + stats-table.value-column-width + 4px;
+                            width: stats-table.value-column-width - 8px;
+                            text: StreamStrings.stats-out;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                        }
+                        Text {
+                            x: stats-table.label-column-width + stats-table.value-column-width * 2 + 4px;
+                            width: stats-table.loss-column-width - 8px;
+                            text: StreamStrings.stats-loss-rate;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                            overflow: elide;
+                        }
+                        Rectangle {
+                            y: parent.height - 1px;
+                            height: 1px;
+                            background: ImGuiLineStyle.border;
+                        }
+                    }
+
+                    for row[index] in root.stats-rows: Rectangle {
+                        y: (index + 1) * stats-table.row-height;
+                        height: stats-table.row-height;
+                        Text {
+                            x: 4px;
+                            width: stats-table.label-column-width - 8px;
+                            text: row.label;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                        }
+                        Text {
+                            x: stats-table.label-column-width + 4px;
+                            width: stats-table.value-column-width - 8px;
+                            text: row.inbound;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                            overflow: elide;
+                        }
+                        Text {
+                            x: stats-table.label-column-width + stats-table.value-column-width + 4px;
+                            width: stats-table.value-column-width - 8px;
+                            text: row.outbound;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                            overflow: elide;
+                        }
+                        Text {
+                            x: stats-table.label-column-width + stats-table.value-column-width * 2 + 4px;
+                            width: stats-table.loss-column-width - 8px;
+                            text: row.loss-rate;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                            overflow: elide;
+                        }
+                        Rectangle {
+                            y: parent.height - 1px;
+                            height: 1px;
+                            background: ImGuiLineStyle.border;
+                        }
+                    }
+
+                    for metric[index] in [
+                        { label: "FPS:", value: root.stats-fps },
+                        { label: StreamStrings.stats-resolution + ":", value: root.stats-resolution },
+                        { label: StreamStrings.stats-connection-mode + ":", value: root.stats-connection-mode },
+                    ]: Rectangle {
+                        y: (index + 5) * stats-table.row-height;
+                        height: stats-table.row-height;
+                        Text {
+                            x: 4px;
+                            width: stats-table.label-column-width - 8px;
+                            text: metric.label;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                        }
+                        Text {
+                            x: stats-table.label-column-width + 4px;
+                            width: stats-table.value-column-width - 8px;
+                            text: metric.value;
+                            color: #30343b;
+                            font-size: ImGuiFontStyle.small;
+                            vertical-alignment: center;
+                            overflow: elide;
+                        }
+                        Rectangle {
+                            y: parent.height - 1px;
+                            height: 1px;
+                            background: ImGuiLineStyle.border;
+                        }
+                    }
+                }
+            }
+
+            if root.display-menu-open: Rectangle {
+                x: control.x + (root.control-docked-left ? 9px : 42px); y: control.y + 40px; width: 180px; height: min(180px, root.displays.length * 30px + 8px);
+                background: white; border-width: 1px; border-color: ImGuiLineStyle.border; border-radius: 5px; z: 11;
+                VerticalLayout {
+                    padding: 4px; spacing: 1px;
+                    for display[index] in root.displays: Rectangle {
+                        height: 29px;
+                        background: display-touch.has-hover || index == root.selected-display ? #e8eef9 : transparent;
+                        Text { x: 8px; text: display; color: #30343b; font-size: ImGuiFontStyle.body; vertical-alignment: center; }
+                        display-touch := TouchArea { clicked => { root.selected-display = index; root.switch-display(index); root.display-menu-open = false; } }
+                    }
+                }
+            }
+
+            if root.shortcut-menu-open: Rectangle {
+                x: control.x + (root.control-docked-left ? 41px : 74px); y: control.y + 40px; width: 150px; height: 68px;
+                background: white; border-width: 1px; border-color: ImGuiLineStyle.border; border-radius: 5px; z: 11;
+                VerticalLayout {
+                    padding: 4px; spacing: 1px;
+                    for shortcut in ["Ctrl+Alt+Del", "Win+L"]: Rectangle {
+                        height: 29px; background: shortcut-touch.has-hover ? #e8eef9 : transparent;
+                        Text { x: 8px; text: shortcut; color: #30343b; font-size: ImGuiFontStyle.body; vertical-alignment: center; }
+                        shortcut-touch := TouchArea { clicked => { root.send-shortcut(shortcut); root.shortcut-menu-open = false; } }
+                    }
+                }
+            }
+
+            // Transfer progress overlay at bottom-left.
+            if root.file-transfer-visible: Rectangle {
+                x: 18px; y: parent.height - min(210px, parent.height * 0.35); width: min(430px, parent.width * 0.6); height: min(190px, parent.height * 0.32);
+                background: #fffffff0; border-width: 1px; border-color: ImGuiLineStyle.border; border-radius: 6px; z: 7;
+                Text { x: 12px; y: 8px; text: StreamStrings.file-transfer; color: #2d3138; font-weight: 600; }
+                IconButton { x: parent.width - 32px; y: 1px; icon: FontAwesomeIcons.xmark; icon-size: 13px; clicked => { root.close-file-transfer(); } }
+                ScrollView {
+                    x: 10px; y: 32px; width: parent.width - 20px; height: parent.height - 42px;
+                    VerticalLayout {
+                        // Slint's ScrollView draws its vertical scrollbar over
+                        // the viewport. Reserve a gutter so transfer content
+                        // never extends underneath it.
+                        padding-right: 16px;
+                        spacing: 8px;
+                        for entry in root.file-transfers: VerticalLayout {
+                            spacing: 3px;
+                            HorizontalLayout { height: 18px; Text { text: entry.name; color: #30343b; font-size: ImGuiFontStyle.body; overflow: elide; } Text { width: 80px; text: entry.status; color: #5c6470; font-size: ImGuiFontStyle.body; horizontal-alignment: right; } }
+                            Rectangle {
+                                height: 7px;
+                                background: #dfe3e8;
+                                border-radius: 3px;
+
+                                Rectangle {
+                                    x: 0px;
+                                    y: 0px;
+                                    width: parent.width * max(0, min(1, entry.progress));
+                                    height: parent.height;
+                                    background: #2463c7;
+                                    border-radius: 3px;
+                                }
+                            }
+                            HorizontalLayout {
+                                height: 14px;
+                                Text { text: round(entry.progress * 100) + "%  " + entry.speed; color: #6a717c; font-size: ImGuiFontStyle.small; }
+                                Text { text: entry.size; color: #6a717c; font-size: ImGuiFontStyle.small; horizontal-alignment: right; }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/gui/views/windows/about_window.cpp

@@ -123,7 +123,7 @@ int GuiApplication::AboutWindow() {
     }
 
     std::string copyright_text = "© 2025 by JUNKUN DI. All rights reserved.";
-    std::string license_text = "Licensed under GNU LGPL v3.";
+    std::string license_text = "Licensed under GNU GPL v3.";
     ImGui::SetCursorPosX(about_window_width * 0.1f);
     ImGui::Text("%s", copyright_text.c_str());
     ImGui::SetCursorPosX(about_window_width * 0.1f);
@@ -145,4 +145,4 @@ int GuiApplication::AboutWindow() {
   }
   return 0;
 }
-} // namespace crossdesk
+} // namespace crossdesk

src/thumbnail/thumbnail.cpp

@@ -18,71 +18,12 @@
 
 #define STB_IMAGE_IMPLEMENTATION
 #include "stb_image.h"
+
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb_image_write.h"
 
 namespace crossdesk {
 
-bool LoadTextureFromMemory(const void* data, size_t data_size,
-                           SDL_Renderer* renderer, SDL_Texture** out_texture,
-                           int* out_width, int* out_height) {
-  int image_width = 0;
-  int image_height = 0;
-  int channels = 4;
-  unsigned char* image_data =
-      stbi_load_from_memory((const unsigned char*)data, (int)data_size,
-                            &image_width, &image_height, NULL, 4);
-  if (image_data == nullptr) {
-    LOG_ERROR("Failed to load image: [{}]", stbi_failure_reason());
-    return false;
-  }
-
-  // ABGR
-  int pitch = image_width * channels;
-  SDL_Surface* surface =
-      SDL_CreateSurfaceFrom(image_width, image_height, SDL_PIXELFORMAT_RGBA32,
-                            (void*)image_data, pitch);
-  if (surface == nullptr) {
-    LOG_ERROR("Failed to create SDL surface: [{}]", SDL_GetError());
-    return false;
-  }
-
-  SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
-  if (texture == nullptr) {
-    LOG_ERROR("Failed to create SDL texture: [{}]", SDL_GetError());
-  }
-
-  *out_texture = texture;
-  *out_width = image_width;
-  *out_height = image_height;
-
-  SDL_DestroySurface(surface);
-  stbi_image_free(image_data);
-
-  return true;
-}
-
-bool LoadTextureFromFile(const char* file_name, SDL_Renderer* renderer,
-                         SDL_Texture** out_texture, int* out_width,
-                         int* out_height) {
-  std::filesystem::path file_path(file_name);
-  if (!std::filesystem::exists(file_path)) return false;
-  std::ifstream file(file_path, std::ios::binary);
-  if (!file) return false;
-  file.seekg(0, std::ios::end);
-  size_t file_size = file.tellg();
-  file.seekg(0, std::ios::beg);
-  if (file_size == -1) return false;
-  char* file_data = new char[file_size];
-  if (!file_data) return false;
-  file.read(file_data, file_size);
-  bool ret = LoadTextureFromMemory(file_data, file_size, renderer, out_texture,
-                                   out_width, out_height);
-  delete[] file_data;
-
-  return ret;
-}
-
 void ScaleNv12ToABGR(char* src, int src_w, int src_h, int dst_w, int dst_h,
                      char* dst_rgba) {
   uint8_t* y = reinterpret_cast<uint8_t*>(src);
@@ -201,17 +142,12 @@ int Thumbnail::SaveToThumbnail(const char* yuv420p, int width, int height,
 }
 
 int Thumbnail::LoadThumbnail(
-    SDL_Renderer* renderer,
     std::vector<std::pair<std::string, Thumbnail::RecentConnection>>&
         recent_connections,
     int* width, int* height) {
-  for (auto& it : recent_connections) {
-    if (it.second.texture != nullptr) {
-      SDL_DestroyTexture(it.second.texture);
-      it.second.texture = nullptr;
-    }
-  }
   recent_connections.clear();
+  if (width) *width = thumbnail_width_;
+  if (height) *height = thumbnail_height_;
 
   std::vector<std::filesystem::path> image_paths =
       FindThumbnailPath(save_path_);
@@ -270,17 +206,40 @@ int Thumbnail::LoadThumbnail(
       recent_connection.remote_host_name = remote_host_name;
       recent_connection.password = password;
       recent_connection.remember_password = remember_password;
+      recent_connection.image_path = image_path;
       recent_connections.emplace_back(
           std::make_pair(original_image_name, recent_connection));
-      LoadTextureFromFile(image_path.c_str(), renderer,
-                          &(recent_connections.back().second.texture), width,
-                          height);
     }
     return 0;
   }
   return 0;
 }
 
+bool Thumbnail::DecodeImage(const std::filesystem::path& image_path,
+                            std::vector<unsigned char>* rgba, int* width,
+                            int* height) const {
+  if (!rgba || !width || !height) {
+    return false;
+  }
+
+  int channels = 0;
+  unsigned char* pixels =
+      stbi_load(image_path.string().c_str(), width, height, &channels, 4);
+  if (!pixels || *width <= 0 || *height <= 0) {
+    if (pixels) {
+      stbi_image_free(pixels);
+    }
+    rgba->clear();
+    return false;
+  }
+
+  const size_t byte_count =
+      static_cast<size_t>(*width) * static_cast<size_t>(*height) * 4;
+  rgba->assign(pixels, pixels + byte_count);
+  stbi_image_free(pixels);
+  return true;
+}
+
 int Thumbnail::DeleteThumbnail(const std::string& filename_keyword) {
   for (const auto& entry : std::filesystem::directory_iterator(save_path_)) {
     if (entry.is_regular_file()) {

src/thumbnail/thumbnail.h

@@ -7,8 +7,6 @@
 #ifndef _THUMBNAIL_H_
 #define _THUMBNAIL_H_
 
-#include <SDL3/SDL.h>
-
 #include <filesystem>
 #include <map>
 #include <unordered_map>
@@ -19,7 +17,7 @@ namespace crossdesk {
 class Thumbnail {
  public:
   struct RecentConnection {
-    SDL_Texture* texture = nullptr;
+    std::filesystem::path image_path;
     std::string remote_id;
     std::string remote_host_name;
     std::string password;
@@ -41,11 +39,14 @@ class Thumbnail {
                       const std::string& password);
 
   int LoadThumbnail(
-      SDL_Renderer* renderer,
       std::vector<std::pair<std::string, Thumbnail::RecentConnection>>&
           recent_connections,
       int* width, int* height);
 
+  bool DecodeImage(const std::filesystem::path& image_path,
+                   std::vector<unsigned char>* rgba, int* width,
+                   int* height) const;
+
   int DeleteThumbnail(const std::string& filename_keyword);
 
   int DeleteAllFilesInDirectory();
@@ -88,4 +89,4 @@ class Thumbnail {
   unsigned char decryptedtext_[64];
 };
 }  // namespace crossdesk
-#endif
+#endif

tests/connection_status_protocol_test.cpp

@@ -63,8 +63,10 @@ int main() {
       ReadFile(repo_root / "submodules/minirtc/src/api/minirtc.h");
   const std::string peer_connection =
       ReadFile(repo_root / "submodules/minirtc/src/pc/peer_connection.cpp");
-  const std::string connection_status_window = ReadFile(
-      repo_root / "src/gui/views/windows/connection_status_window.cpp");
+  const std::string main_window =
+      ReadFile(repo_root / "src/gui/ui/main_window.slint");
+  const std::string gui_application =
+      ReadFile(repo_root / "src/gui/application/gui_application.cpp");
   const std::string runtime_state_h =
       ReadFile(repo_root / "src/gui/runtime/runtime_state.h");
   const std::string remote_session_h =
@@ -83,8 +85,14 @@ int main() {
                           "\"Device offline\"");
   ok &= ExpectNotContains("peer_connection.cpp", peer_connection,
                           "ConnectionStatus::DeviceOffline");
-  ok &= ExpectContains("connection_status_window.cpp", connection_status_window,
-                       "localization::device_offline");
+  ok &= ExpectContains("main_window.slint", main_window,
+                       "in property <bool> connection-dialog-open: false;");
+  ok &= ExpectContains("main_window.slint", main_window,
+                       "text: root.connection-status-text;");
+  ok &= ExpectContains("gui_application.cpp", gui_application,
+                       "case ConnectionStatus::RemoteUnavailable:");
+  ok &= ExpectContains("gui_application.cpp", gui_application,
+                       "return localization::device_offline[language];");
   ok &= ExpectContains("runtime_state.h", runtime_state_h,
                        "pending_presence_probe_started_at_");
   ok &= ExpectContains("remote_session.h", remote_session_h,

tests/display_popup_hover_state_test.cpp

@@ -10,8 +10,7 @@ std::filesystem::path FindRepoRoot() {
   std::filesystem::path current = std::filesystem::current_path();
   while (!current.empty()) {
     if (std::filesystem::exists(current / "xmake.lua") &&
-        std::filesystem::exists(current /
-                                "src/gui/views/toolbars/control_bar.cpp")) {
+        std::filesystem::exists(current / "src/gui/ui/stream_window.slint")) {
       return current;
     }
     current = current.parent_path();
@@ -19,88 +18,51 @@ std::filesystem::path FindRepoRoot() {
   return {};
 }
 
-std::string ReadFile(const std::filesystem::path& path) {
+std::string ReadFile(const std::filesystem::path &path) {
   std::ifstream file(path, std::ios::binary);
   if (!file) {
     return {};
   }
-
   std::ostringstream stream;
   stream << file.rdbuf();
   return stream.str();
 }
 
-bool ExpectContains(const char* name, const std::string& value,
-                    const std::string& expected) {
+bool ExpectContains(const char *name, const std::string &value,
+                    const std::string &expected) {
   if (value.find(expected) != std::string::npos) {
     return true;
   }
-
   std::cerr << name << " missing expected text: " << expected << "\n";
   return false;
 }
 
-bool ExpectNotContains(const char* name, const std::string& value,
-                       const std::string& unexpected) {
+bool ExpectNotContains(const char *name, const std::string &value,
+                       const std::string &unexpected) {
   if (value.find(unexpected) == std::string::npos) {
     return true;
   }
-
   std::cerr << name << " contains unexpected text: " << unexpected << "\n";
   return false;
 }
 
-bool ExpectContainsAtLeast(const char* name, const std::string& value,
-                           const std::string& expected, size_t min_count) {
+bool ExpectContainsAtLeast(const char *name, const std::string &value,
+                           const std::string &expected, size_t min_count) {
   size_t count = 0;
   size_t pos = 0;
   while ((pos = value.find(expected, pos)) != std::string::npos) {
     ++count;
     pos += expected.size();
   }
-
   if (count >= min_count) {
     return true;
   }
-
   std::cerr << name << " expected at least " << min_count
             << " occurrences of: " << expected << ", found " << count << "\n";
   return false;
 }
 
-bool ExpectResetBeforeDisplayPopup(const std::string& value) {
-  const std::string reset = "props->display_selectable_hovered_ = false;";
-  const std::string popup = "ImGui::BeginPopup(\"display\")";
-  const size_t reset_pos = value.find(reset);
-  const size_t popup_pos = value.find(popup);
-
-  if (reset_pos != std::string::npos && popup_pos != std::string::npos &&
-      reset_pos < popup_pos) {
-    return true;
-  }
-
-  std::cerr << "control_bar.cpp must clear display_selectable_hovered_ before "
-               "checking the display popup\n";
-  return false;
-}
-
-bool ExpectResetBeforeShortcutPopup(const std::string& value) {
-  const std::string reset = "props->shortcut_selectable_hovered_ = false;";
-  const std::string popup = "ImGui::BeginPopup(\"shortcut\")";
-  const size_t reset_pos = value.find(reset);
-  const size_t popup_pos = value.find(popup);
-
-  if (reset_pos != std::string::npos && popup_pos != std::string::npos &&
-      reset_pos < popup_pos) {
-    return true;
-  }
-
-  std::cerr << "control_bar.cpp must clear shortcut_selectable_hovered_ before "
-               "checking the shortcut popup\n";
-  return false;
-}
-
-}  // namespace
+} // namespace
 
 int main() {
   const std::filesystem::path repo_root = FindRepoRoot();
@@ -109,75 +71,61 @@ int main() {
     return 1;
   }
 
-  const std::string control_bar =
-      ReadFile(repo_root / "src/gui/views/toolbars/control_bar.cpp");
+  const std::string stream =
+      ReadFile(repo_root / "src/gui/ui/stream_window.slint");
+  const std::string common = ReadFile(repo_root / "src/gui/ui/common.slint");
+  const std::string application =
+      ReadFile(repo_root / "src/gui/application/gui_application.cpp");
 
   bool ok = true;
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "props->display_selectable_hovered_ = false;");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "ImGui::IsWindowHovered("
-                       "ImGuiHoveredFlags_RootAndChildWindows)");
-  ok &= ExpectResetBeforeDisplayPopup(control_bar);
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "props->shortcut_selectable_hovered_ =");
-  ok &= ExpectResetBeforeShortcutPopup(control_bar);
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "void ShowControlBarTooltip(const std::string& text)");
-  ok &= ExpectContainsAtLeast("control_bar.cpp", control_bar,
-                              "ShowControlBarTooltip(", 10);
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::select_display"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::send_shortcut"
-                       "[localization_language_index_]");
-  ok &= ExpectNotContains("control_bar.cpp", control_bar,
-                          "ShowControlBarTooltip("
-                          "props->mouse_control_button_label_)");
-  ok &= ExpectNotContains("control_bar.cpp", control_bar,
-                          "ShowControlBarTooltip("
-                          "props->audio_capture_button_label_)");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::select_file"
-                       "[localization_language_index_]");
-  ok &= ExpectNotContains("control_bar.cpp", control_bar,
-                          "ShowControlBarTooltip("
-                          "props->net_traffic_stats_button_label_)");
-  ok &= ExpectNotContains("control_bar.cpp", control_bar,
-                          "ShowControlBarTooltip("
-                          "props->fullscreen_button_label_)");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::release_mouse"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::control_mouse"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::audio_capture"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::mute[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::hide_net_traffic_stats"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::show_net_traffic_stats"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::exit_fullscreen"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::fullscreen"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::disconnect"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::expand_control_bar"
-                       "[localization_language_index_]");
-  ok &= ExpectContains("control_bar.cpp", control_bar,
-                       "localization::collapse_control_bar"
-                       "[localization_language_index_]");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "private property <bool> display-menu-open: false;");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.shortcut-menu-open = false;");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "if root.display-menu-open: Rectangle");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "display-touch.has-hover");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.switch-display(index)");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "if root.shortcut-menu-open: Rectangle");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "shortcut-touch.has-hover");
+
+  ok &= ExpectContains("common.slint", common,
+                       "if touch.has-hover && root.tooltip != \"\": Rectangle");
+  ok &= ExpectContainsAtLeast("stream_window.slint", stream, "tooltip:", 9);
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "tooltip: StreamStrings.select-display");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "tooltip: StreamStrings.send-shortcut");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.mouse-control-enabled ? StreamStrings.release-mouse : StreamStrings.control-mouse");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.audio-enabled ? StreamStrings.mute : StreamStrings.audio");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "tooltip: StreamStrings.select-file");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.stats-visible ? StreamStrings.hide-stats : StreamStrings.show-stats");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.fullscreen-enabled ? StreamStrings.exit-fullscreen : StreamStrings.fullscreen");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "tooltip: StreamStrings.disconnect");
+  ok &= ExpectContains("stream_window.slint", stream,
+                       "root.control-expanded ? StreamStrings.collapse-control : StreamStrings.expand-control");
+
+  ok &= ExpectContains("gui_application.cpp", application,
+                       "set_select_display(");
+  ok &= ExpectContains("gui_application.cpp", application,
+                       "set_show_stats(");
+  ok &= ExpectContains("gui_application.cpp", application,
+                       "set_expand_control(");
+  ok &= ExpectContains("gui_application.cpp", application,
+                       "set_collapse_control(");
+  ok &= ExpectContains("gui_application.cpp", application,
+                       "(*ui_->stream)->global<ui::StreamStrings>()");
+  ok &= ExpectNotContains("gui_application.cpp", application,
+                          "#include <imgui");
   return ok ? 0 : 1;
 }

tests/slint_ui_smoke_test.cpp

@@ -0,0 +1,144 @@
+#include "crossdesk_ui.h"
+
+#include <cassert>
+#include <memory>
+#include <string>
+#include <vector>
+
+int main() {
+  auto window = crossdesk::ui::MainWindow::create();
+  auto stream = crossdesk::ui::StreamWindow::create();
+  auto server = crossdesk::ui::ServerWindow::create();
+  window->set_local_id("123 456 789");
+  window->set_local_password("123456");
+  window->set_connection_dialog_open(true);
+  window->set_connection_password_required(true);
+  window->set_settings_session_active(true);
+  window->set_portable_service_settings_visible(true);
+  assert(std::string(window->get_local_id()) == "123 456 789");
+  assert(window->get_connection_dialog_open());
+  assert(window->get_connection_password_required());
+  assert(window->get_settings_session_active());
+  assert(window->get_portable_service_settings_visible());
+  window->set_settings_open(true);
+  window->set_about_open(true);
+  assert(window->get_settings_open());
+  assert(window->get_about_open());
+  window->set_remote_id_input("987654321");
+  window->invoke_reset_remote_id();
+  assert(std::string(window->get_remote_id_input()).empty());
+
+  std::vector<crossdesk::ui::RecentConnection> connections;
+  crossdesk::ui::RecentConnection connection;
+  connection.remote_id = "987654321";
+  connection.display_name = "Office PC";
+  connection.host_name = "office-pc";
+  connection.online = true;
+  connections.emplace_back(std::move(connection));
+  window->set_recent_connections(
+      std::make_shared<slint::VectorModel<crossdesk::ui::RecentConnection>>(
+          std::move(connections)));
+  assert(window->get_recent_connections()->row_count() == 1);
+
+  bool connect_requested = false;
+  window->on_connect_requested([&](slint::SharedString remote_id) {
+    connect_requested = std::string(remote_id) == "987654321";
+  });
+  window->invoke_connect_requested("987654321");
+  assert(connect_requested);
+
+  bool password_submitted = false;
+  window->on_connection_submit_password(
+      [&](slint::SharedString password, bool remember) {
+        password_submitted = std::string(password) == "654321" && remember;
+      });
+  window->invoke_connection_submit_password("654321", true);
+  assert(password_submitted);
+
+  crossdesk::ui::StreamTab tab;
+  tab.remote_id = "123456789";
+  tab.title = "Remote host";
+  tab.connected = true;
+  stream->set_tabs(
+      std::make_shared<slint::VectorModel<crossdesk::ui::StreamTab>>(
+          std::vector{tab}));
+  assert(stream->get_tabs()->row_count() == 1);
+
+  bool tab_reordered = false;
+  stream->on_reorder_tab([&](int index, float x, float width) {
+    tab_reordered = index == 0 && x == 120.0f && width == 110.0f;
+  });
+  stream->invoke_reorder_tab(0, 120.0f, 110.0f);
+  assert(tab_reordered);
+
+  crossdesk::ui::FileTransferEntry transfer;
+  transfer.name = "archive.zip";
+  transfer.status = "Sending";
+  transfer.progress = 0.5f;
+  transfer.speed = "1.0 mbps";
+  transfer.size = "2.00 MB";
+  stream->set_file_transfers(
+      std::make_shared<
+          slint::VectorModel<crossdesk::ui::FileTransferEntry>>(
+          std::vector{transfer}));
+  stream->set_file_transfer_visible(true);
+  crossdesk::ui::NetworkStatsRow video_stats;
+  video_stats.label = "Video";
+  video_stats.inbound = "427 kbps";
+  video_stats.outbound = "5 kbps";
+  video_stats.loss_rate = "0%";
+  stream->set_stats_rows(
+      std::make_shared<
+          slint::VectorModel<crossdesk::ui::NetworkStatsRow>>(
+          std::vector{video_stats}));
+  stream->set_stats_fps("53");
+  stream->set_stats_resolution("3024x1964");
+  stream->set_stats_connection_mode("Direct");
+  stream->set_stats_visible(true);
+  stream->set_fullscreen_enabled(true);
+  assert(stream->get_file_transfers()->row_count() == 1);
+  assert(stream->get_file_transfer_visible());
+  assert(stream->get_stats_rows()->row_count() == 1);
+  assert(std::string(stream->get_stats_fps()) == "53");
+  assert(std::string(stream->get_stats_resolution()) == "3024x1964");
+  assert(std::string(stream->get_stats_connection_mode()) == "Direct");
+  assert(stream->get_stats_visible());
+  assert(stream->get_fullscreen_enabled());
+
+  bool display_switched = false;
+  stream->on_switch_display(
+      [&](int index) { display_switched = index == 1; });
+  stream->invoke_switch_display(1);
+  assert(display_switched);
+
+  auto &stream_strings = stream->global<crossdesk::ui::StreamStrings>();
+  stream_strings.set_select_display("Select Display");
+  stream_strings.set_expand_control("Expand Control Bar");
+  assert(std::string(stream_strings.get_select_display()) == "Select Display");
+  assert(std::string(stream_strings.get_expand_control()) ==
+         "Expand Control Bar");
+
+  crossdesk::ui::ControllerEntry controller;
+  controller.remote_id = "123456789";
+  controller.display_name = "Remote host";
+  server->set_controllers(
+      std::make_shared<slint::VectorModel<crossdesk::ui::ControllerEntry>>(
+          std::vector{controller}));
+  server->set_file_transfer_visible(true);
+  server->set_sending_file(true);
+  server->set_file_progress(0.5f);
+  server->set_current_file_name("archive.zip");
+  server->set_file_size_text("1.00 MB / 2.00 MB");
+  assert(server->get_controllers()->row_count() == 1);
+  assert(server->get_file_transfer_visible());
+  assert(server->get_sending_file());
+  assert(server->get_file_progress() == 0.5f);
+
+  bool controller_selected = false;
+  server->on_controller_selected(
+      [&](int index) { controller_selected = index == 0; });
+  server->invoke_controller_selected(0);
+  assert(controller_selected);
+
+  return 0;
+}

tests/windows_sas_guard_test.cpp

@@ -70,8 +70,10 @@ int main() {
     return 1;
   }
 
-  const std::string control_bar =
-      ReadFile(repo_root / "src/gui/views/toolbars/control_bar.cpp");
+  const std::string stream_window =
+      ReadFile(repo_root / "src/gui/ui/stream_window.slint");
+  const std::string gui_application =
+      ReadFile(repo_root / "src/gui/application/gui_application.cpp");
   const std::string windows_service_runtime =
       ReadFile(repo_root / "src/gui/runtime/windows_service_runtime.cpp");
   const std::string runtime_state_h =
@@ -87,13 +89,16 @@ int main() {
   ok &= ExpectTrue(
       "secure desktop input routing",
       crossdesk::IsSecureDesktopInteractionRequired("secure-desktop"));
-  ok &= ExpectNotContains("control_bar.cpp", control_bar,
-                          "CanSendSecureAttentionSequence("
-                          "props->remote_interactive_stage_)");
-  ok &= ExpectNotContains("control_bar.cpp", control_bar,
-                          "ImGui::BeginDisabled();\n"
-                          "      }\n"
-                          "      if (ImGui::Selectable(sas_label.c_str()))");
+  ok &= ExpectContains("stream_window.slint", stream_window,
+                       "for shortcut in [\"Ctrl+Alt+Del\", \"Win+L\"]");
+  ok &= ExpectContains("stream_window.slint", stream_window,
+                       "root.send-shortcut(shortcut)");
+  ok &= ExpectContains("gui_application.cpp", gui_application,
+                       "std::string(shortcut) == \"Ctrl+Alt+Del\"");
+  ok &= ExpectContains("gui_application.cpp", gui_application,
+                       "ServiceCommandFlag::send_sas");
+  ok &= ExpectContains("gui_application.cpp", gui_application,
+                       "ServiceCommandFlag::lock_workstation");
   ok &= ExpectNotContains("windows_service_runtime.cpp",
                           windows_service_runtime, "sas_requires_lock_screen");
   ok &= ExpectContains("runtime_state.h", runtime_state_h,

thirdparty/slint/xmake.lua

@@ -0,0 +1,48 @@
+package("slint")
+    set_homepage("https://slint.dev")
+    set_description("Declarative GUI toolkit for C++")
+    set_license("GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0")
+
+    add_urls("https://github.com/slint-ui/slint/archive/refs/tags/v$(version).tar.gz",
+             "https://github.com/slint-ui/slint.git")
+    add_versions("1.17.1", "68222567f8c70ff677cd4a98cd94fb4765ac0f797eb8f8608a646911c908dc2a")
+
+    add_configs("shared", {description = "Build the Slint runtime as a shared library", default = true, type = "boolean", readonly = true})
+
+    add_deps("cmake")
+
+    on_load(function(package)
+        package:add("includedirs", "include/slint")
+        if package:is_plat("windows") then
+            package:add("links", "slint_cpp.dll")
+        else
+            package:add("links", "slint_cpp")
+        end
+    end)
+
+    on_install("windows", "linux", "macosx", function(package)
+        local configs = {
+            "-DSLINT_BUILD_TESTING=OFF",
+            "-DSLINT_BUILD_EXAMPLES=OFF",
+            "-DSLINT_FEATURE_INTERPRETER=OFF",
+            "-DSLINT_FEATURE_LIVE_PREVIEW=OFF",
+            "-DSLINT_FEATURE_TESTING=OFF",
+            "-DSLINT_FEATURE_SYSTEM_TESTING=OFF",
+            "-DSLINT_FEATURE_MCP=OFF",
+            "-DSLINT_FEATURE_BACKEND_QT=OFF",
+            "-DSLINT_FEATURE_RENDERER_SKIA=OFF",
+            "-DSLINT_FEATURE_RENDERER_SKIA_OPENGL=OFF",
+            "-DSLINT_FEATURE_RENDERER_SKIA_VULKAN=OFF",
+            "-DSLINT_FEATURE_RENDERER_FEMTOVG=ON",
+            "-DSLINT_FEATURE_RENDERER_SOFTWARE=ON",
+            "-DSLINT_STYLE=fluent",
+            "-DBUILD_SHARED_LIBS=ON"
+        }
+        import("package.tools.cmake").install(package, configs)
+    end)
+
+    on_test(function(package)
+        assert(package:has_cxxincludes("slint.h", {configs = {languages = "c++20"}}), "Slint C++ headers are unusable")
+        assert(os.isfile(path.join(package:installdir(), "bin", is_host("windows") and "slint-compiler.exe" or "slint-compiler")), "slint-compiler was not installed")
+    end)
+package_end()

thirdparty/xmake.lua

@@ -1 +1 @@
-includes("cpp-httplib")
+includes("cpp-httplib", "slint")

xmake.lua

@@ -1,8 +1,9 @@
 set_project("crossdesk")
-set_license("LGPL-3.0")
+set_license("GPL-3.0-only")
 
 includes("xmake/options.lua")
 includes("xmake/platform.lua")
+includes("xmake/rules/slint.lua")
 includes("xmake/targets.lua")
 
 setup_options_and_dependencies()

xmake/options.lua

@@ -30,6 +30,8 @@ function setup_options_and_dependencies()
     option_end()
 
     add_rules("mode.release", "mode.debug")
+    -- Preserve the existing codebase/toolchain contract. Slint targets opt in to
+    -- C++20 locally because its generated C++ API requires it.
     set_languages("c++17")
     set_encodings("utf-8")
 
@@ -41,7 +43,9 @@ function setup_options_and_dependencies()
     add_defines("USE_CUDA=" .. (is_config("USE_CUDA", true) and "1" or "0"))
     add_defines("USE_WAYLAND=" .. (is_config("USE_WAYLAND", true) and "1" or "0"))
     add_defines("USE_DRM=" .. (is_config("USE_DRM", true) and "1" or "0"))
-    add_defines("CROSSDESK_PORTABLE=" .. (is_config("CROSSDESK_PORTABLE", true) and "1" or "0"))
+    if is_config("CROSSDESK_PORTABLE", true) then
+        add_defines("CROSSDESK_PORTABLE=1")
+    end
 
     if is_mode("debug") then
         add_defines("CROSSDESK_DEBUG")
@@ -49,7 +53,8 @@ function setup_options_and_dependencies()
 
     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("slint 1.17.1", {configs = {shared = true}})
+    add_requires("libsdl3 3.2.26", {configs = {shared = false}})
     add_requires("openssl3 3.3.2", {system = false})
     add_requires("nlohmann_json 3.11.3")
     add_requires("cpp-httplib v0.26.0", {configs = {ssl = true}})

xmake/platform.lua

@@ -26,8 +26,9 @@ end
 function setup_platform_settings()
     if is_os("windows") then
         add_requires("libyuv", "miniaudio 0.11.21")
+        add_defines("NOMINMAX")
         add_links("Shell32", "dwmapi", "User32", "kernel32",
-            "SDL3-static", "gdi32", "winmm", "setupapi", "version",
+            "gdi32", "winmm", "setupapi", "version",
             "Imm32", "iphlpapi", "d3d11", "dxgi")
         add_cxflags("/WX")
         set_runtimes("MT")
@@ -35,7 +36,7 @@ function setup_platform_settings()
         add_links("pulse-simple", "pulse")
         add_requires("libyuv")
         add_syslinks("pthread", "dl")
-        add_links("SDL3", "asound", "X11", "Xext", "Xrender", "Xft", "Xtst",
+        add_links("asound", "X11", "Xext", "Xrender", "Xft", "Xtst",
             "Xrandr", "Xfixes")
         add_existing_include_dirs({
             "/usr/include/freetype2",
@@ -77,7 +78,6 @@ function setup_platform_settings()
 
         add_cxflags("-Wno-unused-variable")
     elseif is_os("macosx") then
-        add_links("SDL3")
         add_ldflags("-Wl,-ld_classic")
         add_cxflags("-Wno-unused-variable")
         add_frameworks("Cocoa", "OpenGL", "IOSurface", "ScreenCaptureKit",

xmake/rules/slint.lua

@@ -0,0 +1,53 @@
+rule("slint")
+    set_extensions(".slint")
+
+    on_config(function(target)
+        local rule_name = "slint"
+        if target:rule("c++.build") then
+            local cpp_rule = target:rule("c++.build"):clone()
+            cpp_rule:add("deps", rule_name, {order = true})
+            target:rule_add(cpp_rule)
+        end
+
+        local outputdir = path.join(target:autogendir(), "rules", "slint")
+        os.mkdir(outputdir)
+        target:add("includedirs", outputdir, {public = true})
+
+        local sourcebatch = target:sourcebatches()[rule_name]
+        if sourcebatch and sourcebatch.sourcefiles then
+            for _, sourcefile in ipairs(sourcebatch.sourcefiles) do
+                -- Make the generated include discoverable during C++ dependency
+                -- scanning; the real contents are produced before compilation.
+                os.touch(path.join(outputdir, path.basename(sourcefile) .. ".h"))
+            end
+        end
+    end)
+
+    before_buildcmd_file(function(target, batchcmds, sourcefile, opt)
+        local package = assert(target:pkg("slint"), "the slint package is required by this target")
+        local compiler = path.join(package:installdir(), "bin", is_host("windows") and "slint-compiler.exe" or "slint-compiler")
+        local outputdir = path.join(target:autogendir(), "rules", "slint")
+        local outputfile = path.join(outputdir, path.basename(sourcefile) .. ".h")
+        local depfile = outputfile .. ".d"
+
+        batchcmds:show_progress(opt.progress, "${color.build.object}generating.slint %s", sourcefile)
+        batchcmds:mkdir(outputdir)
+        batchcmds:vrunv(compiler, {
+            sourcefile,
+            "-f", "cpp",
+            "-o", outputfile,
+            "--depfile", depfile,
+            "--style", "fluent",
+            "--embed-resources=embed-files",
+            "--cpp-namespace", "crossdesk::ui"
+        })
+        -- The compiler's depfile is useful to external build systems, while
+        -- xmake needs imported .slint files registered explicitly so editing a
+        -- component regenerates the umbrella header without a forced rebuild.
+        for _, dependency in ipairs(os.files(path.join(path.directory(sourcefile), "*.slint"))) do
+            batchcmds:add_depfiles(dependency)
+        end
+        batchcmds:set_depmtime(os.mtime(outputfile))
+        batchcmds:set_depcache(target:dependfile(outputfile))
+    end)
+rule_end()

xmake/targets.lua

@@ -1,5 +1,5 @@
 function setup_targets()
-    add_packages("spdlog", "imgui", "nlohmann_json")
+    add_packages("spdlog", "libsdl3", "nlohmann_json")
 
     includes("submodules", "thirdparty")
 
@@ -18,6 +18,7 @@ function setup_targets()
         set_kind("object")
         add_deps("rd_log")
         add_files("src/common/*.cpp")
+        remove_files("src/common/rounded_corner_button.cpp")
         if is_os("macosx") then
             add_files("src/common/*.mm")
         end
@@ -33,6 +34,7 @@ function setup_targets()
     target("path_manager_portable_test")
         set_kind("binary")
         set_default(false)
+        set_policy("build.ccache", false)
         add_defines("CROSSDESK_PORTABLE=1")
         add_includedirs("src/path_manager")
         add_files("tests/path_manager_portable_test.cpp",
@@ -81,6 +83,15 @@ function setup_targets()
         set_default(false)
         add_files("tests/display_popup_hover_state_test.cpp")
 
+    target("slint_ui_smoke_test")
+        set_kind("binary")
+        set_languages("c++20")
+        set_default(false)
+        add_packages("slint")
+        add_rules("slint")
+        add_files("src/gui/ui/crossdesk_ui.slint")
+        add_files("tests/slint_ui_smoke_test.cpp")
+
     target("version_checker_test")
         set_kind("binary")
         set_default(false)
@@ -209,24 +220,31 @@ function setup_targets()
 
     target("gui")
         set_kind("object")
+        set_languages("c++20")
+        -- spdlog 1.14 bundles fmt 10, whose consteval parser is rejected by
+        -- current Apple Clang in C++20 mode. Keep the established dependency
+        -- version and use fmt's supported runtime-parser fallback here.
+        add_defines("FMT_CONSTEVAL=")
+        add_packages("slint", {public = true})
         add_packages("libyuv", "tinyfiledialogs")
+        add_rules("slint")
         add_defines("CROSSDESK_VERSION=\"" .. (get_config("CROSSDESK_VERSION") or "Unknown") .. "\"")
         add_deps("rd_log", "common", "assets", "config_center", "minirtc",
             "path_manager", "screen_capturer", "speaker_capturer",
             "device_controller", "thumbnail", "version_checker", "tools")
-        add_files("src/gui/render.cpp", "src/gui/application/*.cpp",
+        add_files("src/gui/render.cpp", "src/gui/application/gui_application.cpp",
+            "src/gui/application/portable_service_integration.cpp",
             "src/gui/runtime/*.cpp",
             "src/gui/features/devices/*.cpp", "src/gui/features/input/*.cpp",
             "src/gui/features/clipboard/*.cpp", "src/gui/features/file_transfer/*.cpp",
-            "src/gui/features/settings/*.cpp", "src/gui/views/panels/*.cpp",
-            "src/gui/views/toolbars/*.cpp", "src/gui/views/windows/*.cpp")
+            "src/gui/features/settings/*.cpp", "src/gui/ui/crossdesk_ui.slint")
         add_includedirs("src/gui", {public = true})
         if is_os("windows") then
             add_files("src/gui/platform/tray/win_tray.cpp")
             add_includedirs("src/service/windows", {public = true})
         elseif is_os("macosx") then
-            add_files("src/gui/runtime/*.mm", "src/gui/views/windows/*.mm",
-                "src/gui/platform/tray/*.mm")
+            add_files("src/gui/runtime/*.mm", "src/gui/platform/tray/*.mm",
+                "src/gui/platform/window_drag_mac.mm")
         elseif is_os("linux") then
             add_files("src/gui/platform/tray/linux_tray.cpp")
         end