💻 computer science

Smol-GS: Compact Representations for Abstract 3D Gaussian Splatting

The paper presents Smol-GS, a novel method that achieves state-of-the-art storage compression for 3D Gaussian Splatting while maintaining high rendering quality by utilizing octree-derived positional encoding, entropy-based feature compression, and a recursive voxel hierarchy for coordinate encoding.

Original authors: Haishan Wang, Mohammad Hassan Vali, Arno Solin

Published 2026-03-30

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Haishan Wang, Mohammad Hassan Vali, Arno Solin

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you want to send a photo album of a beautiful, complex 3D world (like a garden, a room, or a train station) to a friend.

The Old Way (Standard 3DGS):
Currently, the best way to do this is called "3D Gaussian Splatting." Think of it like building a 3D scene out of millions of tiny, glowing, fuzzy balls (splats). Each ball has to carry a massive amount of information: its exact location, how big it is, how shiny it is, what color it is from every possible angle, and how transparent it is.

To get a high-quality picture, you need millions of these balls. The problem? The file size is huge. It's like trying to mail a library full of encyclopedias just to show a friend a single room. It takes up gigabytes of space and is slow to send or load.

The New Way (Smol-GS):
The paper introduces Smol-GS ("Smol" is internet slang for "small"). It's a clever trick to shrink that library down to the size of a single postcard without losing the picture quality.

Here is how Smol-GS works, using simple analogies:

1. The "Smart Address" System (Coordinate Compression)

The Problem: In the old method, every single ball needs a precise GPS coordinate (X, Y, Z). Storing millions of precise numbers takes up a lot of space.
The Smol-GS Solution: Imagine the 3D world is a giant building. Instead of giving every ball a unique, long address, Smol-GS uses a recursive map (called an Octree).

It divides the building into 8 big rooms.
If a room is empty, it ignores it.
If a room has balls, it divides that room into 8 smaller rooms, and so on.
The Analogy: Instead of writing down "123 Main St, Apt 4B, Room 5," it just says, "Go to the 3rd floor, turn left, go to the 2nd door." It's a much shorter, smarter way to describe where things are. This shrinks the location data massively.

2. The "Universal Translator" (Positional Encoding)

The Problem: Even with smart addresses, the balls still need to know "where they are" to look right.
The Smol-GS Solution: Smol-GS gives every ball a unique "ID code" based on its address in the map.

The Analogy: Think of this like a barcode on a grocery item. The barcode tells the computer exactly where the item is in the store without needing a huge description. This code helps the computer understand the ball's position instantly, making the system more efficient.

3. The "Abstract Artist" (Feature Abstraction)

The Problem: In the old method, every ball carries its own specific color and material data (like "this ball is red and shiny"). This is redundant because balls next to each other usually look similar.
The Smol-GS Solution: Instead of painting every ball individually, Smol-GS gives each ball a tiny, abstract "sketch" (a feature vector).

The Analogy: Imagine you are describing a forest. Instead of listing the exact shade of green for every single leaf, you tell a small AI artist: "This cluster of leaves is in a shady spot, so make them dark green and slightly wet."
The AI artist (a tiny neural network) then uses that sketch to generate the final color and shine for the ball. This means you don't need to store the final color for every ball; you just store the small "instruction sketch."

4. The "Zipper" (Entropy Compression)

The Problem: Even with the sketches, there's still some wasted space.
The Smol-GS Solution: It uses a mathematical "zipper" (entropy coding) to squeeze out any remaining redundancy.

The Analogy: If you have a suitcase full of clothes, you roll them up tight to fit more in. Smol-GS rolls up the data so tightly that it fits into a tiny fraction of the original space.

The Result: A Magic Trick

By combining these tricks, Smol-GS achieves something incredible:

Size: It shrinks the file size by 150 times compared to the original. A scene that used to be 700 MB is now just 5 MB.
Quality: Despite being so small, the pictures look just as sharp. The shadows, reflections, and glass textures are preserved perfectly.
Speed: Because the data is so small, it loads and renders instantly, even on weaker devices.

In Summary:
If standard 3DGS is like mailing a heavy, bulky box of individual bricks to build a house, Smol-GS is like mailing a tiny, lightweight blueprint and a few tools. The recipient (your computer) uses the blueprint to instantly "print" the house, saving a massive amount of space and time while looking exactly the same.

1. Problem Statement

3D Gaussian Splatting (3DGS) has revolutionized novel view synthesis by offering real-time rendering speeds and high fidelity. However, standard 3DGS suffers from massive memory footprints, often requiring gigabytes of storage to represent complex scenes with millions of Gaussian primitives.

Existing compression methods generally fall into two categories, both with limitations:

Signal-processing approaches: Quantize attributes (color, opacity) but fail to exploit local spatial correlations and repeated patterns effectively.
Learning-based approaches (e.g., Scaffold-GS, HAC++): Use "anchor-offset" hierarchies to share structure. While effective, these introduce structural overhead (transparent offsets), require complex heuristics for coordinate recovery, and often avoid compressing coordinates due to sensitivity to spatial errors.

The Core Challenge: How to achieve extreme compression (orders of magnitude smaller) while maintaining high rendering quality, without relying on heavy anchor-offset structures or sacrificing coordinate precision.

2. Methodology: Smol-GS

Smol-GS proposes a novel framework that decouples geometry (coordinates) from appearance (features), treating them with specialized compression techniques. The method consists of five integrated components:

A. Coordinate Compression: Occupancy-Octree Encoding

Instead of storing raw floating-point coordinates or using anchor offsets, Smol-GS treats coordinates as a point cloud geometry problem.

