SymGS: Symmetry-Aware 3D Gaussian Splatting

• SymGS is a compression framework for 3D Gaussian Splatting that exploits mirror symmetry to eliminate redundant primitives and reduce memory usage.
• It clusters Gaussians by visual attributes and employs geometric voting to reliably detect dominant mirror planes in complex scenes.
• SymGS integrates with anchor-based methods like HAC to achieve up to 108× compression while maintaining photorealistic rendering quality.

Searching arXiv for the specified paper and any directly relevant related work cited in the provided material. SymGS is a compression framework for 3D Gaussian Splatting that incorporates symmetry-aware techniques, specifically targeting mirror symmetries to eliminate redundant primitives for compression. It is presented as a plug-and-play enhancement to state-of-the-art compression methods, including HAC, and introduces learnable mirrors into the scene so as to eliminate local and global reflective redundancies while preserving rendering quality (Gupta et al., 17 Nov 2025).

1. Problem setting and representation

In Gaussian-splatting–based novel-view synthesis, a scene is approximated by $N$ oriented 3D Gaussians,

$G_i = (x_i, \Sigma_i, \alpha_i, c_i),$

where $x_i \in \mathbb{R}^3$ is the mean position, $\Sigma_i \in \mathbb{R}^{3\times3}$ is the covariance, $\alpha_i$ is an opacity or density weight, and $c_i \in \mathbb{R}^3$ is the RGB color, sometimes stored via SH-coefficients (Gupta et al., 17 Nov 2025). Rendering a ray $r$ passing through pixels involves splatting each Gaussian into image space and accumulating color and opacity, for example by

$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$

where $d_i(r)$ measures the distance of ray $r$ to the center $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$0 and $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$1 is derived from $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$2 (Gupta et al., 17 Nov 2025).

The principal systems issue addressed by SymGS is the linear memory scaling of this representation. Typical storage per Gaussian is on the order of $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$3–$G_i = (x_i, \Sigma_i, \alpha_i, c_i),$4 bytes, and the summary gives the approximation

$G_i = (x_i, \Sigma_i, \alpha_i, c_i),$5

To achieve high-fidelity on complex scenes, $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$6 can be $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$7, leading to multi-GB footprints (Gupta et al., 17 Nov 2025). SymGS is therefore situated within the line of work that seeks to reduce either the number of primitives or the storage cost of their attributes, but it does so by making explicit use of scene symmetry rather than relying only on primitive-level redundancy.

2. Relation to prior compression strategies

The summary situates SymGS against several existing approaches to 3DGS compression. These include vector quantization methods that cluster similar colors or SH-coefficients into a small codebook, with LightGaussian and Compact3D given as examples; entropy coding combined with rate-distortion optimized quantization, as in RDO-Gaussian; and anchor-based schemes such as Scaffold-GS and HAC, which introduce a much smaller set of anchors, each storing a latent and a learned local Gaussian ensemble around it (Gupta et al., 17 Nov 2025).

HAC is singled out as a particularly relevant baseline. In the summary, HAC is described as learning a hash-grid MLP to predict quantization step sizes for anchor attributes (Gupta et al., 17 Nov 2025). SymGS does not replace such methods; instead, it is defined as a plug-and-play enhancement that can wrap around them.

Three limitations of prior compression strategies are explicitly identified. First, compression may saturate as residual redundancies remain. Second, removal and quantization are characterized as black-box operations with little interpretability. Third, prior methods make no use of explicit scene-structure priors such as symmetry (Gupta et al., 17 Nov 2025). SymGS is designed to address precisely this third point by treating mirror symmetry as a compressible structural prior rather than as incidental similarity between isolated primitives.

3. Mirror parametrization and symmetry detection

A mirror plane in $G_i = (x_i, \Sigma_i, \alpha_i, c_i),$8 is written as

$G_i = (x_i, \Sigma_i, \alpha_i, c_i),$9

The normal $x_i \in \mathbb{R}^3$0 is parametrized by spherical angles $x_i \in \mathbb{R}^3$1, and the signed distance is written as $x_i \in \mathbb{R}^3$2 with $x_i \in \mathbb{R}^3$3 for scene radius $x_i \in \mathbb{R}^3$4 (Gupta et al., 17 Nov 2025). This parametrization is the basis of SymGS’s symmetry search.

