Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

Efficient 3D Gaussian Splatting with Axis-Shared Rasterization and Order-independent Transmittance

T0 review · 4 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that 3D Gaussian splatting can run in real time on edge hardware by replacing explicit depth sorting with a tiny learned decay function and reusing shared axis terms in rasterization, achieving 23.4–27.8x speedup and…

desk verdict Rasterization factorization is a real contribution; the neural sorting is a per-scene fit, not a general replacement, and the abstract overstates partial speedups as end-to-end. read the letter →

arxiv 2506.07069 v2 pith:NZ7BQI4L submitted 2025-06-08 cs.GR cs.ARcs.CVcs.LG

Zhican Wang , Guanghui He , Lingjun Gao , Dantong Liu , Shell Xu Hu , Chen Zhang , Zhuoran Song , Nicholas Lane
show 1 more author
Hongxiang Fan
This is my paper
classification cs.GRcs.ARcs.CVcs.LG
keywords 3DGaussianSplattinghardwareacceleratorneuralsortingorder-independenttransparencyaxis-sharedrasterizationreconfigurablePEarraytilescheduling
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper tries to establish that 3D Gaussian splatting (3DGS) can be made practical on resource-constrained edge devices by removing two bottlenecks: redundant per-pixel arithmetic in rasterization and the expensive explicit depth sort that feeds alpha blending. It does this by precomputing and broadcasting terms shared along image X- and Y-axes, and by replacing the sort with a two-layer MLP that maps each Gaussian's depth to a decay factor used in an order-independent weighted sum. If correct, a 16x16 reconfigurable FP16 processing array can render MipNeRF-360 scenes at more than 50 FPS end-to-end using 1.64W, while staying within about 1 dB PSNR of the original sorting-based algorithm (26.50 vs 27.45 on average) and beating both edge GPUs and prior dedicated accelerators in speed and energy.

What carries the argument

Two mechanisms carry the argument. Axis-shared rasterization: for a $16\times16$ tile, dedicated X-PE and Y-PE lines compute the X-axis term, Y-axis term, squared terms, and cross-term coefficient once, then broadcast them to a $16\times16$ PE array where each PE only combines the received values (2 multiply, 2 add, 1 exponential per pixel instead of 8 multiply, 4 add). Neural sorting: a two-layer MLP with Leaky ReLU hidden activation and exponential output takes depth $d_i$ and outputs the decay factor $F(d_i)$; its 6 MACs fit inside the same reconfigurable PE array, which switches between rasterization mode and sorting mode. Supporting hardware mechanisms include a fine-grained interleaved pipeline that overlaps the memory-bound MLP sorting of the next subtile with rasterization of the current one, and a generalized $\pi$-trajectory tile schedule (a Hilbert-like ordering) that raises the Gaussian feature cache hit rate from 43% to 62%.

What would settle it

Take a scene with many overlapping semi-transparent Gaussians at similar depths (foliage, glass layers, smoke), fine-tune the MLP with the paper's recipe, and render novel views; if the average PSNR gap to the full sorted baseline exceeds the roughly 1 dB reported here, or if artifacts such as see-through occluders appear, the order-independent decay assumption is falsified. A more direct test is to compare the learned $F(d_i)$ against the true transmittance $\prod_{j<i}(1-\alpha_j)$ for a fixed checkpoint: systematic mismatch in high-occlusion tiles would show the MLP is learning a scene-specific heuristic rather than a general transmittance model.

Watch

Extended reading notes

Core claim

The central claim is that sorting in 3DGS exists only to compute a per-Gaussian decay factor (the transmittance), and that this decay can be learned rather than explicitly ordered. A tiny MLP with only 10 parameters and 6 MACs maps Gaussian depth $d_i$ to a decay $F(d_i)$, replacing the front-to-back product $T_i = \prod_{j<i}(1-\alpha_j)$ with $F(d_i)$ inside the weighted sum $C = \sum_i F(d_i)\alpha_i c_i / \sum_i F(d_i)\alpha_i$. The paper reports that, when trained from a pretrained sorting-based checkpoint with clone/split disabled and with the MLP learning faster than the Gaussians, this order-independent blending produces rendering quality close to the baseline and better than the prior sort-free weighted-sum approach (average PSNR 26.50 vs 25.43). Alongside this, the paper claims that axis-oriented rasterization reduces the $\alpha$-computation MAC count by up to 63% with no loss of parallelism.

