The Meta XR All-in-One SDK is a single Unity package that bundles Meta’s individual XR SDKs, including the Core, Interaction, Audio, Voice, Platform, Haptics and MR Utility Kit packages, so that developers can build applications for Meta Quest headsets from one installation. In XR development, it serves as the vendor-specific layer that sits on top of the Unity engine and its OpenXR runtime support, exposing Quest features that generic toolkits do not cover.
The package does not add a separate runtime of its own. Instead, it acts as a dependency manifest: installing it pulls in a matched set of component packages at the same version number, which removes the version conflicts that appeared when teams installed each SDK by hand.
How the All-in-One package is structured
The All-in-One SDK is a meta-package, meaning it contains little code itself and mainly declares dependencies on the component SDKs. Unity’s Package Manager resolves those dependencies and installs each component at the same release version, so the Core SDK, Interaction SDK and the other modules always match one another.
The following table lists the principal components that the bundle installs and what each one contributes to a Quest project.
| Component | Primary responsibility | Typical use |
|---|---|---|
| Meta XR Core SDK | Camera rig, tracking, passthrough, project setup | Every Quest project |
| Interaction SDK | Hand and controller interactions, grabbing, poking, ray casting | Object manipulation and user interfaces |
| MR Utility Kit | Access to the scene model, room geometry and anchors | Mixed reality placement |
| Audio SDK | Spatialization, room acoustics, ambisonics | Immersive sound design |
| Voice SDK | Speech recognition and voice commands | Hands-free control |
| Platform SDK | Entitlements, achievements, multiplayer, user identity | Store-published applications |
| Haptics SDK | Designed haptic clips for controllers | Tactile feedback |
Some modules, such as the Movement SDK for body, face and eye tracking, and the Meta XR Simulator, are distributed alongside the bundle or as separate packages depending on the release. Developers should check the package list of the specific version they install rather than assume a fixed composition.
Role of the Core SDK and OpenXR
The Core SDK provides the camera rig prefab, the tracking space configuration and the manager components that control passthrough, display refresh rate and performance levels. It also contains the Project Setup Tool, which scans a Unity project and flags settings that do not suit Quest, such as the wrong graphics API or texture compression format.
Under the hood, current releases communicate with the headset through OpenXR, the Khronos Group standard for XR runtimes. Meta exposes Quest-specific capabilities as OpenXR vendor extensions, and the SDK wraps those extensions in Unity components. Earlier projects relied on the legacy Oculus XR Plugin, while newer versions recommend the Unity OpenXR plugin with the Meta feature group enabled.
This table summarizes how the main backend options differ for a Unity project targeting Quest.
| Backend | Standard basis | Current status |
|---|---|---|
| Oculus XR Plugin | Proprietary Oculus API wrapper | Legacy, kept for older projects |
| Unity OpenXR with Meta features | OpenXR plus Meta vendor extensions | Recommended for new projects |
| Plain Unity OpenXR | Cross-vendor OpenXR only | Portable but lacks many Quest features |
How it compares with related XR toolkits
The All-in-One SDK is one of several ways to build Quest content, and its main distinction is depth of Quest feature coverage versus portability across vendors. Choosing between it and a generic toolkit depends on whether a project targets only Meta hardware or several platforms.
| Option | Scope | Strength | Limitation |
|---|---|---|---|
| Meta XR All-in-One SDK | Unity, Meta Quest | Full access to Quest features | Ties code to Meta hardware |
| Unity XR Interaction Toolkit | Unity, many headsets | Vendor-neutral interaction model | Fewer Quest-specific features |
| Meta Spatial SDK | Native Android, Kotlin | Lightweight mixed reality apps | Not a Unity workflow |
| WebXR | Web browsers | No installation required | Limited performance and APIs |
Many studios combine the Unity XR Interaction Toolkit for portable interactions with selected Meta components for passthrough or scene data. This hybrid approach works, but it requires careful dependency management because both toolkits supply camera rigs and input handling that can conflict.
Setting up and configuring a project
A typical setup starts with installing the bundle from the Unity Asset Store or a scoped registry, switching the build target to Android, and running the Project Setup Tool to apply recommended fixes. The tool usually sets Vulkan as the graphics API, ASTC texture compression, the ARM64 architecture and a minimum Android API level suitable for current Quest firmware.
Developers then add capabilities through Building Blocks, a drag-and-drop system that inserts preconfigured objects such as a camera rig, hand tracking, passthrough or a spatial anchor manager. The following decision table shows which components a project usually needs.
| Project type | Key components | Reason |
|---|---|---|
| Fully immersive game | Core, Interaction, Audio, Platform | Controllers, spatial sound and store features |
| Mixed reality utility | Core, MR Utility Kit, Interaction | Passthrough and room-aware placement |
| Social application | Core, Platform, Voice, Movement | Identity, voice and avatar expression |
| Training simulation | Core, Interaction, Haptics | Precise hand interaction and feedback |
Testing can begin without a headset by using the Meta XR Simulator, which emulates head and controller input on a desktop. Final validation, however, must happen on the physical device, because frame timing, thermal limits and tracking quality cannot be reproduced accurately on a computer.
Limitations and common mistakes
The convenience of a single package comes with larger project size and longer import times, since every component is installed even if unused. Teams that ship lean builds sometimes install only the individual packages they need, accepting the extra work of keeping versions aligned.
- Mixing package versions: upgrading one component without the others causes compile errors and missing types.
- Running two camera rigs: combining the Meta rig with another toolkit’s rig leads to duplicated tracking and broken input.
- Skipping the Project Setup Tool: leaving desktop defaults in place often causes poor performance or rendering errors.
- Assuming portability: code built on Meta vendor extensions will not run unchanged on other OpenXR headsets.
- Ignoring release notes: Meta updates the SDK frequently, and APIs are sometimes deprecated between versions.
Because the SDK evolves quickly, the safest practice is to pin a specific version for the duration of a project milestone and upgrade deliberately, with a separate branch for testing.
The simple explanation
Building an app for a Meta Quest headset requires many separate tools: one for tracking the headset, one for hands and controllers, one for sound, one for the online store and several more. The Meta XR All-in-One SDK puts all of these into one box that installs together.
Think of it as a toolkit sold as a complete set rather than as individual tools bought one by one. Because everything in the set comes from the same release, the pieces fit together without compatibility problems. The trade-off is that the set is heavier, and the tools are designed mainly for Meta headsets, not for every brand.
How it is used in practice
A small studio of four developers plans a mixed reality furniture planner for Meta Quest 3. The lead developer creates a new Unity project, installs the All-in-One SDK, switches the build target to Android and accepts the fixes proposed by the Project Setup Tool, which changes the graphics API to Vulkan and enables ASTC compression.
Using Building Blocks, the team adds a camera rig, passthrough, hand tracking and the MR Utility Kit so that virtual sofas can rest on the real floor and align with detected walls. The Interaction SDK lets users grab and rotate furniture with bare hands, and the Platform SDK handles purchase entitlements for premium catalogs.
During development, the team tests interaction logic in the Meta XR Simulator and runs weekly builds on two headsets. By pinning one SDK version for the whole beta, they avoid upgrade breakage and ship the first store build in about three months instead of the five they had estimated when planning to integrate each package separately.