Open-source remote desktop, honestly reviewed. No marketing fluff — just what you get when you self-host it.

TL;DR

What it is: Open-source (AGPL-3.0) remote desktop application — think TeamViewer or AnyDesk, but the relay infrastructure runs on your server and the vendor can’t price you out of your workflow [README][5].
Who it’s for: IT support teams, sysadmins, and small-business owners who need reliable unattended remote access across Windows, macOS, Linux, and Android without paying per-seat SaaS fees [1][homepage].
Cost savings: TeamViewer business plans run $50–100+/month; AnyDesk forced corporate-tier pricing on individual users. RustDesk’s self-hosted OSS server runs free on a $5–10/mo VPS [1][README].
Key strength: Works out of the box against public servers with zero configuration — self-hosting is optional, not mandatory. When you do self-host, three Docker commands get you a working relay server [2][homepage].
Key weakness: AGPL-3.0 license creates friction for commercial embedding. The OSS server is bare infrastructure — no web console, no user management, no audit logs. And the website’s heavy “SELF-HOSTED” focus confuses non-server users who just want the client [1][5].

What is RustDesk

RustDesk is a remote desktop application written in Rust that lets you view and control another computer over the network. You install a small client on both machines, and they connect through either RustDesk’s public servers or your own self-hosted relay. The GitHub description puts it plainly: “An open-source remote desktop application designed for self-hosting, as an alternative to TeamViewer.” [README]

What separates it from the pile of TeamViewer alternatives is the architecture. RustDesk splits the server into two components: hbbs (the ID/signaling server that coordinates who connects to whom) and hbbr (the relay server that handles traffic when direct peer-to-peer connections fail) [5]. When computer A tries to reach computer B, it first attempts NAT hole-punching for a direct connection — no relay bandwidth consumed, no latency penalty. The relay only kicks in when hole-punching fails [5]. In practice, hole-punching succeeds most of the time, which is why the relay server requirements are so modest.

The project has been accumulating attention fast. As of this review it sits at 109,520 GitHub stars with 15,000+ forks, 30M+ client downloads, 10M+ Docker downloads, and claims 10M+ alive devices on its network [homepage]. That’s not a niche tool — that’s infrastructure being taken seriously at scale.

There are two server tiers. RustDesk Server OSS is the open-source backend: hbbs and hbbr, deployable anywhere, community-supported. RustDesk Server Pro adds a web console, REST API, OIDC/LDAP, 2FA, device management, access control lists, and multi-relay management — these are commercial features, not free [5]. The client application is the same regardless of which server backend you point it at.

Why People Choose It

The immediate driver is pricing pressure. AnyDesk shifted to corporate-tier pricing, making it uneconomical for individuals with even a handful of machines. TeamViewer did the same thing years earlier. One reviewer [1] describes the exact migration path: needed unattended access to 3 PCs plus occasional access to dozens of machines during peak periods, couldn’t find a SaaS product that priced that use case affordably, and ended up on RustDesk through forum recommendations.

The secondary driver is data sovereignty. Routing screen captures and keyboard input through a third-party SaaS relay is a real concern for anyone handling client data, patient records, or sensitive internal systems. With RustDesk, the traffic stays on infrastructure you control — or, if hole-punching succeeds, it never hits a relay at all [5].

The tertiary driver, specific to power users, is the self-hosted control plane. RustDesk Server Pro gives IT teams a web console with device grouping, ACL-based access policies, and centralized user management. The 1.5.0 release added user-level ACL and device groups [blog]. That’s not a feature set you’d expect from a project that launched as a hobbyist alternative.

What the BikeGremlin review [1] also surfaces is a less obvious UX benefit: the client works immediately without self-hosting. Point it at RustDesk’s public servers, get an ID, share that ID with whoever you want to grant access, and you’re connecting. Self-hosting is an upgrade path, not a requirement. That lowers the evaluation barrier significantly for non-technical users who want to try it before committing a VPS to it.

Features

Core connectivity:

