A billion Gaussians in a few megabytes

Key idea A three-stage pipeline: (1) global-significance pruning by opacity $\times$ hit count $\times$ volume; (2) SH distillation—a full-SH teacher supervises a degree 3→2 student on pseudo-views; (3) VecTree quantization—Morton-order octree on positions, K=8192 codebook on lowest-significance SH, float16 on geometry.

The volume normalization (by the 90th-percentile Gaussian volume) is the load-bearing innovation: without it, the score is dominated by background blobs that cover many rays but encode no detail.

Key idea Don't just delete — redistribute. Three stages:

• Blur split: any Gaussian whose screen footprint exceeds a threshold is force-split — these are the smeared "cat hair" blobs in high-freq regions.
• Depth re-init: ray-ellipsoid intersection gives dense depth; reseed Gaussians from depth points to fill geometry holes.
• Probabilistic simplification: keep with probability $\propto$ blending weight. Preserves coverage statistics better than hard thresholding.

Key idea Train a Zip-NeRF first as both teacher and initializer; then fit Gaussians to the teacher's clean renders; finally prune by max-contribution.

Max — not sum — is essential: a Gaussian seen only from one side shouldn't be penalized; that side might be the whole reason it exists. Score $h(p_i) = \max_r \alpha_i^r \tau_i^r$ over all training rays.

Key idea Dual signal: keep Gaussian iff $|\alpha|$ AND $|\nabla\alpha|$ both exceed the $\gamma$-quantile. Low $\alpha$ = invisible; low gradient = loss no longer cares. Both low $\Rightarrow$ truly useless. Iterative prune + brief fine-tune.

Key idea Compute the log-determinant of the Hessian of the L2 loss w.r.t. each Gaussian's spatial parameters. High score = loss is sharp around this Gaussian — it really matters. $U_i = \log\det(\nabla_{x,s}I_G \cdot \nabla_{x,s}I_G^\top)$. At a converged model this equals Fisher information restricted to spatial params. One-shot 90% prune + brief fine-tune.

Key idea Budget-aware density control during training. Composite score combines positional gradient$\times 50$ + opacity$\times 100$ + blending weights$\times 50$ + distance-to-center$\times 50$ + view saliency$\times 10$ + scale$\times 25$ + coverage$\times 0.1$ + depth$\times 5$. Each round only the top-scoring Gaussians clone/split until the user budget is hit. Population never explodes.

Key idea Frame Gaussian-count reduction as a sparse optimization problem with an explicit $\ell_0$-like penalty on Gaussian "existence." ADMM-style alternating optimization. $10\text{--}15\times$ compression, no quality loss.

Key idea K-means VQ on SH coefficients and covariance, jointly with training (re-run K-means during the last 10K iters). Two codebooks: 4096 codes for color (SH), 16384 codes for covariance (scale+rotation). Position and opacity are not quantized — too sensitive. Indices Morton-sorted then RLE'd.

Adjacent Gaussians fall into the same cluster, so RLE gets long runs for free.

Key idea Drop SH entirely. View-dependent color comes from a shared Instant-NGP-style hash grid queried at the Gaussian's position + view direction through a tiny MLP. Scale & rotation get Residual VQ; opacity gets 8-bit scalar; hash-grid params get 8-bit + Huffman.

RVQ trick: a 256-code book captures coarse geometry, a second 256-code book captures the residual… 4 stages = 32 bits but expressive equivalent to a $256^4 \approx 4$-billion-entry single codebook.

Key idea Don't quantize raw attributes — quantize a learned latent, decode with a small MLP. SH color → 16-D latent; rotation → 8-D; opacity → 1-D. Position, scale, SH-DC stay full precision (too sensitive). Round latents in the forward pass; use straight-through estimator for backprop.

Analogy: VQ is a dictionary lookup; EAGLES is an autoencoder — trade a small MLP for low-bit integer latents that still cover the full attribute manifold.

