Locality-aware Gaussian Compression for Fast and High-quality Rendering
Authors: Seungjoo Shin
Jaesik Park
Sunghyun Cho
Venue: ICLR 2025 Poster (2025)
Keywords: point-based rendering
neural fields
compression
Primary area: applications to computer vision, audio, language, and other modalities
TL;DR: We propose a locality-aware 3D Gaussian representation with highly compact storage size.

Abstract: We present LocoGS, a locality-aware 3D Gaussian Splatting (3DGS) framework that exploits the spatial coherence of 3D Gaussians for compact modeling of volumetric scenes.
To this end, we first analyze the local coherence of 3D Gaussian attributes, and propose a novel locality-aware 3D Gaussian representation that effectively encodes locally-coherent Gaussian attributes using a neural field representation with a minimal storage requirement.
On top of the novel representation, LocoGS is carefully designed with additional components such as dense initialization, an adaptive spherical harmonics bandwidth scheme and different encoding schemes for different Gaussian attributes to maximize compression performance.
Experimental results demonstrate that our approach outperforms the rendering quality of existing compact Gaussian representations for representative real-world 3D datasets while achieving from 54.6$\times$ to 96.6$\times$ compressed storage size and from 2.1$\times$ to 2.4$\times$ rendering speed than 3DGS. Even our approach also demonstrates an averaged 2.4$\times$ higher rendering speed than the state-of-the-art compression method with comparable compression performance.

Published as a conference paper at ICLR 2025
LOCALITY-AWARE GAUSSIAN COMPRESSION FOR FAST AND HIGH-QUALITY RENDERING
Seungjoo Shin' Jaesik Park2 Sunghyun Cho!
1POSTECH SSoul National University
github. wtcchuu..o/Loooooo
ABSTRACT
We present LocoGS, locality-aware 3D Gaussian Splatting (3DGS) framework that exploits the spatial coherence of 3D Gaussians for compact modeling of vol- umetric scenes. To this end, we first analyze the local coherence of 3D Gaus- sian attributes, and propose novel locality-aware 3D Gaussian representation that effectively encodes locally-cohere representation with minimal storage requirement. On top of the novel represen- tation, LocoGi is carefully designed with additional components such as dense initialization, adaptive spherical harmonics bandwidth scheme and differrnnt encoding schemes for different Gaussian attributes to maximize compression per- formance. Experimental results demonstrate that approach outperforms the rendering quality of existing compact Gaussian representations for representative real-world 3D datasets while achieving from 54.6x 96.6x compressed storage size and from 2. x to 2.4x rendering speed than 3DGS. Even our approach also demonstrates averaged 2.4x higher rendering speed than the state-of-the-art compression method with comparable compression performance.
Gaussian attributes using neural field
INTRODUCTION
Advances in 3D representations have enabled the evolution of novel-view synthesis, which aims to model volumetric scenes render photo-realistic novel-view images. Neural Radiance Field
(NeRF) (Mildenhall et al.] 2021). and its variants have demonstrated impressive performance in neural rendering from a set of RGB images and corresponding camera parameters. The advance- ments of radiance fields mainly focus on improving rendering quality (Zhang et al., 2020) Barron
al.
2021 2022 2023), accelerating convergence speed (Fridovich-Kol al. [2022] Chen al.,
2022
Müller et al. 2022 Sun et al. 2022) and boosting rendering speed (Yu et al.
Hedman
jet al.
X021|Chee et al.] 2023; Reiser al. 2023).
Recently, 3D Gaussian Splatting (3DGS) (Kebb et al. 2023 proposes efficient point-based 3D representation that represents volumetric scenes using explicit primitives known as 3D Gaussians. While existing radiance fields have encountered the trade-off between rendering quality and render- ing speed for practical utilization, 3DGS has emerged as a promising 3D representation with notable advantages over previous methods, including high rendering quality and real-time rendering speed.
Despite its outstanding performance, 3DGS demands considerable storage costs due to the necessity explicitly store numerous Gaussian parameters. In particular, representing single 3D scene quires a large number of Gaussians, potentially millions, especially for complex scenes, while each Gaussian consists of several explicit attributes, including position, color, opacity, and covariance, As result, the storage size can easily exceed 1GB. Therefore, there is a growing need for compact 3DGS representation that requires a small storage size for practical 3D representation.
To resolve the excessive storage requirement of 3DGS, several attempts have recently been made such as pruning techniques that prune less-contributing Gaussians (Lee et al. 2024 Fan et al. 2023] Girish et al. 2023). Quantization techniques have also been introduced to reduce storage require-
ments by representing Gaussian attributes through discretized data representations (Navaneet et al.
2024 Lee et al.; 2024, Niedermayr et al. 2024 Girish et al. 2023 Fan et al. 2023). However, despite the remarkable compression performance, excessive quantization beyond a certain thresh- old significantly degrades rendering quality their compression is performed solely based the

---

Published as a conference paper at ICLR 2025
global distributions of the attribute values without considering local contexts. Another noticeable line of work is anchor-based approaches (Lu et al., 2024; Chen et al. 2024). These approaches demonstrate outstanding compression ratio and rendering quality by adopting view-adaptive neu- ral Gaussian attributes, and a novel rendering scheme that decompresses neural Gaussian attributes and renders Gaussians together in unified rendering pipeline. Despite their remarkable compres- sion performance, their rendering scheme requires up to 30% additional rendering time compared to 3DGS, which makes them less practical for applications that require high-speed rendering, e.g.. rendering of large-scale scenes on mobile device.
To achieve high compression performance while maintaining the rendering efficiency of the 3DGS rendering pipeline, in this paper, we present LocoGS, novel locality-awar compact 3DGS frame- work. As will be presented the analysis in Section 4.1, Gaussians exhibit strong local coherence across nearby Gaussians. Inspired by this, our framework introduces a novel 3D Gaussian repre- sentation that leverages the spatial coherence of Gaussians. Our representation exploits a grid-based neural field representation that allows compact modeling of continuous physical quantities in vol- umetric scenes (Chen et al.] 2022 Müller et al. [022] Tang et al., 2022). Specifically, our rep- resentation encodes locally coherent Gaussian attributes into multi resoluiinn hash grid (Müller et al. 2022) that enables a sparse voxel-grid representation to characterize the sparsely distributed structure of point- representation. Unlike anchor-based approaches, our representation allows the usage of the original 3DGS rendering pipeline without any modification, thus maintaining the rendering efficiency of the original pipeline.
Besides the locality-aware 3D Gaussian representation, our framework also adopts several compo- nents to minimize the storage requirement and enhance the rendering speed and quality. Specifically, our framework adopts dense point cloud initialization, Gaussian pruning, an adaptive spherical har- monics (SH) bandwidth scheme, and quantization and encoding schemes specifically tailored for different Gaussian attributes. Combining all of these, our approach successfully outperforms the ren- dering quality of existing compact Gaussian representations while achieving from 34.6x to 96.6x compressed storage size and from 2.1x 2.4x rendering speed than 3DGS, Our approach also demonstrates an averaged 2.4x higher rendering speed than HAC (Chen et al. 2024), the state-of- the-art compression method, with comparable compression performance.
We summarize our contributions as follows:
We introduce LocoGS, locality-aware compact 3DGS framework that leverages the local coher- ence of 3D Gaussians to achieve high compression ratio and rendering speed.
To this end, we analyze the local coherence of Gaussians, which has been overlooked by previous work, and present a locality-aware 3D Gaussian representation.
On top of the novel representation, LocoGS is carefully designed with additional components such as dense initialization, Gaussian pruning, an adaptive SH bandwidth scheme, and quantization and encoding schemes for different Gaussian attributes maximize compression performance.
Experimental results show that LocoGS clearly outperforms existing approaches in terms of com- pression performance and rendering speed.
2 RELATED WORK
Neural Radiance Fields and Compact Representation Neural fields have emerged as a domi-
nant representation for various continuous signals, including images (Dupont et al.) 2021 Strümpler
et al. 2022), signed distances YYu et al.] [2022] Wang et al. 2023), and 3D/4D scenes (Mildenhall
let al.
2021 Barron et al. 2021 2022; Müller et al. 2022). In particular, Neural Radiance Fields
(s (Mildenhall et al. 2021) have revolutionized the domain of neural rendering. exhibiting
a remarkable ability to represent volumetric scenes. Recently grid-based explicit representations
have been adopted to encode local features and exploit them to model 3D scenes (Chen et al. 2022
Sun et al. 2022] Müller et al. 2022). Despite the outstanding performance, they yield limitations regarding the heavy storage burden. To address this issue, several approaches exploit efficient grid structure (Chen et al., 2022: Müller et al. 2022). pruning (Fridovich-Keil et al. 2022 Rho et al.) 2023), and quantization Takikaawa et al.] 2022 Shin & Park| (024) to further consider efficiency in in terms of storage. Although compact neural radiance fields significantly reduce storage costs, the persistent issue of slow rendering speed remains a limiting factor to becoming a practical 3D repre- sentation. In this paper, we aim to accomplish real-time rendering via efficient point-based rendering while leveraging the compactness of neural fields to attain high rendering quality.
2

---