Load-bearing premise

The load-bearing premise is that a single per-scene 10-parameter function of depth alone, trained from a sorted-checkpoint initialization, can reproduce the visual effect of exact front-to-back alpha blending on arbitrary tiles and views; if it cannot on scenes with complex occlusion or view-dependent transparency, the 'negligible quality loss' claim fails even though the rasterization hardware would still work.

Editorial extensions

If this is right

  • Rendering quality stays within roughly 1 dB PSNR of fully sorted 3DGS while removing the sorting unit from the hardware pipeline; rasterization alone runs at 16.9–20.4x the speed of the edge GPU, exceeding 150 FPS on the tested scenes.
  • A dedicated 16x16 FP16 array at 3.85 mm^2 and 1.64 W in 28nm can meet real-time (over 50 FPS end-to-end) rendering on MipNeRF-360 scenes, with 23.4–27.8x speedup and 28.8–51.4x energy savings over an edge GPU.
  • Replacing per-pixel parallel rasterization with axis-shared, broadcast terms cuts the alpha-computation cost from 8 multiplications and 4 additions to 2 and 2 per pixel, reducing total multiplier count by about 63% while keeping one Gaussian-per-cycle throughput.
  • The interleaved pipeline makes sorting latency effectively negligible: even a naive pipelined version is 102–525x faster than GPU sorting, and the interleaved version reaches roughly 2000x by hiding memory-bound MLP evaluation behind rasterization.
  • The generalized pi-trajectory tile schedule reduces off-chip energy by 2.56x versus a design without cache and by 1.23x versus the Z-trajectory, because it exploits horizontal, vertical, and hierarchical locality in tile traversal.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the central claim holds, the 'sorting is just a decay function' idea may transfer to other order-dependent compositing pipelines, such as particle systems or layered volume rendering, but the depth-to-decay MLP would need per-scene retraining because the paper only demonstrates per-scene fits.
  • The reported end-to-end speedup (7.8–11.5x) is much smaller than the 23.4–27.8x speedup for rasterization plus sorting, because Gaussian projection still runs on the edge GPU; a full-system benefit would require accelerating projection too, which the paper explicitly leaves to the GPU.
  • The requirement to start from a pretrained sorting-based checkpoint and to disable clone/split means the method is a fine-tuning recipe, not a from-scratch training pipeline; scenes trained from scratch with the MLP did not converge in the paper's experiments, so adoption in training-from-scratch workflows would need a different initialization strategy.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The manuscript proposes an algorithm-hardware co-design for 3D Gaussian splatting (3DGS). It makes three main contributions: (i) axis-oriented rasterization, which factors the per-pixel Gaussian exponent computation into shared X-axis and Y-axis terms and combines them in each PE, reducing the per-PE arithmetic from 8 multipliers and 4 adders to about 2.25 multipliers and 2.19 adders when including the support PE lines; (ii) a neural sorting scheme that replaces explicit depth sorting with a two-layer, 10-parameter MLP mapping depth d_i to a decay factor F(d_i), used in a normalized weighted sum (Eq. 4); and (iii) a 16x16 reconfigurable PE array that supports both rasterization and MLP inference, together with a fine-grained interleaved pipeline and a pi-trajectory tile schedule. Experiments on six MipNeRF-360 scenes report PSNR 26.50 on average versus 27.45 for a sorted baseline, and hardware evaluations report 23.4-27.8x speedup and 28.8-51.4x energy savings over an edge GPU, plus 1.94-2.39x area-efficiency and 1.36-1.89x energy-efficiency gains over GSCore.

