Developer Resource

Overview

This article provides comprehensive information about resources for VR and AR development as of 2025, including SDKs, game engines, runtimes, app stores, and development tools for modern virtual reality and augmented reality platforms. The XR development landscape has evolved significantly, with OpenXR emerging as the industry-standard cross-platform API, supported by all major hardware manufacturers and game engines.

The XR Development Landscape

Extended Reality (XR) encompasses Virtual Reality (VR), Augmented Reality (AR), and Mixed Reality (MR), representing a paradigm shift in how users interact with digital content. For developers, this landscape is defined by a rich ecosystem of game engines, Software Development Kits (SDKs), and cross-platform standards designed to build immersive experiences.

At the heart of modern XR development are powerful game engines, primarily Unity and Unreal Engine, which provide the rendering, physics, and scripting environments necessary to create interactive 3D worlds. These engines are complemented by platform-specific SDKs that unlock the unique hardware features of devices like the Meta Quest.

Underpinning this entire ecosystem is the OpenXR standard, a crucial initiative by the Khronos Group to create a unified API that allows developers to write code that can run across multiple hardware platforms with minimal modification, thereby reducing fragmentation and simplifying the development process.

How to Get Started

See also: How to Get Started in VR Development

Getting started with XR development in 2025 requires choosing a target platform and appropriate development tools. Modern VR development primarily uses OpenXR as a cross-platform standard, with platform-specific SDKs providing additional features.

Beginner Path

For beginners, the recommended path is to:

1. Choose a game engine (Unity, Unreal Engine, or Godot)
2. Select target VR headsets (e.g., Meta Quest 3, Meta Quest 3S, Apple Vision Pro, PSVR2)
3. Set up the appropriate SDK and development environment
4. Study platform-specific guidelines and best practices
5. Build a simple app and iterate

Development Environment Setup

1. Select a Development Environment: Use integrated development environments (IDEs) like Unity or Unreal Engine, which support XR out of the box. Download the latest versions: Unity 6.x or Unreal Engine 5.4+.

2. Install SDKs: For Meta devices, use the Meta XR SDK. For Apple, the visionOS SDK. Adopt OpenXR for cross-platform compatibility.

3. Set Up Hardware: Ensure your development PC meets requirements (e.g., high-end GPU for tethered VR). For standalone devices, develop directly on the headset or use simulators like Meta XR Simulator.

4. Learn Basics: Study motion tracking, anchors, environmental understanding, and depth APIs. Resources include official documentation from Meta, Apple, and Khronos Group.

5. Test and Iterate: Use tools like Meta XR Simulator for testing without hardware. Optimize for performance, considering battery life and refresh rates.

Essential Concepts

- Understand 6DOF (six degrees of freedom) motion detection for immersive experiences - Focus on user comfort to avoid motion sickness, using techniques like asynchronous timewarp or reprojection - Integrate haptics and controllers for better interaction - For AR, leverage location anchors and scene semantics for real-world integration

Modern SDKs and Development Kits

SDKs or Software Development Kits are essential tools for building VR apps and AR apps. As of 2025, the XR development landscape has evolved significantly from the early Oculus Rift and HTC Vive era.

OpenXR

OpenXR is an open, royalty-free standard developed by the Khronos Group that provides a unified API for VR and AR platforms. OpenXR eliminates the need for multiple proprietary APIs, allowing developers to create applications that work across different VR headsets and AR devices.

As of 2025, Meta recommends OpenXR as the primary development path starting with SDK version 74. OpenXR support is built into major game engines and provides cross-platform compatibility.

Core Architecture and Concepts

The OpenXR API provides a set of abstractions for developers to interact with the XR system:

• XrInstance: Represents the connection between the application and the OpenXR runtime. It is the first object created.
• XrSystem: Represents the set of XR devices, including the headset and controllers.
• XrSession: Manages the interaction session between the application and the user. It controls the application's lifecycle, such as when it should render frames.
• XrSpace: Defines a 3D coordinate system. This is used to track the position and orientation of the headset, controllers, and other tracked objects.
• XrActions: Provides a high-level, action-based input system. Instead of querying for "button A press," a developer defines an action like "Jump" or "Grab" and maps it to different physical inputs on various controllers.

Key OpenXR Features

• Cross-platform VR and AR development
• Support for multiple VR headsets from different vendors
• Standardized input handling and tracking
• Hand tracking, eye tracking, and spatial anchors
• Passthrough and mixed reality capabilities

Industry Adoption

OpenXR has achieved widespread industry adoption. All major hardware and software platforms provide conformant OpenXR runtimes, including:

• Meta (for Quest and Rift devices)
• Valve (SteamVR)
• Microsoft (for Windows Mixed Reality and HoloLens 2)
• HTC (for Vive headsets)
• Pico (for Pico headsets)

