Toggle search
Toggle menu
5.5K
6.1K
231
53.6K
VR & AR Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Developer Resource

vrarwiki.com · VR & AR Wiki
More actions

Developer Resource is a guide to tools, documentation and workflows for building virtual reality, augmented reality and mixed reality applications. It covers choosing a target platform, configuring an engine, testing on hardware and preparing an app for distribution. OpenXR provides a common application interface for supported XR runtimes, while engine packages and platform SDKs supply additional features.[1]

Reviewed 17 October 2026. Checked the Steam Frame, Unity 6 and XR Interaction Toolkit, Unreal Engine 5.8, Godot 4.7, OpenXR 1.1, Meta v207/XR Operator/Immersive Web SDK, Apple Xcode requirements, Android XR Developer Preview 4, PICO OS 6, Snap and Meta glasses additions and the Fernandes and Feiner study against their official sources, and spot-checked the Windows Mixed Reality status. About review dates.

Choose a development route

The following table links to official starting points. Choose the device and operating system first, then an engine and compatible SDK versions. A shared API does not establish that every device implements every optional feature.[1]

Platform and tool chooser
Target Starting point What to check before building
Meta Quest Unity, Unreal Engine or Godot with OpenXR; Meta's engine routes Meta recommends the engines' OpenXR paths and supplies platform integrations for Horizon OS features. Choose the integration needed by the application.[2]
PC VR with SteamVR An engine with OpenXR support; Steamworks VR documentation Install and select a suitable runtime. Steam distribution also has application settings and launch options to configure.[3][4]
Steam Frame Steamworks Steam Frame documentation; Unity, Unreal Engine, Godot or a custom engine through OpenXR Valve lists Windows and Linux PC titles, native ARM64 builds and Android APKs as supported execution models. Standalone titles receive a compatibility review result of Verified, Playable, Unsupported or Unknown.[5][6]
Android XR Google's tool chooser: Jetpack XR, game engines, OpenXR or WebXR Match the tools to the app type. Android XR's OpenXR guide says its emulator does not support Unity or OpenXR applications.[7][8]
Apple Vision Pro Xcode and visionOS; SwiftUI and RealityKit, or Unity's visionOS integration Select a window, volume or immersive-space design. Apple supplies its own frameworks and development route.[9]
PlayStation VR2 on PlayStation 5 PlayStation Partners Partner registration and approval precede access to development tools and documentation. PC use of the headset is a separate target.[10][11]
PICO PICO developer documentation and its Unity, Unreal or OpenXR routes Select documentation for the intended device, OS and SDK. The developer portal distinguishes spatial applications from immersive OpenXR applications.[12]
Phone and tablet AR ARKit for Apple devices, ARCore for supported devices, or Unity AR Foundation Check device support and install the platform provider packages. AR Foundation supplies common interfaces; the provider implements the features.[13][14]
Browser-based XR WebXR and a compatible browser Detect session and feature support. The WebXR Device API has security, permission and user-activation requirements.[15]

Versioned documentation

Use documentation for the engine and package versions installed in the project. The references below are specific documentation branches checked for this guide, not a promise that every vendor SDK supports the same versions.

Tool Versioned reference Purpose
Unity Unity 6.3 LTS manual XR project, scene, graphics and audio workflows.[16] Unity 6.3 is the current LTS release, supported until December 2027; Unity states that Unity 6.0 LTS is supported through October 2026.[17]
Unity XR Interaction Toolkit XRI 3.3 documentation Interaction components and locomotion. XRI is distinct from the OpenXR provider plug-in.[18] Version 3.6.1 of the package lists Unity 6000.0 and later as its requirement; check component names against the installed version.[19]
Unreal Engine Unreal Engine 5.7 VR Template OpenXR project structure, teleportation, turning and object interaction.[20] The later Unreal Engine 5.8 release notes list experimental Steam Frame support implemented together with Valve, OpenXR stereo layers that can be drawn behind the main scene, and a PICO controller OpenXR plug-in enabled by default in the VR Template.[21]
Godot Godot 4.6 XR guide XR scene setup and Android export. Check the release policy before selecting an older branch; Godot 4.3 is listed as unsupported.[22][23] Godot 4.7 was released in June 2026. Its release policy lists 4.7 and 4.6 with full support, 4.5 with partial support, and 4.4 and earlier 4.x releases as end of life.[24]

How to get started

An initial project should establish that the chosen tools can build and run on the target device. Unity's setup workflow separates provider configuration, support packages and scene components; Godot similarly requires an initialized XR interface and a configured scene.[25][22]

  1. Choose one initial device and application type from the platform table.
  2. Install a supported editor and the target platform's build tools. Follow the matching official setup guide rather than combining steps from different engine generations.
  3. Run an official starter scene or sample. Confirm head tracking, input, world scale and the tracking origin before adding application logic.
  4. Build a small interaction: select an object, pick it up, or activate a menu. Add movement only when the application requires it.
  5. Make an installed device build, collect performance measurements, and test comfort and accessibility. Repeat those checks when adding another device or runtime.

These steps are a suggested workflow. The sections below explain the underlying components and link to implementation instructions.

Essential concepts

Concept Development consequence
Tracking and coordinate spaces The application locates objects relative to a reference space. OpenXR distinguishes reference spaces and tracked action spaces; select the space appropriate to the experience.[26]
Input devices Define application actions and supply bindings. Input actions describe intent, such as selecting a menu item, rather than requiring one controller's button layout.[26]
Locomotion Physical movement and artificial movement have different design constraints. Plan for physical movement even in an application that primarily uses controller locomotion.[27]
Refresh rate and frame time The display interval constrains the rendering budget. For example, 90 Hz gives approximately 11.1 ms per interval. Measure CPU and GPU work as well as displayed frame rate.[28][29]
Passthrough and spatial anchors Mixed reality features depend on platform APIs and permissions. On visionOS, ARKit offers separate data providers for capabilities such as world tracking, hand tracking and scene reconstruction.[30]

SDKs, APIs and runtimes

A software development kit supplies libraries and tools used to build an application. A runtime implements the interface used by the running application. An interaction toolkit adds behaviors such as grabbing and teleportation. These are separate parts of an XR project: Unity, for example, configures provider plug-ins independently of support packages such as XR Interaction Toolkit.[25][1]

