1. Why this article exists, and why now

In January 2025, Niantic announced that 8th Wall would transition: the engine would go open source in stages (binary engine in 2025, full open source planned), and hosted services — the actual URLs that serve your campaigns — would shut down on February 28, 2027. As of April 28, 2026, the more immediate date has already passed: platform access ended on February 28, 2026, so the remaining runway is hosting continuity rather than further editing.

If you have an 8th Wall project shipped, three things are true:

• Your campaign URL may still work today if it was live before February 28, 2026.
• You can no longer log in, edit, or export hosted 8th Wall projects after February 28, 2026.
• Those hosted URLs stop working on March 1, 2027, so the migration window is now about keeping a live experience alive, not continuing normal authoring.

This article is the playbook. It is concept-heavy and decision-heavy by design — actual integration with Niantic Studio requires their account, their SDK, and your project's specifics. The demo at the bottom is small and illustrative: a placeable AR-like cube on a flat plane, the visual ancestor of every "tap to place" 8th Wall demo.

2. What 8th Wall did, in one paragraph

8th Wall was the dominant commercial WebAR platform from 2018 onward. It shipped:

• Markerless world tracking via SLAM — initialise from camera + IMU, no markers, no preset images.
• Image targets — robust marker tracking that exceeded MindAR.
• Sky and face effects — sky segmentation in camera feed; face mesh + expressions.
• Lightship VPS for Web — visual positioning system, centimetre-accurate world-anchored AR at 100k+ scanned locations.
• Niantic Studio — their visual editor for WebXR experiences (not 8th Wall classic; the successor).
• Pipelines for Three.js, A-Frame, Babylon.js — XR8 runtime that produced camera-pose streams those engines consumed.

The whole package was hosted, paid (per-active-campaign and per-MAU), and largely closed source. Coca-Cola, Burger King, LEGO, Pepsi, Heineken, plus thousands of agency-built campaigns ran on it.

3. What Niantic Studio offers

Niantic Studio is the successor — a web-based collaborative editor for WebXR experiences that sits on top of an open-sourced version of 8th Wall's tech. As of April 28, 2026:

• Editor. Browser-based scene authoring, multi-user (Figma-for-3D-AR pattern). Drag in glTF, attach scripts, preview on device via QR.
• Runtime. Three.js-based scene graph with the WebXR APIs Niantic exposes. Scripts are TypeScript modules attached to entities.
• SLAM. Niantic's world-tracking is the same algorithm as 8th Wall's, distributed as a binary engine library with a free-for-commercial-use license.
• VPS. Lightship VPS continues. Server-side cloud anchoring against the same 100k+ scanned locations.
• Hosting. Niantic offers hosting; you can also self-host the runtime.

The continuity is real: most 8th Wall concepts have a Niantic Studio counterpart. The migration is mostly about asset re-import, script re-write, and project configuration — not a rewrite of your AR logic.

4. The decision tree

Not every 8th Wall project should migrate to Niantic Studio. Some should go to MindAR. Some should go to model-viewer. Some should go to nothing — sunset gracefully. Here is the tree:

5. 8th Wall → Niantic Studio code-shape comparison

The mental shift is small. Both expose Three.js. Both inject a camera-pose stream. Both have a scene-graph and event hooks. Naming changes, lifecycle changes a little.

8th Wall (XR8 pipeline)

// 8th Wall — register a Three.js pipeline module
const Pipeline = {
  name: 'product-ar',
  onStart: ({ canvas }) => {
    const scene = new THREE.Scene();
    const camera = new THREE.PerspectiveCamera(60, canvas.width / canvas.height, 0.01, 1000);
    const renderer = new THREE.WebGLRenderer({ canvas });
    // ... add a glTF model
    Pipeline.scene  = scene;
    Pipeline.camera = camera;
    Pipeline.render = renderer;
  },
  onUpdate: ({ processCpuResult }) => {
    // 8th Wall provides the camera matrix per frame
    const reality = processCpuResult.reality;
    if (!reality) return;
    Pipeline.camera.matrix.fromArray(reality.cameraTransform);
    Pipeline.camera.matrix.decompose(
      Pipeline.camera.position,
      Pipeline.camera.quaternion,
      Pipeline.camera.scale
    );
  },
  onRender: () => Pipeline.render.render(Pipeline.scene, Pipeline.camera),
};
XR8.addCameraPipelineModule(Pipeline);
XR8.run({ canvas });

Niantic Studio equivalent

// Niantic Studio — a TypeScript script attached to an entity
import { Entity, World, useFrame } from '@niantic/studio';
import * as THREE from 'three';

export default function ProductAR(entity: Entity, world: World) {
  // Niantic Studio gives you a Three.js scene + a camera that already tracks
  const scene  = world.three.scene;
  const camera = world.three.camera;       // already auto-driven by SLAM

  // Author content as normal Three.js Object3D children of the entity
  const loader = new GLTFLoader();
  loader.load('/models/product.glb', (gltf) => entity.add(gltf.scene));

  // Per-frame logic
  useFrame((dt) => {
    entity.rotation.y += dt * 0.4;
  });
}

What changed:

• You no longer write the camera-update plumbing. Niantic Studio's editor wires it.
• Scripts attach to entities (declarative). XR8's pipeline modules attached to a camera-feed stream (imperative).
• Build is editor-driven; XR8.run() goes away.
• Hot reload for scripts is built in.

6. Asset migration

8th Wall projects ship a tree of .glb models, image targets (PNG with metadata), audio, and shaders. The migration matrix:

