Article

Remote From Anywhere: The Remote-Desktop Stack Chinese Developers Actually Use

Remote From Anywhere: The Remote-Desktop Stack Chinese Developers Actually Use

The file you need is on your office desktop. You're on the subway, or at a café, or visiting family far away. Your office PC is awake, online, and unreachable — no public IP, a router you don't control, and a corporate network that takes no inbound connections. What do you do?

If you asked this question in the US or Europe, the answers would come fast: Parsec, Tailscale, AnyDesk, maybe plain RDP over a WireGuard tunnel. Ask it on LINUX DO, China's biggest developer forum, and you get a different stack — built around NetEase's UU Remote, Oray's Sunflower, and a strong undercurrent of developers who tunnel Windows RDP through their own frp tunnels or self-hosted RustDesk relays. This article decodes that stack: what the tools are, why Chinese developers pick them, and how the two DIY routes actually work.

The short answer

For most Chinese developers, the practical shortlist for reaching a remote PC from a phone or laptop looks like this:

ToolWhat it isPrice modelWhy forum users pick it
UU Remote (UU远程)NetEase's proprietary remote desktop clientFreemium tiersForum-reported as the crowd favorite: low latency, phone-to-PC smooth
Sunflower (向日葵)Oray's commercial remote desktopFreemium, subscription tiersLong-established brand; forum-reported as the stable fallback
ToDeskIndependent commercial remote desktopFreemiumForum-reported as a clean, lightweight alternative
RDP + frpMicrosoft's Remote Desktop tunneled through an open-source reverse proxyFree (needs a VPS with public IP)Full control, no third-party relay; a marked "solution" in the thread
Self-hosted RustDeskOpen-source remote desktop with your own relay serverFree (needs a VPS)Open source, E2E encrypted, clients on every platform; also a marked "solution"

The forum thread that inspired this piece (47 replies, with the poster asking specifically for phone-to-office-PC access) saw two answers marked as accepted solutions: RDP tunneled through frp, and frp + RDP alongside a self-built RustDesk server. The commercial tools got the votes; the self-hosted routes got the green checkmarks — which tells you how this community thinks: convenience is fine, but nothing beats infrastructure you control.

Why the stack looks different from the West

Three structural reasons push Chinese developers toward these particular tools:

  • NAT and CGNAT are the norm. Most home and office connections sit behind carrier-grade NAT, so direct peer-to-peer tools that "just work" in Western homelabs often can't punch through. Tools with aggressive NAT traversal — or relays with good domestic bandwidth — win by default.
  • Latency to foreign relays is punishing. A remote session routed through a US or EU relay feels like typing through molasses. Domestic tools keep relay traffic inside China, which is why UU Remote — unknown to most Western readers — can feel dramatically faster than a big Western name.
  • Self-hosting is a reflex, not a hobby. Chinese dev culture skews toward owning the infrastructure: config files beat SaaS dashboards, and a third-party relay is a dependency to be eliminated, not a service to be bought. (See the same instinct in our look at China's free-VPS hunting culture.)

The commercial trio: what the forum reports

Forum discussions are recommendations, not product pages, so take this section as reported community sentiment from the source discussion, not as verified benchmarking.

UU Remote (UU远程) comes from NetEase — the same company behind one of China's largest game-accelerator services. It's proprietary software, and its heritage shows: game-optimized networking tuned for low latency and smooth video is exactly what a remote desktop needs. Forum members describe it as the default first try for phone-to-PC access.

Sunflower (向日葵), by Oray, is the old hand — long-established enough that most Chinese developers first met it in a school lab. It's commercial and freemium, treated in the thread as the boring-but-reliable fallback: the one you install on a relative's computer because it always works.

ToDesk is the independent challenger. Forum members who recommend it usually cite a cleaner client and lighter feel than the incumbents, filling the "I want something simple" slot.

If you just need to get in now, any of the three reportedly gets the job done: UU Remote first, ToDesk second, Sunflower as the safety net. If you want the thing to still work in three years without depending on someone else's servers, keep reading.

Route one: RDP over frp — no relay server in the middle

The first marked solution in the thread is elegantly minimal: Windows' built-in Remote Desktop Protocol, bridged over NAT with frp, the open-source fast reverse proxy by fatedier (verified against the project's official README).

frp's architecture is simple. You run frps on a cheap VPS with a public IP, and frpc on your office PC. The office machine opens an outbound connection to your VPS — no firewall holes needed at the office — and frp exposes the PC's RDP port (3389) through it:

