Gaussian Splats Web Implementation: SOG Format, Streaming, and Compression

Research Date: 2026-01-20
Source URL: https://www.youtube.com/watch?v=ALSmVguEimA
Video Title: Gaussian Splats Are Now Web Ready
Channel: XR AI Spotlight
Publication Date: 2025-11-12
Duration: 47:05

Reference URLs

SuperSplat Editor - Open-source Gaussian splat editor
PlayCanvas Engine - WebGL game engine with splat support
Will Eastcott LinkedIn - Interviewee profile
XR AI Spotlight Newsletter - Source channel newsletter
YouTube Video - Primary source

Summary

This research note documents technical implementation details for deploying 3D Gaussian Splats on the web, based on an interview with Will Eastcott, CEO of PlayCanvas. The discussion covers three primary technical domains: the SOG compression format that achieves up to 95% file size reduction through WebP-based lossless encoding, a streaming level-of-detail system for adaptive rendering across device capabilities, and practical guidance on Gaussian count limits for web performance.

The SOG (Splat Optimized Graphics) format represents a significant advancement in splat compression by encoding Gaussian properties into WebP image channels and utilizing codebook-based quantization to preserve precision. PlayCanvas’s streaming architecture enables rendering of arbitrarily large splat scenes by dynamically loading Gaussian chunks based on camera position and device performance metrics.

Key technical constraints identified include a practical limit of approximately 4 million Gaussians for web deployment on desktop hardware, with mobile devices requiring substantially fewer. The interview also addresses the trade-offs between streaming complexity and use-case requirements, distinguishing between product visualization (where full-resolution static splats are appropriate) and large-scale environment exploration (where streaming becomes essential).

Technical Analysis

SOG Compression Format Architecture

The SOG format, developed by PlayCanvas engineer Donovan Hutchinson, achieves substantial file size reduction by leveraging WebP’s lossless compression capabilities. The format encodes Gaussian splat properties into image channels rather than traditional binary formats.

Property Encoding Schema

Each Gaussian in 3D Gaussian Splatting contains the following properties that require encoding:

Property	Description	Encoding Strategy
Position (x, y, z)	3D world coordinates	Quantized to WebP channels
Scale (sx, sy, sz)	Ellipsoid dimensions	Codebook-indexed values
Rotation (quaternion)	Orientation as 4D quaternion	Codebook-indexed values
Color (RGB)	Spherical harmonics coefficients	Direct RGB channel mapping
Opacity	Alpha transparency value	WebP alpha channel

The selection of WebP over newer formats like AVIF was deliberate. According to Eastcott, while AVIF provides superior lossy compression, WebP outperforms it for lossless compression, which is critical for splat rendering fidelity:

“As soon as you apply any lossy compression, it’s very much noticeable in the rendering artifacts. So we needed lossless compression, and this is why we’re not using AVIF.”

Codebook-Based Quantization

The SOG format employs codebook quantization to maximize precision within the available bit depth. This technique pre-computes a dictionary of commonly occurring values for properties like rotation and scale, then encodes references to these dictionary entries rather than raw values.

flowchart TD RawGaussianData[Raw Gaussian Data] --> PropertyExtraction[Property Extraction] PropertyExtraction --> PropertyTypeCheck{Property Type} PropertyTypeCheck -->|Position| Quantization[Quantization] PropertyTypeCheck -->|Rotation| CodebookLookup[Codebook Lookup] PropertyTypeCheck -->|Scale| CodebookLookup PropertyTypeCheck -->|Color| DirectRGBMapping[Direct RGB Mapping] PropertyTypeCheck -->|Opacity| AlphaChannel[Alpha Channel] Quantization --> WebPChannelEncode[WebP Channel Encoding] CodebookLookup --> WebPChannelEncode DirectRGBMapping --> WebPChannelEncode AlphaChannel --> WebPChannelEncode WebPChannelEncode --> LosslessCompress[Lossless WebP Compression] LosslessCompress --> SOGFileOutput[SOG File Output]

File Structure

The SOG format supports two packaging modes:

Bundled Mode: Single .sog file containing JSON metadata and embedded WebP images
Unbundled Mode: Separate JSON manifest file plus individual WebP image files

The unbundled mode is preferred for web delivery as it enables:

Parallel downloading of WebP chunks
HTTP range requests for partial loading
Better CDN caching characteristics

Streaming Level-of-Detail System

PlayCanvas has developed a streaming LOD system to address the fundamental constraint that web browsers cannot efficiently render arbitrarily large Gaussian counts in real-time.

Performance Thresholds

Empirical testing by PlayCanvas established the following performance boundaries:

Device Class	Maximum Gaussians	Frame Rate Target
High-end Desktop	~4 million	60 FPS
Mid-range Desktop	~2-3 million	60 FPS
High-end Mobile	~500K-1M	30 FPS
Low-end Mobile	~100K-300K	30 FPS

These figures represent practical limits where frame drops begin to occur. The streaming system addresses this by dynamically managing which Gaussians are loaded based on view frustum and distance.

Spatial Chunking Architecture

The streaming system divides splat data into spatial chunks organized in a hierarchical structure:

