Open source remote desktop software and how the licences differ

Of the tools on a typical “open source remote desktop” list, three are full support tools with their own agent, relay and control plane, and all three can be self-hosted: RustDesk, MeshCentral and Roomler. MeshCentral is Apache-2.0 with no commercial edition. Roomler’s server is AGPL-3.0 and its agent is MPL-2.0. Everything else on those lists is a component: TigerVNC implements a protocol, Remmina and FreeRDP are a client and a library, Apache Guacamole is a gateway, and Tailscale and NetBird are mesh networks with no screen. The question that sorts the field is which component is open, and under which licence.

Four kinds of tool hide behind one search term

A list that scores TigerVNC and RustDesk on the same feature checklist is a catalogue, and a catalogue cannot tell you what to run. A VNC server implements a protocol. It brings no NAT traversal, no identity, no consent prompt and no audit, so you wrap it in SSH or a VPN, add the missing pieces yourself, and end up running a stack. Four kinds of thing share the search term:

• VNC servers and viewers: TigerVNC, TightVNC, UltraVNC.
• RDP libraries and multi-protocol clients: FreeRDP, Remmina, xrdp.
• Browser gateways that speak those protocols for you: Apache Guacamole, which reaches RDP, VNC and SSH targets and has no agent of its own.
• Full support tools with their own agent, relay and control plane: RustDesk, MeshCentral, Roomler.

Only the fourth kind replaces TeamViewer on its own. The parts to compare across them are the viewer, the agent on the controlled machine, the relay, and the control plane that authenticates you and introduces the two ends.

Roomler’s own compare pages begin at the other end. Every product on them is better than Roomler at the thing it was built for, with more years, more users, more platforms and more polish in its own lane, and each page says where before anything else. The comparison those pages make is against the stack people assemble: Tailscale plus RustDesk means two agents, two control planes, two identity systems and two audit trails on every machine, and the remote-desktop half has no idea the mesh exists. If your problem sits squarely in another product’s lane, the pages tell you to use that product.

The field, sorted by what is open and under which licence

The split matters because the closed component is the one that can change terms on you. The most common complaint about the incumbents’ free tier is being flagged as a commercial user and locked out mid-session, and that decision is made in a control plane you cannot read. A protocol implementation has no control plane to change terms with, and none to get you through NAT.

Roomler’s split: an AGPL server and an MPL agent

The server is AGPL-3.0, and the agent that runs on the machines you control is MPL-2.0. The AGPL is a copyleft licence whose source-sharing obligation also covers software offered over a network; the MPL is a file-level copyleft that allows its files to be combined with proprietary code. That server is one container: API, web app, signalling plane, chat and conferencing server, relay floor.

The agent’s licence was chosen so that a managed-service provider can ship it to client machines. Running it for yourself, your family or your company is exactly what the licence is for, and LICENSING.md on GitHub spells out the split and what changes if you offer the product itself as a service.

MeshCentral is Apache-2.0 throughout, with no licence split and no commercial edition, which the docs call simpler than Roomler’s AGPL server if any copyleft is a problem for you.

Self-hosting runs the same code as the hosted service, on your own machine, with nothing held back. A self-hosted server has no plan limits. You need Docker with Compose v2, about 4 GB of RAM and 10 GB of disk for the Roomler container plus MongoDB and MinIO. Run the compose pull before the compose up: Compose treats a service with a build section as buildable, so without the pull it compiles the image from source, silently, instead of downloading the published one. The documented limits are a single node in the compose file, no automatic TLS, and arm64 images that are published but have not yet been run end to end as a whole stack.

What RustDesk, MeshCentral and TeamViewer do better

RustDesk has years of production use and an enormous install base, so its viewer and codec paths have been exercised by far more people and far more hardware than Roomler’s. It has native clients everywhere, including iOS and Android, and Roomler has no mobile viewer. It has a large community and does one thing, and if your problem is seeing and controlling a remote screen, RustDesk solves exactly that.

MeshCentral has the RMM surface Roomler lacks: hardware inventory, power control, out-of-band management, software deployment and device groups. It relays RDP, VNC and SSH through its web interface to devices that will never run its agent, and Roomler does not. It has more than a decade of production use behind it and runs on hardware where Roomler’s stack would not.

TeamViewer and AnyDesk have two decades of polish, clients for every platform including iOS, Android, ChromeOS and appliances, the attended-support workflow, and the certifications and support contracts a purchasing department already knows. They let you help a stranger by reading an ID and a password to each other over the phone, and Roomler cannot do that today, because both machines must be in the same organization.

If you need a mesh with SSO and SCIM provisioning, NetBird is the direct answer, and Roomler has neither. If your problem is purely a private network between your machines, the docs call Tailscale an easy recommendation. Every side-by-side table on those pages lists Roomler’s maturity as “Young”. The full pages are Roomler vs RustDesk, Roomler vs MeshCentral and Roomler vs TeamViewer and AnyDesk.

Where Roomler differs from the other open tools

The viewer is a browser tab, with Chrome, Edge or another Chromium browser recommended, and nothing is installed on the viewing side. Only the machine you reach runs an agent. That matters on a machine you do not control, such as a client’s laptop or a borrowed computer. The tour post walks through an install, a first connection and the lock screen.