OpenXR

OpenXR is a royalty-free standard maintained by the Khronos Group. It defines how an application communicates with a runtime for operations including tracking, input and submitting rendered frames. Khronos maintains a list of conformant runtimes and participating engines.[1] OpenXR 1.1, released on 15 April 2024, moved widely used extensions into the core specification. Among them, XR_EXT_local_floor became the Local Floor reference space, XR_EXT_palm_pose became the grip surface pose and XR_VARJO_quad_views became the stereo with foveated rendering view configuration. The release also added 13 interaction profiles, most of them promoted from vendor extensions.[31]

Core architecture

The main concepts in the specification are:[26]

Object or identifier Role
XrInstance The application's connection to the runtime and associated OpenXR state.
XrSystemId Identifies a system of related XR devices selected through the runtime.
XrSession Coordinates presentation and interaction, including changes in the session's lifecycle.
XrSpace A coordinate frame used to express or locate poses.
XrAction An application input or output action, associated with physical controls through bindings.

Extensions and portability

Hand tracking, eye tracking, passthrough and other capabilities can require extensions and platform integration. The application must check what its runtime supports. Meta exposes Horizon OS features through OpenXR extensions and engine integrations; Google's Android XR documentation lists its supported extensions separately.[2][8]

Portability still requires testing the target platform's packaging and export settings. Godot's Android XR documentation, for example, describes Gradle builds, loaders and vendor settings. From Godot 4.6, the vendor plug-in is optional for many Android devices but remains recommended and can be needed for store releases.[32]

SteamVR and OpenVR

Valve distributes the runtime for its OpenVR API through SteamVR. The OpenVR SDK repository contains the API and samples, with documentation for application and driver interfaces. OpenXR is a separate standard that SteamVR also implements.[33][1]

For an OpenXR project, install the appropriate runtime and make sure the editor uses it. Epic's OpenXR setup documentation warns against enabling incompatible legacy Oculus, SteamVR and Windows Mixed Reality engine plug-ins alongside the OpenXR plug-in.[3]

Historical platform support

Windows Mixed Reality is a legacy target. Microsoft removed the Windows Mixed Reality components in Windows 11 version 24H2. Microsoft's published transition guidance allows existing devices to continue working with Steam through November 2026 on Windows 11 version 23H2, after which Windows Mixed Reality support and updates end. Older tutorials that assume these components are present in every Windows installation need to be checked against the actual OS version.[34]

Game engines

The practical choice is the engine that supports the intended platform, required features and team's workflow. The following comparison describes development routes rather than ranking visual quality or ease of learning.

Route XR integration Useful starting project
Unity C# scripting.[35] XR Plug-in Management selects providers; XR Interaction Toolkit supplies interactions; AR Foundation supplies common AR interfaces.[25][13] Unity Hub XR templates and the XR Interaction Toolkit examples linked by Unity's manual.[16]
Unreal Engine C++ and Blueprint visual scripting can be used separately or together.[36] XR projects use the OpenXR plug-in and compatible extension plug-ins.[3] VR Template with the VRPawn, teleportation, snap turning and grabbing examples.[20]
Godot GDScript and C#, with C and C++ available through GDExtension.[37] A built-in OpenXR interface, with optional add-ons for vendor features and reusable interactions.[22][32] The versioned XR tutorial and Godot XR Tools support scenes. Check the add-on's engine-version compatibility table.[38]

Developing with Unity

Project setup

Unity's XR templates preinstall selected packages but still require platform configuration. Follow the project-creation instructions for the installed editor. Install the build modules for each deployment target and choose a compatible rendering pipeline.[39]

In XR Plug-in Management, configure providers for the selected build target. Enabling a provider for a desktop build does not configure the Android target. Run the provider's project validation and resolve the reported requirements before testing.[40]

Packages and their roles

Package or system Role
XR Plug-in Management Configure the XR provider for each build target.[40]
OpenXR provider plug-in Connect the Unity application to an OpenXR runtime.[40]
XR Interaction Toolkit Component-based interaction, locomotion and UI behaviors.[18]
AR Foundation Cross-platform AR interfaces, used with the appropriate provider plug-ins.[13]
Meta XR packages Meta-specific rigs, input and other platform features. Meta's overview also covers Mixed Reality Utility Kit and Building Blocks.[41]

Meta XR integration

Meta XR Core SDK includes the OVRCameraRig prefab. Meta's Interaction SDK adds higher-level interaction components, while OVRInput exposes controller input. Meta's documentation directs developers needing non-Meta platform compatibility toward Unity's Input System. Building Blocks supply configured prefabs for exploring features, and Mixed Reality Utility Kit supplies tools for spatially aware applications.[41]

Use Meta's Unity development overview to reach the current setup and compatibility pages. Add the specific SDKs required by the project rather than treating every package as mandatory.

In a 24 September 2026 post after Meta Connect, Meta said that the Meta VR Glasses, which ship in spring 2027, use the same SDKs and that the v207 SDKs are enough to start building for them. Eyes and hands are the primary inputs; Touch Plus controllers are supported, though Meta expects most customers not to use them. For Unity and Unreal developers, v207 adds a VR Glasses profile in Meta XR Simulator, and the main addition to the Interaction SDK is Gaze Interaction. Meta gives the glasses' field of view as roughly 70 by 66 degrees, against 110 by 96 for Quest 3, and says its testing found a few apps that place UI elements at the extreme edges of the field of view.[42]

Interaction Toolkit architecture

XRI separates the object initiating an interaction from the object receiving it. An Interactor identifies potential targets; an Interactable defines the target's response. The Interaction Manager coordinates state changes among registered components. A typical scene uses one manager, but XRI permits multiple complementary managers, so it is not a mandatory singleton.[43]

The interaction states include Hover, Select, Focus and Activate. Selecting an object and activating it are distinct: an application might select a tool by holding it, then activate its function with another input. XRI's documentation describes the state transitions and interaction groups used to arbitrate competing interactors.[43]

Locomotion and UI