Significance. The axis-shared rasterization identity is a legitimate and clearly explained arithmetic saving: the per-PE MAC reduction is substantial, and the hardware design is presented in enough detail (RTL synthesis, cycle-accurate simulator cross-validated with RTL, CACTI and DRAMPower estimates) to be credible as an engineering contribution. The design-space exploration of the MLP and the ablation study isolating each optimization are also strengths. The paper is less convincing on the algorithmic side: the claim that neural sorting 'preserves rendering quality' is the load-bearing premise for the whole co-design, and that premise currently rests on a per-scene co-training procedure whose comparison baseline is not matched in training budget. If the quality claim can be re-benchmarked and appropriately scoped, the hardware contributions would merit publication.

major comments (4)
  1. [Sec. 4.1-4.2, Eq. (4)] The central algorithmic claim that Eq. (4) can replace exact front-to-back alpha blending with negligible quality loss is not backed by a correctness argument or a controlled experiment. Exact transmittance in Eq. (3) is T_i = prod_{j<i}(1-alpha_j), which depends on the accumulated opacity of every preceding Gaussian and on their order. A scalar function F(d_i) of depth alone cannot represent such order-dependent interactions in general. The paper itself reports in Sec. 4.2 that co-training the MLP and Gaussians from scratch fails and that freezing the Gaussians while training only the MLP also fails, which shows that the method is not a drop-in sorting replacement for a fixed scene model. The quality numbers in Table 1 are therefore the result of a co-trained model with an additional 15,000 iterations of fine-tuning, not a demonstration that sorting can be omitted without quality loss. Please report the frozen-Gaussian baseline quantitatively and compare against the sorted baseline at matched total training budget.
  2. [Sec. 6.1 and Table 1] The quality comparison is confounded by training protocol. The baseline is trained for 7,000 epochs, while the neural-sorting model starts from that checkpoint and is trained for a further 15,000 epochs with the Gaussian learning rate scaled by 0.01, clone and split disabled, and the best-PSNR checkpoint selected. This gives the proposed method a longer and differently regularized training schedule, so the reported average gap of 0.95 dB PSNR and the per-scene gaps of 1.43-1.55 dB on Room and Bonsai cannot be attributed to the sorting-free formulation alone. The comparison with the sort-free method [16] is also a reproduction under the authors' own framework; the reproduction protocol is not described in enough detail to assess fairness. Please provide per-scene PSNR curves over training time and the exact settings used for the [16] baseline.
  3. [Sec. 6.1-6.2] Generalization to unseen scenes is not evaluated. The MLP F(d_i) is trained per scene on the same reconstruction loss used to report quality, so the 'negligible quality loss' claim in the abstract and Sec. 6.5 is only demonstrated on the six training scenes. Scenes with more complex occlusion (Room, Bonsai) already show the largest gaps. To support the architecture-algorithm co-design claim, the authors should either evaluate cross-scene transfer (e.g., train the MLP on one scene and test on held-out scenes or held-out views with denser occlusion) or explicitly limit the claim to per-scene fine-tuned deployment.
  4. [Sec. 6.5, Fig. 17] The headline speedup numbers mix algorithmic and hardware contributions in a way that could mislead. The sorting+rasterization speedup of 23.4-27.8x drops to 7.8-11.5x end-to-end once the edge GPU executes projection, and the comparison with GSCore is reported as area efficiency and energy efficiency rather than end-to-end latency. Please state clearly whether the GSCore comparison includes projection and memory system effects, and report end-to-end latency/energy for both designs under the same workload. Without this, the claimed advantage over prior accelerators is not directly comparable.
minor comments (6)
  1. [Title/Abstract/Sec. 3] The arXiv abstract and the full-text title differ ('Axis-Shared Rasterization and Order-independent Transmittance' vs. 'Neural Sorting and Axis-Oriented Rasterization'), and the abstract states a MAC reduction of up to 38% while Sec. 3 states 63%; please align these.
  2. [Eq. (3)] Eq. (3) uses alpha_i inside the product for T_i; it should be alpha_j (or alpha_{j}) to be correct.
  3. [Throughout] There are numerous typos and inconsistent terms, e.g., 'PNSR' for PSNR, 'redundency', 'minized', and alternating 'GScore'/'GSCore'; please proofread.
  4. [Sec. 6.1] '7000epochs' is presumably 'iterations' or 'steps' (the original 3DGS trains for 30k iterations); please clarify the training schedule and use the same unit throughout.
  5. [Fig. 13] In Fig. 13, the PSNR differences across activation functions are small (roughly 25.1-25.9 dB); please indicate whether these differences are consistent across scenes or only shown for Garden.
  6. [Abstract/Code availability] The paper states the code is open source at a GitHub URL containing 'ISCA26'; if the manuscript is intended for journal review, the URL should not pre-commit to a specific conference.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the learned transmittance is a per-scene trained approximation validated against external baselines, not a quantity forced by construction.