NAT hole-punching for direct peer-to-peer connections; relay fallback when direct fails [5]
Unattended access via permanent password, or interactive access via one-time password [1][4]
ID-based addressing — you share a numeric ID with the remote party, no IP address needed [4][1]

Client platforms:

Windows (portable .exe or installed .msi), macOS, all major Linux distributions (Debian/Ubuntu, Red Hat/Fedora, Arch, openSUSE, NixOS), Android [4]
iOS supported for viewing/controlling others; cannot be controlled from iOS [4]
Web client — host it on your own domain with a reverse proxy for HTTPS access [homepage]
50+ UI languages [homepage]

Display and input:

Scale adaptive view, quality vs. latency tradeoff in settings [1]
Clipboard sync, file transfer [documentation]
Hardware codec support for lower CPU usage [4]
Audio capture [4]

Configuration:

Encrypted config string for mass client deployment — generate in Server Pro, push to clients via --config flag [4]
90+ configurable options in Server Pro [homepage]
Custom branding: your name, icon, logo on the client application [homepage]

Server Pro features (commercial-gated):

Web console for centralized device and user management [5]
OIDC, LDAP, 2FA authentication [5]
Access control lists at user and device-group level [5][blog]
Multi-relay management [5]
REST API [5]

OSS server (free):

hbbs + hbbr only — no web console, no user management, no ACLs [5]
Community support via Discord [5]

Pricing: SaaS vs Self-Hosted Math

RustDesk Server OSS:

Software: $0 (AGPL-3.0) [README]
VPS to run it: $5–10/month (Hetzner CX11 or equivalent handles most deployments)
Total: ~$5–10/month with no per-seat, per-session, or per-device fees

RustDesk Server Pro:

Starting at $9.90/month [pricing page]
Adds web console, ACL, LDAP/OIDC, device management, multi-relay — the features that matter past 10 users

The competitor context: The BikeGremlin reviewer [1] abandoned AnyDesk specifically because AnyDesk’s pricing became untenable for the combination of a few unattended machines plus occasional one-off access. TeamViewer has a history of flagging free accounts for “commercial use” and demanding subscription payments. Neither company publishes transparent small-team pricing that works for the “3 permanent machines + rare ad-hoc access” use case.

Savings math for a typical IT support owner: Say you’re managing 10 machines with unattended access, occasional remote support sessions. On TeamViewer Business you’re looking at $50–100+/month depending on tier and seat count. On AnyDesk Business, similar range. On RustDesk OSS self-hosted: a $6/month Hetzner VPS and zero per-device fees. That’s ~$600–1,200/year returned to your pocket, in exchange for an afternoon of setup.

RustDesk Server Pro at $9.90/month is still far cheaper than any TeamViewer or AnyDesk tier and buys you the management console that OSS doesn’t include.

Note: RustDesk’s pricing page mentions custom pricing for larger plans. The OSS tier has no user limits, device limits, or connection limits — it’s raw relay infrastructure, and you provision as much as your VPS can handle [2][5].

Deployment Reality Check

The homepage sells self-hosting as three commands, and for Docker that’s accurate [2][homepage]:

