Skip to main content
RemoteOS

Your computer, anywhere.
With a receipt.

An end-to-end-encrypted, energy-metered remote desktop. Sub-20ms latency, 4K@60, hardware-accelerated on every platform. Every session is signed and logged — for you, by you, kept by you.

<20ms
Local latency
4K@60
Hardware accelerated
E2E
Encrypted by default
100%
Signed sessions

Download

One install. Every platform.

macOS and the web client are stable. Windows and Linux are in open beta. Mobile is on its way.

All builds are signed and notarized. Latest stable: v0.9.0-beta · checksum at /checksums

Features

What's in the box.

Six things RemoteOS does — every install, every platform, every session.

01
ENCRYPTION

End-to-end encrypted by default.

ChaCha20-Poly1305 over an X25519 key exchange. Only your two devices hold keys. Nothing in the middle can read your screen, your inputs, or your files — including us.

02
RECEIPTS

Every session leaves a signed receipt.

When a session ends, RemoteOS writes a tamper-evident receipt — start time, end time, frames, bytes, energy, peer fingerprints. You keep the receipts. We don't. Self-host the log if you want.

03
ENERGY

Energy, on the wire.

RemoteOS measures the joules of every session — your laptop, the encoder, the network, the remote box. The number lives in the menu bar and on the receipt. The first remote desktop honest enough to tell you what it costs in physics.

04
TRANSPORT

Modern QUIC transport.

RemoteOS rides Media-over-QUIC for video and inputs. One connection, multiple tracks, one congestion controller. Sub-100ms over the public internet. Fallback to WebRTC where QUIC is blocked.

05
PERFORMANCE

Local NPU upscaling.

Stream 1080p over modest networks; the viewer's GPU/NPU upscales to 4K. Hardware-accelerated end to end — VideoToolbox, NVENC, QuickSync, AMF, AV1. Frames cost less than the bytes that carry them.

06
SELF-HOST

Self-hostable, end to end.

Run the whole stack on your own boxes — control plane, relay, TURN, ledger. Docker Compose for a single host, Helm chart for Kubernetes, ARM64 images for Pi and Apple Silicon homeservers. Your devices connect peer-to-peer where they can; your relay only when they can't.

Inside a session

Six stages. One signed total.

Click "Connect" and RemoteOS lights up six internal stages. Each one measures its own energy. At "Disconnect," the session leaves you with a single signed receipt — every byte and every joule accounted for.

01
Stage
Sign in
0.18 J
measured

You authenticate; the session keypair is co-authored.

Email + passkey, or single sign-on. The remote box and your viewer derive a shared session key — neither side moves alone, neither key sits on a server.

02
Stage
Capture
0.40 J/s
measured

Your screen is captured at the source.

ScreenCaptureKit on macOS, DXGI on Windows, PipeWire on Linux. The hardware encoder converts frames to AV1, H.265, or H.264 with zero copies. The encoder logs its own joule cost.

03
Stage
Wire
0.22 J/s
measured

Frames travel over QUIC.

Media-over-QUIC carries the session as a multi-track stream — video, audio, input, clipboard, files. Each chunk is signed under the session key. The wire IS the audit.

04
Stage
Render
0.60 J/s
measured

Local NPU upscales 1080p → 4K.

On the viewer the GPU and NPU do the heavy lifting. Bandwidth stays modest; perceived quality climbs. The upscaler emits the joules it spent so the receipt sees end-to-end energy.

05
Stage
Input
0.05 J/s
measured

Your inputs go back, signed.

Mouse, keyboard, clipboard, file drops. Each event is signed under the session key. Kalman-filtered prediction smooths perceived latency without lying about what was sent.

06
Stage
Receipt
Σ session joules
measured

RemoteOS writes the session receipt.

Sum of capture + wire + render + input. The session ends with a signed total — duration, frames, bytes, joules, peer fingerprints. The receipt becomes a row in your ledger.

Receipts

Every session leaves a signed trail.

When you disconnect, RemoteOS writes a session receipt to your account's ledger. Who connected, from where, for how long, how many bytes, how many joules. The signature is non-forgeable — rewriting one means forging an Ed25519 signature.

  • Audit by default. Compliance, security, and IT teams get a tamper-evident log without lifting a finger.
  • Energy by default. Every receipt carries the joule cost of the session it describes. Sustainability reporting is a query, not a project.
  • Yours, not ours. Receipts live with you. Self-host the log if you prefer; the format is documented and the signatures verify offline.