flowchart TD subgraph Server[Server Side Processing] FullResSplat[Full Resolution Splat] --> SpatialPartition[Spatial Partitioning] SpatialPartition --> ChunkGenerate[Chunk Generation] ChunkGenerate --> LODPyramidCreate[LOD Pyramid Creation] LODPyramidCreate --> SOGEncodeChunk[SOG Encoding per Chunk] end subgraph Client[Client Side Runtime] CameraPosition[Camera Position] --> ChunkSelectAlgo[Chunk Selection Algorithm] ChunkSelectAlgo --> DistanceCheck{Distance Check} DistanceCheck -->|Near| RequestHighLOD[Request High LOD] DistanceCheck -->|Medium| RequestMediumLOD[Request Medium LOD] DistanceCheck -->|Far| RequestLowLOD[Request Low LOD] RequestHighLOD --> AsyncDownload[Async Download] RequestMediumLOD --> AsyncDownload RequestLowLOD --> AsyncDownload AsyncDownload --> GPUBufferUpload[GPU Buffer Upload] GPUBufferUpload --> RenderFrame[Render] end SOGEncodeChunk -.->|HTTP Request| AsyncDownload

LOD Selection Algorithm

The LOD selection follows a distance-based model where chunks closer to the camera receive higher detail levels:

View Frustum Culling: Chunks entirely outside the view frustum are not loaded
Distance Calculation: Compute distance from camera to chunk center
LOD Assignment: Map distance to LOD level using configurable thresholds
Budget Management: Enforce total Gaussian count limits based on device capability
Priority Queuing: Order download requests by visual importance

The system monitors frame timing to dynamically adjust the total Gaussian budget. If frame times exceed the target (16.67ms for 60 FPS), the system reduces detail levels until performance stabilizes.

Compression Ratio Analysis

The claimed 95% file size reduction requires contextualization. Eastcott clarified that this figure represents the maximum achievable compression when comparing:

Baseline: Uncompressed PLY format with full 32-bit float precision
Compressed: SOG format with codebook quantization and WebP lossless compression

Typical compression ratios observed in practice:

Input Format	Output Format	Compression Ratio
Uncompressed PLY	SOG	90-95% reduction
Compressed PLY	SOG	40-60% reduction
SPZ format	SOG	~50% reduction

The SOG format reportedly achieves approximately 2x smaller file sizes compared to the SPZ format, which was previously considered state-of-the-art for web splat delivery.

Rendering Pipeline Integration

The SOG format integrates with web rendering pipelines through the following stages:

sequenceDiagram participant Browser participant Decoder participant GPU Browser->>Browser: Fetch SOG and WebP files Browser->>Decoder: Pass WebP to Image decoder Decoder->>Decoder: Decode to raw pixels Decoder->>Browser: Return pixel data Browser->>Browser: Extract Gaussian properties from channels Browser->>Browser: Apply codebook lookup for rotation and scale Browser->>GPU: Upload to vertex and texture buffers GPU->>GPU: Sort Gaussians by depth GPU->>GPU: Rasterize splats GPU->>Browser: Display frame

The WebP decoding step leverages the browser’s native image decoder, which is typically hardware-accelerated and highly optimized. This provides a performance advantage over custom binary decoders implemented in JavaScript or WebAssembly.

WebXR Viewer Implementation

PlayCanvas has developed a WebXR-compatible splat viewer that demonstrates several technical considerations for immersive rendering:

Stereo Rendering: Gaussian sorting must be performed per-eye for correct depth ordering
Performance Budgeting: VR requires 72-90 FPS minimum, further constraining Gaussian counts
Foveated Rendering: Potential optimization by reducing detail in peripheral vision (not yet implemented)

The viewer is available as open-source at the SuperSplat website and can be embedded via iframe or integrated directly into applications using PlayCanvas’s viewer API.

Format Adoption and Ecosystem

At the time of the interview (November 2025), SOG format support was limited to PlayCanvas. However, the format specification is documented for third-party implementation. Eastcott indicated that ecosystem adoption would follow as the format demonstrates superiority:

“At the moment it’s so new that of course PlayCanvas is the only engine that supports it. Over time we’ll see more tools in the ecosystem start to adopt this format because right now it’s just by far the best thing out there.”

The format can be generated through:

SuperSplat web editor (GUI-based export)
Command-line conversion tool (batch processing)
PlayCanvas Editor integration

Key Technical Findings

SOG Format: Achieves 90-95% compression over uncompressed PLY by encoding Gaussian properties into WebP channels with codebook-based quantization for rotation and scale values
WebP Selection: Lossless WebP outperforms AVIF for this use case; lossy compression produces visible artifacts in rendered output
Performance Ceiling: Approximately 4 million Gaussians represents the practical upper limit for 60 FPS rendering on desktop browsers
Streaming Architecture: Distance-based LOD selection with dynamic budget management enables rendering of arbitrarily large scenes by loading chunks on demand
Unbundled Delivery: Separate JSON manifest with individual WebP files enables parallel downloads and better CDN caching
WebXR Constraints: VR rendering requires per-eye sorting and stricter performance budgets, further limiting achievable Gaussian counts

Implementation Recommendations

For developers implementing web-based Gaussian splat rendering:

Target 1-2 million Gaussians for broad device compatibility
Implement streaming for scenes exceeding 4 million Gaussians or targeting mobile devices
Use SOG unbundled format for production deployments to leverage HTTP/2 multiplexing
Monitor frame timing and implement dynamic quality adjustment
Pre-process splats using SuperSplat to remove unnecessary Gaussians (backgrounds, occluded regions)

References

Gaussian Splats Are Now Web Ready - YouTube - Primary source, accessed 2026-01-20
SuperSplat - Open-source splat editor
PlayCanvas - WebGL engine with splat support
3D Gaussian Splatting for Real-Time Radiance Field Rendering - Original academic paper by Kerbl et al., SIGGRAPH 2023