XRI supplies locomotion providers for teleportation, continuous movement and turning. The locomotion system works with the XR Origin and its body-transform components. Follow the package-version documentation when adding providers; component names and setup differ between major XRI versions.[44]

For Unity UI, XRI's setup uses a world-space Canvas, an XR-configured EventSystem, and a Tracked Device Graphic Raycaster. The UI setup guide explains the required components and input configuration.[45]

Developing with Unreal Engine

Project setup and the VR Template

Start from the VR Template, install the target device's runtime and configure the OpenXR plug-in. Target-specific build tools and SDKs remain necessary when packaging for another operating system.[3][20]

The template's VRPawn represents the player and contains controller input logic. VRGameMode selects the pawn, and Player Start establishes the initial tracking origin. Its teleportation and snap-turn examples can be inspected in the pawn. Navigation meshes mark permitted teleport areas; exclusion volumes can prevent teleportation into selected regions.[20]

The template also demonstrates grabbing through a GrabComponent, with free, snap and custom grab behavior, and a menu built with Unreal Motion Graphics. These examples are starting implementations to adapt to an application's interaction requirements.[20]

Platform integration and rendering

Meta documents both the engine OpenXR route and its Unreal source fork for Horizon OS features. Select a compatible integration and check its release documentation before changing the engine version.[2]

Do not assume that a desktop rendering feature is suitable for standalone XR. Epic's Nanite and Lumen XR documentation describes support as experimental and not officially supported, with the documented configuration restricted to PC, the Deferred Renderer and DirectX 12. It explicitly excludes mobile XR hardware and warns about the cost of rendering both views.[46]

Developing with Godot

Godot's XR system exposes interfaces through XRServer. In the 4.6 setup guide, enable OpenXR and XR shaders in Project Settings, then restart. The scene contains an XROrigin3D with an XRCamera3D and controller nodes beneath it. Handle failure to initialize the interface, and enable XR output on the intended viewport.[22]

The same guide recommends the Mobile renderer for desktop VR and the Compatibility renderer for standalone headsets. This is version-specific guidance, so check the corresponding manual when using another Godot release.[22] The 4.7 version of the guide changes this: it recommends the Mobile renderer for desktop VR and for standalone headsets such as the Meta Quest 3, and says Forward+ works but is less optimized for XR.[47]

For Android export, follow Godot's Android build prerequisites and XR export settings. The OpenXR Vendors plug-in supplies vendor integrations; choose the appropriate features in the export configuration. Godot XR Tools is a separate collection of reusable support scenes, with its own release and engine-compatibility table.[32][38]

Platform-specific development

Steam Frame

Valve describes Steam Frame as a standalone headset designed primarily for low-latency streaming of a player's Steam library from a PC, with standalone VR and non-VR applications also supported. It runs SteamOS, and Valve states that it keeps full compatibility with SteamVR and OpenXR.[5]

To test on the headset, Valve's guide turns on Developer Mode, pairs the headset with the SteamOS Devkit Client on a PC, and uploads a build with a selected runtime: Android for APKs, Steam Linux Runtime 3.0 ARM64 (Sniper) for Linux ARM64 binaries, or Steam Play (Proton) for Windows builds.[48]

For Unity, Valve recommends an Android target with Unity's built-in OpenXR plug-in, plus its Valve OpenXR Utilities package for the Steam Frame controller interaction profile. Its required project settings include IL2CPP, the ARM64 architecture and disabling Meta XR and Meta Quest OpenXR features.[49] Valve's Unreal Engine guide says Android builds run with the engine's built-in OpenXR support from Unreal Engine 5.6, recommends the VR Template as a starting point with the Steam Frame OpenXR Extension plug-in enabled, and also documents a LinuxArm64 route for running directly on SteamOS.[50]

The standalone compatibility review sets a minimum of 72 fps at 1728x1728 during normal play for VR titles and 30 fps at 1280x720 for 2D titles, along with input and "seamlessness" checks. Valve also recommends submitting motion vectors and depth suitable for reprojection.[6]

Apple Vision Pro and visionOS

Apple's development route starts with Xcode and the visionOS SDK. SwiftUI defines windows, volumes and immersive spaces, while RealityKit handles 3D content. Reality Composer Pro is part of the content-authoring workflow. Unity is another supported authoring route, using its visionOS integration.[9]

The system supports standard gestures for indirect and direct interaction. Apple recommends adopting system gestures for common tasks and using ARKit when custom hand-tracking interaction is required. External game controllers require explicit support through the Game Controller framework.[51]

ARKit capabilities and access are specific to the device, OS and application configuration. Select the data providers the application needs, check support and request the corresponding permissions. Apple's documentation separates system-mediated interaction from access to sensor data.[30]

Use the current Xcode and SDK requirements linked from Apple's guide. A minimum from an early visionOS tutorial does not establish compatibility with a later SDK or current store submission requirements. Since 28 April 2026, Apple requires apps uploaded to App Store Connect to be built with Xcode 26 or later using an SDK such as visionOS 26.[52] Apple released Xcode 27 on 14 September 2026, visionOS 27.0.1 on 28 September 2026 and Xcode 27.1 on 15 October 2026.[53]

PlayStation VR2

For PlayStation 5 development, Sony's public instructions begin with PlayStation Partners registration. Approved partners obtain development tools, documentation and publishing resources after completing the required agreement. Detailed setup should follow those partner resources.[10]

Using PS VR2 as a PC headset does not supply the full PlayStation 5 feature set. Sony's support page lists HDR, eye tracking, headset feedback, adaptive triggers and the Sense controllers' advanced haptics as unsupported on PC; basic controller vibration remains available. Account for this distinction when specifying a PC build's input and rendering features.[11]

PICO

PICO's developer portal links to Unity and Unreal SDKs, OpenXR development, spatial applications and developer tools. It also distinguishes newer PICO OS spatial features from immersive OpenXR workflows. Follow the documentation selected for the target device and SDK rather than assuming that eye, face or body tracking is available on every PICO headset.[12]

