How to start building for Meta VR Glasses before they ship

Meta spent two days at Connect 2026 announcing things it will not sell you for six months, and then did something more useful than the announcement: it shipped the software early. Meta VR Glasses arrive in spring 2027 at around 100 grams, and the v207 SDKs that build for them are downloadable now, with simulator profiles that stand in for the hardware. Meta's own framing is direct: "the next year belongs to the developers who start now."

This is the whole path, in the order you would actually do it, with the tools Meta points you at and the ones worth adding.

What exists right now, and what does not

• Available today: the v207 SDKs for Unity, Unreal, Android and the web; a VR Glasses profile in Meta XR Simulator; the Interaction SDK's new gaze interaction; the Device Readiness Check; the Wearables Device Access Toolkit 1.0 for mobile developers; the Immersive Web SDK for WebXR; Horizon Create and Horizon Studio on an early-access waitlist; the Muse model family through Meta Model API and partners.
• Not available: the headsets themselves. Meta VR Glasses ship in spring 2027, and you cannot buy test hardware. Everything before that point is a simulator, a Quest headset, or the glasses you already own.
• Rolling out from September 30, 2026: the AI-glasses build paths and the new discovery surfaces where people find what you make.

One caveat worth stating because Meta's own pages disagree. The Connect recap calls Meta Model API generally available globally; the product page still labels it public preview with "expanded global access". Plan for preview terms until the two pages agree.

Pick your path first

Four roads lead to the same store, and Meta has said plainly that you do not need to learn anything new to take one.

• You build games in Unity or Unreal: stay in the engine. v207 adds the VR Glasses simulator profile and gaze interaction, and your Quest build is most of the way there.
• You build Android apps: your app gets 360-degree screen space, multiple windows, gaze input, spatial audio and passthrough, with three small SDKs and an Android Studio plugin.
• You build for the web: WebXR plus the Immersive Web SDK, one command to start, and a PWA path into the store.
• You already ship a mobile app and want it on glasses: the Wearables Device Access Toolkit is the shortest distance from something working to something worn.

Path 1: Unity or Unreal

Step 1. Get v207 and switch the simulator to VR Glasses. Meta XR Simulator has a VR Glasses profile for Unity and for Unreal. This is how you test before hardware exists, and it is the reason to start now rather than in March.

Step 2. Add gaze interaction. It is the headline addition in the Interaction SDK: add it to a UI Canvas from the Quick Actions menu in Unity, or drop in the Eye Gaze Interaction Building Block. The rig switches between gaze and raycast depending on the device, so one project serves both.

Step 3. Design for the input model and the lens. This is where VR Glasses differ from what you have built for:

• Eyes and hands are primary. Touch Plus controllers are supported and sold separately, but Meta expects most buyers not to have them.
• The store prioritizes controller-free titles for VR Glasses users who own no controllers, so hand support is a distribution decision, not a polish item.
• The field of view is narrower and sharper. Roughly 70 by 66 degrees against Quest 3's 110 by 96, with higher resolution per eye. Text is more legible and eye fatigue drops, but Meta's own testing found apps placing UI at the extreme edges where VR Glasses users struggled to see it. Pull key UI toward the center.

Step 4. Run the Device Readiness Check. It produces a prioritized list of fixes, and it has an AI mode for agents such as Muse Code, which is Meta telling you to bring a coding agent to the compatibility pass.

If you want a first project rather than a migration, the Unity documentation tree starts with Hello World, Set Up Unity and Set Up Your Headset, which is still the fastest way to get a build on a device.

Path 2: Android

Your phone app becomes a spatial app with three additions and one install:

• Meta VR Layout SDK for multi-window layouts, with Jetpack Compose and React Native support.
• Meta VR Gaze SDK, in developer preview, for custom hover states.
• Meta VR UI Set SDK, so your app looks native on the platform rather than ported.
• The Android Studio plugin, which installs templates, the Meta Spatial Simulator and the CLI in one step.

