Remote Compose: A New Document-Driven Paradigm for Cross-Platform UI on Android

In Android development, UI is typically tightly bound to the application process, but when the interface needs to be projected onto a watch, a widget, or even another device, traditional screen mirroring or app distribution approaches fall short in terms of latency and performance. The Remote Compose project attempts to solve this problem at its root: instead of transmitting screen pixels, it transmits a compact document that describes the UI, allowing the remote surface to render and interact autonomously.

The UI Dilemma of Remote Surfaces and the Document-Based Approach

According to Google tech lead Nicolas Rod, a remote surface can be a watch face, a desktop widget, or even another app or service. Whether the distance is a physical network or a process boundary, transmission has a cost. The simplest approach is to send a screenshot, but this isn't fast enough, and every interaction requires a round trip to the original creator, resulting in a sluggish experience. Remote Compose chooses to send a binary document consisting of a list of operations, whose core advantage is its small size—typically only a few KB in common scenarios, and even complex adaptive layouts are mostly in the tens of KB range. This directly affects the time to first frame and the number of documents a surface can carry.

Developer relations engineer John Zoller added the practical benefits on Wear OS: an exercise tracker built with Remote Compose can achieve real-time metrics refreshed in seconds, whereas a traditional Compose approach in ambient mode might need to wait a minute to update metrics once—a significant improvement for both battery life and user experience.

Glance is the declarative UI framework in Jetpack for building Android widgets. Its API style is similar to Compose, but it is specifically optimized for the rendering constraints of remote surfaces. Glance's underlying implementation has long relied on RemoteViews, working by converting the UI into a view description that can be rendered in the host process. The relationship between Remote Compose and Glance is that the latest version of Glance can automatically generate Remote Compose documents as a backend, allowing existing widgets to enjoy smaller document sizes and richer animation capabilities without rewriting. This means Glance becomes the unified entry point for developers targeting widgets, while Remote Compose serves as its underlying serialization format; together they form a complete pipeline from declarative code to remote rendering.

Three Ways to Create Documents and Runtime Autonomy

Remote Compose offers three equivalent ways to create documents: the Compose API, a procedural Kotlin API (KMP), and JSON format. All three ultimately produce the same byte stream. The Compose API can directly leverage Android Studio's live preview, allowing developers to see expression-driven animations right in the IDE. The JSON format is particularly well-suited for collaborating with LLMs, as models can read and modify documents—for example, changing the clock's minute hand to green.

Once a document is loaded by a player, it becomes autonomous: scaling, scrolling, touch handling, component visibility, and animation all happen within the document without needing to call back to the source. If a new document is genuinely needed, an action can be explicitly requested. Official players include the Compose player, the View player, and a Remote View implementation built into the Android platform starting from a certain version, which powers launcher widgets. Experimental players also cover C++/Skia, TypeScript, and Compose Multiplatform.

Compose Multiplatform is the cross-platform Compose runtime driven by JetBrains, supporting compilation of Compose UI to targets such as desktop, iOS, and Web. Remote Compose's player implementation covers Compose Multiplatform, meaning the same remote document can be played not only in Android's Compose, View, or Remote View, but also rendered in Compose runtimes on non-Android platforms. This provides the runtime foundation for "create once, play on multiple surfaces": document creation and playback are completely decoupled—creators can use the Android toolchain to generate documents, while players can run on any platform that supports Compose, including embedded or cross-platform scenarios.

Capability Layers: From Canvas to Adaptive Components

At the bottom, the document is a Canvas that fully preserves all the features of the Android Canvas while allowing all floating-point values to be replaced with expressions. These expressions support math, trigonometry, array access, and spline interpolation, and any mutable value can be animated. In the demo, each pendulum uses a different animation type, all running within the document.

On top of this are the familiar Compose primitives—Box, Row, Column—as well as adaptive components. Since the document is no longer under the creator's control during playback, these components can independently handle the appearance and disappearance of elements caused by size changes, and support component-level animations, including custom shader effects. For interaction, clicks, touches, scrolling, and the full accessibility API are all built in. A complete stopwatch app in the demo runs entirely on the player side without sending any data back to the server. The host app and the document can also communicate bidirectionally: the blue app portion and the black remote document can pass values to each other.