OpenXR vs. OpenVR

A common point of confusion is the distinction between OpenXR and OpenVR:

• OpenVR is an older API developed by Valve. It was the primary API for the SteamVR platform and was "open" in the sense that other hardware could create drivers to be compatible with it. However, its development was ultimately controlled by Valve.
• OpenXR is the modern, multi-company standard managed by the Khronos Group. It is the successor to proprietary APIs like OpenVR and the old Oculus SDK.

Today, the SteamVR platform itself is an OpenXR runtime. This means it can run applications built with the OpenXR API, while also maintaining backward compatibility with older applications built with the OpenVR API.

Cross-Platform Considerations

While OpenXR has successfully standardized the foundational layer of XR development, its "write once, run anywhere" promise is not absolute. For standalone Android-based headsets, developers often still need to create separate application packages (APKs) for different platforms like Meta Quest and Pico, as these platforms may use their own vendor-specific OpenXR loaders.

Furthermore, innovative platform-specific features—such as Meta's advanced Passthrough capabilities, hand tracking enhancements, or spatial anchors—are exposed to developers through vendor-specific extensions to the OpenXR standard. To leverage these powerful features, a developer must write code that specifically targets that vendor's hardware.

Meta Quest SDK

The Meta Quest SDK (formerly Oculus SDK) supports Meta Quest 2, Meta Quest 3, Meta Quest 3S, and Meta Quest Pro headsets. As of March 2025, Meta transitioned to recommending OpenXR as the primary development approach, while still providing the Meta XR Core SDK for Horizon OS-specific features.

Supported Platforms

• Meta Quest 2
• Meta Quest 3
• Meta Quest 3S
• Meta Quest Pro

Key Features

• Native OpenXR integration
• Hand tracking via OpenXR hand skeleton (as of SDK version 78)
• Passthrough API for mixed reality
• Spatial anchors and scene understanding
• Haptic feedback and controller support
• Meta XR Simulator for desktop testing

Apple Vision Pro SDK (visionOS)

The visionOS SDK enables development for Apple Vision Pro, Apple's spatial computing platform launched in February 2024.

Development Tools

• Xcode 15.2 or later with visionOS SDK
• SwiftUI for UI development
• RealityKit for 3D rendering
• ARKit for spatial awareness
• Reality Composer Pro for 3D content creation
• Unity support (Apple Silicon Mac required)

Key Features

• Eye tracking and hand tracking as primary inputs
• Spatial audio with head tracking
• Passthrough and mixed reality
• Foveated rendering (Dynamically Foveated Rendering)
• Mac Virtual Display integration
• WebXR support in Safari

Requirements

• Mac with Apple Silicon (M1 or later)
• macOS Monterey or later
• Xcode 15.2 or later
• For Unity: Unity 2022 LTS (2022.3.191 or newer), Apple Silicon version only

PlayStation VR2 SDK

PSVR2 development uses the same SDK as PlayStation 5, making porting between platforms more straightforward.

Supported Features

• Unity and Unreal Engine support
• Hand tracking (added in 2024 SDK update)
• Eye tracking
• HDR OLED displays
• Haptic feedback via Sense controllers
• Foveated rendering
• PC VR support via PSVR2 PC adapter (launched August 2024)

Pico SDK

Pico SDK, developed by ByteDance's Pico division, supports the Pico 4, Pico 4 Pro, and Pico 4 Ultra headsets available in Europe and Asia.

Supported Platforms

• Pico 4
• Pico 4 Pro
• Pico 4 Ultra (launched 2024)

Key Features

• 6DoF head and hand tracking
• Mixed reality capabilities
• Body tracking
• Face tracking
• Eye tracking
• Spatial anchors
• Unity and Unreal Engine support
• OpenXR compatibility

AR-Specific SDKs

ARKit

ARKit is Apple's framework for iOS AR, current version 6. Features include:

• 4K video capture
• Depth API with LiDAR
• Motion capture
• Scene geometry
• People occlusion

ARCore

ARCore is Google's SDK for Android AR. Supports:

• Motion tracking
• Anchors
• Environmental understanding
• Depth API
• Geospatial API
• Scene semantics

Game Engines

Choosing a Game Engine: Unity vs. Unreal

The choice of a game engine is one of the most fundamental decisions in XR development. Unity and Unreal Engine are the two dominant forces in the industry, each with a distinct set of strengths, weaknesses, and development philosophies.

Unity

Unity remains one of the most popular engines for VR development. As of 2025, Unity provides native OpenXR support through the XR Interaction Toolkit.

Core Strengths

