acceptodds
Under review as a conference paper at ICLR 2027

Towards Practical Compression of 3D Gaussian Splatting

Abstract

3D Gaussian Splatting (3DGS) enables high-quality novel-view synthesis but requires substantial storage. Existing compression methods often rely on spatial context modeling over irregular 3D representations, increasing the complexity of training and coding. Meanwhile, floating-point context inference can introduce numerical inconsistencies across platforms, causing entropy-decoding failures. To address these practical challenges, we propose COSA-GS, which constructs Context withOut Spatial Aggregation through anchor-wise causal factorization. Specifically, we use geometry context derived from each anchor's coordinates to model a compact learnable anchor latent. The anchor latent is then fused with the geometry context to form an anchor context for attribute coding. The resulting context model features a simple architecture composed solely of linear transformations and activations. We train COSA-GS using rate-distortion optimization with adaptive Gaussian pruning. Further, we develop quantization-aware training and integer inference for the context model to achieve bit-exact consistency of entropy-decoded symbols across platforms. Experiments demonstrate that COSA-GS achieves state-of-the-art compression performance while retaining fast and consistent cross-platform decoding, providing a simple yet effective framework for practical 3DGS compression. Anonymized code and a demo are provided in the supplementary materials and at https://anonymous.4open.science/r/COSA-GS.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
3D Gaussian Splatting, Neural Compression, Causal Context Modeling, Cross-Platform Decoding

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_Wz3sOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper presents COSA-GS, a practical compression framework for 3DGS that aims to improve rate–distortion performance, coding efficiency, and cross-platform decoding consistency. COSA-GS introduces an anchor-wise causal coding scheme that models dependencies within individual anchors. Specifically, coordinate-derived geometry context is used to encode a compact learnable anchor latent, which is subsequently fused with the geometry context to predict the probability distributions of anchor attributes. This design eliminates the need for complex inter-anchor spatial context modeling and enables efficient parallel processing across anchors. Furthermore, the authors develop a quantization-aware integer inference pipeline for the entropy context model to ensure consistent decoding across heterogeneous hardware platforms. Experiments on four standard benchmarks demonstrate competitive rate–distortion performance, substantially faster coding, and consistent cross-platform entropy decoding.

Critical strengths
  1. Efficient anchor-wise coding without spatial aggregation: The proposed anchor-wise causal coding scheme provides a simple and effective alternative to spatial context modeling in existing 3DGS compression methods. By exploiting dependencies among anchor coordinates, learnable latents, and attribute groups, the method avoids complex spatial context aggregation while maintaining strong rate–distortion performance. Its lightweight context model also enables efficient parallel processing across anchors. Experimental results demonstrate favorable compression performance and substantially reduced coding latency compared with existing approaches such as HAC++ and PCGS.
  2. Reliable cross-platform entropy coding: The paper addresses floating-point inconsistencies across hardware platforms by introducing quantization-aware training and integer inference for deterministic entropy decoding. Experiments across multiple GPU–CPU configurations demonstrate identical decoded symbols while maintaining rate–distortion performance close to the floating-point implementation, improving the reliability of learned 3DGS compression.
Critical weaknesses
  1. Insufficient justification for eliminating spatial context aggregation: The paper hypothesizes that 3DGS optimization can reduce inter-anchor dependencies, enabling anchor-wise context modeling. However, this hypothesis lacks direct validation. The ablations neither quantify inter-anchor dependencies nor compare against spatial context modeling under controlled settings, leaving the effectiveness of eliminating spatial aggregation insufficiently justified.
  2. Further clarification of technical contributions: The proposed framework effectively integrates anchor-wise context modeling, rate–distortion optimization, and integer inference into a practical 3DGS compression system. While the overall design is effective, several components build upon established techniques. A clearer discussion of the technical contributions beyond their integration would further strengthen the paper.
Questions for authors
  1. Could the authors provide direct evidence that the proposed optimization reduces inter-anchor dependencies, or compare anchor-wise modeling with spatial context aggregation under otherwise identical settings to better justify its removal?
  2. Could the authors further clarify the key technical distinctions between the proposed anchor-wise context modeling and existing context modeling approaches, and elaborate on which design choices contribute most to the overall compression performance?