Mechanism: It recursively subdivides the scene's bounding box into an octree.
Quantization: Coordinates are quantized to the center of the finest-level octree cells (depth $R$ ). The paper demonstrates that 16-bit quantization per axis causes negligible quality loss.
Storage: Only non-empty nodes are stored. An 8-bit occupancy byte indicates which of the 8 children are occupied.
Entropy Coding: These occupancy bytes are highly sparse and are compressed using Huffman coding. This allows for lossless (within the grid) storage of coordinates with minimal overhead.

B. Positional Encoding (Octree-Derived)

To compensate for the loss of precise coordinate information due to quantization, Smol-GS introduces a unique positional encoding.

Derivation: Each splat is assigned a unique identifier based on the path taken in the octree to reach its cell.
Representation: This is encoded as a binary sequence (Morton code/Z-order index) representing the specific sub-box at each recursion level.
Function: This encoding ( $f_{oct}$ ) is fed into a small MLP ( $MLP_{oct}$ ) to provide the network with explicit spatial locality cues, enhancing representation efficiency without storing raw coordinates.

C. Neural Gaussian Splats (Abstract Features)

Instead of storing high-dimensional view-dependent attributes (like 3rd-degree Spherical Harmonics) for every splat, Smol-GS learns low-dimensional abstract features.

Feature Vector: Each splat has a compact feature vector $f \in \mathbb{R}^8$ and a scaling controller $s \in \mathbb{R}^3$ .
Decoding: During rendering, a set of tiny MLPs ( $MLP_o, MLP_c, MLP_r, MLP_s$ $M L P_{o}, M L P_{c}, M L P_{r}, M L P_{s}$ ) reconstructs the final attributes (opacity, color, rotation, scaling) by concatenating:
1. The abstract feature $f$ .
2. View direction and distance.
3. The positional encoding $f_{oct}$ .
Benefit: This "abstracts away" view-dependent cues, allowing the model to learn material properties and optical effects more efficiently than storing explicit SH coefficients.

D. Feature Compression

The abstract features and scaling controllers are compressed using Hash-grid assisted arithmetic coding.

Context: A tiny network ( $MLP_h$ ) predicts a Gaussian distribution ( $\mu, \Sigma$ ) and step sizes ( $\Delta$ ) for the features based on a spatial hash of the location.
Quantization & Coding: Features are quantized using learned step sizes and encoded using arithmetic coding. The Negative Log-Likelihood (NLL) of the quantization bin serves as the rate loss during training to minimize storage.

E. Training Pipeline

The training follows a 5-stage process to balance fidelity and size:

Warm-up: Initialize from SfM points.
Densification: Add splats in high-gradient regions.
Compaction: Prune low-opacity splats and apply $\ell_1$ regularization.
Feature Compression: Activate quantization and arithmetic coding for features.
Coordinate Compression: Activate octree quantization and coordinate coding.

3. Key Contributions

Novel Neural Splat Model: Smol-GS eliminates the "anchor-offset" overhead found in state-of-the-art methods (like Scaffold-GS), enabling direct splat-level manipulation and reducing structural complexity.
Octree-Derived Positional Encoding: A new encoding scheme that explicitly models spatial locality, allowing for efficient coordinate quantization without sacrificing reconstruction quality.
Unified Compression Strategy: Successfully compresses both coordinates (via octree/Huffman) and features (via arithmetic coding/MLP) simultaneously, achieving storage reductions of ~150x compared to vanilla 3DGS.
State-of-the-Art Performance: Achieves the best rate-distortion trade-off on standard benchmarks (Mip-NeRF 360, Tanks and Temples, Deep Blending).

4. Results

The paper validates Smol-GS on standard datasets with the following outcomes:

Compression Ratio:
- On Mip-NeRF 360, Smol-GS achieves a model size of 4.87 MB (Small variant) with a PSNR of 27.61 dB.
- This is a reduction of approximately 150x compared to the vanilla 3DGS-30K model (734 MB).
- It outperforms strong baselines like HAC++, ContextGS, and HEMGS in both size and quality.
Quality:
- Qualitative results show Smol-GS preserves sharp edges, specular highlights, and material effects (e.g., glass, flat walls) better than vanilla 3DGS, despite the massive size reduction.
- It generates fewer artifacts than vanilla 3DGS, particularly in challenging lighting conditions.
Efficiency:
- Training: ~26.58 minutes per scene (35k iterations).
- Inference: ~241 fps (real-time rendering).
- Encoding/Decoding: Fast (approx. 2-3 seconds for encoding/decoding per scene), making it practical for transmission.
Component Breakdown:
- Features ( $f$ ) take up ~50% of the size.
- Coordinates ( $x$ ) are highly efficient due to octree encoding.
- MLP weights are negligible (<1% of total size).

5. Significance and Impact

Redefining 3DGS Storage: Smol-GS proves that explicit geometry can be stored efficiently via octrees, challenging the premise that coordinates must remain uncompressed or rely on anchor offsets.
Scalability: By reducing model sizes to the megabyte range, Smol-GS enables the deployment of high-fidelity 3D scenes on resource-constrained devices (mobile, VR/AR headsets) and facilitates rapid transmission over networks.
Flexibility: The removal of anchor-offset structures allows for easier 3D editing and manipulation of individual primitives, a capability often hindered in hierarchical anchor-based systems.
Future Directions: The discrete nature of the learned features suggests potential for integration with 3D tokenization and large language models (LLMs) for semantic understanding of 3D scenes.

In summary, Smol-GS represents a paradigm shift in 3DGS compression, moving from heuristic anchor-based sharing to a principled combination of geometric octree coding and neural feature abstraction, setting a new benchmark for compact 3D representation.