Extensions
OpenXR was written for headsets. A display on a desk differs in four ways; DisplayXR extends OpenXR with an XR_DXR_* extension for each.
Where vanilla OpenXR stops
1
Where the display is
2
Many windows, not one screen
3
2D and 3D in the same window
4
3D over the desktop, when you want it
Plus advanced extensions for shells, capture, agents and 2D-to-3D.
Gap 1
Where the display is
OpenXR assumes a headset: A headset moves with your head, so OpenXR hands the app a symmetric field of view.
On a display: A display has a physical size and stays put, and both eyes look at the same rectangle from different places.
Display Info
XR_DXR_display_info- Vanilla OpenXR assumes
- a headset, whose optics fix the views. There is no call for a screen's physical size or the viewer's tracked eyes.
- This adds
- the panel's size in metres and a recommended render scale, its rendering modes (2D, stereo, multiview), eye-tracking modes with an event when tracking is lost, and where the panel sits on the desktop.
- You need it if
- you render for a spatial display on purpose. Unmodified OpenXR apps still run without it, with a runtime-chosen compromise.
View Rig
XR_DXR_view_rig- Vanilla OpenXR assumes
- views come from fixed optics: the app renders the pose and field of view it is handed, with nothing to tune.
- This adds
- a rig descriptor chained on xrLocateViews (virtual display height and ipd, parallax and perspective factors, or a camera's convergence and vertical FOV). You get back standard XrView pose and FOV; the runtime does the off-axis math.
- You need it if
- you want to frame the scene's scale and depth without writing the off-axis projection yourself.
Gap 2
Many windows, not one screen
OpenXR assumes a headset: A headset session is exclusive: it owns the whole display, because on a headset that is the whole world.
On a display: On a desk, several 3D apps share the screen in ordinary windows you drag, resize and overlap.

Win32 Window Binding
XR_DXR_win32_window_binding- Vanilla OpenXR assumes
- the runtime owns the output. There is no app window to render into.
- This adds
- your HWND, so the runtime renders into your window: windowed mode, your own keyboard and mouse, several apps on one display. Also offscreen readback and a shared D3D11/D3D12 texture.
- You need it if
- your Windows app owns its window.
Cocoa Window Binding
XR_DXR_cocoa_window_binding- Vanilla OpenXR assumes
- the runtime owns the output. There is no app window to render into.
- This adds
- your CAMetalLayer-backed NSView, so the runtime renders into your view: windowed mode, your own input, several apps on one display. Also offscreen readback.
- You need it if
- your macOS app owns its window.
Xlib Window Binding
XR_DXR_xlib_window_binding- Vanilla OpenXR assumes
- the runtime owns the output. There is no app window to render into.
- This adds
- your X11 Display* and Window, so the runtime's Vulkan compositor renders into your window: windowed mode, your own keyboard and mouse.
- You need it if
- your Linux app owns an X11 window.
Wayland Surface Binding
XR_DXR_wayland_surface_binding- Vanilla OpenXR assumes
- the runtime owns the output. There is no app surface to render into.
- This adds
- your wl_display and wl_surface, and the surface size, which a Wayland surface does not carry. You keep the surface lifecycle; transparency over the desktop is native.
- You need it if
- your Linux app owns a Wayland surface.
Android Surface Binding
XR_DXR_android_surface_binding- Vanilla OpenXR assumes
- the runtime owns the output. There is no app surface to render into.
- This adds
- your Surface, so the runtime composites into it instead of spawning its own, republished across background and resume, with the window's on-panel position each frame.
- You need it if
- your Android app runs in a window (freeform or split-screen). Without it, the runtime's own surface is fullscreen-only.
Gap 3
2D and 3D in the same window
OpenXR assumes a headset: Core OpenXR's layers (projection, quad, cube, cylinder) describe a world, not a 3D region inside a 2D window.
On a display: Most of a screen is text and menus. The 3D is one region inside the window, with the flat page around it.

Local 3D Zones
XR_DXR_local_3d_zone- Vanilla OpenXR assumes
- the projection layer is the whole picture. Layers describe a world, not which pixels of a window are 3D.
- This adds
- a per-pixel 3D mask over your window (whole window, rectangles, or freeform) and a flat 2D layer composited after the weave. The same mask drives panels that can switch regions between 2D and 3D.
- You need it if
- your window mixes 3D with flat UI: toolbars, panels, text.
Display Zones
XR_DXR_display_zones- Vanilla OpenXR assumes
- one set of views per session, framed for the whole display.
- This adds
- several 3D zones in one window, each framed by its own view rig, plus 2D zones and a mask telling the panel where to switch to 3D. Builds on Local 3D Zones and View Rig.
- You need it if
- you need more than one 3D region, or a 3D region framed apart from the rest of the window.
Window Weave Service
XR_DXR_weave- Vanilla OpenXR assumes
- the runtime presents the final image, so nothing else needs its weaver.
- This adds
- a weave service for callers that own and present their own window: hand it side-by-side stereo and window rects, get back a woven texture and a fence. The weave runs in out-of-process sessions only.
- You need it if
- you present your own window, as a browser does, and want 3D regions in it woven.
Gap 4
3D over the desktop, when you want it
OpenXR assumes a headset: In a headset there is no desktop: one compositor draws everything the eyes see.
On a display: On a desk, 3D can sit over ordinary flat windows, see-through around its edges, with clicks passing to the window behind.

Rear Depth Budget
XR_DXR_depth_budget- Vanilla OpenXR assumes
- nothing shows through around the content, so how far back it renders is the app's call alone.
- This adds
- an advisory budget: the runtime looks at the desktop behind a transparent app and says how far behind the screen it can render and still read correctly. Ignore it and nothing changes.
- You need it if
- your app is transparent over the desktop and wants content behind the screen plane.
Spatial Workspace
XR_DXR_spatial_workspace- Vanilla OpenXR assumes
- each session stands alone. No process arranges the others.
- This adds
- the contract for a privileged workspace controller: claim the role, then place client windows, route input, hit-test and capture. The DisplayXR Shell is one such controller.
- You need it if
- you build a shell, launcher, kiosk or OEM workspace. Ordinary apps never do.
Advanced / other
Capture, agents, 2D-to-3D, workspace dialogs and graphics bindings: useful, and none of them a gap every app hits.
3D App Share
XR_DXR_app_share- Vanilla OpenXR assumes
- an app's frames end at its own display. Nothing outside the DisplayXR runtime can receive them.
- This adds
- a running app as one more stereo camera source: its left and right views, before the weave, as one side-by-side stream with per-frame content details. Every share starts behind a runtime prompt, and an app can opt out of ever being listed. No new entry points; it builds on Stereo Camera. Windows today, and in-process OpenGL apps are not shared.
- You need it if
- you build a call or capture client that sends a running 3D app to others in 3D, as the DisplayXR Browser does, or your app must never be shared.
Atlas Capture
XR_DXR_atlas_capture- Vanilla OpenXR assumes
- the composed frame stays inside the runtime. To capture, you read back your own swapchains, once per graphics API.
- This adds
- one call that saves the multi-view atlas the runtime composed for your session as a PNG, at a compositor stage you pick. Any app class can call it.
- You need it if
- you want screenshots, recordings or datasets of your 3D output.
Depth-Aware Cursor
XR_DXR_cursor_depth- Vanilla OpenXR assumes
- the pointer is drawn flat on the display plane, so over content that pops out of the glass it sits behind what it is hovering.
- This adds
- an opt-in hint on xrLocateViews: you report the nearest content depth under the pointer, and the runtime hands back where and how large to draw a cursor sprite so it sits just in front, moving the same way in every app.
- You need it if
- your app shows content in front of the display plane and users point at it, such as model, splat or stereo media viewers.
Desktop Control
XR_DXR_desktop_control- Vanilla OpenXR assumes
- an app sees only its own session. It has no view of the rest of the desktop.
- This adds
- one API for an app's agent to observe and operate the desktop (windows, UI text, typing, clicks) and, as a separate consent scope, capture screen stills. It runs inside the calling app through the OS's own consent, so the permission belongs to the app, never to DisplayXR. In development: OS backends are landing one by one, and an OS without one reports the feature as unsupported.
- You need it if
- your app's AI agent needs to see or act on other windows on the desktop.
Input Providers
XR_DXR_input_providers- Vanilla OpenXR assumes
- input devices sit behind interaction profiles. An app cannot tell which source drives its controllers or hands.
- This adds
- a list of the resident input providers (each provider's own name, the families it supplies, whether its hardware is there, which one serves this app), and a request for one per family, optionally saved as the user's per-app choice.
- You need it if
- you want to show which device drives the hands or controllers, or let the user pick one, without naming a vendor in your code.
2D-to-3D Conversion
XR_DXR_lift- Vanilla OpenXR assumes
- the app renders its own 3D content.
- This adds
- asynchronous access to the machine's 2D-to-3D conversion providers (depth, stereo, N-view, or photo to Gaussian splats). You ask by task, can warm a task before you need it, and hand frames in with explicit synchronization. The runtime picks and hosts the provider per task, tells you when it is ready, and never weaves. Reached through the service, from IPC apps and from in-process D3D11 and D3D12 apps on Windows.
- You need it if
- you show 2D photos or video and want the panel's own conversion rather than shipping a model.
macOS OpenGL Binding
XR_DXR_macos_gl_binding- Vanilla OpenXR assumes
- OpenGL bindings for Windows and Linux (Xlib, XCB, Wayland), and none for macOS.
- This adds
- an OpenGL binding for macOS: pass your CGL context, and the runtime shares IOSurface-backed textures with its Metal compositor.
- You need it if
- your macOS app renders with OpenGL.
App MCP Tools
XR_DXR_mcp_tools- Vanilla OpenXR assumes
- input comes from the user's devices. There is no path for an agent to call into the app.
- This adds
- your own MCP tools on the runtime's per-app MCP server. Calls arrive on the OpenXR event queue and you answer from your frame loop; through the workspace, tools are namespaced by your app id.
- You need it if
- you want AI agents or voice drivers to operate your app. Inert unless MCP is enabled on the machine.
Stereo Camera
XR_DXR_stereo_camera- Vanilla OpenXR assumes
- a display's stereo camera belongs to whichever process opens it first, so an app and the eye tracker fight over the device.
- This adds
- a runtime-owned stereo camera source. The service opens the camera once and fans side-by-side frames out to each authorised stream over shared memory, behind a consent, foreground and in-use-indicator gate.
- You need it if
- you want live stereo video from the display's own camera, for calls, capture or depth, without taking it from the tracker.
Stereo Comfort Zone
XR_DXR_stereo_comfort- Vanilla OpenXR assumes
- optics fix the views, so how much depth is comfortable is not the app's question.
- This adds
- an opt-in report on xrLocateViews: the comfort zone for the current viewer, as depth bounds in front of and behind the glass with the matching on-glass disparity, at the tracked or nominal viewing distance and with the user's depth preference applied.
- You need it if
- you set your own eye separation and want it right on every display size and viewing distance, instead of a hard-coded percentage.
Swapchain Color Encoding
XR_DXR_swapchain_color_encoding- Vanilla OpenXR assumes
- every non-sRGB format holds linear values, so the runtime encodes a UNORM swapchain on its way to the panel.
- This adds
- a declaration that a UNORM swapchain already holds display-encoded (sRGB) values, so the DisplayXR runtime reads it like an _SRGB one and a 10-bit back buffer goes through without conversion. Windows, in-process D3D11 and D3D12 only; other paths refuse the declaration.
- You need it if
- you submit pixels that are already display-referred, such as a game's back buffer, a decoded video frame or a desktop capture.
Window Visibility
XR_DXR_window_visibilityTells the app when nobody can see its window (minimized, cloaked, covered, hidden, the session locked or the display off) and why, with an opt-in that moves a hidden session to SYNCHRONIZED so it stops rendering, never while its window is the foreground window and never before it is first shown
Workspace File Dialog
XR_DXR_workspace_file_dialog- Vanilla OpenXR assumes
- no workspace: an app's dialogs are the OS's business.
- This adds
- an asynchronous file picker the workspace controller shows as its own window, with the result arriving as an event. When no controller supports it, the call says so and you use the OS dialog.
- You need it if
- your app runs inside a workspace such as the Shell and opens or saves files.
Catalog
Generated from the headers. Since runtime v2.0.0 every extension uses the XR_DXR_* author tag, registered with Khronos in July 2026 (before that, provisional XR_EXT_* names); scripts/dxr_rename.py in the runtime repo migrates a codebase in one command. Headers and specs live in displayxr-extensions.
| Extension | Spec | Summary |
|---|---|---|
| XR_DXR_android_surface_binding | v3 | App-provided Android Surface / ANativeWindow, republished across background and resume, with the per-frame window rect and the surface's touch events for the runtime's touch input provider |
| XR_DXR_app_share | v1 | 3D screen share: a running DisplayXR app's pre-weave left/right views offered as one more XR_DXR_stereo_camera source, display-referred side-by-side frames with per-frame content metadata, behind a per-start runtime share prompt (ADR-061; not implemented yet) |
| XR_DXR_atlas_capture | v3 | Vendor-neutral PNG snapshot of the multi-view atlas at a caller-selected compositor stage, for any app class |
| XR_DXR_cocoa_window_binding | v8 | App-provided NSView, IOSurface sharing, runtime-owned phase-snapped window drag/resize (opt-out) |
| XR_DXR_cursor_depth | v8 | Opt-in: the app reports the nearest content under the cursor at xrLocateViews; the runtime places a cursor sprite just in front of it (and, since v5, draws it, with the app's own sprite or the OS cursor's look; since v8 also on any woven rect, so a web page's cursor is drawn by the runtime with the browser's real cursor), so the pointer never sits behind 3D content |
| XR_DXR_depth_budget | v4 | Advisory limit on how far behind the display plane a transparent app may render, chained on XrViewState at xrLocateViews |
| XR_DXR_desktop_control | v3 | An app's agent observes and operates the desktop (windows, UI text, typing, clicks) and, as a separate consent scope, captures screen stills, through the OS's own consent, granted to the app, never to DisplayXR |
| XR_DXR_display_info | v26 | Display dimensions, eye-tracking modes, and the data needed for asymmetric (Kooima) projection |
| XR_DXR_display_zones | v3 | A layout of independent 3D zones and flat 2D zones across one display, each 3D zone with its own view rig, plus the wish mask a switchable-lens panel honours; poll xrGetDisplayZoneRecommendedViewSizeDXR for per-zone sizes — XrEventDataDisplayZoneMetricsChangedDXR is deprecated and never emitted |
| XR_DXR_input_providers | v1 | An app lists the resident input providers (the provider's own name, families it supplies, presence, which one holds this app's controllers / hands / gamepad) and requests one per family, optionally as the user's per-app pin |
| XR_DXR_lift | v5 | 2D-to-3D conversion as a service: depth, video depth, stereo or N views, and photo-to-Gaussian-splats, served by whichever conversion provider the runtime selects per task (apps see tasks; they may list the candidate providers read-only and hint one per stream, never set the user's default); enumerate tasks with their readiness and pushed state events, and wait for READY rather than fall back to an in-app converter; submit 2D frames (any platform image kind, explicit sync), acquire the latest result with its depth units and view metadata, or flag a weave rect as 2D so the service lifts it before weaving; the runtime owns the viewpoint policy, can derive the viewpoints from the app's own view rig, and returns depth from the same inference aligned to display space |
| XR_DXR_local_3d_zone | v5 | Per-pixel 3D-ness mask over an app's own window, with the flat 2D side as a first-class post-weave composition layer; its view-size event is soft-deprecated since spec 5 in favour of the Khronos XR_EXT_view_configuration_views_change, but still emitted unchanged |
| XR_DXR_macos_gl_binding | v2 | macOS OpenGL graphics binding |
| XR_DXR_mcp_tools | v1 | An app registers its own MCP tools with the runtime's agent surface; calls arrive on the OpenXR event queue |
| XR_DXR_spatial_workspace | v26 | Multi-app composition across every 3D screen: screen enumeration, per-screen window placement and overlays, capture, modal input grab |
| XR_DXR_stereo_camera | v7 | A runtime-owned, privacy-gated stereo camera source: the display's own camera (usually the eye tracker's, supplied by the vendor plug-in without taking it from the tracker) or an opted-in plain UVC side-by-side webcam, fanned out by the service to clients as rectified newest-frame side-by-side pairs over shared memory |
| XR_DXR_stereo_comfort | v1 | Opt-in: xrLocateViews reports the comfort zone for the current viewer (diopter bounds in front of and behind the glass, and the matching on-glass disparity, at the tracked or nominal viewing distance, with the user's depth preference applied), so an app sizes its eye separation from the display instead of a hard-coded percentage |
| XR_DXR_swapchain_color_encoding | v1 | Declares that a UNORM swapchain holds display-encoded (sRGB) values, so the runtime reads it like an _SRGB one: lets a 10-bit back buffer be submitted without converting it |
| XR_DXR_view_rig | v5 | App declares a display or camera rig descriptor and consumes render-ready XrView{pose, fov}; the runtime owns the projection math — and, chained on the hand-joint locate, returns the joints in that same rig frame |
| XR_DXR_wayland_surface_binding | v2 | App-provided wl_display and wl_surface (desktop Linux), plus the app-declared surface size that makes windowed Wayland work |
| XR_DXR_weave | v21 | Window-bound synchronous weave for present-owners: hand the runtime a stereo texture and a window rect, get back a weaved shared texture and a fence (sync_file acquire/release fences on desktop Linux and Android, so the weave pipelines with the caller's GPU work); a window spanning two 3D screens is woven per screen, with each screen's eyes and each rect's per-screen parts handed back; a present-owner can report when its frames were presented, so the runtime predicts the viewer's eyes across the measured weave-to-scanout interval |
| XR_DXR_win32_window_binding | v9 | App-provided HWND, shared texture, canvas sub-rect |
| XR_DXR_window_visibility | v1 | Tells the app when nobody can see its window (minimized, cloaked, covered, hidden, the session locked or the display off) and why, with an opt-in that moves a hidden session to SYNCHRONIZED so it stops rendering, never while its window is the foreground window and never before it is first shown |
| XR_DXR_workspace_file_dialog | v1 | Async spatial-native file picker spawned by the active workspace controller, with fallback to the platform dialog |
| XR_DXR_xlib_window_binding | v2 | App-provided X11 Display* and Window (desktop Linux) |