Open-source, self-hosted remote desktop built in Rust — your data, your infrastructure, no third-party cloud.
RustDesk is a fully open-source remote desktop application that gives individuals and organizations complete control over their remote access infrastructure. Written in Rust for memory safety and high performance, it delivers screen sharing, file transfer, clipboard sync, and TCP tunneling across Windows, macOS, Linux, Android, iOS, and the web — all without routing traffic through any third-party server.
At its core, RustDesk uses a rendezvous-and-relay architecture where a lightweight self-hosted server handles peer discovery and fallback relay traffic while the actual session data travels peer-to-peer via TCP hole punching. This means low latency for most connections and zero bandwidth cost on the relay server when a direct path is available.
The client is built with Flutter for a native cross-platform experience, bridged to a Rust backend via flutter_rust_bridge. The UI adapts to desktop and mobile form factors with full touch support, hardware-accelerated video codecs, and a real-time QoS engine that dynamically adjusts frame rate and bitrate based on measured network latency — not static presets.
For teams and enterprises, RustDesk Server Pro adds centralized user management, device groups, LDAP/OIDC authentication, per-user access control lists, audit logging, and a custom client generator for branded internal deployments. The open-source community edition covers the full remote-access feature set with no seat limits.
Architecture RustDesk is organized as a multi-crate Rust workspace where responsibilities are cleanly partitioned: screen capture lives in a dedicated scrap crate, cross-platform input emulation in enigo, clipboard logic in a clipboard crate, and all network and protocol utilities in hbb_common. The main crate wires these together through a service-oriented architecture where audio, video, input, and clipboard each run as independent async services coordinated by a shared connection manager. Platform-specific code is isolated behind conditional compilation flags in a platform module, so the same high-level connection logic runs unchanged on Windows, macOS, and Linux. The Flutter UI communicates with the Rust backend exclusively through a generated FFI bridge, keeping UI state entirely separate from connection state and making it straightforward to add new platforms without touching core logic.
Tech Stack The backend is written in Rust 1.75+ using Tokio for async I/O throughout, with Protobuf-encoded messages over TCP/UDP for the rendezvous and relay protocol. Screen capture uses platform-native APIs (ScreenCaptureKit on macOS, DXGI on Windows, PipeWire/X11 on Linux) abstracted through the scrap crate, while video encoding leverages libvpx, libyuv, and optionally hardware codecs via platform acceleration APIs. The cross-platform UI is built with Flutter and Dart, bridged to Rust via flutter_rust_bridge, giving the application a single consistent UI codebase that compiles to native ARM and x86 binaries on mobile and desktop. Build dependencies are managed through vcpkg for native C/C++ libraries, with a Dockerized build environment ensuring reproducible compilation across all target platforms.
Code Quality The codebase exhibits consistently idiomatic Rust: Result and Option types are used throughout rather than panics or unwraps in hot paths, shared mutable state is managed with Arc/RwLock and crossbeam channels, and async code follows Tokio best practices with select! and interval timers for connection lifecycle management. The test suite includes unit tests embedded in source files covering IPC, language handling, platform detection, and connection management, and the CI pipeline (GitHub Actions) runs builds and tests across all target platforms on every commit. Comment density is high in the networking and QoS modules where the algorithms are non-trivial, providing clear rationale for timing constants and bitrate control decisions. The project maintains a CONTRIBUTING.md and AGENTS.md, and its multilingual README in over 25 languages reflects a mature community contribution process.
What Makes It Unique RustDesk’s most technically distinctive choice is its real-time video QoS engine in the video_qos module, which maintains a sliding history of per-user round-trip delays and independently adjusts both frame rate and bitrate based on whether measured latency crosses a 150ms threshold — a level of adaptive control typically found only in commercial video conferencing stacks. The combination of Rust’s memory safety with Flutter’s cross-platform UI via flutter_rust_bridge is unusual in the remote desktop space and enables a single codebase to ship native-performance clients on six platforms without per-platform rewrites. The plugin callback system exposes connection lifecycle hooks at the native Rust layer, allowing behavior extensions that run at full performance without scripting overhead. Finally, the TOTP 2FA implementation uses encrypted secret storage managed entirely within the Rust process, eliminating the need for any external identity provider even in self-hosted deployments.
RustDesk is licensed under the GNU Affero General Public License version 3 (AGPL-3.0). This means you can freely use, modify, and self-host it without paying any license fees, including for commercial internal use. The copyleft condition requires that if you distribute modified versions or run the software as a network service that others access, you must make the corresponding source code available under the same AGPL terms. For most self-hosters running RustDesk internally — IT teams, businesses supporting their own employees, educational institutions — this has no practical impact. However, if you plan to build a commercial SaaS product on top of RustDesk or distribute a modified client externally, you will need to publish your modifications or negotiate a commercial license with the RustDesk team.
Running RustDesk yourself means operating both the client application and the rustdesk-server (or rustdesk-server-s6), which handles rendezvous and relay. The server is lightweight and can run on a modest VPS — a single CPU and 1 GB of RAM is sufficient for dozens of concurrent sessions when most traffic travels peer-to-peer. You are responsible for provisioning the server, configuring firewall rules (TCP 21115-21119 and UDP 21116), managing TLS certificates, handling software updates, and monitoring uptime. Backup requirements are minimal since the server is largely stateless; peer credentials and configuration live on the client devices.
The community open-source edition covers the full remote-access feature set with no seat limits, but it lacks centralized management capabilities. RustDesk Server Pro, the commercial tier, adds a web-based admin console, user and device group management, LDAP/OIDC single sign-on, per-user ACLs, audit logging, and a custom client generator for branded deployments. The Pro tier also includes priority support with SLAs, which the community edition does not offer. Teams evaluating whether to self-host should weigh the operational burden of managing server infrastructure against the cost of Pro licensing or a competing managed SaaS alternative — for organizations with existing DevOps capacity, the community edition provides significant cost savings with full feature parity for basic remote access scenarios.