2 comments

Thank you for recognizing the efficiency and cross-platform consistency of COSA-GS. We provide additional spatial-context experiments to address your concerns. All averages below cover the nine Mip-NeRF360 scenes.

1. Evidence for omitting spatial context aggregation

To test how much spatial dependence remains after anchor-wise RD optimization, we add spatial context to the trained 15K+30K COSA-GS models. We divide anchors into four interleaved Morton-order groups. For each anchor in a subsequent group, we use cudaKDTree to find the 8 nearest anchors from previously decoded groups. A per-neighbor conditional MLP and mean aggregation combine their features to predict anchor-feature distributions. Starting from the same trained models, we run two settings for 5K additional steps:

  • Frozen spatial: freeze the anchor representation and optimize only the entropy model.
  • Joint spatial: jointly optimize the representation and entropy model.
SettingPSNR (dB)Size (MiB)Decode (ms)
Original COSA-GS27.61264.196081.34
Frozen spatial, +5K27.60054.1937114.22
Joint spatial, +5K27.62754.1679115.62

With the representation frozen, spatial context provides essentially no compression benefit: size decreases by only 0.05%, with a PSNR change of -0.012 dB. Joint optimization reduces size by 0.67% and raises PSNR by 0.015 dB, but increases decoding time by 42%. These results support relatively weak exploitable inter-anchor dependence in the anchor-wise optimized representation. Spatial context becomes more useful when the representation adapts to it. The modest RD gain and substantial decoding overhead support COSA-GS's anchor-wise design as a practical choice.

2. Technical distinctions and sources of compression gains

Existing approaches construct context through spatial feature fields or inter-anchor dependencies. COSA-GS instead derives geometry context directly from each anchor's coordinates. It conditions each latent channel on this geometry context and previously decoded latent channels, then fuses the decoded latent with geometry context for attribute modeling. This forms a causal structure within each anchor, enabling parallel context inference across anchors using only linear layers and activations.

To identify the design choices responsible for the compression gains, we progressively introduce COSA-GS design choices into ContextGS. At each stage, we enable (P) or disable (NP) ContextGS's hierarchical anchor context.

  • S0: Original ContextGS configuration.
  • S1: Add geometry-conditioned causal latent coding, and use 32-channel anchor features and scalar position scaling.
  • S2: Initialize from existing 15K Scaffold models and train the codec for 30K steps with fixed anchors. Adopt COSA-style total-rate optimization, rate warmup, and learning-rate schedules.
  • S3: Adopt COSA-style mask optimization. Prune anchors and freeze masks at 25K, using a threshold of 0.5.
  • S4: Store network parameters in FP16.
  • S5: Replace ContextGS's direct coordinate storage with octree-based coding.

Each stage builds on the preceding one.

StageP: PSNR (dB) / MiBNP: PSNR (dB) / MiB
S027.5987 / 12.458227.6509 / 13.0706
S127.5481 / 10.241027.5012 / 14.3807
S227.7395 / 8.597427.7585 / 8.9623
S327.5866 / 5.327627.5884 / 5.3112
S427.5867 / 5.236227.5881 / 5.2196
S527.5867 / 4.426327.5881 / 4.4212

At S1, disabling hierarchical anchor context increases size by 40.4% while slightly reducing PSNR. After aligning optimization and masking, S3 performs nearly identically with and without this context. This supports our explanation that the benefit of spatial context depends on the representation and its optimization.

These results also explain the sources of compression gains. Building on S1, COSA-style optimization at S2 reduces size by 1.64 MiB and improves PSNR by 0.191 dB in P mode. The masking changes at S3 further reduce size by 3.27 MiB, with a PSNR decrease of 0.153 dB. FP16 network storage and octree-based coordinate coding then reduce storage overhead at S4-S5. Together, these changes bring the NP model to 27.5881 dB at 4.4212 MiB, close to COSA-GS's 27.6126 dB at 4.1960 MiB.

