Building AR and VR with React Native looks very different in 2026. ReactVision is now a full XR stack: spatial infrastructure built in, an MCP server so AI agents can build and test XR apps, and one codebase that runs on phones, headsets and the web. Here's what that means for your next app.

From library to XR stack

ViroReact began life at Viro Media, was open-sourced in 2019 and kept alive by the Viro Community fork, before ReactVision took it on in 2025 with a full-time team. Since then the pace has been relentless, with around twenty releases in 2026 alone, including ViroReact 3.0 in September and 3.1 in November.

Today ReactVision is four products that work as one:

  • ViroReact, the MIT-licensed, open-source renderer for React Native and Expo.
  • ReactVision Spatial, managed spatial infrastructure built into ViroReact.
  • The Editor, a browser-based, no-code AR and VR editor with its own AI agent.
  • The ReactVision MCP server, which connects your coding agent to all of the above.

ReactVision describes itself as the XR stack your AI agent builds on. Let's look at the three areas that matter most.

ReactVision Spatial: AR that remembers where things are

Most AR libraries give you a renderer and leave the hard parts to you: persistence, multi-user sync and content delivery. ReactVision Spatial provides those as managed services. You add a ReactVision API key and project ID, and there's no backend to build or run.

Cloud Anchors

Cloud Anchors persist AR content across app restarts and share it between users in the same space. The newer <ViroARCloudAnchor> component renders its children in a resolved anchor's shared coordinate frame, so two devices that mount the same anchor see a child at [0, 0, -1] in the same physical spot, with no coordinate maths in your app code.

Geospatial Anchors

Geospatial Anchors pin content to a real latitude, longitude and altitude. Drop a 3D model on a street corner and it's there every time someone visits. Think city trails, location-based games and place-based storytelling.

Scans and VPS

With ReactVision's Visual Positioning System (VPS), you scan a room or space once to define its own persistent coordinate frame, then relocalise any device inside it later. Content lands where you put it relative to the room, not to GPS. Scans can also produce a world mesh for occlusion and physics, and you can choose the scan's mesh quality to trade build time for detail.

Advanced VPS

Advanced VPS takes this further, with continuous localisation against a place's map that improves with every scan. Matching can happen on the device or on ReactVision's servers. ViroReact 3.1 added a server mode, where the app sends camera frames to be matched server-side instead of downloading the map. That's useful for large spaces and lower-powered devices.

Co-location and shared state

Co-location lets several people, on phones and headsets, share one coordinate frame in real time. ViroReact 3.0 added replicated room state on top: ordered, conflict-resolved shared state where whoever holds an object owns it. Hosted rooms are saved when the last person leaves, so objects left in a space are still there tomorrow. ReactVision Spatial also handles asset hosting with over-the-air content updates, and it can run on-premises for regulated industries.

Agent-first: the ReactVision MCP server

The biggest shift is how XR apps get built. AR and VR code has always been hard for AI agents. The APIs move quickly, there's little good training data, and bugs only show up in a real room. ReactVision's answer is to make the whole stack agent-first.

The ReactVision MCP server is a hosted Model Context Protocol server that works with Claude, Claude Code, Cursor, Codex, Windsurf and any other MCP client. You add one URL, sign in with a free ReactVision account, and your agent can:

  • Learn the live APIs: every ViroReact component, prop, event, doc and working example, plus which features run on which device.
  • Generate and validate scenes against the real component schemas, so a bad prop is caught before a failed build.
  • Run and render-test its own work, including rendering scenes inside recorded real-world rooms, comparing renders to catch visual regressions, and flagging 3D models that are too heavy for the target device.
  • Diagnose errors by matching crash logs against known issues.
  • Generate 3D models and images and add them to your project.
  • Convert between Editor scenes and ViroReact code, and turn an 8th Wall project into a ViroReact scaffold.