7. SLAM differences — what to expect at handoff

Both platforms use Niantic's tech under the hood. The differences are operational:

• Initialization. 8th Wall used a dedicated "tap to place" UI; Niantic Studio defaults to camera-feature-driven auto-init but you can keep the tap pattern.
• Drift. Equivalent on Quest, identical on phone — same algorithm.
• Lighting estimation. 8th Wall exposed lightingEstimation; Niantic Studio routes it through world.lighting with the same shape.
• Image-target → world handoff. The hybrid pattern (detect image, lock pose, switch to SLAM) survives — the API is similar, names changed.
• VPS confidence. Niantic Studio surfaces a confidence score. 8th Wall did this through events; Niantic Studio exposes it as a reactive value.

8. Alternatives summary

MindAR (open source, image + face tracking)

• TF.js-powered. Image targets via custom feature pipeline; face mesh via MediaPipe-style model.
• Three.js bindings first-class.
• No SLAM. No VPS. No sky effects.
• Best fit: marketing campaigns where the print/package is the trigger.

AR.js (open source, marker + geo)

• Hiro/NFT marker AR plus location-based AR.
• Cheaper, slower-moving project than MindAR.
• Best fit: museum kiosks, location-based geo-AR walks.

model-viewer (Google, glTF + AR launch)

• <model-viewer> with ar attribute. AR fall-through to Quick Look (iOS) and Scene Viewer (Android).
• No SLAM, no markers — uses native AR APIs.
• Best fit: e-commerce product viewers, "see in your room" buttons.

WebXR + Three.js

• If your audience is Quest 3 / Vision Pro / Chromium Android, WebXR alone covers AR mode + image tracking + depth (S11-13).
• No SLAM in browser-API form (depends on platform). No VPS.
• Best fit: headset-first XR with progressive web fallback.

9. The flagship-project recipe

You shipped a campaign on 8th Wall in 2023. Big brand, big agency, big budget. Live URL still serves traffic. What do you do?

1. Audit the experience. What APIs does it use — SLAM, image targets, VPS, face? Decision tree (§4) gives you the destination.
2. Lock a deadline. Q4 2026, no later. Migration deploys and a redirect from old URL to new.
3. Re-author in target. Pull glTF, audio, shaders into Niantic Studio (or MindAR project, or model-viewer). Re-write the AR logic in target's idiom.
4. Test on a 2024-era Android + iPhone. Camera permission UX is the #1 conversion killer. Replicate 8th Wall's permission prompt.
5. Run a soft launch. Old URL up; new URL gets 10% of traffic, 50%, 100%. Cutover; redirect.
6. Hold a self-hosted 8th Wall binary build as backup. If the new build has issues at scale, you have a fallback.

10. Live demo — concept piece

A small placeable cube on a flat plane. No real AR — that needs a camera and an XR session. The interaction is the visual ancestor of every 8th Wall "tap to place" demo: you click the floor, an object pins there, scale + rotate it, repeat. The same JSX shape you would write in Niantic Studio scripts; the same Three.js setup that survives every migration in §4.

11. Season 11 recap

Fifteen articles. Two arcs:

• The configurator arc (S11-01 to S11-08). Architecture, materials/colour picker, AR launch, watch industry, eyewear/sneaker try-on, modular furniture, Shopify integration, the production capstone. Eight articles aimed at the highest-paying segment of the 3D web market.
• The flagships (S11-09 to S11-15). IFC.js BIM viewer, Spark splat renderer, Nerfstudio bridge, R3F v10 + WebGPU + TSL, WebXR Layers + Depth, Hillaire atmosphere, this Niantic migration. Seven articles each filling a Master Part F gap.

The thread tying them together is "ship-this-to-clients." Less playful than S1-S3, more production-quality. The visual identity — emerald, deep green-black, "money green" by association — is intentional.

12. What Season 12 might look like

Master Part F has another 85 ranked candidates. The Tier 2 cuts that didn't make S11:

• Volumetric clouds at scale. Schneider's HZD pipeline ported to TSL/WebGPU. C1.3 in the research.
• Ghost-of-Tsushima dense grass. 200k blades in WebGPU compute. C1.5.
• FFT ocean + Jacobian foam. Beyond the Gerstner sum from S4. C1.7.
• OPFS + 3-tier asset cache. 2-7× cold-start improvement. C3.15.
• Service workers + 3D. Offline AR/VR/3D apps. C3.16.
• Pixel Streaming + Three.js hybrid. Heavy hero render, light browser UI. C3.10.
• Hand-pose ML classifier in WebXR. Including ASL fingerspelling. C3.4.
• Persistent anchors at scale. The 8-anchor-per-origin Quest limit, prioritised. C3.3.

If the configurator arc finds an audience, the next season probably leans further into commerce-shaped pieces (try-on, virtual store, livestream commerce). If the flagships find an audience, Season 12 doubles down on rendering and XR. Either is a real season.

13. Takeaways

• Feb 28, 2027 — that's the 8th Wall hosted-services cutoff. Plan migration before Q4 2026.
• Niantic Studio is the official continuity, especially if you used VPS or markerless SLAM.
• If you used image targets only, MindAR is the open-source path.
• If you used AR launch on a glTF, model-viewer is the no-JS path.
• Code-shape changes are small. The big work is asset re-import and project configuration.
• Self-hosting the open-sourced 8th Wall binary engine is the safety-net option for in-flight projects.
• Lead any client conversation with the deadline. It is the wedge.

Thanks for reading Season 11.