Together, the migration experiments show how representation and optimization choices can make a simple anchor-wise model effective. Adding spatial aggregation provides only a modest further RD gain at a substantial decoding cost. These results align with our practical goal of jointly considering RD performance, decoding speed, and cross-platform deployability. We also provide an anonymous WebGPU demo for browser-based COSA-GS decoding and interactive rendering, together with its source code. We hope these clarifications address your concerns.

Thank you for your response, which has addressed my concerns. I will maintain my positive rating.

Reviewer_j7wrOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes COSA-GS, a 3DGS compression method that does not rely on spatial context aggregation. Built on the anchor representation of Scaffold-GS, it derives a geometry context from each anchor's coordinates, uses it to model a compact anchor latent, and then fuses the two into an anchor context for entropy coding of all attribute groups.

Critical strengths

The architecture is simple, consisting only of anchor-wise linear layers and activations, without hash grids or hierarchical inter-anchor dependencies. Decoding is about two orders of magnitude faster than HAC++ and PCGS (about 0.13 s vs. about 25 s) while also achieving a lower bitrate.

Critical weaknesses
  1. Novelty is limited. Integer networks were introduced by Ballé et al. (2019), and the per-anchor latent is essentially close to a hyperprior (ContextGS also uses a per-anchor hyperprior). The paper reads more like an engineering integration of existing components.
  2. Removing the geometry context barely changes performance, which suggests that the gain mainly comes from the learnable latent rather than the coordinate-derived context. The paper also does not analyze why inter-anchor dependencies can be eliminated without spatial aggregation.
  3. The comparison may be unfair. The default setting uses 45K iterations in total (15K initialization + 30K rate–distortion optimization), more than the 30K/40K used by most baselines, and baseline results are taken directly from the original papers instead of being re-run in the same environment. In addition, the cross-platform experiments cover only NVIDIA GPUs with x86 CPUs, with no ARM, mobile, or other more heterogeneous platforms, and the rendering MLP still runs in FP16.
Questions for authors

Please refer to the weakness part.

2 comments

Thank you for recognizing the simplicity and decoding efficiency of COSA-GS. We provide additional spatial-context and cross-platform decoding experiments to address your concerns. All dataset averages below cover the nine Mip-NeRF360 scenes.

1. Technical contribution

Both ContextGS and COSA-GS use learnable per-anchor latents as side information. However, COSA-GS conditions each latent channel on the anchor's coordinates and previously decoded latent channels, then models attributes within the same anchor without relying on ContextGS's hierarchical anchor context. This organization allows context inference to run in parallel across anchors and supports a lightweight implementation using linear layers and activations.

We extend the integer inference approach of Balle et al. (2019) from learned image compression to 3DGS compression. Our pipeline uses integer arithmetic for context prediction, CDF selection, and reconstruction of values reused as context to ensure consistent entropy decoding across platforms. Our contribution lies in a simple anchor-wise causal framework that coordinates representation, optimization, and coding to jointly address RD performance, decoding speed, and cross-platform deployability.

2. Spatial dependence

The ablations in Fig. 4 show that either geometry context or the learnable anchor latent can provide informative conditioning. Geometry context remains useful without latent context, demonstrating its contribution to compression. Removing both sources noticeably degrades RD performance. The proposed design therefore draws on their combined role rather than relying on latent context alone.

To directly examine the remaining spatial dependence, we add spatial context to trained 15K+30K COSA-GS models. Anchors are divided into four interleaved Morton-order groups. For each anchor in a subsequent group, cudaKDTree finds the 8 nearest anchors from previously decoded groups. A per-neighbor conditional MLP and mean aggregation combine their features to predict anchor-feature distributions. We run 5K additional steps with the representation either frozen or jointly optimized with the entropy model.

SettingPSNR (dB)Size (MiB)Decode (ms)
Original COSA-GS27.61264.196081.34
Frozen spatial, +5K27.60054.1937114.22
Joint spatial, +5K27.62754.1679115.62