Published as a conference paper at ICLR 2025
3D Gaussian Splatting and Compact Representation While 3DGS (Kerbl et al. 2023) achieves real-time rendering and remarkable reconstruction performance, it requires excessive storage space due to the large quantity of 3D Gaussians needed for single scene and the several explicit attributes necessary for each Gaussian. To address this issue, several 3D Gaussian compression approaches have been proposed, which can be categorized into global-statistic-baees and locality-epploiting approaches. Soobal-statsstic-aassee approaches do not leverage the local coherence of Gaussian at- tributes but rely on global statistics for quantization-basel compression (Navaneet al. 2024 Fan
et al., 2023 Girish et al. 2023) and segee-oode-bbsse compression Morgenstern et al. (023). eocality-xplooting approaches include C3DGS (Niedermayr et al., 2024). Compact-3DGS (Lee)
et al. 2024). and based methods (Lu et al. 2024] Chen et al.] 2024). These approaches
exploit the local coherence of Gaussian attributes to reduce storage size. However, they still only partially exploit locality, resulting in limited performance compared to our method.
C3DGS (Niedermayr et al.) 2024) sorts Gaussian attributes according to their positions along a space-filling curve, placing spatially close Gaussians nearby positions in the sorted sequence. This enables subsequent compression steps to exploit local coherence. However, projecting 3D Gaussians to ID sequence along space-filling curve cannot fully leverage the local coherence of Gaussian attributes. Compact-3DGS (Lee et al. 2024) uses a hash grid to encode view-dependent colors and vector quantization for geometric attributes such as rotation and scale. While it achieves a noticeable 81.8x compression ratio for color, it only achieves a 5.5x compression ratio for vector-quantized attributes, as exploits global statisties instead of local coherence.
Anchor-based methods like Scaffold-GS (Lu et al., 2024) and HAC (Chen et al., 2024) also ex- ploit local coherence. Scaffold-GS uses an anchor- pottborr-pnt--bseddd representation, where each anchor point encodes multiple locally-adjacent Gaussians with attributes changing based on the viewing direction. However, it focuses on rendering quality rather than compression and requires computa- tionally expensive per-view processing. HAC builds on Scaffold-GS by incorporating hash grid for compression, but unlike our method, it encodes only the context of anchor point features. Despite its high rendering quality and compression ratio, HAC requires slow per-view rendering due to its anchor-point-assed representation.
Our approach also belongs to locality-exploiting approaches. In contrast to previous methods that partially exploit locality, our approach fully leverages the locality of all Gaussian attributes, includ- ing color and geometric attributes, for superior compression performance. To this end, we present an analysis of the local coherence of Gaussian attributes and propose a novel locality-based 3D Gaussian representation that directly encodes local information in an effective grid-based structure. Furthermore, our representation allows the use of the original 3DGS rendering pipeline, providing high rendering speed compared to anchor-based methods.
PRELIMINARIES: 3D GAUSSIAN SPLATTING
In this section, we briefly review 3DGS (Kerbl al. 2023), which LocoGS is built upon. 3DGS represents a volumetric scene using number of 3D Gaussians, each of which is semi-transparent point-like primitive in a 3D space whose shape is defined by a 3D Gaussian function and whose color changes in view-dependent way. Formally, a 3D Gaussian G can be defined as set of its attributes, i.e., G = (p. O, S, r, k), where p E R is a position, o E [0, 1] is an opacity, s E RR3 is a scale vector, and E R is quaternion-basee
rotation vector. k (k", ..... k)) is SH coefficients where k' (2(+1) is the SH coefficient of degree I, and L is the maximum degree of the SH coefficients, which is commonly set to to achieve sufficient quality (Kerbl et al. 2023). The opacity of 3D Gaussian a 3D coordinate E R is defined as:
a (x 9) = exp (-2 (x -x-xx
(1)
where Σ = RSST R is a 3D covariance matrix, R is rotation matrix defined by r, and S is scaling matrix defined as S = diag(s). Given a viewing direction d, the depedeennndnnt color of 3D Gaussian G is computed as:
L c(d: 9) = k + Σ Hd)
(2)
1=1
where H; is the SH function for the degree l.
3

---

Published as a conference paper at ICLR 2025
begle/m-11 11
logy
Opecity
Roale
Rosisiion
Base color
Residual SHz
Dercty
Denstyy
Denaity
Euclidean disance
Euciddan destncc
Eud dean distance
Euciidean 1.0
Ocasity
Scale
Rozation
Base
Resicual Sids
E: 0M00n ditunoo
1.0
Sparie dadenzm (04b
Spstal didarno (aga)
Spotad dirbence (ogu)
Spurs dodenca
Spsial cidaaron (Rgg)
Figure 1: Evaluation of the local coherence of Gaussian attributes. We visualize histograms of the Euclidean distances of Gaussian attributes (top), and bar graphs of the average Euclidean distances of Gaussian attributes (bottom) between two Gaussians at different spatial distances. The yellow histograms and bar graphs correspond to the largest spatial distances, while the pink ones correspond to the smallest spatial distances.
The 3DGS method (Kerbl et al, 2023) reconstructs a target 3D scene from a collection of images by optimizing set of 3D Gaussians. Once optimized, these 3D Gaussians can be projected to render novel-view images from any desired viewpoints. The optimization process begins with initializing the attributes of Gaussians employing sparse points from Structure-from- from-Motion (SfM) (Schon- berger & Frahm 2016). Precisely, the positions p. scales 8, and base colors k" are initialized based on the SiM-estimated points, while the other attributes are initialized as constants. The initialized attributes are then optimized to minimize the difference between the input images and the 2D ren- derings from the Gaussians. However, the initial number of Gaussians may not be sufficient to ac- curately represent the details in a complex well-wrldd scene. Therefore, during the optimization pro- cess, additional Gaussians are introduced by cloning small Gaussians and splitting large Gaussians into smaller ones, thereby achieving high-quality 3D reconstruction.
LOCALITY-AWARE 3D GAUSSIAN REPRESENTATION
4.1 ANALYSIS ON THE LOCAL COHERENCE OF 3D GAUSSIANS
Before introducing our locality-aware 3D Gaussian representation, we first analyze the local co- herence of 3D Gaussians. For the analysis of the local coherence of Gaussians, we examine each Gaussian attribute reconstructed from widely used benchmark datasets. To this end, we apply 3DGS (Kerbl et al., 2023) to all the scenes from widely used benchmark datasets: Mip-NeRF 360 (Barron et al. 2022). Tanks and Temples (Knapitsch et al.] (017), and Deep Blending (Hed- man et al. 2018 and obtained 3D Gaussians G = (G For each 3D Gaussian G,, sample the neighboring Gaussians G neighhor within a spatial distance d E R as Gneightorr = b where
lIp 1 [-=-- < d and K, denotes set of Gaussian indices neighboring the i-th Gaussian G. Specif- ically, we bound the position within [0, 1] using the contraction function from Barron et al. (2022). Then, we compute the Euclidean distance of each attribute between G; and its neighboring Gaussians G meightarr Among them, we randomly sampled 100K pairs of Gaussians for each scene and computed their Euclidean distances.
Fig. visualizes the Euclidean distances between two Gaussians with various spatial distances. It illustrates that, regardless of the spatial distances, all histograms have high peaks at small Euclidean distances, while their shapes become flatter as the spatial distances between Gaussians increase. The graphs demonstrate that spatially adjacent Gaussians have smaller Euclidean distances between their attributes. This local coherence among Gaussians is analogous to the pixel value coherence in natural images. Just as natural images display local color coherence, Gaussian attributes such as base color, SH coefficients, and opacity are often similar among adjacent Gaussians, Additionally,
4

---

Published as a conference paper at ICLR 2025
the scale and rotation of Gaussian are influenced by the local texture patterns and the underlying geometry, which are spatially coherent in natural images. Overall, our analysis demonstrates that Gaussian attributes possess significant local coherence.
4.2 LOCALITY-AWARE 3D GAUSSIAN REPRESENTATION
Our main idea for a compact representation is to represent high-dimensional attributes, which are originally stored in an explicit form, using neural field that supports a compact representation of spatially-coherent quantities. To this end, for a given 3D Gaussian primitive G, we decompose its
attributes into two groups, i.e., G = (gexplicit gimplicit) where gexplicit and Gimplicir are the explicit attribute and implicit attribute, which are defined as:
(3) respectively, In Eq. 3 is a base scale attribute, and $ is a normalized scale attribute such that s = 78. k" is the base color of Gaussian G. which the zero-frequency component of the SH coeffi- cients, and k l: denotes the residual SH coefficients. Our representation stores gexplisir in an explicit form for each G. On the other hand. Gimplicit is stored in a compact neural field leveraging their local coherence to minimize the storage requirement. Specifically, we model Gimplicit as G Gimplicit = F(p) where F is neural field so that we can retrieve the implicit attribute Gimplicit for a given Gaussian primitive G using its position. For the neural field F, we adopt the multi- restuiiooolotinn hash-grid ap- proach (Müller et al. 2022). Specifically, F consists of a multi-resolution hash grid by followed by tiny multi-layer perceptrons (MLPs) θ, where 0 is the parameter of Φ
Gimplisir (,,,,,r,k"), gexplicit (p, 7,,,k' k)), and
We categorize the attributes into the explicit and implicit attributes to facilitate the 3D Gaussian opti- mization process while minimizing the storage requirement. As discussed in Section 3 the optimiza- tion process involves operations that directly manipulate the attribute values of Gaussian primitives such as initialization, cloning, and splitting, which are challenging with neural field representa- tion. Thus, gesplicit consists of the essential attributes that need to be stored in an explicit form to support direct manipulation despite that the explicit attributes also exhibit local coherence as shown in Section 1.1 while gimplicit consists of the remaining attributes for compact storage.
Fig. 2 iillustrates an overview of our representation. Given a Gaussian primitive G, we retrieve a local feature f corresponding to its implicit attribute by feeding its position p. i.e., f = interp(p. &a) where interp is tri-linear interpolation operator. The local feature f then fed to the MLP of each of the attributes: normalized scale s, rotation opacity o, and the residual SH coefficients ''... Finally, combining y with š and r, we obtain the covariance matrix of the Gaussian G. Similarly, by concatenating k0 and kL:,, we obtain the full SH coefficients k of G. To represent unbounded scenes using our representation, we adopt the coordinate contraction scheme of Barron et al. (2022) for the neural field representation F.
Adaptive SH Bandwidth To further boost the rendering speed and quality of Gaussians, our framework adopts an adaptive SH bandwidth scheme inspired by WWang et al. (2024), where each Gaussian has different number of SH coefficients. Specifically, for a Gaussian G. its SH coeffi- cient k is defined as k k.d where E {0, ... ,I,} an additional attribute of 9. which in- dicates the SH bandwidth, scheme, we redefine the explicit and implicit attributes in Eq. (3) as gexplicil = (p. 7, kD 6) and gimplisit (o, r, kl:b),, respectively, where b in gexplicit requires additional two bits for L = 3. While the adaptive SH scheme introduces a slight increase in the storage requirement, it greatly improves the rendering speed a huge portion of surfaces in natural scenes are close Lambertian surfaces whose colors do not change regardless of the view direction. Furthermore, it also improves the quality as it provides additional regularization on the colors of Gaussians.
the maximum degree of the SH coefficients. Based on the adaptive
LocoGS FRAMEWORK
Fig. iilustrates the compression and decompression pipeline of LocoGS based on the locality-
3D Gaussian representation. Given collection of input images of a target scene, our compression pipeline first performs the LocoGS representation learning step learn compact representation of the target scene, and further compresses the learned attributes through quantization and encoding. For decompression, our approach performs decoding and dequantization to reconstruct LocoGS representation. Then, from the LocoGS representation, it reconstructs a conventional Gaussian rep- resentation that stores all the attributes in explicit form for efficient rendering.
5

---

Published as a conference paper at ICLR 2025
M Scale
7
S
Bese scale
Scale
Σ
P Rotaton
Covariance
P Position
f
1+2
Pm Opacty
Local feoture
Q
Opaciy
k" Base
Hash grid
k
1:L
k
Points with explicit attributes
DPC
MLPs
SHs
SHS
3D Gaussians
Figure 2: Overview of our framework: locality- 3D Gaussian representation.
Note that, in contrast to anchor-based methods (Lu et al. 2024 Chen et al. 2024), the decompression process of LocoGS reconstructs a conventional 3D Gaussian representation, which requires no alter- ations to the original 3DGS rendering pipeline that would compromise efficiency. Moreover, due to the high quality of our representation, we are able to more aggressively prune the cess-contributing Gaussians while still preserving rendering quality on par with prior methods, thereby enhancing the rendering speed. In the following, we describe each step of our compression pipeline in detail.
5.1 LOCALITY- 3D GAUSSIAN REPRESENTATION LEARNING
To build compact 3D Gaussian representation, we follow the optimization process of 3DGS (Kerbl et al. 2023) with a slightly modified loss. Specifically, we optimize loss L defined as:
== - (1 + ALSSIM + Amask + SSH <
(4)
where L1 and LSSI represent Li loss and SSIM loss between images rendered from the compressed representation and their corresponding input images, respectively, both of which are bor- rowed from 3DGS. Lmask is a mask loss introduced by Lee et al. (2024) for pruning less- less-contributing Gaussians during the optimization. Also, CSII is SH mask loss to restrict the maximum SH degree for each Gaussian. These mask losses will be further discussed later. X, Amask and Amisk are balanc- ing weights. We optimize and hash grid be and MLPs θ that encode implicit attributes Gimplicit Additionally, we adopt mask parameters f and 7 for each Gaussian to prune costribbtii Gaussians and select adaptive the SH bandwidths, optimizing L with respect μ and r7 as well.
loss L with respect to the explicit attributes Gexplicit 3D Gaussians,
Gaussian Pruning The densification strategy of the 3DGS (Kerbl et al. 2023) optimization ap- proach yields excessive number of Gaussians, not only leading causing a degradation in rendering speed. To alleviate this, we adopt the soft movement pruning ap- proach (Sanh al. 2020 Lee al., 20224. Specifically, we introduce an auxiliary mask parameter IR for each Gaussian, and apply it to the opacity and scale of the Gaussian as follows:
large storage size but also
(5) where the subscript i an index to each Gaussian. and ş are the masked opacity and scale of the i-th Gaussian, respectively, which replace and the rendering process during optimization. m, E {0, } is a binary mask computed from such that m, 0 means that the i-th Gaussian pruned. I(-) is an indicator function, or-) is a sigmoid function, and is a threshold value that controls the binary mask m, Since the indicator function is con-differentiable. we optimize the mask parameters μ4, employing the straight-through crrough-estimator (STE) (Bengio al. 2013). To control the sparsity level, the mask loss Lmusk is defined as:
o m, 6; m,S; m,(7));), m, [(a())) 2 T)
N
Emask
Σ ((1)),
(6)
N
where N indicates the number of Gaussians.
Adaptive SH bandwidth For adaptive SH bandwidth selection, we define an SH mask parameter 77 = "o'',.."')) E L for each Gaussian and apply it to the residual SH coefficient k 1: as:
K2
m/k/,
mf
II ((o(T))) 2 TSH),

---

Published as a conference paper at ICLR 2025
Locallty-aware Representation Learning
Quantization
Storage
Decoding Dequantzation
Locality Representation
& Encoding
Input images
Conventional
representation
Octree
Pr
encoding
k-bit uniform quantization
Entropy coding
Parta
Entropy coding
Hash grid
Entropy coding
quantization
|0]
Entropy coding
Explicit attributes
Sorting along the Marton curve
Sorted explicit attributss
MLPs
Figure 3: Overall pipeline of LocoGS.
where i is an index to each Gaussian, m/ E {0, 1) is a binary mask to indicate whether the SH coefficients of the (-th degree are used, and TSH is threshold value that controls the SH binary masks m.. To control the SH bandwidth for each Gaussian, the SH mask loss L is defined as:
21 ++1-
CSH
(L. (1+1)2-1 (1/)
After optimization, we derive the adaptive SH bandwidth b, the i-th Gaussian as:
6; 0,
m = 0,
(9)
max (1)mm = Hissss))
otherwise.
Initialization The construction 3D Gaussian representation of target scene requires an ac- curate initialization due to the highly non-linear nature of its optimization process. To initialize Gaussians, 3DGS (Kerbl al. 2023) adopts a Structure-from-MMonn
(SfM) method (Schonberger & Frahm 2016), known COLMAP, that provides sparse point cloud. However, sparse point cloud is insufficient for capturing intricate details complex real-world components. To mitigate this, employ dense point cloud generated from Nerfacto (Tancik et al. (023). Specifically, first build a neural representation for a given target scene using the approach of Nerfacto, and densely sample point cloud adjacent to the reconstructed surface. From the neural representation, sam- ple one million points and initialize Gaussians using the sampled points. Refer to the appendix for more implementation details.
5.2 QUANTIZATION AND ENCODING
Once 3D Gaussian representation of target scene is obtained, further compress both explicit and implicit attributes to achieve a more compact storage size. Fig. 3 shows an overview of the encoding process. To compress the explicit attributes, employ different encoding schemes for different attributes. Specifically, we adopt G-PCC for the positions, which is an MPEG standard codec for geometry-based point cloud compression (Schwarz et al., 2018). For the other attributes, we adopt entropy coding. However, while the entropy coding scheme preserves the order of data, G-PCC does not, and consequently, loses the association between the positions and the other ex- plicit attributes after encoding. Thus, to preserve the association between the positions and the other explicit attributes, we first sort the Gaussians along Morton curve (Morton) 1966) before encoding the attributes. In the decompression stage, we reconstruct the association between the positions and other attributes by sorting the positions after decoding them.
Regarding the positions, we adopt lossless compression scheme. This is because the accuracy of 3D Gaussians is highly sensitive to positional errors, and even minor errors from lossy compres- sion schemes like quantization can lead to significant quality degradation. To this end, adopt G-PCC (Schwarz et al., (2018), which encodes 3D positions using an octree structure. While G-PCC significantly reduces storage requirements, its octree-based scheme requires positions quantized to

---

Published as a conference paper at ICLR 2025
Mip-NeRF 360
Quantitative evaluation on Mip-NeRF 360 (Bar- ron et al. 2022). We report the average scores of all scenes in the dataset. All storage sizes are in MB. We highlight the best score second-best score and third-best score of compact representations.
Table 1:
Ours 13.9
0.15-
3DGS 822 MB
0.200
Scaffold-GS
0.225
167.3 MB
0.230
Method
PSNR
SSIM
Mip-NeRF 360
LPIPS
Size
FPS
0.235
17.0MB
HAC
EAGL FS
LightGaussan
7.9
Ours
ScaffolFUS
3DGS Kerbl et al.
2023
2024
27.66
27.44
0.813
0.812
0.223
0.218
822.6
187.3
127
122
0.40
C3DGS
30.0 MB
C3DGS Niederhaiv
CompGS Navancet St
Compact- Lee et a
2024
2024
27.09
27.04
26.95
0.804
0.797
0.237
0.244
0.243
29.98
26.31
22.93
236
134
143
0.245
CoMp
KB
Compos
22 MB
LightGuisSia din curll 2024
26.90
0,800
0.240
53,96
244
Rendering speed (FPS)
EAGLES (Girisi 20 R0A5
27.10
0.807
0.234
59.49
155
SSGS Morgenseen
27.02
43.77
134
Figure 4: Comparison with baseline
HAC Chen ot al. 20241
27.49
0.807
0.236
16.95
110
approaches on Mip-NeRF 360 (Bar-
Ours-Small
27.04
0.806
7.90
310
Ours
27.33
0.814
0.219
13.89
270
ron et al. 2022).
the voxel resolution. To avoid information loss from quantization, we reinterpret the floating- footing-point values of the positions as integer values with the same bit arrangement. This method prevents quanti- zation errors and achieves lossless quantization of positions to integer values. We then encode these reinterpreted values using G-PCC. We refer the readers to appendix for more details on G-PCC.
For the base scale and base color k", we employ k-bit uniform quantization. Specifically, quan- tize these attributes within the distributional range (Dupont et al., 2022), which is computed with the standard deviation of the parameters, rather than simple Min-Max range. On the other hand, for the SH bandwidth i, we do not apply any quantization as it requires only two bits per Gaussian. Subsequently, we perform entropy coding on the quantized yy and k", and b. The entropy coding can be effectively performed thanks to the earlier sorting step. This step ensures that Gaussians, which are spatially proximate, are also closely placed in the sorted sequence. As result, neighbor- ing Gaussians in the sorted sequence demonstrate strong coherence, thereby boosting the efficiency of entropy encoding.
We also compress the implicit attributes, which are represented by the hash-grid &g and following MLPs O. Specifically, we apply both quantization and entropy coding to 0. However, for θ we only apply entropy coding as θ is more susceptible to quantization errors.
EXPERIMENTS
Implementation Details & Datasets Following the optimization scheme of 3DGS (Kerbl al., 2023), the optimization process of LocoGS adopts 30K iterations to construct a 3D representation for each scene. which takes about one hour for single scene on an NVIDIA RTX 6000 Ada GPU. During the optimization, we exponentially decay the learning rate for the neural field F. We also employ 5K iterations of the warm-up stage to prevent the initial over-fitting of hash grid-based neural fields. Refer to appendix x for more implementation details. For evaluation, we adopt three representative benchmark novel-view synthesis datasets. Specifically, we employ three real- world datasets: Mip-NeRF 360 (Barron et al. 2022). Tanks and Temples (Knapitsch et | (017)). and Deep Blending (Hedman et al. 2018). Following 3DGS (Kerbl et al. [202)), we evaluate our method on nine scenes from Mip-NeRF 360, two from Tanks and Temples, and two from Deep Blending.
6.1 COMPARISON
We compare our method with existing compact 3D Gaussian frameworks as well as the original 3DGS (Kerbl al. 2023) and Scaffold-GS (Lu et al. 2024). For comparison, we roughly categorize the existing compression approaches into the quantication-based image-codec-based, hash-gric based, and anchor- based approaches. The quantization
approaches include CompGS (Nava-) neet et al. 2024), C3DGS Niedermayr et al.] 2024), LightGaussian (Fan et al. (023), and EA- GLES (Giris et al. 2023). The image-codec- based approach includes SSGS (Morgenstern et al. 2023), which maps 3D Gaussian attributes onto a 2D plane and compresses the attributes using an image codec. The hash-grid -rid-grddbbaa based approaches include Compact- (Lee et al., 2024) as well as ours. Finally, the anchor-based approaches include Scaffold-GS (Lu al. 2024) and HAC (Chen
8

---

Published as a conference paper at ICLR 2025
CompaS (FPS 130)
Compact- 3DGS (FFS. 1409
C3DGS (PPS 246)
Lightnnusslnn (FPS. 201)
EAGLES (PPS 185)
LFIPS: 0.240 /Boe. 41 KB
LPIPS 0.288 Ste 31.19 MB
LPIPS. 0.241 /Bbe 33 MB
LPIPE: 0.237 / 78 MB
LPIPS 0.228 Size 00.37 VE
(FRB (50)
IFFS Ours-Small (FP8: 360)
Ours
Figure 5: Qualitative results on the 'stump' scene of Mip-NeRF 360 (Barron et al. 2022 Rendering speed, LPIPS, and storage size are shown at the bottom of each subfigure.
Quantitative evaluation on Tanks and Temples (Knapitsch et al., 2017 and Deep Blend- ing (Hedman et al.] 2018). We evaluate rendering quality, storage size, and rendering speed. We report the average scores of all scenes in the dataset. All storage sizes are in MB. We highlight the best score second-best score and third-best score of compact representations.
Table 2:
Tanks and Temples
Deep Blending
Method
PSNR
SSIM 1
IPIPS
Size
FPS f
PSNR
SSIM
TPPPS
Size |
FPS 1
3DGS (Kerhl et
2025
452.4
175
0,900
0.246
134
Scuffoli OS 1i mi
2022
24.11
0.855
0,165
154.3
109
30.28
0.907
0.243
121.2
194
CompGS Navaneet et
2024
23.29
0.835
0.201
14.23
329
29.85
0.907
0.253
15.15
Compact-3DGs Lxe ol 2024
23.33
0.831
0.202
18.97
199
29.71
0.901
0.257
21.75
184
C3DGS NNedeerhy
23.52
0.837
0.188
18.58
166
29.53
0.899
0.254
24.96
143
LightGatisann (Fai el K056
23.32
0.829
0,204
29.94
379
29.12
0.895
0.262
45,25
287
EAGLES (Girikr Fin 2025
23.14
0.203
30.18
244
29.72
0.906
0.249
54.45
137
SSGS Morgensterii mi 2023
21.54
0.833
0,188
24.42
222
29.21
0.891
0.271
19.32
224
HAC (Chen et alr 2024
0.846
0.186
8.42
129
0.902
0.268
235
Ours-Small
23.63
0.847
0,169
6.39
333
30.06
0.904
0.249
7.64
334
Ours
23.84
0.852
0.161
12.34
311
30.11
0.906
0.243
13.38
297
et al. 2024). while Scaffold-GS adopts an anchor-based representation not for compression but for improving the rendering quality. For a fair comparison of rendering quality, storage size, and rendering speed, we reproduce the results of all the baseline models using the officially released codes and configurations. In our evaluation, we evaluate two variants of our approach: 'Ours'. and 'Ours-Small". 'Ours' is our baseline model, while 'Ours-Smal uses a smaller hash grid and more aggressive pruning compared to 'Ours' to obtain more compact representations.
Fig. E Table [ and Table 2 show quantitative comparisons of the rendering quality (PSNR, SSIM, LPIPS), storage size, and rendering speed of diffcrent approaches. The comparison results show that our approach outperforms the baselinn methods, achieving highly compact storage sizes (54.6x to 96.6x compressed storage size than 3DGS (Kerbl et al., (023)), while achieving comparable or higher rendering quality. In terms of rendering speed, approach offers 2.1 x to 2.4x rendering approaches (CompGS (Na-
speed compared to 3DGS. On the other hand, the quantizaaion vaneet et al. 2024), C3DGS (Niedermayr et al. 2024), LightGaussian (Fan et al. 2023), and EA- GLES (Girish et al. 2023)) suffer from relatively large storage sizes and lower rendering qualities as they solely rely on global statistics of Gaussian attributes not considering the local coherence. SSGS (Morensterm et al. 2023), an image-codec-basee approach, also exhibits lower compression performance as projecting 3D Gaussians ence of 3D Gaussians. Compact-3DGS (Lee et al. 2024), which is a hash-grid grid-based approach, uses a hash grid only as a mapping to an RGB color from 3D position and a view direction. Thus, it exhibits not only low compression ratios, but also slow rendering speed as its rendering process requires an additional MLP to obtain color values for a given view direction. Finally, HAC (Chen et al. 2024). anchor-based approach, achieves impressive performance in terms of rendering quality and storage size, but its rendering speed is significantly slower than ours, as its rendering process also requires additional MI.ss
2D image plane cannot fully exploit the local coher-

---

Published as a conference paper at ICLR 2025
Table 3: Ablation study on the overall pipeline. All storage sizes are in MB.
Method
Rendering
Storage size
PSNR
SSIM
LPIPS
TPP
eG
Position
Color
Scale
Mask
Hash-MLP
Total
3DGS (eebl et
2025
0.813
3.32
822.6
3DGS + Friiing + Compression
26.95
0.798
0.235
188
1.54
79.14
Locality-waar sware 3D representation
27.28
0.808
0.233
216
1,53
8.17
8.17
2.72
25.26
44,32
+ initialization
238
7.92
2.64
43.74
+ Adaptive SH bandwidth
27.40
0.815
0.219
220
1.32 M
7.95
7.95
2.65
0.33
25.26
44.14
G-PCC for positions
27.40
0.815
0,219
270
1.32
2.80
7.95
2.65
0.33
25.26
38.99
+ Explicit compression
0.814
270
3.10
0.80
32.25
+ Implicit artr compression
27.33
0.814
0.219
270
1.32 M
2,80
3.10
0.80
0.29
6.90
13,89
Fig. 5 demonstrates qualitative comparison of LocoGS against previous methods (Navaneet al.,
2024 Lee et al. 2024, Niedermayr et al. 2024 Fan et al. 2023 Girish et al. [023] Morgenstern jt al. 2023] Chen et al. 2024). Existing compact approaches struggle with the intricate structures of real-world scenes, leading to severe artifacts (e.g., floaters) due to the lack of information for achiev- ing storage efficiency.
contrast, our method clearly shows superior rendering quality, capturing fine details of textureless regions, although it requires minimal storage capacity. Moreover, the result of 'Ours-Small', which requires a significantly smaller storage size, surpasses the rendering quality of all the other approaches.
6.2 ABLATION STUDY
LocoGS Pipeline To verify the effectiveness of each component in LocoGS, we conduct an abla- tion study. To this end, we evaluate the performance of variants of LocoGS on the Mip-NeRF 360 dataset (Barron et al. 2022). reports the evaluation results. In the table, '3DGS + Pruning Compression" indicates variant of 3DGS, to which we apply Gaussian pruning and the compres- sion schemes including G-PCC, quantization, and entropy coding as done in LocoGS without our locality-aware 3D representation. 'Locality-awar 3D representation' corresponds to baseline model that adopts only the representation learning step and COLMAP for Gaussian initialization.
As the table shows, locality-aware representation greatly reduces the storage requirement compared to the '3DGS + Pruning + Compression', while maintaining a similar number of Gaussians. The dense initialization further enhances the rendering quality and speed while reducing the storage size as it helps accurately reconstruct the target scene with fewer Gaussians. The adaptive SH bandwidth scheme greatly enhances the rendering speed at the cost of a slightly increased storage size. Fur- thermore, G-PCC and the other compression steps for the explicit and implicit attributes introduce a significant storage size reduction while maintaining the rendering quality and speed. Firstly, G-PCC decreases 11. 11.7% of storage space by compressing the positions. Moreover, explicit attribute com- pression saves 15.3% of storage capacity by compressing the hase scales and base colors into smaller bits. Finally, implicit attribute compression achieves further reduction of 41.6% in storage capac- ity by compressing the parameters of hash-grid and MLPs. Consequently, the compression pipeline shows 3.18x compression ratio with minimal loss in rendering performance. Appendix pro- vides additional ablation studies on the dense initialization and adaptive SH bandwidth scheme.
CONCLUSION
In this paper, we introduced LocoGS, a locality- compact 3DGS framework that addresses large storage requirements of Gaussian primitives. To this end, we first explored the local coherence of Gaussian attributes and employed them to devise a storage-efficient representation. Based on the novel representation, presented carefully-desinnee framework with additional components to maximize compression performance. Our experiments verified that our approach demonstrates su- perior compression performance compared to existing approaches in terms of storage size, rendering quality, and rendering speed.
Limitation Despite its remarkable performance, our representation takes longer to train than exist- ing methods, approximately one hour for each scene. In addition, our representation learning process requires more memory space than 3DGS due to the gradient computation of the hash grid and Gaus- sian attributes, which poses challenges for large-scale scenes. Thus, improving training efficiency is required by adopting optimization techniques to accelerate the computation of neural representa- tions. Our method assumes a cube-shaped, object-centric scene for setting the hyperparameters of the hash grid, which may be less effective for complex structures in large-scale scenes.
10

---

Published as a conference paper at ICLR 2025
8 ACKNOWLEDGMENTS
This work was supported by the National Research Foundation of Korea (NRF) grant funded by Korea government (Ministry of Education) (N0.202211AAAA10355555 Basic Science Research Program (10%)), and Institute of Information & communications Technology Planning & Evalua- tion (IITP) grant funded by Korea government (MSIT) NNo.RS-2019-1133
Al Graduate School Program (POSTECH) (10%); No.RS 2021-1121134,, Al Graduate School Program (Scoul National University) (5%); y; No.RS NOORR-2224-000 2024-00457882, AI Research Hub Project (30%); No. RRS-2023-002279933 Detailed 3D reconstruction for urban areas from unstructured images (45%)).
REFERENCES
Jonathan T Barron, Ben Mildenhall, Matthew Tancik, Peter Hedman, Ricardo Martin-Brualla, and Pratul P Srinivasan. Mip-nerf: A multiscale representation for anti-aliasing neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 5855-5864, 2021.
Jonathan T Barron, Ben Mildenhall, Dor Verbin, Pratul P Srinivasan, and Peter Hedman. Mip-nerf 360: Unbounded anti-aliased neural radiance fields. In Proceedings of the IEEE/CVF Conference Computer Vision and Pattern Recognition, pp. 5470-5479, 2022.
Jonathan T Barron, Ben Mildenhall, Dor Verbin, Pratul P Srinivasan, and Peter Hedman. Zip-nerf: Anti-aliased grid-based neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 19697-19705, 2023.
Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint urXiv:1308.34333 2013.
Anpei Chen, Zexiang Xu, Andreas Geiger, Jingyi Yu, and Hao Su. Tensorf: Tensorial radiance fields. In European Conference on Computer Vision, pp. 333-350. Springer, 2022.
Yihang Chen, Qianyi Wu, Jianfei Cai, Mehrtash Harandi, and Weiyao Lin, Hac: Hash-grid assisted context for 3d gaussian splatting compression. arXiv preprint arXiv:2403. 14530, 2024.
Zhiqin Chen, Thomas Funkhouser, Peter Hedman, and Andrea Tagliasacchi. Mobilenerf: Exploit- ing the polygon rasterization pipeline for efficient neural field rendering on mobile architectures. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp- 16569-16578, 2023.
Emilien Dupont, Adam Goliński, Milad Alizadeh, Yee Whye Teh, and Arnaud Doucet. Coin: Com- pression with implicit neural representations. arXiv preprint arXiv:2 2021.
Emilien Dupont, Hrushikesh Loya, Milad Alizadeh, Adam Golinski, Yee Whye Teh, and Arnau Doucet. Coin++: Data agnostic neural compression. arXiv preprint 12Xi::220..12004, 1(2)4, 2022.
Zhiwen Fan, Kevin Wang, Kairun Wen, Zehao Zhu, Dejia Xu, and Zhangyang Wang. Lightgaus- sian: Unbounded 3d gaussian compression with 15x reduction and 200+ fps. arXiv preprint arXiv:2311.17245, 2023.
Sara Fridovich-Keil. Alex Yu, Matthew Tancik, Qinhong Chen, Benjamin Recht, and Angjoo Kanazawa. Plenoxels: Radiance fields without neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5501-5510, 2022.
Sharath Girish, Kamal Gupta, and Abhinay Shrivastava. Eagles: Efficient accelerated 3d gaussians with lightweight encodings. arXiv preprint urXiv:2312.04556 2023.
Peter Hedman, Julien Philip. True Price, Jan-Michael Frahm, George Drettakis, and Gabriel Bros- tow. Deep blending for free-viewpoint image-based rendering. ACM Transactions on Graphics (ToG), 1-55 2018.
11

---

Published as a conference paper at ICLR 2025
Peter Hedman, Pratul P Srinivasan, Ben Mildenhall, Jonathan T Barron, and Paul Debevec. Baking neural radiance fields for real-time view synthesis. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 5875-5884, 2021.
Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis. 3d gaussian splat- ting for real-time radiance field rendering. ACM Transactions on Graphics, 42(4))1-14, 2023.
Arno Knapitsch, Jaesik Park, Qian- Yi Zhou, and Vladlen Koltun. Tanks and temples: Benchmarking large-scale scene reconstruction. ACM Transactions on Graphics (ToG), 36(4):1-13, 2017.
Joo Chan Lee, Daniel Rho, Xiangyu Sun, Jong Hwan Ko, and Funbyung Park. Compact 3d gaussian representation for radiance field. In Proceedings of the IEEE/CVF Conference Computer Vision and Puttern Recognition, pp. 21719-21728, 2024.
Tao Lu, Mulin Yu, Linning Xu, Yuanbo Xiangli, Limin Wang, Dahua Lin, and Bo Dai. Scaffold-gs: Structured 3d gaussians for view-adaptive rendering. Conference on Computer Vision and Pattern Recognition (CVPR), 2024.
Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. Communications of the ACM, (5(1):99-106, 2021.
Wieland Morgenstern, Florian Barthel, Anna Hilsmann, and Peter Eisert, Compact 3d scene repre- sentation via self-organizing gaussian grids. arXiv preprint arXiv:2312. 13299, 2023.
Guy M Morton. 1966.
computer oriented geodetic data base and a new technique in file sequencing.
Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller. Instant neural graphics prim- itives with a multiresolution hash encoding. ACM transactions on graphics (TOG), (14) 2022.
KL Navaneet, Kossar Pourahmadi Meibodi, Soroush Abbasi Koohpayegani, and Hamed Pirsiavash. Compgs: Smaller and faster gaussian splatting with vector quantization. ECCV, 2024.
Simon Niedermayr, Josef Stumpfegger, and Rüdiger Westermann. Compressed 3d gaussian splatting for accelerated novel view synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10349-10358) 2024.
Christian Reiser, Rick Szeliski, Dor Verbin, Pratul Srinivasan, Ben Mildenhall, Andreas Geiger, Jon Barron, and Peter Hedman. Merf: Memory- radiance fields for real-time view synthesis in unbounded scenes. ACM Transactions on Graphics (TOG), 42(4):1-12, 2023.
Daniel Rho, Byeonghyeon Lee, Seungtae Nam, Joo Chan Lee, Jong Hwan Ko, and Eunbyung Park. Masked wavelet representation for compact neural radiance fields. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 20680-20690, 2023.
Victor Sanh, Thomas Wolf, and Alexander Rush. Movement pruning: Adaptive sparsity by fine- tuning. Advances in neural information processing systems, 1--20378-20385 2020.
Johannes L Schonberger and Jan-Michael Frahm. Strueture-from-mottie revisited. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4104-4113 2016.
Sebastian Schwarz, Marius Preda, Vittorio Baroncini, Madhukar Budagavi, Pablo Cesar. Philip A Chou, Robert A Cohen, Maja Krivokuća, Sébastien Lasserre, Zhu Li. al. Emerging mpeg standards for point cloud compression. IEEE Journal on Emerging and Selected Topics in Circuits and Systems, 911: 2018
Seungjoo Shin and Jaesik Park. Binary radiance fields. Advances Neural Information Processing Systems, 36, 2024.
Yannick Strümpler, Janis Postels, Ren Yang, Luc Van Gool, and Federico Tombari. Implicit neural representations for image compression. In European Conference on Computer Vision, pp. 74-91. Springer, 2022.
12

---

Published as a conference paper at ICLR 2025
Cheng Sun, Min Sun, and Hwann-Tzone Chen. Direct voxel grid optimization: Super-fast con- vergence for radiance fields reconstruction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5459-555555 5469,, 2022.
Towaki Takikawa, Alex Evans, Jonathan Tremblay, Thomas Müller, Morgan McGuire, Alec Ja- cobson, and Sanja Fidler. Variable bitrate neural fields. ACM SIGGRAPH 2022 Conference Proceedings, pp. 1-9, 2022.
Matthew Tancik, Ethan Weber, Evonne Ng, Ruilong Li, Brent Yi, Terrance Wang. Alexander Kristof- fersen, Jake Austin, Kamyar Salahi, Abhik Ahuja, et al. Nerfstudio: A modular framework for neural radiance field development. ACM SIGGRAPH 2023 Conference Proceedings, pp. 1-12, 2023.
Jiaxiang Tang, Xiaokang Chen, Jingbo Wang, and Gang Zeng. Compressible nerf via rank-residual decomposition. Advances in Neural Information Processing Systems, 35:14798- 14809, 2022.
Haithem Turki, Deva Ramanan, and Mahadev Satyanarayanan. Mega-nerf: Scalable construction of large-scale nerfs for virtual fly-throughs. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 12922-12931, 2022.
Henan Wang, Hanxin Zhu, Tianyu He, Runsen Feng, Jiajun Deng. Jiang Bian, and Zhibo Chen. End- to-end rate-distortion optimized 3d gaussian representation. arXiv preprint arXiv:2406.01597 2024.
Yiming Wang, Qin Han, Marc Habermann, Kostas Danilliiis, Christian Theobalt, and Lingjie Liu. Neus2: Fast learning of neural implicit surfaces for multi-view reconstruction. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 3295-3306, 2023.
Alex Yu, Ruilong Li, Matthew Tancik, Hao Li, Ren Ng, and Angjoo Kanazawa. Plenoctrees for real-time rendering of neural radiance fields. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 5762-5761, 2021.
Zehao Yu, Songyou Peng, Michael Niemeyer, Torsten Sattler, and Andreas Geiger. Monosdf: Ex- ploring monocular geometric cues for neural implicit surface reconstruction. Advances in neural information processing systems, 35:25018 -20032, 2022.
Kai Zhang, Gernot Riegler, Noah Snavely, and Vladlen Koltun. Nerf++: Analyzing and improving neural radiance fields. arXiv preprint 27014:2010007442, 2020. 2020.
A APPENDIX
A.1 IMPLEMENTATION AND EVALUATION DETAILS
Architecture The proposed neural fields consist of multi-resolltion hash grid with 16 levels of resolutions from 16 to 4096, followed by multi-layer perceptrons (MLPs) with two 64-channel hidden layers with ReLU activation for each locality-awan attribute. Each level of the hash grid contains up to 217 feature vectors for our small variant and 249 feature for our base model with two dimensions. The output of MI.Ps for each attribute is activated by the sigmoid function, normaliza- tion function, and exponential function for scale, rotation, and opacity, respectively. Note that no activation function is applied to spherical harmonics (SH) coefficients.
Optimization We optimize Nerfacto (Tancik et al. 2023 for 30K iterations to acquire dense point cloud for initialization, which takes less than 10 min for a single scene. We set the rendering loss weight À 0.2, the mask threshold to 0.01 and the masking loss weight to Amssk 0.005 for our small variant and Amask = 0.004 for our base model. We set the SH mask threshold to Tsu = 0.01, and SH masking loss weight to ASH 0.0001.
Quantization We apply 6-bit uniform quantization for hash grid parameters f and base scales y and apply b-t uniform quantization for base colors kº. Prior to b-b quantization, clip the target values to lie within - 3(k- 1)/15 standard deviations their mean, as proposed by Dupont et al. 2022). Additionally, define position p with 16-bit precision with half tensor.
13

---

Published as a conference paper at ICLR 2025
Rendering Speed Measurement For fair comparison of rendering speed, we reproduce all the baselines following the outlined configuration and measure the rendering speed in the same exper- imental setting. We render every test image 100 times report the average rendering time. Also, we add 100 iterations of warm-up rendering before measur- ing the speed. We follow the original image resolution of the Tanks and Temples dataset (Knapitsch et al. 2017) and the Deep Blending dataset (Hedman et al. 2018)) processed by 3DGS (Kerbl et al.) 2023). In particular, we downsample the image resolution of the Mip-NeRF 360 dataset (Bar-) ron et al. 2022) not to exceed maximum width of 1.6K, following the evaluation setting of 3DGS (Kerbl al. 2023).
single GPU (NVIDIA RTX 3090) and
A.2 ADDITIONAL. DETAILS ON LocoGS
A.2.1 DENSE INITIALIZATION
In the following, introduce the detailed process to obtain dense point cloud from optimized neural radiance fields (NeRF). NeRF optimizes continuous 5D function that maps a 3D coordinate Rs and 2D viewing direction d IR² to RGB color R and opacity E Rt. For volume rendering, the colors and opacities of sampled points along ray r(t) = o + t are accumulated to acquire the color of the ray follows:
NN
i-1
C(r) = E Taac, T, = [I j=1
a; == 1=11-ep(--o01)
(10)
1=1
where T; denotes accumulated transmittance, a; and c; denote alpha and color of the i-th sampled point, respectively. 6, 44+1 4 denotes the distance between neighboring points. To acquire dense point cloud, we render the median depth 2 as follows:
N.
=(r)
Σ as//xi/ll
where TN, 2 0.5 and TN.-1 < 0.5,
(11)
i=1
where x; is a sampled point along the ray and N₂ is the median index of sampled point along the ray r. Then we project each training view pixel into 3D space according to its median depth z as follows:
(12) where Pa is the projected 3D coordinate along ray rs. C(ra) denotes predicted color value along ray Fg, and K. is uniformly sampled ray indices for all rays of training views. O₃ and d, represents ray origin and ray direction, respectively. In this work, we set |K] = 1M for efficiency.
Pdense {DE, C(rK)))EE. Ds = og + (r
A.2.2 G-PCC
We explain the overall process of the octree-based geometry coding, G-PCC (Schwarz al. 2018), for compressing positions. First, it voxelizes the input positions p E RR3 before dividing octree nodes. This is achieved by computing quantized positions p' 1 using user-defined scaling R and shifting Paint E 3 as follows:
(13) Upon these quantized positions, the octree structure is built through the recursive subdivision, and occupancy codes are efficiently stored using entropy coding. The resolution of the octree is de- termined by the scaling 8, where a larger scaling requires more storage space. Conversely, using a smaller scaling reduces the storage size whereas it increases the quantization error in Eq. [13 resulting in accuracy reduction.
p' = (p Panin) x s].
To analyze the impact of quantization error, we evaluate the rendering quality according to the vary- ing quantization levels. Fig. [ demonstrates that we encounter severe quality degradation above a specific quantization level, leading to limited compression performance. Thus, we propose loss- less transformation that ensures the high precision of positions for octree encoding, instead of using lossy quantization. The key idea is to reinterpret floating point values integer values with the same bit arrangement as follows:
(14) where float2int() denotes casting operator from float to integer. As shown in Fig. the pro- posed invertible transformation enables lossless encoding and decoding of positions using octree geometry. Specifically, convert float16 into int16.
p' = sign(p) float2int(lp).
14

---

Published as a conference paper at ICLR 2025
X
quantization
X
ours
272
0.812
27.28
SSIM
0.221
0.10
27.24
0.234
2720
0.000
0.82
2.73
3,00
3.25
3.50
Size (MB)
Size (MB)
Size (MB)
Figure 6: Ablation study on the voxelization method.
A.3 ADDITIONAL ABLATION STUDIES
A.3.1 ATTRIBUTE DESIGN
To validate the optimality of our current selection of explicit attributes, compare the performance of LocoGS on the Mip-NeRF 360 dataset (Barron et al. 2022) when the base color and base scale treated either explicit implicit attributes. Table summarizes the comparison results. As the table shows, treating either the base scale or base color as implicit attributes degrades performance, as they cannot be explicitly initialized or manipulated during the training process. Specifically, treat- ing the base scale as an implicit attribute makes the training process highly unstable, resulting in severely small number of Gaussians and poor rendering quality. Treating the base color an im- plicit attribute also degrades the rendering quality while increasing the number of Gaussians. Thus, we selected them as explicit attributes along with positions.
Table 4: Ablation study on the attribute design.
Base color
Base scale
PSNR
SSIM f
LPIPS
Size
FPS
#G
Explicit Implicit
Implicit
20.48
0.661
0.383
10.13
176
0.65 M
Explicit
27.15
0.811
0.225
11.22
224
1.42
Explicit
Explicit
27.33
0.814
0.219
13.89
270
1.32
A.3.2 HASH GRID SIZE
Our locality-aware 3D Gaussian representation significantly reduces storage by encoding Gaussian attributes compact hash grid. The size of the hash grid is a crucial parameter influencing both the compression ratio and quality. To understand the impact of the hash grid size, examine the performance of our framework with different grid sizes using the Mip-NeRF 360 dataset (Barron) evaluate the performance according the maximum number of feature vectors from 21 to 220 which are involved in each resolution level of the hash grid. Note that the hash grid size does not influence the rendering speed, does affect the number of Gaussian primitives or spherical harmonics computation. As Fig. demonstrates, higher compression ratio can be achieved by reducing the hash grid size, although this leads decrease in rendering quality. The graphs also reveal that by increasing the hash grid size, we can attain a higher rendering quality than 3DGS (Kerbl et al. 2023), while the increased size still about 40 times smaller than that of 3DGS. Furthermore, can achieve rendering quality comparable to Scaffold-GS (Lu et al. 2024) with just 10 MBs, which is more than 18 times smaller than that of Scaffold-GS.
al. al.] 2022). Specifically,
A.3.3 EFFECT OF DENSE INITIALIZATION ON LoCoGS
We analyze the effectiveness of the dense point cloud-based initialization. Fig. demonstrates that the lack geometric prior from sparse point cloud results in visual artifacts in the rendering image, whereas dense point cloud stands out for its ability to capture the fine details of the scene. As result, Table shows that we can further achieve robust optimization and photo-realistic rendering with dense geometric priors acquired from radiance fields.
15

---

Published as a conference paper at ICLR 2025
0.815
822,6MB
3DGS
21
220
0.220
822. SMB
3DGS
2
200
SSIM
0.812
18
Scaffold-GS 187.3 MB
218
0.223
Scaffold-GS
0.809
217
0.226
2
Size (MB)
Size (MB)
Figure 7: Ablation study on the hash grid size.
Table 5: Ablation study on the effect of dense initialization. 'Ours (w/o dense init.)' denotes our variant that begins optimization from SIM points, not applying dense initialization
Method
PSNR
SSIM
LPIPS
Size
FPS
Ours (w/o dense init.)
27.16
0.807
0.233
14.15
246
Ours
27.33
0.814
0.219
13.89
270
COLMAP (0.03M)
Ours (1.00M)
COLMAP (0.05M)
Ours (1.00M)
Figure 8: Visualization of the initial point cloud (upper) and rendering image (bottom).
A.3.4 EFFECT OF DENSE INITIALIZATION ON EXISTING COMPRESSION METHODS
Moreover, we further adopt dense initialization existing 3DGS compression methods to validate its general effectiveness. Specifically, we additionally adjust the compression parameters of the exist- ing compression methods, such as pruning strength and quantization strength, since simply applying dense initialization increases the number of Gaussians. Thus, conduct an evaluation comparing the performance of existing approaches a) without dense initialization, b) with dense initialization but no compression parameter tuning, and c) with dense initialization and compression parameter tuning on the MipNeRF-360 dataset (Barron et al.) 2022). In this evaluation, we also include two non-compression methods, 3DGS (Kerbl et al. 20233) and Scaffold-GS (Lu al. 22024), which have no compression parameters, so we do not perform compression parameter tuning for them. Fig. P and Table 6 summarize the evaluation results. As shown in Fig. b). dense initialization without compression parameter tuning increases the number of Gaussians and storage size, and it decreases the rendering speed for all methods. As shown in Fig. (cc) dense initialization with compression parameter tuning enhances rendering speed and storage requirements while achieving comparable or higher rendering quality for most existing approaches. ization with compression parameter tuning does not perform well with HAC (Chen et al. 2024), as shown in Table because its anchor-based approach does not directly encode individual Gaussians, thus lacks pruning mechanism reduce the number of Gaussians. Compared to them, our ap- proach still has distinctive advantages over existing compression methods producing smaller-sized results while providing higher rendering speed and comparable rendering quality.
worth mentioning that dense initial-
16

---

Published as a conference paper at ICLR 2025
Mip-NeRF 360
Mip-NeRF 360
Mip-NeRF 360
Scofold
0.100
3.50
20:55
0120
LPIPS
STASII FSS
piPS
850S1 EAGLES
Ours
Ours
Ours
3.24
Scofflld 66
BIDGS
STAGLES
Lightes
0040
Campowd NDCC
Lap
0040
CHOGS!
CompectDes
Compas
Ughit
Complssi
390
22 23
12
0.90
20 Mn
12
230 Rendering (FPS)
100
Rondaring speed (FPS)
Rondering speed (FPS)
(a) Baseline
(b) Dense initialization
Dense initialization and compression parameter tuning
Figure 9: Ablation study on the dense initialization for existing 3DGS approaches. denotes ap- plying dense initialization, and denotes applying dense initialization and compression parameter tuning.
Table 6: Ablation study the dense initialization for existing 3DGS approaches. * denotes applying dense initialization, and t denotes applying dense initialization and compression parameter tuning.
Method
PSNR
SSIM f
LPIPS
Size |
FPS
Mathod
PSNR
SSIM 1
IPPPS
Size
FPS
JDGS
0.813
0.218
822.6
127
LightGaussian
0.800
3DGS
27.80
0.826
0.198
935.8
118
LightGaussian
27.08
0.806
0.229
60.21
228
Scaffold GS
0,223
187.3
122
LighiGaussian
0.799
Scaffold-GS
28.24
0,828
0.187
387.4
49
EAGLES
27.10
0.807
0.234
59.49
155
C3DGS
27.09
0,802
0.237
29.98
134
EAGLES
0.821
0,214
67.54
126
C3DGS
27.39
0.812
0,220
33.87
131
EAGLES
27.35
0.818
0.219
56.55
137
C3DGS!
27.39
0.812
0,221
26.95
141
SSGS
0,800
0.226
43.77
Compact-3DGiS
26.95
0.797
0.244
26.31
143
SSGS
27.13
0.805
0.211
72,00
102
Compuct-3DGS 3DGS
27.47
0.814
0.219
31.99
124
SSGS
0.797
Compact-3DGS
27.30
0.807
0,232
20.19
188
HAC
27.49
0.807
0.236
16.95
110
CompGS
27.04
0.804
0.243
22.93
236
HAC"
27.71
0.822
0,201
42.67
CompGS*
27.42
0.818
0,223
24.75
218
HAC!
27.16
0.808
0.219
32.19
54
CompGSt
27.21
0.810
0.241
15.24
271
0.814
13.89
A.3.5 DENSE INITIALIZATION METHON
Table 7 compares the final rendering qualities of LocoGS initialized with 3DGS and Nerfacto. As shown in the table, LocoGS with Nerfacto achieves higher rendering quality, faster rendering speeds, and fewer Gaussians, thanks to the better initial solutions provided by Nerfacto. While Nerfacto typ- ically produces results with lower rendering quality than 3DGS, it generates more accurate geometry information thanks to the regularization terms in its training loss function, which helps our training process achieve more accurate Gaussian representation learning. Furthermore, we find that Nerfacto also requires approximately 2x shorter training time of 3DGS for both 30K iterations in the same environment (NVIDIA RTX 3090).
A.3.6 ADAPTIVE SPHERICAL HARMONICS BANDWIDTH
We investigate the effectiveness of the adaptive spherical harmonics (SH) bandwidth method com- pared to varying fixed SH bandwidth L. Table 8 implics that our SH pruning scheme adaptively reduces the SH bandwidth of less view-dependent Gaussians during optimization. Lower SH de- grees yield notable rendering quality degradation despite the improvement in rendering speed. In contrast, we can accelerate the rendering process by excluding unnecessary SH elements, while the regularization effect of pruning leads to improved rendering quality compared to using the full SH degree (L = 3). Moreover, the results indicate that lower SH degrees (L < 3) tend to increase the number of Gaussians to represent the riewddependent effect through more Gaussians. As result, our approach achieves faster speed due to less number of Gaussians, even compared to rendering without harmonies components (T. 0).
17

---

Published as a conference paper at ICLR 2025
Table Evaluation of LocoGS according to the dense initialization method.
Method
PSNR
SSIM
LPIPS +.
Size J
FPS 1
#G
Bonsai (Mip-NeRF 360)
3DGS
31.55
0.933
0.212
9.39
315
0.52 M
Nerfacto
31.58
0.935
0.208
9.15
355
0.49 M
Stump (Mip-NeRF 360)
3DGS
27.04
0.790
0.199
17.63
281
2.02 M
Nerfacto
27.24
0.801
0.194
15.55
303
1.65 M
Truck (Tanks and Temples)
3DGS
25.34
0.880
0.129 0.125
13.17
303
1.07 M
Nerfacto
25.70
0.885
12.19
326
0.90 M
Playroom (Deep Blending)
3DGS
30.32
0.907
0.250
11.55
328
0.83 M
Nerfacto
30.49
0.907
0.248
10.75
386
0.68 M
Table 8: Ablation study on the SH bandwidth.
Method
PSNR
SSIM
LPIPS 4
Size |
f
L =
27.29
0.814
0.219
13.58
238
L =
27.22
0.813
0.220
13.64
258
I,
27.08
0.811
0.221
13.68
268
1, 0
26.72
0.814
0.226
13.96
269
Ours
27.33
0.814
0,219
13.89
A.4 ALGORITHMS
We provide the locality-aware Gaussian representation learning step of LocoGS pipeline.
Algorithm Locality- Gaussian representation learning
gexplicit (4 < INITIALIZE()
Explicit attribute, neural field, and mask parameter
while not converged do
+ GETGAASSIINN@<pile,, FF)
Alg.
+ MASKGAUSSIAN(C, (4 m,
Alg.
< RASTERIZE(()
b Rasterization Bq.
C LOSS(I, + LOSs(u) + Loss(n)
gexplicit F,,,, μr, 7 +- ADAM(VL)
ISPRUNEITERRATIONNNN ATION()) then
Goxplicit <- PRUNEGAUSSTAN p))
Alg.
end if
(SREEENMENNTTEE)AIOO))))) then
gexplicit +- ADARTIVEDENSSTYCONNROO.OO
Densification
end if end while
COMPUTEBANDWIDDTH(())
> Eq.
18

