Makepad is a promising Rust UI, app-shell, and XR-panel substrate for controls, inspectors, and diagnostic tools.
Makepad Strategy
Makepad is the app shell. Rusty XR keeps the camera contracts.
Rusty XR uses Makepad where Rust-native UI, panels, live iteration, and headset diagnostics need a strong framework. Raw camera resources, projection timing, frame freshness, and validation contracts stay explicit and framework-neutral.
Rusty XR keeps frame identity, resource identity, transforms, color status, lifecycle, and validation evidence as public contracts.
Generic external-resource metadata, video lifecycle events, Android lifecycle hooks, and shader-resource diagnostics can become Makepad-level improvements.
Current Alignment
The maintained Makepad branch has started converging back toward upstream Makepad instead of remaining an isolated renderer experiment. Recent work integrated upstream video lifecycle, Android rendering, text wrapping, Android lifecycle, manifest/tooling, minimum-SDK, and Android App Bundle packaging directions while preserving Rusty XR camera-lane diagnostics.
| Area | Current direction | Why Rusty XR cares |
|---|---|---|
| Video lifecycle | Upstream apply-gate behavior plus texture update metadata. | Correlate producer frames, Makepad texture updates, and XR submission. |
| Android rendering | Upstream Android rendering/loading fixes. | Keep XR panel quality and Android behavior aligned before debugging camera resources. |
| Text and layout | Upstream text wrapping correction. | Avoid stale UI forks while relying on Makepad for readable headset panels. |
| Android tooling | Manifest reconciliation, SDK defaults, minimum-SDK alignment, and AAB packaging. | Keep deterministic Rusty XR builds close to Makepad's own packager. |
| Frame diagnostics | Cadence-tuned frame-flow markers. | Debug stale frames and resource lifecycle without turning log markers into the renderer architecture. |
What Makepad Provides
Makepad is a Rust-native application stack: a custom GPU-first UI/runtime framework, widget layer, Studio tooling, live design language, and cross-platform build tooling. Current public materials frame Makepad 2.0 around AI-native Rust UIs and Splash, while the repository and book describe a broader Rust-first framework for native, mobile, and web targets.
| Surface | Rusty XR Reading |
|---|---|
| Widgets and panels | Good fit for XR controls, diagnostics, operator panels, graph views, and settings. |
| GPU text and vector UI | Useful for crisp headset panels without routing all UI through a low-resolution canvas texture. |
| Live/Splash-style UI | Promising for faster diagnostic and operator-tool iteration once the runtime contracts are stable. |
| Platform tooling | Useful for Android and mobile workflows, but still needs explicit validation around Quest/XR camera paths. |
| XR roots | Historically relevant and useful, but not a replacement for raw camera-resource contracts. |
Why Rusty XR Uses It
- Rust-native UI and app structure.
- High-quality 2D panels inside XR scenes.
- Room for live UI and tooling iteration.
- A serious upstream project with real app pressure from Studio, Robrix, Moly, and related work.
- A framework lane for comparing direct HWB/OES renderers against a Makepad-first app shell.
What Stays Explicit
- Camera frame identity and timestamps.
- Hardware-buffer, OES, and CPU-YUV transport identity.
- Acquire, upload/import, reuse, stale, and release lifecycle facts.
- Camera crop, transform, projection, color, and stereo lane semantics.
- XR frame timing, submission evidence, and validation summaries.
Adapter Direction
Shared camera texture lane contract -> Direct Vulkan/HWB adapter -> Direct OpenGL/OES adapter -> Makepad CPU-YUV adapter -> Makepad hardware-buffer/external-texture adapter
The Makepad adapters should translate Makepad events and resources into the same Rusty XR contract used by the direct renderers. Rusty XR core crates stay independent of Makepad.
What Rusty XR Can Contribute
| Pressure | Makepad-level candidate | Upstream value |
|---|---|---|
| External camera/video textures | A backend-neutral external frame or resource descriptor with format, color space, transform, timestamp, validity, and lifecycle state. | Helps camera, decoder, XR, and future external-texture integrations. |
| Frame freshness | Video lifecycle events that can express acquire, update, reuse, stale, release, and producer timestamps. | Makes real-time media apps observable without private log formats. |
| Android and XR lifecycle | Hooks for activity/session state, permissions, surface recreation, pause/resume, shutdown, and resource invalidation. | Reduces fragile app-specific Android and XR lifecycle code. |
| Android packaging | Source-root deterministic builds, manifest normalization, SDK clarity, AAB support, and transcript ordering. | Makes `cargo-makepad` more predictable for CI and mobile distribution. |
| Backend parity | Shader-resource reflection and descriptor diagnostics that do not assume a specific application. | Creates a safer path for external resources and backend descriptor layouts. |
| XR panel quality | DPI, text, scaling, focus, and input improvements that help all Makepad mobile or XR panels. | Improves Makepad's high-DPI and XR UI story beyond Rusty XR. |
Sources
Sources accessed on 2026-05-26. See the Markdown note for the full source list and collaboration posture.