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. 1

    Where the display is

  2. 2

    Many windows, not one screen

  3. 3

    2D and 3D in the same window

  4. 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.

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

EssentialShipping
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

EssentialShipping
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

EssentialBeta
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

EssentialEarly
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

EssentialShipping
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.

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.

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

AdvancedEarly
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

AdvancedEarly
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

AdvancedEarly
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

AdvancedExperimental
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

AdvancedEarly
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

AdvancedExperimental
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

AdvancedShipping
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

AdvancedEarly
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

AdvancedEarly
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

AdvancedEarly
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

AdvancedEarly
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

AdvancedEarly
XR_DXR_window_visibility

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

Workspace File Dialog

AdvancedBeta
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.

ExtensionSpecSummary
XR_DXR_android_surface_bindingv3App-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_sharev13D 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_capturev3Vendor-neutral PNG snapshot of the multi-view atlas at a caller-selected compositor stage, for any app class
XR_DXR_cocoa_window_bindingv8App-provided NSView, IOSurface sharing, runtime-owned phase-snapped window drag/resize (opt-out)
XR_DXR_cursor_depthv8Opt-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_budgetv4Advisory limit on how far behind the display plane a transparent app may render, chained on XrViewState at xrLocateViews
XR_DXR_desktop_controlv3An 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_infov26Display dimensions, eye-tracking modes, and the data needed for asymmetric (Kooima) projection
XR_DXR_display_zonesv3A 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_providersv1An 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_liftv52D-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_zonev5Per-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_bindingv2macOS OpenGL graphics binding
XR_DXR_mcp_toolsv1An app registers its own MCP tools with the runtime's agent surface; calls arrive on the OpenXR event queue
XR_DXR_spatial_workspacev26Multi-app composition across every 3D screen: screen enumeration, per-screen window placement and overlays, capture, modal input grab
XR_DXR_stereo_camerav7A 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_comfortv1Opt-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_encodingv1Declares 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_rigv5App 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_bindingv2App-provided wl_display and wl_surface (desktop Linux), plus the app-declared surface size that makes windowed Wayland work
XR_DXR_weavev21Window-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_bindingv9App-provided HWND, shared texture, canvas sub-rect
XR_DXR_window_visibilityv1Tells 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_dialogv1Async spatial-native file picker spawned by the active workspace controller, with fallback to the platform dialog
XR_DXR_xlib_window_bindingv2App-provided X11 Display* and Window (desktop Linux)

Where to next