The same agent puts the machine on a private WireGuard-style mesh with a stable address and a name, so after the session you can still reach a database, an internal web app or SSH on it with no second product. After a RustDesk session you still cannot reach the machine’s services.

The server coordinates and never carries the session in the clear: pixels, keystrokes, clipboard and files travel between the two ends encrypted, or through a relay that carries only ciphertext. It holds no session video, keystrokes, tunnel contents, SSH bytes or mesh traffic. Conference media is the documented exception, because a multi-party call needs a forwarding unit. MeshCentral relays sessions through the server by design.

Plans are counted by devices and users, and no heuristic decides whether you look like a business. The free plan covers 10 users and 100 devices, commercial use included.

Consent defaults to ask: only the Automatic mode skips the prompt, and a device with no consent setting at all still asks. Unattended access is a per-device switch meant for your own servers, and the wrong setting for a colleague’s laptop.

Fleet operations cover enrolment, per-device policy, remote command execution and SSH, with four independent default-deny gates on the powerful ones and every decision audited. Chat, rooms and video calls run on the same server and accounts. There is OAuth sign-in but no SSO and no SCIM provisioning, which the docs count as a gap for an organization of any size.

Open source does not make the download trustworthy

Roomler’s agent updates itself and runs what it downloads as the machine’s most privileged account, SYSTEM on Windows and root under systemd, which makes the update path the most security-sensitive thing in the product. The same is true of any agent that updates itself, whatever its licence.

Windows binaries carry an Authenticode signature with the publisher G ROX LTD, macOS builds are Developer ID signed and notarised where the format allows, and every platform ships a detached GPG signature against a published release key plus SLSA build provenance.

The updater checks three things in order: that the signature is valid, with GPG against a key pinned inside the binary on Linux and macOS; that the signer names G ROX LTD; and that the version inside the signed artifact matches what the release claimed. Only then does it install, and it rolls back if the new version crash-loops.

Each check exists because of one attack. A valid signature alone proves only that someone the operating system trusts signed the file, since every commercial code-signing certificate chains to a trusted root, so it is the publisher name that makes the signature mean “ours”. A checksum arrives in the same manifest, from the same origin, as the download URL, so anyone able to serve one can serve the other, and the hash proves transfer integrity and nothing about origin. Without the version binding, a tampered manifest could advertise a new version while pointing the download at a correctly signed older build with known vulnerabilities, and the other two checks would pass.

The agent fetches the release manifest through your own server’s origin. Signing uses short-lived federated credentials, so there is no signing key in the repository, in a CI secret or on a build machine to steal. The documented gap is that the manifest itself is not yet signed as a unit: version, URL and hash are not attested together, and the manifest remains the weakest link in the chain.

On Windows, check the installed binary yourself:

Get-AuthenticodeSignature "C:\Program Files\Roomler\roomlerd.exe" |
  Select-Object Status, @{n='Signer';e={$_.SignerCertificate.Subject}}

Status must be Valid and the signer must name G ROX LTD; stopping at Valid is the mistake, because a valid signature from any trusted publisher reads the same.

On Linux and macOS, verify the detached signature and the build provenance:

gpg --verify roomlerd-<version>-x86_64-unknown-linux-gnu.deb.asc roomlerd-<version>-x86_64-unknown-linux-gnu.deb
gh attestation verify roomlerd-<version>-x86_64-unknown-linux-gnu.deb --repo gjovanov/roomler-ai

Verify your install covers the rest of the post-install checks, and signed releases holds the reasoning. For RustDesk, the docs’ table entry under signed releases plus publisher check is “Varies”.

If endpoint protection blocks the installer or a later update, the allow-list needs roomler.ai or your own server for the Windows MSI and the tunnel CLI, github.com and release-assets.githubusercontent.com for the Linux and macOS packages, the desktop companion and automatic updates, and aka.ms for the Visual C++ runtime the Windows script fetches when it is missing. The publisher name, the GPG signature and the build provenance are the evidence to hand a security team when you ask for the exception.

Which one to pick

Assembled from the Choosing steps on the compare pages:

• You need a mobile viewer: RustDesk, because Roomler has none.
• You want the most proven remote-desktop stack: RustDesk.
• You want an RMM with inventory, power control and out-of-band management: MeshCentral.
• You need to reach devices that will never run an agent, over RDP or VNC: MeshCentral. Apache Guacamole does the same job as a gateway.
• Any copyleft is a procurement problem: MeshCentral’s Apache-2.0 is simpler.
• You support strangers ad hoc by ID and password: TeamViewer or AnyDesk, because Roomler needs both machines in one organization.
• You need SSO or SCIM provisioning: NetBird on the mesh side.
• You want the machine reachable after the session as well as visible during it, with one agent, one identity and one audit trail: Roomler.
• You support people inside your organization on machines you do not control and cannot install a viewer on: Roomler.
• You must host the control plane yourself, on the same code the hosted service runs: Roomler.

Install Roomler on one machine and open its desktop from a browser tab.