MEGS^{2}: Memory-Efficient Gaussian Splatting via Spherical Gaussians and Unified Pruning

## Abstract

Abstract 3D Gaussian Splatting (3DGS) has emerged as a dominant novel-view synthesis technique, but its high memory consumption severely limits its applicability on edge devices.
A growing number of 3DGS compression methods have been proposed to make 3DGS more efficient, yet most only focus on storage compression and fail to address the critical bottleneck of rendering memory.
To address this problem, we introduce MEGS 2 , a novel memory-efficient framework that tackles this challenge by jointly optimizing two key factors: the total primitive number and the parameters per primitive, achieving unprecedented memory compression.
Specifically, we replace the memory-intensive spherical harmonics with lightweight, arbitrarily oriented spherical Gaussian lobes as our color representations.
More importantly, we propose a unified soft pruning framework that models primitive-number and lobe-number pruning as a single constrained optimization problem.
Experiments show that MEGS 2 achieves a 50 % \% static VRAM reduction and a 40% rendering VRAM reduction compared to existing methods, while maintaining comparable rendering quality. Project page: https://megs-2.github.io/

## 1 Introduction

Although 3D Gaussian Splatting (3DGS) (Kerbl et al., 2023) has been rapidly replacing implicit neural radiance fields (NeRF) (Mildenhall et al., 2020) as the dominant paradigm in neural rendering, thanks to its fast reconstruction, real-time performance, and high-quality outputs, supporting its application across devices with varying constraints has become increasingly important. As a result, compression of 3DGS (Bagdasarian et al., 2025) is gaining significantly more attention, with the goal of enabling real-world use cases on edge devices, such as mobile 3D scanning and previewing, virtual try-on, and real-time rendering in video games.

Nevertheless, existing compression methods only focus on storage compression rather than memory compression.
While the former storage compression speeds up the one-time data transfer of 3DGS files, the rendering memory dictates whether the 3DGS rendering process can run smoothly on edge devices.
This limits the applicability of 3DGS applications to low-end devices like cell phones.
For example, some methods based on neural compression, vector quantization, and hash grid compression (Chen et al., 2024; Girish et al., 2024; Lee et al., 2024) achieve high storage compression rates.
However, these methods require decoding the full Gaussian parameters from a compressed state before rendering, even resulting in a larger rendering memory than the 3DGS methods without compression.
Another branch of works, i.e., primitive pruning methods (Zhang et al., 2025b; Fang & Wang, 2024), is effective at reducing both storage and rendering memory due to the reduced primitives.
However, these pruning methods still need to retain a substantial number of 3D Gaussians for a reasonable rendering quality, which still consumes a large rendering memory. How to further reduce the rendering memory of 3DGS-based rendering methods remains an open question.

In this paper, we observe that the overall memory consumption for 3DGS rendering is intrinsically tied to two key factors: the total primitive count and the parameters per primitive.
Thus, we propose a novel framework that simultaneously reduces both factors, rather than only optimizing for the primitive numbers in previous methods Zhang et al. (2025b); Fang & Wang (2024).
Specifically, the rendering VRAM can be divided into a static component and a dynamic component. The static part relates directly to the total number of Gaussian primitives loaded into the renderer, which is a product of the primitive count and the parameters per primitive. On the other hand, the dynamic part, which consists of intermediate data like projected 2D Gaussian parameters and the tile-depth-gaussian key-value table, is also related to the primitive count in the specific camera viewpoint. This inherent relationship underscores that to reduce the overall memory footprint, we need to reduce both the number of primitives and the per-primitive parameter size.

Based on this analysis, we conclude that to truly address the memory bottleneck, we must reduce both the number of primitives and the number of parameters per primitive.
To this end, we first analyze the limitations of using Spherical Harmonics (SH) for color representation. While effective for low-frequency lighting, SH functions are inherently global and require many high-order coefficients to represent localized, high-frequency details like sharp highlights. This results in low parameter utilization and makes them difficult to compress due to the varying parameter counts across different degrees.
Building upon this, we introduce the use of Spherical Gaussians (SG) as a more memory-efficient alternative. Spherical Gaussians excel at modeling view-dependent signals with very few parameters, and their complexity can be flexibly controlled by the number of lobes. This inherent locality and sparsity make them a much more convenient and effective choice for compression.

Based on the SG-based representation, we further introduce a novel unified soft pruning framework. We leverage the favorable properties of Spherical Gaussians to dynamically prune redundant lobes for each primitive, thereby compressing the per-primitive parameter count. To achieve a globally optimal memory footprint, our framework models the two traditionally separate pruning problems—primitive-count pruning and per-primitive lobe pruning—as a single constrained optimization problem, with the total parameter budget serving as a unified constraint. Extensive experiments demonstrate that the proposed MEGS^2 achieves an excellent balance between rendering quality and VRAM efficiency.

Overall, our contributions can be summarized as follows:

- •
We introduce a novel color representation for 3DGS by replacing spherical harmonics with arbitrarily-oriented spherical Gaussians, which significantly reduces the per-primitive parameter count and thus lowers rendering VRAM with minimal impact on quality.
- •
We propose a unified soft pruning framework that models both primitive-count and lobe-pruning as a memory-constrained optimization problem, which yields superior performance compared to existing staged or hard-pruning methods.
- •
We achieve unprecedented memory compression for 3DGS, surpassing both vanilla and state-of-the-art lightweight methods. Our method delivers over an 8$\times$ static VRAM compression and nearly a 6$\times$ rendering VRAM compression compared to vanilla 3DGS, while maintaining or even improving rendering quality. Furthermore, it still achieves a  2$\times$ static VRAM compression and a 40% rendering VRAM reduction over the SOTA method, GaussianSpa, with comparable quality.

## 2 Related work

### 2.1 Evolution of Splatting-Based Scene Representations

While Neural Radiance Fields (NeRF) (Mildenhall et al., 2020) and their variants (Barron et al., 2021; Müller et al., 2022; Barron et al., 2023) achieved excellent quality in novel view synthesis, their slow rendering speeds precluded real-time applications. 3D Gaussian Splatting (3DGS) (Kerbl et al., 2023) overcame this limitation by introducing a differentiable rasterizer for 3D Gaussians, enabling unprecedented real-time performance with high visual fidelity. The success of 3DGS, however, highlighted its primary challenge: a substantial memory and storage footprint. This has directly motivated the body of work on 3DGS compression and pruning that we discuss subsequently.

### 2.2 Memory Analysis in 3DGS Rendering

In most 3DGS compression studies (Bagdasarian et al., 2025), the rendering memory footprint has not been thoroughly analyzed or compared. Memory usage can be conceptualized into two main components: a static portion, consisting of the total parameters of all loaded Gaussian primitives, and a dynamic portion, representing the runtime overhead. The dynamic overhead, which is highly dependent on a renderer’s implementation, includes the storage of preprocessed 2D Gaussian attributes—an overhead that scales significantly with the number of rendering channels, as seen in multi-channel applications like Feature Splatting (Qiu et al., 2024). Additionally, it includes data structures required by tile-based renderers, an overhead first discussed and optimized by FlashGS (Feng et al., 2024) for large-scale scenes.

### 2.3 Pruning Techniques for 3DGS

Pruning unimportant primitives is a natural and widely explored approach for 3DGS compression. Some work has focused on refining adaptive density control strategies to achieve more efficient representations (Kheradmand et al., 2025; Cheng et al., 2024; Liu et al., 2024a; Pateux et al., 2025; Mallick et al., 2024; Kim et al., 2024).
Other research has concentrated on defining better importance metrics to decide which primitives to remove, with notable examples including LP-3DGS (Zhang et al., 2024), mini-splatting (Fang & Wang, 2024), and Reduced3DGS (Papantonakis et al., 2024), the latter of which also involves spherical harmonic pruning.
A recent noteworthy development is GaussianSpa (Zhang et al., 2025b), which models pruning as a constrained optimization problem, offering a novel perspective and good compatibility with other pruning techniques. While effective at reducing the number of primitives, these methods generally achieve a limited compression ratio and are therefore often used as an initial step within a larger, integrated compression pipeline.

### 2.4 Other Compression Schemes for 3DGS

Besides pruning, researchers have applied common compression techniques like vector quantization, scalar quantization, neural, and hash grid compression to 3DGS (Girish et al., 2024; Lee et al., 2024; Wang et al., 2024a; Lee et al., 2025; Liu et al., 2024b; Navaneet et al., 2024; Xie et al., 2024). While methods with entropy encoding (Chen et al., 2024; 2025; Liu et al., 2025; Wang et al., 2024c) achieve the highest storage compression ratios, they are often limited to structured (anchor-based) Gaussian representations (Lu et al., 2023; Ren et al., 2024; Zhang et al., 2025a). These techniques may drastically reduce file size, but they fail to deliver a comparable reduction in rendering memory. This is because they cannot render directly from a compressed state; instead, they must first decode the full Gaussian parameters. The resulting memory footprint is, therefore, never smaller than that required for uncompressed Gaussian primitives, and the decoding process itself, particularly when involving neural networks, can introduce significant additional memory overhead.

## 3 Method

We present MEGS^2, Memory-Efficient Gausian Splatting via Spherical Gaussian and Unified Pruning, a novel Gaussian compression framework designed from a VRAM-centric perspective. Our method achieves an optimal balance between rendering quality and memory footprint by simultaneously optimizing both the number of Gaussian primitives and the average parameters per primitive.

