Meta XR All-in-One SDK

On this page 7

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.

ComponentPrimary responsibilityTypical use
Meta XR Core SDKCamera rig, tracking, passthrough, project setupEvery Quest project
Interaction SDKHand and controller interactions, grabbing, poking, ray castingObject manipulation and user interfaces
MR Utility KitAccess to the scene model, room geometry and anchorsMixed reality placement
Audio SDKSpatialization, room acoustics, ambisonicsImmersive sound design
Voice SDKSpeech recognition and voice commandsHands-free control
Platform SDKEntitlements, achievements, multiplayer, user identityStore-published applications
Haptics SDKDesigned haptic clips for controllersTactile feedback
Main component packages in the bundle

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.

BackendStandard basisCurrent status
Oculus XR PluginProprietary Oculus API wrapperLegacy, kept for older projects
Unity OpenXR with Meta featuresOpenXR plus Meta vendor extensionsRecommended for new projects
Plain Unity OpenXRCross-vendor OpenXR onlyPortable but lacks many Quest features
Backend options for Quest projects in Unity

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.

OptionScopeStrengthLimitation
Meta XR All-in-One SDKUnity, Meta QuestFull access to Quest featuresTies code to Meta hardware
Unity XR Interaction ToolkitUnity, many headsetsVendor-neutral interaction modelFewer Quest-specific features
Meta Spatial SDKNative Android, KotlinLightweight mixed reality appsNot a Unity workflow
WebXRWeb browsersNo installation requiredLimited performance and APIs
Comparison with neighboring development options

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 typeKey componentsReason
Fully immersive gameCore, Interaction, Audio, PlatformControllers, spatial sound and store features
Mixed reality utilityCore, MR Utility Kit, InteractionPassthrough and room-aware placement
Social applicationCore, Platform, Voice, MovementIdentity, voice and avatar expression
Training simulationCore, Interaction, HapticsPrecise hand interaction and feedback
Choosing components by project type

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.