With the representation frozen, spatial context reduces size by only 0.05%. Joint optimization reduces size by 0.67% and raises PSNR by 0.015 dB, but increases decoding time by 42%. These results support relatively weak exploitable inter-anchor dependence in the anchor-wise optimized representation. Spatial context becomes more useful when the representation adapts to it, with a modest RD gain and substantial decoding overhead.

We further examine this dependence by progressively introducing COSA-GS design choices into ContextGS. At each stage, we enable (P) or disable (NP) ContextGS's hierarchical anchor context, keeping the network architecture unchanged within each pair.

  • S0: Original ContextGS configuration, trained for 30K steps from the input point cloud.
  • S1: Add geometry-conditioned causal latent coding, and use 32-channel anchor features and scalar position scaling.
  • S2: Initialize from existing 15K Scaffold models and train the codec for 30K steps with fixed anchors. Adopt COSA-style total-rate optimization, rate warmup, and learning-rate schedules.
  • S3: Adopt COSA-style mask optimization. Prune anchors and freeze masks at 25K, using a threshold of 0.5.
  • S4: Store network parameters in FP16.
  • S5: Replace ContextGS's direct coordinate storage with octree-based coding.

Each stage builds on the preceding one.

StageP: PSNR (dB) / MiBNP: PSNR (dB) / MiB
S027.5987 / 12.458227.6509 / 13.0706
S127.5481 / 10.241027.5012 / 14.3807
S227.7395 / 8.597427.7585 / 8.9623
S327.5866 / 5.327627.5884 / 5.3112
S427.5867 / 5.236227.5881 / 5.2196
S527.5867 / 4.426327.5881 / 4.4212

At S1, disabling hierarchical anchor context increases size by 40.4% while slightly reducing PSNR. After aligning optimization and masking, S3 performs nearly identically with and without this context. Together with the spatial context experiment above, this supports our explanation that the benefit of spatial context depends on the representation and its optimization.

AuthorsOpenReview ↗

Official Comment by Authors

3. Comparison protocol

Although our default setting is 15K+30K, we also provide complete 15K+20K results (35K iterations in total) across all four datasets in Table 6, with the corresponding RD curves in Figs. 3 and 6. The 35K setting retains competitive RD performance, showing that our results do not rely solely on the additional training steps.

We follow the same training/test view splits and image-resolution settings as prior work, as detailed in Appendix A.1, and use the RD results reported by the original authors. We do not expect repeating their training under the same configurations to improve their reported RD performance. However, we are willing to rerun the complete training and evaluation of the baselines in our environment to verify these results if needed.

4. Cross-platform deployment

We provide an anonymous WebGPU demo for browser-based COSA-GS decoding and interactive rendering, together with its source code. We have tested it on desktop computers, Android phones, and iPhones, extending deployment beyond the NVIDIA/x86 configurations in Table 2. The demo supports consistency checks using SHA-256 hashes of decoded integer coordinates and entropy symbols. For the provided scene, the expected verification hash is 1bab7c3de0268fcf26dccd4a08c54a30d33e22e9bcf57d9c26269f78a1dfa5bc.

As explained in the paper, our consistency goal is to ensure bit-exact recovery of entropy symbols across platforms and prevent entropy-decoding failures. The rendering MLP operates after entropy decoding and does not feed back into context prediction or CDF selection. Storing its weights in FP16 and using floating-point rendering therefore do not compromise this goal. Table 2 and the browser demo verify bit-exact consistency of decoded anchor coordinates and entropy symbols. We hope these clarifications address your concerns.