Meta also offers a route with no local setup at all: build in Replit, where the Replit Agent already knows the VR Glasses input methods and SDKs, preview the result on a headset, and publish to the store when it is ready. BeamXR is the reference case Meta cites for that pipeline end to end.

Path 3: The web

The Quest browser is one of the most used apps on the platform, and browsing is expected to grow on VR Glasses. Two things make this path cheap:

1. The Immersive Web SDK (IWSDK). Start with a single command, develop with gaze simulation in the emulator, then test on a Quest 3 or 3S. The SDK ships its own AI tooling: full XR emulation control, scene composition, scene graph inspection, ECS-level debugging, input simulation, scene-file validation and runtime inspection, plus an MCP toolset so an agent can drive it.
2. The v0 by Vercel starter. Meta's v0 template includes the IWSDK scaffolding and the VR Glasses input model, so a prompt becomes a live HTTPS experience with nothing installed locally.

When it works, you have two distribution options: a hosted web experience or a Progressive Web App packaged for the Meta Horizon Store.

Path 4: AI glasses, three ways

Meta opened three doors here, and one of them needs no new SDK at all.

1. Extend a mobile app with the Wearables Device Access Toolkit 1.0. After a year in preview, it is now a stable release, and your app keeps its logic and its backend while the glasses become a hands-free front end. Users launch it with "Hey Meta", speak naturally while automatic speech recognition turns words into commands, and steer with a swipe on the Meta Neural Band. One integration covers display and displayless glasses, and 1.0 adds camera capture, voice input and motion streaming.

The requirements, from Meta's setup page:

• iOS 15.2 or later, or Android 10 or later, matching the Meta AI app.
• Xcode 14.0 or later, or Android Studio Flamingo or newer.
• Glasses supported today: Ray-Ban Meta Gen 1 and Gen 2, Ray-Ban Meta Optics, and Meta Ray-Ban Display.
• Developer mode enabled in the Meta AI app, which registers your unpublished app under Meta AI settings, App connections, Developer mode apps, and enables invite-only release channels.
• A Mock Device Kit if you have no hardware, so you can simulate the device.

2. Build a web app for Meta Ray-Ban Display. If you write HTML, CSS and JavaScript, you are already qualified. Web apps run without a native app or separate SDK, can read device position, location and wrist motion from the Neural Band, and accept text by dictation, handwriting or an on-screen keyboard. Meta ships a UI Toolkit on GitHub with accompanying skills, and a browser-based simulator for testing without hardware. WebMCP, in developer preview, lets you define exactly what Meta AI may control in your app.

3. Connect a service to Meta AI. Meta AI connectors turn your API into tools the assistant can call, so people reach your product inside a conversation instead of an app switch.

The AI tools Meta itself points you at

This is the part worth reading twice, because Meta has written the setup for your agent rather than for you.

• Muse Code is out of beta, runs on Windows, and is multi-agent by default, with parallel workers writing and testing code in isolated workspaces for long-horizon engineering.
• Muse Spark 1.3 handles the reasoning, and Meta Model API serves it with a one-click key and OpenAI SDK compatibility, which means a base URL change rather than a rewrite. Pricing on the product page runs per million tokens: $0.10 in and $0.20 out on the contributor tier, $1.25 in and $4.25 out on the tier Meta does not train on, both with a 1M context window. Muse Image is listed at $0.01 an image, Muse Voice Transcribe at $3.00 per 1,000 minutes, and SAM 3.1 at $2.50 per 1,000 images or $0.20 per 1,000 video frames. Muse Glimmer, an open-weights 30-billion-parameter model, is built to run on a single GPU or a Mac Mini.
• The DAT documentation is agent-ready. Meta publishes a copy-paste prompt that inspects your environment, picks iOS or Android, installs the matching GitHub plugin, wires up the documentation server and asks it for the current first-app guidance before any code is edited. The server is at <code>https://mcp.developer.meta.com/wearables</code> and exposes one tool, <code>search_dat_docs</code>, plus an <code>llms.txt</code> for exact API reference.
• Muse Code plugin commands are given verbatim, iOS and Android: <code>export MUSE_EXPERIMENTAL_PLUGINS=1</code>, then <code>muse plugins marketplace add mwdat-ios-marketplace https://github.com/facebook/meta-wearables-dat-ios</code>, <code>muse plugins install mwdat-ios@mwdat-ios-marketplace</code> and <code>muse plugins approve mwdat-ios</code>, with <code>mwdat-android</code> substituted for Android. Installing the plugin also registers the docs server, so there is nothing to add separately.
• Free credits. The Meta Global AI Developer Hackathon offers free Model API credits on Muse Code, the Model API and the open-weights models, with workshops run by Meta Superintelligence Labs engineers.