# frps.toml — runs on your VPS
bindPort = 7000
auth.token = "a-long-random-string-only-you-know"

# frpc.toml — runs on the office PC behind NAT
serverAddr = "your-vps-ip"
auth.token = "a-long-random-string-only-you-know"

[[proxies]]
name = "office-rdp"
type = "tcp"
localIP = "127.0.0.1"
localPort = 3389
remotePort = 6000

Connect your RDP client to your-vps-ip:6000, and you're looking at your office desktop. The frp README documents support for TCP, UDP, HTTP, and HTTPS proxies, plus token auth and TLS transport — and even a P2P connect mode that tries to keep traffic off the relay entirely.

Three practical notes, all from the verified documentation rather than the forum:

  1. Token auth is mandatory in practice. An frp server without a shared token is an open relay for strangers' traffic. Set auth.token on both ends and treat it like a password.
  2. Encrypt the tunnel. Enable TLS transport so your RDP session isn't riding plaintext across the internet.
  3. Harden RDP itself. A tunneled RDP is still RDP: strong account passwords, Network Level Authentication, and a non-obvious remotePort.

The total cost of this route is whatever your smallest VPS costs — and if you hunt aggressively, that can be effectively zero.

Route two: a self-hosted RustDesk relay

The second marked solution goes a step further up the control ladder: host your own remote-desktop infrastructure with RustDesk, the open-source remote desktop application. What you're self-hosting is the two server components that let machines find each other:

ComponentRolePorts
hbbsID/rendezvous server — how clients find each other21115, 21116 (TCP+UDP)
hbbrRelay server — carries traffic when direct connection fails21117

(Verified against third-party self-hosting guides and community documentation, which agree on the two-container split and port assignments; ports 21118/21119 are for the optional web client.) Clients try to connect directly peer-to-peer; when NAT blocks them, traffic falls back to your own relay instead of a vendor's.

A minimal Docker setup looks like this:

services:
  hbbs:
    image: rustdesk/rustdesk-server
    command: hbbs
    network_mode: host
    volumes:
      - ./data:/root
  hbbr:
    image: rustdesk/rustdesk-server
    command: hbbr
    network_mode: host
    volumes:
      - ./data:/root

Then, in every RustDesk client (Settings → Network), set the ID Server and Relay Server to your VPS address and paste in the server's public key. Both ends must point at your private server — a client left on the default public infrastructure will produce an ID Does Not Exist error even when your own client shows "Ready."

RustDesk's clients cover Windows, macOS, Linux, iOS, and Android, with file transfer, clipboard sync, and unattended access built in. For a homelabber, the appeal is the whole package: open source, end-to-end encrypted with keys generated on your own server, no account required — a TeamViewer-class workflow without a SaaS dependency in the loop.

Which route should you take?

A decision checklist, decoded from how the forum weighs the trade-offs:

  • Need access in the next 10 minutes? Install UU Remote (or ToDesk as second choice) on both ends — forum-reported as the smoothest phone-to-PC experience.
  • Need it to work for relatives forever? Sunflower: the stable, boring pick — and "boring" is a feature when you're the family tech support.
  • Need full control, minimal dependencies? RDP + frp. Two config files, one VPS, zero vendor lock-in. Token auth, TLS, hardened RDP.
  • Need remote access for several machines? Self-hosted RustDesk. One relay server covers your office PC, your homelab, and your phone.
  • Need it free and have no VPS? Both DIY routes assume a server with a public IP — which is why the same community maintains a whole subculture around finding cheap or free compute.

One pattern worth noting: several forum members run both a commercial tool and a self-hosted route. The commercial client is the quick daily driver; the frp or RustDesk setup is the backup that works when a vendor changes pricing or throttles free users. If you're building a remote workstation for an AI coding agent that runs while you're away, that redundancy is not paranoia — it's uptime.

The cultural footnote

What makes this thread representative isn't any single tool — it's the instinct in the accepted answers. A Western help thread about remote access tends to converge on one SaaS product. This one converged on "host your own relay." The Chinese developer community's bias toward owning the infrastructure shows up everywhere: in frp's tens of thousands of GitHub stars, in the homelab culture that treats a $5 VPS as basic hygiene. Trust the protocol, own the server, keep the relay optional — that's the real takeaway, and these tools are just this year's expression of it.

Keep reading
Plan Mode vs. Just Do It: Why AI Coding Agents Are Splitting on the Simplest Design Question
Read next →