techGalen Guan

Spark 2.0: World Labs Unleashes Streamable 3D Gaussian Splatting on the Web

It is mid-April 2026. While the AI world is busy chasing ever-larger language models, a quiet revolution in visual computing has just landed. Spark 2.0 — the open-source 3D Gaussian Splatting renderer built by Fei-Fei Li's World Labs — ships with a Level-of-Detail streaming system that lets a smartphone render a scene with a billion splats without breaking a sweat. If that sounds like hyperbole, stay with me.

What You Need to Know

Spark is an MIT-licensed 3D Gaussian Splatting (3DGS) renderer that plugs into THREE.js, the web's most popular 3D graphics library. It treats "splats" — tiny oriented Gaussian blobs that collectively form photorealistic 3D scenes — as first-class citizens in the scene graph, letting you mix them with traditional triangle meshes, apply shader effects, and animate them in real time. With version 2.0, the game changes entirely.

The headline feature is a streaming Level-of-Detail (LOD) system backed by a virtual memory manager for splats. Think of it as the operating-system pagination model applied to 3D rendering. Spark pre-allocates a fixed GPU memory pool (default 16 million splats), fetches chunks over HTTP Range requests, and evicts the least useful chunks using an LRU policy. The result: scenes containing 100 million or even 1 billion+ splats render at a steady, tunable frame rate on anything from a Vision Pro to an Android phone.

Why This Matters

Before Spark 2.0, web-based 3DGS viewers had hard ceilings. Loading a multi-gigabyte .PLY file would crash the browser because it could not allocate buffers that large. Sorting millions of splats in real time was a computational bottleneck. And scenes with large coordinates would exhibit visible quantization artifacts — striping and shimmering. Spark 2.0 solves all three.

Here is the technical breakdown:

  • LoD Splat Tree: Any splat file can be turned into a tree where interior nodes represent progressively downsampled splats, reaching all the way up to a single "root splat" — the average color and shape of everything. At render time, Spark computes optimal slices through this tree in O(N log N), selecting exactly the most visually important N splats for the current viewpoint.

  • Composite LoD Worlds: Drop multiple SplatMesh objects anywhere in space and Spark traverses all their LoD trees jointly, computing the optimal global subset. This means you can compose enormous worlds from modular parts — each independently editable, each with its own shader graph.

  • .RAD Format: A new extensible file format designed for streaming. Loads start from the coarsest root splats and resolve detail progressively as network bandwidth allows. Instant first paint, continuous refinement.

  • Two LoD Algorithms: tiny-lod runs on-demand in a browser WebWorker (1-3 seconds per million input splats). bhatt-lod is a higher-quality pre-processing pass. Both ship as a command-line tool written in Rust.

  • ExtSplats: A 32-byte encoding with float32 center coordinates, eliminating the quantization artifacts that plagued 16-byte encodings in large coordinate spaces.

Spark 2.0 Streaming LOD Architecture

The Competitive Landscape

The 3DGS ecosystem has been fragmented. The original reference implementation from Inria / GraphDeco (21k GitHub stars) is a research codebase — not a rendering engine for applications. Other web viewers each have limitations:

3DGS Web Renderer Landscape

Project Stars What It Does Limitation
antimatter15/splat 3k WebGL splat viewer Single static scene, no dynamic editing
mkkellogg/GaussianSplats3D 2.7k THREE.js integration Single object, no LOD, no streaming
PlayCanvas Engine 14.8k Full web graphics runtime 3DGS is a format plugin, not a programmable engine
Spark 2.0 2.9k Programmable 3DGS renderer with LOD streaming Newer, smaller community but richer engine

Spark's positioning is distinct: it is not a viewer, but a programmable rendering engine. Its Dyno shader graph system allows composing arbitrary GLSL computation graphs for procedural splat generation, real-time recoloring, displacement, and skeletal animation. Spark 2.0 even lets you inject your own vertex and fragment shader code without forking the library.

The Deeper Story: Spatial Intelligence

