diff --git a/.github/workflows/build-depends.yml b/.github/workflows/build-depends.yml
index fdd09c425545..fb5b5f4d4a99 100644
--- a/.github/workflows/build-depends.yml
+++ b/.github/workflows/build-depends.yml
@@ -170,8 +170,8 @@ jobs:
         uses: actions/cache/restore@v5
         with:
           path: depends/sources
-          key: depends-sources-${{ hashFiles('depends/packages/*') }}
-          restore-keys: depends-sources-
+          key: depends-sources-v2-${{ hashFiles('depends/packages/*') }}
+          restore-keys: depends-sources-v2-
 
       - name: Restore SDKs cache
         id: sdk-cache
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 52811ebc8276..7dc94ae9e8b5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -227,8 +227,7 @@ jobs:
     if: |
       vars.SKIP_LINUX64 == '' ||
       vars.SKIP_LINUX64_ASAN == '' ||
-      vars.SKIP_LINUX64_FUZZ == '' ||
-      vars.SKIP_LINUX64_SQLITE == ''
+      vars.SKIP_LINUX64_FUZZ == ''
     with:
       build-target: linux64
       container-path: ${{ needs.container.outputs.path }}
@@ -263,6 +262,18 @@ jobs:
       runs-on: ${{ needs.check-skip.outputs['runner-amd64'] }}
       runs-on-check: ${{ needs.check-skip.outputs['runner-check-skip'] }}
 
+  depends-linux64_platform_gui:
+    name: x86_64-pc-linux-gnu_platform_gui
+    uses: ./.github/workflows/build-depends.yml
+    needs: [check-skip, container, cache-sources]
+    if: ${{ vars.SKIP_LINUX64_SQLITE == '' }}
+    with:
+      build-target: linux64_platform_gui
+      container-path: ${{ needs.container.outputs.path }}
+      base-image-digest: ${{ needs.check-skip.outputs.base-image-digest }}
+      runs-on: ${{ needs.check-skip.outputs['runner-amd64'] }}
+      runs-on-check: ${{ needs.check-skip.outputs['runner-check-skip'] }}
+
   depends-mac:
     name: x86_64-apple-darwin
     uses: ./.github/workflows/build-depends.yml
@@ -387,15 +398,15 @@ jobs:
   src-linux64_sqlite:
     name: linux64_sqlite-build
     uses: ./.github/workflows/build-src.yml
-    needs: [check-skip, container, depends-linux64]
+    needs: [check-skip, container, depends-linux64_platform_gui]
     if: ${{ vars.SKIP_LINUX64_SQLITE == '' }}
     with:
       build-target: linux64_sqlite
       container-path: ${{ needs.container.outputs.path }}
-      depends-key: ${{ needs.depends-linux64.outputs.key }}
-      depends-host: ${{ needs.depends-linux64.outputs.host }}
-      depends-dep-opts: ${{ needs.depends-linux64.outputs.dep-opts }}
-      depends-artifact: ${{ needs.depends-linux64.outputs.built-artifact }}
+      depends-key: ${{ needs.depends-linux64_platform_gui.outputs.key }}
+      depends-host: ${{ needs.depends-linux64_platform_gui.outputs.host }}
+      depends-dep-opts: ${{ needs.depends-linux64_platform_gui.outputs.dep-opts }}
+      depends-artifact: ${{ needs.depends-linux64_platform_gui.outputs.built-artifact }}
       runs-on: ${{ needs.check-skip.outputs['runner-amd64'] }}
     secrets: *remote-ccache-auth
 
diff --git a/.github/workflows/cache-depends-sources.yml b/.github/workflows/cache-depends-sources.yml
index d8fb54b67ee9..7681d2a5b9ba 100644
--- a/.github/workflows/cache-depends-sources.yml
+++ b/.github/workflows/cache-depends-sources.yml
@@ -31,15 +31,23 @@ jobs:
           allow-unsafe-pr-checkout: true
           persist-credentials: false
 
+      # v2: caches from before the Platform GUI step below lack its sources.
       - name: Check for cached sources
         id: cache-check
         uses: actions/cache@v5
         with:
           path: depends/sources
-          key: depends-sources-${{ hashFiles('depends/packages/*') }}
-          restore-keys: depends-sources-
+          key: depends-sources-v2-${{ hashFiles('depends/packages/*') }}
+          restore-keys: depends-sources-v2-
           lookup-only: true
 
       - name: Download sources
         if: steps.cache-check.outputs.cache-hit != 'true'
         run: make -C depends download
+
+      # The linux64_platform_gui depends job runs on x86_64, but this runner
+      # may not: name the build machine, since the Rust toolchain and protoc
+      # archives are chosen by it. download-linux would not pass BUILD on.
+      - name: Download Platform GUI sources for x86_64 Linux
+        if: steps.cache-check.outputs.cache-hit != 'true'
+        run: make -C depends download-one PLATFORM_GUI=1 BUILD=x86_64-pc-linux-gnu HOST=x86_64-unknown-linux-gnu
diff --git a/ci/dash/build_src.sh b/ci/dash/build_src.sh
index 2184966c28eb..e7db41d27345 100755
--- a/ci/dash/build_src.sh
+++ b/ci/dash/build_src.sh
@@ -54,6 +54,10 @@ if [ "${RUN_STDLIB_PATH_CHECK}" = "true" ]; then
   make -C src --jobs=1 check-stdlib-paths
 fi
 
+if [ "${RUN_CHECK_NO_RUST}" = "true" ]; then
+  "${BASE_ROOT_DIR}/contrib/devtools/check-no-rust.py" src/dashd src/dash-cli src/dash-tx src/dash-util src/dash-wallet src/test/fuzz/fuzz
+fi
+
 if [ -n "$USE_VALGRIND" ]; then
     echo "valgrind in USE!"
     "${BASE_ROOT_DIR}/ci/test/wrap-valgrind.sh"
diff --git a/ci/dash/matrix.sh b/ci/dash/matrix.sh
index 26ea6d1fc10f..7fdf2b20b849 100755
--- a/ci/dash/matrix.sh
+++ b/ci/dash/matrix.sh
@@ -30,6 +30,8 @@ elif [ "$BUILD_TARGET" = "linux64_multiprocess" ]; then
   source ./ci/test/00_setup_env_native_multiprocess.sh
 elif [ "$BUILD_TARGET" = "linux64_nowallet" ]; then
   source ./ci/test/00_setup_env_native_nowallet_libbitcoinkernel.sh
+elif [ "$BUILD_TARGET" = "linux64_platform_gui" ]; then
+  source ./ci/test/00_setup_env_native_platform_gui.sh
 elif [ "$BUILD_TARGET" = "linux64_sqlite" ]; then
   source ./ci/test/00_setup_env_native_sqlite.sh
 elif [ "$BUILD_TARGET" = "linux64_tsan" ]; then
diff --git a/ci/test/00_setup_env_native_platform_gui.sh b/ci/test/00_setup_env_native_platform_gui.sh
new file mode 100755
index 000000000000..6fc4c8cd2d5a
--- /dev/null
+++ b/ci/test/00_setup_env_native_platform_gui.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+#
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C.UTF-8
+
+# Depends with dash-sdk-cxx (PLATFORM_GUI=1); linux64_sqlite builds against it.
+export CONTAINER_NAME=ci_native_platform_gui
+export HOST=x86_64-pc-linux-gnu
+export DEP_OPTS="PLATFORM_GUI=1"
diff --git a/ci/test/00_setup_env_native_sqlite.sh b/ci/test/00_setup_env_native_sqlite.sh
index 8af6d3fd9ae9..32f42e300a7e 100755
--- a/ci/test/00_setup_env_native_sqlite.sh
+++ b/ci/test/00_setup_env_native_sqlite.sh
@@ -11,3 +11,4 @@ export PACKAGES="python3-zmq qtbase5-dev qttools5-dev-tools libdbus-1-dev libhar
 export DEP_OPTS="NO_BDB=1 NO_UPNP=1 DEBUG=1"
 export GOAL="install"
 export BITCOIN_CONFIG="--enable-zmq --enable-reduce-exports --with-sqlite --without-bdb CC=gcc-11 CXX=g++-11"
+export RUN_CHECK_NO_RUST="true"
diff --git a/configure.ac b/configure.ac
index d36c49ebfdf6..cb2a2126aee9 100644
--- a/configure.ac
+++ b/configure.ac
@@ -307,6 +307,14 @@ if test "$enable_miner" = "yes"; then
     AC_DEFINE(ENABLE_MINER, 1, [Define this symbol if in-wallet miner should be enabled])
 fi
 