If you already pay for a coding agent, the documented path works with it: point Muse Code, or whatever coding agent you already use, at the developer documentation and let it scaffold the integration. Meta's own Immersive Web SDK takes the same line, exposing MCP tools for the emulator rather than a menu of buttons.

What we would reach for

Meta's stack answers the platform questions. It does not answer the production ones, so here is the shortlist we would put beside it.

• An agentic coding tool in the repository: Claude Code, Codex or Muse Code, doing the scaffolding, the SDK wiring and the boring parts of a first build. This is the single highest-leverage choice, because the DAT and IWSDK workflows assume an agent is reading the docs.
• An editor-side assistant: Cursor or GitHub Copilot for the line-by-line work the CLI agents are bad at.
• 3D assets: Meshy or Tripo to generate props and environment pieces you would otherwise spend a week modeling, then clean up in Blender.
• Voice: ElevenLabs for character and narration audio, or Muse Voice Transcribe when you need speech turned into commands inside the app rather than performed.
• Video and texture: Runway, Seedance or Kling for the screens, posters and surfaces that VR scenes need in volume.
• Local inference: Muse Glimmer when you want an on-device agent without an API bill.

The rule we would follow is Meta's: use the agent on the documentation before you use it on the codebase. The failure mode of every one of these tools is plausible code against a hallucinated API version, and the fix is the same as the DAT prompt's: make the docs a tool the agent can call, not something you paste in.

Horizon, if you want players rather than users

Two new tools sit on the Meta Horizon Engine's agentic creation stack, and neither requires an engine to learn.

• Horizon Create is a phone app: describe the game you want, watch it build, keep playing while it generates, and refine art style, characters, story and progression by describing the changes.
• Horizon Studio is the browser version with visual editing on top: arrange the scene, swap individual assets, tune script parameters, shape spatial layouts by hand.

Everything transfers between them, assets and iteration history included, so starting on the phone costs you nothing. Publishing makes a game eligible for distribution across Facebook, Instagram and Horizon, where a clip in a feed can put someone in a multiplayer session without a download. Discovery is ranked on engagement, and monetization runs through in-game purchases and the Meta Horizon Creator Fund. Both tools are in early access on a waitlist.

What to do this week

1. Make a Meta developer account and organization, then install Meta Quest Developer Hub and the v207 SDKs for your engine.
2. Enable developer mode on any Quest you can borrow, and on your phone for the Meta AI app if you are taking the glasses path.
3. Run the Hello World tutorial end to end. It is short, and it proves your whole toolchain before you spend a week on a feature.
4. Add the VR Glasses simulator profile and run the Device Readiness Check on something you have already shipped. The fix list is the cheapest product research available this quarter.
5. Join the Horizon Create and Studio waitlist, and the hackathon, for credits and access.
6. Ship one small thing that only works on glasses. Gaze hover, a hands-only interaction, or a hands-free command through the toolkit. Knowledge of this input model is the scarce skill for the next year.

Why this is worth a weekend

Meta has handed developers a five-month head start on hardware it has not shipped, a simulator that stands in for it, documentation written to be consumed by agents, and free credits for the models. The companies that matter in 2027 on this platform will mostly be the ones that started in October 2026, because the phase everyone underestimates is the boring one: getting a build onto a device, learning what gaze breaks, and finding out which of your assumptions about hands did not survive contact with a lens that sees 70 degrees.

The hardware is not here. The tools are, and they are the whole of the job.