splats4D: A Streamable 4D Gaussian Splatting Format

Overview

splats4D is a novel 4D Gaussian splatting format designed for high-efficiency compression and streaming of dynamic 3D scenes. It achieves compression ratios between 16–58× smaller than raw data and 14–20× smaller than gzip, with encoding speeds of approximately 640 MB/s. The format is specifically engineered for delivery via object stores (such as S3, GCS, or R2) using HTTP Range requests, allowing for instant first-view rendering and rapid seeking without the need for server-side logic or manifest files.

Compression Architecture

The .splat4d format reduces file size by separating static and dynamic elements and employing a temporal delta-encoding strategy.

Static and Dynamic Split

To minimize redundancy, the format classifies splats as static if a single quantized value satisfies the user-defined error bound across the entire clip. These static splats are stored once, meaning the background of a large sequence can be reduced to a few megabytes regardless of the length of the clip.

Deadband "Hold" Tracks

To prevent quantization flicker and reduce temporal deltas, splats use a "hold" mechanism. A stored value only changes when the actual value violates the user-defined bound against the current stored value. This ensures that temporal deltas remain mostly zero and maintains a strict guarantee of accuracy before every emitted symbol.

GOP Structure and Seeking

Borrowing from H.265, the format uses closed Groups of Pictures (GOPs). Keyframes (absolute quantized values) are stored every N frames, followed by P-frames consisting of exact integer deltas. Because each GOP chunk decodes independently, seeking does not require processing previous chunks. Key streams are positioned before delta streams within each chunk, allowing a client to fetch only the first ~10% of a chunk to display a keyframe instantly.

Entropy Stack

The final compression pipeline utilizes Morton-ordered splats, zigzag-coded integer deltas, a Blosc-style byte-plane shuffle, and zstd compression per stream. This process brings the output size close to the order-0 entropy of the symbol streams.

Deterministic Error Bounds

Unlike formats that rely on PSNR or average error, splats4D uses SZ/ZFP-style error-bounded quantization. This ensures that every attribute of every splat in every frame is within a deterministic, pointwise bound of the source.

Attribute	Bound	Default
Position	± millimeters, Lⁿ per axis	±2 mm
Color RGB	± 8-bit levels per channel	±4/255
Opacity	± 8-bit levels	±4/255
Rotation	± quaternion component	Exact (±0)
Scale	± relative %, per axis	±2%

Streaming and Object Store Integration

The format is designed for plain HTTP Range requests. A client can render a scene by performing a small number of targeted fetches:

1. Header: Fetch the first 256 KB to retrieve the magic number and header JSON containing byte offsets.
2. Static Section: Fetch the static splats to render the complete first view.
3. GOP Chunks: Fetch the corresponding GOP chunk during playback or prefetch.
4. Seeking: Fetch the chunk-prefix range to display a keyframe in approximately 100–150 ms.

Performance Benchmarks

Across eight sequences from pipelines including Dynamic 3D Gaussians and Neu3D, splats4D consistently outperforms generic compression. In one example, a 2-second "flame" scene was reduced from 427 MB (raw) to 18.5 MB, a 23.2× reduction.

Sequence	Frames × Splats	Raw Size	Gzip Size	splat4d Size
Birthday	40 × 659k	844 MB	724 MB	40.7 MB (20.7×)
Boxes	40 × 351k	450 MB	423 MB	27.2 MB (16.5×)
Flame	40 Ó 334k	427 MB	367 MB	18.5 MB (23.2×)
Juggle	150 Ó 337k	1616 MB	1515 MB	83.4 MB (19.4×)
Sear	40 Ó 109k	16.9×	8.2 MB
Softball	40 Ó 336k	430 MB	404 MB	25.9 MB (16.6×)
Tennis	40 Ó 333k	426 MB	401 MB	26.2 MB (16.3×)

Implementation

The project is MIT licensed and provides a Python package (pip install splats4d) for encoding time series of .splat frames into a single .splat4d file. The viewer is a port of the antimatter15/splat renderer, supporting WebGPU with a WebGL2 fallback.