---

Published as a conference paper at ICLR 2025
Algorithm 2 Acquisition of Gaussians during optimization
Input:
Explicit attributes gesplici = [g NN
Fi=1 and neural field F.
Gaussian attributes function GETGAUSSIAN
Output:
.F)
be a new list of Gaussians
for i +- to N do
N Gaussians Explicit attribute gesplici
ps, No. k. t gexplisir
0s, S; ri, k.b &- F(p.)
& Implicit attribute g iimplicit
S; +- S
Scale sp
k; f- k k.
D SH coefficients k, b Gaussian G
G 6 Pi, Oz St, (i,ki)
end for return G end function
> Gaussians g
Algorithm Masking Gaussians during optimization
Input: Gaussian attributes g = { and corresponding mask parameters v).
Output: Masked Gaussian attributes G
function MASKGAUSSIAN(,, 17)
be a new list of masked Gaussians
for i + 1 to N do
b N Gaussians
Ps: 0i, S, ri, k; 9i
- (144 <)
Binary mask
o, + m,0, m,s,
B Masked opacity o and masked scale š;
m f-1
for 1 tto L do
m m 1-1, 1 (o())) s TSH)
Binary SH mask m for degree I
k m
Masked SH coefficients k, for degree /
end for
G. < (pr oj Si, ri, k;}
b Masked Gaussian 9
return 9.
end for return و
> Masked Gaussians g
end function
Algorithm 4 Pruning Gaussian during optimization
Input: Explicit attributes gexplicit {gexplicity N and corresponding mask parameters μs.
Output: Pruned explicit attributes gexplicit function PRUNEGAUSSIAN
for i <- 1 to N do
m, <- (pss < <)
D Binary mask my
if m, 0 then
gexplicit gexplicit gexpliiiieep gexplicit
D Remove i-th Gaussian
end if end for
return gexplicit end function
A.5 ADDITIONAL RESULTS
A.5.1 NUMBER OF GAUSSIANS
We evaluate the numbers of Gaussians after optimization Table and along the training iterations in Fig. 10 Compared to 'Qurs", 'Ours-Small" has fewer Gaussians, resulting in higher rendering
19

---

Published as a conference paper at ICLR 2025
speed and slight degradation in rendering quality. In our framework, the rendering speed is inversely proportional to the number of Gaussians. While the rendering quality is influenced by the number of Gaussians, shown in Table 9 it is also affected by other factors, such dense initialization. In Fig. T0. 'Ours' and 'Ours-Small" begin with dense initialization. Thus, at the beginning, they have more Gaussians than 3DGS and 'Ours (w/o dense init.)'. We prune Gaussians for the entire optimization process (30K iterations), whereas 3DGS preserves a large number of Gaussians after densification (I5K iterations). Therefore, can achieve small Gaussian quantity after optimiza- tion. MOrs--malll uses larger weight for the mask loss, so it has fewer Gaussians than 'Ours' after training.
Table 9: Evaluation of the rendering quality, rendering speed, and number of Gaussians.
Mip-NeRF 360
Tanks and Temples
Deep Blending
Method
LPIPS
#G
LPIPS
FPS
LPIPS 4
FPS
Ours-Small
0.232
310
1.09
0.169
333
0.78
0.249
334
1.04 M
Ours
0.219
270
1.32
0.161
311
0.89
0.243
297
1.20 M
Bicycle (Mip-NeRF 360)
Truck and Temples)
6
2.5
2.0
Number of Gausoianss
Number Caussiann
8-
1.5
3-
2-
JOGS
Ours (wlo dense int)
Ours (wi donse Int))
Ouro Small
Ouro-Small
(K)
Iteration (K)
Figure 10: Illustration of the number of Gaussians along iterations. 'Ours (w/o dense init.)' denotes variant that begins optimization from SfM points, not applying dense initialization.
A.5.2 DECODING TIME
Table 10 compares the decoding times different compression methods. LocoGS shows compa- rable decoding times despite its highly compact storage sizes compared to the other approaches, requiring less than nine seconds for single scene.
Table 10: Evaluation of the decoding time (sec).
Method
Mip-NeRF 360
Tanks Temples
Deep Blending
CompGS
12.9
6.9
10.6
Compact-3DGS
178.4
139.4
59.8
C3DGS
0.2
0.1
0.2
EAGLES
8.1
7.0
LightGaussian
0.7
0.5
0.8
SSGS
6.6
3.8
2.8
HAC
24.3
13.9
5.0
Ours-Small
7.3
4.9
6.7
Ours
8.5
5.5
7.9
A.5.3 LARGE-SCALE SCENES
We evaluate the performance of LocoGS representative large-scale dataset, the Mill-19 dataset (Turki et al. 2022), as shown in Table [T]] The large-scale scenes Mill-19 require an excessive number of Gaussians, resulting in large storage requirements exceeding 1.3GB for the
20