In practice this means you can ask your agent for a feature such as "let users place furniture and share it with a second device" and get back code that has already been checked and tested against the current API. Designers and subject matter experts can work in parallel in the Editor, and the agent can bring their scenes into code.

One codebase, more devices than ever

The other big change is reach. A single ViroReact codebase now renders natively on:

  • iPhone and iPad through ARKit.
  • Android phones and tablets through ARCore.
  • Meta Quest (Quest 2, Pro, 3 and 3S) through OpenXR, with passthrough mixed reality on Quest 3 and 3S.
  • Apple Vision Pro, for fully immersive visionOS apps, through the optional @reactvision/react-native-visionos package.
  • The web, through the optional WebGL2/WASM @reactvision/viro-web-renderer, including web AR.

Android XR is listed as coming soon. Optional packages add front-camera face tracking on iOS and on-device object detection with YOLOE through ONNX Runtime, which also runs on Quest 3 and 3S through Meta's passthrough camera API.

This isn't WebXR in a browser canvas. ViroReact turns your React components into native draw calls, so you get full hardware performance and native app distribution on every platform.

Quick start with Expo

ViroReact supports Expo through a config plugin and requires the New Architecture (Fabric). You'll need a development build rather than Expo Go, and a physical device for AR. The fastest route is the official Expo + TypeScript starter kit, or you can add it to a project:

npx create-expo-app@latest my-ar-app
cd my-ar-app
npm install @reactvision/react-viro

Add the plugin to app.json:

{
  "expo": {
    "plugins": [
      [
        "@reactvision/react-viro",
        {
          "android": { "xRMode": "AR" },
          "ios": { "cameraUsagePermission": "This app uses your camera for AR." }
        }
      ]
    ]
  }
}

Then write a scene:

import {
  ViroARScene,
  ViroARSceneNavigator,
  ViroAmbientLight,
  ViroText,
} from "@reactvision/react-viro";

const HelloWorldScene = () => (
  <ViroARScene>
    <ViroAmbientLight color="#ffffff" />
    <ViroText
      text="Hello from React Native AR"
      position={[0, 0, -1]}
      scale={[0.3, 0.3, 0.3]}
      style={{ fontSize: 30, color: "#ffffff", textAlign: "center" }}
    />
  </ViroARScene>
);

export default function App() {
  return (
    <ViroARSceneNavigator
      autofocus
      initialScene={{ scene: HelloWorldScene }}
      style={{ flex: 1 }}
    />
  );
}

Build and run with npx expo prebuild --clean and then npx expo run:ios (or run:android). Or connect the ReactVision MCP server and ask your agent to take it from here.

How it compares

  • Unity as a Library: a powerful engine with a huge asset ecosystem, and still a good fit for graphics-heavy games. But embedding it in a React Native app means a second engine, a second language (C#), a separate build pipeline and a months-long ramp-up, and you still have to build or buy your own spatial backend.
  • Native ARKit and ARCore: the most control and day-one access to new platform features, at the cost of separate Swift and Kotlin codebases, plus more work again for Quest or Vision Pro.
  • WebGL libraries such as react-three-fiber with expo-gl: excellent for 3D rendering inside a React Native app, but they don't provide native ARKit or ARCore tracking, cloud anchors or headset support on their own.

ViroReact is the most widely used open-source library for AR and VR in React Native, and ReactVision brings a native renderer, managed spatial infrastructure and an agent-first workflow together in one stack. If your team already builds with React Native or Expo, it's by far the best way to add AR or VR in 2026.

Planning an AR or VR app? Let's talk

At Morrow we build AR and VR apps with React Native, Expo and ReactVision, from quick prototypes to production apps with persistent, multi-user and location-based experiences.

If you're planning an AR or VR project, or want to add spatial features to an existing React Native app, book a call with us and we'll talk through what you're trying to build.

Are you looking for app development experts to drive your project forward?
Morrow are here to help!
Contact us
a photo of the Morrow team sat at a dinner table
More insights