Photographic 3D scenes can now be rendered in a web page. Gaussian splatting represents a scene as millions of small, semi-transparent, colored blobs, and WebSplatter draws them in real time using WebGPU, the browser's modern interface to the graphics card. It does this by keeping the whole scene in memory. A mid-sized scene already needs about 1.2 GB, and a browser tab dies at roughly 4 GB (Moving beyond the desktop). A city therefore has to be streamed and shown at reduced detail. Reduced detail brings a familiar problem: "popping," where coarse content snaps visibly to fine content. On the web there are two causes. One is the camera crossing a distance threshold. The other is a packet of detail arriving late over a slow network.
We propose one representation that removes both causes. Each blob gets a learned "fade distance," the camera distance beyond which it smoothly fades out. The file is stored sorted by that distance within each spatial cell. The blobs visible from any viewpoint are then just the first k entries of each cell's list. Several things follow from this ordering. Choosing what to draw becomes one number per cell rather than a tree search. Fetching what is missing becomes a contiguous HTTP byte-range request. Late arrivals are handled by treating the camera as slightly farther away than it really is, so new detail fades in the same way it does when the camera approaches, instead of popping. The core claim is that making fade order and streaming order the same thing lets a browser render city-scale scenes within its memory budget with no popping from either distance changes or network delays.
What exists and what is missing
Continuous detail control for Gaussian splats already exists, but only in native CUDA or C++ rendering. CLoD-GS learns a per-Gaussian distance decay so that less important blobs fade with distance. It reduces Amsterdam from about 1592 MB to 445 MB, but it assumes the whole model is resident in memory. We reuse its training idea and add a storage order and a streaming rule. LODGE builds detail layers, splits the city into camera-clustered chunks, and fades Gaussians across chunk boundaries. Its authors name mobile-browser streaming as future work. Its chunks overlap and are chosen per camera cluster, which is different from a single ordered stream. LapisGS adds discrete enhancement layers and interpolates opacity between them. Our ordering is per blob and continuous rather than per layer.
The streaming systems motivate the problem because they show popping in practice. GSStream switches among six discrete tile quality tiers. Adaptive 3DGS Video Streaming reports flicker when tiles change tier between groups of frames.
Two results constrain the design. Voyager finds that on mobile GPUs, walking the level-of-detail tree to decide what to draw ("cut finding") dominates frame time. Tree-based schemes such as Octree-GS are therefore a poor fit. WebSplatter shows that WebGPU lacks global atomics, so it needs flat, wait-free scans. A flat per-cell prefix is exactly the structure such a scan handles well.
Core Claim
Let Gaussian $i$ have base opacity $\alpha_i$ and learned fade scale $s_i$. Its rendered opacity at camera distance $d$ is $\alpha_i\, g(d/s_i)$, where $g$ is a fixed decreasing ramp and $g(x)=0$ for $x \ge 1$. Now sort each spatial cell's Gaussians by $s_i$ from largest to smallest. At distance $d$, the blobs with nonzero opacity are exactly those with $s_i > d$, which is a prefix of that sorted list.
Suppose the client has so far received the prefix that is complete down to scale $\hat s_c$ for cell $c$. It renders using the effective distance
$$d^{\text{eff}}_i = \max\big(d_i,\ \tilde s_c(t)\big),$$
where $\tilde s_c(t)$ is $\hat s_c$ smoothed over time $t$ with a bounded rate. While detail is missing, the cell is drawn as the representation would look from slightly farther away. When bytes arrive, $\tilde s_c$ decreases smoothly and the new blobs fade in. Because every blob is drawn only above its own fade distance, the image never shows a blob that should be absent, and it never snaps one into view. Memory scales with the visible prefix. Choosing what to draw costs one binary search per cell, followed by a Blelloch prefix sum to compact the selected blobs. That prefix sum is the same primitive WebSplatter already uses.
Research Program
Training. We train CLoD-GS-style fade scales on large scenes. We add one regularizer that keeps the within-cell ordering stable under the per-Gaussian versus cell-center distance approximation: the client fetches using cell-center distance, while the shader evaluates each Gaussian's exact distance.
Packing and streaming. We pack each cell as a sorted, quantized byte stream, using WebSplatter's 32-bit packing. A browser client in WebGPU then does three things each frame. It computes a target prefix length per cell and issues range requests prioritized by the resulting screen-space deficit. It maintains the frontier $\tilde s_c$. It applies $d^{\text{eff}}$ in the preprocessing compute pass, before WebSplatter's radix sort.
Analysis. We will measure how large the cells can be before the cell-center fetch rule under-fetches for nearby blobs. We will also measure what frontier rate limit keeps the fade-in speed below visible thresholds.
Baselines
The naive reference is WebSplatter itself, loading the full model. It is the strongest possible image-quality baseline where it fits in memory. On garden it reports about 1.20 GB of peak VRAM, against more than 2.80 GB for other WebGPU viewers. On city scenes we expect it to exceed the tab cap. Recording that failure is part of the result.
The strongest existing method is LODGE, reimplemented as a WebGPU client on top of the same WebSplatter renderer. It keeps its chunking, its tile-cost-derived distance thresholds, and its chunk-boundary opacity fade, and it streams chunks over the same network traces. LODGE reports 26.57 PSNR on SmallCity, 257 FPS on an A100 and 41 FPS on an iPhone 13 mini, all native. There is no reported result on Lacuna for any browser implementation, and no reported result on Lacuna for a popping metric for LODGE.
We also run a discrete-tile baseline in the style of 3D Tiles. It swaps whole tiles with a 200 ms cross-dissolve, standing in for GSStream-style tiered switching.
Fairness controls apply to all methods. They share the same trained Gaussian scene as the source, where the method permits it. They share the same renderer core, the same browsers and devices, the same bandwidth traces, and the same byte budget. Thresholds are tuned per method on held-out trajectories with equal tuning effort.
Two ablations isolate the key ingredient. The first drops the arrival clamp and fades by distance only, which should pop when data arrives. The second keeps the clamp but streams blobs in random or importance order instead of fade order, so a received prefix no longer corresponds to a coherent detail level.
Beating LODGE means matching its image quality within 0.3 dB PSNR while reducing temporal artifacts and peak memory, at interactive frame rates on phones. Temporal artifacts are measured by FovVideoVDP JOD on fly-through videos and by excess frame-to-frame flicker relative to a full-model reference render.
Why not just…?
Why not just use discrete tiles with a temporal cross-fade? This is the real threat for popping caused by distance changes. During each fade, the coarse and fine tiles are both resident and both drawn, which roughly doubles overdraw. Blending two independently built representations that do not share structure produces ghosting, as BungeeNeRF's multi-scale analysis (BungeeNeRF) and the file's summary of Son et al. describe. The tile baseline above measures both peak memory and FovVideoVDP. If cross-fading tiles matches us on both, the representation adds nothing, and we will report that.
Why not just port CLoD-GS to WebGPU? For small scenes this may be enough, and we will include it. However, it keeps the whole model resident. Even its reduced Amsterdam model is 445 MB before any browser overhead, and it provides no rule for what to fetch first or how to display content that has not yet arrived. The first ablation (no clamp, distance fade only) is essentially that port with naive streaming added.
Why not just render on a server and stream video? Pixel streaming avoids client memory limits entirely. The cost is round-trip latency on every camera move, a GPU per user on the server, and bandwidth. We will report motion-to-photon latency against a WebRTC server running LODGE as a context point. We do not claim a win where latency does not matter.
Why not just prune harder, as WebSplatter does? Pruning shrinks the model by a constant factor. It does not make memory depend on the viewpoint. Culling at a fixed opacity threshold is itself a hard threshold, which causes flicker. The naive baseline tests this directly.
Proposed Experiments
Scenes. We use BungeeNeRF for extreme zoom, MatrixCity for aerial-to-street transitions, SmallCity and Campus as used by LODGE, and Mip-NeRF 360 garden as a small-scene check against WebSplatter.
Trajectories. For city scenes, trajectories are scripted zoom-and-traverse fly-throughs, including hovering near thresholds. For small scenes, we use GSStream's viewport trajectory dataset.
Network traces. Bandwidth traces span 40–120 Mbps, following GSStream.
Devices and browsers. We test Chrome and Safari on an iPhone, a mid-range Android phone, and an integrated-GPU laptop.
Metrics. Image quality is measured by PSNR, SSIM, and LPIPS against full-model renders. Temporal quality is measured by FovVideoVDP JOD and excess flicker. System cost is measured by peak tab memory, FPS, cut-selection time per frame, bytes transferred, and time to first frame.
Decisive checks. We accept the proposal if three things hold. First, image quality matches LODGE-in-browser. Second, flicker is lower both when hovering near thresholds and during bandwidth drops. Third, cut selection stays below Voyager-style tree traversal cost on phones. We reject it if either ablation performs as well as the full method, or if the cross-dissolve tile baseline matches us on both memory and JOD.
References
- WebSplatter: Enabling Cross-Device Efficient Gaussian Splatting in Web Browsers via WebGPU
- Moving beyond the desktop: prospects for practical bioimage analysis via the web
- CLoD-GS: Continuous Level-of-Detail via 3D Gaussian Splatting
- LODGE: Level-of-Detail Large-Scale Gaussian Splatting with Efficient Rendering
- LapisGS: Layered Progressive 3D Gaussian Splatting for Adaptive Streaming
- GSStream: 3D Gaussian Splatting based Volumetric Scene Streaming System
- Adaptive 3D Gaussian Splatting Video Streaming
- Voyager: Real-Time Splatting City-Scale 3D Gaussians on Your Phone
- Octree-GS: Towards Consistent Real-time Rendering with LOD-Structured 3D Gaussians
- BungeeNeRF: Progressive Neural Radiance Field for Extreme Multi-scale Scene Rendering