Step beyond the desktop path with both eyes open
Ailloli UI already separates its retained scene from the host and renderer. That opens exciting doors, but beta.2 does not make every door equally ready.
Outcome: you will know which path is the default, which crates are separate, what a hardware-free input check proves, and what still needs a real XR system.
01
Start from the path that ships with the façade
The default winit feature brings the native host and primary WGPU renderer. Ordinary desktop applications do not need Vulkan or OpenXR dependencies.
Your application
Widgets, State, actions, and windows built with ailloli_ui.
Portable scene
The retained runtime produces layers and DrawCmd values.
Winit + WGPU
The primary desktop host creates surfaces and renders the scene.
02
Read the labels before choosing a path
Available means the source and public contract exist. Experimental means the API may move quickly and needs integration work beyond the façade.
Beta.2 capability map
Five paths, each with a different readiness level.
- Primary
Winit + WGPU desktop
Default façade path for native desktop windows and GPU rendering.
- Experimental
Vulkan renderer
Separate host-oriented crate. It records a retained Scene into host-owned Vulkan targets.
- Partial integration
XR input adapter
Host-agnostic pointer mapping is available without starting an OpenXR session.
- Experimental
OpenXR runtime path
Separate feature-gated host path that requires real loader, runtime, GPU, and hardware validation.
- Experimental
Native desktop overlay
The opt-in native_overlay feature creates a non-activating overlay through Linux X11 or Wayland layer-shell backends. Other platforms are unsupported in beta.2.
Beta.2 registry publication is still in progress. Confirm that each exact crate version is listed before using a registry-only manifest.
03
Vulkan is a renderer, not an application switch
ailloli_ui_render_vulkan consumes Scene and DrawCmd data and records Vulkan commands into a target supplied by a specialized host.
Host-owned lifecycle
The host owns the Vulkan device, queue, command pool, target image, rendered-frame pacing, and presentation.
Separate crate
There is no Vulkan feature on the ailloli_ui façade in beta.2. Add the renderer crate directly for a custom integration.
Build-time shaders
The crate compiles GLSL to SPIR-V with shaderc during the build. A successful cargo check does not prove a driver or presentation path.
Rendering parity is incomplete
RingProgress and Polyline commands are ignored in beta.2, unsupported images are counted as ignored, and the renderer waits for its queue after submission. Measure the real workload before relying on it.
04
OpenXR combines adapters and an optional runtime
ailloli_ui_openxr is also separate from the façade. Its host-agnostic input mapper can turn XR pointer samples into ordinary Ailloli UI events.
Input adapter
Pointer IDs, hits, trigger transitions, and scroll deltas can be mapped without creating an OpenXR session.
OpenXR feature
The openxr feature enables the loaded OpenXR and Vulkan host path. It needs a loader, runtime, compatible device, and real host lifecycle.
smoke_ui feature
This adds the built-in smoke scene used by example hosts. It is a validation aid, not an end-user application framework.
05
A safe hardware-free input check
This program translates two hit frames for the same XR pointer, first released and then pressed. It proves that the public input adapter can produce a transition, not that an XR runtime can present a rendered frame.
Declare the frontier explicitly
The probe starts with the hardware-free input adapter. Optional features expose type-level Vulkan and OpenXR runtime probes.
[package]
name = "experimental-hosts"
version = "0.1.0"
edition = "2021"
rust-version = "1.88"
publish = false
[features]
default = []
vulkan-probe = ["dep:ailloli_ui_render_vulkan"]
openxr-runtime = ["ailloli_ui_openxr/openxr"]
[dependencies]
ailloli_ui_core = "=0.1.0-beta.2"
ailloli_ui_openxr = { version = "=0.1.0-beta.2", default-features = false }
ailloli_ui_render_vulkan = { version = "=0.1.0-beta.2", optional = true }use ailloli_ui_core::event::Modifiers;
use ailloli_ui_core::Point;
use ailloli_ui_openxr::{
map_samples_to_openxr_input_events, OpenXrInputMapper, OpenXrPointerFrame, OpenXrPointerHit,
OpenXrPointerSample, PointHit,
};
fn main() {
let hit = OpenXrPointerHit::Hit(PointHit::new(Point::new(120.0, 80.0), None));
let released = OpenXrPointerFrame::new(vec![OpenXrPointerSample::new(1, hit, false)]);
let pressed = OpenXrPointerFrame::new(vec![OpenXrPointerSample::new(1, hit, true)]);
let mut mapper = OpenXrInputMapper::new();
let _hover_events =
map_samples_to_openxr_input_events(&mut mapper, &released, Modifiers::default());
let press_events =
map_samples_to_openxr_input_events(&mut mapper, &pressed, Modifiers::default());
assert!(!press_events.is_empty());
#[cfg(feature = "vulkan-probe")]
let _vulkan_options = ailloli_ui_render_vulkan::VulkanRendererOptions::default();
#[cfg(feature = "openxr-runtime")]
let _openxr_options = ailloli_ui_openxr::OpenXrRuntimeOptions::default();
}The default input adapter, Vulkan type check, and OpenXR runtime feature all pass cargo +1.88.0 check against the beta.2 source.
06
What compile-time success cannot prove
Immersive software crosses hardware, driver, loader, runtime, graphics, and interaction boundaries. Validate each one on the target system.
Loader and runtime
An OpenXR loader and active runtime must expose the required extensions.
GPU compatibility
The selected Vulkan physical device and queues must match the XR runtime requirements.
Real interaction
Controllers, hands, rays, focus, trigger transitions, and panel scale need device testing.
Frame behavior
Check frame pacing, synchronization, swapchains, text clarity, and failure recovery under the real workload.
You reached the frontier
You can now build a friendly desktop app, reason about its retained runtime, inspect it, and evaluate experimental hosts without confusing source availability with production readiness.
Try it yourself
Exercise: add a scroll gesture to the probe
Extend the hardware-free pointer probe with one more kind of input.
- 1Add with_scroll(0.0, 12.0) to the released pointer sample.
- 2Inspect the first event batch for a scroll event while keeping the press transition in the second batch.
Keep the pointer hit and identity unchanged. A nonzero logical-pixel delta is enough to produce scrolling.
The first batch includes scrolling, the second still includes a press transition, and no XR runtime is started.