Unity's core is built around the C# programming language, which is widely regarded as having a more gentle learning curve compared to C++. This accessibility, combined with a user-friendly interface, makes it an attractive option for developers of all experience levels, from indie creators to large studios.

Current Version

Unity 6 (2025)

Asset Ecosystem

A significant accelerator for Unity development is the Unity Asset Store. It offers a vast library of pre-built tools, 3D models, scripts, and plugins that can dramatically reduce development time and cost. This rich ecosystem allows teams to prototype rapidly and bring products to market faster.

VR Features

• XR Interaction Toolkit (current version 3.1.2)
• OpenXR Plugin with native support (version 1.14 achieves feature parity with legacy Oculus XR Plugin)
• AR Foundation for AR development
• Native support for Meta Quest, PSVR2, and other VR platforms
• Meta Quest Link for rapid iteration

Key Packages

Package	Purpose	Current Version
XR Interaction Toolkit	High-level interaction system	3.1.2
OpenXR Plugin	OpenXR runtime support	1.14+
XR Plugin Management	XR backend management	Latest
AR Foundation	AR development framework	Latest
Meta XR SDK	Meta Quest-specific features	Latest

Unreal Engine

Unreal Engine 5 provides robust VR development capabilities with built-in OpenXR support. As of 2025, Unreal Engine 5.6 is the current major version.

Core Strengths

Unreal Engine's primary advantage is its advanced rendering engine, which delivers exceptional visual quality with minimal setup. Features like Lumen for dynamic global illumination and Nanite for virtualized micropolygon geometry enable developers to create incredibly realistic and detailed worlds, making it a powerhouse for PCVR and high-end simulations.

Current Versions

• Unreal Engine 5.6 (June 2025)
• Unreal Engine 5.5 (December 2024)
• Unreal Engine 5.7 Preview (September 2025)

Scripting Model

Unreal Engine employs a dual-language development model. For maximum performance and low-level system control, developers use C++. Complementing this is the Blueprints system, a powerful node-based interface that allows designers, artists, and programmers to build complex game logic without writing traditional code.

VR Features

• Built-in OpenXR support
• Nanite virtualized geometry system
• Lumen global illumination
• Virtual Scouting toolset with OpenXR-compatible HMDs
• MetaHuman creation tools
• Mobile Forward Renderer improvements for PC VR
• XR dynamic resolution support

VR Development Tools

• Virtual Scouting with VR Content Browser
• OpenXR native integration
• SteamVR support
• Meta fork of Unreal Engine for Horizon OS-specific features

Godot

Godot Engine has significantly improved XR support with native OpenXR integration in Godot 4. Meta has sponsored improvements to Godot's OpenXR support.

Current Version

Godot 4.3 (2025)

XR Features

• Built-in OpenXR support (no plugin required for Godot 4)
• Godot XR Tools addon (version 4.4.0)
• Meta XR Simulator integration
• WebXR support for browser-based VR
• Godot Meta Toolkit (version 1.0.2) for Meta Platform SDK
• OpenXR Vendors plugin for platform-specific features

Supported Platforms

• Meta Quest via OpenXR
• SteamVR
• PSVR2
• WebXR (browser-based VR)

Comparative Analysis

Unity vs. Unreal Engine for XR Development

Feature	Unity	Unreal Engine
Primary Scripting	C#	C++
Visual Scripting	Bolt (Visual Scripting package)	Blueprints (deeply integrated)
Learning Curve	More gentle, user-friendly interface	Steeper, especially for its custom C++ framework
Graphical Fidelity (Out-of-the-box)	Good, but often requires configuration to achieve high-end results	Excellent, industry-leading visuals with Lumen and Nanite
Asset Ecosystem	Extensive (Unity Asset Store), major strength for rapid development	Growing, but smaller than Unity's
Community Size	Larger, more beginner-friendly resources	Smaller but strong, particularly for high-end development
Primary Target Platform (XR)	Strongest in standalone and mobile VR (e.g., Meta Quest)	Strongest in PCVR and high-fidelity simulations
Ideal Use Cases	Indie games, mobile/standalone VR/AR, rapid prototyping, projects prioritizing speed-to-market	AAA games, architectural visualization, cinematic experiences, enterprise simulations requiring photorealism

Developing with Unity

Setting up a Unity project for XR development involves a series of specific configuration steps to enable communication with XR hardware and import the necessary SDKs.

Project Setup for XR

Prerequisites

Before creating a project, developers must use the Unity Hub to install a supported version of the Unity Editor (e.g., 2022.3 LTS or newer). During installation, it is crucial to include the Android Build Support module, as this is a requirement for developing applications for Android-based standalone headsets like the Meta Quest.

Creating a Project and Configuring the Build Platform