---

Published as a conference paper at ICLR 2025
original 3DGS approach. LocoGS effectively reduces the memory size less than 34MB, achiev- ing a 4 compression ratio. Additionally, our effective compression scheme involving Gaussian point pruning also substantially improves the rendering speed.
Despite its high compression ratio, our method requires more memory space than the original 3DGS during training, which presents some challenges when applying scenes. The slight quality degradation observed in Table 11 is also because of this heavy memory requirement, which limits the number of Gaussians fewer than necessary. To address this issue, dividing a large-scale scene into smaller subregions could be a promising solution. Note that in- creased memory consumption only applies to the training phase. Our method follows memory usage of the original 3DGS for the rendering, which is proportional to the number of Gaussians.
method directly large-scale
Table 11: Evaluation on the Mill-19 dataset (Turki et al.
2022).
Method
PSNR
SSIM f
LPIPS
Size
FPS f
#G
Building
3DGS
19.14
0.651
0.365
1371.02
83
5.44 M
Ours
19.79
0.630
0.354
32.97
113
4.13 M
Rubble
3DGS
23.75
0.733
0.311
1752.37
69
6.95 M
Ours
23.38
0.651
0.366
33.26
122
4.20 M
A.5.4
QUANTITATIVE RESULTS
Tables 12 13
and 14 demonstrate the quantitative results each scene of the Mip-NeRF 360
dataset (Brrro et al. 2022), Tanks and Temples dataset (Knapitsch et al. 2017). and Deep Blending dataset Hedmaan et al. 2018). We measure the rendering quality (PSNR, SSIM, LPIPS), storage size, and rendering speed each method on the various datasets.
A.5.5 QUALITATIVE RESULTS
14 and 15 demonstrate the quantitative results on each scene of the Mip-NeRF 360 dataset (Barron et al. 2022), Tanks and Temples dataset (Knapitsch et al. (017). and Deep Blending dataset (Hedman et al. 2018)
Figs.
21

---

Published as a conference paper at ICLR 2025
Table 12: Quantitative results of rendering quality, storage size, and rendering speed Mip-
NeRF 360 (Barron et al. 2022p. All storage sizes are in MB. We highlight the best score second-hest score and third-best score of compact representations.
Method
Bicycle
Bonsai
PSNR
SSIM
LPIPS
Size (MB)
FPS
PSNR
SSIM
LPIPS
Size (MB)
FPS
3DGG Kerhi al.
1506.3
69
0.206
310.7
208
Scaffalb-tSS Lu
2024
25.21
0.758
0.231
309.8
101
32.52
0.941
0.205
130.7
117
CompGS (Naangel
20347
24.98
0,750
0.238
49.15
99
31.48
0.952
0.216
13.74
171
Compact-DDSS
90
210
C3DGS Nisdemaay ot 20744
24.91
0.752
0.248
35.64
191
31.18
0.930
0.226
10.41
288
LightGalsttan [rin
24.93
0.752
0.233
98,82
181
30.84
0.926
0.225
20.55
317
KAGI J& (Girish
124
0.218
30.16
SSGS MMpaciscer
2023
24.64
0.745
0.218
56.93
131
31.39
0.930
0,207
25.40
136
HAC Clion oFal 2124
25.09
0,753
0.242
30.95
66
32.20
0.936
0.214
9.01
114
Ours Small
25.32
0,760
0.227
13.75
141
31,18
0.928
0.220
4.11
401
Ours
25.41
21,28
135
0.208
9.15
Garden
Method
PSNR
SSIM
LPIPS
Size (MB)
FPS 1
PSNR
SSIM
LPIPS L
Size (MB)
FPS
3DGS Kebll st
2023
28.94
0,906
0.302
296.3
155
27.31
0.863
0.108
1419.7
79
ScaffolbrGs Lareran 2014
115
0.119
ComptiS Navancet et
2034
28.61
0.896
0.215
14.16
138
26.91
0.847
0.138
48.56
107
Compact-31XX (1:3 of
2004
28.54
0,892
0.223
14,00
153
26.61
0.838
D.145
36,52
100
C3DGS Nielepiay
37.26
LightGaussiin [an ot A044
27.97
0.885
0.232
19.53
234
26.78
0.844
0.136
92.81
189
EAGLES (Girisa ot al.
2025
28.29
0.897
0.217
26.80
143
26.83
0.843
0,146
69.15
151
SSGS (Mageetaeer
2023
28.56
0.894
0.210
19.00
139
26.98
0.847
0.119
88.68
101
HAC
7.68
110
0.1.6
22.85
89
Ours
Oual-Small Small
28.40
0.889
0.224
4.42
238
26.81
0.834
0,155
7.26
3:9
Ours
28.72
0.897
0.311
9.56
214
27.07
0.845
0,139
13.36
302
Method
Kitchen
Room
LPIPS
(MB)
SSIM
LPIPS
(MB)
3DG3 Kerbl at al. 2013
$1.53
0.926
0.127
445.1
123
31.38
0.917
0.221
379.6
144
Scaffohars Tar mn 6024
31.48
0.925
0.129
106.4
900
32.04
0.922
0.213
87.7
154
CompGS (Navanget
2024Y
121
Compadi:1AAn> (1.83
2002
30.38
0.913
0.141
22.11
119
30.69
0.910
0.233
13.92
199
C3DGS Nielonhay al
2072
50.47
0.916
0.144
15.45
2001
31.13
0.911
0.238
9.19
256
LightCailsenn
30.36
0.908
0.152
29.16
221
30.95
0.908
0.238
24.95
235
EAGLES (Girisn mil XM/3
30.56
0,921
0.138
47.35
115
31,44
0.917
0.226
31.57
124
SSGS Morgoisior de 3n 2023
30.59
0.907
0.147
24.73
121
30.79
0.905
0.229
15.32
133
HAC
30.99
0.917
0,141
8.59
87
31,38
0.912
0.233
5.63
155
Ourl-Small
0.156
349
0.249
3.84
360
Ours
90.71
0.914
0.145
9.47
298
31.44
0.913
0,252
9.19
318
Method
Sramp
Flowers
PSNR
SSIM
IPPIS
Size (MR)
FPS
PSNR
SSIM
I.PISS
Size (MB)
PPS
Kerbl
2023
1193.8
906.3
Scaffall-GG Ls (ar 24
26.56
0.766
0.235
259.1
147
21.36
0.593
0.349
230.0
142
CompGS (Naaanee
20247
26.32
0.757
0.249
41.66
139
21.16
0.584
0.358
33,02
154
Compac--3XX0 51XG
140
0.378
C3DGS Nidlephsy
2024
26.52
0.767
0.241
33.06
246
21.29
0.587
0,368
27.83
274
Lightaadsun ef 2024
26.46
0.765
0.237
78.11
261
21.31
0.587
0.358
59.61
304
EAGLES (Girisa 2025
26.59
0.771
0.218
99.37
169
21.28
0.588
0.361
58.04
219
0.749
58.12
150
21.62
59,02
HAC Tion cl 2024
26.62
0.765
0.243
22.23
13%
21.39
0.587
0.360
21.65
127
Ours-Smal
27.04
0.792
0.207
9.17
369
21.55
0.613
0.317
10.46
315
15.55
0.306
17.14
Treshill
PSNR
SSIM 1
LPIPS
Size (MB)
FPS
3DGS Kobll al.
2023
22,48
0.633
0.337
945.8
120
Seaffalo-GS (Laret
2124
0.324
130
CompGS (Navanget et
2024
22.41
0.622
0.351
34,99
142
Compact- 31x [ of
20024
22.61
0.634
0.347
37.00
116
C3DGS Niedephiyy xt
252
LightCannstan Fain
2023
22.53
0.350
62.05
251
EAGLES (GiriS c am 20135
22.62
0.637
0.338
73.73
161
SSGS Medrentsien 2023
22.52
0.615
0.348
46.69
149
2024
103
Qual--rall
22,80
0.632
0.334
13.63
267
Ours
22.86
0.635
0.338
20.33
257
22

---

Published as a conference paper at ICLR 2025
Table 13: Quantitative results of rendering quality, storage size, and rendering speed on Tanks and Temples (Knapitsch al. 2017p. All storage sizes are in MB. We highlight the best score second-hest score and third-best score of compact representations.
Method
Train
Truck
PSNR
SSIM
LPIPS
Size -
FPS
PSNR
SSIM
LPIPS
FPS
3DGS (Kerbl al. 2033
21.95
0.810
0.210
266.6
201
25.38
0.878
0.148
638.2
150
Scaffoli Fir 2424
110.5
25.71
0.139
CompGS Navaneet et al 2024
21.83
0.802
0.221
14.40
170
25.22
0.872
0.156
22.75
162
Compact-3DCS Lze el 2024
21.64
0.792
0.241
17.64
203
25.02
0.870
0.163
20.30
196
C3DGS (Niedoraa 01
2024
21.61
0.800
0.233
13.61
311
24.98
0.871
0.168
14.85
346
LightGausain Fan sl
21.54
0.788
0.248
17.75
440
25.10
0.870
0.161
42.14
318
EAGLES (Girikl 2013
21.28
0.794
0.240
21.49
247
25.00
0.871
0.165
38.87
242
SSGS Morgestenn 2023
21.64
0.794
0.225
17.19
254
25.45
0.872
0.150
31.64
190
HAC Crar
22.22
0.813
0,217
7.10
136
25.95
0.879
0.155
9.75
122
Ours: Small
21.71
0.814
0.203
6.75
311
25.53
0.880
0:134
6.43
356
Ours
22.07
0.822
12.49
296
25.70
0.885
0.125
12.19
326
Table 14: Quantitative results of rendering quality, storage size, and rendering speed Deep Blending (eedman et al. 2018). All storag sizes in MB. We highlight the best score. second- besttd-bestte score and third-best score of compact representations.
Drjohnson
Playroom
Method
PSNR
SSTM
LPPPS
Size .
FPS
PSNR
SSIM
LPIPS
Size
FPS
3DGS (Kerhl al
2023
29.14
0.898
0.246
810.9
110
29.83
0.901
0.247
574.2
157
Scaffoli caree
0.245
CompGS Navancet et 2024
29.14
0.897
0.254
28.97
128
29.91
0.900
0.254
20.94
157
Compact-3DGS Leeret
2024
29.16
0.899
0.257
25.97
152
30.26
0.902
0.258
17.53
216
C3DGS (Niedertaty
2122
29.46
0.906
0.251
19.47
251
30.32
0:907
0.255
10.83
351
LightGaussian Fan 2al 20.3
28.75
0.894
0.262
$2.97
247
29.49
0.89
0.261
37.54
328
EAGLES (Giiist Cia 2025
29.32
0.906
0.244
71.52
98
30.12
0.907
0.254
37.38
176
SSGS Moggialen al
2023
28.81
0.886
0.277
19.98
210
29.61
0.897
0.264
18:66
239
HAC (Wi ai.
29.56
0.903
0.265
5.59
196
30.43
0.902
0.272
3.44
275
Ours-Small
29.85
0.904
0.244
10.22
214
30.40
0.906
0.256
5.06
454
Ours
29.84
0.904
0.240
16.02
208
30.49
0.907
0.248
10.75
386
23

---

Published as a conference paper at ICLR 2025
Bicycle
Garden
Shump
(a) Ground truth
(b) 3DGS
(c) Ours
Figure 11: Additional qualitative results on Mip-NeRF 360 (Barron et al. 2022
24

---

Published as a conference paper at ICLR 2025
Kitchen
Flowers
Treehill
(a) Ground truth
(b) 3DGS
(c) Ours
Figure 12: Additional qualitative results on Mip-NeRF 360 (Barron et al. 2022
25

---

Published as a conference paper at ICLR 2025
Bonsai
Counter
Room
(a) Ground truth
(b) 3DGS
(c) Ours
Figure 13: Additional qualitative results on Mip-NeRF 360 (Barron et al. 2022
26

---

Published as a conference paper at ICLR 2025
Train
Truck
(a) Ground truth
(b) 3DGS
(c) Ours
Figure 14: Additional qualitative results on Tanks and Temples (napitsch et al. 2017
27

---

Published as a conference paper at ICLR 2025
DrJohnson
Playroom
6
(a) Ground truth
(b) 3DGS
(c) Ours
Figure 15: Additional qualitative results Deep Blending (Hedman et al. 2018
28


Reviews:
[{"review_id": "X85BvNyMG1", "reviewer": "Reviewer_6k9A", "summary": "This paper tackles the high storage demands associated with 3D Gaussian Splatting by introducing an effective compression method. The core idea is to exploit local similarity within Gaussian attributes, representing them through compact, well-encoded local features. The authors start by conducting a statistical analysis of 3D Gaussian Splatting (3DGS) attributes and proceed to design a local feature that captures and encodes these similar patterns within a given region. By combining carefully structured steps—such as pruning, point cloud initialization, quantization, and entropy encoding—the proposed method achieves substantial compression of the 3DGS field. Remarkably, this compression is achieved while maintaining, or even enhancing, the rendering quality and fidelity relative to the original setup.", "questions": "1. Please include the number of Gaussians for the different ablation versions in Tab.3 to understand the main reason for high FPS.\n \n2 Decoding Time: Including the decoding time would help readers understand the applicability of the proposed method.", "limitations": "", "rating": 6, "confidence": 5, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. The overall solution is comprehensive, incorporating careful designs for initialization, pruning, and compression schemes for different components. \n2. The paper is well-written with a clear logical flow.\n3. The dense initialization demonstrates an interesting improvement in compression.\n4. The analysis of storage size in Tab.3 provides a valuable indication for the community about the current bottlenecks in compression.", "weaknesses": "1. Number of Gaussians in Variants: It would be beneficial to provide the number of Gaussians for different variants, as Ours-Sparse has a lower FPS compared to Ours-Small and Ours. Understanding whether the final number of Gaussians influenced the results is important. Including the point number counts along the training iteration would help illustrate the influence of different initializations. Additionally, it would be interesting to see if such an initialization design could improve the performance of previous approaches.\n2. The method still takes extra training time to compress a 3DGS, which will be a limitation in some real applications.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "O4zVwvwsA8", "reviewer": "Reviewer_5DLr", "summary": "The paper aims to achieve both high rendering speed and reduced storage size for 3D Gaussian Splatting-based scene representations. To this end, it analyzes the local coherence of Gaussians across several scenes and proposes exploiting multi-resolution hash grids. More specifically, Gaussians now have only base scale, positions, and base color, while hash grids fill in the details. In addition, the paper employs adaptive SH bandwidth, pruning, dense initialization, quantization, and encoding. With all these methods, the paper demonstrates significant performance improvement.", "questions": "How did you calculate cosine similarity of opacities?\nI would also like to know how and why three explicit attributes were selected.", "limitations": "", "rating": 8, "confidence": 4, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "The concept of locality is not novel in 3D Gaussian Splatting, but the paper effectively illustrates this through graphs. Moreover, it clearly addresses the differences between other locality-based methods (anchor-based methods), explaining why the proposed method is important and highlighting key points for readers already familiar with anchor-based representation.\n\nThe performance improvements in terms of size, rendering speed, and rendering quality are significant.\n\nAdditionally, the paper includes many technical details for adopting various techniques, especially during quantization and encoding, which will benefit those working in this research areas.", "weaknesses": "As I mentioned in the strength section, the idea of utilizing locality in 3D Gaussian Splatting is not novel.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "o2HpYGTBmM", "reviewer": "Reviewer_FMA7", "summary": "LocoGS analyzes the local coherence of the attributes of Gaussian primitives and introduces a novel representation that incorporates locality information. By utilizing the locality-aware 3D Gaussian representation along with other compression methods, such as quantization and encoding schemes, LocoGS achieves state-of-the-art compression performance and rendering FPS compared to existing compression methods.", "questions": "1. I would like to understand the reason why the rendering performance of LocoGS is lower than that of Scaffold-GS. Aside from the quantization and encoding schemes, do the authors discard the view input of the MLP when obtaining each attribute of the 3D Gaussians?\n2. How about the performance in large-scale datasets, like Mega-NeRF, Urbanscene3D or MatrixCity?\n\nIf the authors solve these questions, I’ll raise the score.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. LocoGS carefully analyzes the relationships among 3D Gaussian attributes and introduces a locality-aware representation based on these relationships.\n2. The paper is well written and easy to follow, with an excellent categorization of compression methods.\n3. LocoGS outperforms existing methods in both compression performance and rendering speed.", "weaknesses": "1. Dense initialization is not related to compression; it is merely a warm-up trick. It would be unfair for the authors to use this trick since all of the baselines still initialize with COLMAP points.\n2. As we know, the training time for Nerfacto is significantly longer than for 3DGS. Why do the authors choose to use Nerfacto for warm-up instead of 3DGS? Both methods can generate coarse depth maps, which can then be used to create an initialization point cloud. Additionally, how many iterations do the authors train Nerfacto for dense initialization?\n3. In the limitations section, the authors describe that LocoGS requires one hour more training time than the baselines. Which components affect the training efficiency—is it the dense initialization?\n4. No demos submitted.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "lYQumtwKTD", "reviewer": "Reviewer_EsF7", "summary": "The paper introduces \"LocoGS,\" a locality-aware 3D Gaussian Splatting (3DGS) framework designed for fast and high-quality rendering. This framework capitalizes on the spatial coherence among 3D Gaussians to offer a compact, efficient representation that significantly reduces storage requirements and enhances rendering speed without sacrificing quality. \n\nKey contributions include:\n1. A new locality-aware 3D Gaussian representation that efficiently encodes locally-coherent Gaussian attributes.\n2. Implementation of additional components like dense initialization, Gaussian pruning, adaptive spherical harmonics bandwidth scheme, and tailored encoding schemes to maximize compression performance.\n3. Demonstrated superior performance over existing methods in terms of compression ratio and rendering speed, verified through extensive experiments.", "questions": "1. Are there scenarios or conditions under which the proposed method might not perform as expected? e.g. large scenes.\n2. Could you provide more detailed explanations or pseudo-codes for complex components like the adaptive SH bandwidth and pruning strategy? Are you going to publish your code?\n3. Does your model also perform better in larger scenes? Can you please add more experiments on how it performs in larger scenes? e,g. Miller-19 dataset.", "limitations": "", "rating": 3, "confidence": 5, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. The locality-aware strategy for Gaussian attribute representation is a novel approach that leverages spatial coherence effectively.\n2. The paper includes detailed comparisons with existing methods, showing improvements in storage efficiency and rendering speed. The reduced storage and increased speed facilitate the practical application of 3DGS in real-time scenarios, like mobile devices.\n3. The motivation and clarity of the paper are commendable.", "weaknesses": "1. The multiple components introduced (e.g., multi-resolution hash grids, and adaptive SH bandwidths) might complicate the implementation and tuning of the framework.\n2. The paper could benefit from more discussion on any potential trade-offs or limitations, particularly in different or more challenging rendering environments. e.g. metal and lighting area.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)