+AC_ARG_ENABLE([platform-gui],
+    [AS_HELP_STRING([--enable-platform-gui],
+                    [enable Dash Platform (usernames, DashPay contacts) in the GUI; requires the GUI, the wallet and the Dash Platform SDK's C++ binding (dash-sdk-cxx) built by depends with PLATFORM_GUI=1 (default is no)])],
+    [enable_platform_gui=$enableval],
+    [enable_platform_gui=no])
+AC_ARG_VAR([PLATFORM_CXX_CFLAGS], [C++ compiler flags for dash-sdk-cxx, overriding pkg-config])
+AC_ARG_VAR([PLATFORM_CXX_LIBS], [Linker flags for dash-sdk-cxx, overriding pkg-config (default: the library and the vetted system libraries from the depends dash_sdk_cxx.pc)])
+
 dnl Enable different -fsanitize options
 AC_ARG_WITH([sanitizers],
     [AS_HELP_STRING([--with-sanitizers],
@@ -1926,6 +1934,41 @@ if test "$build_bitcoin_wallet$build_bitcoin_cli$build_bitcoin_tx$build_bitcoin_
   AC_MSG_ERROR([No targets! Please specify at least one of: --with-utils --with-libs --with-daemon --with-gui --enable-fuzz(-binary) --enable-bench or --enable-tests])
 fi
 
+dnl dash-sdk-cxx, the C++ binding of the Dash Platform SDK, is a Rust static
+dnl library linked into dash-qt (and its tests) only. depends installs
+dnl dash_sdk_cxx.pc, whose Libs are the library and the vetted system libraries
+dnl it needs; depends checks those against rustc's --print=native-static-libs.
+if test "$enable_platform_gui" = "yes"; then
+  if test "$bitcoin_enable_qt" != "yes"; then
+    AC_MSG_ERROR([--enable-platform-gui requires the GUI])
+  fi
+  if test "$enable_wallet" != "yes"; then
+    AC_MSG_ERROR([--enable-platform-gui requires the wallet])
+  fi
+  PKG_CHECK_MODULES([PLATFORM_CXX], [dash_sdk_cxx], [],
+    [AC_MSG_ERROR([--enable-platform-gui requires dash-sdk-cxx (build depends with PLATFORM_GUI=1)])])
+  TEMP_CPPFLAGS="$CPPFLAGS"
+  TEMP_LIBS="$LIBS"
+  CPPFLAGS="$CPPFLAGS $PLATFORM_CXX_CFLAGS"
+  LIBS="$PLATFORM_CXX_LIBS $LIBS"
+  AC_LANG_PUSH([C++])
+  AC_MSG_CHECKING([whether a program using dash-sdk-cxx links])
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+      #include <dash/sdk/ffi.h>
+    ]], [[
+      rust::Box<dash_sdk::PlatformClient> client{dash_sdk::new_platform_client(dash_sdk::Config{}, nullptr)};
+      client->shutdown();
+    ]])],
+    [AC_MSG_RESULT([yes])],
+    [AC_MSG_RESULT([no])
+     AC_MSG_ERROR([a program using dash-sdk-cxx does not link; see config.log])])
+  AC_LANG_POP([C++])
+  CPPFLAGS="$TEMP_CPPFLAGS"
+  LIBS="$TEMP_LIBS"
+  AC_DEFINE([ENABLE_PLATFORM_GUI], [1], [Define this symbol to enable Dash Platform support in the GUI])
+fi
+AM_CONDITIONAL([ENABLE_PLATFORM_GUI], [test "$enable_platform_gui" = "yes"])
+
 AM_CONDITIONAL([TARGET_DARWIN], [test "$TARGET_OS" = "darwin"])
 AM_CONDITIONAL([BUILD_DARWIN], [test "$BUILD_OS" = "darwin"])
 AM_CONDITIONAL([TARGET_LINUX], [test "$TARGET_OS" = "linux"])
@@ -2121,6 +2164,7 @@ echo "  debug enabled   = $enable_debug"
 echo "  stacktraces     = $enable_stacktraces"
 echo "  crash hooks     = $enable_crashhooks"
 echo "  miner enabled   = $enable_miner"
+echo "  platform gui    = $enable_platform_gui"
 echo "  werror          = $enable_werror"
 echo
 echo "  target os       = $host_os"
diff --git a/contrib/devtools/README.md b/contrib/devtools/README.md
index c7dbad85e8be..49fea496b958 100644
--- a/contrib/devtools/README.md
+++ b/contrib/devtools/README.md
@@ -193,3 +193,37 @@ Example usage:
 
     cd .../src
     ../contrib/devtools/circular-dependencies.py {*,*/*,*/*/*}.{h,cpp}
+
+update-rust-hashes.py
+=====================
+
+Refreshes the sha256 pins of the prebuilt Rust toolchain
+(`depends/packages/native_rust.mk`) and of the per-host standard libraries
+(`depends/packages/rust_stdlib.mk`) after the version in `native_rust.mk` was
+changed; each downloaded archive must match the `.sha256` file published next
+to it. `--check` compares the pins with the published `.sha256` files instead
+of rewriting them.
+
+platform-bundle.sh
+==================
+
+Produces the crate bundle from which `depends/packages/platform_cxx.mk` builds
+`dash-sdk-cxx` (the C++ binding of the Dash Platform SDK) for a given
+`dashpay/platform` commit, and prints the hashes to pin in `platform_cxx.mk`.
+The bundle includes the Tenderdash source archive for the tag the commit's
+`Cargo.lock` pins, so the two cannot disagree. Requires the Cargo version pinned in `native_rust.mk`,
+GNU tar, GNU gzip (set `TAR` and `GZIP_PROG` if they are installed under other
+names) and a `TMPDIR` with no `.cargo/config.toml` in any parent directory.
+The output is reproducible: rerunning it for the same commit yields the same
+bundle hash on any machine. The Platform tarball and the bundle are then
+uploaded to the depends sources mirror.
+
+    contrib/devtools/platform-bundle.sh <platform-commit>
+
+check-no-rust.py
+================
+
+Fails if any of the given executables contain Rust code. Run by the
+`linux64_sqlite` CI job, which builds against depends with `PLATFORM_GUI=1`,
+on `dashd`, the command-line tools and the fuzz binary, which must never link
+`dash-sdk-cxx`.
diff --git a/contrib/devtools/check-no-rust.py b/contrib/devtools/check-no-rust.py
new file mode 100755
index 000000000000..7572df20f04b
--- /dev/null
+++ b/contrib/devtools/check-no-rust.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+'''
+Check that executables do not link Rust code.
+
+dash-sdk-cxx, the Dash Platform SDK binding (--enable-platform-gui), is for
+dash-qt only; dashd, the command-line tools and the fuzz binary must not
+contain any of it.
+A binary fails if its symbol table has cxx bridge, Rust runtime or Rust
+standard library symbols, or has no symbols at all (a stripped binary cannot
+be checked).
+
+Example usage:
+
+    contrib/devtools/check-no-rust.py src/dashd src/dash-cli src/dash-tx src/dash-wallet src/test/fuzz/fuzz
+'''
+import re
+import subprocess
+import sys
+
+from utils import determine_wellknown_cmd
+
+# cxx bridge symbols carry "cxxbridge1$". Rust code is either legacy-mangled
+# under a crate namespace (rust, std, core, alloc) or v0-mangled ("_R"
+# followed by a path tag and a crate root "Cs<disambiguator>_"), which C and
+# C++ symbols never match. The allocator shim, the panic handler and the
+# unwinding personality are plain C names every Rust program links.
+RUST_SYMBOL = re.compile(
+    r'cxxbridge1\$'
+    r'|_ZN(4rust|3std|4core|5alloc)[0-9]'
+    r'|\b_?_R[A-Za-z0-9_]*?Cs[A-Za-z0-9]*_[0-9]'
+    r'|\b_?(__rust_alloc|rust_begin_unwind|rust_eh_personality)'
+)
+
+
+def rust_symbols(nm, path):
+    result = subprocess.run(nm + [path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False)
+    if result.returncode != 0:
+        sys.exit(f'{path}: {result.stderr.strip()}')
+    lines = result.stdout.splitlines()
+    if not lines:
+        sys.exit(f'{path}: no symbols, so it cannot be checked (stripped?)')
+    return [line for line in lines if RUST_SYMBOL.search(line)]
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(__doc__)
+    nm = determine_wellknown_cmd('NM', 'nm')
+    failed = False
+    for path in sys.argv[1:]:
+        found = rust_symbols(nm, path)
+        if found:
+            failed = True
+            print(f'{path}: links Rust code, for example:')
+            for line in found[:5]:
+                print(f'    {line}')
+    sys.exit(1 if failed else 0)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/contrib/devtools/platform-bundle.sh b/contrib/devtools/platform-bundle.sh
new file mode 100755
index 000000000000..ec68ea48469d
--- /dev/null
+++ b/contrib/devtools/platform-bundle.sh
@@ -0,0 +1,204 @@
+#!/usr/bin/env bash
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export LC_ALL=C
+set -euo pipefail
+
+# Produces the crate bundle that depends/packages/platform_cxx.mk builds
+# dash-sdk-cxx from, for a given dashpay/platform commit.
+#
+# The bundle holds a Cargo workspace trimmed to packages/rs-sdk-cxx, the
+# commit's Cargo.lock pruned to that workspace (entries are only removed, never
+# changed), every locked crate vendored with `cargo vendor --locked
+# --versioned-dirs`, the Tenderdash source archive tenderdash-proto's build
+# script generates its protobuf code from (tenderdash/tenderdash-<tag>.zip, for
+# the rs-tenderdash-abci tag the lock pins), and a .cargo/config.toml that
+# replaces all crate sources with the vendored directory and sets
+# TENDERDASH_COMMITISH to that same tag. Vendored crates outside the build
+# closure of dash-sdk-cxx (dev-dependencies and crates only other
+# workspace members use) are reduced to their manifest and empty target files:
+# Cargo needs them to resolve the lock, never to build. The archive is written
+# with a fixed file order, owner, mode and mtime, so the same commit yields the
+# same sha256 on every machine that uses the pinned Rust version, GNU tar and
+# GNU gzip (and as long as GitHub serves the same Tenderdash zip).
+#
+# This is the only step that downloads crates. The maintainer bumping the
+# pin runs it, updates the hashes in platform_cxx.mk from its output, and
+# uploads the Platform tarball and the bundle to the depends sources mirror;
+# reviewers rerun it to reproduce the hash.
+
+usage() {
+    echo "Usage: $0 <dashpay/platform commit>" >&2
+    echo >&2
+    echo "Writes platform-<commit>.tar.gz and dash-sdk-cxx-crates-<commit>.tar.gz to" >&2
+    echo "SOURCES_PATH (default: depends/sources), and keeps the downloaded" >&2
+    echo "tenderdash-<tag>.zip there." >&2
+    exit 1
+}
+
+[ $# -eq 1 ] || usage
+COMMIT="$1"
+[[ "$COMMIT" =~ ^[0-9a-f]{40}$ ]] || { echo "error: expected a full 40-character commit hash" >&2; exit 1; }
+
+TOPDIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+SOURCES_PATH="${SOURCES_PATH:-$TOPDIR/depends/sources}"
+mkdir -p "$SOURCES_PATH"
+# The script changes directory below; a relative path must not follow it.
+SOURCES_PATH="$(cd "$SOURCES_PATH" && pwd)"
+# shellcheck disable=SC2016
+RUST_VERSION="$(sed -n 's/^\$(package)_version:=//p' "$TOPDIR/depends/packages/native_rust.mk")"
+CARGO="${CARGO:-cargo}"
+TAR="${TAR:-tar}"
+GZIP_PROG="${GZIP_PROG:-gzip}"
+
+# cargo vendor output (normalized manifests) depends on the Cargo version.
+export RUSTUP_TOOLCHAIN="${RUSTUP_TOOLCHAIN:-$RUST_VERSION}"
+case "$("$CARGO" --version)" in
+    "cargo $RUST_VERSION "*) ;;
+    *) echo "error: $CARGO is not Cargo $RUST_VERSION (the version pinned in native_rust.mk)" >&2; exit 1 ;;
+esac
+case "$("$TAR" --version)" in
+    *"GNU tar"*) ;;
+    *) echo "error: $TAR is not GNU tar; set TAR" >&2; exit 1 ;;
+esac
+case "$("$GZIP_PROG" --version)" in
+    *"Free Software Foundation"*) ;;
+    *) echo "error: $GZIP_PROG is not GNU gzip; set GZIP_PROG" >&2; exit 1 ;;
+esac
+
+WORKDIR="$(mktemp -d "${TMPDIR:-/tmp}/platform-bundle.XXXXXX")"
+trap 'rm -rf "$WORKDIR"' EXIT
+# Cargo looks for configuration above the physical directory it runs in.
+WORKDIR="$(cd "$WORKDIR" && pwd -P)"
+# A private Cargo home keeps the cached registries and the Cargo home's
+# config.toml out of the bundle. Cargo also reads .cargo/config.toml from every
+# parent of the directory it runs in, so the work directory must have none
+# (TMPDIR under a home directory with ~/.cargo/config.toml fails here).
+export CARGO_HOME="$WORKDIR/cargo-home"
+dir="$WORKDIR"
+while :; do
+    dir="$(dirname "$dir")"
+    for config in "$dir/.cargo/config" "$dir/.cargo/config.toml"; do
+        if [ -e "$config" ]; then
+            echo "error: $config would configure Cargo; set TMPDIR to a directory outside its tree" >&2
+            exit 1
+        fi
+    done
+    [ "$dir" != / ] || break
+done
+
+# Downloads $1 to SOURCES_PATH/$2, unless a copy there passes the integrity
+# test $3 (a partial or corrupt one is downloaded again).
+fetch() {
+    local url="$1" file="$2" test="$3"
+    if [ -f "$SOURCES_PATH/$file" ] && $test "$SOURCES_PATH/$file" 2> /dev/null; then
+        return
+    fi
+    rm -f "$SOURCES_PATH/$file"
+    curl --location --fail --silent --show-error --retry 3 -o "$SOURCES_PATH/$file.temp" "$url"
+    $test "$SOURCES_PATH/$file.temp"
+    mv "$SOURCES_PATH/$file.temp" "$SOURCES_PATH/$file"
+}
+
+gzip_test() {
+    "$GZIP_PROG" -t "$1"
+}
+
+zip_test() {
+    python3 -c 'import sys, zipfile; sys.exit(zipfile.ZipFile(sys.argv[1]).testzip() is not None)' "$1"
+}
+
+sha256() {
+    if command -v sha256sum >/dev/null; then
+        sha256sum "$1" | cut -d' ' -f1
+    else
+        shasum -a 256 "$1" | cut -d' ' -f1
+    fi
+}
+
+# Prints "name version source" for every [[package]] of a Cargo.lock.
+lock_entries() {
+    awk '/^\[\[package\]\]$/ { if (name) print name, version, source; name = version = source = "" }
+         /^name = /    { name = $3 }
+         /^version = / { version = $3 }
+         /^source = /  { source = $3 }
+         END           { if (name) print name, version, source }' "$1" | sort
+}
+
+PLATFORM_ARCHIVE="platform-$COMMIT.tar.gz"
+fetch "https://github.com/dashpay/platform/archive/$COMMIT.tar.gz" "$PLATFORM_ARCHIVE" gzip_test
+
+SRC="$WORKDIR/src"
+mkdir -p "$SRC"
+"$TAR" --strip-components=1 -xzf "$SOURCES_PATH/$PLATFORM_ARCHIVE" -C "$SRC"
+cd "$SRC"
+
+# Trim the workspace to the one crate depends builds and prune the lock to it.
+cp Cargo.lock "$WORKDIR/Cargo.lock.pinned"
+awk '/^members = \[/ { print "members = [\"packages/rs-sdk-cxx\"]"; skip = !/\]/; next }
+     skip && /^\]/   { skip = 0; next }
+     !skip' Cargo.toml > "$WORKDIR/Cargo.toml"
+mv "$WORKDIR/Cargo.toml" Cargo.toml
+"$CARGO" metadata --format-version 1 > /dev/null
+if lock_entries Cargo.lock | comm -13 <(lock_entries "$WORKDIR/Cargo.lock.pinned") - | grep .; then
+    echo "error: trimming the workspace changed the locked packages above" >&2
+    exit 1
+fi
+
+TENDERDASH_TAG="$(awk '/^name = "tenderdash-proto"$/ { found = 1 }
+                       found && /^source = / { print; exit }' Cargo.lock |
+                  sed -n 's|.*/rs-tenderdash-abci?tag=\(v[^#]*\)#.*|\1|p')"
+[ -n "$TENDERDASH_TAG" ] || { echo "error: no tagged tenderdash-proto entry in Cargo.lock" >&2; exit 1; }
+TENDERDASH_ARCHIVE="tenderdash-$TENDERDASH_TAG.zip"
+fetch "https://github.com/dashpay/tenderdash/archive/$TENDERDASH_TAG.zip" "$TENDERDASH_ARCHIVE" zip_test
+mkdir tenderdash
+cp "$SOURCES_PATH/$TENDERDASH_ARCHIVE" tenderdash/
+
+rm -rf .cargo
+mkdir .cargo
+{
+    echo "# Generated by contrib/devtools/platform-bundle.sh for dashpay/platform@$COMMIT"
+    "$CARGO" vendor --locked --versioned-dirs vendor
+    echo
+    echo "[env]"
+    echo "TENDERDASH_COMMITISH = \"$TENDERDASH_TAG\""
+} > "$WORKDIR/config.toml"
+grep -qx 'directory = "vendor"' "$WORKDIR/config.toml" || { echo "error: cargo vendor printed no source replacement" >&2; exit 1; }
+mv "$WORKDIR/config.toml" .cargo/config.toml
+# From here on every crate must come from vendor/, never from the Cargo home.
+rm -rf "$CARGO_HOME"
+
+closure() {
+    "$CARGO" tree --frozen -p dash-sdk-cxx -e normal,build --target all --prefix none --format '{p}' |
+        awk '{ sub(/^v/, "", $2); print $1 "-" $2 }' | sort -u
+}
+closure > "$WORKDIR/closure"
+for dir in vendor/*/; do
+    dir="${dir%/}"
+    grep -qxF "${dir#vendor/}" "$WORKDIR/closure" && continue
+    checksum="$(sed -En 's/.*"package":(null|"[0-9a-f]*")}$/\1/p' "$dir/.cargo-checksum.json")"
+    find "$dir" ! -type d ! -name '*.rs' ! -path "$dir/Cargo.toml" -delete
+    find "$dir" -type f -name '*.rs' -print0 | while IFS= read -r -d '' file; do : > "$file"; done
+    find "$dir" -type d -empty -delete
+    printf '{"files":{},"package":%s}' "$checksum" > "$dir/.cargo-checksum.json"
+done
+closure | cmp -s - "$WORKDIR/closure" || { echo "error: the build closure changed after pruning" >&2; exit 1; }
+
+BUNDLE="dash-sdk-cxx-crates-$COMMIT.tar.gz"
+"$TAR" --create --format=gnu --sort=name --mtime=@0 --owner=0 --group=0 --numeric-owner \
+       --mode='u+rw,go+r-w,a+X' Cargo.toml Cargo.lock .cargo/config.toml tenderdash vendor |
+    "$GZIP_PROG" -9n > "$SOURCES_PATH/$BUNDLE.temp"
+mv "$SOURCES_PATH/$BUNDLE.temp" "$SOURCES_PATH/$BUNDLE"
+
+cat <<EOF
+$(sha256 "$SOURCES_PATH/$PLATFORM_ARCHIVE")  $PLATFORM_ARCHIVE
+$(sha256 "$SOURCES_PATH/$BUNDLE")  $BUNDLE
+$(sha256 "$SOURCES_PATH/$TENDERDASH_ARCHIVE")  $TENDERDASH_ARCHIVE (in the bundle)
+
+depends/packages/platform_cxx.mk:
+\$(package)_version=$COMMIT
+\$(package)_sha256_hash=$(sha256 "$SOURCES_PATH/$PLATFORM_ARCHIVE")
+\$(package)_crates_sha256_hash=$(sha256 "$SOURCES_PATH/$BUNDLE")
+EOF
diff --git a/contrib/devtools/update-rust-hashes.py b/contrib/devtools/update-rust-hashes.py
new file mode 100755
index 000000000000..5017729bf51d
--- /dev/null
+++ b/contrib/devtools/update-rust-hashes.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# Copyright (c) 2021-2022 The Zcash developers
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+'''
+Refresh the sha256 pins of the prebuilt Rust toolchain (native_rust.mk) and
+the per-host standard libraries (rust_stdlib.mk) for the version set in
+native_rust.mk, or verify them with --check.
+
+Rewriting downloads every archive from static.rust-lang.org, hashes it locally
+and requires the result to match the .sha256 file published next to it.
+--check only compares the pins with the published .sha256 files.
+'''
+import argparse
+import hashlib
+import http.client
+import re
+import sys
+import urllib.request
+from pathlib import Path
+
+DIST_URL = "https://static.rust-lang.org/dist"
+TIMEOUT = 60  # seconds without data before a request fails
+PACKAGES_DIR = Path(__file__).resolve().parents[2] / "depends" / "packages"
+NATIVE_RUST_MK = PACKAGES_DIR / "native_rust.mk"
+RUST_STDLIB_MK = PACKAGES_DIR / "rust_stdlib.mk"
+
+
+def pins(content: str, kind: str) -> dict:
+    """Return {id: value} for every `$(package)_<kind>_<id>:=<value>` line."""
+    return dict(re.findall(rf"^\$\(package\)_{kind}_(\w+):=(\S+)$", content, re.MULTILINE))
+
+
+def published_sha256(url: str) -> str:
+    """Return the hash in the `<hash>  <file>` line of `<url>.sha256`."""
+    with urllib.request.urlopen(f"{url}.sha256", timeout=TIMEOUT) as response:
+        return response.read().decode().split()[0]
+
+
+def sha256_of(url: str, attempts: int = 3) -> str:
+    for _ in range(attempts):
+        hasher = hashlib.sha256()
+        received = 0
+        try:
+            with urllib.request.urlopen(url, timeout=TIMEOUT) as response:
+                length = response.headers["Content-Length"]
+                while chunk := response.read(1 << 20):
+                    hasher.update(chunk)
+                    received += len(chunk)
+        except (http.client.IncompleteRead, OSError) as error:
+            print(f"warning: {url}: {error}", file=sys.stderr)
+            continue
+        if length is None or received == int(length):
+            return hasher.hexdigest()
+        print(f"warning: {url}: download ended after {received} of {length} bytes", file=sys.stderr)
+    sys.exit(f"error: {url}: no complete download in {attempts} attempts")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--check", action="store_true", help="verify the pinned hashes instead of rewriting them")
+    args = parser.parse_args()
+
+    native = NATIVE_RUST_MK.read_text(encoding="utf-8")
+    stdlib = RUST_STDLIB_MK.read_text(encoding="utf-8")
+    version_pin = re.search(r"^\$\(package\)_version:=(\S+)$", native, re.MULTILINE)
+    if version_pin is None:
+        sys.exit(f"error: no version pin in {NATIVE_RUST_MK}")
+    version = version_pin.group(1)
+
+    archives = []  # (makefile, pin id, archive name)
+    build_targets = pins(native, "build_target")
+    for build_id, file_name in pins(native, "file_name").items():
+        file_name = file_name.replace("$($(package)_version)", version)
+        if build_id not in build_targets:
+            sys.exit(f"error: {NATIVE_RUST_MK} has no build_target_{build_id} pin")
+        file_name = file_name.replace(f"$($(package)_build_target_{build_id})", build_targets[build_id])
+        archives.append((NATIVE_RUST_MK, build_id, file_name))
+    for host_id, target in pins(stdlib, "target").items():
+        archives.append((RUST_STDLIB_MK, host_id, f"rust-std-{version}-{target}.tar.gz"))
+
+    contents = {NATIVE_RUST_MK: native, RUST_STDLIB_MK: stdlib}
+    stale = []
+    for makefile, pin_id, archive in archives:
+        pinned = pins(contents[makefile], "sha256_hash").get(pin_id)
+        if pinned is None:
+            sys.exit(f"error: {makefile} has no sha256_hash_{pin_id} pin")
+        url = f"{DIST_URL}/{archive}"
+        actual = published_sha256(url)
+        if not args.check:
+            downloaded = sha256_of(url)
+            if downloaded != actual:
+                sys.exit(f"error: {archive} hashes to {downloaded}, but its published .sha256 says {actual}")
+        print(f"{actual}  {archive}")
+        if actual != pinned:
+            stale.append(archive)
+            contents[makefile] = re.sub(rf"^(\$\(package\)_sha256_hash_{pin_id}:=)\S*$",
+                                        rf"\g<1>{actual}", contents[makefile], flags=re.MULTILINE)
+
+    if args.check:
+        for archive in stale:
+            print(f"error: pinned hash for {archive} does not match", file=sys.stderr)
+        return 1 if stale else 0
+
+    for makefile, content in contents.items():
+        makefile.write_text(content, encoding="utf-8")
+    print(f"Updated {len(stale)} of {len(archives)} pins for Rust {version}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/depends/Makefile b/depends/Makefile
index a50aabc0bb27..6d4faaefd95c 100644
--- a/depends/Makefile
+++ b/depends/Makefile
@@ -44,6 +44,7 @@ NO_UPNP ?=
 NO_USDT ?=
 NO_NATPMP ?=
 MULTIPROCESS ?=
+PLATFORM_GUI ?=
 LTO ?=
 NO_HARDEN ?=
 FALLBACK_DOWNLOAD_PATH ?= http://dash-depends-sources.s3-website-us-west-2.amazonaws.com
@@ -171,6 +172,7 @@ natpmp_packages_$(NO_NATPMP) = $(natpmp_packages)
 
 zmq_packages_$(NO_ZMQ) = $(zmq_packages)
 multiprocess_packages_$(MULTIPROCESS) = $(multiprocess_packages)
+platform_packages_$(PLATFORM_GUI) = $(platform_packages)
 usdt_packages_$(NO_USDT) = $(usdt_$(host_os)_packages)
 
 packages += $($(host_arch)_$(host_os)_packages) $($(host_os)_packages) $(boost_packages_) $(libevent_packages_) $(qt_packages_) $(wallet_packages_) $(upnp_packages_) $(natpmp_packages_) $(usdt_packages_)
@@ -185,6 +187,14 @@ packages += $(multiprocess_packages)
 native_packages += $(multiprocess_native_packages)
 endif
 
+ifeq ($(platform_packages_),)
+ifneq ($(NO_QT)$(NO_WALLET),)
+$(error PLATFORM_GUI needs the GUI and the wallet; unset NO_QT and NO_WALLET)
+endif
+packages += $(platform_packages)
+native_packages += $(platform_native_packages)
+endif
+
 all_packages = $(packages) $(native_packages)
 
 meta_depends = Makefile config.guess config.sub funcs.mk builders/default.mk hosts/default.mk hosts/$(host_os).mk builders/$(build_os).mk
@@ -253,6 +263,7 @@ $(host_prefix)/share/config.site : config.site.in $(host_prefix)/.stamp_$(final_
             -e 's|@no_usdt@|$(NO_USDT)|' \
             -e 's|@no_natpmp@|$(NO_NATPMP)|' \
             -e 's|@multiprocess@|$(MULTIPROCESS)|' \
+            -e 's|@platform_gui@|$(PLATFORM_GUI)|' \
             -e 's|@lto@|$(LTO)|' \
             -e 's|@no_harden@|$(NO_HARDEN)|' \
             -e 's|@debug@|$(DEBUG)|' \
diff --git a/depends/README.md b/depends/README.md
index ef640a65998b..e97905ea2d9c 100644
--- a/depends/README.md
+++ b/depends/README.md
@@ -92,6 +92,9 @@ The following can be set when running make: `make FOO=bar`
   build script logic) are searched for among the host system packages using
   `pkg-config`. It allows building with packages of other (newer) versions
 - `MULTIPROCESS`: build libmultiprocess (experimental, requires cmake)
+- `PLATFORM_GUI`: build the Rust toolchain and `dash-sdk-cxx` (the Dash Platform SDK's C++ binding) needed for
+  `--enable-platform-gui` (which config.site then enables); cannot be combined with `NO_QT`
+  or `NO_WALLET`
 - `DEBUG`: Disable some optimizations and enable more runtime checking
 - `HOST_ID_SALT`: Optional salt to use when generating host package ids
 - `BUILD_ID_SALT`: Optional salt to use when generating build package ids
diff --git a/depends/config.site.in b/depends/config.site.in
index 398a09b74c63..ff54ed3db74b 100644
--- a/depends/config.site.in
+++ b/depends/config.site.in
@@ -50,6 +50,10 @@ if test -z "$enable_multiprocess" && test -n "@multiprocess@"; then
   enable_multiprocess=yes
 fi
 
+if test -z "$enable_platform_gui" && test -n "@platform_gui@"; then
+  enable_platform_gui=yes
+fi
+
 if test -z "$with_miniupnpc" && test -n "@no_upnp@"; then
   with_miniupnpc=no
 fi
diff --git a/depends/funcs.mk b/depends/funcs.mk
index 566f83a9868e..e8aa530f2c3c 100644
--- a/depends/funcs.mk
+++ b/depends/funcs.mk
@@ -71,7 +71,7 @@ $(1)_build_log:=$(BASEDIR)/$(1)-$($(1)_version)-$($(1)_build_id).log
 $(1)_all_sources=$($(1)_file_name) $($(1)_extra_sources)
 
 #stamps
-$(1)_fetched=$(SOURCES_PATH)/download-stamps/.stamp_fetched-$(1)-$($(1)_version)-$($(1)_sha256_hash).hash
+$(1)_fetched=$(SOURCES_PATH)/download-stamps/.stamp_fetched-$(1)-$($(1)_version)-$($(1)_sha256_hash)$(if $($(1)_fetched_id),-$($(1)_fetched_id)).hash
 $(1)_extracted=$$($(1)_extract_dir)/.stamp_extracted
 $(1)_preprocessed=$$($(1)_extract_dir)/.stamp_preprocessed
 $(1)_cleaned=$$($(1)_extract_dir)/.stamp_cleaned
diff --git a/depends/packages.md b/depends/packages.md
index 4232bb1006bd..4e4fe155e516 100644
--- a/depends/packages.md
+++ b/depends/packages.md
@@ -48,6 +48,13 @@ These variables are optional:
     Any extra files that will be fetched via $(package)_fetch_cmds. These are
     specified so that they can be fetched and verified via 'make download'.
 
+    $(package)_fetched_id:
+    Added to the name of the package's download stamp, which otherwise holds
+    only $(package)_version and $(package)_sha256_hash. Set it to the hash of
+    an extra source that can change while those stay the same, so that a
+    change refetches it. It must be a single word: join several hashes with
+    "-", not spaces.
+
 
 ## Build Variables:
 After defining the main identifiers, build variables may be added or customized
diff --git a/depends/packages/native_protobuf.mk b/depends/packages/native_protobuf.mk
new file mode 100644
index 000000000000..52c3745ee279
--- /dev/null
+++ b/depends/packages/native_protobuf.mk
@@ -0,0 +1,43 @@
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+package=native_protobuf
+$(package)_version=32.0
+$(package)_download_path=https://github.com/protocolbuffers/protobuf/releases/download/v$($(package)_version)
+
+# Linux (ARMv8)
+$(package)_file_name_aarch64_linux=protoc-$($(package)_version)-linux-aarch_64.zip
+$(package)_sha256_hash_aarch64_linux=56af3fc2e43a0230802e6fadb621d890ba506c5c17a1ae1070f685fe79ba12d0
+
+# Linux (x86_64)
+$(package)_file_name_x86_64_linux=protoc-$($(package)_version)-linux-x86_64.zip
+$(package)_sha256_hash_x86_64_linux=7ca037bfe5e5cabd4255ccd21dd265f79eb82d3c010117994f5dc81d2140ee88
+
+# macOS (ARMv8)
+$(package)_file_name_aarch64_darwin=protoc-$($(package)_version)-osx-aarch_64.zip
+$(package)_sha256_hash_aarch64_darwin=09a2c729cc821215cc0d4c564b761760961fe338c52f24b302fd7e18e7b675d1
+
+# macOS (x86_64)
+$(package)_file_name_x86_64_darwin=protoc-$($(package)_version)-osx-x86_64.zip
+$(package)_sha256_hash_x86_64_darwin=63eeba15ddc12ab11b0a8bce81fb2d46cc69022c3e6ad21fecde90d52139bff6
+
+$(package)_file_name=$($(package)_file_name_$(build_arch)_$(build_os))
+$(package)_sha256_hash=$($(package)_sha256_hash_$(build_arch)_$(build_os))
+
+ifeq ($($(package)_file_name),)
+$(error native_protobuf has no prebuilt protoc $($(package)_version) for $(build_arch)-$(build_os))
+endif
+
+define $(package)_extract_cmds
+  echo "$($(package)_sha256_hash)  $($(package)_source)" > .$($(package)_file_name).hash && \
+  $(build_SHA256SUM) -c .$($(package)_file_name).hash && \
+  python3 -m zipfile -e $($(package)_source) .
+endef
+
+define $(package)_stage_cmds
+  mkdir -p $($(package)_staging_prefix_dir)/bin $($(package)_staging_prefix_dir)/include && \
+  cp bin/protoc $($(package)_staging_prefix_dir)/bin/ && \
+  chmod 0755 $($(package)_staging_prefix_dir)/bin/protoc && \
+  cp -R include/google $($(package)_staging_prefix_dir)/include/
+endef
diff --git a/depends/packages/native_rust.mk b/depends/packages/native_rust.mk
new file mode 100644
index 000000000000..5d853f094ac8
--- /dev/null
+++ b/depends/packages/native_rust.mk
@@ -0,0 +1,52 @@
+# Copyright (c) 2016-2025 The Zcash developers
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# To update the Rust compiler, change the version below and then run the script
+# ./contrib/devtools/update-rust-hashes.py
+
+package:=native_rust
+$(package)_version:=1.98.1
+$(package)_download_path:=https://static.rust-lang.org/dist
+
+# Linux (ARMv8)
+$(package)_build_target_aarch64_linux:=aarch64-unknown-linux-gnu
+$(package)_file_name_aarch64_linux:=rust-$($(package)_version)-$($(package)_build_target_aarch64_linux).tar.gz
+$(package)_sha256_hash_aarch64_linux:=f00ba576645cef658e1deed96fab8f707958e9d58808b16343448b5d1c4f7407
+
+# Linux (x86_64)
+$(package)_build_target_x86_64_linux:=x86_64-unknown-linux-gnu
+$(package)_file_name_x86_64_linux:=rust-$($(package)_version)-$($(package)_build_target_x86_64_linux).tar.gz
+$(package)_sha256_hash_x86_64_linux:=24ba1338a2d35c5a3247936546429e163fa674d726102af18bdf624582c57aea
+
+# macOS (ARMv8)
+$(package)_build_target_aarch64_darwin:=aarch64-apple-darwin
+$(package)_file_name_aarch64_darwin:=rust-$($(package)_version)-$($(package)_build_target_aarch64_darwin).tar.gz
+$(package)_sha256_hash_aarch64_darwin:=cfc171d8120d401b10a1028c52646dd8e00e3e66852f949061ce087845f55afd
+
+# macOS (x86_64)
+$(package)_build_target_x86_64_darwin:=x86_64-apple-darwin
+$(package)_file_name_x86_64_darwin:=rust-$($(package)_version)-$($(package)_build_target_x86_64_darwin).tar.gz
+$(package)_sha256_hash_x86_64_darwin:=443a1165abbac41c9143b83ff837c0fb1d8c03d2f8fb1da27427bc9fc646aad3
+
+# The Rust target triple of the build machine.
+$(package)_build_target:=$($(package)_build_target_$(build_arch)_$(build_os))
+$(package)_file_name=$($(package)_file_name_$(build_arch)_$(build_os))
+$(package)_sha256_hash=$($(package)_sha256_hash_$(build_arch)_$(build_os))
+
+ifeq ($($(package)_file_name),)
+$(error native_rust has no prebuilt Rust $($(package)_version) for $(build_arch)-$(build_os))
+endif
+
+# The prebuilt toolchain cannot run inside a Guix environment as is.
+ifneq ($(GUIX_ENVIRONMENT),)
+$(error native_rust: PLATFORM_GUI is not supported in Guix builds yet; see <GUIX-ISSUE-URL>)
+endif
+
+define $(package)_stage_cmds
+  mkdir -p $($(package)_staging_prefix_dir)/bin $($(package)_staging_prefix_dir)/lib/rustlib && \
+  cp cargo/bin/cargo rustc/bin/rustc $($(package)_staging_prefix_dir)/bin/ && \
+  cp -R rustc/lib/. $($(package)_staging_prefix_dir)/lib/ && \
+  cp -R rust-std-*/lib/rustlib/. $($(package)_staging_prefix_dir)/lib/rustlib/
+endef
diff --git a/depends/packages/packages.mk b/depends/packages/packages.mk
index 59232930eb38..e3299ea041ff 100644
--- a/depends/packages/packages.mk
+++ b/depends/packages/packages.mk
@@ -24,4 +24,7 @@ natpmp_packages=libnatpmp
 multiprocess_packages = libmultiprocess capnp
 multiprocess_native_packages = native_libmultiprocess native_capnp
 
+platform_packages = rust_stdlib platform_cxx
+platform_native_packages = native_rust native_protobuf
+
 usdt_linux_packages=systemtap
diff --git a/depends/packages/platform_cxx.mk b/depends/packages/platform_cxx.mk
new file mode 100644
index 000000000000..362d88383574
--- /dev/null
+++ b/depends/packages/platform_cxx.mk
@@ -0,0 +1,219 @@
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# dash-sdk-cxx, the C++ binding of the Dash Platform SDK (packages/rs-sdk-cxx
+# of dashpay/platform), built from two sha256-pinned archives: the Platform
+# source tarball at the pinned commit, and the crate bundle that
+# contrib/devtools/platform-bundle.sh produces for that commit (trimmed
+# workspace, pruned Cargo.lock, vendored crates, the Tenderdash sources
+# tenderdash-proto generates its protobuf code from, Cargo configuration).
+# Cargo runs with --frozen and never touches the network.
+#
+# Both archives must be on the depends sources mirror (FALLBACK_DOWNLOAD_PATH)
+# before this is merged. The bundle has no upstream URL, and GitHub does not
+# promise stable bytes for the archive endpoint the tarball comes from.
+# Whoever bumps the pin runs platform-bundle.sh, which prints the lines to
+# update here, and uploads both. Until then, a bundle the script wrote to
+# SOURCES_PATH is used as is; its hash is checked on extraction either way.
+
+package=platform_cxx
+$(package)_version=dc4dc8e80ef8c495be693d4cc19c378a94f5d116
+$(package)_download_path=https://github.com/dashpay/platform/archive
+$(package)_download_file=$($(package)_version).tar.gz
+$(package)_file_name=platform-$($(package)_version).tar.gz
+$(package)_sha256_hash=fca5a310c8322924734ae7f8c522bffe4622bb4eb8394a6e054f56129ffbe592
+$(package)_crates_file_name=dash-sdk-cxx-crates-$($(package)_version).tar.gz
+$(package)_crates_sha256_hash=6f9d50e3c82406956b4b769874824bac7c28e8f1bcf1b3d514f7d381ea672f55
+$(package)_fetched_id=$($(package)_crates_sha256_hash)
+$(package)_extra_sources=$($(package)_crates_file_name)
+$(package)_dependencies=native_rust rust_stdlib native_protobuf
+$(package)_patches=rustc-linker.sh build-linker.sh check-native-libs.sh
+
+# The system libraries the archive needs, which dash_sdk_cxx.pc passes on
+# to configure. Each is vetted against contrib/guix/symbol-check.py, and the
+# build fails if rustc reports one (--print=native-static-libs) that is
+# neither here nor in the ignored list below.
+$(package)_native_libs_linux=-lpthread -ldl -lm
+$(package)_native_libs_darwin=-framework Security -framework CoreFoundation
+$(package)_native_libs_mingw32=-lbcrypt -ladvapi32 -lkernel32 -lntdll -luserenv -lws2_32 -ldbghelp
+
+# Libraries rustc reports that are deliberately not passed on:
+# - the C++ runtime the cxx bridge needs, which the C++ link of dash-qt
+#   already has: -lstdc++, and -lc++ on macOS;
+# - the toolchain's own C runtime, which every link already has: -lc,
+#   -lgcc_s, -lgcc_eh and -lgcc, and on mingw-w64 -lmsvcrt, -lmingwex,
+#   -lmingw32 and -l:libpthread.a;
+# - glibc's -lutil and -lrt: symbol-check.py does not allow them, and the
+#   glibc standard library imports nothing from them (every symbol it uses
+#   from glibc 2.31 is in libc, libpthread, libdl or libm);
+# - macOS's -liconv, -lSystem, -lc and -lm, which the macOS linker adds anyway.
+$(package)_native_libs_ignored_linux=-lstdc++ -lc -lgcc_s -lgcc_eh -lgcc -lutil -lrt
+$(package)_native_libs_ignored_darwin=-lc++ -liconv -lSystem -lc -lm
+$(package)_native_libs_ignored_mingw32=-lstdc++ -lmsvcrt -lmingwex -lmingw32 -lgcc_eh -lgcc -l:libpthread.a
+
+define $(package)_fetch_cmds
+$(call fetch_file,$(package),$($(package)_download_path),$($(package)_download_file),$($(package)_file_name),$($(package)_sha256_hash)) && \
+( echo "$($(package)_crates_sha256_hash)  $($(package)_source_dir)/$($(package)_crates_file_name)" | $(build_SHA256SUM) -c >/dev/null 2>&1 || \
+  ( rm -f $($(package)_source_dir)/$($(package)_crates_file_name) && \
+    $(call fetch_file_inner,$(package),$(FALLBACK_DOWNLOAD_PATH),$($(package)_crates_file_name),$($(package)_crates_file_name),$($(package)_crates_sha256_hash)) ) )
+endef
+
+# Only packages/ is needed from the Platform tarball; the bundle supplies the
+# workspace manifest, lock and Cargo configuration.
+define $(package)_extract_cmds
+  echo "$($(package)_sha256_hash)  $($(package)_source)" > .$($(package)_file_name).hash && \
+  echo "$($(package)_crates_sha256_hash)  $($(package)_source_dir)/$($(package)_crates_file_name)" >> .$($(package)_file_name).hash && \
+  $(build_SHA256SUM) -c .$($(package)_file_name).hash && \
+  $(build_TAR) --no-same-owner --strip-components=1 -xf $($(package)_source) platform-$($(package)_version)/packages && \
+  $(build_TAR) --no-same-owner -xf $($(package)_source_dir)/$($(package)_crates_file_name)
+endef
+
+$(package)_rust_target=$(rust_stdlib_target)
+$(package)_cc_target=$(subst -,_,$($(package)_rust_target))
+$(package)_build_linker_var:=CARGO_TARGET_$(shell echo $(native_rust_build_target) | tr a-z- A-Z_)_LINKER
+
+# Only the bundle's .cargo/config.toml configures Cargo:
+# - Cargo reads .cargo/config.toml in the directory it runs in and in every
+#   parent, whatever --manifest-path says, so it runs from / and is given the
+#   bundle's file with --config. Configuration above the depends tree, such as
+#   ~/.cargo/config.toml when the tree is under a home directory, is therefore
+#   never read, and the build works wherever the tree is; preprocess fails if
+#   / itself has one.
+# - The Cargo home is private and empty.
+# - Environment variables that would change the build are removed:
+#   RUSTC_WORKSPACE_WRAPPER, RUSTC_BOOTSTRAP, CARGO_ENCODED_RUSTFLAGS,
+#   __CARGO_DEFAULT_LIB_METADATA, and all CARGO_BUILD_*, CARGO_PROFILE_*,
+#   CARGO_TARGET_* and CARGO_UNSTABLE_* ones, and the <VAR>_<triple> forms
+#   (such as CC_x86_64-unknown-linux-gnu) that cc-rs prefers over the
+#   <VAR>_<triple_with_underscores> ones set below; TENDERDASH_DIR and
+#   TENDERDASH_COMMITISH, which the bundle's configuration sets to the tag of
+#   the Tenderdash archive it carries.
+# - The release profile is pinned to Platform's, which is Cargo's default:
+#   opt-level 3, no debug info, no LTO, 16 codegen units, no incremental
+#   compilation, and unwinding panics (the crate refuses panic=abort). Nothing
+#   Cargo links here is installed (build scripts, the cdylib dash-sdk also
+#   declares), so nothing is stripped; on macOS that would need rust-objcopy
+#   and an LLVM library native_rust does not stage.
+$(package)_unset_env:=RUSTC_WORKSPACE_WRAPPER RUSTC_BOOTSTRAP CARGO_ENCODED_RUSTFLAGS __CARGO_DEFAULT_LIB_METADATA
+$(package)_unset_env+=TENDERDASH_DIR TENDERDASH_COMMITISH
+$(package)_unset_env+=$(filter CARGO_BUILD_% CARGO_PROFILE_% CARGO_TARGET_% CARGO_UNSTABLE_%,$(.VARIABLES))
+$(package)_unset_env+=$(filter %_$(rust_stdlib_target) %_$(native_rust_build_target),$(.VARIABLES))
+$(package)_profile_env:=CARGO_PROFILE_RELEASE_OPT_LEVEL=3 CARGO_PROFILE_RELEASE_DEBUG=false
+$(package)_profile_env+=CARGO_PROFILE_RELEASE_LTO=false CARGO_PROFILE_RELEASE_CODEGEN_UNITS=16
+$(package)_profile_env+=CARGO_PROFILE_RELEASE_PANIC=unwind CARGO_PROFILE_RELEASE_INCREMENTAL=false
+$(package)_profile_env+=CARGO_PROFILE_RELEASE_STRIP=false CARGO_INCREMENTAL=0
+
+# RUSTFLAGS takes the place of Platform's .cargo/config.toml, which the bundle
+# does not carry. Of what that file sets, --cfg tokio_unstable only enables
+# tokio APIs (runtime metrics, task hooks, io-uring) that nothing in
+# dash-sdk-cxx's dependency graph uses, target-feature=-crt-static only
+# changes musl targets (glibc targets link the C runtime dynamically anyway),
+# and target-cpu=x86-64 and -lstdc++ are the defaults or only matter for
+# executables; none of them is set here.
+#
+# For the host, the depends compiler links (through rustc-linker.sh), the C and
+# C++ sources in the crate closure (ring, blst, blake3, secp256k1, the cxx
+# bridge) are compiled with the depends compiler and flags, and the build
+# directory is remapped out of both the Rust and the C objects. Build scripts
+# and proc macros run on the build machine; build-linker.sh links them with the
+# depends build compiler, which also compiles any C they need (CC_<build
+# triple> and HOST_CC; when the build and host triples are the same, the host's
+# CC_<triple> wins and the host and build compilers are the same machine's).
+#
+# For windows-gnu, rustc creates the import libraries of raw-dylib imports
+# (windows-link, which the Rust standard library and windows-sys use) with
+# the mingw-w64 dlltool.
+define $(package)_set_vars
+$(package)_cargo_env = CARGO_HOME=$$($(package)_build_dir)/.cargo-home
+$(package)_cargo_env += CARGO_TARGET_DIR=$$($(package)_build_dir)/target
+$(package)_cargo_env += $($(package)_profile_env)
+$(package)_cargo_env += $($(package)_build_linker_var)=$$($(package)_build_dir)/build-linker.sh
+$(package)_cargo = cd / && env $$(addprefix -u ,$$($(package)_unset_env)) $$($(package)_cargo_env) \
+  cargo --config $$($(package)_build_dir)/.cargo/config.toml
+$(package)_rustflags = -C linker=$$($(package)_build_dir)/rustc-linker.sh --remap-path-prefix=$(BASEDIR)=/build
+$(package)_rustflags_mingw32 = -C dlltool=$(host_toolchain)dlltool
+$(package)_build_env += RUSTC="$(build_prefix)/bin/rustc" RUSTC_WRAPPER=
+$(package)_build_env += RUSTFLAGS="$$($(package)_rustflags) $$($(package)_rustflags_$(host_os))"
+$(package)_build_env += DEPENDS_CC="$$($(package)_cc)" DEPENDS_LDFLAGS="$$($(package)_ldflags)"
+$(package)_build_env += DEPENDS_BUILD_CC="$(build_CC)"
+$(package)_build_env += CC_$($(package)_cc_target)="$$($(package)_cc)" CXX_$($(package)_cc_target)="$$($(package)_cxx)"
+$(package)_build_env += AR_$($(package)_cc_target)="$$($(package)_ar)"
+$(package)_build_env += CFLAGS_$($(package)_cc_target)="$$($(package)_cppflags) $$($(package)_cflags) -ffile-prefix-map=$(BASEDIR)=/build"
+$(package)_build_env += CXXFLAGS_$($(package)_cc_target)="$$($(package)_cppflags) $$($(package)_cxxflags) -ffile-prefix-map=$(BASEDIR)=/build"
+$(package)_build_env += HOST_CC="$(build_CC)" HOST_CXX="$(build_CXX)"
+ifneq ($(native_rust_build_target),$($(package)_rust_target))
+$(package)_build_env += CC_$(subst -,_,$(native_rust_build_target))="$(build_CC)" CXX_$(subst -,_,$(native_rust_build_target))="$(build_CXX)"
+endif
+$(package)_build_env += PROTOC="$(build_prefix)/bin/protoc" PROTOC_INCLUDE="$(build_prefix)/include"
+ifeq ($(host_os),darwin)
+$(package)_build_env += MACOSX_DEPLOYMENT_TARGET=$(OSX_MIN_VERSION)
+ifneq ($(build_os),darwin)
+$(package)_build_env += SDKROOT="$(OSX_SDK)"
+endif
+endif
+endef
+
+# tenderdash-proto's build script extracts its sources from
+# tenderdash-$$TENDERDASH_COMMITISH.zip in its cache directory
+# (CARGO_TARGET_DIR) and would download the archive if it were missing; the
+# bundle's configuration sets the tag of the archive the bundle carries.
+define $(package)_preprocess_cmds
+  for config in /.cargo/config /.cargo/config.toml; do \
+    if test -e $$$$config; then echo "$$$$config would configure Cargo; remove it" >&2; exit 1; fi; \
+  done && \
+  cp $($(package)_patch_dir)/rustc-linker.sh $($(package)_patch_dir)/build-linker.sh . && \
+  chmod +x rustc-linker.sh build-linker.sh && \
+  tag=$$$$(sed -n 's/^TENDERDASH_COMMITISH = "\(.*\)"$$$$/\1/p' .cargo/config.toml) && \
+  if ! test -f "tenderdash/tenderdash-$$$$tag.zip"; then \
+    echo "the crate bundle has no Tenderdash archive for TENDERDASH_COMMITISH \"$$$$tag\"" >&2; exit 1; \
+  fi && \
+  mkdir -p target && \
+  cp "tenderdash/tenderdash-$$$$tag.zip" target/
+endef
+
+# The build fails if the dependency graph (normal and build dependencies, both
+# of which Cargo compiles) reaches a trusted third-party context provider, an
+# HTTP client or OpenSSL: every trust input comes from Core. The graph goes to
+# a file first, so that a failing cargo tree fails the build.
+#
+# The crate is built as a static library only, with rustc printing the system
+# libraries the archive needs; check-native-libs.sh compares them with the
+# vetted and ignored lists above. The build log goes to a file as well, and
+# the exit status to another, since a pipeline has the status of tee.
+define $(package)_build_cmds
+  ( $($(package)_cargo) tree --frozen --manifest-path $($(package)_build_dir)/Cargo.toml \
+      -p dash-sdk-cxx -e normal,build --target $($(package)_rust_target) ) > cargo-tree.txt && \
+  if grep -E 'rs-sdk-trusted-context-provider|reqwest|openssl-sys' cargo-tree.txt; then \
+    echo "dash-sdk-cxx depends on a forbidden crate" >&2; exit 1; \
+  fi && \
+  ( ( $($(package)_cargo) rustc --frozen --offline --release --manifest-path $($(package)_build_dir)/Cargo.toml \
+      -p dash-sdk-cxx --lib --crate-type staticlib --target $($(package)_rust_target) \
+      -- --print=native-static-libs ); echo $$$$? > cargo-rustc.status ) 2>&1 | tee cargo-rustc.log && \
+  test "$$$$(cat cargo-rustc.status)" = 0 && \
+  sh $($(package)_patch_dir)/check-native-libs.sh cargo-rustc.log \
+    "$($(package)_native_libs_$(host_os))" "$($(package)_native_libs_ignored_$(host_os))"
+endef
+
+# The crate's build script stages the generated bridge header dash/sdk/ffi.h,
+# dash/sdk/callbacks.h and the cxx runtime header rust/cxx.h under
+# target/<triple>/release/include; that tree, the static archive and
+# dash_sdk_cxx.pc are the installed interface. The
+# .pc file locates the prefix from its own directory.
+define $(package)_stage_cmds
+  mkdir -p $($(package)_staging_prefix_dir)/include $($(package)_staging_prefix_dir)/lib/pkgconfig && \
+  cp -R target/$($(package)_rust_target)/release/include/. $($(package)_staging_prefix_dir)/include/ && \
+  cp target/$($(package)_rust_target)/release/libdash_sdk_cxx.a $($(package)_staging_prefix_dir)/lib/ && \
+  printf '%s\n' \
+    'prefix=$$$${pcfiledir}/../..' \
+    'exec_prefix=$$$${prefix}' \
+    'libdir=$$$${prefix}/lib' \
+    'includedir=$$$${prefix}/include' \
+    '' \
+    'Name: dash_sdk_cxx' \
+    'Description: C++ binding of the Dash Platform SDK' \
+    'Version: $($(package)_version)' \
+    'Cflags: -I$$$${includedir}' \
+    'Libs: -L$$$${libdir} -ldash_sdk_cxx $($(package)_native_libs_$(host_os))' \
+    > $($(package)_staging_prefix_dir)/lib/pkgconfig/dash_sdk_cxx.pc
+endef
diff --git a/depends/packages/rust_stdlib.mk b/depends/packages/rust_stdlib.mk
new file mode 100644
index 000000000000..e6600acac2be
--- /dev/null
+++ b/depends/packages/rust_stdlib.mk
@@ -0,0 +1,65 @@
+# Copyright (c) 2016-2025 The Zcash developers
+# Copyright (c) 2026 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Precompiled Rust standard library for the host, installed next to the
+# native_rust compiler. The version follows native_rust.mk; update both with
+# ./contrib/devtools/update-rust-hashes.py
+
+package:=rust_stdlib
+$(package)_version:=$(native_rust_version)
+$(package)_download_path:=$(native_rust_download_path)
+
+# Every host in contrib/guix/guix-build's default HOSTS has an entry. Linux
+# hosts use the glibc (-unknown-linux-gnu) standard library, the one Rust
+# supports for linking into a glibc program. Its libc imports are unversioned
+# in the archive and bind at link time to the glibc the program is linked
+# against; every symbol it requires unconditionally exists in glibc 2.31 on
+# all five Linux architectures (the rest are weak and looked up at run time).
+
+# Linux (x86_64)
+$(package)_target_x86_64_linux:=x86_64-unknown-linux-gnu
+$(package)_sha256_hash_x86_64_linux:=eddab0358cbd12aeb897716aab00d1db7b59696e85b9ac4982e72259a9a976b1
+
+# Linux (ARMv8)
+$(package)_target_aarch64_linux:=aarch64-unknown-linux-gnu
+$(package)_sha256_hash_aarch64_linux:=779407b14507542581216d89eb9f3fbb232abbf3abcc15c365cb32fa0614e409
+
+# Linux (RISC-V 64)
+$(package)_target_riscv64_linux:=riscv64gc-unknown-linux-gnu
+$(package)_sha256_hash_riscv64_linux:=bea4eac8f0b752aec63389d626d96280424da68b033c2d515bc4af204f07bf44
+
+# Linux (ARMv7, hard float)
+$(package)_target_arm_linux:=armv7-unknown-linux-gnueabihf
+$(package)_sha256_hash_arm_linux:=6f15060d308793d1687a5092c80f2fbebc808c73096980b67f9de71d4f54f92c
+
+# Linux (POWER, big endian)
+$(package)_target_powerpc64_linux:=powerpc64-unknown-linux-gnu
+$(package)_sha256_hash_powerpc64_linux:=2d6268b4dddc385c24ae77b2e1fe16161781b92958108cbb2a6f9fab21689823
+
+# Windows (x86_64)
+$(package)_target_x86_64_mingw32:=x86_64-pc-windows-gnu
+$(package)_sha256_hash_x86_64_mingw32:=0cda26447df0749bc84044be8c8083ac4dc87bf137c11cc31ec9673a6e2e0344
+
+# macOS (x86_64)
+$(package)_target_x86_64_darwin:=x86_64-apple-darwin
+$(package)_sha256_hash_x86_64_darwin:=af7ffb3b408aa2f6a6940fc83ea6dc9c3e919d18f1b04f1a581b7896441e8b78
+
+# macOS (ARMv8)
+$(package)_target_aarch64_darwin:=aarch64-apple-darwin
+$(package)_sha256_hash_aarch64_darwin:=840484e8f9c2a8ed024b706262a1257bb07d9617670a1fc90020536282950690
+
+$(package)_target:=$($(package)_target_$(host_arch)_$(host_os))
+$(package)_sha256_hash:=$($(package)_sha256_hash_$(host_arch)_$(host_os))
+
+ifeq ($($(package)_target),)
+$(error rust_stdlib has no Rust standard library for $(host))
+endif
+
+$(package)_file_name:=rust-std-$($(package)_version)-$($(package)_target).tar.gz
+
+define $(package)_stage_cmds
+  mkdir -p $($(package)_staging_dir)$(build_prefix)/lib/rustlib && \
+  cp -R rust-std-$($(package)_target)/lib/rustlib/$($(package)_target) $($(package)_staging_dir)$(build_prefix)/lib/rustlib/
+endef
diff --git a/depends/patches/platform_cxx/build-linker.sh b/depends/patches/platform_cxx/build-linker.sh
new file mode 100755
index 000000000000..da7d04b6a9cc
--- /dev/null
+++ b/depends/patches/platform_cxx/build-linker.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+export LC_ALL=C
+set -f
+# Links build scripts and proc macros, which run on the build machine, with the
+# depends build compiler. rustc's `-C linker=` takes a single executable, but
+# DEPENDS_BUILD_CC is a command line (on macOS with an -isysroot flag).
+# shellcheck disable=SC2086
+exec $DEPENDS_BUILD_CC "$@"
diff --git a/depends/patches/platform_cxx/check-native-libs.sh b/depends/patches/platform_cxx/check-native-libs.sh
new file mode 100755
index 000000000000..51d1bad850f3
--- /dev/null
+++ b/depends/patches/platform_cxx/check-native-libs.sh
@@ -0,0 +1,42 @@
+#!/bin/sh
+export LC_ALL=C
+set -f
+# Usage: check-native-libs.sh <build log> <vetted libraries> <ignored libraries>
+#
+# Fails unless every system library rustc reports for the static archive (the
+# "native-static-libs" note in the build log) is vetted or ignored, so that
+# whoever bumps the Platform pin or the Rust toolchain notices a new one.
+log=$1
+vetted=$2
+ignored=$3
+
+libs=$(sed -n 's/^note: native-static-libs: //p' "$log")
+if test -z "$libs"; then
+  echo "rustc reported no native-static-libs in $log" >&2
+  exit 1
+fi
+echo "rustc native-static-libs: $libs"
+
+unvetted=
+framework=
+for word in $libs; do
+  if test "$word" = -framework; then
+    framework=yes
+    continue
+  fi
+  lib=$word
+  if test -n "$framework"; then
+    lib="-framework $word"
+    framework=
+  fi
+  case " $vetted $ignored " in
+    *" $lib "*) ;;
+    *) unvetted="$unvetted $lib" ;;
+  esac
+done
+
+if test -n "$unvetted"; then
+  echo "rustc reports system libraries platform_cxx.mk has not vetted:$unvetted" >&2
+  echo "Check each against contrib/guix/symbol-check.py, then add it to platform_cxx_native_libs_<os>, or with the reason to platform_cxx_native_libs_ignored_<os>." >&2
+  exit 1
+fi
diff --git a/depends/patches/platform_cxx/rustc-linker.sh b/depends/patches/platform_cxx/rustc-linker.sh
new file mode 100755
index 000000000000..db2063792520
--- /dev/null
+++ b/depends/patches/platform_cxx/rustc-linker.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+export LC_ALL=C
+set -f
+# rustc's `-C linker=` takes a single executable, but the depends compiler is
+# a command line (target and sysroot flags, under Guix an `env -u ...` prefix).
+# platform_cxx.mk passes that command in DEPENDS_CC and the link flags in
+# DEPENDS_LDFLAGS; word splitting them here keeps every part, and set -f keeps
+# a flag with a glob character from being expanded.
+# shellcheck disable=SC2086
+exec $DEPENDS_CC $DEPENDS_LDFLAGS "$@"
diff --git a/doc/dependencies.md b/doc/dependencies.md
index a54e60efbe03..ed49a3fec2bd 100644
--- a/doc/dependencies.md
+++ b/doc/dependencies.md
@@ -36,6 +36,13 @@ You can find installation instructions in the `build-*.md` file for your platfor
 | [qrencode](../depends/packages/qrencode.mk) | [link](https://fukuchi.org/works/qrencode/) | [4.1.1](https://github.com/bitcoin/bitcoin/pull/27312) | | No |
 | [Qt](../depends/packages/qt.mk) | [link](https://download.qt.io/official_releases/qt/) | [5.15.18](https://github.com/dashpay/dash/pull/6949) | [5.11.3](https://github.com/bitcoin/bitcoin/pull/24132) | No |
 
+### Dash Platform GUI (`--enable-platform-gui`, depends `PLATFORM_GUI=1` only)
+| Dependency | Releases | Version used | Minimum required | Runtime |
+| --- | --- | --- | --- | --- |
+| [Rust](../depends/packages/native_rust.mk) (compiler and standard library) | [link](https://forge.rust-lang.org/infra/other-installation-methods.html#standalone-installers) | 1.98.1 | 1.98.1 | No |
+| [protoc](../depends/packages/native_protobuf.mk) (build tool) | [link](https://github.com/protocolbuffers/protobuf/releases) | 32.0 | 25.0 | No |
+| [dash-sdk-cxx](../depends/packages/platform_cxx.mk) (Dash Platform SDK C++ binding) | [link](https://github.com/dashpay/platform) | commit [dc4dc8e...](https://github.com/dashpay/platform/tree/dc4dc8e80ef8c495be693d4cc19c378a94f5d116) | | No |
+
 ### Networking
 | Dependency | Releases | Version used | Minimum required | Runtime |
 | --- | --- | --- | --- | --- |
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index ca191acfef7b..53eec4a79bde 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -487,6 +487,9 @@ endif
 if ENABLE_ZMQ
 bitcoin_qt_ldadd += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
 endif
+if ENABLE_PLATFORM_GUI
+bitcoin_qt_ldadd += $(PLATFORM_CXX_LIBS)
+endif
 bitcoin_qt_ldadd += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBDASHBLS) $(LIBUNIVALUE) $(LIBLEVELDB) $(LIBMEMENV) \
   $(BACKTRACE_LIBS) $(QT_LIBS) $(QT_DBUS_LIBS) $(QR_LIBS) $(BDB_LIBS) $(MINIUPNPC_LIBS) $(NATPMP_LIBS) $(SQLITE_LIBS) $(LIBSECP256K1) \
   $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS) $(GMP_LIBS)
diff --git a/src/Makefile.qttest.include b/src/Makefile.qttest.include
index 4690c07a5ea0..f7d1615836d6 100644
--- a/src/Makefile.qttest.include
+++ b/src/Makefile.qttest.include
@@ -87,6 +87,9 @@ endif
 if ENABLE_ZMQ
 qt_test_test_dash_qt_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
 endif
+if ENABLE_PLATFORM_GUI
+qt_test_test_dash_qt_LDADD += $(PLATFORM_CXX_LIBS)
+endif
 qt_test_test_dash_qt_LDADD += $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBDASHBLS) $(LIBUNIVALUE) $(LIBLEVELDB) \
   $(LIBMEMENV) $(BACKTRACE_LIBS) $(QT_LIBS) $(QT_DBUS_LIBS) $(QT_TEST_LIBS) \
   $(QR_LIBS) $(BDB_LIBS) $(MINIUPNPC_LIBS) $(NATPMP_LIBS) $(SQLITE_LIBS) $(LIBSECP256K1) \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 90a0ed75ed64..28474503589a 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -276,6 +276,9 @@ if ENABLE_WALLET
 test_test_dash_LDADD += $(LIBBITCOIN_WALLET)
 test_test_dash_CPPFLAGS += $(BDB_CPPFLAGS)
 endif
+if ENABLE_PLATFORM_GUI
+test_test_dash_LDADD += $(PLATFORM_CXX_LIBS)
+endif
 test_test_dash_LDADD += $(LIBBITCOIN_NODE) $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) \
   $(LIBDASHBLS) $(LIBLEVELDB) $(LIBMEMENV) $(BACKTRACE_LIBS) $(LIBSECP256K1) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS) $(MINISKETCH_LIBS)
 test_test_dash_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)