Figure: Figure 2: Overview of our proposed MEGS^2. (A) In Section [3.2](https://arxiv.org/html/2509.07021v2#S3.SS2), we first replace the Spherical Harmonics with Spherical Gaussians. (B) In Section [3.3.1](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS1), we formulate the compression as a memory-constrained optimization problem, which is solved using an ADMM-inspired approach (Section [3.3.2](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS2)). (C) In Section [3.3.3](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS3), near-invalid primitives and low-sharpness lobes are removed, and a color compensation term (Eq.[12](https://arxiv.org/html/2509.07021v2#S3.E12)) is introduced to recover the energy of the removed lobes.
Refer to caption: x2.png

### 3.1 Preliminaries for 3D Gaussian Splatting

3D Gaussian Splatting (3DGS) (Kerbl et al., 2023) represents a scene using a set of 3D Gaussian primitives. Each primitive is defined by a center $\mu\in\mathbb{R}^{3}$, a covariance matrix $\Sigma\in\mathbb{R}^{3\times 3}$, a scalar opacity $o$, and a view-dependent color model. The color is determined by a function $c(\mathbf{v}):\mathbb{S}^{2}\to\mathbb{R}^{3}$, which maps a viewing direction $\mathbf{v}$ to an RGB color. In the original work, this function is modeled using Spherical Harmonics (SH).

To render an image, these 3D primitives are projected onto the 2D image plane. The final pixel color is computed by alpha-blending the primitives that overlap with the pixel in front-to-back order, according to the equation: $C=\sum_{i}c_{i}\alpha_{i}\prod_{j=1}^{i-1}(1-\alpha_{j})$. Here, the rendering opacity $\alpha_{i}$ is a product of the primitive’s scalar opacity $o_{i}$ and its 2D Gaussian value at the pixel location.

### 3.2 Spherical Gaussians

Although the original 3D Gaussian Splatting (3DGS) utilized Spherical Harmonics (SH) for color modeling, as we discussed in Section [1](https://arxiv.org/html/2509.07021v2#S1), SH functions suffer from limitations in parameter efficiency and the ability to model local and high-frequency signals.

In contrast, Spherical Gaussians (SG) offer a more compact representation, where the parameter count can be controlled by adjusting the number of lobes. As we demonstrated in Figure [4](https://arxiv.org/html/2509.07021v2#A1.F4), a three-lobe SG requires only about half the parameters of a 3rd-order SH while achieving comparable expressive power and superior high-frequency detail capture because, in most cases, we only need to model highlights. Furthermore, as shown in Table [2](https://arxiv.org/html/2509.07021v2#S4.T2), SG is more amenable to pruning than SH.

SG was first introduced in real-time rendering to support all-frequency shadows from both point lights and environment lights (Wang et al., 2009). Specifically, a lobe of SG has the form

$$ $G(\mathbf{v};\mathbf{\mu},s,a)=ae^{s(\mathbf{\mu}\cdot\mathbf{v}-1)},$ (1) $$

where $\mathbf{\mu}\in\mathbb{S}^{2}$ is the unit-length lobe axis, $s\in\mathbb{R}^{+}$
controls the sharpness, and $a\in\mathbb{R}^{3}$ is the RGB amplitude vector, with $\mathbf{v}\in\mathbb{S}^{2}$ being the viewing direction.

We use the sum of all lobes of SG for color modeling and introduce a diffuse term to model the direction-independent component. The view-dependent color $c(\mathbf{v})$ is thus computed as:

$$ $c(\mathbf{v})=c_{0}+\sum_{i=1}^{n}G(\mathbf{v};\mathbf{\mu}_{i},s_{i},a_{i}).$ (2) $$

where $c(\mathbf{v})\in\mathbb{R}^{3}$ is the final color from the viewing direction $\mathbf{v}\in\mathbb{S}^{2}$, $c_{0}\in\mathbb{R}^{3}$ is the direction-independent diffuse color, and the sum is over $n$ all lobes of SG, with $\mathbf{\mu}_{i}\in\mathbb{S}^{2}$ being the lobe axis, $s_{i}\in\mathbb{R}^{+}$ the sharpness, and $a_{i}\in\mathbb{R}^{3}$ the RGB amplitude for the $i$-th spherical lobe.

Choice of arbitrarily-oriented SG lobes It is particularly notable that the lobe axes of different SG are not constrained to be orthogonal, nor is any regularization term introduced to enforce orthogonality. Instead, each SG lobe is allowed to have an arbitrary direction. This flexibility grants the SG model a higher degree of freedom, leading to greater representation capability compared to models with fixed orthogonal axes.
As shown in Figure [4](https://arxiv.org/html/2509.07021v2#A1.F4) (in Appendix), SG-Splatting (Wang et al., 2024b) with fixed orthogonal axes demonstrated significant rendering performance degradation, further underscoring the importance of supporting arbitrarily oriented SG lobes.

### 3.3 Unified soft-pruning framework

Benefiting from the property of Spherical Gaussians to control the number of parameters with the number of lobes, they provide an ideal object for pruning. Given that most Gaussian primitives in a scene require only a few lobes to effectively model their color, and that the number of Gaussian primitives is itself often redundant, we propose a novel unified soft pruning framework.
In the framework, we first redefine the pruning of both Gaussian primitives and spherical lobes as a unified optimization problem with a total memory-overhead constraint (Section [3.3.1](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS1)). To handle the non-differentiable nature of this constraint, we introduce an ADMM-inspired algorithm to efficiently solve the problem (Section [3.3.2](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS2)). After optimization, the model enters a post-processing procedure where the final primitives and spherical lobes are removed, with rendering quality subsequently recovered through a color compensation strategy and minor fine-tuning (Section [3.3.3](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS3)).

#### 3.3.1 Problem Formulation

We unify primitive count pruning and spherical lobe pruning into a memory-constrained optimization problem. The $L_{0}$ norm of the opacity vector represents the number of active primitives, as primitives with zero opacity do not contribute to rendering. Similarly, the $L_{0}$ norm of the sharpness vector denotes the number of active spherical lobes, since lobes with zero sharpness exhibit no view-dependent effect and their color can be directly added to the diffuse term $c_{0}$.
Building upon GaussianSpa (Zhang et al., 2025b)’s sparsification framework and our analysis, we extend the pruning objective from primitive count optimization to total memory budget control, formalized as:

$$ $\min_{\mathbf{o},\mathbf{s},\Theta}\mathcal{L}(\mathbf{o},\mathbf{s},\Theta),\quad\text{s.t.}\quad\underbrace{\rho_{o}\|\mathbf{o}\|_{0}+\rho_{s}\|\mathbf{s}\|_{0}\leq\kappa}_{\text{total memory constraint}}$ (3) $$

where $\mathbf{o}\in\mathbb{R}^{N\times 1}$ means opacity vector for $N$ Gaussian primitives, $\mathbf{s}\in\mathbb{R}^{N\times 3}$ means flattened sharpness vector for $N$ Gaussians, $\Theta\in\mathbb{R}^{N\times 13}$ (other Gaussian variables), $\rho_{o}=11$ and $\rho_{s}=7$ count base parameters for a single Gaussian primitive and a single SG lobe respectively, and $\kappa$ is the total parameter budget. $\mathcal{L}(\mathbf{o},\mathbf{s},\Theta)$ is the reconstruction loss function.

Figure: Algorithm 1 Memory-constrained optimizing

#### 3.3.2 Memory-constrained Optimization

In this subsection, we aim to solve the memory-constrained optimization defined in Section [3.3.1](https://arxiv.org/html/2509.07021v2#S3.SS3.SSS1). Due to the introduction of a non-differentiable component (the $L_{0}$ norm) into the constraint, we cannot directly optimize it with regularized stochastic gradient descent. Instead, we adopt an ADMM-inspired approach by introducing proxy variables $\tilde{\mathbf{o}}$ and $\tilde{\mathbf{s}}$ for $\mathbf{o}$ and $\mathbf{s}$, respectively. This decomposition strategy enables us to split the original optimization problem into two tractable subproblems:

$$ $\min_{\mathbf{o},\mathbf{s},\Theta}\mathcal{L}(\mathbf{o},\mathbf{s},\Theta)+\frac{\delta}{2}\left(\rho_{o}\|\mathbf{o}-\tilde{\mathbf{o}}+\bm{\lambda}_{\mathbf{o}}\|^{2}+\rho_{s}\|\mathbf{s}-\tilde{\mathbf{s}}+\bm{\lambda}_{\mathbf{s}}\|^{2}\right)$ (4) $$

$$ $\min_{\tilde{\mathbf{o}},\tilde{\mathbf{s}}}h(\tilde{\mathbf{o}},\tilde{\mathbf{s}})+\frac{\delta}{2}\left(\rho_{o}\|\mathbf{o}-\tilde{\mathbf{o}}+\bm{\lambda}_{\mathbf{o}}\|^{2}+\rho_{s}\|\mathbf{s}-\tilde{\mathbf{s}}+\bm{\lambda}_{\mathbf{s}}\|^{2}\right)$ (5) $$

where $h(\cdot,\cdot)$ is an indicator function enforcing the sparsity constraint:

$$ $h(\mathbf{o},\mathbf{s})=\begin{cases}0&\text{if }\rho_{o}\|\mathbf{o}\|_{0}+\rho_{s}\|\mathbf{s}\|_{0}\leq\kappa,\\ +\infty&\text{otherwise}\end{cases}$ (6) $$

and the proxy variables are updated via the proximal operator:

$$ $(\tilde{\mathbf{o}},\tilde{\mathbf{s}})=\mathbf{prox}_{h}(\mathbf{o}+\bm{\lambda}_{\mathbf{o}},\mathbf{s}+\bm{\lambda}_{\mathbf{s}}).$ (7) $$

Here, $\bm{\lambda}_{\mathbf{o}}$ and $\bm{\lambda}_{\mathbf{s}}$ denote the corresponding Lagrange multipliers for the constraints.
The specific algorithm flow can be found in Algorithm [1](https://arxiv.org/html/2509.07021v2#alg1), and the detailed derivation is in Appendix [A.1.1](https://arxiv.org/html/2509.07021v2#A1.SS1.SSS1).

Proximal Operator Implementation The proximal operator projects $\mathbf{o}$ and $\mathbf{s}$ onto the constraint $\rho_{o}\|\mathbf{o}\|_{0}+\rho_{s}\|\mathbf{s}\|_{0}\leq\kappa$, compatible with any importance metric. To simplify the design and leverage importance criteria from prior primitive-pruning research, we choose to factorize the projection:

$$ $\tilde{\mathbf{o}}=\mathbf{prox}_{h}(\mathbf{o}+\bm{\lambda}_{\mathbf{o}}),\left\|\tilde{\mathbf{o}}\right\|_{0}<\kappa_{\mathbf{o}}$ (8) $$

$$ $\tilde{\mathbf{s}}=\mathbf{prox}_{h}(\mathbf{s}+\bm{\lambda}_{\mathbf{s}}),\left\|\tilde{\mathbf{s}}\right\|_{0}<\kappa_{\mathbf{s}}$ (9) $$

For opacity projection, Zhang et al. (2025b) has established multiple proximal operators that are selected based on scene characteristics. Our approach reuses these operators (See Appendix [A.2](https://arxiv.org/html/2509.07021v2#A1.SS2)).

For sharpness projection, we propose two distinct operators:

- •
Sharpness-Based Selection: Sorts $(\mathbf{s}\!+\!\bm{\lambda}_{\mathbf{s}})$ and preserves the $\kappa_{s}$ elements with highest magnitudes, where $\kappa_{s}$ controls the number of active spherical harmonic coefficients.
- •
Range-Based Selection: Similarly, Retains $\kappa_{s}$ elements using the dynamic range metric:
$D_{i}=|\max_{\mathbf{v}}(c_{i})-\min_{\mathbf{v}}(c_{i})|=|a_{i}|(1-e^{-2s_{i}})$
(10)
where $a_{i}$ is the RGB amplitude for the $i$-th spherical lobe.

Discussion: Sequential vs. Unified Pruning While sequential pruning tackles memory reduction in a two-stage process—first reducing primitive count, then per-primitive parameters—our unified framework jointly optimizes both factors as a single problem. This approach finds a better trade-off between primitive count and per-primitive complexity, thus avoiding the sub-optimal solutions often found by sequential methods. For a detailed experimental validation, please refer to Section [4.4.2](https://arxiv.org/html/2509.07021v2#S4.SS4.SSS2).

#### 3.3.3 Post-Processing Procedure

After completing the constrained optimization process, we obtain a large number of primitives and spherical lobes with near-zero opacity and sharpness values, respectively. As the hard constraints are enforced on the proxy variables rather than the original ones, these near-zero values must still be pruned to achieve an actual memory and storage benefit. We address this with a three-step post-processing strategy: first, we remove Gaussian primitives whose opacity falls below a certain threshold. Then, for spherical lobes, we remove those with negligible sharpness and introduce a simple color compensation method to minimize the average per-view color variation and mitigate performance degradation caused by their removal.

This compensation is achieved by finding an optimal term, $\Delta c_{0}$, that minimizes the integral of the squared color difference over all view directions on the unit sphere:

$$ $\min_{\Delta c_{0}}\int_{\mathbb{S}^{2}}\left((c_{0}+\Delta c_{0})-(c_{0}+G(\mathbf{v};\mathbf{\mu}_{i},s_{i},a_{i}))\right)^{2}d\mathbf{v}$ (11) $$

Solving equation [11](https://arxiv.org/html/2509.07021v2#S3.E11) yields an exact compensation term that preserves the color of the removed lobe:

$$ $\Delta c_{0}=a_{i}\cdot\frac{1-e^{-2s_{i}}}{2s_{i}}$ (12) $$

The diffuse term of the parent primitive is then updated with this value:

$$ $c_{0}^{\prime}=c_{0}+\Delta c_{0}$ (13) $$

Finally, after removing some primitives and spherical lobes, we continue to fine-tune for a small number of steps to recover the rendering quality. The detailed derivation is in Appendix [A.1.2](https://arxiv.org/html/2509.07021v2#A1.SS1.SSS2)

## 4 Experiments

### 4.1 Experimental Settings

Datasets and Metrics Following 3DGS (Kerbl et al., 2023), we evaluate the rendering performance on real-world datasets, including all indoor scenes and outdoor scenes in Mip-NeRF360 (Barron et al., 2022), two scenes from Tanks & Temples (Knapitsch et al., 2017), and two scenes from Deep Blending (Hedman et al., 2018). Additionally, we measure the VRAM overhead during the Gaussian loading (static) and rendering stages on these scenes.

Baselines On all datasets, we benchmark our method against four categories of baselines:
(1) vanilla 3DGS (Kerbl et al., 2023) and SG-Splatting (Wang et al., 2024b);
(2) lightweight 3DGS methods based on primitive pruning: LP-3DGS (Zhang et al., 2024), Mini-Splatting (Fang & Wang, 2024), and GaussianSpa (Zhang et al., 2025b);
(3) lightweight 3DGS methods based on pruning spherical harmonic coefficients: Reduced3DGS (Papantonakis et al., 2024);
(4) 3DGS compression methods utilizing orthogonal techniques such as neural compression and vector quantization: CompactGaussian (Lee et al., 2024), EAGLES (Girish et al., 2024), and MesonGS (Xie et al., 2024).

Experimental Setup To ensure a fair comparison, we follow the core training procedures established by 3DGS (Kerbl et al., 2023) and GaussianSpa (Zhang et al., 2025b). We evaluate rendering quality using PSNR, SSIM, and LPIPS, and measure efficiency via static and rendering VRAM consumption. For a detailed description of our specific implementation, as well as the definitions and measurement procedures for both static and rendering VRAM, please refer to Appendix [A.2](https://arxiv.org/html/2509.07021v2#A1.SS2).

### 4.2 Main Results and Analysis

The quantitative results are summarized in Table [1](https://arxiv.org/html/2509.07021v2#S4.T1), comparing our approach with several existing lightweight 3DGS methods. Overall, our method achieves comparable or slightly superior rendering quality to the current state-of-the-art lightweight 3DGS methods, while demonstrating significantly lower VRAM overhead across all existing methods.
Compared to vanilla 3DGS, our method achieves a 0.4 dB PSNR improvement on the DeepBlending dataset and a 0.012 LPIPS reduction on the Tanks & Temples dataset. Furthermore, it achieves more than an 8$\times$ compression rate for static VRAM and nearly a 6$\times$ compression rate for rendering VRAM across all datasets.
Even when compared to the current state-of-the-art lightweight 3DGS method, GaussianSpa (Zhang et al., 2025b), we still achieve a nearly 2$\times$ compression rate for static VRAM on the Mip-NeRF360 dataset and reduce rendering VRAM by approximately 40% with comparable rendering quality.

Analysis on Existing Compression Methods Many recent methods achieve high storage compression but fail to reduce VRAM. Techniques based on hash grid compression, vector quantization or neural networks (e.g., CompactGaussian (Lee et al., 2024), EAGLES (Girish et al., 2024)) must first decompress their parameters into a renderable state. This requirement, coupled with the decoding process itself, results in a VRAM footprint that can exceed even vanilla 3DGS (Appendix, Tab. [3](https://arxiv.org/html/2509.07021v2#A1.T3)). Similarly, HAC++ (Chen et al., 2025), a SOTA method designed specifically for anchor-based 3DGS, is not a general solution and offers minimal VRAM reduction for the same reason. In contrast, our method achieves superior perceptual quality (SSIM/LPIPS) with 50-60% less VRAM and a 1.5-1.7x rendering speedup.

Analysis on Pruning-based Methods Pruning-based methods (Zhang et al., 2025b; Fang & Wang, 2024; Zhang et al., 2024) effectively reduce VRAM but face a bottleneck, as aggressively reducing primitive count degrades quality. Our method overcomes this by not only pruning primitives but also reducing per-primitive costs. When compared to methods that also compress color, such as Reduced3DGS (Papantonakis et al., 2024) which prunes SH coefficients, our advantage is twofold: the superior amenability of our Spherical Gaussians to pruning, and our more effective unified soft pruning framework, as validated in Section [4.4](https://arxiv.org/html/2509.07021v2#S4.SS4).

**Table 1: Quantitative comparison across three datasets. Best results are in red region, second best are in orange region. Memory (VRAM) values are in MB.**
| Method | Mip-NeRF 360 | Tanks&Temples | DeepBlending |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | VRAM$\downarrow$ | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | VRAM$\downarrow$ | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | VRAM$\downarrow$ |  |  |  |  |
| Stat. | Rend. | Stat. | Rend. | Stat. | Rend. |  |  |  |  |  |  |  |  |  |  |
| 3DGS | 27.48 | 0.813 | 0.217 | 648 | 1717 | 23.68 | 0.849 | 0.171 | 370 | 1021 | 29.71 | 0.902 | 0.242 | 582 | 1569 |
| SG-Splatting | 27.27 | 0.813 | 0.218 | 416 | 1327 | 23.47 | 0.840 | 0.177 | 229 | 822 | 29.57 | 0.901 | 0.247 | 357 | 983 |
| Reduced3DGS | 27.21 | 0.810 | 0.225 | 191 | 493 | 23.51 | 0.839 | 0.187 | 90 | 252 | 29.60 | 0.902 | 0.248 | 121 | 340 |
| CompactGaussian | 27.08 | 0.798 | 0.247 | 267 | 838 | 23.32 | 0.831 | 0.201 | 177 | 469 | 29.79 | 0.901 | 0.258 | 187 | 532 |
| EAGLES | 27.23 | 0.810 | 0.240 | – | – | 23.37 | 0.840 | 0.200 | 333 | 965 | 29.86 | 0.910 | 0.250 | 510 | 1550 |
| MesonGS-FT | 26.98 | 0.801 | 0.233 | 709 | 1336 | 23.32 | 0.837 | 0.193 | 424 | 783 | 29.51 | 0.901 | 0.251 | 656 | 1202 |
| LP-3DGS | 27.12 | 0.805 | 0.239 | 420 | 1239 | 23.41 | 0.834 | 0.198 | 251 | 769 | – | – | – | – | – |
| Mini-Splatting | 27.40 | 0.821 | 0.219 | 125 | 477 | 23.45 | 0.841 | 0.186 | 72 | 253 | 30.05 | 0.909 | 0.254 | 89 | 324 |
| GaussianSpa | 27.56 | 0.824 | 0.215 | 115 | 448 | 23.73 | 0.857 | 0.162 | 106 | 336 | 30.00 | 0.912 | 0.239 | 104 | 372 |
| Ours | 27.54 | 0.824 | 0.209 | 55 | 265 | 23.45 | 0.853 | 0.159 | 51 | 211 | 30.17 | 0.912 | 0.233 | 54 | 243 |
| 27.21 | 0.814 | 0.227 | 40 | 224 | 23.27 | 0.851 | 0.167 | 37 | 163 | 30.01 | 0.908 | 0.246 | 33 | 193 |  |

### 4.3 Qualitative Results

Figure [3](https://arxiv.org/html/2509.07021v2#S4.F3) presents a qualitative comparison of MEGS^2 against baselines, including GaussianSpa and 3DGS on various scenes. In Bicycle and Truck, our method accurately recovers specular reflections on smooth surfaces and mirrors, details that other methods fail to fully capture. In Bonsai, MEGS^2 faithfully captures high-contrast lighting in both contours and brightness. Furthermore, MEGS^2 delivers a cleaner and more complete reconstruction in Playroom. Notably, MEGS^2 achieves these high-quality results with a VRAM footprint of only 50-60% compared to GaussianSpa, demonstrating a substantial enhancement in memory efficiency. These visual results indicate that our Spherical Gaussian based representation has a stronger capability for fitting local view-dependent signals than Spherical Harmonics, leading to sharper and more photorealistic images.

Figure: Figure 3: Qualitative results on the Bicycle, Bonsai, Kitchen, Playroom and Truck scenes comparing to previous methods and the corresponding ground truth images from test views. The rendering VRAM consumption for the corresponding method is annotated at the bottom of each image.
Refer to caption: x3.png

### 4.4 Ablation Studies

In this section, we conduct a series of ablation studies to validate the effectiveness of our proposed designs and answer two key questions: 1. Is the replacement of spherical harmonics with spherical Gaussians necessary? And why not use the theoretically lighter-weight orthogonal-axis spherical variants? (Section [4.4.1](https://arxiv.org/html/2509.07021v2#S4.SS4.SSS1))
2. Is our proposed unified soft pruning framework effective? And does it offer a significant advantage over simply combining existing pruning methods? (Section [4.4.2](https://arxiv.org/html/2509.07021v2#S4.SS4.SSS2))

#### 4.4.1 Ablation on Color Modeling

To validate our color model, we replace the spherical harmonics (SH) in 3DGS with our arbitrarily-oriented spherical Gaussians (SG) while keeping training settings identical. Our SG model achieves a superior quality-VRAM trade-off (see Appendix, Fig. [4](https://arxiv.org/html/2509.07021v2#A1.F4)).
Furthermore, we show that the fixed-axis SG from SG-Splatting (Wang et al., 2024b) struggles to capture complex view-dependent effects, leading to a sharp quality drop (about 0.6 dB PSNR). This rigidity also makes it incompatible with our lobe-pruning strategy.

**Table 2: Ablation studies for different pruning strategies on Mip-NeRF360 dataset.**
| Method | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | VRAM$\downarrow$ |
| --- | --- | --- | --- | --- |
| Spa+Redu. | 26.05 | 0.776 | 0.280 | 402 |
| Spa(SH $\to$ SG) | 27.01 | 0.808 | 0.230 | 339 |
| soft $\to$ hard | 27.23 | 0.814 | 0.228 | 288 |
| unified $\to$ seq. | 27.33 | 0.818 | 0.222 | 328 |
| w/o color comp. | 27.46 | 0.822 | 0.213 | 265 |
| full model | 27.54 | 0.824 | 0.209 | 265 |

#### 4.4.2 Ablation on Pruning Strategies

We evaluate our unified soft pruning framework against several ablations and baselines, with results in Table [2](https://arxiv.org/html/2509.07021v2#S4.T2).
First, replacing our soft pruning with a hard-pruning variant (soft → hard) that only optimizes opacity results in a significant performance drop. Second, performing primitive and lobe pruning sequentially (unified → sequential) is inferior to our joint optimization, confirming the advantage of a unified approach. We also found that removing our color compensation harms performance (w/o color comp.).
Finally, we test two naive baselines. Combining GaussianSpa with Reduced3DGS leads to severe quality degradation, showing that existing SH pruning metrics fail on fewer primitives. Simply replacing SH with SG in GaussianSpa is also outperformed by our method. This demonstrates that our pruning strategy not only reduces memory but also acts as a regularizer, improving rendering quality.

## 5 Conclusion

We introduced MEGS^2, a framework that addresses the 3D Gaussian Splatting memory bottleneck by jointly optimizing primitive count and per-primitive parameters. Our approach combines a lightweight spherical Gaussian color representation with a unified soft pruning method to achieve state-of-the-art memory compression. MEGS² shifts the focus of 3DGS compression towards rendering VRAM efficiency, paving the way for high-quality rendering on edge devices.

Limitation Our method focuses on compressing static memory for broad, renderer-agnostic applicability. We leave the optimization of implementation-specific dynamic VRAM for future work, and note that the model’s performance on highly complex highlights warrants further investigation.

### Ethics statement

Our work presents no direct ethical concerns. The primary application of our method is for novel view synthesis from captured data.

### Reproducibility statement

To ensure reproducibility: (1) While not included with this submission, our full project (including the WebGL renderer, training, and evaluation scripts) will be released on GitHub upon publication.
(2) All experimental details, including our VRAM measurement protocol, are provided in Appendix [A.2](https://arxiv.org/html/2509.07021v2#A1.SS2).
(3) Our data and preprocessing follow the official 3DGS implementation.
(4) Derivations and proofs for our core algorithms are in Appendix [A.1.1](https://arxiv.org/html/2509.07021v2#A1.SS1.SSS1) and [A.1.2](https://arxiv.org/html/2509.07021v2#A1.SS1.SSS2).

## References

- Bagdasarian et al. (2025)
Milena T. Bagdasarian, Paul Knoll, Yi-Hsin Li, Florian Barthel, Anna Hilsmann, Peter Eisert, and Wieland Morgenstern.
3dgs.zip: A survey on 3d gaussian splatting compression methods, 2025.
URL [https://arxiv.org/abs/2407.09510](https://arxiv.org/abs/2407.09510).
- Barron et al. (2021)
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, 2021.
URL [https://arxiv.org/abs/2103.13415](https://arxiv.org/abs/2103.13415).
- Barron et al. (2022)
Jonathan T. Barron, Ben Mildenhall, Dor Verbin, Pratul P. Srinivasan, and Peter Hedman.
Mip-nerf 360: Unbounded anti-aliased neural radiance fields.
*CVPR*, 2022.
- Barron et al. (2023)
Jonathan T. Barron, Ben Mildenhall, Dor Verbin, Pratul P. Srinivasan, and Peter Hedman.
Zip-nerf: Anti-aliased grid-based neural radiance fields, 2023.
URL [https://arxiv.org/abs/2304.06706](https://arxiv.org/abs/2304.06706).
- Chen et al. (2024)
Yihang Chen, Qianyi Wu, Weiyao Lin, Mehrtash Harandi, and Jianfei Cai.
Hac: Hash-grid assisted context for 3d gaussian splatting compression, 2024.
URL [https://arxiv.org/abs/2403.14530](https://arxiv.org/abs/2403.14530).
- Chen et al. (2025)
Yihang Chen, Qianyi Wu, Weiyao Lin, Mehrtash Harandi, and Jianfei Cai.
Hac++: Towards 100x compression of 3d gaussian splatting, 2025.
URL [https://arxiv.org/abs/2501.12255](https://arxiv.org/abs/2501.12255).
- Cheng et al. (2024)
Kai Cheng, Xiaoxiao Long, Kaizhi Yang, Yao Yao, Wei Yin, Yuexin Ma, Wenping Wang, and Xuejin Chen.
Gaussianpro: 3d gaussian splatting with progressive propagation, 2024.
URL [https://arxiv.org/abs/2402.14650](https://arxiv.org/abs/2402.14650).
- Fang & Wang (2024)
Guangchi Fang and Bing Wang.
Mini-splatting: Representing scenes with a constrained number of gaussians, 2024.
URL [https://arxiv.org/abs/2403.14166](https://arxiv.org/abs/2403.14166).
- Feng et al. (2024)
Guofeng Feng, Siyan Chen, Rong Fu, Zimu Liao, Yi Wang, Tao Liu, Zhilin Pei, Hengjie Li, Xingcheng Zhang, and Bo Dai.
Flashgs: Efficient 3d gaussian splatting for large-scale and high-resolution rendering, 2024.
URL [https://arxiv.org/abs/2408.07967](https://arxiv.org/abs/2408.07967).
- Girish et al. (2024)
Sharath Girish, Kamal Gupta, and Abhinav Shrivastava.
Eagles: Efficient accelerated 3d gaussians with lightweight encodings, 2024.
URL [https://arxiv.org/abs/2312.04564](https://arxiv.org/abs/2312.04564).
- Hedman et al. (2018)
Peter Hedman, Julien Philip, True Price, Jan-Michael Frahm, George Drettakis, and Gabriel Brostow.
Deep blending for free-viewpoint image-based rendering.
37(6):257:1–257:15, 2018.
- Kerbl et al. (2023)
Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis.
3d gaussian splatting for real-time radiance field rendering.
*ACM Transactions on Graphics*, 42(4), July 2023.
URL [https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/).
- Kheradmand et al. (2025)
Shakiba Kheradmand, Daniel Rebain, Gopal Sharma, Weiwei Sun, Jeff Tseng, Hossam Isack, Abhishek Kar, Andrea Tagliasacchi, and Kwang Moo Yi.
3d gaussian splatting as markov chain monte carlo, 2025.
URL [https://arxiv.org/abs/2404.09591](https://arxiv.org/abs/2404.09591).
- Kim et al. (2024)
Sieun Kim, Kyungjin Lee, and Youngki Lee.
Color-cued efficient densification method for 3d gaussian splatting.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) Workshops*, pp. 775–783, June 2024.
- Knapitsch et al. (2017)
Arno Knapitsch, Jaesik Park, Qian-Yi Zhou, and Vladlen Koltun.
Tanks and temples: Benchmarking large-scale scene reconstruction.
*ACM Transactions on Graphics*, 36(4), 2017.
- Kwok & Ye (2023)
Kevin Kwok and Haoyang Ye.
splat, 2023.
URL [https://github.com/antimatter15/splat](https://github.com/antimatter15/splat).
- Lee et al. (2024)
Joo Chan Lee, Daniel Rho, Xiangyu Sun, Jong Hwan Ko, and Eunbyung Park.
Compact 3d gaussian representation for radiance field.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)*, pp. 21719–21728, 2024.
- Lee et al. (2025)
Soonbin Lee, Fangwen Shu, Yago Sanchez, Thomas Schierl, and Cornelius Hellge.
Compression of 3d gaussian splatting with optimized feature planes and standard video codecs, 2025.
URL [https://arxiv.org/abs/2501.03399](https://arxiv.org/abs/2501.03399).
- Liu et al. (2025)
Lei Liu, Zhenghao Chen, Wei Jiang, Wei Wang, and Dong Xu.
Hemgs: A hybrid entropy model for 3d gaussian splatting data compression, 2025.
URL [https://arxiv.org/abs/2411.18473](https://arxiv.org/abs/2411.18473).
- Liu et al. (2024a)
Rong Liu, Rui Xu, Yue Hu, Meida Chen, and Andrew Feng.
Atomgs: Atomizing gaussian splatting for high-fidelity radiance field, 2024a.
URL [https://arxiv.org/abs/2405.12369](https://arxiv.org/abs/2405.12369).
- Liu et al. (2024b)
Xiangrui Liu, Xinju Wu, Pingping Zhang, Shiqi Wang, Zhu Li, and Sam Kwong.
Compgs: Efficient 3d scene representation via compressed gaussian splatting, 2024b.
URL [https://arxiv.org/abs/2404.09458](https://arxiv.org/abs/2404.09458).
- Lu et al. (2023)
Tao Lu, Mulin Yu, Linning Xu, Yuanbo Xiangli, Limin Wang, Dahua Lin, and Bo Dai.
Scaffold-gs: Structured 3d gaussians for view-adaptive rendering, 2023.
URL [https://arxiv.org/abs/2312.00109](https://arxiv.org/abs/2312.00109).
- Mallick et al. (2024)
Saswat Subhajyoti Mallick, Rahul Goel, Bernhard Kerbl, Francisco Vicente Carrasco, Markus Steinberger, and Fernando De La Torre.
Taming 3dgs: High-quality radiance fields with limited resources, 2024.
URL [https://arxiv.org/abs/2406.15643](https://arxiv.org/abs/2406.15643).
- Mildenhall et al. (2020)
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, 2020.
URL [https://arxiv.org/abs/2003.08934](https://arxiv.org/abs/2003.08934).
- Müller et al. (2022)
Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller.
Instant neural graphics primitives with a multiresolution hash encoding.
*ACM Transactions on Graphics*, 41(4):1–15, July 2022.
ISSN 1557-7368.
doi: 10.1145/3528223.3530127.
URL [http://dx.doi.org/10.1145/3528223.3530127](http://dx.doi.org/10.1145/3528223.3530127).
- Navaneet et al. (2024)
KL Navaneet, Kossar Pourahmadi Meibodi, Soroush Abbasi Koohpayegani, and Hamed Pirsiavash.
Compgs: Smaller and faster gaussian splatting with vector quantization, 2024.
URL [https://arxiv.org/abs/2311.18159](https://arxiv.org/abs/2311.18159).
- Papantonakis et al. (2024)
Panagiotis Papantonakis, Georgios Kopanas, Bernhard Kerbl, Alexandre Lanvin, and George Drettakis.
Reducing the memory footprint of 3d gaussian splatting.
*Proceedings of the ACM on Computer Graphics and Interactive Techniques*, 7(1), May 2024.
URL [https://repo-sam.inria.fr/fungraph/reduced_3dgs/](https://repo-sam.inria.fr/fungraph/reduced_3dgs/).
- Pateux et al. (2025)
Stéphane Pateux, Matthieu Gendrin, Luce Morin, Théo Ladune, and Xiaoran Jiang.
Bogauss: Better optimized gaussian splatting, 2025.
URL [https://arxiv.org/abs/2504.01844](https://arxiv.org/abs/2504.01844).
- Qiu et al. (2024)
Ri-Zhao Qiu, Ge Yang, Weijia Zeng, and Xiaolong Wang.
Feature splatting: Language-driven physics-based scene synthesis and editing, 2024.
URL [https://arxiv.org/abs/2404.01223](https://arxiv.org/abs/2404.01223).
- Ren et al. (2024)
Kerui Ren, Lihan Jiang, Tao Lu, Mulin Yu, Linning Xu, Zhangkai Ni, and Bo Dai.
Octree-gs: Towards consistent real-time rendering with lod-structured 3d gaussians, 2024.
URL [https://arxiv.org/abs/2403.17898](https://arxiv.org/abs/2403.17898).
- Wang et al. (2024a)
Henan Wang, Hanxin Zhu, Tianyu He, Runsen Feng, Jiajun Deng, Jiang Bian, and Zhibo Chen.
End-to-end rate-distortion optimized 3d gaussian representation, 2024a.
URL [https://arxiv.org/abs/2406.01597](https://arxiv.org/abs/2406.01597).
- Wang et al. (2009)
Jiaping Wang, Peiran Ren, Minmin Gong, John Snyder, and Baining Guo.
All-frequency rendering of dynamic, spatially-varying reflectance.
*ACM Trans. Graph.*, 28(5):1–10, December 2009.
ISSN 0730-0301.
doi: 10.1145/1618452.1618479.
URL [https://doi.org/10.1145/1618452.1618479](https://doi.org/10.1145/1618452.1618479).
- Wang et al. (2024b)
Yiwen Wang, Siyuan Chen, and Ran Yi.
Sg-splatting: Accelerating 3d gaussian splatting with spherical gaussians, 2024b.
URL [https://arxiv.org/abs/2501.00342](https://arxiv.org/abs/2501.00342).
- Wang et al. (2024c)
Yufei Wang, Zhihao Li, Lanqing Guo, Wenhan Yang, Alex C. Kot, and Bihan Wen.
Contextgs: Compact 3d gaussian splatting with anchor level context model, 2024c.
URL [https://arxiv.org/abs/2405.20721](https://arxiv.org/abs/2405.20721).
- Xie et al. (2024)
Shuzhao Xie, Weixiang Zhang, Chen Tang, Yunpeng Bai, Rongwei Lu, Shijia Ge, and Zhi Wang.
Mesongs: Post-training compression of 3d gaussians via efficient attribute transformation, 2024.
URL [https://arxiv.org/abs/2409.09756](https://arxiv.org/abs/2409.09756).
- Zhang et al. (2025a)
Jiahui Zhang, Fangneng Zhan, Ling Shao, and Shijian Lu.
Sogs: Second-order anchor for advanced 3d gaussian splatting, 2025a.
URL [https://arxiv.org/abs/2503.07476](https://arxiv.org/abs/2503.07476).
- Zhang et al. (2025b)
Yangming Zhang, Wenqi Jia, Wei Niu, and Miao Yin.
Gaussianspa: An ”optimizing-sparsifying” simplification framework for compact and high-quality 3d gaussian splatting.
In *Proceedings of the Computer Vision and Pattern Recognition Conference (CVPR)*, pp. 26673–26682, June 2025b.
- Zhang et al. (2024)
Zhaoliang Zhang, Tianchen Song, Yongjae Lee, Li Yang, Cheng Peng, Rama Chellappa, and Deliang Fan.
Lp-3dgs: Learning to prune 3d gaussian splatting, 2024.
URL [https://arxiv.org/abs/2405.18784](https://arxiv.org/abs/2405.18784).

## Appendix A Appendix

### A.1 Algorithmic Derivation

#### A.1.1 Derivation for Memory-constrained optimizing

This appendix provides the detailed derivation of Algorithm [1](https://arxiv.org/html/2509.07021v2#alg1) presented in the main text. The algorithm solves the memory-constrained optimization problem with $L_{0}$ norm constraints using an ADMM-inspired approach.

Problem Formulation Consider the constrained optimization problem:

$$ $\displaystyle\min_{\mathbf{o},\mathbf{s},\Theta}$ $\displaystyle\mathcal{L}(\mathbf{o},\mathbf{s},\Theta)$ (A.1) s.t. $\displaystyle\rho_{o}\|\mathbf{o}\|_{0}+\rho_{s}\|\mathbf{s}\|_{0}\leq\kappa$ $$

where $\mathcal{L}$ is the loss function, $\|\cdot\|_{0}$ denotes the $L_{0}$ norm (count of non-zero elements), and $\kappa$ represents the memory budget.

Augmented Lagrangian Formulation Introduce proxy variables $\tilde{\mathbf{o}}$, $\tilde{\mathbf{s}}$ to reformulate the problem:

$$ $\displaystyle\min_{\mathbf{o},\mathbf{s},\Theta,\tilde{\mathbf{o}},\tilde{\mathbf{s}}}$ $\displaystyle\mathcal{L}(\mathbf{o},\mathbf{s},\Theta)$ (A.2) s.t. $\displaystyle\mathbf{o}=\tilde{\mathbf{o}},\quad\mathbf{s}=\tilde{\mathbf{s}}$ $\displaystyle\rho_{o}\|\tilde{\mathbf{o}}\|_{0}+\rho_{s}\|\tilde{\mathbf{s}}\|_{0}\leq\kappa$ $$

The augmented Lagrangian function is constructed as:

$$ $\displaystyle\mathcal{L}_{\delta}(\mathbf{o},\mathbf{s},\Theta,\tilde{\mathbf{o}},\tilde{\mathbf{s}},\bm{\lambda}_{\mathbf{o}},\bm{\lambda}_{\mathbf{s}})=$ $\displaystyle\mathcal{L}(\mathbf{o},\mathbf{s},\Theta)$ (A.3) $\displaystyle+\bm{\lambda}_{\mathbf{o}}^{\top}(\mathbf{o}-\tilde{\mathbf{o}})+\bm{\lambda}_{\mathbf{s}}^{\top}(\mathbf{s}-\tilde{\mathbf{s}})$ $\displaystyle+\frac{\delta}{2}\left(\rho_{o}\|\mathbf{o}-\tilde{\mathbf{o}}\|^{2}+\rho_{s}\|\mathbf{s}-\tilde{\mathbf{s}}\|^{2}\right)$ $$

where $\bm{\lambda}_{\mathbf{o}}$ and $\bm{\lambda}_{\mathbf{s}}$ are Lagrange multipliers, and $\delta>0$ is the penalty parameter.

ADMM Alternating Minimization The ADMM framework decomposes the optimization into three subproblems:

Primal Variables Update With proxy variables and multipliers fixed, update the primal variables:

$$ $\displaystyle(\Theta^{k+1},\mathbf{o}^{k+1},\mathbf{s}^{k+1})=$ $\displaystyle\arg\min_{\Theta,\mathbf{o},\mathbf{s}}\mathcal{L}(\mathbf{o},\mathbf{s},\Theta)$ (A.4) $\displaystyle+\frac{\delta}{2}\left[\rho_{o}\|\mathbf{o}-\tilde{\mathbf{o}}^{k}+\bm{\lambda}_{\mathbf{o}}^{k}\|^{2}+\rho_{s}\|\mathbf{s}-\tilde{\mathbf{s}}^{k}+\bm{\lambda}_{\mathbf{s}}^{k}\|^{2}\right]$ $$

Using gradient descent approximation:

$$ $\displaystyle\Theta^{k+1}$ $\displaystyle=\Theta^{k}-\eta\nabla_{\Theta}\mathcal{L}(\Theta^{k},\mathbf{o}^{k},\mathbf{s}^{k})$ (A.5) $\displaystyle\mathbf{o}^{k+1}$ $\displaystyle=\mathbf{o}^{k}-\eta\left[\nabla_{\mathbf{o}}\mathcal{L}(\Theta^{k},\mathbf{o}^{k},\mathbf{s}^{k})+\delta_{o}(\mathbf{o}^{k}-\tilde{\mathbf{o}}^{k}+\bm{\lambda}_{\mathbf{o}}^{k})\right]$ $\displaystyle\mathbf{s}^{k+1}$ $\displaystyle=\mathbf{s}^{k}-\eta\left[\nabla_{\mathbf{s}}\mathcal{L}(\Theta^{k},\mathbf{o}^{k+1},\mathbf{s}^{k})+\delta_{s}(\mathbf{s}^{k}-\tilde{\mathbf{s}}^{k}+\bm{\lambda}_{\mathbf{s}}^{k})\right]$ $$

where $\delta_{o}=\delta\rho_{o},\delta_{s}=\delta\rho_{s}$.

Proxy Variables Update With primal variables and multipliers fixed, update the proxy variables:

$$ $(\tilde{\mathbf{o}}^{k+1},\tilde{\mathbf{s}}^{k+1})=\arg\min_{\tilde{\mathbf{o}},\tilde{\mathbf{s}}}h(\tilde{\mathbf{o}},\tilde{\mathbf{s}})+\frac{\delta}{2}\left[\rho_{o}\|\mathbf{o}^{k+1}-\tilde{\mathbf{o}}+\bm{\lambda}_{\mathbf{o}}^{k}\|^{2}+\rho_{s}\|\mathbf{s}^{k+1}-\tilde{\mathbf{s}}+\bm{\lambda}_{\mathbf{s}}^{k}\|^{2}\right]$ (A.6) $$

where $h(\tilde{\mathbf{o}},\tilde{\mathbf{s}})$ is the indicator function enforcing the sparsity constraint:

$$ $h(\tilde{\mathbf{o}},\tilde{\mathbf{s}})=\begin{cases}0&\text{if }\rho_{o}\|\tilde{\mathbf{o}}\|_{0}+\rho_{s}\|\tilde{\mathbf{s}}\|_{0}\leq\kappa\\ +\infty&\text{otherwise}\end{cases}$ (A.7) $$

The solution is given by the proximal operator:

$$ $(\tilde{\mathbf{o}}^{k+1},\tilde{\mathbf{s}}^{k+1})=\mathbf{prox}_{h}(\mathbf{o}^{k+1}+\bm{\lambda}_{\mathbf{o}}^{k},\mathbf{s}^{k+1}+\bm{\lambda}_{\mathbf{s}}^{k})$ (A.8) $$

Dual Variables Update Update the Lagrange multipliers:

$$ $\displaystyle\bm{\lambda}_{\mathbf{o}}^{k+1}$ $\displaystyle=\bm{\lambda}_{\mathbf{o}}^{k}+(\mathbf{o}^{k+1}-\tilde{\mathbf{o}}^{k+1})$ (A.9) $\displaystyle\bm{\lambda}_{\mathbf{s}}^{k+1}$ $\displaystyle=\bm{\lambda}_{\mathbf{s}}^{k}+(\mathbf{s}^{k+1}-\tilde{\mathbf{s}}^{k+1})$ $$

#### A.1.2 Derivation for Color Compensation

$$ $\min_{\Delta c_{0}}\int_{\mathbb{S}^{2}}\left((c_{0}+\Delta c_{0})-(c_{0}+G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i}))\right)^{2}d\mathbf{v}$ (A.10) $$

where
$G(\mathbf{v};\bm{\mu},s,a)=ae^{s(\bm{\mu}\cdot\mathbf{v}-1)},$
$\bm{\mu}\in\mathbb{S}^{2}$ is the unit-length lobe axis, $s\in\mathbb{R}^{+}$ controls the sharpness, and $a\in\mathbb{R}^{3}$ is the RGB amplitude vector, with $\mathbf{v}\in\mathbb{S}^{2}$ being the viewing direction.

Simplifying the objective function:

$$ $\min_{\Delta c_{0}}\int_{\mathbb{S}^{2}}\left(\Delta c_{0}-G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i})\right)^{2}d\mathbf{v}$ (A.11) $$

Expanding the squared term:

$$ $\min_{\Delta c_{0}}\int_{\mathbb{S}^{2}}\left(\Delta c_{0}^{2}-2\Delta c_{0}G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i})+G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i})^{2}\right)d\mathbf{v}$ (A.12) $$

Taking derivative with respect to $\Delta c_{0}$ and setting to zero:

$$ $\frac{\partial}{\partial\Delta c_{0}}=2\int_{\mathbb{S}^{2}}\left(\Delta c_{0}-G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i})\right)d\mathbf{v}=0$ (A.13) $$

Solving for the optimal $\Delta c_{0}$:

$$ $\Delta c_{0}=\frac{\int_{\mathbb{S}^{2}}G(\mathbf{v};\bm{\mu}i,s_{i},a_{i})d\mathbf{v}}{\int_{\mathbb{S}^{2}}d\mathbf{v}}=\frac{1}{4\pi}\int_{\mathbb{S}^{2}}G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i})d\mathbf{v}$ (A.14) $$

Evaluating the spherical Gaussian integral. Without loss of generality, align $\bm{\mu}_{i}$ with the z-axis:

$$ $\displaystyle\int_{\mathbb{S}^{2}}G(\mathbf{v};\bm{\mu}_{i},s_{i},a_{i})\,d\mathbf{v}$ $\displaystyle=a_{i}\int_{0}^{2\pi}\int_{0}^{\pi}e^{s_{i}(\cos\theta-1)}\sin\theta\,d\theta\,d\phi$ $\displaystyle=2\pi a_{i}\int_{0}^{\pi}e^{s_{i}(\cos\theta-1)}\sin\theta\,d\theta$ $\displaystyle\quad\text{(substitute }u=\cos\theta,du=-\sin\theta d\theta)$ $\displaystyle=2\pi a_{i}\int_{-1}^{1}e^{s_{i}(u-1)}\,du$ $\displaystyle=2\pi a_{i}\cdot\frac{1-e^{-2s_{i}}}{s_{i}}.$ $$

Substituting back:

$$ $\Delta c_{0}=\frac{1}{4\pi}\cdot 2\pi a_{i}\cdot\frac{1-e^{-2s_{i}}}{s_{i}}=a_{i}\cdot\frac{1-e^{-2s_{i}}}{2s_{i}}$ (A.15) $$

The diffuse term is updated as:

$$ $c_{0}^{\prime}=c_{0}+\Delta c_{0}$ (A.16) $$

### A.2 Experimental Details

Implementation Details Our experiments are conducted on a single NVIDIA RTX 3090 GPU (24GB). For a fair comparison, we adopt the same hyperparameters and optimizer used by vanilla 3DGS (Kerbl et al., 2023) on all datasets.
Regarding the training strategy, we employ the same densification, pruning, and fine-tuning procedures as GaussianSpa, conducting densification training, sparse training, and fine-tuning for the same number of steps.
To ensure the accuracy of our VRAM measurements, we reproduce 3DGS, GaussianSpa (Zhang et al., 2025b), EAGLES (Girish et al., 2024), CompactGaussian (Lee et al., 2024), MesonGS (Xie et al., 2024), and Reduced3DGS (Papantonakis et al., 2024) for direct VRAM measurement. For other pruning-based methods, we utilize both the rendering quality metrics and primitive counts reported in the GaussianSpa paper. We then estimate their corresponding VRAM consumption based on our own VRAM measurements for 3DGS and GaussianSpa. EAGLES cannot be trained on a single NVIDIA RTX 3090 GPU with 24GB on some scenes in Mip-NeRF360, so we do not report VRAM consumption.

Evaluation Details For rendering performance, we report the peak signal-to-noise ratio (PSNR), structural similarity (SSIM),
and learned perceptual image patch similarity(LPIPS).
For VRAM consumption, we report both static VRAM overhead and rendering VRAM overhead. The former refers to the VRAM required to load all 3DGS primitives into the renderer and dequantize or decode them into a ready-to-render state. This is not necessarily equal to the file size, as some methods might represent Gaussian attributes in a more compact or lower-precision data format but still require restoring them to full, 32-bit precision Gaussian attributes before rendering. The latter denotes the peak VRAM usage during the rendering process, which is typically larger than the static VRAM due to the introduction of intermediate variables (e.g., projected 2D Gaussian attributes, key-value tables for tile-based rendering) during rendering. We measure this value across all test viewpoints and report the average.
To exclude the overhead introduced by the framework itself and the impact of memory fragmentation, we note that the memory allocation and management of the official 3DGS implementation’s renderer are almost entirely handled by PyTorch. Therefore, all VRAM-related metrics are reported using the values provided by the PyTorch framework.

Proximal Operators Implementation As mentioned in the main text, for opacity projection, we reuse the two proximal operators from GaussianSpa (Zhang et al., 2025b). These operators select $\kappa_{o}$ primitives to preserve based on different importance criteria. The first is a Magnitude-Based Selection, which sorts the input vector $(\mathbf{o}\!+\!\bm{\lambda}_{\mathbf{o}})$ and preserves the $\kappa_{o}$ elements with the highest magnitudes. The second operator employs an Importance-Based Selection, adopting the importance score metric from MiniSplatting (Fang & Wang, 2024). The importance score $I_{i}$ for the $i$-th Gaussian is the sum of its blending weights across all intersecting camera rays seen during training:

$$ $I_{i}=\sum_{j=1}^{K}w_{ij}$ (A.17) $$

where the blending weight $w_{ij}$ is the product of the Gaussian’s opacity $\alpha_{i}$, its projected 2D value $G_{i}^{2D}$, and the accumulated transmittance $T_{ij}$ along the $j$-th ray. Here, $K$ is the total number of intersected rays. The operator then preserves the $\kappa_{o}$ primitives with the highest importance scores.

### A.3 More Quantitive Results

**Table 3: Average parameter costs for the color model per Gaussian primitive. Storage and Rendering costs are measured in the number of float32 parameters. Decode Overhead indicates whether a method introduces significant additional VRAM during calculating color. The values of our method are calculated on the DeepBlending dataset.**
| Method | Storage | Rendering | Decode Overhead |
| --- | --- | --- | --- |
| 3DGS | 48 | 48 | No |
| EAGLES | $<1$ | $>48$ | Yes |
| CompactGaussian | $<1$ | $>32$ | Yes |
| ours w/o lobe-pruning | 24 | 24 | No |
| ours | 9.7 | 9.7 | No |

**Table 4: Comparison of anchor-based 3DGS and specialized SOTA compression schemes on the Mip-NeRF360 dataset. The best result is shown in bold.**
| Method | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | VRAM$\downarrow$ | FPS$\uparrow$ |
| --- | --- | --- | --- | --- | --- |
| Scaffold-GS | 27.74 | 0.811 | 0.226 | 612 | 123 |
| HAC++ (highrate) | 27.81 | 0.811 | 0.231 | 637 | 115 |
| HAC++ (lowrate) | 27.60 | 0.803 | 0.253 | 514 | 132 |
| Ours | 27.54 | 0.824 | 0.209 | 265 | 200 |

Figure: Figure 4: Comparison of different 3DGS color representations on Mip-NeRF360 dataset.
Refer to caption: x4.png

**Table 5: Mip-NeRF360 Indoor per scene results. Best results are in red region, second best are in orange region. Memory (VRAM) values are in MB.**
| Scene | Method | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | Static VRAM$\downarrow$ | Rendering VRAM$\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- |
| Bonsai | 3DGS | 32.23 | 0.940 | 0.205 | 393 | 798 |
| Reduced3DGS | 31.44 | 0.933 | 0.214 | 66 | 276 |  |
| GaussianSpa | 31.76 | 0.943 | 0.198 | 146 | 420 |  |
| Ours | 31.95 | 0.943 | 0.192 | 44 | 266 |  |
| 31.51 | 0.937 | 0.205 | 28 | 227 |  |  |
| Counter | 3DGS | 29.09 | 0.906 | 0.201 | 393 | 893 |
| Reduced3DGS | 28.57 | 0.899 | 0.212 | 67 | 331 |  |
| GaussianSpa | 28.98 | 0.911 | 0.191 | 175 | 518 |  |
| Ours | 28.78 | 0.906 | 0.195 | 44 | 326 |  |
| 28.35 | 0.892 | 0.220 | 25 | 272 |  |  |
| Kitchen | 3DGS | 31.24 | 0.925 | 0.126 | 581 | 1197 |
| Reduced3DGS | 31.03 | 0.921 | 0.133 | 118 | 428 |  |
| GaussianSpa | 31.50 | 0.929 | 0.127 | 163 | 443 |  |
| Ours | 31.51 | 0.927 | 0.127 | 51 | 309 |  |
| 31.27 | 0.923 | 0.133 | 36 | 275 |  |  |
| Room | 3DGS | 31.55 | 0.918 | 0.220 | 474 | 1007 |
| Reduced3DGS | 31.03 | 0.914 | 0.227 | 68 | 310 |  |
| GaussianSpa | 31.61 | 0.922 | 0.211 | 141 | 401 |  |
| Ours | 31.56 | 0.923 | 0.207 | 36 | 250 |  |
| 31.16 | 0.915 | 0.226 | 22 | 214 |  |  |

**Table 6: Tanks&Temples per scene results. Best results are in red region, second best are in orange region. Memory (VRAM) values are in MB.**
| Scene | Method | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | Static VRAM$\downarrow$ | Rendering VRAM$\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- |
| Train | 3DGS | 21.97 | 0.818 | 0.198 | 397 | 773 |
| Reduced3DGS | 21.74 | 0.804 | 0.219 | 74 | 227 |  |
| GaussianSpa | 21.81 | 0.826 | 0.197 | 164 | 339 |  |
| Ours | 21.52 | 0.820 | 0.197 | 49 | 208 |  |
| 21.32 | 0.818 | 0.205 | 35 | 160 |  |  |
| Truck | 3DGS | 25.39 | 0.881 | 0.143 | 752 | 1268 |
| Reduced3DGS | 25.28 | 0.875 | 0.154 | 105 | 276 |  |
| GaussianSpa | 25.65 | 0.887 | 0.126 | 115 | 448 |  |
| Ours | 25.37 | 0.886 | 0.121 | 54 | 214 |  |
| 25.23 | 0.883 | 0.130 | 39 | 167 |  |  |

**Table 7: Mip-NeRF360 Outdoor per scene results. Best results are in red region, second best are in orange region. Memory (VRAM) values are in MB.**
| Scene | Method | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | Static VRAM$\downarrow$ | Rendering VRAM$\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- |
| Bicycle | 3DGS | 25.20 | 0.764 | 0.210 | 1794 | 2955 |
| Reduced3DGS | 25.10 | 0.763 | 0.219 | 314 | 686 |  |
| GaussianSpa | 25.43 | 0.779 | 0.222 | 240 | 491 |  |
| Ours | 25.34 | 0.782 | 0.206 | 63 | 248 |  |
| 25.16 | 0.771 | 0.226 | 48 | 205 |  |  |
| Stump | 3DGS | 26.61 | 0.769 | 0.217 | 1585 | 2487 |
| Reduced3DGS | 26.75 | 0.778 | 0.218 | 318 | 663 |  |
| GaussianSpa | 27.07 | 0.802 | 0.207 | 222 | 460 |  |
| Ours | 27.19 | 0.803 | 0.198 | 60 | 233 |  |
| 27.04 | 0.797 | 0.213 | 47 | 198 |  |  |
| Garden | 3DGS | 27.36 | 0.863 | 0.108 | 1494 | 2449 |
| Reduced3DGS | 27.14 | 0.858 | 0.116 | 303 | 684 |  |
| GaussianSpa | 27.22 | 0.854 | 0.140 | 227 | 460 |  |
| Ours | 27.17 | 0.858 | 0.127 | 78 | 273 |  |
| 26.62 | 0.846 | 0.143 | 63 | 240 |  |  |
| Flowers | 3DGS | 21.49 | 0.602 | 0.338 | 1066 | 1716 |
| Reduced3DGS | 21.37 | 0.598 | 0.345 | 221 | 497 |  |
| GaussianSpa | 21.60 | 0.624 | 0.332 | 209 | 451 |  |
| Ours | 21.65 | 0.625 | 0.331 | 66 | 255 |  |
| 21.37 | 0.609 | 0.344 | 48 | 203 |  |  |
| Treehill | 3DGS | 22.58 | 0.633 | 0.328 | 1192 | 1947 |
| Reduced3DGS | 22.41 | 0.630 | 0.337 | 241 | 563 |  |
| GaussianSpa | 22.84 | 0.655 | 0.312 | 226 | 471 |  |
| Ours | 22.74 | 0.649 | 0.313 | 59 | 233 |  |
| 22.44 | 0.640 | 0.335 | 43 | 188 |  |  |

**Table 8: DeepBlending per scene results. Best results are in red region, second best are in orange region. Memory (VRAM) values are in MB.**
| Scene | Method | PSNR$\uparrow$ | SSIM$\uparrow$ | LPIPS$\downarrow$ | Static VRAM$\downarrow$ | Rendering VRAM$\downarrow$ |
| --- | --- | --- | --- | --- | --- | --- |
| Playroom | 3DGS | 30.00 | 0.903 | 0.244 | 678 | 1197 |
| Reduced3DGS | 29.96 | 0.904 | 0.248 | 90 | 276 |  |
| GaussianSpa | 30.48 | 0.914 | 0.239 | 137 | 320 |  |
| Ours | 30.77 | 0.914 | 0.229 | 52 | 218 |  |
| 30.58 | 0.912 | 0.243 | 30 | 167 |  |  |
| DrJohnson | 3DGS | 29.41 | 0.902 | 0.239 | 1129 | 1941 |
| Reduced3DGS | 29.24 | 0.901 | 0.247 | 152 | 404 |  |
| GaussianSpa | 29.50 | 0.910 | 0.239 | 184 | 424 |  |
| Ours | 29.56 | 0.909 | 0.237 | 56 | 269 |  |
| 29.45 | 0.904 | 0.250 | 37 | 219 |  |  |

**Table 9: Real-time rendering performance comparison of different methods across various desktop and mobile devices in Bicycle scene. All tests were conducted using a WebGL-based viewer, which we modified from the repository (Kwok & Ye, 2023) to support both Spherical Gaussians and 3rd-order Spherical Harmonics. Performance measured in FPS. ”cannot render” indicates that the device’s browser crashed or showed a black screen, while ”render error” signifies incorrect rendering, such as color display issues.The best result is shown in bold.**
| Method | RTX3060 | Dimensity 9400+ | Snapdragon 8+ Gen 1 | Snapdragon 888 |
| --- | --- | --- | --- | --- |
| 3DGS | 26.3 | 6.6 | cannot render | connot render |
| GaussianSpa | 165.0 | 31.4 | render error | render error |
| Ours | 165.0 | 91.0 | 120.9 | 60.1 |

### A.4 More Qualitative results

Figure: Figure 5: Real-time rendering performance of MEGS^2 on various scenes, showcased via a WebGL-based viewer on a lenovo laptop with NVIDIA GeForce RTX3060 Laptop GPU. The live frame rate (FPS) for each view is annotated in the imagery.
Refer to caption: x5.png

Figure: Figure 6: Real-time rendering performance of MEGS^2 on various scenes, showcased via a WebGL-based viewer on Huawei MatePad Air with Qualcomm Snapdragon 888. The live frame rate (FPS) for each view is annotated in the imagery.
Refer to caption: x6.png

Figure: Figure 7: Real-time rendering performance of MEGS^2 on various scenes, showcased via a WebGL-based viewer on OnePlus Ace 5 Ultra with MediaTek Dimensity 9400+. The live frame rate (FPS) for each view is annotated in the imagery.
Refer to caption: x7.png

Figure: Figure 8: Real-time rendering performance of MEGS^2 on various scenes, showcased via a WebGL-based viewer on RedMi K60 with Qualcomm Snapdragon 8+ Gen 1. The live frame rate (FPS) for each view is annotated in the imagery.
Refer to caption: x8.png

### A.5 The Use of Large Language Models (LLMs)

The article was refined using Gemini 2.5 Pro / Gemini 2.5 Flash / DeepSeek R1 to improve phrasing for natural English expression and correct grammatical errors.

## Peer Reviews

confidence: 5
contribution: 1
initial_rating: 2
presentation: 1
questions: * The first contribution claim in lines 97–99 makes it sound as if the authors are the first to propose substituting Gaussian Splats with Spherical Gaussians, which is not true, as this was already introduced by SG-Splatting. The authors should instead highlight the distinction between **fixed axes** and **arbitrarily oriented axes** in Spherical Gaussians. Emphasizing the reduction of per-primitive parameter count and VRAM savings is also inappropriate, since these advantages originate from SG-Splatting.
* The second contribution claim in lines 100–102 also seems inaccurate. The memory-constrained problem and its solution were originally introduced by GaussianSpa, and the authors simply extend that method by incorporating the sharpness of Gaussians to retain those with better expressive capacity. The authors should revise the statement of contribution 2 to accurately reflect their original findings.
* The VRAM reduction of the proposed method is primarily attributed to the smaller number of parameters used for encoding view-specific color and pruning. To provide supporting evidence for the pruning aspect, I suggest that the authors present both VRAM consumption and the number of Gaussians in Table 1. This will help readers better understand the pruning performance compared to pruning-only baselines such as LP-3DGS, Mini-Splatting, and GaussianSpa.
* The qualitative results in Figure 3 do not fully support the authors’ claim that "MEGS² delivers a cleaner and more complete reconstruction in Playroom" (line 415). When examining the ceiling area in the top center of the rendered images, MEGS² produces a somewhat speckled texture, whereas GaussianSpa and 3DGS yield cleaner textures. Additionally, the light switch in the bottom-left area appears blurrier in MEGS² compared to GaussianSpa.
* I am wondering about the effect of using arbitrarily oriented Spherical Gaussians. Please include an ablation study to analyze this effect. For example, the authors could test:
  1. The proposed method with **Spherical Harmonics (SH)**
  2. The proposed method with **fixed-axis Spherical Gaussians**
* Furthermore, I am curious why **GaussianSpa (SH → SG)** shows a quality drop (27.01dB in Table 2) compared to the original GaussianSpa (27.56dB in Table 1). This raises doubts about the justification for using Spherical Gaussians.
soundness: 3
strengths: This paper addresses the limited color representation capacity of SG-Splatting and further introduces opacity- and sharpness-based pruning, along with energy recovery of removed lobes, to reduce VRAM usage with maintaining high reconstruction quality.
summary: This paper proposes memory efficient gaussian splatting method by combining Spherical Gaussian and ADMM-inspired unified pruning. Noticed from related paper SG-Splatting, they found fixed orthogonal axes of SG lobes limit rendering performance, and they make it arbitrary oriented. Inspired from GuassianSpa, they optimize proxy of opacity and sharpness parameters simulatenously to sparsify the values. At the end of optimization of proxies, they prune primitives based on significance of the proxies. They found sequential pruning (prune gaussians first then prune parameters) shows poorer trade-off between primitive count and primitive parameters than unified pruning (prune gaussians and parameters together). To recover rendering quality degradation caused by pruning, they further finetune diffuse color based on color loss. Their experiment results show comparable rendering quality of their method against state-of-the-art method but significant save in VRAM, tested on standard benchmarking datasets.
weaknesses: I think the major issue is the inaccurate contribution claim of this paper. As discussed in Questions 1 and 5, the first contribution claim seems exaggerated, and their findings are not well supported by ablation experiments. Similarly, the second contribution claim is also inaccurate, as discussed in Question 2. Moreover, poor presentation of the method, such as missing information on model choices, makes it difficult for readers to fully understand their approach. Please refer to my Questions for detailed comments.

Presentation issue:
* I could not find the authors’ conclusion regarding model selection.
  1. In lines 306–311, the authors propose two distinct operators: **sharpness-based selection** and **range-based selection**. Which one is ultimately adopted in the final model and why? I could not find a statement clarifying this choice.
  2. Similarly, in lines 785–787, which criterion was finally chosen and why?: **magnitude-based selection** or **importance-based selection**?
* I could not identify the setting difference between the last two rows in Table 1. Please provide distinct method names (e.g., ours-setting_A and ours-setting_B) and explain them clearly in the appropriate section of the main text.
* Please include a citation for ADMM at line 234.

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: - The authors argue SGs are “more amenable to pruning.” Can the authors quantify how many lobes are actually used per Gaussian at convergence, per scene?
- The optimization looks more complex than sequential pruning: how sensitive is it to the pruning budget? Do small changes lead to big quality swings?
soundness: 3
strengths: The paper provides following strenghts:
- Unlike storage-only methods, it reduces static and rendering VRAM (50% static, 40% rendering vs SOTA), so it runs on edge/mobile. 
- Usage of SG color model is prunable. SGs keep high-freq/view-dependent details with about half the params of SH and allow lobe-wise pruning.
- Unified soft pruning works better than sequential. ADMM-style optimization over opacity and sharpness finds a better quality–memory trade-off than “prune primitives then prune SH.”
summary: The paper presents MEGS^2, a 3D Gaussian Splatting framework that cuts both primitive count and per-primitive parameters to fix the rendering VRAM bottleneck. 
The paper replaces SH colors with lightweight, arbitrarily oriented spherical Gaussians (SG) so most Gaussians use only a few lobes. 
The paper’s method formulates primitive and lobe pruning as one memory-constrained optimization, reaching ~8× static and ~6× rendering VRAM compression over vanilla 3DGS, still close to SOTA quality. 

The paper backs its claims with extensive experiments on standard datasets (MipNeRF 360, etc), with qualitative evaluations. 
Ablation studies show different pruning scheme is outperformed by the method presented by the paper, unified soft pruning.
weaknesses: The paper suffers from following weaknesses:
- Optimization pipeline is complex. Needs proxy variables, proximal projection, then post-processing + fine-tuning, so it’s harder to integrate than simple importance-pruning. 
- As stated in the limitation section, the paper mostly focuses on renderer-agnostic static memory. Paper explicitly leaves renderer-specific dynamic VRAM optimization “for future work,” so some engines may still hit a ceiling.
- As authors noted, performance on “highly complex highlights” needs more study, so scenes with extreme view-dependent effects may degrade first.

---

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: See weaknesses.
soundness: 4
strengths: - Replacing SH with arbitrarily oriented Spherical Gaussians is an effective solution to reduce per-primitive parameters. The formulation is physically intuitive and well integrated into the 3DGS framework.
- The paper provides detailed quantitative and qualitative results across multiple datasets and baselines.
- The WebGL-based real-time rendering results demonstrate real usability on mobile platforms. 
- The method’s ability to generalize across devices and maintain reasonable quality is a clear step toward deployable Gaussian-based rendering.
summary: The paper presents MEGS2, a memory-efficient framework for 3D Gaussian Splatting (3DGS) that targets the rendering VRAM bottleneck rather than only the storage footprint. The authors propose two key ideas: (1) replacing high-order Spherical Harmonics (SH) color modeling with Spherical Gaussians (SG) for compact, local view-dependent representation, and (2) a unified soft pruning framework that simultaneously prunes redundant Gaussian primitives and per-primitive SG lobes under a total memory constraint, formulated as a constrained optimization problem solved by an ADMM-inspired method. Experiments show the effectiveness of the proposed method. The approach is further validated on both desktop and mobile devices, showing strong frame rates in a WebGL viewer.
weaknesses: - Several important parameters are not explicitly described or justified. The choice of these hyperparameters may significantly affect performance and reproducibility.
- Scenes with highly specular highlights or dense transparency are acknowledged as future work but should be illustrated. The method’s performance on dynamic or large-scale scenes remains unknown.
- While the authors promise code release, the current text lacks explicit training schedules, optimization hyperparameters, and hardware runtimes, which hinders replication.
- The convergence and optimality properties of the ADMM-inspired procedure are not formally analyzed.

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 3
questions: - Could you compare the proposed pruning method with other pruning metrics from existing approaches, such as CompactGaussian [CVPR'24], EAGLES [ECCV'24], and LightGaussian [NeurIPS'24]?

-  Could a lower degree of spherical harmonics be more efficient than spherical Gaussian lobes? It could be helpful to compare the diverse SH degrees against the proposed representation.
soundness: 3
strengths: - The paper effectively analyzes the key factors of large VRAM consumption and mitigates them using the proposed techniques.

- The use of spherical Gaussian verifies to be an efficient alternative for color representation, achieving meaningful parameter reduction while maintaining a comparable representation capacity to spherical harmonics.

- Experimental results show that the proposed method outperforms various 3DGS baselines in rendering quality while requiring only minimal VRAM consumption.
summary: This paper presents a memory-efficient Gaussian Splatting framework that replaces high-dimensional spherical harmonics with lightweight spherical Gaussian lobes. It also introduces a unified pruning strategy for both Gaussian primitives and spherical Gaussians, resulting in improved pruning performance due to its regularization effect. Experimental results demonstrate that the proposed framework achieves substantial reductions in both static and dynamic VRAM usage while providing superior rendering quality.
weaknesses: - The lack of technical novelty needs to be enhanced. The main performance gain for the memory reduction originates from the replacement of spherical harmonics with spherical Gaussian lobes. However, spherical Gaussians have already been applied to 3DGS in prior work, such as SG-Splatting. 

- Pruning solely based on the opacity value may lead to performance limitations, since the contribution of Gaussians is also influenced by other attributes, such as scales. 

- Despite the low VRAM consumption, this representation requires a relatively high storage demand compared to compact Gaussian approaches.

---

confidence: 4
contribution: 2
initial_rating: 2
presentation: 3
questions: No code attached. I think it would be better if the authors released the code. 

Have the authors try 4DGS? In my opinion, it is quite easy to adapt the proposed method for 4DGS.
soundness: 3
strengths: 1. This paper is well-organized and easy to follow. Language is good.
2. The proposed method can render comparable results to 3DGS.
3. The presentation is good. The demonstrated effect is impressive.
summary: This paper proposed a memory-efficient Gaussian Splatting method for edge devices. It uses spherical Gaussians to replace the original spherical harmonics for better efficiency. It also involves a pruning process to eliminate the redundant Gaussian points. Experimental results show the proposed method can reduce VRAM compared to the original 3DGS.
weaknesses: 1. In the abstract, "Experiments show that MEGS2 achieves a 50% static VRAM reduction and a 40% rendering VRAM reduction ...", this sentence confuses me. What's static VRAM and rendering VRAM? There's no clear claim.

2. In lines 60-62, the authors claim, "However, these methods require decoding the full Gaussian parameters from a compressed
state before rendering, even resulting in a larger rendering memory than the 3DGS methods without compression.".  I am wondering if the proposed method doesn't need to decode the compressed Gaussian parameters for rendering? I did not find a clear description.

3. The authors claim the proposed spherical Gaussian is their contribution. However, the spherical Gaussian was already proposed by [1]. The authors do not present a clear discussion of it. I did not find a detailed description for arbitrarily-oriented SG. How to achieve it? Why is it better than orthogonal? Is there any theoretical analysis?

4. The proposed memory-constraint optimization is too straightforward. Please elaborate on the contribution. The formulation did not claim the relation between opacity $o$ and sharpness $s$.

5. To the proposed post-processing procedure, the authors claim they have a three-step strategy. However, I only find two: (1) removal according to low opacity, (2) by sharpness. Moreover, I do not think it is novel. It is also straightforward. There's no specific design in it.

6. As for experiments, the authors do not compare with state-of-the-art GS compression methods, like LocoGS[2], speedy-splat[3], LightGaussian[4], maskGaussian[5].


7. There's no visual comparison for the ablation study. I think it would be better to present it. There are no Gaussian numer comparisons. 
It would be better to show the training costs and storage memory. There are no detailed VRAM analyses for each Gaussian attribute.






[1] Wang Y, Chen S, Yi R. Sg-splatting: Accelerating 3d gaussian splatting with spherical gaussians[J]. arXiv preprint arXiv:2501.00342, 2024.

[2] Shin S, Park J, Cho S. Locality-aware gaussian compression for fast and high-quality rendering[J]. arXiv preprint arXiv:2501.05757, 2025.

[3] Hanson A, Tu A, Lin G, et al. Speedy-splat: Fast 3d gaussian splatting with sparse pixels and sparse primitives[C]//Proceedings of the Computer Vision and Pattern Recognition Conference. 2025: 21537-21546.


[4] Fan Z, Wang K, Wen K, et al. Lightgaussian: Unbounded 3d gaussian compression with 15x reduction and 200+ fps[J]. Advances in neural information processing systems, 2024, 37: 140138-140158.

[5] Liu Y, Zhong Z, Zhan Y, et al. Maskgaussian: Adaptive 3d gaussian representation from probabilistic masks[C]//Proceedings of the Computer Vision and Pattern Recognition Conference. 2025: 681-690.


Decision: Accept (Poster)