A new project should be created using the 3D (URP) template. The Universal Render Pipeline provides a modern, performant rendering foundation suitable for the majority of XR applications. Once the project is created, the first step is to set the target build platform. This is done by navigating to `File > Build Settings`. For Meta Quest development, select Meta Quest (in Unity 6.1 and later) or Android (in older versions) and click the "Switch Platform" button.

XR Plug-in Management

Unity communicates with XR runtimes through its XR Plugin Management system. This package must be installed from the Package Manager if it is not already present.

1. Navigate to `Edit > Project Settings`.
2. Select the `XR Plug-in Management` tab.
3. In both the Standalone (PC icon) and Android tabs, check the box for OpenXR. This tells Unity to use the OpenXR API to interface with the headset's runtime.

This step is critical as it enables the core connection between the engine and the XR hardware.

The Meta XR SDK for Unity

For developers targeting Meta Quest devices, the Meta XR SDK is essential. It provides access to the full suite of the platform's features.

Installation and Core Components

The primary package is the Meta XR Core SDK, which is installed from the Unity Package Manager via the `Window > Package Manager` interface. This SDK includes several key components:

• OVRCameraRig: A pre-configured camera prefab that serves as the XR rig. It replaces the standard Unity camera and automatically handles head and controller tracking, mapping the user's physical movements into the virtual scene.
• OVRInput: A robust API for handling input from the Touch controllers and hand tracking.
• Project Setup Tool: A utility that analyzes the project for common configuration errors and provides one-click fixes to apply recommended settings.

Project Setup Tool

After importing the Core SDK, developers should immediately run the Project Setup Tool by navigating to `Meta XR > Tools > Project Setup Tool`. This tool checks for dozens of required settings related to graphics, physics, and build configurations. Clicking the Fix All and Apply All buttons will automatically configure the project according to Meta's best practices.

Other Meta SDKs

The Meta ecosystem is composed of several specialized SDKs that build upon the Core SDK:

• Meta XR Interaction SDK: A high-level framework for creating natural and robust interactions like grabbing, poking, and interacting with UI using both controllers and hands.
• Meta XR Audio SDK: Provides advanced spatial audio features, including HRTF-based spatialization and room acoustics simulation.
• Meta XR Platform SDK: Enables integration with Meta's platform services, such as leaderboards, achievements, user profiles, and multiplayer matchmaking.

The Meta XR All-in-One SDK is available on the Asset Store as a convenient package to manage these various SDKs.

Unity's XR Interaction Toolkit (XRI)

The XR Interaction Toolkit (XRI) is Unity's own high-level, component-based framework for building XR interactions. It is designed to be flexible and extensible, providing a solid foundation for VR and AR projects.

Core Concepts

XRI's architecture is built around a few key concepts:

• Interaction Manager: A singleton component that acts as the central hub, mediating all interactions between Interactors and Interactables in a scene.
• Interactors: These are components that initiate actions. They represent the user's hands or controllers. Common types include:
  • `XR Ray Interactor`: For pointing at and selecting objects from a distance.
  • `XR Direct Interactor`: For directly touching and grabbing objects that are within arm's reach.
  • `XR Socket Interactor`: A static interactor that objects can be snapped into, useful for puzzles or placing items in specific locations.
• Interactables: These are components placed on objects in the scene that can be acted upon by Interactors. The most common is the `XR Grab Interactable`, which allows an object to be picked up, held, and thrown.

Locomotion and UI

XRI includes a complete locomotion system that can be added to the XR Origin (the main camera rig). This includes a Teleportation Provider for point-and-click movement and a Continuous Move Provider for smooth, joystick-based locomotion. It also provides tools for interacting with world-space UI canvases, using components like the `Tracked Device Graphic Raycaster` to allow ray interactors to click on buttons and other UI elements.

Developing with Unreal Engine

Unreal Engine offers a powerful, high-fidelity platform for XR development, with a streamlined setup process centered around its VR Template and OpenXR integration.

Project Setup for XR

Prerequisites

Developers must first install Unreal Engine via the Epic Games Launcher. For development targeting standalone Android headsets like the Meta Quest, it is also necessary to install and configure Android Studio and the required Android SDK and NDK components.

Creating a Project and Plugin Configuration

The recommended way to start a new XR project is by using the built-in Virtual Reality template. This can be selected from the "Games" category in the Unreal Project Browser when creating a new project. This template provides a pre-configured project with essential plugins enabled, a basic level, and a functional player pawn with locomotion and interaction systems.

After creation, developers should verify that the necessary plugins are enabled by navigating to `Edit > Plugins`. The most important plugin is OpenXR. Platform-specific plugins like OculusVR (for Meta devices) or SteamVR should also be enabled depending on the target hardware.

The Meta XR Plugin for Unreal