full rationale

The paper's central algorithmic claim is that a tiny MLP can replace explicit depth sorting by producing a depth-dependent decay factor F(d_i) in the weighted-OIT-style equation (4). This is a learned approximation, not an algebraic derivation: F(d_i) is not constructed to equal the exact transmittance T_i = prod_{j<i}(1-alpha_j) from equation (3), and the paper never claims equality. Instead, the MLP is an independent 10-parameter function optimized end-to-end against the image reconstruction loss on MipNeRF-360 scenes, with the resulting rendering compared to a sorted 3DGS baseline. The quality comparison is therefore an empirical result, not a tautology. The paper's own admissions that co-training from scratch fails and that freezing the Gaussians while training only the MLP does not work (Sec. 4.2) narrow the scope of the claim: the method requires initialization from a sorting-based pretrained checkpoint and subsequent co-training. But this is a limitation and a contingency of the training procedure, not a circular reduction, because the MLP outputs are not defined in terms of the quantity they are said to predict. The hardware claims are also self-contained: axis-oriented rasterization is an arithmetic restructuring with a concrete MAC count, and the speedup/energy numbers come from a cycle-accurate simulator compared against an external GSCore implementation and a Jetson edge GPU. The only apparent self-citation is GSArch [12] in related work, and it is not load-bearing. Potential concerns about per-scene fitting and checkpoint selection by PSNR are correctness or overfitting risks, not circularity under the definitions used here. No step in the paper's derivation chain reduces, by construction or self-citation, to its own inputs.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The central algorithmic novelty, the learned decay function, adds ten fitted parameters per scene plus several hand-chosen training hyperparameters. The axis-shared rasterization adds no free parameters. The method relies on established approximations from weighted OIT and on the assumption that a small MLP is expressive enough; no new physical entities are introduced.

free parameters (5)
  • MLP weights and biases for F(d) = 10 values, not listed in paper
    Trained per scene on MipNeRF-360 to minimize reconstruction loss; defines the learned transmittance or decay function that replaces sorting (Sec. 4.2).
  • MLP learning rate = 0.005
    Hand-chosen hyperparameter for neural sorting training (Sec. 6.1).
  • Gaussian learning rate scaling factor = 0.01
    Hand-chosen factor applied to original 3DGS learning rates during neural sorting training (Sec. 6.1).
  • Training epoch counts = 7000 baseline, 15000 neural sorting, best PSNR checkpoint
    Selected by hand and by best-PSNR selection; affects the reported quality comparison (Sec. 6.1).
  • Leaky ReLU negative slope = 1/8
    Chosen for hardware simplicity rather than derived from data (Sec. 4.2).
assumptions (4)
  • domain assumption Exact front-to-back alpha blending in 3DGS can be approximated by weighted sum rendering with a single depth-dependent factor F(d_i).
    Equation (4) is adopted from weighted order-independent transparency [24] and sort-free 3DGS [16]; the paper does not derive an error bound for this approximation (Sec. 4.1).
  • ad hoc to paper A 2-layer, 10-parameter MLP with only depth as input is sufficient to represent the needed decay factor across a scene.
    The MLP architecture is chosen by a small design exploration on one scene (garden) and is not shown to be sufficient for unseen scenes (Sec. 4.2 and Sec. 6.2).
  • domain assumption The pretrained 3DGS checkpoint from the original sorting-based pipeline is a valid initialization for the sort-free pipeline.
    Training from scratch is reported to fail; the method depends on starting from a checkpoint produced by the very sorting process it aims to replace (Sec. 4.2).
  • domain assumption The cycle-accurate simulator and RTL synthesis correctly model the proposed hardware and the GSCore baseline.
    GSCore comparison is based on a simulator implemented by the authors, and RTL is cross-validated only internally (Sec. 6.1 and Sec. 6.5).