Expressions are the dynamic computation units in a Remote Compose document that replace static values, supporting math operations, trigonometry, array access, and spline interpolation. Their key design is that expressions form a dependency tree: when an input value that an expression depends on changes, the system only recomputes that expression and its downstream nodes, without traversing the entire document tree. The demo's "expression dependency tree enables efficient dirty value cleanup" refers precisely to this mechanism—the player evaluates only the affected expression branches on each frame update, allowing animations and interactions to run efficiently inside the document while keeping the document compact, because expressions describe computation rules rather than per-frame data.

Making Documents Smaller: Loops, Functions, Templates, and Compression

"Small is a feature" is the design philosophy running throughout the talk. Taking a typical list UI as an example, the original document is about 25KB, and Remote Compose offers multiple means to compress it further: automatically deduplicating identical strings, using loop operations to draw graphics, abstracting repeated graphics into functions, and reusing component rows with templates. Finally, the document can be compressed as a whole, typically saving about half the size. The document header is not compressed, making it easy to quickly filter through large numbers of documents without decompressing. By combining these techniques, the example document's size can be reduced by an order of magnitude.

Progress on Widgets and Wear OS

Remote Compose can now fully replicate existing widgets and supports adaptive adjustments and animations. A complete widget game document is only about 4KB. For existing widgets, the official recommendation is to continue using Glance, whose latest version can automatically generate a Remote Compose backend. On Wear OS, a new exercise tracker has been built with Remote Compose and has landed in the public beta of the Asics RunKeeper app. Wear OS widgets replace the old ProtoLayout Tiles library, unifying under the Jetpack Glance ecosystem; the UI is decoupled from the specific app process, can be serialized and safely rendered on the device, and brings modern graphics and responsive layouts. Hardware vendors for Wear OS 7 have adopted the vertical scrolling tray, while older devices automatically present it as a full-screen Tile, with backward compatibility down to Wear OS 4.

ProtoLayout Tiles is the library previously used on Wear OS to build Tiles (widgets), based on the ProtoLayout layout protocol and relatively disconnected from the Jetpack ecosystem. In Wear OS widget scenarios, Remote Compose replaces ProtoLayout Tiles, unifying Tiles under the Jetpack Glance ecosystem. The significance of this migration is that the UI is decoupled from the specific app process, documents can be serialized and safely rendered on the device, and modern graphics capabilities and responsive layouts are gained. Hardware vendors for Wear OS 7 have adopted the vertical scrolling tray, while older devices automatically present it as a full-screen Tile, with backward compatibility down to Wear OS 4, so developers don't need to maintain multiple sets of Tiles code for different device form factors.

Developer Tools and Open Ecosystem

The Remote Compose library is hosted on AndroidX, with documents and versions released alongside DAC. The team is working on a public specification for the document format and developing a vector resource conversion tool, encouraging developers to send vectors rather than bitmaps. A Document Inspector preview has been released, supporting step-by-step execution of operations, visualization of layouts at different densities and sizes, and full layout inspection capabilities similar to Android Studio, including even 3D viewing. The project is developed in the open, and the team explicitly states it wants to collect developer feedback to expand into more remote surface scenarios.

It's worth noting that the interface of the entire talk itself was driven by Remote Compose, including all animations.

One-line Summary

Remote Compose replaces screen pixel transmission with a few-KB binary document, letting remote surfaces render UI autonomously.

Paragraph Summary

Remote Compose is a remote UI solution proposed by Google. Instead of transmitting screenshots, it sends a compact binary document consisting of a list of operations, typically only a few KB in size, with complex layouts mostly in the tens of KB range, thereby significantly reducing first-frame latency and interaction round-trip costs. Documents support expression animations, adaptive components, touch interaction, and the accessibility API; once loaded, scaling, scrolling, and animation all run autonomously on the player side. Developers can create documents in three equivalent ways: the Compose API, a procedural Kotlin API, or JSON, with JSON being convenient for collaborative editing with LLMs. Loops, functions, templates, and compression can further reduce size by an order of magnitude. The solution has landed in Wear OS exercise trackers and widgets, and the latest Glance version can automatically generate a Remote Compose backend.