Key idea Standard K-means weights all dimensions equally. But a slot whose change visibly distorts rendering should be closer to its codebook entry. Compute per-parameter sensitivity $= \partial\text{image}/\partial\text{param}$, weight K-means by it. Then quantization-aware fine-tune.

Key idea Borrow tools from MPEG point-cloud compression (G-PCC): RAHT wavelet transform, quaternion→Euler (3 numbers instead of 4), block scalar quantization + brief fine-tune.

RAHT (Region Adaptive Hierarchical Transform) is the layered wavelet from PCC standards — concentrates spatially-correlated attributes into DC + low-entropy AC residuals, like JPEG's DCT but on irregular point sets.

Key idea Don't use straight-through estimator. Instead, inject matched noise as a surrogate for the quantization step during training. Gradients flow naturally; at inference, the same codebook quantizes for real.

A small but important trick: classical VQ training has a chicken-and-egg problem (gradients can't flow through arg-min); STE is biased; matched-noise substitution is unbiased and dramatically better in practice.

Key idea Each Gaussian gets its own SH degree from {0,1,2,3}. Matte Gaussians on a wall only need degree 0 (one RGB triple); shiny ones keep degree 3. Then codebook-quantize the remainder.

Key idea Given a freshly-trained 3DGS file, compress it in seconds, no fine-tuning. Attribute-discriminative pruning + INT8/INT4 channel-wise mixed-precision quantization + online adaptation. Mobile-deployable.

Covered in PART IV. Highlight: per-Gaussian adaptive degree 0/1/2/3 + codebook quantize the rest. $\sim\!27\times$ compression at only 0.21 dB drop.

Covered in PART III. SH distillation: take the full-SH model as teacher, train a low-degree student on pseudo-view-jittered renderings. The student learns to fake the high-band specular look with limited coefficients.

Same trick as classical Hinton-style knowledge distillation, ported to view-dependent appearance.

Covered in PART IV. Drop SH entirely; view-dependent color comes from a shared hash grid + tiny MLP. Per-Gaussian SH cost: 0 floats. Shared: ~30 MB hash grid + ~100 KB MLP, amortized over millions of Gaussians.

Effectively = NeRF appearance + 3DGS geometry. The cleanest fusion of the two worlds.

Key idea Swap the primitive: $\exp(-x^2)$ → $\exp(-|x|^\beta)$ with learnable $\beta$. Sharper edges need fewer primitives → indirectly saves SH.

Strictly speaking this isn't SH compression — it's "primitive redesign that shrinks the SH footprint as a side effect." Often filed with SH methods but really belongs to the compaction axis.

Key idea Treat the giant $(N_\text{gaussians} \times N_\text{attr})$ matrix as low-rank. CP decomposition (rank $\sim\!16$) reconstructs each Gaussian's attributes from a few axis-wise factor vectors.

The TensoRF lineage: a 3D tensor factorizes as a sum of outer products of 1D vectors. For 3DGS, the tensor is "Gaussian $\times$ attribute"; rank is much smaller than either dimension.

Key idea Replace 48 SH coefficients with ~10 Spherical Gaussian lobes. An SG is $\exp(\lambda(\mathbf{d}\cdot\boldsymbol\mu - 1))$ — a directional Gaussian on the sphere centered at $\boldsymbol\mu$ with sharpness $\lambda$.

SH is a global basis (each band has support over the whole sphere); SGs are local (each lobe only lights up near its center). For typical appearance (few highlights, mostly diffuse), SGs are a much more compact representation.

2000s graphics already used SGs for precomputed radiance transfer (Tsai & Shih 2006); this is the rediscovery in the 3DGS era.

Key idea Plot the SH AC coefficient histogram. It's almost exactly Laplace. So just fit a Laplace, arithmetic-code under it. No context model, no MLP — just a closed-form distribution.

Other attributes (rotation, scale, opacity) use Gaussian mixtures. Per-Gaussian distribution parameters drive the arithmetic coder.

Key idea Don't store each Gaussian. Scatter sparse anchors on a voxel grid; each anchor carries a feature vector (e.g. 32-D) and $k$ learnable offset vectors (e.g. $k=10$). At render time, an MLP takes (anchor feature, view direction, view distance) → predicts opacity, color (no SH — direct RGB), scale, rotation of $k$ neural Gaussians at anchor_pos + offset_i. Anchors grow/prune dynamically during training.

Stored on disk: anchor positions + features + scaling + $k$ offsets + MLP weights (~few hundred KB). Regenerated at render time: every Gaussian's attributes.

View-dependent trick: the MLP takes view direction as input — no SH needed. That's why Scaffold-GS often improves PSNR: the MLP expresses smoother view-dependence than degree-3 SH.

Key idea Put Scaffold-GS anchors in an octree; choose fractional LOD per pixel based on camera footprint. Distant pixels decode only coarse levels. Cumulative LOD across octree levels; a learnable per-anchor LOD bias supplements high-freq regions.

Key idea Organize Gaussians into trees: leaves store rapidly-varying attributes (position, opacity) explicitly; internal nodes hold shared features that an MLP decodes into smoothly-varying attributes (rotation, scale, color) for many leaves.

The clean pedagogical statement: store what varies a lot, share what varies smoothly.

Key idea Replace per-Gaussian attributes with a multi-level tri-plane (three 2D feature grids); a tiny MLP decodes each Gaussian by position lookup. The tri-plane is a 2D smooth field, designed to be compressible by off-the-shelf image codecs. Positions are stored separately for lossless coding.

Key idea Two kinds of primitives: a few anchor primitives with full geometry + many coupled primitives that store only tiny residuals predicted from the anchor. Rate-distortion loss $\lambda R + D$ + hyperprior Gaussian entropy models drive quantization.

Exact video codec analogy: anchors = I-frames, coupled = P-frames, only delta stored.

Key idea Compact representation around octree positional encoding + learned per-splat features. Recursive voxel hierarchy for coordinates; entropy-based feature compression. Mip-NeRF 360: 4.87 MB / 27.61 PSNR — among the smallest reported in late 2025.

Key idea Take Scaffold-GS anchors. Jointly train a multiresolution binary hash grid. Each anchor queries the hash grid at its position → feature; a tiny MLP_c outputs $(\mu, \sigma)$ of a Gaussian distribution for each attribute; arithmetic-code the anchor under that predicted distribution.

This is the learned image compression framework (Ballé 2017/2018) ported to 3DGS — hash grid = hyperprior, MLP translates hyperprior into per-anchor distribution. The entropy is explicitly minimized as a training loss ($\lambda R + D$).

"Binary" = hash grid values quantized to $\{-1, +1\}$ — the hyperprior itself is essentially free.

Key idea On top of HAC: (1) intra-anchor context — the $k$ sibling Gaussians of one anchor predict each other; (2) per-attribute adaptive quantization; (3) a learnable mask drops useless Gaussians during training.

Intra-anchor fills HAC's gap: the $k=10$ Gaussians from one anchor are obviously correlated (shared parent feature), but HAC didn't exploit it. HAC++ adds autoregressive coupling among siblings on top of the hash-grid prior.

Key idea Where HAC predicts each anchor from a hash-grid feature, ContextGS predicts each anchor from its already-coded neighbors. Like PixelCNN for 3D anchors.

Split anchors into hierarchical levels (coarse → medium → fine). Coarsest first, coded under a small hyperprior. Once decoded, those anchors serve as context for the next level's distribution, arithmetic-coded. And so on. Directly exploits inter-anchor spatial redundancy — which HAC exploits only indirectly via the hash grid.

Key idea Lay 3DGS attributes on 2D feature planes; run HEVC — the same codec that streams Netflix. Get 25 years of video-codec engineering for free, with hardware decoders included.

HEVC has intra prediction, transform coding, CABAC, rate control — why reinvent? Train the feature planes to be HEVC-friendly (frequency-domain entropy model aligned with what HEVC will do).

Key idea Every method above re-trains a neural codec on each new scene (minutes per scene). FCGS doesn't: a single pretrained network compresses any 3DGS scene in one forward pass — ~1 second per 100K Gaussians.

Entropy module is a 3-component Gaussian Mixture conditioned on: (1) hyperprior $h$ (coarse scene-wide latent), (2) inter-Gaussian context $s$ (grid-interpolated from already-decoded Gaussians), (3) intra-Gaussian context $c$ (within-Gaussian channel chunks). Multi-path entropy module routes each attribute to a different rate-constraint path.

Key idea One bitstream, multiple decode quality levels. Clients can stop early for a decent preview; reading more refines. Progressive JPEG for 3DGS.

Progressive anchor masking (add anchors as you decode more) + progressive quantization (step size shrinks as more bits arrive). Single training, multiple bitrates extractable at decode time.

Key idea Sort Gaussians along a Morton (Z-order) curve: nearby in the bitstream $\Leftrightarrow$ nearby in 3D. Then exploit the resulting coherence with a neural field + adaptive SH bandwidth.

Key idea Sort $N$ Gaussians onto a $\sqrt N \times \sqrt N$ 2D grid so that grid-neighbors have similar attributes. Each attribute (position-x, scale-y, SH-coeff-k…) becomes a smooth 2D image. Save with PNG/JPEG-XL/WebP/AVIF — let the image codec do the entropy coding.

Sorting algorithm: PLAS (Parallel Linear Assignment Sorting) — a custom GPU algorithm that assigns $N$ high-D vectors to a 2D grid in seconds, optimizing local smoothness.

The most pedagogically elegant idea in the whole field. Make the unstructured problem structured; existing tools solve it.

Key idea SOG productionized. Each attribute is a WebP texture bundled in an archive. Decoded natively by the browser; loaded straight to the GPU in Morton order.

SOG v2 (late 2025) adds: Morton ordering for GPU-friendly loading, WebGPU-only encoder (no CUDA needed to write .sog), single self-contained archive.

Key idea Quantize each attribute to small int range. Gzip the whole blob. Done.

The deliberately-simple alternative to SOG:

• 16-bit fixed-point positions
• quantized quaternion / scale / opacity
• preserves full degree-3 SH (many compressed formats don't)
• final gzip pass

SPZ 4 (May 2026) adds: vendor extensions, $\sim\!3\text{-}5\times$ faster encode, $\sim\!1.5\text{-}2\times$ faster decode.

Key idea A "trimmed PLY" binary: 8-bit SH, struct layout matching the Three.js renderer's internal Gaussian. Load bytes, point a buffer view, render — zero transformation.

Multiple compression levels; the most aggressive 8-bit-quantizes SH. Emphasizes decode speed over absolute size.

Key idea The first cross-vendor 3DGS-in-glTF standard. SPZ is the official compression payload; design is algorithm-agnostic so future codecs can drop in.

Two extensions:

1. KHR_gaussian_splatting defines the uncompressed structure: position, rotation, scale, opacity, SH split into diffuse (deg 0) + specular (deg 1-3).
2. KHR_gaussian_splatting_compression_spz wraps SPZ-compressed blobs as glTF buffers.

Backed by Niantic, Cesium/Bentley, Esri, OGC, and Khronos. The analog of the moment JPEG got written into a web spec.

Key idea The same standards body that gave us MPEG-2 and HEVC now treats 3DGS as a first-class media type. Goal: interoperable ISO codec, with HEVC/VVC as starting points. Reference standard expected 2027-2028.

Key idea Aggressive training-free pruning (UGC) + mask-guided one-step diffusion (GaussPainter) restores renders. Real-time inference. $100\times$ compression, 354 MB → 3.31 MB.

Key idea Push to $1000\times$ by destroying most detail, then resurrecting with an artifact-aware one-step diffusion decoder. The line between compression and synthesis blurs.