how reviews work

0 comments
Cite this review

Pith. "Pith review of Efficient 3D Gaussian Splatting with Axis-Shared Rasterization and Order-independent Transmittance." pith.science (2026). https://pith.science/paper/NZ7BQI4L

@misc{pith2026250607069,
  author       = {Pith},
  title        = {Pith review of: Efficient 3D Gaussian Splatting with Axis-Shared Rasterization and Order-independent Transmittance},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NZ7BQI4L}},
  note         = {Machine review of arXiv:2506.07069}
}
read the original abstract

3D Gaussian Splatting (3DGS) has emerged as a powerful technique for novel view synthesis, combining high-quality reconstruction with efficient rendering. It has been widely adopted in domains such as AR/VR, robotics, and autonomous driving. However, achieving real-time performance on resource-constrained platforms remains challenging due to strict power and area budgets. Prior accelerators improve hardware performance but still overlook key inefficiencies, including insufficient rasterization efficiency, poor sorting scalability, and pipeline imbalance. This paper presents an architecture-algorithm co-design to address these challenges. First, we propose axis-shared rasterization, which precomputes and reuses common terms along the X- and Y-axes, reducing multiply-and-accumulate (MAC) operations by up to 38% while preserving high parallelism. Second, we develop a novel order-independent transmittance method that removes the need for explicit sorting by leveraging a lightweight multilayer perceptron (MLP) to directly approximate the transmittance of each Gaussian, enabling efficient alpha blending with negligible quality loss. Third, we design a unified reconfigurable PE array that supports both rasterization and MLP inference, sustaining high utilization without costly sorting hardware. Our experiments demonstrate that our design preserves rendering quality while achieving a 1.33 to 1.88x speedup over state-of-the-art 3DGS accelerators. Our code is open source at https://github.com/WangZhican/ISCA26_3DGS_Acc.

Figures

Figures reproduced from arXiv: 2506.07069 by the authors.