For PICO OS 6 and the Project Swan headset, which PICO lists as launching globally in 2026, PICO's developer site describes a Kotlin-based PICO Spatial SDK for spatial apps, the PICO Spatial Plugin and PICO Spatial Editor for Android Studio, and a PICO Emulator for testing on a PC or Mac without a headset. It also lists new PICO Unity and Unreal SDKs, the open-source WebSpatial SDK for web apps, and continued OpenXR support.[54]

Android XR

Google provides a tool chooser for Android XR that includes Jetpack XR and immersive development routes. Its OpenXR support includes version 1.1 and selected vendor extensions. Google also publishes Unity integration documentation and feature compatibility information.[7][8]

Google's Unity Direct Preview workflow uses a physical Android XR device with the editor, streaming rendered content to the device and supported tracking data back. This is different from the Android XR emulator; the OpenXR guide states that the emulator is not supported for Unity or OpenXR apps.[55][8]

The Android XR SDK reached Developer Preview 4 on 19 May 2026. Google's announcement added official support for Unreal Engine and Godot, introduced the Android XR Engine Hub, and updated Jetpack Projected and Jetpack Compose Glimmer for glasses. The same post renamed "AI glasses" to "audio glasses" and "display AI glasses" to "display glasses".[56] Jetpack XR SceneCore reached version 1.0.0-rc02 on 7 October 2026; no stable 1.0.0 release was listed.[57]

Phone and tablet AR

ARCore provides development routes for native Android and Unity, among other supported environments. Apple's ARKit requires supported hardware and appropriate user permission. Check each requested capability rather than inferring support from the operating-system name alone.[14][58]

Unity AR Foundation separates common AR interfaces from platform provider implementations. The package documentation includes a platform-feature matrix: the presence of an interface in AR Foundation does not mean all providers implement it.[13]

WebXR

WebXR provides browser APIs for XR sessions, tracking and input. A website can test session support before offering an immersive mode, and request the features it needs when creating the session. Browser and device support must be checked for the intended use case; the API's permission and secure-context requirements are part of deployment.[15]

Meta's open-source Immersive Web SDK (IWSDK), built on Three.js and an entity component system, reached version 1.0 on 14 October 2026. Meta describes interactions, locomotion, physics, spatial UI and mixed reality features behind a stable API, gaze and pinch input for Meta VR Glasses, and projects created with npm create @iwsdk@latest. Apps can be hosted on any HTTPS server or packaged as Progressive Web Apps for Meta's store.[59]

AR and AI glasses

Apps for Snap's Spectacles (2024) are built in Lens Studio. Snap's Spectacles developer documentation lists frameworks including the Spectacles Interaction Kit, Spectacles UI Kit and Spectacles Sync Kit.[60] At AWE on 16 June 2026, Snap announced tools for its Snap Specs glasses: a developer preview of agent-based development for Specs Lenses in Lens Studio, a Migration Agent for porting projects from tools such as Unity, and a Native Development Kit for bringing C and C++ code into Lenses. Developers join through the SPECS Developer Program.[61]

Meta opened its Wearables Device Access Toolkit as a developer preview in September 2025, with iOS and Android SDKs that let a phone app use the glasses' camera, audio and microphone. Meta said only select partners could publish integrations during the preview and planned to open publishing in 2026.[62] Meta's wearables developer site now lists three routes: the Device Access Toolkit, standalone web apps that need no companion app, and Meta AI Connectors in developer preview. It says submissions to discovery surfaces on Meta Ray-Ban Display glasses and in the Meta AI app are "coming soon".[63]

Comfort, interaction and accessibility

Locomotion design

Offer movement settings appropriate to the application and its users. Meta's locomotion guidance recommends choices between teleportation and sliding, and between snap and smooth turning. Teleportation can reduce motion discomfort but can also disorient users, particularly when orientation changes unexpectedly. Preview the destination and make direction changes clear.[64]

Comfort options can include field-of-view restriction during movement and transition effects. Physical effort also matters: repeated turning, reaching or standing may limit who can use an application. Meta's guidance discusses stationary use and alternatives for limited space or mobility.[65]

Ajoy S. Fernandes and Steven K. Feiner studied dynamic field-of-view restriction at IEEE 3DUI 2016. In a two-session, multi-day study with 30 seated participants using an Oculus Rift DK2, the field of view narrowed subtly during virtual motion. The authors report that participants stayed in the environment longer and felt more comfortable than in the control condition, without a decrease in subjective presence, and that half of the participants said they did not notice the restriction. They note the relatively small sample, and several comparisons were not significant after Bonferroni correction.[66] Unity's XR Interaction Toolkit includes a Tunneling Vignette Controller, described as a comfort mode intended to mitigate motion sickness, which locomotion providers can trigger.[67]

A 2023 study by Rachel L. Franz, Jinghan Yu and Jacob O. Wobbrock compared six seated locomotion techniques with 19 participants with upper-body motor impairments. Teleportation was favored in interviews, but preferences also depended on enjoyment, exercise and presence. The authors recommended offering a range of accessible choices. The result applies to that study population and does not establish one universally preferred method.[68]

Interaction and spatial UI

Use input methods suited to the task and provide feedback about focus, selection and activation. XRI's separate interaction states offer one implementation model; Apple's visionOS guidance recommends standard gestures for common interactions.[43][51]

Apple's accessibility guidance recommends keeping important interfaces in view, avoiding large repeated gestures, moderating motion in peripheral vision and avoiding content anchored to the wearer's head. Treat comfort and accessibility as test criteria alongside whether a control technically responds.[69]

Suggested test cases include seated and standing use, different reach ranges, the application's supported input methods, loss and recovery of tracking, and interrupted sessions. Record which tasks require a particular physical movement and whether the app supplies an alternative.

Performance, testing and debugging

Measure on the target device

Meta recommends systematic profiling to locate performance problems rather than applying settings without measurement. Graphics debuggers such as RenderDoc inspect rendering work; platform profiling tools expose timing and other device metrics.[70]

Frame rate alone does not reveal the cost of a rendered frame. Meta's GPU-cost guide explains that synchronization and inserted waits can obscure the relationship between FPS and GPU work. Collect CPU and GPU timing, check for repeated stalls, and measure scenes representative of the shipped application.[29]