bash <(wget -qO- https://get.docker.com)
wget rustdesk.com/oss.yml -O compose.yml
docker compose up -d

That’s the happy path. What the documentation [2][5] and the BikeGremlin experience [1] together reveal about reality:

What you actually need:

A Linux VPS with a public IP — bandwidth requirements are low (30 KB/s for office work, up to 3 MB/s for 1080p screen sharing) [5]
Ports opened on your firewall: TCP 21114–21119, UDP 21116 [5]
Docker and docker-compose (or systemd if you prefer native services)
A domain and reverse proxy (nginx or Caddy) if you want the web client with HTTPS

What the OSS tier doesn’t give you:

Any web interface to manage users or devices
Access logs
User authentication — anyone with a device ID and password can connect
Multi-relay if you want geographic distribution

What can confuse first-time users: The BikeGremlin reviewer [1] flagged this directly: the RustDesk website is so focused on self-hosting that a new user who just wants the client gets confused about where to download it. The client download is on GitHub releases, not prominently linked from the homepage. The site is optimized for operators, not end users evaluating the product. That’s a minor UX friction but worth knowing.

The same reviewer also noted that autostart behavior differs between Windows and Linux. On Windows the installer sets RustDesk to autorun (disable via Apps → Startup). On Linux the systemd service starts at boot and needs manual disabling via sudo systemctl disable rustdesk.service [1]. Neither is a dealbreaker, but it catches people off guard.

For alternative installation methods: The documentation [2] lists a community-maintained install script from Techahold for systemd-based deployments, and Debian packages for systems using native package management. The Docker route is the one supported and documented by the core team.

Realistic time estimates:

Technical user with Docker experience: 30–45 minutes to a working self-hosted relay
Non-technical user following a guide: 2–3 hours including firewall and domain setup
Client-only (using public servers, no self-hosting): under 10 minutes

Pros and Cons

Pros

Works immediately without self-hosting. Install the client, get an ID, start connecting. Self-hosting is an upgrade, not a prerequisite [4][1]. Lower evaluation friction than tools that require a server before you can test anything.
Genuinely low hardware requirements. The relay server runs comfortably on the cheapest VPS tier available. A Raspberry Pi works [2][5].
NAT hole-punching reduces relay dependency. In most real-world conditions, direct peer-to-peer connections succeed and no relay traffic is consumed [5]. Your relay server bill doesn’t scale linearly with session count.
109K+ GitHub stars, 10M+ alive devices. This isn’t an abandoned project. The community is active, forks are current, and there’s a real company behind it [homepage][README].
Cross-platform client with broad Linux distro support. Debian, Red Hat, Arch, openSUSE, NixOS, Flatpak — better Linux coverage than most commercial alternatives [4].
Custom branding on Pro. Build RustDesk into your own support workflow with your logo and client name — relevant for MSPs and IT teams deploying to clients [homepage].
Web client option. Host a browser-based connection endpoint on your own domain [homepage].
Three-command Docker install. The happy path is genuinely as simple as advertised [2][homepage].

Cons

AGPL-3.0, not MIT. AGPL requires that if you distribute software incorporating RustDesk’s server code, you must open-source your modifications. For a solo operator self-hosting, this is irrelevant. For an MSP embedding it in a managed service product, it requires legal review. TeamViewer and AnyDesk aren’t open-source at all, so this is still a net positive — but it’s a different license profile than MIT tools like Activepieces.
OSS server is bare infrastructure. No web console, no user accounts, no ACLs, no access logs [5]. You’re running two relay daemons. If you need management features, you’re buying Server Pro.
The website confuses first-time users. “SELF-HOSTED” plastered everywhere sends non-server users on a detour before they find the client download [1]. GitHub releases is where clients live.
iOS cannot be controlled. You can remote into other machines from an iPhone, but you can’t control an iPhone remotely [4]. This is an Apple platform restriction, not a RustDesk choice, but it’s a real gap for mobile support workflows.
Limited third-party review corpus. Compared to TeamViewer or AnyDesk, independent long-term reviews of RustDesk in production at scale are sparse. Most coverage is installation guides and short-term evaluations. The lack of public reviews makes it harder to assess stability under heavy load.
Misuse disclaimer in the README. The README opens with a caution about unauthorized access [README]. This isn’t a reason to avoid the tool, but it signals that the same properties that make RustDesk useful for legitimate remote support make it attractive for abuse. Legitimate deployments should use strong passwords, the fixed-password unattended access mode with access controls, and ideally Server Pro’s ACL features.

Who Should Use This / Who Shouldn’t

Use RustDesk if:

You’re paying TeamViewer or AnyDesk monthly fees for remote access to fewer than 50 machines and the cost is irrational for what you actually use.
You’re an IT support provider or MSP who needs remote access to client machines without per-device SaaS costs eating into margins.
You need cross-platform support and your Linux coverage matters — the distro support list is better than most competitors [4].
Your compliance posture requires that remote session data stays on infrastructure you control, not a third-party relay.
You’re comfortable with Docker and a Linux VPS, or willing to pay someone to set it up once.

Skip it (stay on TeamViewer/AnyDesk) if:

You have a corporate security team that won’t approve software without SOC 2 certification and a commercial support contract. RustDesk OSS has neither.
You need iOS remote control. That platform is blocked by Apple policy [4].
You need a fully managed, zero-ops experience — RustDesk’s public relay is free but there’s no SLA, and self-hosting requires you to maintain the VPS.

Use RustDesk Server Pro instead of OSS if:

You’re managing more than ~10 machines and need centralized visibility into who connected to what and when.
Your organization uses LDAP/Active Directory for authentication and you need SSO instead of per-device passwords.
You’re deploying to a team and need ACL-based access policies rather than trusting everyone with the permanent password [5].

Skip it (pick a web-based alternative) if:

You specifically need browser-based screen sharing without installing client software on both ends — RustDesk requires the client application on controlled machines, though the web client covers the remote end [homepage].

Alternatives Worth Considering

Apache Guacamole — web-based remote desktop gateway (RDP, VNC, SSH) with no client installation on the connecting end. Better for browser-only access. More complex to self-host.
Sunshine + Moonlight — specifically for game streaming and high-performance remote GPU access. Not for IT support workflows.
xRDP — native Linux RDP server, paired with a Windows RDP client. Free, no relay needed on the same network, but no hole-punching and no managed relay infrastructure.
NoMachine — proprietary, free for personal use, fast NX protocol. Not self-hostable in the same way; the relay is NoMachine’s.
Tailscale + VNC/RDP — a different architecture: build a private WireGuard network with Tailscale (free tier available), then run standard VNC or RDP over it. No relay needed. More moving parts but zero dependency on any remote desktop vendor’s infrastructure.
TeamViewer — still the category benchmark for ease of use and feature depth, but the pricing and “commercial use detected” enforcement make it increasingly hostile to small operators.
AnyDesk — similar story to TeamViewer; the individual-use pricing that attracted early adopters has been replaced by corporate tiers [1].

For a non-technical founder or solo IT operator, the realistic shortlist is RustDesk OSS self-hosted vs. RustDesk Server Pro. The question isn’t which tool — it’s whether the management console at $9.90/month is worth it for your team size. Under 10 machines with a single operator: OSS. Past 10 machines with multiple technicians: Pro.

Bottom Line

RustDesk is what TeamViewer was supposed to be before TeamViewer discovered enterprise pricing. The client installs in minutes, works immediately against public servers, and — when you’re ready — points at your own relay with three Docker commands and an open firewall port. The OSS server is deliberately minimal: it’s relay infrastructure, not a management platform. For a solo operator or small IT team that knows what a VPS is, the math is obvious: a $6/month Hetzner box versus $50–100+/month for any commercial remote desktop subscription. The trade-offs are real — AGPL-3.0 instead of MIT, no management console without paying for Pro, a website that confuses users who just want the client download. But 109,520 GitHub stars and 10 million alive devices suggest those trade-offs aren’t stopping anyone. If you’re still paying TeamViewer or AnyDesk bills and you have ten minutes to install a client and one afternoon to set up a VPS, you already know what to do.

If the VPS setup is the blocker, that’s exactly what upready.dev deploys for clients — one-time fee, running, yours to own.

Sources

Relja Novović, Bike Gremlin I/O — “Rustdesk — remote access software” (hands-on installation and configuration review). https://io.bikegremlin.com/38997/rustdesk-remote-access-software/
RustDesk Documentation — “Installation — RustDesk Server OSS” (official self-hosting install guide). https://rustdesk.com/docs/en/self-host/rustdesk-server-oss/install/
RustDesk Documentation — “Video Tutorials”. https://rustdesk.com/docs/en/videos/
RustDesk Documentation — “RustDesk Client” (platform support, installation, configuration). https://rustdesk.com/docs/en/client/
RustDesk Documentation — “Self-host” (server architecture, OSS vs Pro comparison, port requirements). https://rustdesk.com/docs/en/self-host/