Remote Compose: AAOS Gets a Cross-App UI That Doesn't Suck
For any developer building on Android Automotive — whether at an OEM, a tier-1 supplier, or a third-party app team — cross-app UI embedding is a recurring source of complexity and technical debt. Remote Compose offers a genuinely new architectural pattern that could simplify ownership boundaries and reduce integration pain across the entire infotainment stack. The PoC shows it's not just theory; it works today alongside legacy systems.
Embedding one app's UI inside another on Android Automotive OS has always been a pain. Internal components force teams to become experts in every domain. TaskView burns through hardware overlay budgets. SurfaceControlViewHost introduces fragile IPC. And RemoteViews is too primitive for anything serious.
Remote Compose flips the model. Instead of sharing a surface, it shares a compact binary stream of drawing instructions. The host just plays them back on its own Canvas — no lifecycle coupling, no process knowledge needed. A PoC running a phone widget inside the CarLauncher shows it coexisting with native Views and CarTaskView in a three-column layout, with the provider on a separate display. The contract is minimal: the provider sends byte arrays, the host sends integer action IDs back.
The approach is pragmatic for OEMs. Remote Compose ships a View-based player artifact, so legacy View-system hosts like the standard CarLauncher can adopt it without migrating to Jetpack Compose. The provider side uses familiar Compose syntax with Remote-prefixed components. Android itself is baking a native player into API 35, but the AndroidX artifacts let teams adopt it today on older OS versions.
Still, Remote Compose is alpha-grade. Debugging tools don't work well, accessibility support is limited, and rotary navigation handling is incomplete. But for the core problem — sharing rich UI across app boundaries without tight coupling — it's the first approach that genuinely breaks the trade-off cycle.
The shift from sharing surfaces to sharing intent is the key architectural insight — it decouples UI rendering from business logic at a fundamental level.
The PoC's coexistence with legacy Views and CarTaskView is more important than the Remote Compose implementation itself; it proves a viable migration path for OEMs with massive existing codebases.
Baking a native player into API 35 is a strong signal that Google sees this as the future for cross-app UI in Automotive, but the AndroidX artifacts are the pragmatic choice for real-world adoption today.
The minimal contract (bytes in, integers out) is elegant because it forces clean separation by design — teams can't accidentally couple through shared state or lifecycle hooks.
The accessibility limitations are a real concern for production use, especially in automotive where regulatory compliance (CVAA) is mandatory. This shifts the burden to the host in ways that may recreate the complexity Remote Compose aims to eliminate.
The alpha status and lack of debugging tools mean early adopters will need to invest in custom instrumentation — a non-trivial cost that OEMs should factor into their evaluation.