Figure 1
Figure 1. Challenges of 3DGS acceleration and organization of the paper. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The source of redundant computing in rasterization. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The number of Gaussians varies across tiles and [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (13 more)
Figure 4
Figure 4. Figure 4: Hardware and computation flow of axis-oriented [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: 3DGS 𝛼 blending is similar to image composition. Apparently, the over operation is non-commutative, thus requir￾ing costly depth sorting. Fortunately, several order-independent transparency (OIT) techniques have been proposed in computer graphics [3, 5, 6, 24, 27]. Giv…
Figure 6
Figure 6. Figure 6: Neural network structure and the training framework. [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]
Figure 7
Figure 7. Figure 7: Unified hardware architecture of rasterization and neural sorting (left), and the structure of modules (right). [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Rasterization mode configured PE. e x M-4-1 M-4-2 M-4-3 A-4-1 E A-4-2 A-4-3 M-1 A-1 M-2 M-3 A-3 A-2 di w1 w2 w3 b1 b2 b3 w4 w5 w6 b4 Sorting Mode PE w4 w5 w6 +b4 e x +b1 +b2 +b3 Layer-1 Layer-2 w1 w2 w3 [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]
Figure 10
Figure 10. Figure 10: Roofline model analysis and pipeline comparison. [PITH_FULL_IMAGE:figures/full_fig_p008_10.png]
Figure 11
Figure 11. Figure 11: Comparison of different tile schedule trajectories with [PITH_FULL_IMAGE:figures/full_fig_p009_11.png]
Figure 12
Figure 12. Figure 12: Visualization of our neural sorting training process with an indoor (left) and an outdoor (right) scene. [PITH_FULL_IMAGE:figures/full_fig_p010_12.png]
Figure 15
Figure 15. Figure 15: Cache hit rate and energy comparison. the baseline trajectory, the Z-trajectory, and our generalized 𝜋- trajectory tile schedule. The baseline achieves a hit rate of 43%, the Z-trajectory 55%, and our method improves the hit rate to 62%. The corresponding off-chip acc…
Figure 14
Figure 14. Figure 14: Speedup of variants isolating each optimization. [PITH_FULL_IMAGE:figures/full_fig_p010_14.png]
Figure 16
Figure 16. Figure 16: Speedup of rasterization and sorting over GPU. [PITH_FULL_IMAGE:figures/full_fig_p011_16.png]
Figure 17
Figure 17. Figure 17: Overall speedup and energy saving over GPU. [PITH_FULL_IMAGE:figures/full_fig_p011_17.png]
Figure 18
Figure 18. Figure 18: Comparison with SOTA accelerator [22]. Comparison with SOTA Accelerators. We select GSCore [22] for comparison because it also focuses on the original 3DGS infer￾ence and accelerates the sorting and rasterization through dedi￾cated hardware design, while others focus …

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. DeGS: A Scalable 3DGS Architecture via Decoupled Workload Parsing and Reorganization

    cs.AR 2026-08 conditional novelty 6.0 of 10

    DeGS restructures 3DGS rendering into span parsing, task reorganization, and dense blending stages, achieving 1.8x-7.2x speedup and >80% scaling utilization over prior 3DGS accelerators.

Reference graph

Works this paper leans on

46 extracted references · 24 canonical work pages · cited by 1 Pith paper

  1. [16]

    Qiqi Hou, Randall Rauwendaal, Zifeng Li, Hoang Le, Farzad Farhadzadeh, Fatih Porikli, Alexei Bourd, and Amir Said. 2024. Sort-free Gaussian Splatting via Weighted Sum Rendering.arXiv preprint arXiv:2410.18931(2024)

    arXiv 2024

  2. [1]

    2022.NVIDIA Jetson Xavier NX-based AI Vision System

    ADLINK Technology Inc. 2022.NVIDIA Jetson Xavier NX-based AI Vision System. https://www.adlinktech.com/en/news/nvidia-xavier-nxbasedpoe-ai- vision-system

    work page 2022

  3. [2]

    Jonathan T Barron, Ben Mildenhall, Dor Verbin, Pratul P Srinivasan, and Peter Hedman. 2022. Mip-nerf 360: Unbounded anti-aliased neural radiance fields. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 5470–5479

    2022

  4. [3]

    Loren Carpenter. 1984. The A-buffer, an antialiased hidden surface method. In Proceedings of the 11th annual conference on Computer graphics and interactive techniques. 103–108

    work page 1984

  5. [4]

    Karthik Chandrasekar, Christian Weis, Yonghui Li, Benny Akesson, Norbert Wehn, and Kees Goossens. 2012. DRAMPower: Open-source DRAM power & energy estimation tool.URL: http://www. drampower. info22 (2012)

    work page 2012

  6. [5]

    Eric Enderton, Erik Sintorn, Peter Shirley, and David Luebke. 2010. Stochastic transparency. InProceedings of the 2010 ACM SIGGRAPH symposium on Interactive 3D Graphics and Games. 157–164

    work page 2010

  7. [6]

    Cass Everitt. 2001. Interactive order-independent transparency.White paper, nVIDIA2, 6 (2001), 7

    work page 2001

  8. [7]

    Zhiwen Fan, Kevin Wang, Kairun Wen, Zehao Zhu, Dejia Xu, Zhangyang Wang, et al. 2024. Lightgaussian: Unbounded 3d gaussian compression with 15x reduc- tion and 200+ fps.Advances in neural information processing systems37 (2024), 140138–140158

    2024

Show all 46 references
  1. [8]

    Guangchi Fang and Bing Wang. 2024. Mini-splatting: Representing scenes with a constrained number of gaussians. InEuropean Conference on Computer Vision. Springer, 165–181

    2024

  2. [9]

    Guangchi Fang and Bing Wang. 2024. Mini-Splatting2: Building 360 Scenes within Minutes via Aggressive Gaussian Densification.arXiv preprint arXiv:2411.12788 (2024)

    2024

  3. [10]

    Sharath Girish, Kamal Gupta, and Abhinav Shrivastava. 2024. Eagles: Efficient accelerated 3d gaussians with lightweight encodings. InEuropean Conference on Computer Vision. Springer, 54–71

    2024

  4. [11]

    Frank Gray. 1953. Pulse code communication.United States Patent Number 2632058(1953)

    1953

  5. [12]

    Houshu He, Gang Li, Fangxin Liu, Li Jiang, Xiaoyao Liang, and Zhuoran Song

  6. [13]

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2015. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. InProceedings of the IEEE international conference on computer vision. 1026–1034

    2015

  7. [14]

    David Hilbert and David Hilbert. 1935. Über die stetige Abbildung einer Linie auf ein Flächenstück.Dritter Band: Analysis·Grundlagen der Mathematik·Physik Verschiedenes: Nebst Einer Lebensgeschichte(1935), 1–2

    1935

  8. [15]

    Charles Antony Richard Hoare. 1961. Algorithm 64: quicksort.Commun. ACM 4, 7 (1961), 321

    1961

  9. [17]

    Mihai F Ionescu and Klaus E Schauser. 1997. Optimizing parallel bitonic sort. In Proceedings 11th International Parallel Processing Symposium. IEEE, 303–309

    1997

  10. [18]

    Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis

  11. [19]

    Mustafa Khan, Hamidreza Fazlali, Dhruv Sharma, Tongtong Cao, Dongfeng Bai, Yuan Ren, and Bingbing Liu. 2024. Autosplat: Constrained gaussian splatting for autonomous driving scene reconstruction.arXiv preprint arXiv:2407.02598 (2024)

    2024 arXiv

  12. [20]

    Yoongu Kim, Weikun Yang, and Onur Mutlu. 2015. Ramulator: A fast and extensible DRAM simulator.IEEE Computer architecture letters15, 1 (2015), 45–49

    2015

  13. [21]

    Siddharth Krishna Kumar. 2017. On weight initialization in deep neural networks. arXiv preprint arXiv:1704.08863(2017)

    2017 arXiv

  14. [22]

    Junseo Lee, Seokwon Lee, Jungi Lee, Junyong Park, and Jaewoong Sim. 2024. Gscore: Efficient radiance field rendering via architectural support for 3d gaussian splatting. InProceedings of the 29th ACM International Conference on Architectural Support for Programming Languages a...

    2024

  15. [23]

    Weikai Lin, Yu Feng, and Yuhao Zhu. 2025. MetaSapiens: Real-Time Neural Rendering with Efficiency-Aware Pruning and Accelerated Foveated Rendering. InProceedings of the 30th ACM International Conference on Architectural Sup- port for Programming Languages and Operating Systems...

    2025

  16. [24]

    Morgan McGuire and Louis Bavoil. 2013. Weighted blended order-independent transparency.Journal of Computer Graphics Techniques2, 4 (2013)

    2013

  17. [25]

    Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. 2021. Nerf: Representing scenes as neural radiance fields for view synthesis.Commun. ACM65, 1 (2021), 99–106

    2021

  18. [26]

    Guy M Morton. 1966. A computer oriented geodetic data base and a new tech- nique in file sequencing. (1966)

    1966

  19. [27]

    Cedrick Münstermann, Stefan Krumpen, Reinhard Klein, and Christoph Peters

  20. [28]

    Naveen Muralimanohar, Rajeev Balasubramonian, and Norman P Jouppi. 2009. CACTI 6.0: A tool to model large caches.HP laboratories27 (2009), 28

    2009

  21. [29]

    Michael Niemeyer, Fabian Manhardt, Marie-Julie Rakotosaona, Michael Oechsle, Daniel Duckworth, Rama Gosula, Keisuke Tateno, John Bates, Dominik Kaeser, and Federico Tombari. 2024. Radsplat: Radiance field-informed gaussian splatting for robust real-time rendering with 900+ fps...

    2024 arXiv

  22. [30]

    Thomas Porter and Tom Duff. 1984. Compositing digital images. InProceedings of the 11th annual conference on Computer graphics and interactive techniques. 253–259

    1984

  23. [31]

    David P Rodgers. 1985. Improvements in multiprocessor system design.ACM SIGARCH Computer Architecture News13, 3 (1985), 225–231

    1985

  24. [32]

    1995.Alpha and the history of digital compositing

    Alvy Ray Smith. 1995.Alpha and the history of digital compositing. Technical Report. Citeseer

    1995

  25. [33]

    Synopsys, Inc. [n. d.]. DesignWare Library. https://www.synopsys.com/ designware-ip/soc-infrastructure-ip/designware-library.html

  26. [34]

    Xuechang Tu, Bernhard Kerbl, and Fernando de la Torre. 2024. Fast and robust 3D Gaussian splatting for virtual reality. InSIGGRAPH Asia 2024 Posters. 1–3

    2024

  27. [35]

    Samuel Williams, Andrew Waterman, and David Patterson. 2009. Roofline: an insightful visual performance model for multicore architectures.Commun. ACM 52, 4 (2009), 65–76

    2009

  28. [36]

    Lizhou Wu, Haozhe Zhu, Siqi He, Jiapei Zheng, Chixiao Chen, and Xiaoyang Zeng. 2024. GauSPU: 3D Gaussian Splatting Processor for Real-Time SLAM Systems. In2024 57th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, 1562–1573

    2024

  29. [37]

    Jin Xu, Zishan Li, Bowen Du, Miaomiao Zhang, and Jing Liu. 2020. Reluplex made more practical: Leaky ReLU. In2020 IEEE Symposium on Computers and communications (ISCC). IEEE, 1–7

    2020

  30. [38]

    Vickie Ye, Ruilong Li, Justin Kerr, Matias Turkulainen, Brent Yi, Zhuoyang Pan, Otto Seiskari, Jianbo Ye, Jeffrey Hu, Matthew Tancik, et al . 2025. gsplat: An open-source library for Gaussian splatting.Journal of Machine Learning Research 26, 34 (2025), 1–17

    2025

  31. [39]

    Zhifan Ye, Yonggan Fu, Jingqun Zhang, Leshu Li, Yongan Zhang, Sixu Li, Cheng Wan, Chenxi Wan, Chaojian Li, Sreemanth Prathipati, and Yingyan (Celine) Lin

  32. [40]

    Zhifan Ye, Chenxi Wan, Chaojian Li, Jihoon Hong, Sixu Li, Leshu Li, Yongan Zhang, and Yingyan Celine Lin. 2024. 3D Gaussian Rendering Can Be Sparser: Ef- ficient Rendering via Learned Fragment Pruning.Advances in Neural Information Processing Systems37 (2024), 5850–5869

    2024

  33. [41]

    Hongjia Zhai, Xiyu Zhang, Boming Zhao, Hai Li, Yijia He, Zhaopeng Cui, Hujun Bao, and Guofeng Zhang. 2025. Splatloc: 3D Gaussian splatting-based visual lo- calization for augmented reality.IEEE Transactions on Visualization and Computer Graphics(2025)

    2025

  34. [42]

    Siting Zhu, Guangming Wang, Xin Kong, Dezhi Kong, and Hesheng Wang. 2024. 3D Gaussian splatting in robotics: A survey.arXiv preprint arXiv:2410.12262 (2024). 12

    2024 arXiv

  35. [43]

    InProceedings of the 2025 IEEE International Sympo- sium on High Performance Computer Architecture (HPCA)

    Gaussian Blending Unit: An Edge GPU Plug-in for Real-Time Gaussian- Based Rendering in AR/VR. InProceedings of the 2025 IEEE International Sympo- sium on High Performance Computer Architecture (HPCA). IEEE

    2025

  36. [2018]

    Moment-based order-independent transparency.Proceedings of the ACM on Computer Graphics and Interactive Techniques1, 1 (2018), 1–20

    2018

  37. [2023]

    Graph.42, 4 (2023), 139–1

    3D Gaussian splatting for real-time radiance field rendering.ACM Trans. Graph.42, 4 (2023), 139–1

    2023

  38. [2025]

    InProceedings of the 2025 IEEE International Symposium on High Performance Computer Architecture (HPCA)

    GSArch: Breaking Memory Barriers in 3D Gaussian Splatting Training via Architectural Support. InProceedings of the 2025 IEEE International Symposium on High Performance Computer Architecture (HPCA). IEEE

    2025

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.