The Meta XR Plugin (often referred to as the OculusVR plugin) is the key to unlocking the full feature set of Meta Quest devices in Unreal Engine. It provides access to platform-specific functionalities not covered by the core OpenXR standard. This includes:

• Advanced tracking features like Hand Tracking, Body Tracking, and Face/Eye Tracking
• Mixed Reality features such as Passthrough, Spatial Anchors, and Scene understanding
• Performance optimization tools like Application SpaceWarp and Fixed Foveated Rendering
• Platform services integration for leaderboards, achievements, and parties
• The Movement SDK for more realistic avatar motion and the Voice SDK for voice commands and dictation

Leveraging the VR Template

The standard VR Template is a powerful starting point that encapsulates logic for many common VR features.

Core Components

The template is built around a few key assets:

• VRPawn: This Blueprint is the user's representation in the virtual world. It contains the camera component, motion controller components for tracking the hands, and all the logic for handling input and movement.
• VRGameMode: This object defines the rules for the level, most importantly specifying that the `VRPawn` should be the default pawn class for the player.

Locomotion Systems

The template includes two primary, comfort-oriented locomotion methods:

• Teleportation: The user can aim with one controller, which displays an arc and a target location. Releasing the thumbstick instantly moves the pawn to that location. This system relies on a Nav Mesh Bounds Volume placed in the level.
• Snap Turn: Using the other controller's thumbstick, the user can rotate their view in discrete increments (e.g., 45 degrees). This avoids the smooth rotation that can cause motion sickness for some users.

Runtimes

Runtimes handle core VR functionality including rendering, tracking, and reprojection.

OpenXR Runtime

OpenXR provides a unified runtime layer that works across multiple VR platforms. As of 2025, most major VR headsets support OpenXR runtime.

Supported by:

• Meta Quest Runtime
• SteamVR Runtime
• Windows Mixed Reality
• Pico Runtime
• Monado (open-source runtime for Linux)

SteamVR / OpenVR

SteamVR supports both OpenVR (legacy) and OpenXR runtimes. OpenVR was developed by Valve and has been the default runtime for SteamVR, though OpenXR is increasingly recommended.

Current State (2025)

• SteamVR defaults to OpenVR but supports OpenXR
• Lighthouse tracking system still used for high-precision tracking
• Full body tracking via Vive Trackers
• Support for multiple VR headsets including Valve Index, HTC Vive, and others

Features

• Reprojection for smooth frame rates
• Room-scale VR setup
• Controller and tracker support
• Overlay system for UI

Meta Quest Runtime

The Meta Quest Runtime handles VR rendering and tracking for Meta Quest devices, now with integrated OpenXR support.

Features

• Application SpaceWarp (ASW) - Meta's reprojection technology
• Asynchronous SpaceWarp for maintaining frame rate
• Guardian boundary system
• Native hand tracking
• Passthrough API

Essential Best Practices for XR Development

Beyond the specifics of any single engine, creating a successful XR application requires adherence to a set of universal principles focused on user comfort, intuitive interaction, and technical performance.

User Experience and Comfort

The primary goal of XR design is to create a sense of presence and immersion. This can be easily broken by experiences that are uncomfortable or unintuitive.

Locomotion Design

Movement in VR is the single greatest challenge for user comfort. The sensory conflict between seeing motion in the headset while the body's vestibular system reports being stationary can lead to Visually induced motion sickness (VIMS), also known as VR sickness.

Comfort-First Techniques

• Teleportation: This method instantly moves the user from one point to another, completely avoiding the continuous visual flow that causes motion sickness. It is consistently the most comfortable and widely preferred option.
• Snap Turns: Replace smooth, continuous rotation with discrete, instantaneous jumps in orientation. This is significantly more comfortable for many users than smooth turning.

Continuous Locomotion and Comfort Options

While more immersive for some, smooth joystick-based movement is the most likely to cause discomfort. If offered, it should always be an option, not a requirement, and should be accompanied by comfort settings. A common technique is vignetting (also called tunneling), which narrows the user's field of view during movement, reducing peripheral optic flow.

Environmental Design

The design of the virtual world itself can impact comfort. Developers should:

• Avoid forcing movement on steep slopes or stairs
• Keep walls and large objects at a comfortable distance to reduce optic flow
• Consider using an Independent Visual Background (IVB), such as a static skybox that only moves with head rotation

Interaction Design

Intuitive interaction is key to maintaining presence. The choice of input modality has a significant impact on the user experience.

Controllers vs. Hand Tracking

• Controllers offer high precision, tactile feedback through buttons and triggers, and haptic feedback, making them ideal for gaming, creative tools, and any application requiring reliable and precise input.
• Hand tracking uses the headset's cameras to track the user's bare hands, offering a highly natural and intuitive interaction method. However, its performance can be affected by poor lighting, fast movements, and occlusion. It is generally less precise than controllers and is best suited for more casual experiences.

