An idea in the lab — sharper pixels, someday.

A remote-desktop stream goes through two compression hits before it reaches your eyes. First, the host downscales when the source resolution exceeds what your client can display — an M4 MacBook Pro 14" hosting at 3024 by 1964 streamed to an iPad mini at 2266 by 1488 has already given up roughly a third of its pixels before the encoder sees the frame. Second, the encoder itself applies lossy compression to fit the bitrate the network can carry. Both steps throw away high-frequency detail — exactly what makes the difference between a crisp character glyph and a smudgy blob.

The idea we're exploring is a quality-recovery pass that would run on the client after decode: look at the decompressed frame and predict the high-frequency content the original frame had before it was downscaled and squeezed through the encoder. Unlike classical bilinear or bicubic upscaling — which can only interpolate from the pixels already there — a trained neural network can learn what edges, letterforms, and UI shapes look like at full resolution, and reconstruct detail a simple interpolation can't recover.

If it works the way we hope, the effect would be most visible exactly where you need it most: 11-point body text, code in a monospaced font, hairlines in a Figma file, button outlines in a sidebar. These are the cases where a few smudged pixels mean the difference between "readable" and "I have to lean in." That's a real gap in what any motion-tuned encoder can do on its own — which is precisely why it's worth the research time to find out whether an on-device model can close it.

We're not there yet. Today, the honest answer to "how do I keep a session sharp on a bad connection" is Remio's adaptive bitrate engine — it already reads your network and picks the envelope that keeps the picture as sharp as the connection allows, without spiking lag. Neural upscaling would be an additional layer on top of that, not a replacement for it.

Does it clearly beat what we already have? Remio's adaptive bitrate engine already reads your connection and picks the envelope that keeps the picture as sharp as the network allows. A neural model only earns its place if it recovers detail beyond that baseline by a margin people actually notice — not a benchmark win that disappears at normal viewing distance.

Does it cost meaningful battery on a phone or tablet? Running any model on every decoded frame, all session long, has a real power cost. We'd want that cost to be small enough that nobody has to think about it — or a clear, honest "Auto" behavior that only spends the battery when there's something worth recovering, with a real off switch for anyone who'd rather not pay it at all.

Does it stay honest about what it's doing? A model that reconstructs plausible-looking detail from compressed pixels is doing something different from a model that invents content that was never there. For a remote desktop, where what you see has to match what's actually on the host, that distinction isn't a nice-to-have — it's the whole trust model. Anything we ship would have to reconstruct, never hallucinate.

Until we can answer all three with real numbers, not projections, this stays a research idea on this page — not a toggle in the app.

Hardware H.265 end to end means the encoder on the host and the decoder on your client both run on dedicated video silicon, not the CPU — the same reason a 4K video plays smoothly on a phone that would choke trying to decode it in software. That headroom is what lets Remio hold detail at a bitrate a software codec couldn't sustain.

The adaptive bitrate engine is the piece doing the actual job neural upscaling is being explored to help with: it measures your connection at the start of a session and chooses the highest bitrate envelope that connection can sustain without lag spikes, instead of quietly starving the stream. Read how adaptive quality works →

The virtual display and the zero-buffering renderer round it out. Because the display Remio streams is sized exactly to your window rather than the host's full monitor, you're never looking at a downscaled copy of something bigger. And because the renderer always draws the newest decoded frame — dropping stale ones instead of catching up on them — nothing you see is old by the time it reaches your screen. Between the four, most sessions never need a quality-recovery pass at all.

It would not hallucinate missing UI. If a button is cut off at the edge of a stream because the encoder dropped a region, a model that invents the rest of the button doesn't belong in a remote desktop. You need to trust that what you see on your iPad matches what's actually on the host — a generative model that filled in content that was never there would break that trust, so we'd only ship a model that reconstructs from pixels that were genuinely encoded, never one that invents.

It would not claim to increase frame rate. Frame rate on Remio is set by the host's capture rate and the network's ability to deliver frames on time — that's a job for the zero-buffering renderer that already ships, not for an upscaler. Any model we build would produce one sharper frame per decoded frame, nothing more.

It would not be pitched as fixing video playback on the host. If you're watching a movie on your remote Mac, what streams is whatever the host's own video decoder rendered — at the host's resolution. A quality-recovery pass on the stream doesn't improve on a source the host already produced; for sharper movie playback, the honest advice stays the same as today: play it on your client device, not on the host.

And it would never be sold as a replacement for a good network. A direct LAN connection is always going to be sharper than a clamped WAN connection with any amount of upscaling on top — the adaptive bitrate engine Remio ships today already gets you the best picture your actual connection can sustain. Anything we build here would be additional insurance for bad networks, not a substitute for a good one.