Example display intervals
Refresh rate Approximate time per interval
72 Hz 13.9 ms
90 Hz 11.1 ms
120 Hz 8.3 ms

These intervals are examples, not universal application requirements. Supported refresh rates and acceptable operating modes depend on the device and platform. Meta's refresh-rate guide explains how raising the rate reduces the time available to render a frame.[28]

Profiling tools

Tool or workflow Use
Unity Profiler on Meta Quest Capture measurements from a development build running on the headset. Meta documents the Development Build and Autoconnect Profiler settings.[71]
Meta Quest Developer Hub Deploy builds, inspect logs, capture recordings and generate performance traces.[41]
Meta XR Simulator Preview an XR scene on a development computer. Meta documents Windows and macOS support.[41]
Meta XR Operator An experimental OpenXR API layer in Meta XR SDK v205, announced on 18 August 2026, that lets an MCP-compatible AI agent take screenshots, send input and inspect a running app in Meta XR Simulator. Meta recommends Windows and notes controller input limitations on macOS.[72]
PICO developer tools PICO's portal links to Developer Center, Metrics HUD and RenderDoc for PICO.[12]
Android XR Direct Preview Iterate with a physical device connected to Unity Editor.[55]
visionOS testing Apple provides device and simulator testing guidance; some sensor features require hardware. For example, its object-tracking sample does not run in the simulator.[73][74]

Optimization workflow

Use the profiler to identify the expensive work, change one part of the scene or configuration, and measure again. Check the cost of geometry, material complexity, transparency, lighting and resolution on the device. Keep performance records for demanding scenes and repeat them when the engine, SDK or content changes.[70]

Foveated rendering, resolution scaling and application frame-generation features are platform-specific options. Meta supplies a sample that demonstrates CPU/GPU levels, fixed foveation, resolution controls and Application SpaceWarp. Such controls need measurement in the application; an option's availability does not guarantee that it improves the relevant bottleneck.[75]

Reprojection and generated frames

Reprojection and frame synthesis belong to the runtime/rendering workflow. OpenXR coordinates the application frame loop with the runtime, including predicted display timing. Application SpaceWarp and other frame-generation features can require additional inputs such as motion vectors and depth; Google's Android XR documentation describes these inputs for its space-warp and frame-synthesis features.[26][8]

When reporting performance, distinguish application-rendered frames from generated or reprojected output and identify the mode used. A smooth headset image alone does not establish that the application is rendering at the display's refresh rate.[29][75]

AI model and deployment planning

An XR voice interface can use a model API and function calling to turn spoken requests into app actions, as Google's Android XR guidance describes.[76] Start with the required inputs, context and deployment route. AI Wiki's model comparison finder filters these published specifications rather than ranking XR performance.[77]

For a hosted prototype, enter expected tokens and request volume in the API cost and context planner. Its text-token estimate excludes media and other feature charges; confirm provider rates separately.[78] For local inference on a development PC, the LLM VRAM and RAM calculator estimates weights, context cache and runtime headroom. A memory fit does not establish response latency or headset compatibility; test the actual integration on target hardware.[79]

App stores and distribution

Meta Horizon Store

On August 5, 2024, Meta merged App Lab content into discoverability on the Meta Horizon Store. The migration ended App Lab's separate distribution route. Meta's transition announcement also describes Early Access and alternatives for applications not ready for public release.[80]

Follow the submission guide for the app record, build, product information and review process. Technical and content requirements should be checked before scheduling release.[81] Meta said at Connect 2026 that the store prioritizes controller-free titles for Meta VR Glasses users who do not own controllers, so hand-tracking support affects which users see an app first.[42]

Steam

Steam uses Steamworks to configure and distribute applications. Its VR documentation covers VR launch options and application settings, with separate references for SteamVR Input and OpenVR. Follow the appropriate launch configuration and accurately describe the tested hardware and play modes on the store page.[4]

PlayStation and Apple platforms

PlayStation publishing begins through the partner program and its documentation.[10] Apple's App Store for Vision Pro supports native visionOS applications and compatible iPhone/iPad applications. Apple provides a submission guide covering product pages, compatibility, testing and privacy information.[73]

A WebXR experience visited in a browser is a web distribution route; it should not be listed as though it were automatically a native app-store package.[15]

PICO and alternative distribution

PICO provides self-service developer onboarding, app publishing and store review guidance through its developer portal.[12] SideQuest supplies installers and device-management tools; its desktop application can install APK and OBB files. This is a separate workflow from submitting a native application to a headset manufacturer's store.[82]

3D models and asset resources

Choose assets that match the application's format, rendering pipeline and measured performance budget. The following directories cover different kinds of content; an asset listing is not evidence that the asset will meet a particular headset's performance target.

Resource Content and checks
Fab Models, materials, animations, audio, effects and tools, including Unreal and Unity content. Fab provides format and license filters and a 3D inspector for examining models.[83]
Unity Asset Store A marketplace for Unity assets and tools. Check each package's requirements before importing it.[84]
CGTrader A 3D model marketplace with categories and filters including low-poly, rigged and animated content.[85]
TurboSquid A marketplace for 3D models in multiple formats. Inspect the individual model's formats and specifications.[86]
Poly Haven A public library of models, textures and HDRIs. Its overview identifies its assets as CC0.[87]

Keep an asset record with its source, version and applicable license. Check the listing's requirements before distributing the asset in a project. Fab, for example, offers different license types; a free price alone does not identify the terms.[83]

Wrappers and compatibility layers

Community compatibility layers can help with existing software, but their supported application lists need separate verification. Revive describes itself as a layer between the Oculus SDK and OpenVR/OpenXR for running Oculus-exclusive games on HTC Vive or Valve Index. Its maintainers direct users to a community compatibility list and known issues.[88]

For a new project, start with the official engine and platform setup route. Treat a compatibility layer as a specific dependency to test, rather than as proof that a build works on every runtime.

Learning resources and community support

Official documentation and maintained sample projects are the starting points for version-specific setup. Community discussions are useful for troubleshooting, but a successful configuration in an old discussion may depend on different engine, OS or plug-in versions.