Multimodal Input

The best practice is often to support multiple input modalities. Allowing a user to seamlessly switch between controllers, hands, and even voice commands provides maximum accessibility.

UI/UX in 3D Space

Designing User Interfaces (UI) for a 3D, immersive space presents unique challenges.

Placement and Comfort

UI panels should be placed at a comfortable viewing distance, typically around 1-2 meters from the user, and positioned slightly below their natural line of sight to avoid neck strain.

World-Locking vs. Head-Locking

A critical rule is to avoid locking UI elements directly to the user's head (a "head-locked" HUD). This is extremely uncomfortable and can cause motion sickness. Instead, UI should be "world-locked" (anchored to a position in the environment) or, if it must follow the user, it should do so with a gentle, smoothed animation.

Feedback

Clear and immediate feedback is essential. Interactive elements should have distinct hover states (e.g., highlighting or scaling up), and actions like button presses should be accompanied by both visual and auditory cues.

Technical Performance and Optimization

Maintaining a consistently high and stable frame rate is the most important technical requirement for a comfortable VR experience.

Understanding VR Performance Metrics

• Framerate vs. Frame Time: Framerate, measured in Frames Per Second (FPS), is the average number of frames rendered over a second. Frame Time, measured in milliseconds (ms), is the time it takes to render a single frame. Frame time is a more accurate indicator of performance smoothness.
• Performance Targets: For standalone headsets like the Meta Quest series, applications must achieve a minimum of 72 FPS. For PCVR, the target is typically 90 FPS or higher.

Profiling and Debugging

The first step in optimization is identifying the bottleneck. Performance issues are typically either CPU-bound (caused by complex game logic, physics, or too many draw calls) or GPU-bound (caused by high resolution, complex shaders, or too much geometry).

Essential profiling tools include:

• Engine Profilers: Unity Profiler and Unreal Insights are powerful, built-in tools for analyzing CPU and GPU usage.
• Platform Tools: Meta Quest Developer Hub (MQDH) provides real-time performance metrics and analysis tools for Quest development.
• Graphics Debuggers: Tools like RenderDoc allow for in-depth analysis of every command sent to the GPU.

Core Optimization Strategies

• Reduce Draw Calls: Combine multiple textures into a single texture atlas and use static batching to draw multiple similar objects in a single call. For standalone Quest, developers should aim for 50-200 draw calls per frame.
• Optimize Geometry: Keep polygon counts within the budget for the target platform (e.g., 750k-1M triangles for Quest 2). Use Level of Detail (LOD) systems.
• Simplify Lighting and Shaders: Use baked lighting whenever possible. Avoid complex, multi-pass shaders and full-screen post-processing effects on mobile hardware.
• Use Occlusion Culling: This prevents the engine from rendering objects that are completely hidden from the camera's view.

Understanding Reprojection Technologies

When an application fails to render a new frame in time for the headset's display refresh, VR platforms employ asynchronous reprojection techniques. These systems act as a safety net, but they are not a substitute for good performance.

Key Reprojection Technologies Explained

Technology	Developer	Mechanism	Corrects For	Common Artifacts
Asynchronous Timewarp (ATW)	Meta	Takes the last successfully rendered frame and re-projects it based on the newest head rotation data.	Head Rotation only. Does not account for positional movement or in-scene animation.	Positional judder, animation judder.
Asynchronous SpaceWarp (ASW)	Meta	When an app's framerate drops to half the display's refresh rate, ASW analyzes the motion between two previous frames to synthesize and insert a new, predicted frame.	Head rotation, head position, controller movement, and in-scene animation.	Warping, ghosting, or "bubbling" artifacts, especially around fast-moving objects.
Motion Smoothing	Valve	Similar to ASW, it activates when an application cannot maintain framerate. It looks at the last two frames to estimate motion and extrapolates a new frame.	Head rotation, head position, controller movement, and in-scene animation.	Similar to ASW, it can produce visual artifacts like warping or wobbling.

App Stores and Distribution

Meta Quest Store

The Meta Quest Store (formerly Oculus Store) is the primary distribution platform for Meta Quest applications on Horizon OS.

Supported Devices

• Meta Quest 2
• Meta Quest 3
• Meta Quest 3S
• Meta Quest Pro

Distribution Methods

• Official Meta Quest Store - Highly curated marketplace requiring stringent technical and content guidelines. Reserved for polished, high-quality experiences.
• App Lab - Alternative distribution path allowing developers to publish without full store curation. Apps are not browsable in the main store and can only be accessed via direct URL. Ideal for early access builds, experimental applications, and apps still in development.
• SideQuest - Third-party platform for sideloading applications