To detect dominant symmetries, Gaussians are first clustered by similar attributes, specifically color bins in HSV, opacity bins, and scale bins, so that only visually similar Gaussians pair up (Gupta et al., 17 Nov 2025). For each pair $x_i \in \mathbb{R}^3$5 in a cluster $x_i \in \mathbb{R}^3$6, a candidate mirror is generated with

$x_i \in \mathbb{R}^3$7

The parameters $x_i \in \mathbb{R}^3$8 are then discretized into an accumulator grid $x_i \in \mathbb{R}^3$9 of size $\Sigma_i \in \mathbb{R}^{3\times3}$0. Each pair votes at a voxel given by

$\Sigma_i \in \mathbb{R}^{3\times3}$1

The voxel with maximum votes yields the most dominant mirror $\Sigma_i \in \mathbb{R}^{3\times3}$2 (Gupta et al., 17 Nov 2025).

This procedure combines attribute-level filtering with geometric voting. A plausible implication is that the clustering stage suppresses pairings that are geometrically admissible but visually implausible, while the accumulator identifies a scene-level consensus plane rather than a purely local correspondence. The summary’s emphasis on local and global reflective redundancies indicates that the framework is intended to capture both prominent scene symmetries and more restricted repeated structures, provided they manifest through the iterative procedure (Gupta et al., 17 Nov 2025).

4. Reflection-based compression and mirror-aware optimization

Once a mirror $\Sigma_i \in \mathbb{R}^{3\times3}$3 is selected, the current set of Gaussians is split into

$\Sigma_i \in \mathbb{R}^{3\times3}$4

$\Sigma_i \in \mathbb{R}^{3\times3}$5

and

$\Sigma_i \in \mathbb{R}^{3\times3}$6

To halve primitives in the symmetric region, SymGS discards the original $\Sigma_i \in \mathbb{R}^{3\times3}$7 and replaces them by reflecting $\Sigma_i \in \mathbb{R}^{3\times3}$8:

$\Sigma_i \in \mathbb{R}^{3\times3}$9

The method therefore compresses by storing one side of the symmetric structure and reconstructing the other by reflection (Gupta et al., 17 Nov 2025).

The summary notes that discretization and clustering errors degrade fidelity. SymGS therefore makes $\alpha_i$0 learnable and jointly re-optimizes the remaining primitives under the standard photometric loss,

$\alpha_i$1

Gradients are backpropagated to the attributes of $\alpha_i$2 and $\alpha_i$3, namely $\alpha_i$4, and also to the mirror parameters $\alpha_i$5 (Gupta et al., 17 Nov 2025). This is described as “mirror-aware optimization,” and the summary states that it typically restores per-view shading consistency and fine shape details.

This formulation clarifies that the mirror is not treated as a fixed preprocessing artifact. Instead, it is a trainable component of the scene representation. That design choice distinguishes SymGS from a purely geometric pruning strategy: the compression step is coupled to photometric reconstruction, and mirror placement is refined by the same loss used to preserve view synthesis quality.

5. Recursive hierarchy and integration with HAC

SymGS extends beyond a single mirror by applying symmetry detection recursively on the reduced set $\alpha_i$6 to find $\alpha_i$7, split, reflect, optimize, discard, and continue for $\alpha_i$8 levels (Gupta et al., 17 Nov 2025). At each iteration step, the procedure is:

1. Input $\alpha_i$9.
2. Cluster and vote to pick $c_i \in \mathbb{R}^3$0.
3. Define $c_i \in \mathbb{R}^3$1 and $c_i \in \mathbb{R}^3$2 and reflect $c_i \in \mathbb{R}^3$3.
4. Jointly optimize primitives and $c_i \in \mathbb{R}^3$4.
5. Discard the reflected half.

In the final compressed representation, only the stored means $c_i \in \mathbb{R}^3$5, full attributes for $c_i \in \mathbb{R}^3$6, and mirror parameters $c_i \in \mathbb{R}^3$7 remain for each level $c_i \in \mathbb{R}^3$8 (Gupta et al., 17 Nov 2025). Reconstruction at train or test time re-applies the mirror reflections in reverse order to recreate the full scene.

