The Meta XR SDK Alphabet Soup Explained: Which Packages Do You Actually Need? (Part 3)

Welcome back to part 3 of the VR series! If you've missed the other articles click here. This one took me a little while due to its complexity (and boringness - but it's all stuff we need to know in order to make our first game in Meta Quest VR!). 

Alright, so your environment should be all set up, your headset is in Developer Mode, and ADB can finally see your Quest. Time for the fun part, right? Well...

Well not so fast. First you have to open the Package Manager and meet the Meta XR SDK family, which looks like someone fell asleep on a keyboard: Core, Interaction, Interaction Essentials, Platform, Audio, Haptics, MRUK, All-in-One. Which ones do you need? What does each one even do?

That's today's article. By the end, hopefully you'll have a clearer picture of what's in the box, which pieces matter right now, and wtf that mysterious camera rig prefab is doing in your scene.

Why Are There So Many Packages??

Because Meta split its tooling into focused pieces instead of one giant blob. That's actually good news: you install what you need and skip what you don't. The tradeoff is that the names are confusing until someone sorts them into a mental picture.

Here's the picture I use:

Meta XR Core SDK → Everything Else Builds On Top

Core is the foundation. Almost everything else either depends on it or extends it. So if you remember one thing from this section, remember that.

The Family At A Glance

Here's what each package does, in plain English:

• Meta XR Core SDK: The foundation for every Quest app. It handles rendering, tracking, and platform integration, and it includes the camera rig, controller input, hand input, and mixed reality basics like Passthrough, Anchors, and Scene. You need this one. Always.
• Meta XR Interaction SDK: The "pick things up" package. It gives you prebuilt components for grabbing, poking, ray pointing, and locomotion, for both hands and controllers. We'll spend all of Part 6 on this one.
• Meta XR Interaction SDK Essentials: A lighter version of the above, with the core building blocks for hands and controller input and a smaller footprint.
• Meta XR Platform SDK: Identity, social features, multiplayer, in-app purchases, and achievements. Think "talking to Meta's online services."
• Meta XR Audio SDK: Spatial audio, room acoustics, and positional sound, so a noise behind you actually sounds like it's behind you.
• Meta XR Haptics SDK: Designed controller vibration. Because "buzz at full strength" isn't a haptic design.
• Meta MR Utility Kit (MRUK): Higher-level helpers built on top of the Scene features, for apps that understand the player's real room. This one is for mixed reality, and we'll meet it in Part 9.
• Meta XR All-in-One SDK: All of the above in a single install.

There are a few more specialized ones too, like the Voice SDK and the Movement SDK for body and face tracking, but they're add-ons you can ignore until you have a reason to care.

All-in-One Or Pick-And-Choose?

This is the first real decision you'll make, so here's my take.

If you're learning, or following along with this series, install the All-in-One SDK. It gives you every tool, every Building Block, and every sample, and you don't have to hunt for a missing package when a tutorial references one. Think of it as buying the toolbox instead of picking screwdrivers one at a time.

If you're shipping a real game and want a lean project, install only what you actually use. Meta's packages are versioned together, so mixing and matching is safe as long as you keep them on matching versions. A smaller list of packages also means less to update, less to debug, and less clutter in your project.

Learning → All-in-One. Shipping → Only What You Use.

You can find the packages in the Unity Asset Store and install them through the Package Manager. Search for "Meta XR All-in-One SDK," add it to your project, and then run the Project Setup Tool from Part 2 again to make sure nothing is complaining.

What Does The Camera Rig Actually Do?

Here's where VR stops feeling like a regular Unity project.

In a flat game, you have one Main Camera. It renders what the player sees, and that's about it. In VR, one camera isn't enough. You need a setup that handles two eyes, tracks the headset, and tracks the controllers or hands. That setup is called an XR rig. In Unity's own documentation you'll also see it called an XR Origin. Same idea, different name.

Meta's version of this lives in the Core SDK as a prefab called OVRCameraRig. It replaces your Main Camera completely. Here's what happens behind the scenes:

Headset + Controllers → Tracking Data → OVRCameraRig → Moves Your Cameras And Hands In The Scene

Or, even simpler:

Meta XR Core SDK → XR Rig → Tracking + Rendering

The rig is the center of your "tracking space." When the player turns their head, leans in, or walks across their living room, the rig is what moves the view in your game to match. Without it, you'd have a scene that renders but doesn't respond to a single thing the player does.

There's also a variant called OVRCameraRigInteraction, which comes with the Interaction SDK. It extends the basic rig with controller and hand tracking, so grabbing and poking work out of the box. If you're using the Interaction SDK (and you will be), you'll likely end up using this one.

A practical tip: when you add a rig to a scene, delete the default Main Camera. Two cameras fighting over the player's view is how you get very confusing bugs and very unhappy testers.

Building Blocks: The Shortcut You're Gonna Love

Here's a feature that saves a surprising amount of time. In the Unity menu bar, go to Meta XR Tools → Building Blocks, and you'll get a window full of ready-made features: camera rig, controller tracking, hand tracking, passthrough, and more.

Each Building Block represents one piece of Quest functionality. Click to add it to your scene, and its dependencies and configuration get set up for you automatically. It's the fastest way to say "I want hand tracking" without reading three pages of documentation first.

Is it the only way to do things? No. But it's a great way to learn what's possible, and a great way to see how Meta wires things together before you start wiring your own.

Reading Controller Input With OVRInput

The Core SDK comes with OVRInput, a class for reading controller buttons, triggers, and tracking. Here's a tiny script that logs a message when you squeeze the right trigger:

using UnityEngine;

public class TriggerDemo : MonoBehaviour
{
    void Update()
    {
        if (OVRInput.GetDown(OVRInput.Button.PrimaryIndexTrigger, OVRInput.Controller.RTouch))
        {
            Debug.Log("Right trigger pressed!");
        }
    }
}

Read it like a sentence: "If the right Touch controller's index trigger was just pressed this frame, log a message." GetDown fires once on the frame you press, while a plain Get stays true as long as you hold it. Same logic as Unity's regular input, just with VR-flavored names.

A quick note on choices. OVRInput is Meta's low-level, Quest-specific way to read input. If you want your game to work across non-Meta headsets too, Meta recommends the Unity Input System instead. Since this series is focused on Quest, OVRInput is the simplest place to start.

Testing Without Putting The Headset On

You won't want to strap on the headset for every tiny change. Meta gives you two options:

• Meta Horizon Link: Streams your app from the editor to a connected headset over a USB-C cable or Wi-Fi. At the time of writing, it's Windows only.
• Meta XR Simulator: Simulates a headset right on your computer, so you can preview a scene without any hardware. It works on both Windows and macOS.

We'll use both in the optimization and testing articles later in the series. For now, just know they exist.

Quick Recap

So, in summary:

• Core SDK is the foundation, and you always need it.
• Interaction SDK handles grabbing, poking, and pointing.
• All-in-One is the easy button while you're learning.
• OVRCameraRig replaces your Main Camera and turns headset movement into in-game movement.
• Building Blocks add features to your scene without the setup headaches.

What's Next

In Part 4, we'll actually build something. Let's keep it simple and start with a cube, in VR, on your actual headset. It's boring on purpose, because it's the "did the whole pipeline work" checkpoint before the fun stuff starts. It's also a great way to make sure everything is set up correctly so far!

See you in Part 4!