RemoteOS Session Receipt remoteos.session.completed
{
  "kind":      "remoteos.session.completed",
  "session":   "rs_2026_05_07_a3f1c91a_9241",
  "viewer":    { "device": "macbook-pro-16", "os": "darwin/14.6", "ip_geo": "us-ca" },
  "host":      { "device": "studio-imac",     "os": "darwin/15.0", "ip_geo": "us-or" },
  "transport": "moqt",
  "codec":     "av1+opus",
  "started_at":  "2026-05-07T17:22:04Z",
  "ended_at":    "2026-05-07T18:14:38Z",
  "duration_s":  3154,
  "frames":      189240,
  "bytes":       412318472,
  "joules":      4781.6,
  "kwh":         0.001328,
  "co2_g":       0.42,
  "sig":         "ed25519:c7a2…1f4b"
}

Specs

Everything, on the table.

No marketing-page softening. The actual numbers, protocols, and platforms RemoteOS supports today.

Performance

Local latency
Sub-20ms (LAN)
Public latency
30–60ms typical (QUIC), 50–90ms (WebRTC fallback)
Frame rate
Up to 4K @ 60fps
Encoders
AV1 · H.265 · H.264 · VP9 (hardware-accelerated)
Hardware paths
VideoToolbox · NVENC · QuickSync · AMF · Mali · Adreno
Upscaling
On-device NPU/GPU 1080p → 4K (Apple Neural Engine, NVIDIA RTX, Intel NPU, AMD XDNA)

Security

Encryption
ChaCha20-Poly1305 · X25519 ECDH
Authentication
Passkey, email + magic link, SAML/OIDC SSO, optional MFA
Session keys
Per-session ephemeral, never on a server
At rest
Argon2id-hashed credentials
Transport
TLS 1.3 over QUIC (HTTP/3) · DTLS 1.3 fallback
NAT traversal
ICE/STUN/TURN (RFC 8445), relay only when peer-to-peer fails

Receipts & energy

Receipt format
RemoteOS Session Receipt — signed JSON, Ed25519
Logged fields
duration · frames · bytes · joules · kwh · co2_g · peer fingerprints
Storage
Your account's ledger, or self-hosted log
Export
JSON, CSV, NDJSON · streaming via webhook
Energy method
Per-stage instrumentation (encode + transport + decode + display)
Verifiable
Signatures verify offline; no RemoteOS service required

Platforms

macOS
13+ Universal — stable
Web
Chrome 120+ · Safari 17+ · Firefox 122+ · WASM + WebGPU — stable
Windows
10+ x64/ARM64 — beta
Linux
Ubuntu 22+, Fedora 39+, Arch · x86_64/aarch64 — beta
iOS / iPadOS
17+ — coming
Android
13+ — coming

Questions

Common ones, answered straight.

Where does my data live?
On your two devices. Sessions are end-to-end encrypted with ChaCha20-Poly1305 over X25519 ECDH — only the host and the viewer hold keys. Nothing in the middle, including RemoteOS infrastructure, can read your screen, your keystrokes, or your files.
How fast is it?
Sub-20ms on a local network. 30–60ms over the public internet on QUIC, 50–90ms when we fall back to WebRTC. Hardware-accelerated end to end on every supported platform — VideoToolbox on macOS, NVENC on NVIDIA, QuickSync on Intel, AMF on AMD.
Which platforms work today?
macOS native and the browser are stable (Chrome 120+, Safari 17+, Firefox 122+). Windows and Linux are in open beta. iOS, iPadOS, and Android are in development — they need their respective app store reviews.
Can I host my own server?
Yes. There's a Docker Compose stack for single-box deployments and a Helm chart for Kubernetes. Your devices connect peer-to-peer where possible; TURN handles the rest. The hosted service is the easy default; self-host is the option for orgs that need it.
What's a session receipt?
A signed JSON record RemoteOS writes when a session ends. It captures duration, frames, bytes, energy in joules, peer fingerprints, and an Ed25519 signature. The receipts live in your account ledger (or self-hosted log) and verify offline. Audit and sustainability reporting become side-effects of using the product, not separate workstreams.
Why does it measure energy?
Because every other claim about software performance is a lie until you can show what it cost. RemoteOS measures the joules of your sessions so you can compare workloads, optimize codecs, and report sustainability metrics without instrumenting anything yourself.
Is the source open?
No. RemoteOS is closed source. The receipt format is documented and the signatures verify offline; the wire protocols are open standards (QUIC, MoQT, MLS, OIDC). Builds are signed and notarized.