Resource Entry point
Unity XR Manual, samples and linked learning resources
Unreal Engine VR Template and developer forums
Godot XR XR tutorial and Godot XR Tools
OpenXR Specification, SDK, conformance and community resources
Meta Quest Development overview and submission guide
Apple visionOS Getting started and distribution
Android XR Tool chooser
PICO Developer portal
Steam Frame Steamworks Steam Frame documentation
Snap Spectacles Spectacles documentation

When asking for help, include the engine and SDK versions, target device and OS, selected runtime, reproduction steps and relevant logs. Remove credentials and personal information from shared logs.

See also

References

  1. ↑ 1.0 1.1 1.2 1.3 1.4 "OpenXR". Khronos Group. https://www.khronos.org/openxr/. Retrieved 2026-09-17.
  2. ↑ 2.0 2.1 2.2 "Meta and OpenXR". Meta Horizon OS Developers. 2025-03-07. https://developers.meta.com/horizon/blog/openxr-standard-quest-horizonos-unity-unreal-godot-developer-success/. Retrieved 2026-09-17.
  3. ↑ 3.0 3.1 3.2 3.3 "OpenXR Runtime". Unreal Engine 5.7 Documentation. https://dev.epicgames.com/documentation/en-us/unreal-engine/openxr-prerequisites-in-unreal-engine?application_version=5.7. Retrieved 2026-09-17.
  4. ↑ 4.0 4.1 "Virtual Reality". Steamworks Documentation. https://partner.steamgames.com/doc/features/steamvr. Retrieved 2026-09-17.
  5. ↑ 5.0 5.1 "Steam Frame". Steamworks Documentation. Valve. https://partner.steamgames.com/doc/steamhardware/steamframe. Retrieved 2026-10-17.
  6. ↑ 6.0 6.1 "Steam Frame Standalone Compatibility Review Process". Steamworks Documentation. Valve. https://partner.steamgames.com/doc/steamhardware/steamframe/compat. Retrieved 2026-10-17.
  7. ↑ 7.0 7.1 "Select your development tools and technologies". Android Developers. https://developer.android.com/develop/xr/tools-technologies. Retrieved 2026-09-17.
  8. ↑ 8.0 8.1 8.2 8.3 8.4 "Develop with OpenXR". Android Developers. https://developer.android.com/develop/xr/openxr. Retrieved 2026-09-17.
  9. ↑ 9.0 9.1 "visionOS". Apple Developer. https://developer.apple.com/visionos/. Retrieved 2026-09-17.
  10. ↑ 10.0 10.1 10.2 "Showing your Game to PlayStation". Sony Interactive Entertainment. 2026-04-07. https://sonyinteractive.com/en/news/blog/showing-your-game-to-playstation/. Retrieved 2026-09-17.
  11. ↑ 11.0 11.1 "PlayStation VR2 Support". PlayStation. https://www.playstation.com/en-us/support/hardware/psvr2/. Retrieved 2026-09-17.
  12. ↑ 12.0 12.1 12.2 12.3 "PICO Developer". PICO. https://developer.picoxr.com/. Retrieved 2026-09-17.
  13. ↑ 13.0 13.1 13.2 13.3 "AR Foundation". Unity AR Foundation 6.3 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/index.html. Retrieved 2026-09-17.
  14. ↑ 14.0 14.1 "Overview of ARCore and supported development environments". Google for Developers. https://developers.google.com/ar/develop. Retrieved 2026-09-17.
  15. ↑ 15.0 15.1 15.2 "WebXR Device API". W3C Immersive Web Working Group. https://immersive-web.github.io/webxr/. Retrieved 2026-09-17.
  16. ↑ 16.0 16.1 "XR". Unity 6.3 LTS Manual. https://docs.unity3d.com/6000.3/Documentation/Manual/XR.html. Retrieved 2026-09-17.
  17. ↑ "Unity 6 Releases and Support". Unity. https://unity.com/releases/unity-6/support. Retrieved 2026-10-17.
  18. ↑ 18.0 18.1 "XR Interaction Toolkit". Unity XR Interaction Toolkit 3.3 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/index.html. Retrieved 2026-09-17.
  19. ↑ "XR Interaction Toolkit". Unity XR Interaction Toolkit 3.6.1 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/index.html. Retrieved 2026-10-17.
  20. ↑ 20.0 20.1 20.2 20.3 20.4 "VR Template". Unreal Engine 5.7 Documentation. https://dev.epicgames.com/documentation/en-us/unreal-engine/vr-template-in-unreal-engine?application_version=5.7. Retrieved 2026-09-17.
  21. ↑ "Unreal Engine 5.8 Release Notes". Unreal Engine 5.8 Documentation. Epic Games. https://dev.epicgames.com/documentation/unreal-engine/unreal-engine-5-8-release-notes. Retrieved 2026-10-17.
  22. ↑ 22.0 22.1 22.2 22.3 22.4 "Setting up XR". Godot Engine 4.6 Documentation. https://docs.godotengine.org/en/4.6/tutorials/xr/setting_up_xr.html. Retrieved 2026-09-17.
  23. ↑ "Godot release policy". Godot Engine 4.6 Documentation. https://docs.godotengine.org/en/4.6/about/release_policy.html. Retrieved 2026-09-17.
  24. ↑ "Godot release policy". Godot Engine 4.7 Documentation. https://docs.godotengine.org/en/4.7/about/release_policy.html. Retrieved 2026-10-17.
  25. ↑ 25.0 25.1 25.2 "XR project set up". Unity 6.3 LTS Manual. https://docs.unity3d.com/6000.3/Documentation/Manual/configuring-project-for-xr.html. Retrieved 2026-09-17.
  26. ↑ 26.0 26.1 26.2 26.3 "The OpenXR 1.1 Specification". Khronos Group. https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html. Retrieved 2026-09-17.
  27. ↑ "Locomotion types". Meta Horizon OS Developers. 2025-12-17. https://developers.meta.com/horizon/design/locomotion-types/. Retrieved 2026-09-17.
  28. ↑ 28.0 28.1 "Set Display Refresh Rates". Meta Horizon OS Developers. https://developers.meta.com/horizon/documentation/unity/unity-set-disp-freq/. Retrieved 2026-09-17.
  29. ↑ 29.0 29.1 29.2 "Accurately Measure an App's Per-Frame GPU Cost". Meta Horizon OS Developers. https://developers.meta.com/horizon/documentation/unity/po-per-frame-gpu/. Retrieved 2026-09-17.
  30. ↑ 30.0 30.1 "ARKit in visionOS". Apple Developer Documentation. https://developer.apple.com/documentation/arkit/arkit-in-visionos. Retrieved 2026-09-17.
  31. ↑ "Khronos Releases OpenXR 1.1 to Further Streamline Cross-Platform XR Development". Khronos Group. 2024-04-15. https://www.khronos.org/news/press/khronos-releases-openxr-1.1-to-further-streamline-cross-platform-xr-development. Retrieved 2026-10-17.
  32. ↑ 32.0 32.1 32.2 "Deploying to Android". Godot Engine 4.6 Documentation. https://docs.godotengine.org/en/4.6/tutorials/xr/deploying_to_android.html. Retrieved 2026-09-17.
  33. ↑ "OpenVR SDK". Valve Software on GitHub. https://github.com/ValveSoftware/openvr. Retrieved 2026-09-17.
  34. ↑ "Deprecated features for Windows client". Microsoft Learn. https://learn.microsoft.com/en-us/windows/whats-new/deprecated-features. Retrieved 2026-09-17.
  35. ↑ "Introduction to programming in Unity". Unity 6.3 LTS Manual. https://docs.unity3d.com/6000.3/Documentation/Manual/intro-to-scripting.html. Retrieved 2026-09-17.
  36. ↑ "Coding in UE: Blueprint vs. C++". Unreal Engine 5.7 Documentation. https://dev.epicgames.com/documentation/en-us/unreal-engine/coding-in-unreal-engine-blueprint-vs-cplusplus?application_version=5.7. Retrieved 2026-09-17.
  37. ↑ "Scripting languages". Godot Engine 4.6 Documentation. https://docs.godotengine.org/en/4.6/getting_started/step_by_step/scripting_languages.html. Retrieved 2026-09-17.
  38. ↑ 38.0 38.1 "Godot XR Tools". GodotVR on GitHub. https://github.com/GodotVR/godot-xr-tools. Retrieved 2026-09-17.
  39. ↑ "Create an XR project". Unity 6.3 LTS Manual. https://docs.unity3d.com/6000.3/Documentation/Manual/xr-create-projects.html. Retrieved 2026-09-17.
  40. ↑ 40.0 40.1 40.2 "Choose and configure XR provider plug-ins". Unity 6.3 LTS Manual. https://docs.unity3d.com/6000.3/Documentation/Manual/xr-configure-providers.html. Retrieved 2026-09-17.
  41. ↑ 41.0 41.1 41.2 41.3 "Develop Unity apps for Meta Quest VR headsets". Meta Horizon OS Developers. https://developers.meta.com/horizon/documentation/unity/unity-development-overview/. Retrieved 2026-09-17.
  42. ↑ 42.0 42.1 "VR is Expanding. Start Building for Meta VR Glasses Today.". Meta Horizon OS Developers. 2026-09-24. https://developers.meta.com/vr/blog/meta-connect-recap-start-building-the-future-of-vr/. Retrieved 2026-10-17.
  43. ↑ 43.0 43.1 43.2 "Interaction overview". Unity XR Interaction Toolkit 3.3 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/architecture.html. Retrieved 2026-09-17.
  44. ↑ "Locomotion". Unity XR Interaction Toolkit 3.3 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/locomotion.html. Retrieved 2026-09-17.
  45. ↑ "UI setup". Unity XR Interaction Toolkit 3.3 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/ui-setup.html. Retrieved 2026-09-17.
  46. ↑ "Nanite and Lumen for XR". Unreal Engine Documentation. https://dev.epicgames.com/documentation/unreal-engine/nanite-and-lumen-for-xr-in-unreal-engine. Retrieved 2026-09-17.
  47. ↑ "Setting up XR". Godot Engine 4.7 Documentation. https://docs.godotengine.org/en/4.7/tutorials/xr/setting_up_xr.html. Retrieved 2026-10-17.
  48. ↑ "How to load and run games on Steam Frame". Steamworks Documentation. Valve. https://partner.steamgames.com/doc/steamhardware/steamframe/loadgames. Retrieved 2026-10-17.
  49. ↑ "Unity". Steamworks Documentation. Valve. https://partner.steamgames.com/doc/steamhardware/steamframe/engines/unity. Retrieved 2026-10-17.
  50. ↑ "Unreal Engine". Steamworks Documentation. Valve. https://partner.steamgames.com/doc/steamhardware/steamframe/engines/unreal. Retrieved 2026-10-17.
  51. ↑ 51.0 51.1 "Get Started with visionOS". Apple Developer. https://developer.apple.com/visionos/get-started/. Retrieved 2026-09-17.
  52. ↑ "Upcoming Requirements". Apple Developer. https://developer.apple.com/news/upcoming-requirements/. Retrieved 2026-10-17.
  53. ↑ "Releases". Apple Developer. https://developer.apple.com/news/releases/. Retrieved 2026-10-17.
  54. ↑ "PICO Developer: Use AI to develop spatial apps". PICO Developer. Pico Technology. https://developer.picoxr.com/pico-os-6/. Retrieved 2026-10-17.
  55. ↑ 55.0 55.1 "Set up Direct Preview for Unity". Android Developers. https://developer.android.com/develop/xr/unity/direct-preview. Retrieved 2026-09-17.
  56. ↑ Stevan Silva and Amy Zeppenfeld (2026-05-19). "Android XR SDK Developer Preview 4 updates". Android Developers Blog. https://android-developers.googleblog.com/2026/05/android-xr-sdk-developer-preview-4-updates.html. Retrieved 2026-10-17.
  57. ↑ "XR SceneCore". Android Developers. https://developer.android.com/jetpack/androidx/releases/xr-scenecore. Retrieved 2026-10-17.
  58. ↑ "Verifying Device Support and User Permission". Apple Developer Documentation. https://developer.apple.com/documentation/ARKit/verifying-device-support-and-user-permission. Retrieved 2026-09-17.
  59. ↑ "Immersive Web SDK 1.0: Build for Quest and Meta VR Glasses with AI-Native Web Tools". Meta Horizon OS Developers. 2026-10-14. https://developers.meta.com/vr/blog/immersive-web-sdk-1-0/. Retrieved 2026-10-17.
  60. ↑ "Spectacles Docs". Snap for Developers. Snap Inc.. https://developers.snap.com/spectacles/home. Retrieved 2026-10-17.
  61. ↑ "Snap Launches New Tools for SPECS Developers". Snap Newsroom. Snap Inc.. 2026-06-16. https://newsroom.snap.com/snap-launches-new-tools-for-specs-developers. Retrieved 2026-10-17.
  62. ↑ "Introducing the Meta Wearables Device Access Toolkit". Meta for Developers. 2025-09-18. https://developers.meta.com/blog/introducing-meta-wearables-device-access-toolkit/. Retrieved 2026-10-17.
  63. ↑ "Build for AI glasses from Meta". Meta for Developers. https://developers.meta.com/wearables/. Retrieved 2026-10-17.
  64. ↑ "Locomotion user preferences". Meta Horizon OS Developers. 2026-09-08. https://developers.meta.com/horizon/design/locomotion-user-preferences/. Retrieved 2026-09-17.
  65. ↑ "Locomotion comfort and usability". Meta Horizon OS Developers. https://developers.meta.com/horizon/design/locomotion-comfort-usability/. Retrieved 2026-09-17.
  66. ↑ Ajoy S. Fernandes and Steven K. Feiner (2016). "Combating VR Sickness through Subtle Dynamic Field-Of-View Modification". 2016 IEEE Symposium on 3D User Interfaces (3DUI), pp. 201-210. https://doi.org/10.1109/3DUI.2016.7460053. Retrieved 2026-10-17.
  67. ↑ "Tunneling Vignette Controller". Unity XR Interaction Toolkit 3.6.1 Documentation. https://docs.unity3d.com/Packages/[email protected]/manual/tunneling-vignette-controller.html. Retrieved 2026-10-17.
  68. ↑ Rachel L. Franz, Jinghan Yu and Jacob O. Wobbrock (2023). "Comparing Locomotion Techniques in Virtual Reality for People with Upper-Body Motor Impairments". ASSETS 2023. https://faculty.washington.edu/wobbrock/pubs/assets-23.02.pdf. Retrieved 2026-09-17.
  69. ↑ "Accessibility". Apple Human Interface Guidelines. https://developer.apple.com/design/human-interface-guidelines/accessibility. Retrieved 2026-09-17.
  70. ↑ 70.0 70.1 "Performance optimization". Meta Horizon OS Developers. 2026-05-11. https://developers.meta.com/horizon/resources/publish-overview-performance/. Retrieved 2026-09-17.
  71. ↑ "Unity Profiler". Meta Horizon OS Developers. https://developers.meta.com/horizon/documentation/unity/unity-profiler-tool/. Retrieved 2026-09-17.
  72. ↑ "Introducing Meta XR Operator: Close the Build-Test-Verify Loop for VR". Meta Horizon OS Developers. 2026-08-18. https://developers.meta.com/vr/blog/meta-xr-operator-close-the-build-test-verify-loop-for-vr/. Retrieved 2026-10-17.
  73. ↑ 73.0 73.1 "Submit your apps to the App Store for Apple Vision Pro". Apple Developer. https://developer.apple.com/visionos/submit/. Retrieved 2026-09-17.
  74. ↑ "Exploring object tracking with ARKit". Apple Developer Documentation. https://developer.apple.com/documentation/visionOS/exploring_object_tracking_with_arkit. Retrieved 2026-09-17.
  75. ↑ 75.0 75.1 "Unity Performance Settings sample". Meta Horizon OS Developers. 2026-08-11. https://developers.meta.com/horizon/documentation/unity/unity-sample-performance-settings/. Retrieved 2026-09-17.
  76. ↑ "Enhance your Android XR app with AI using Gemini API". Android Developers. 2026-09-22. https://developer.android.com/develop/xr/gemini. Retrieved 2026-10-16.
  77. ↑ "AI model comparison finder". AI Wiki. https://aiwiki.ai/tools/compare_models. Retrieved 2026-10-16.
  78. ↑ "AI API cost and context planner". AI Wiki. https://aiwiki.ai/tools/ai_cost_calculator. Retrieved 2026-10-16.
  79. ↑ "LLM VRAM and RAM calculator". AI Wiki. https://aiwiki.ai/tools/llm_vram_calculator. Retrieved 2026-10-16.
  80. ↑ "Get Your App Ready for the Meta Horizon Store". Meta Horizon OS Developers. 2024-07-05. https://developers.meta.com/horizon/blog/get-apps-ready-app-lab-meta-horizon-store-meta-quest-developers/. Retrieved 2026-09-17.
  81. ↑ "Submitting your app". Meta Horizon OS Developers. https://developers.meta.com/horizon/resources/publish-submit/. Retrieved 2026-09-17.
  82. ↑ "Get SideQuest". SideQuest. https://sidequestvr.com/setup-howto. Retrieved 2026-09-17.
  83. ↑ 83.0 83.1 "Fab Digital Marketplace". Fab. https://www.fab.com/o/about. Retrieved 2026-09-17.
  84. ↑ "Unity Asset Store". Unity. https://assetstore.unity.com/. Retrieved 2026-09-17.
  85. ↑ "CGTrader 3D Models and 3D Printing Marketplace". CGTrader. https://www.cgtrader.com/. Retrieved 2026-09-17.
  86. ↑ "Free and Premium 3D Models for Download". TurboSquid. https://www.turbosquid.com/. Retrieved 2026-09-17.
  87. ↑ "About / Contact". Poly Haven. https://polyhaven.com/about-contact. Retrieved 2026-09-17.
  88. ↑ "Revive Compatibility Layer". LibreVR on GitHub. https://github.com/LibreVR/Revive. Retrieved 2026-09-17.
Retrieved from "https://vrarwiki.com/index.php?title=Developer_Resource&oldid=52483"
Contents