The submission process involves creating an app page, uploading builds (often using the Meta Quest Developer Hub desktop tool), providing store assets and metadata, and undergoing technical review.

Steam / SteamVR

For PC-based VR, SteamVR is the dominant platform. It is known for its broad hardware compatibility, supporting not only Valve's own Index headset but also devices from HTC, Meta (via Link or Air Link), Windows Mixed Reality, and others.

Supported Headsets

• Valve Index
• HTC Vive series
• Meta Quest (via Meta Quest Link or Air Link)
• Windows Mixed Reality headsets
• Pico headsets (via SteamVR)

Publishing on Steam is handled through Steamworks, Valve's suite of tools and services for developers. The barrier to entry is lower than the curated Meta Quest Store. The recent release of the official Steam Link app on the Meta Quest Store has further solidified Steam's role as a central hub for PCVR.

PlayStation Store (PSVR2)

PSVR2 games are distributed through the PlayStation Store for PlayStation 5.

Notable Features

• Integrated with PS5 library
• Support for PSVR2-exclusive titles
• Cross-buy support for some titles

Apple Vision Pro App Store

Vision Pro applications are distributed through a dedicated section of the App Store for visionOS.

App Types

• Native visionOS apps
• Compatible iOS/iPadOS apps
• Unity-based VR experiences
• WebXR experiences via Safari

Pico Store

The Pico Store distributes content for Pico headsets in Europe and Asia markets. Pico offers a PICO Developer Program which provides qualifying developers with financial support, technical assistance, and marketing resources.

Alternative Distribution: SideQuest

SideQuest is the leading third-party platform and community for the Meta Quest ecosystem. Its primary function is to facilitate the "sideloading" of applications—the process of installing an app directly onto the headset via a PC, bypassing the official store.

SideQuest has become a vital hub for:

• Early access and experimental games
• Unofficial ports of classic games to VR
• Content that may not meet the curation guidelines of the official store

XR Distribution Platform Overview

Platform	Primary Devices	Curation Level	Target Audience	Key Feature
Meta Quest Store	Meta Quest series	High (Strict VRCs)	Mainstream consumers	Highest visibility and monetization potential for standalone VR
App Lab	Meta Quest series	Low (Basic technical review)	Early adopters, testers, niche communities	Distribute to Quest users via direct link without full store curation
SteamVR	PCVR Headsets (Index, Vive, Quest via Link, etc.)	Low (Self-publishing model)	PC gamers, VR enthusiasts	Broadest hardware compatibility for PCVR; large existing user base
SideQuest	Meta Quest series	Low (Community-driven)	VR enthusiasts, modders, indie game followers	Primary platform for sideloading, experimental content, and early access
Pico Store	Pico headsets (e.g., Pico 4)	High (Similar to Quest Store)	Consumers in markets where Pico is prevalent	Growing ecosystem with developer incentive programs

Development Tools and Resources

XR Interaction Toolkits

Toolkit	Engine	Features	Current Version
XR Interaction Toolkit	Unity	Locomotion, UI interaction, object grabbing	3.1.2
Godot XR Tools	Godot	Teleportation, snap turning, hand interactions	4.4.0
Unreal VR Template	Unreal Engine	Motion controllers, VR preview	Built-in
Meta XR Interaction SDK	Unity	Hand interactions, controller support	Latest
PICO Unity Integration SDK	Unity	Pico-specific features	Latest

SDKs and Plugins

Meta XR SDKs

• Meta XR Core SDK - Core Horizon OS functionality
• Meta XR Interaction SDK - Interaction systems
• Meta XR Simulator - Desktop testing without headset
• Meta XR Building Blocks - Pre-built VR components

Other SDKs

• OpenXR Toolkit - Enhanced OpenXR features
• Godot Meta Toolkit - Meta Platform SDK for Godot
• VRTK (Virtual Reality Toolkit) - Cross-platform VR interactions

Testing and Debugging Tools

• Meta XR Simulator - Test Meta Quest apps on PC/Mac
• visionOS Simulator - Test Vision Pro apps in Xcode
• WebXR Emulator Extension - Browser-based VR testing
• PICO Debugger - Debugging tool for Pico development
• SteamVR VR Preview - In-editor VR preview

3D Models and Asset Marketplaces

Major 3D Asset Marketplaces