Spark does not exist in isolation. World Labs, founded by Fei-Fei Li and backed by significant funding (announced February 2026), is building what they call "Spatial Intelligence" — AI that can perceive, reason about, and interact with the 3D world. Their product Marble generates interactive 3D worlds from text, images, or video. Spark is the consumption layer: the renderer that makes those worlds accessible on any device with a web browser.

In other words, Spark is to World Labs what the web browser is to the internet. Marble generates the content. Spark renders it. Together, they form an end-to-end pipeline for AI-generated immersive experiences.

This is notable because it runs counter to the walled-garden approach common in spatial computing. Apple Vision Pro developers need Xcode, an Apple Developer account, and a device that costs thousands of dollars. Spark renders the same content on a $200 Android phone, through any browser, with no app store approval. The web as a spatial computing platform is not a new idea, but Spark 2.0 is the first time it feels technically viable at scale.

Numbers That Tell the Story

  • 146,000 npm downloads in the last 30 days
  • 2.5 million default splat budget for desktop rendering
  • 500,000 splat budget for Oculus Quest
  • 1-3 seconds to build an LoD tree from 1 million input splats in a browser WebWorker
  • 98%+ WebGL2 device coverage target
  • 3,900+ individuals who contributed to the Spark project

What Is Still Early

Spark 2.0 marks an ambitious jump from 0.1 — the migration guide even documents breaking changes. Some features carry the "experimental" label: covariance splats for anisotropic scaling, linear blend skinning for rigged character animation, and real-time splat portals for non-contiguous scene spaces. The LOD system itself has tunable foveation parameters (cone angles, behind-foveate scaling) that developers will need to learn to balance quality against performance.

The .RAD format is new and not yet widely adopted by authoring tools. The documentation is good but still growing. And the community — 2.9k stars versus PlayCanvas's 14.8k — is early.

But these are not weaknesses. They are the shape of a project that has just crossed the threshold from "promising experiment" to "serious platform." The fact that World Labs ships Spark under MIT license, with no lock-in to their Marble ecosystem, signals strategic confidence: when the infrastructure is openly available, the value moves up the stack to content creation.

Getting Started

Three lines of code is all it takes to put an LoD splat tree on your page:

<script type="importmap">
  {
    "imports": {
      "three": "https://cdnjs.cloudflare.com/ajax/libs/three.js/0.180.0/three.module.js",
      "@sparkjsdev/spark": "https://sparkjs.dev/releases/spark/2.0.0/spark.module.js"
    }
  }
</script>
<script type="module">
  import * as THREE from "three";
  import { SparkRenderer, SplatMesh } from "@sparkjsdev/spark";

  const scene = new THREE.Scene();
  const renderer = new THREE.WebGLRenderer();
  renderer.setSize(window.innerWidth, window.innerHeight);
  document.body.appendChild(renderer.domElement);

  const spark = new SparkRenderer({ renderer });
  scene.add(spark);

  const splats = new SplatMesh({
    url: "./my-scene-lod.rad",
    paged: true,   // stream over HTTP Range requests
  });
  scene.add(splats);

  renderer.setAnimationLoop(() => renderer.render(scene, camera));
</script>

Pre-build the LoD tree from the command line first:

npm run build-lod -- my-scene.spz --quality

This produces my-scene-lod.rad, ready for instant loading and progressive streaming.

Why I Am Paying Attention

I have watched the 3D web go through multiple hype cycles — WebGL, WebXR, glTF, USDZ — each promising to make immersive content accessible but each falling short on the "accessible" part. The bottleneck was never the rendering API. It was the content: how do you create, stream, and composite massive 3D scenes that look photorealistic without requiring a gaming PC?

Gaussian Splatting solves the creation problem (generate from photos or AI). Spark 2.0 solves the delivery problem (stream over HTTP, render on any device). The combination is what makes me think this time might actually be different.

If you are building anything that involves 3D visualization on the web — from e-commerce product configurators to architectural walkthroughs to virtual tourism — you should be watching Spark 2.0 closely.

Links