Reviewer_Zn79OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes COSA-GS, a 3DGS compression framework built on Scaffold-GS anchors that constructs context without spatial aggregation. Anchor coordinates are coded with an octree using per-level empirical distributions. For each anchor, a geometry context is derived from its own normalized coordinate, a compact learnable anchor latent (4 channels) is coded channel-wise autoregressively from this context, and the two are fused into an anchor context. All attribute groups (feature, position scaling, offsets, Gaussian scaling) are then coded with a Gaussian model in a fixed within-anchor causal order, with a binary offset mask for adaptive pruning. The model is trained with a rate–distortion objective, and quantization-aware training with integer linear layers, integer GELU and precomputed integer CDF tables enables bit-exact entropy decoding across platforms. Experiments on Mip-NeRF360, DeepBlending, Tanks&Temples and BungeeNeRF show competitive or better RD performance than ContextGS, HAC++, CAT-3DGS, PCGS and SpeedyGS, very fast decoding, and consistent decoding bitstreams on three GPU–CPU platforms.

Critical strengths

• The paper addresses two practical problems (coding speed and cross-platform consistency) that are rarely studied in 3DGS compression. The architecture is simple and fully parallel across anchors, the integer pipeline is described in detail, and code, a demo and per-scene results are provided.

  1. Anchor-wise context without spatial aggregation enables fast, fully parallel decoding. Existing methods must gather information from neighbor each anchor to build its context. HAC++, PCGS and CAT-3DGS interpolate shared hash grids or triplanes, and ContextGS predicts finer anchors from decoded neighbours level by level. This aggregation adds extra structures and sequential dependencies that slow down decoding. COSA-GS removes this step. Each anchor’s context comes only from its own decoded coordinate and its own latent, through small Linear + GELU layers, so no anchor has to wait for or read from any other anchor. All anchors are therefore processed in parallel, and the only sequential steps are a few within-anchor stages (4 latent channels, then the attribute groups)
  2. The paper identifies cross-platform entropy-decoding consistency as a practical requirement that prior 3DGS codecs ignore, floating-point context inference can introduce numerical inconsistencies across platforms, causing entropy-decoding failures.
Critical weaknesses
  1. RD optimization removes inter-anchor dependence” is only inferred from RD curves. The “w/o geometry context” ablation is close to the full model, so the method is essentially a per-anchor hyperprior (as in ContextGS) without the hash grid. This makes it hard to judge whether the gain comes from the proposed principle or from other factors.
  2. The paper motivates the integer pipeline by stating that floating-point context inference can cause entropy-decoding failures across platforms. However, the only cross-platform experiment (Table 2) evaluates the QAT variant of COSA-GS, and no existing method or floating-point model is tested.
Questions for authors
  1. RD optimization removes inter-anchor dependence” is only inferred from RD curves. The “w/o geometry context” ablation is close to the full model, so the method is essentially a per-anchor hyperprior (as in ContextGS) without the hash grid. This makes it hard to judge whether the gain comes from the proposed principle or from other factors.
  2. The paper motivates the integer pipeline by stating that floating-point context inference can cause entropy-decoding failures across platforms. However, the only cross-platform experiment (Table 2) evaluates the QAT variant of COSA-GS, and no existing method or floating-point model is tested.
2 comments

Thank you for recognizing the practical value of fast decoding and cross-platform consistency. We provide additional spatial-context and cross-platform decoding experiments to address your concerns. All averages below cover the nine Mip-NeRF360 scenes.

1. Inter-anchor dependence and the source of compression gains

Adding spatial context to a trained COSA-GS representation. To test how much spatial dependence remains after anchor-wise RD optimization, we add spatial context to the trained 15K+30K COSA-GS models. We divide anchors into four interleaved Morton-order groups. For each anchor in a subsequent group, we use cudaKDTree to find the 8 nearest anchors from previously decoded groups. A per-neighbor conditional MLP and mean aggregation combine their features to predict anchor-feature distributions. We run two settings for 5K additional steps:

  • Frozen spatial: freeze the anchor representation and optimize only the entropy model.
  • Joint spatial: jointly optimize the representation and entropy model.
SettingPSNR (dB)Size (MiB)Decode (ms)
Original COSA-GS27.61264.196081.34
Frozen spatial, +5K27.60054.1937114.22
Joint spatial, +5K27.62754.1679115.62

With the representation frozen, spatial context provides essentially no compression benefit: size decreases by only 0.05%, with a PSNR change of -0.012 dB. Joint optimization reduces size by 0.67% and raises PSNR by 0.015 dB, but increases decoding time by 42%.