Marketplace	Specialty	Notable Features	URL
Fab	Unified content marketplace	Supports Unity, Unreal Engine, UEFN. Successor to Unreal Engine Marketplace and Sketchfab Store. Free Quixel Megascans through 2024. In 2025, 1,500+ Megascans free to all users.	fab.com
CGTrader	General 3D models	Over 2 million 3D models, supports VR/AR content, auction system	cgtrader.com
TurboSquid	Professional 3D models	CheckMate certification, enterprise licensing, owned by Shutterstock	turbosquid.com
Sketchfab	Web-based 3D viewer	Real-time 3D preview, VR/AR optimized, WebGL viewer	sketchfab.com
Unity Asset Store	Unity assets	Engine-specific assets, plugins, templates	assetstore.unity.com
Quixel Megascans	Photorealistic scans	Now part of Fab, 1,500+ free assets in 2025	fab.com
Yobi3D	3D model search engine	Aggregates models from various sites, supports VR/AR	yobi3d.com

Asset Types for VR Development

• 3D Models: Characters, props, environments
• Textures and Materials: PBR materials for realistic rendering
• Audio Assets: Spatial audio, sound effects
• Animations: Rigged characters, mocap data
• VFX: Particle effects, shaders
• Plugins: Engine extensions and tools

Free Asset Resources

• Fab Free Content (monthly rotating selection)
• Quixel Megascans (1,500+ assets free in 2025)
• Unity Asset Store free section
• Sketchfab Creative Commons content
• Free3D community marketplace
• Poly Haven (formerly Poly): Free high-quality PBR assets

Cross-Platform Development

OpenXR for Cross-Platform Development

OpenXR enables developers to create applications that work across multiple VR platforms without requiring separate codebases for each headset.

Supported Platforms via OpenXR

• Meta Quest family
• SteamVR-compatible headsets
• Windows Mixed Reality
• PSVR2 (limited support)
• Pico headsets

Engine Support

• Unity (via OpenXR Plugin 1.14+)
• Unreal Engine (built-in)
• Godot (built-in in Godot 4)

Platform-Specific Considerations

Platform	Input Methods	Unique Features	Distribution
Meta Quest	Controllers, hand tracking	Passthrough MR, spatial anchors, standalone	Meta Quest Store, Steam
Apple Vision Pro	Eye tracking, hand tracking, voice	Mac Virtual Display, spatial video	App Store
PSVR2	Sense controllers, hand tracking	Eye tracking, HDR OLED	PlayStation Store
PCVR (Steam)	Various controllers	High-end graphics, full body tracking	Steam
Pico	Controllers, hand tracking, body tracking	Mixed reality, face tracking	Pico Store

Best Practices and Guidelines

Performance Optimization

• Target 72 FPS minimum (90 FPS for PCVR)
• Use foveated rendering when available
• Implement dynamic resolution scaling
• Optimize draw calls and polygon counts
• Use occlusion culling effectively

User Comfort

• Minimize artificial locomotion sickness
• Provide comfort options (teleportation, snap turning)
• Maintain stable frame rates
• Design UI within comfortable viewing angles
• Test with diverse users

Platform-Specific Guidelines

• Follow Meta Quest Human Interface Guidelines
• Adhere to Apple Vision Pro Design Guidelines
• Meet PlayStation VR2 Technical Requirements
• Consider OpenXR best practices for cross-platform apps

Wrappers and Compatibility Layers

Some community tools exist to help run content across platforms:

• ReVive - An open-source compatibility layer that lets Rift-exclusive games run on Vive or Index by translating Oculus SDK calls to OpenVR/SteamVR. (It does not bypass Oculus entitlement checks; games must still be owned on Oculus Home.)
• OpenXR/Runtime Bridges - Modern runtimes like SteamVR now support OpenXR, reducing the need for hacks.
• Legacy solutions (e.g. LibOVRWrapper) enabled old Rift apps to work with newer runtime DLLs, but these are rarely needed now.

In general, using the official SDK or OpenXR is recommended for compatibility.

Communities and Forums

Developer Communities

• Meta Quest Developer Forum
• Unity XR Forums
• Unreal Engine Forums
• Godot XR GitHub Community
• r/vrdev (Reddit)
• OpenXR Developer Portal

Learning Resources

• Unity Learn XR Courses
• Unreal Engine Learning Portal
• Meta Quest Developer Hub
• Apple Developer Documentation
• Godot XR Documentation
• YouTube channels for VR development

Official Documentation

• Meta Developers: developers.meta.com/horizon
• Apple Vision Pro: developer.apple.com/visionos
• Unity XR: docs.unity3d.com/Manual/XR.html
• Unreal Engine VR: dev.epicgames.com/documentation/en-us/unreal-engine/virtual-reality-development
• Godot XR: docs.godotengine.org/en/stable/tutorials/xr
• OpenXR: khronos.org/openxr
• SteamVR: partner.steamgames.com/doc/features/steamvr
• Pico Developer: developer.picoxr.com

See Also

• How to Get Started in VR Development
• VR Headsets
• AR Development
• Mixed Reality
• Spatial Computing
• WebXR