The same mechanism is described as compatible with anchor-based compression. For HAC, one first runs HAC to obtain anchors $c_i \in \mathbb{R}^3$9, clusters their aggregated color, opacity, and scale, and then performs identical mirror voting on the anchors instead of the raw Gaussians (Gupta et al., 17 Nov 2025). At each recursion step, SymGS reflects half the anchors via the learned plane, jointly fine-tunes HAC’s hash-grid MLP, anchor features, and the mirror parameters under $r$0, and discards the mirrored anchors while keeping only half (Gupta et al., 17 Nov 2025). The summary states that this adds only $r$1 extra trainable parameters, specifically $r$2 per mirror.

This plug-and-play property is central to the framework’s scope. SymGS is not restricted to a bespoke representation learned from scratch; it is formulated as a symmetry-exploitation layer that can wrap around an existing anchor-based compressor. A plausible implication is that the method’s gains can be interpreted as orthogonal to primitive quantization and anchorization, because they arise from explicit structural redundancy rather than solely from attribute coding.

6. Quantitative results, ablations, and limitations

The reported quantitative results are averaged over $r$3 scenes from Synthetic-NeRF, Mip-NeRF360, Tanks & Temples, DeepBlending, and BungeeNeRF (Gupta et al., 17 Nov 2025). Relative to uncompressed 3DGS, SymGS achieves approximately $r$4 mean compression. Compared to HAC, it yields an extra $r$5 size reduction on average, with up to $r$6 on large-scale scenes, specifically DeepBlending and BungeeNeRF (Gupta et al., 17 Nov 2025).

The summary gives the following example breakdown versus HAC at matched rendering quality:

Dataset	Compression improvement vs HAC	Matched PSNR
Synthetic-NeRF	$r$7 better	$r$8
Mip-NeRF360	$r$9 better	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$0
Tanks & Temples	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$1 better	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$2
DeepBlending	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$3 better	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$4
BungeeNeRF	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$5 better	$$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$6

The rendering metrics, specifically PSNR and SSIM, are stated to remain on par with HAC and often slightly improve in symmetric scenes, with Lego in Synthetic-NeRF and indoor rooms in DeepBlending named as examples (Gupta et al., 17 Nov 2025). This suggests that symmetry modeling can function not only as a storage reduction device but also as a regularizer in scenes where reflective structure is strong.

The ablation studies isolate three design variables. First, finer $$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$7 leads to more accurate mirror detection and higher PSNR but slightly larger models because more Gaussians are kept, whereas coarser $$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$8 leads to more quantization error in the mirror and lower PSNR and lower compression (Gupta et al., 17 Nov 2025). Second, freezing HAC’s hash-grid MLP during mirror optimization yields lower PSNR, approximately $$C(r) = \sum_{i=1}^N w_i(r)\,c_i \quad \text{with} \quad w_i(r)=\alpha_i\cdot\exp(-d_i(r)^2/\sigma_i^2),$$9 for Chair, while jointly fine-tuning the MLP raises fidelity by up to $d_i(r)$0 at similar size (Gupta et al., 17 Nov 2025). Third, multi-mirror joint training, in which the last $d_i(r)$1 mirrors’ plane parameters also adapt during each step rather than only the newest mirror, further improves PSNR, for example from $d_i(r)$2 to $d_i(r)$3 on Chair, at the cost of a minor increase in stored size (Gupta et al., 17 Nov 2025).

The limitations are explicit. SymGS targets reflective planar symmetries; rotational or translational symmetries remain unexploited. Worst-case $d_i(r)$4 voting is mitigated by GPU acceleration, but very large scenes may still be expensive. Approximate or broken symmetries, due to occlusions or asymmetric lighting, can limit gains in certain outdoor natural scenes (Gupta et al., 17 Nov 2025). These points delimit a common misconception: the method does not claim to exploit symmetry in a general group-theoretic sense, but specifically mirror symmetry represented by planes of reflection.

The practical deployment path is correspondingly narrow and concrete. Mirror decomposition and Gaussian pruning are done offline, and at inference one re-applies the few stored plane reflections during the splatting rasterization pass, incurring negligible overhead while delivering multi-GB model size reductions while preserving photoreal fidelity (Gupta et al., 17 Nov 2025). The future directions named in the summary—higher-order symmetries such as $d_i(r)$5-fold rotations, graph-based local symmetry clustering, dynamic or non-rigid scenes, and end-to-end unsupervised detection via learnable Hough-voting networks—indicate that SymGS is framed as a first step toward symmetry-aware 3DGS compression rather than a complete account of structural redundancy in splatted scene representations (Gupta et al., 17 Nov 2025).