These results support relatively weak exploitable inter-anchor dependence in the anchor-wise optimized representation. Spatial context becomes more useful when the representation adapts to it. The modest RD gain and substantial decoding overhead support COSA-GS's anchor-wise design as a practical balance between compression efficiency and speed.

Tracing the gains from ContextGS to COSA-GS. We progressively introduce COSA-GS design choices into ContextGS. At each stage, we enable (P) or disable (NP) ContextGS's hierarchical anchor context, keeping the network architecture unchanged within each pair.

  • S0: Original ContextGS configuration, trained for 30K steps from the input point cloud.
  • S1: Add geometry-conditioned causal latent coding, and use 32-channel anchor features and scalar position scaling.
  • S2: Initialize from existing 15K Scaffold models and train the codec for 30K steps with fixed anchors. Adopt COSA-style total-rate optimization, rate warmup, and learning-rate schedules.
  • S3: Adopt COSA-style mask optimization. Prune anchors and freeze masks at 25K, using a threshold of 0.5.
  • S4: Store network parameters in FP16.
  • S5: Replace ContextGS's direct coordinate storage with octree-based coding.

Each stage builds on the preceding one.

StageP: PSNR (dB) / MiBNP: PSNR (dB) / MiB
S027.5987 / 12.458227.6509 / 13.0706
S127.5481 / 10.241027.5012 / 14.3807
S227.7395 / 8.597427.7585 / 8.9623
S327.5866 / 5.327627.5884 / 5.3112
S427.5867 / 5.236227.5881 / 5.2196
S527.5867 / 4.426327.5881 / 4.4212

At S1, disabling hierarchical anchor context increases size by 40.4% while slightly reducing PSNR. After aligning optimization and masking, S3 performs nearly identically with and without this context. By S5, the NP model reaches 27.5881 dB at 4.4212 MiB, close to COSA-GS's 27.6126 dB at 4.1960 MiB. This shows that the benefit of spatial context depends on the representation and its optimization. The substantial gains at S2-S3 highlight the importance of training and masking choices, with storage changes providing further reductions at S4-S5.

3DGS compression has advanced rapidly in recent years, with many valuable ideas and methods. Both ContextGS and COSA-GS use learnable latents as side information. However, COSA-GS conditions each latent channel on the anchor's coordinates and previously decoded latent channels, then models attributes within the same anchor without relying on ContextGS's hierarchical anchor context. This aligns with our goal of developing a simple, practical compression framework that jointly considers RD performance, decoding speed, and cross-platform deployability. We hope these additional experiments address your concerns and that COSA-GS can be a simple yet efficient reference for future research.

AuthorsOpenReview ↗

Official Comment by Authors

2. Cross-platform failure of the floating-point model

To evaluate cross-platform decoding, we encode on an RTX 5880 Ada and decode the same bitstreams on both the RTX 5880 Ada and an RTX 4090. All models are trained with a rate weight of 0.002.

ModelDecoding GPUPSNR (dB)SSIMLPIPSSize (MiB)
Floating-pointRTX 5880 Ada27.61260.79850.26284.1960
Floating-pointRTX 409019.63140.59190.40954.1960
QAT / integer contextRTX 5880 Ada27.64980.80160.25794.4722
QAT / integer contextRTX 409027.64980.80160.25794.4722

Floating-point decoding degrades quality on all nine scenes, with an average PSNR drop of 7.98 dB. Integer context inference preserves quality. These results directly demonstrate the failure our integer pipeline addresses.

We also provide an anonymous WebGPU demo for browser-based COSA-GS decoding and interactive rendering, together with its source code. We have tested it on desktop computers, Android phones, and iPhones. The demo supports cross-platform consistency checks using SHA-256 hashes of the decoded integer coordinates and entropy symbols. For the provided scene, the expected verification hash is 1bab7c3de0268fcf26dccd4a08c54a30d33e22e9bcf57d9c26269f78a1dfa5bc.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.