Spark 2.0 Streams 100M Gaussian Splats to Your Browser

The web just got a new dimension. Not a WebGL demo that crashes your phone. Not a Unity embed that takes 40 seconds to load. A full 3D Gaussian Splatting engine that streams photorealistic worlds to any device, in any browser, at interactive frame rates.

Spark 2.0 shipped this week. Open-source, MIT-licensed, built by the team at World Labs (Fei-Fei Li's spatial AI company). It is the most ambitious open-source 3D web renderer I have seen.

Here is what it does and why it matters.

#What is 3D Gaussian Splatting

Forget polygons and texture maps. 3D Gaussian Splatting (3DGS) represents scenes as millions of semi-transparent 3D ellipsoids, each carrying position, scale, rotation, color, and opacity data. They blend together to form hyper-realistic detail that traditional triangle-based rendering struggles to match.

Think of it as digital pointillism, but in 3D. Each "splat" is a tiny Gaussian blob. Stack millions of them and you get photorealistic scenes captured from the real world. The technique was introduced in 2023 and has been tearing through the research community ever since.

The problem: rendering even 5 million splats at interactive rates maxes out most devices. A large scene can hit 100 million splats easily. Before Spark 2.0, that meant "nice demo, but not for production."

#How Spark 2.0 Breaks the Scale Barrier

Spark 2.0 solves the scale problem with three systems working together. Each one is interesting on its own. Combined, they are a breakthrough.

#The Splat Tree (Level-of-Detail)

Spark organizes every splat into a hierarchy. Parent nodes are lower-resolution merges of their children. The root is a single large splat representing the entire object. At render time, Spark traverses this tree and picks a "cut" -- the set of nodes that gives the best visual quality within a GPU budget.

You set a budget (500K to 2.5M splats). Spark computes the optimal detail level in O(N log N) time. The GPU workload stays constant regardless of scene size. A 10M splat scene and a 100M splat scene cost the same to render.

Two training-free algorithms build these trees automatically:

• Tiny-LoD: fast, runs in the browser, good for on-demand use
• Bhatt-LoD: offline, uses statistical shape similarity (Bhattacharyya distance) for higher quality merges

No reference images needed. Just raw 3DGS data in, hierarchy out.

#The .RAD Streaming Format

Existing formats like .PLY and .SPZ are not built for streaming. You download the entire file before you see anything.

Spark developed .RAD: a spatially partitioned format that loads a coarse 64K-splat approximation of the entire scene instantly, then progressively refines detail as you move through the world. Refinement is prioritized for your current view direction.

This is the difference between "wait 30 seconds for a 2GB download" and "see the world in 500ms, watch it sharpen around you in real-time."

#GPU Virtual Memory

This is where it gets wild. Spark adapts operating system-level virtual memory concepts to the GPU.

It maintains a 16M-splat physical pool on the GPU and swaps 64K-splat "pages" in and out from .RAD files using an LRU (Least Recently Used) eviction strategy. Pages near your viewpoint stay loaded. Pages behind you get evicted to make room for what is ahead.

This is how you render infinite, composite worlds on a mobile device. The GPU never sees more than 16M splats at once, but the scene can be arbitrarily large.

#Performance Tricks

Spark does not just manage data well. It renders it well too.

Foveated rendering concentrates the splat budget toward the center of your view. More detail where you look, less at the periphery. This is the same principle VR headsets use, applied to web rendering.

WebAssembly workers handle LoD tree traversal asynchronously. The main rendering loop never blocks on hierarchy computation. Spark compiles Rust to WASM for this -- the sort of engineering choice that separates production tools from research demos.

Two-pass radix sort in a Web Worker handles the painter's algorithm (back-to-front sorting of millions of splats) without touching the main thread.

Multi-object compositing uses a three-step algorithm: generate a global sort list across all objects, sort back-to-front, render in one pass. This means you can place multiple 3DGS objects in the same scene and they blend correctly. No "pasted on" artifacts.

#The Programmable Pipeline

Spark is not just a viewer. It exposes a programmable GPU pipeline for every splat. Developers can apply per-splat effects at render time:

• SDF clipping: slice through objects with arbitrary shapes
• Animated transitions: morph between splat states
• 4DGS interpolation: render time-varying (animated) Gaussian Splat scenes

The pipeline is decorator-based. Your existing Three.js code stays the same. Spark wraps it.

#Why This Matters

The gap between what 3DGS can capture and what the web can render has been the bottleneck for two years. Photogrammetry pipelines produce beautiful scans. NeRF alternatives generate stunning reconstructions. But showing them to someone meant "download this app" or "buy a better GPU."

Spark 2.0 closes that gap. A 40-million-splat scan of Coit Tower runs interactively in a browser tab. On a phone.

This is the infrastructure layer for:

• Digital twins that anyone can inspect without specialized software
• Real estate walkthroughs that feel like being there, not looking at a 360 photo
• Cultural heritage preservation accessible to anyone with a browser
• Robotics simulation where spatial AI models can be visualized in real-time
• Gaming and interactive media built on photorealistic captured environments

World Labs built Spark internally to power their spatial AI platform. Open-sourcing it is a statement: the rendering layer should be commoditized. The value is in what you build on top.

#Get Started

Spark 2.0 is on GitHub under MIT license. Built on Three.js and WebGL2, it drops into any existing web project.

• sparkjs.dev -- documentation and examples
• GitHub: sparkjsdev/spark -- source code
• World Labs technical blog -- deep dive into the architecture

The future of 3D on the web is not polygons. It is splats. And now you can stream 100 million of them to a phone.