Sort-free Gaussian Splatting via Weighted Sum Rendering
Authors: Qiqi Hou
Randall Rauwendaal
Zifeng Li
Hoang Le
Farzad Farhadzadeh
Fatih Porikli
Alexei Bourd
Amir Said
Venue: ICLR 2025 Poster (2025)
Keywords: Sort-free
Gaussian Splatting
Weighted Sum Rendering
Primary area: applications to computer vision, audio, language, and other modalities

Abstract: Recently, 3D Gaussian Splatting (3DGS) has emerged as a significant advancement in 3D scene reconstruction, attracting considerable attention due to its ability to recover high-fidelity details while maintaining low complexity. Despite the promising results achieved by 3DGS, its rendering performance is constrained by its dependence on costly non-commutative alpha-blending operations. These operations mandate complex view dependent sorting operations that introduce computational overhead, especially on the resource-constrained platforms such as mobile phones. In this paper, we propose Weighted Sum Rendering, which approximates alpha blending with weighted sums, thereby removing the need for sorting. This simplifies implementation, delivers superior performance, and eliminates the ``popping'' artifacts caused by sorting. Experimental results show that optimizing a generalized Gaussian splatting formulation to the new differentiable rendering yields competitive image quality. The method was implemented and tested in a mobile device GPU, achieving on average $1.23\times$ faster rendering.

Published as a conference paper at ICLR 2025
SORT-FREE GAUSSIAN SPLATTING VIA WEIGHTED SUM RENDERING
Qiqi Hou', Randall Rauwendaal", Zifeng Li², Hoang Le', Farzad Farhadzadeh', Fatih Porikli', Alexei Bourd Amir Said*1
Qualcomm AT Research (ghou, srauwend, zifeli, hoanle, ffazhadz, abourd, fporikli, asaid] Beti qualcerm. com com
*Graphies Research Team
150.0
3DGS Compute
30.0
3DES
125.0
Runtime (mS)
Ours
Memory (MB)
100.0
PSNR (6B)
28.0
200
26.0
100
25.0
0.0
282412 201/14
ha
22.0
rre-processing
Uighnng
Serting Rasterisation
Total
SUGR-Comput
3005 3005-Graphoo Graphics
Mip NJR7360
Temples
Deep Slanding
(a) Run on Mobile Phones
(b) Runtime Comparison
(c) Memory Comparison (d) PSNR comparison
Figure 1: This paper proposes sort-free Gaussian Splatting method, which simplifies volumetric
(a) Visual example from the "counter" scene rendered on Snapdragon" 8 Gen 3 GPU (b) and (c) Runtime and memory comparison between our methods and 3DGS Kerbl et al. (2023) at a resolution of 1920 1080 on the "counter" scene respectively. We implemented two versions of 3DGS, one implementation faithfully porting 3DGS CUDA kernels to Vulkan compute shaders (3DGS- SoGisCComutte, and another leveraging a global-sort following by hardware rasterization 3DDGS-Graphice (d) PSNR results Mip-NeRF, Tank & Temples, and Deep Blending datasets.
rendering to Weighted Sum Rendering.
ABSTRACT
Recently, 3D Gaussian Splatting (3DGS) has emerged as a significant advance- ment in 3D scene reconstruction, attracting considerable attention due its abil- ity to recover high-fidelity details while maintaining low complexity. Despite the promising results achieved by 3DGS, its rendering performance is constrained by its dependence on costly non-commutative alpha-blending operations. These op- erations mandate complex view dependent sorting operations that introduce com- putational overhead, especially on the aooource-constrinne platforms such as mo- bile phones. In this paper, we propose Weighted Sum Rendering, which approxi- mates alpha blending with weighted sums, therehy removing the need for sorting. This simplifies implementation, delivers superior performance, and eliminates the "popping" artifacts caused by sorting. Experimental results show that optimizing a generalized Gaussian splatting formulation to the new differentiable rendering yields competitive image quality. The method was implemented and tested in mobile device GPU, achieving on average 1.23x faster rendering.
INTRODUCTION
Photo-realistic 3D view synthesis has very wide use in graphics applications like video games, vir- tual reality, and 3D scene modeling techniques based learnable appearance and transparency have achieved remarkable success thanks to their capability for consistently generating image de- tails. Neural Radiance Fields (NeRF) by Mildenhall et al. (2021) is seminal work using this
"Correponding author
QQulcoom Research an initiative Qualcomm Technologies, Inc. 'Snapdragon and Qualcomm branded products products of Qualcomm Technologies, Inc. and/or its subsidiaries.

---

Published as a conference paper at ICLR 2025
approach, where Multi-Layer Perceptron (MLP) networks and positional encoding used to cre- ate models representing a scene's 's radiance field and opacity.
proposed by Kerbl et al. (2023), and rapidly gained popularity (Fei et al. 2024 Chen & Wang 2024b Wu et al. 2024). It replaces the MLP networks used by NeRF with sparse scattering of anisotropic 3D Gaussian "splats" that have view- dependent appearance. These splats are efficiently rendered using rasterization instead of costly vol- umetric ray-marching, while maintaining its rendering differentiability. Nevertheless, while 3DGS produces high quality views with significantly lower complexity compared to NeRF, it is still chal- lenging for resource-constrained platforms like mobile phones.
More recently, 3D Gaussian Splatting (3DGS)
An important complexity factor results from the fact that splatting volumetric elements with trans- parency requires sorting before a-blending, and it is difficult to combine non-commutative blending operations are intrinsically sequential- wiith the parallelization required for fast rendering. Furthermore, approximating ray integrals with sorting can create visible "popping" transitions due to temporal changes in rendering order, that can only be alleviated with more complex sorting and rendering (Radl et al. 2024).
The original 3DGS proposal achieves impressive rendering performance with a compute- based ras- terizer implemented in CUDA, enabled by a tiled-based GPU radix sort that ensures front-to-back a- blending, but incurring memory overhead. Subsequent implementations have leveraged other APIs such as Vulkan or WebGL Kishimisu (204))) Kwok (2024). , either choosing a similar compute-based implementation, leveraging the graphics hardware (GPU) to varying degrees. Unfortunately, there is no mechanism to feed the hardware rasterizer in a tile-wise fashion, so such implementations must either perform costly global-sort prior submitting work to the hardware rasterizer, or maintain a compute-based rasterizer, sacrificing the benefits of hardware execution. In the case of WebGL, implementations often rely on an asynchronous CPU-sort that runs at a lower-frequency than the frame rate, which degrades view quality and exacerbates temporal "popping" artifacts.
Although the sorting stage in Gaussian Splatting appears inevitable, it results from using approxi- mations to physical processes. In reality, a general scheme for learning scene representations, with components and parameters optimized for the best view reproductions, bound only by the mathe- matical constraints of the scene model. This observation motivates us to pursue alternative methods that reduce rendering complexity while incurring minimal degradation in view quality.
We are further encouraged by a widely adopted empirical method for rendering transparent me- dia utilizing the traditional rendering pipeline - Order Independent Transparency (OIT) Meshkin (007); McGuire & Bavoil (2013), representing class of techniques in rasterization- puter graphics for rendering transparency without sorting. By eliminating the sorting step from the rasterization pipeline, OIT maintains rendering speed and has been incorporated into commercial tools such as Blender, Vulkan, Unity, and Unreal Engine.
com-
In this paper exploit those approaches to develop novel view synthesis method combining learning with commutative blending operations. It extends the definition of learned Gaussian Splat- ting, and integrates it with new method for volumetric rendering, called Weighted-Sum Rendering (GS-WSR), still relying on differentiable rendering and machine learning techniques. To render an image, our approach employs the depth of each Gaussian to compute weights for each Gaussian splat using learned functions. These weighted Gaussians are then splatted onto the image plane us- ing a straightforward summation operation, thereby obviating the necessity for sorting. As a further enhancement, we found that introducing view-dependent opacity greatly improved image quality for sort-free Gaussian Splatting.
This paper contributes to Gaussian Splatting as follows. First, we present the first sort-free Gaussian Splatting technique which is compatible with the graphics pipeline, and allows us the benefit of hardware rasterization. Second, we introduce Weighted Sum Rendering as well as view-dependent opacity that can effectively learn the model parameters and produce high-quality rendered images. Third, our experiments show that our method accelerates Gaussian Splatting with comparable visual performance on mobile phones.
2

---

Published as a conference paper at ICLR 2025
2 RELATED WORK
Neural Scene Representations. Recent advancements in neural scene representations for novel view synthesis have led to significant progress, with techniques assigning neural features to struc- tures like volumes Lombardi et al. (2019); Sitzmann et al. (2019), textures Chen et al. (2020); Thies) et al. (211)), or point clouds Aliev al. (2020). The pioneering NeRF (Neural Radiance Fields) ap- proach proach Mildenhall et al. (0021). revolutionized the field by using Multi-Layer Perceptrons (MLPs) to encode 3D density and radiance without proxy geometry, achieving photorealistic renderings from sparse 2D images. Subsequent research has aimed to enhance NeRF's quality and efficiency through optimized sampling strategies Neff et al. (202T), light field-based formulations Li et al. (2022). com- pact representations Müller et al. (2022). tensor decomposition Chen et al. (2022), or leveraging the polygon rasterization pipeline for efficient rendering on mobile devices such as MobileNeRF Chen et al. (203)). However, the high computational and memory requirement still puts a challenge on mapping these methods on resource constrained platforms.
Order Dependent Transparency 3DGS The novel 3D Gaussian Splatting (3DGS) and its numer- ous follow-up works primarily utilize anisotropic 3D Gaussians for scene representation and an efficient differentiable rasterizer to project these Gaussians onto the image plane, either in pixel or feature representation [Hamdi al. (2024); [in et al. (2024):
| Yu et al. (2024); Liang et al. (2024); Yan et al. (2024); Lu et al. (2024); Bulò et al. (2024); Fan et al. (2024): ; Fu ct al. (2024 Zhang al. (2024): Zou et al. ): Jiang et al. (2023); Qin et al. (2 Li et al. (2024); 4 Jo et al. (2024); Lee (2024) : Fan et al. (2023); Niedermayr et al. (202)) : Chen et al. (2024); Morgenstern al.
(203) Navaneet et al. (202)). These methods enable fast, high-resolution rendering while main- taining excellent quality. For a comprehensive overview, please refer recent survey papers such as Chen & Wang (2024a). A crucial requirement in these methods for proper blending and rendering the order of the Gaussians, which are typically sorted by their depth using a tile-based sorting algorithm. However, this sorting requirement introduces several challenges in practical implemen- tation and visual quality, such sudden changes in the appearance of object parts "popping" artifacts, as recently addressed in |Rdd et al. (2024). While their results show a limited increase in computational complexity, the necessary sorting modifications are significantly more involved.
Order Independent Transparency. Modeling partial coverage has long history in computer graphics. It's an essential problem as we need to render fine non-opaque structure or elements such as flames, smoke, clouds, hair, etc. In Porter and Duff's seminal work Porter & Duff (1984), they formulate transparency as the OVER operator as
C = CoCo + (1 - ao)ci,
(1)
where a, c indicate alpha and color, respectively. As the OVER operator is not commutative, it re- quires back-to-front order for composition. Traditional accelerated either by successively "peeling" depth layers [Everit| (200T) or accumulating list for sorting like A-buffers Carpenter (1984). These
methods introduce time and memory overhead.
To avoid sorting, there are many methods that have been proposed to approximate compositing, namely Order--ndependent Transparency (OIT). For instance, k-bufffr methods work like depth peeling methods, but only storing and accumulating first k-layers in a single pass Bavoil et al.) (007)) Alternatively, stochastic transparency methods in Monte Carlo rendering samples the frag- ments according to the opacity and depth, which can generate promising results for a large sampling rate Enderton et al. (201O). A survey on these methods can be found in Wyman (2016).
The weighted blended OIT proposed by McGuire & Bavoil (013)) is the most relevant to our method. There are several OIT variants listed in McGuire Bavoil (2013), the most general of which is to replace the OVER operator with the following commutative blending operator
NV C= II (1-))) co +
NV
> c (di, as)
II (1-a)) ax)
(2)
Em are (di, as)
where de the distance to camera, Co is the background color, w (-) is a function that decreases with distance, so that objects nearer to the camera are assigned larger weights. In the OIT rendering Eq. 2 there are two sums defining pixel values, and since addition is commutative, they can be computed in any order. Inspired by OIT, our method extends to Gaussian Splatting by introducing the learnable parameters and view-dependent opacity. Besides, compared to the OIT exponential weights, linear weights produce better PSNR results for Gaussian Splatting.
3

---

Published as a conference paper at ICLR 2025
22.
dg.
Bept
+11
Gau2
Gau3
(1
Disc Hrail
Image
Gaussiens
Tiling 3DGS with sort
Replication
Sorting
Rendering
Splatting
Gaussions
Sort-free Gaussian Splatting via Weighted Sum Rendering
Rgy Ca. dg
Pixel
dg
CRST
Thoight
Gaussian for blue tile with depth
0= di agw(dh)a Des
Alpha
Color d Depth
+a,w(ds))
Weight Calluuation
Weighted Sum Rendering
The architecture of sort-free Gaussian Splatting via Weighted Sum Rendering. 3DGS needs to tiling, replication, sorting, and rendering. Our method only needs to calculate the weight for each Gaussian, and independently sum their contributions per-pixel.
Figure 2:
PRELIMINARIES GAUSSIAN SPLATTING
The 3DGS scene model ((ps; q: 8t, H.) represents a scene N Gaussians with center locations p R3, maximum opacity 4 [0, orientation q E R1, scale s E IR$, and spherical harmonies coefficients H following an equation similar to Gaussian probability distributions. The opacity of cach element at position in 3D space is defined according to
(- (x p:)² E (q, 8:)] (x -xp)
0i (x) 1, exp
i= 1,1,, ,N
2
and considering camera with focal point at position f, the view-dependent color is defined by Y (I]f p:ll H:), i= 1,2, .N.
where Y()) indicates the spherical harmonic function and ||-|| indicates the vector norm.
To render an image, each 3D Gaussian is mapped to 2D as approximated by a 2D Gaussian with the following 2 covariance matrix
En JWE W
(5)
where W a matrix defined by the camera's 's image- generation transformation, and J is the Jacobian matrix defined by affine approximation of the projective camera transformation.
After sorting Gaussians in depth order, the final pixel color obtained by Gaussian splatting can be computed according to
N
C,O, C
(1-);,) a,),
i=1
/=1
which corresponds the well-known computer graphics technique of alpha-blending (Marschner & Shirley 2015).
SORT-FREE GAUSSIAN SPLATTING VIA WEIGHTED SUM RENDERING
4.1 FORT-FREE GAUSSIAN SPLATTING
As discussed in Sec. 3DGS relies non-commutative alpha blending, which requires depth order sorting operation before rendering. To recover high-fidelity the rendered images, 3DGS models typically include substantial number of Gaussians, which escalate to millions in com- plex scenes. The overhead associated with these sorting operations poses a challenge in splatting Gaussians onto image without effective optimization.

---

Published as a conference paper at ICLR 2025
To accelerate rendering, 3DGS incorporates several optimizations designed to leverage parallel com- putation capabilities in CUDA. As shown in Figure 2 non-overlapping tiles, with Gaussians that span across multiple tiles being duplicated accordingly. Each Gaussian is assigned a tile ID) and sorted by depth on a per-tile basis. Once sorted, all tiles are rendered in parallel, significantly improving computational efficiency. Additionally, 3DGS employs early termination to further optimize performance: if the alpha value of the frontmost Gaussians sufficiently high, the rendering process will skip subsequent Gaussians, reducing unnecessary computations and memory usage.
3DGS splits the rendered image into multiple
While 3DGS achieved promising results, its CUDA based implementation restricts its portability, and its sorting requirement limits its performance. Their usage of an efficient tile-based radix sort forces them maintain fully compute-base based render pipeline, including compute-based rasteriza- tion. On the other hand, current APIs fail to expose efficient mechanisms to submit geometry to the hardware rasterizer in tiled fashion, thereby requiring that implementations leveraging the hard- ware rasterizer execute more costly global sort over all visible Gaussians. 3DGS chose to pursue the fully compute-based approach with its CUDA implementation, which denies them some of the benefits of the GPU's fixed function hardware. Their file-based sort incurs some overhead in its duplication of Gaussians at tile boundaries, which is exacerbated in instances where there are a large number of Gaussians, and finally, as noted by prior work Radi al. (2024), sorting Gaussians by their centers can introduce "popping" artifacts during view transformation, further affecting visual quality.
These limitations motivate the elimination of the sorting phase in Gaussian Splatting, which not only significantly simplifies the implementation but also enhances compatibility with hardware graph- ies pipelines. Inspired by Order Independent Transparency (OIT), we propose novel approach that modifies the volumetric rendering process in 3DGS to more efficient representation termed Weighted Sum Rendering (WSR).
4.2 WEIGHTED SUM RENDERING
Figure compares the architectures of the original sort- based 3DGS model, with our proposed sort-free Gaussian Splatting framework. Unlike the volumetric rendering approach employed by 3DGS, our method estimates the transparency of each Gaussian solely based on its depth and learnable parameters, thereby eliminating the need for depth ordering. The final image can be rendered using
6
a₂ = 1 d2
a1 = 1,
CBWB + Eie c,0,w((d))
GT
DIR-WSR EXP-WSR LC-WSR
C
(7)
WB + EN (;w(d,)
Figure 3: Three variants of Weighted Sum Rendering with different weight calculations, namely Direct Weighted Sum Rendering (DIR-WSR), Exponen- tial Weighted Sum Rendering (EXP- WSR), and Linear Correction Weighted Sum Rendering (LC-WSR).
where cp and Wy indicate the color and learnable weight of the background, respectively. d indicates the depth. wo() indicates the learnable weight function. Our net- work learns the Gaussian's 's parameters during training. Rendering with Eq. 7 in WSR corresponds to comput- ing weighted sums. As the addition commutative, these sums can be computed in any order, overcoming the constraints of depth sorting. Unlike traditional OIT methods Meshkin (2007): McGuire & Bavoil (2013), which rely on predefined parameters, our method optimizes the parameters of this new representation during training.
3DGS produces novel views based on a physics-based blend model, whereas GS- WSR demonstrates the benefits of departing from a phsyically-based model, and using machine learning to train the parameters for a non-physically based model. volumetric rendering Eq. 6 it is necessary to have a4 E J0, 1] to guarantee that all terms are positive. However, these constraints are not necessary in WSR Eq. 7 as ag serves as a learnable parameter in a radiance field model. Removing such constraints can potentially result in better approximations. Similarly, our view-dependent opacity may not correspond to optical laws, but it is in practice useful for minimizing the limitations of the WSR Eq. 7 compared to volume rendering Eq. 6
Direct Weighted Sum Rendering (DIR-WSR). A straightforward method of rendering is to sum all contributions directly, allowing the network to learn specific opacities. In DIR- the weight
5

---

Published as a conference paper at ICLR 2025
is defined as constant as follows
w(d)) 1, i= 1, ,N.
(8)
However, DIR-WSR does not work well for complex scenes, and often introduces blurring artifacts in areas where Gaussians overlap. We attribute the poor visual performance due to the lack of depth information, which prevents accurate estimation of transparency.
visual example provided in
Figure 3 illustrating two non non-transyee -on-transprrentt Gaussians with 1 with different color Since DIR- WSR uses a constant weight of 1, is unable to correctly handle this situation, leading to an incorrect estimation of the resulting color as purple
Exponential Weighted Sum Rendering (EXP-WSR). To better capture the effects of occlusion, introduce EXP-WSR assign larger weights to Gaussians closer to the camera. The weight is defined as
w exp (-od,) i= 1,2, .N,
where 0, 3 are learnable parameters. In this manner, the Gaussians closer to the viewer would have a higher weight, thus contributing more the final rendered image. Although EXP-WSR can effectively reduce artifacts and generate better results compared to DIR-WSR, it is not entirely free from visual distortions, as distant Gaussians still contribute to the rendered image some extent. As shown in Figure 3 the red Gaussian, being closer to the viewer, has larger weight than the blue Gaussian, yielding results that are closer to the ground truth. However, some artifacts remain visible in the final output.
Linear Correction Weighted Sum Rendering (LC-WSR). Inspired by the deformable convolution Dai et al. (2017) and KPConv Thomas et al. (019), we use linear correction to estimate the weight from depth by
w (d.) max 0, de Us i= 1,2, .N,,
(10)
where i are learnable parameters. This formulation will assign relatively larger weight for the Gaussians closer to the camera. For distant Gaussians, the weight may be reduced to O, depending on u.. As shown in Figure the rendered result is closest to the ground truth, since this model can set weights to zero it can more accurately model occlusions. Additionally, compared to EXP-WSR, LC-WSR is cheaper to compute.
4.3 VIEW-DEPENDENT OPACITY
In Sec we proposed WSR to assign differ- ent weights to Gaussians according to their depth. Moreover, the order of Gaussians would also change depending on the viewer's direction in the original 3DGS. Figure 4 illustrates this phenomenon: two viewers observe two Gaussians from different di- rections. The left viewer assigns larger weight to the red Gaussian, while the right viewer assigns smaller weight the same Gaussian. This ob- servation motivates our approach to assigning view- dependent opacities.
8 0.9
02 1
8
& 0 0.9
& (1 a3
& (1 a.)a; 0.1
Figure 4: View dependent opacity. In 3DGS, the accumulated & changes depending the viewer's s direction, which motivates us to assign view-dependent opacities in sort-free Gaussian Splatting.
We substitute our opacity values for an additional set of spherical harmonic coefficients for view- dependency. It's another mechanism by which we mitigate the contribution of occluded Gaussians. We modify Eq 3 which defines the sort-free Gaussian's 's opacity, replacing the 3DGS element's maximum opacity t; E [0, 1] with an unconstrained value u; as
= Y (lff [|ll- H.), i= 1,2, .N
(11)
where Y(.) indicates the spherical harmonic function and ||. indicates the vector norm. H; indicates
the learnable spherical harmonies coefficients for opacity. Thus, the maximum opacity u, depends on view direction | - p:ll according to learned spherical harmonics parameter vector H, There is
Please note that in WSR, can be larger than 1. We assume 1 as non-transparency for illustrative purposes.

---

Published as a conference paper at ICLR 2025
Johnson (LC-WSR)
GTPSSNR))
3DGS(30.66)
DIR-WSR(32 72)
EXP-WSR(33.07)
LC-WSR(33.49)
Room (LC-WSR)
GTPSSN--)
3DGS(30.20)
DIR-WSR(28.0)
EXP-WSR(30.87)
LC-WSR(32.72)
Counter (LC-WSR)
GTOPNN-)
3DGS(30.19)
DIR-WSR(28 86) EXP-WSR(30.1) LC-WSR(31.1)
Figure 5: Visual comparison on the Mip-NeRF 360 dataset. Our OIT method achieves similar visual performance compared to 3DGS. Please note that our method doesn 't require the order of Gaussians.
slight difference the SH evaluation for the RGB channels and the opacity in implementation. The maximum opacity u, is not clamped. Please note that the view-dependent opacity may not correspond optical laws, but it is in practice useful for minimizing the limitations of OIT rendering Eq. compared to volume rendering Eq. 6
4.4 IMPLEMENTATION DETAILS
Loss function. We optimize our sort-free Gaussian Splatting using the same rendering loss from 3DGS Kerbl al. 2023), which contains the & loss and D-SSIM loss with factor of 0.2.
Training and Evaluation. We trained our sort-free Gaussian Splatting method using PyTorch. We implemented the custom CUDA kernels for the PyTorch version. For EXP- WSR, we initialize the o = 0.1 and = 0.8. For LC-WSR, we initialize o = 10 and v, = 0.1. For convenience, we also evaluate the quality of our method with PyTorch inference simulation.
Testing on mobile devices. To measure model efficiency on mobile devices, we implemented our method and the competitive 3DGS method in Vulkan [] which is cross-platform graphics and compute API created and maintained by the Khronos Group
3DGS's s rendering mobile device contains four steps: pre- pre-processing lighting, sorting, and ras- terization. The pre-procssinng step projects the 3D Gaussian into 2D based on the camera view. The lighting stage calculates per-Gaussian color based the camera view and the spherical harmonics (SHs). The sorting step sorts the Gaussians front to back, and the rasterization step rasterizes all Gaussians within each tile to output the final image.
To make fair comparison, we implemented two versions of 3DGS, namely 3DGS-Compute and 3DGS- GraShrrap 3DGS-Compute attempts faithfully replicate the approach from 3DGS Kerbl et al. (2023) in Vulkan compute shaders. It follows a similar scheme of replicating Gaussians per- overlapped tile, followed by compute-bars based rasterization. The most notable difference that the optimized radix-sort from the NVIDIA CUB libraries NVIDIA (2024) had to be replaced with Vulkan equivalent. By contrast, the 3DGS- GoGG-igapsssss approach allows for more mobile friendly
hhtpss//www.vulkan..o http:///wwwwwwhoooss.oo

---

Published as a conference paper at ICLR 2025
Table 1: PSNR scores of our method on the Mip-NeRF360 dataset, the Tanks Temples dataset, and the Deep Blending dataset. Our method achieved comparable results with 3DGS.
Mip-NeRF 360
Tanks & Temples
Deep Blending
Method
PSNRT
SSIM
LPIPS
PSNRT
SSIMT
LPIPS
PSNR1
SSIM
LPIPS.
Plenoxels
23.08
0.626
0.463
21.08
0.719
0.379
23.06
0.795
0,510
INGP-Base
25.30
0.671
0.371
21.72
0.723
0.330
23.62
0.797
0.423
INGP-Big
25.59
0.699
0.331
21.92
0.745
0.305
24.96
0.817
0.390
M-NeRF360
27.69
0.792
0.237
22.22
0.759
0.257
29.40
0.901
0.245
3DGS
27.21
0.815
0.214
23.14
0.841
0.183
29.41
0.903
0.243
Compact 3DGS
27.08
0.798
0.247
23.71
0.845
0.178
29.79
0.901
0.258
LightGaussian
27.28
0.805
0.243
23.11
0.817
0.231
Compressed 3DGS
26.98
0.801
0.238
23.32
0.832
0.194
29.38
0.898
0.253
LC-WSR
27.19
0.804
0.211
23.61
0.842
0.177
29.63
0.902
0.229
execution. It's implementation globally sorts the Gaussians, eliminating per-tile replication, and allowing it to easily submit a glohal list of Gaussian to the hardware graphics pipeline. Gaussian color and opacity are evaluated in a fragment shader. These modifications allow Gaussians to be efficiently rendered by the fixed-function rasterizer, while their contributions are accumulated by hardware blending operations.
For both our method and the 3DGS methods, the pre-processing and lighting steps remain the same as the original 3DGS implementation, except that our method's opacity is now calculated in the lighting stage based the camera view and SHs. Our method removes the entire sorting step, and rasterizes Gaussians a fragment shader. Besides, our method contains an extra subpss to perform the final normalization step. With method, all Gaussians draw call instead of the per-tile fashion used by 3DGS. We verified the consistency between our on mobile implementation versus the Pytorch reference implementation. Please refer our supple- mentary for more details about our on mobile implementation.
rendered using a single instanced
5 EXPERIMENTAL RESULTS
Datasets. To ensure fair comparison, we followed the evaluation setting of 3DGS Kerbl et al. (003)) and conducted our experiments on 13 real-world scenes. Specifically, they include the com- plete set of scenes from the Mip-Nerf360 dataset Barron et al. (2022), two scenes from the Tanks & Temples dataset Knapitsch al. (2017). and two scenes from the Deep Blending dataset [Hedman et al. (018)). These scenes encompass various challenging scenarios, including both indoor and outdoor environments.
Evaluation metrics. We evaluate reconstruction fidelity using Peak Signal-to-Noise Ratio (PSNR), Structural Similarity (SSIM), and Learned Perceptual Image Patch Similarity (LPIPS) metries. For model efficiency, report run times on Qualcomm" Adreno GPU from Snapdragon 8 gen chipset. To enable comparison, we also re-implemented our method and the official 3DGS (Kerbl et al. 2023) in Vulkan for this setting.
5.1 COMPARISON WITH STATE-OF-THF-AA METHODS
We compare our method with state-oftth-eee ahe techniques. including Plenoxels Fridovich-Keil et al. (2022), INGP Müller et al. (202)). M-NeRF360 [Barron al. (2022). 3DGS Kerbl et al. (2023), Compact 3DGS Morgenstem et al. 2023). Compressed 3DGS Niedermayr et al (2024)) and Light- Gaussian Fan et al. (2023). The results in Table [ demonstrate that our method, while avoiding any sorting, achieves comparable results to the baseline 3DGS. In terms of PSNR,
method outperforms 3DGS by 0.47dB and 0.22dB on the Tanks & Temples and Deep Blending datasets, respectively, while averaging only 0.02dB less the Mip-NeRF360 dataset. For visual compari- son, 5 shows that our LC-WSR excellently recovers challenging details of the fireplace in the "Dr Johnson scenes. In other scenes, WSR particularly recovers better fidelity in areas with strong illumination and reflection.
5.2 COMPUTATIONAL COMPLEXITY STUDY
In this study, we examine the running time and memory consumption of our methods on the mobile devices, using Snapdragon 8 Gen 3 GPU, and with implementation based on Vulkan. To
8

---

Published as a conference paper at ICLR 2025
Table 2: Runtime (ms) comparion using Snapdragon 8 Gen 3 GPU on the Mip-NeRF360, Tanks & Temples and Deep Blending datasets. The images are rendered at resolution of 1920 x 1080. ("#" indicates that mobile resources are exhausted).
Mip-NeRF360
Tanks& Tempe&Templcs
Deep Bleading
Method
Task
bicycle
Bowers
gurden
stump
treehill
room counter kitchen bonsai
truck
train
drjohnson playroom
Pre-processing
12.84
7.05
10.15
6.94
7.53
3.99
3.02
4.46
3.12
6.29
3.03
7:50
6.04
Lighting
4.57
3,26
5.19
3.43
3.37
1.84
1.55
3.07
1.40
3.53
2.41
2.61
2.40
3DGS CGSppop
Sorting
246.65
122.68
210.35
180.23
139.98
70.83
50.57
89.96
50.63
105.83
60.83
140.64
110.97
Rasterization
1239.12*
115.18
899.19
265.27
147.08
140.16
85.94
177.01
73.43
165.64
130.23
212.10
167.09
Total
1511.96
253.60
842.15
463.06
303.68
219.31
143.03
277.35
130.58
285.11
198.01
367,93
290.32
Pre- Pre-prazessing
13:27
7.82
13.73
10:46
8.01
3.40
2.62
4.09
2.62
5.84
2.35
7.22
5.57
Lighting
5.32
3.66
5.67
3.68
3,80
2,00
1,61
3.55
1,51
4.03
2.68
2.94
2.71
3DGS Graphics
Sorting
40.26
24.79
38.25
31.09
25.47
11.23
13.76
9.17
7.43
23:13
18.43
Rasterization
618.83"
246.47"
697.81
344.72"
206
28
32.50
28.22
52.84
30.86
164.25
82.45
Total
678.08
283.11
755.89
390.33
245.95
49.46
42.15
74.56
44.47
107.64
52.48
197,86
109.46
Pre-processing
6.83
3.92
5.53
6.46
4,63
1.94
1.67
2.74
1.64
3.42
1.61
4.61
2.48
Lighting
4.36
3.67
1.41
1,16
3.21
1.70
Ours
Rasterization
57.84
57.25
52.99
68.51
37.52
52.89
78.11
Total
78.99
35.28
67.90
67.63
61.11
49.02
34.06
74.47
40.63
59.75
53.13
85.85
54.28
make a fair comparison, we also re-implement the 3DGS in Vulkan. Please refer Section 4.4 for implementation details. We conduct our experiments on the Mip-Nerf360, Tanks & Temples, and Deep Blending datasets, where each image is rendered at resolution of 1920 1080.
Table reports the runtime comparison of 3DGS- DDGS-CCopute, 3DGS GrrS-Grap and our LC-WSR on the Mip-NeRF360, Tempss and Deep Blending datasets. Compared to 3DGS- JDGS-Compute, 3DGS SoGS-Graphics is more efficient as it eliminates the replication steps and thus reducing the number of Gaussians for sorting. Besides 3DGS- Graphics can also better utilize the graphic fixed-functions in the hardware-supported graphic rasterization pipeline. Our method is in most cases faster than the method due the elimination of the sorting step and fewer Gaussians. Note that for certain scenes using the 3DGS 3DGS-Graphics method, we can exhaust our edge device's resources due to the sorting step and high Gaussian count, which will drastically slow down the rasterization step (labeled with "*"). Unfortunately, it can be difficult to pinpoint the sources of inefficiency in complex GPUs To the best of our knowledge, this caused by sudden changes to many more cache misses. In contrast, our method is fully capable of running all scenes in real time. In theory, our method's lighting pass should be slightly slower because opacity is calculated using SH, and our rasterization step should be slower due to the weight calculations in the fragment shader and the extra subpass for weight normalization. However, we observed that WSR tends to generate models with fewer Gaussians (scene average 2. 2.88M) compared to the original 3DGS (scene average 3. 3.98M), which is consistent with prior work Radl et al. (2024) that suggests modifying opacity leads to a reduction in the number of Gaussians. This also contributes to faster lighting and rasterization steps for us compared with EDGS-Graphin number of Gaussians, our total time is close to or slightly worse compared to the original model because the overhead added in the rasterization step is not fully compensated by the removal of the sorting step, which may indicate further optimizations are needed for our method's 's rasterization implementation. Overall, the proposed method is on average 1.23x faster in total time when the mobile resources are not exhausted.
For certain scenes (kitchen and train) that have a similar
Table 3 compares the runtime memory of our method with 3DGS- Gra-hrrap and 3DGS-Compuct
Compared to SDGGSComppin thereby eliminating the replication step. Our method only requires around 63% memory of 3DGS- Graphics. This memory reduction can be attributed to removing the sorting operations as well as fewer total Gaussians. Specifically, removing sorting reduces around 17% memory, while the reduc- ing the number of Gaussians contribute the remaining. For the view dependent opacity, the spherical harmonics data in GPU graphic pipeline is represented as RGBARGBA instead of RBGRGB-... We exploit this fact by using the alpha memory position to create view-dependent opacity, which does not increase the amount of memory and vector operations, i.e., computational complexity. For
3DGGS-Graphies utilizes less memory as it performs global sorting

---

Published as a conference paper at ICLR 2025
Table 3: Runtime memory (MB) comparison on the Mip-NeRF360, Tanks Temples and Deep
Blending datasets. The images are rendered at resolution of 1920 1080.
Mip-NcRF360
Tanks Temples
Deep Blending
Mothod
bicycle flowers garden stump trechill room counter kitchen bonsai truck
train
drjohnson playroom
3DGS-Compute
2017
1205
1920
1636
1253
542
421
626
429
850
358
1131
851
3DGS-Graphir
1520
911
1448
1235
947
413
322
476
328
644
274
855
645
Ours
881
526
681
853
276
241
367
217
615
344
Table 4: WSR variants on the Mip-NeRF360, Tanks & Temples and Deep Blending datasets.
Mip-NeRF 360
T Tanks&Temples
Deep Blending
Method
PSNRT
SSIMT
LPIPS!
PSNRT
SSIM
LPIPS
PSNR1
SSIM
LPIPS.J
DIR-W WSR
25.99
0.778
0.262
22.80
0.821
0.218
28.85
0.899
0.254
EXP-WSR
26.97
0.801
0.216
23.32
0.833
0.183
29.77
0.902
0.229
L.CWSR 27.19
0.804
0.211
23.61
0.842
0.177
29.63
0.902
0.229
general storing of the splatting elements, it indeed increases the footprint per Gaussians because the number of spherical harmonics coefficient values increases from 3 to 4.
5.3 ABLATION STUDY
Comparison of WSR variants. We compare the variants of WSR in Table f on Mip-NeRF360, Tanks & Temples, and Deep Blending datasets. LC-WSR achieved the best performance on Mip- NeRF360 and Tanks & Temples datasets, while EXP-WSR provides the best performance on Deep Blending dataset. See Figure for visual examples that demonstrate LC-WSR performs best at recovering fine details.
View dependent opacity. We examine how method works with view dependent opacity. Ex- perimentally comparing our method with the view independent opacity method used in 3DGS, we demonstrate view dependent opacity significantly improve the results, shown in Table
Popping artifacts. As a side effect of not relying on sorting, methods also eliminates "popping" tifacts. Figure [ shows an experiment in which we slightly rotate the camera, causing the black Gaus- sian to suddenly "pop" out in 3DGS, generating no- ticeable temporal artifacts, whereas our method pro- duces temporally consistent results.
Garden
3DG3
Ours
Figure 6: Our method eliminates the "pop- Learnable parameters. Traditional OIT methods ping" artifacts during view transformation. rely on predefined parameters, while our method optimizes the parameters during training. We compare fixed parameters vs. our learnable parameters in Table 5 which shows that our learnable parameters significantly improve the performance.
Table 5: Ablation study on the Mip-NeRF360. Tanks & Temples and Deep Blending datasets.
Mip-NeRF 360
Tanks & Temples
Deep Blending
Method
PSNR1
SSIM
LPIPS
PSNR
SSIM
LPIPS
PSNRT
SSIM
LPIPS
Ours
27.19
0.804
0.211
23.61
0.842
0.177
29.63
0.902
0.229
w.o. learnable parameters
23.19
0.711
0.318
21.55
0.788
0.245
27.92
0.893
0.260
view-dependent opacity
25.88
0.784
0.251
21.83
0.798
0.237
29.27
0.902
0.249
CONCLUSIONS
This paper introduces novel sort-free Gaussian Splatting method, enabled by its use of learned non- commutative blend weight functions, a technique we term Weighted Sum Rendering. We presented three variants of Weighted Sum Rendering: DIR-WSR, EXP-WSR, and LC-WSR. These variants effectively eliminate the need for the sort operation in 3DGS. Additionally, we developed view- dependent opacity technique that significantly enhances reconstruction fidelity in sort-free Gaussian Splatting. Our experimental results demonstrate that WSR not only achieves competitive visual performance compared to 3DGS but also operates 1.23 times faster mobile devices.
10

---

Published as a conference paper at ICLR 2025
REFERENCES
Kara-Ali Aliev, Artem Sevastopolsky, Maria Kolos, Dmitry Ulyanov, and Victor Lempitsky. Neural point-based graphics. In European Conference on Computer Vision, pp. 696-712. Springer, 2020.
Jonathan T Barron, Ben Mildenhall, Dor Verbin, Pratul P Srinivasan, and Peter Hedman. Mip-nerf 360: Unbounded anti-aliased neural radiance fields. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 5470-5479, 2022.
Louis Bavoil, Steven P Callahan, Aaron Lefohn, Joao LD Comba, and Cláudio T Silva. Multi- fragment effects on the gpu using the k-buffer. In Proceedings of the 2007 symposium on Inter- active 3D graphics and games, pp. 97-104, 2007.
Samuel Rota Bulò, Lorenzo Porzi, and Peter Kontschieder. Revising densification in gaussian splat- ting. arXiv preprint arXiv:2404.06109, 2024.
Loren Carpenter. The a-buffer, an antialiased hidden surface method. In Proceedings of the 11th
annual conference on Computer graphics and interactive techniques, pp. 103-108, 1984.
Anpei Chen, Zexiang Xu, Andreas Geiger, Jingyi Yu, and Hao Su. Tensorf: Tensorial radiance fields. In European Conference on Computer Vision (ECCV), 2022.
Guikun Chen and Wenguan Wang, A survey 3d gaussian splatting. arXiv preprint arXiv:2401.0380) 2024a.
Guikun Chen and Wenguan Wang. A Survey on 3D Gaussian Splatting, July 2024b. URL http: arXiv:2401.0380) [cs].
Yihang Chen, Qianyi Wu, Jianfei Cai, Mehrtash Harandi, and Weiyao Lin. Hac: Hash-grid assisted context for 3d gaussian splatting compression. arXiv preprint arXiv:2403.145500 2024.
Zhang Chen, Anpei Chen, Guli Zhang, Chengyuan Wang, Yu Ji, Kiriakos N Kutulakos, and Jingyi
Yu. A neural rendering framework for free-viewpoin relighting. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5599-5610, 2020.
Zhiqin Chen, Thomas Funkhouser, Peter Hedman, and Andrea Tagliasacchi. Mobilenerf: Exploiting the polygon rasterization pipeline for efficient neural field rendering mobile architectures. In The Conference on Computer Vision and Pattern Recognition (CVPR), 2023.
Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In Proceedings of the IEEE international conference on computer vision, pp. 764-773, 2017.
Eric Enderton, Erik Sintor, Peter Shirley, and David Luebke. Stochastic transparency. In Pro- ceedings of the 2010 ACM SIGGRAPHI symposium on Interactive 3D Graphics and Games, pp. 157-164, 2010.
Cass Everitt. Interactive order-independent transparency. White paper, AVIDIA, 2(6))7,
Zhiwen Fan, Kevin Wang, Kairun Wen, Zehao Zhu, Dejia Xu, and Zhangyang Wang. Lightgaussian: Unbounded 3d gaussian compression with 15x reduction and 200+ fps, 2023.
Zhiwen Fan, Wenyan Cong, Kairun Wen, Kevin Wang. Jian Zhang, Xinghao Ding, Danfei Xu, Boris Ivanovic, Marco Pavone, Georgios Pavlakos, et al. Instantsplat: Unbounded sparse-view pose-free gaussian splatting in 40 seconds. arXiv preprint arXiv:2403.20309 2024.
Ben Fei, Jingyi Xu, Rui Zhang, Qingyuan Zhou, Weidong Yang, and Ying He. 3D Gaussian as New Era: A Survey. IEEE Transactions on Visualization and Computer Graphics. pp. 1- 20, 2024. ISSN 1077-2626, 194 1941-0506, 21 2160-9306. doi: 109//TCC..20243333777 http://arxit org/ abs 2402. .2..002.0000 07181 arXiv:2402.0711 07111111111111 [cs].
URI.
Sara Fridovich-Kei.. Alex Yu, Matthew Tancik, Qinhong Chen, Benjamin Recht, and Angjoo Kanazawa. Plenoxels: Radiance fields without neural networks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 5501-5510, 2022.

---

Published as a conference paper at ICLR 2025
Yang Fu, Sifei Liu, Amey Kulkarni, Jan Kautz, Alexei A. Efros, and Xiaolong Wang. Colmap- free 3d gaussian splatting. In Proceedings of the IEEE/CVE Conference on Computer Vision and Pattern Recognition (CVPR), pp.
June 2024.
Abdullah Hamdi, Luke Melas-Kyriazi, Jinjie Mai, Guocheng Qian, Ruoshi Liu, Carl Vondrick, Bernard Ghanem, and Andrea Vedaldi. Ges: Generalized exponential splatting for efficient ra- diance field rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 19812-19822, 2024.
Peter Hedman, Julien Philip. True Price, an-Michael Frahm, George Drettakis, and Gabriel Bros- low. Deep blending for free-viewpoint image- rendering. 37 2018.
Wen Jiang, Boshu Lei, and Kostas Daniilidis. Fisherrf: Active view selection and uncertainty quan- tification for radiance fields using fisher information. arXiv preprint 1rXiv:2311.17874 2023.
Joongho Jo, Hyeongwon Kim, and Jongsun Park. Identifying unnecessary 3d gaussians using clus- tering for fast rendering of 3d gaussian splatting. arXiv preprint arXiv:2402. 13827, 2024.
Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis. 3D Gaussian Splat- ting for real-time radiance field rendering. ACM Transactions on Graphics, 42(4), 2023.
kishimisu. Ristimisw/GausiianSSllaiinngg WebGL, September 2024. URL /tttps://githt/ coom://iaahiimsssuaausssaaa Salpiaann--llatnnnnngge - original-date: 2023-10-19911::399244
Arno Knapitsch, Jaesik Park, Qian- Yi Zhou, and Vladlen Koltun. Tanks and temples: Benchmarking large-scale scene reconstruction. ACM Transactions on Graphics (ToG), 36
Kevin Kwok. antimatter 1 5/splat, September 2024.
URL httts: com/
antimatter15/spl.
original-date: 0023-09-11170::2::566
Joo Chan Lee, Daniel Rho, Xiangyu Sun, Jong Hwan Ko, and Eunbyung Park. Compact 3d gaussian representation for radiance field. In Proceedings the IEEE/CVF Conference on Computer Vision and Puttern Recognition, pp. 21719-21722 2024.
Zhan Li, Zhang Chen, Zhong Li, and Yi Xu. Spacetime gaussian feature splatting for real-time dynamic view synthesis. In Proceedings of the IEEF/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 8508-8520, June 2024.
Zhong Li, Liangchen Song, Celong Liu, Junsong Yuan, and Yi Xu. Neulf: Efficient novel view synthesis with neural 4d light field. In Eurographics Symposium on Rendering, 2022. URL
https://apt semanttttttt.ee icscoo 1 ar org/ Corpus ID 236913029
Zhihao Liang, Qi Zhang, Ying Feng, Ying Shan, and Kui Jia. Gs-ir: 3d gaussian splatting for inverse rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 21644 21653, 2024.
Jiaqi Lin, Zhihao Li, Xiao Tang, Jianzhuang Liu, Shiyong Liu, Jiayue Liu, Yangdi Lu, Xiaofei Wu, Songcen Xu, Youliang Yan, et al. Vastgaussian: Vast 3d gaussians for large scene reconstruction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp-
5166-5175, 2024.
Stephen Lombardi, Tomas Simon, Jason Saragih, Gabriel Schwartz, Andreas Lehrmann, and Yaser Sheikh. Neural volumes: Learning dynamic renderable volumes from images. ACM Trans. Graph. 38(4):65:1-65:14, July 2019.
Tao Lu, Mulin Yu, Linning Xu, Yuanbo Xiangli, Limin Wang, Dahua Lin, and Bo Dai. Scaffold-gs: Structured 3d gaussians for ada-tive rendering. In Proceedings of the IEEE/CVF Conference 2024.
on Computer Vision and Pattern Recognition, pp.
Steve Marschner and Peter Shirley. Fundamentals of Computer Graphics. A K Peters, Wellesley, MA, fourth edition, 2015. ISBN 978-1482229394.
Morgan McGuire and Louis Bavoil. Weighted Blended Order-Independent Transparency. Journal of Computer Graphics Techniques, 2(4), 2013.
12

---

Published as a conference paper at ICLR 2025
Houman Meshkin. Sort- Sort-Independent Alpha Blending, 2007.
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. Commun. ACM, 65(1):99 106, dec 2021. ISSN 0001-0782. doi: 10.1 105/3555503250 httlhtttss//cc.... 10.114453503227
Wieland Morgenstern, Florian Barthel, Anna Hilsmann, and Peter Eisert. Compact 3d scene repre- sentation via self-organizing gaussian grids. arXiv preprint arXiv:23/2. 13299, 2023.
Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller. Instant neural graphics prim- itives with a multiresolution hash encoding. ACM Trans. Graph. 41(4):102:1100::15 July 2022. doi: 10.1145/3522223335531222
URL https:://dbi.org//1000 1ttp:///...111111522222222
3530127
KL Navaneet, Kossar Pourahmadi Meibodi, Soroush Abbasi Koohpayegani, and Hamed Pirsiavash. Compact3d: Compressing gaussian splat radiance field models with vector quantization. arXiv preprint arXiv:2311.1815 2023.
Thomas Neff, Pascal Stadlbauer, Mathias Parger, Andreas Kurz, Joerg H Mueller, Chakravarty R Alla Chaitanya, Anton Kaplanyan, and Markus Steinberger. Donerf: Towards real-time render- ing of compact neural radiance fields using depth oracle networks. In Computer Graphics Forum, volume 40, pp. 45-59. Wiley Online Library, 2021.
Simon Niedermayr, Josef Stumpfegger, and Rüdiger Westermann. Compressed 3d gaussian splatting for accelerated novel view synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. (0349-10358, June 2024.
NVIDIA. CUB CUDA Toolkit Documentation, 2024. URL https: http///ccssscc http//cccs...ii.../. com/ Buda/cub// index. hww.hhllluuhbbhc wcun-lluuubbbbvcoooooo Accessed: 2024-10-23.
Thomas Porter and Tom Duff. Compositing digital images. In Proceedings of the 11th annual conference on Computer graphics and interactive techniques, pp. 253-259, 1984.
Minghan Qin, Wanhua Li, Jiawei Zhou, Haoqian Wang, and Hanspeter Pfister. Langsplat: 3d lan- guage gaussian splatting. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 20051-20060, 2024.
Lukas Radl, Michael Steiner, Mathias Parger, Alexander Weinrauch, Bernhard Kerbl, and Markus Steinberger. Stopthepop: Sorted gaussian splatting for view-consistent real-timo rendering, ACM Trans. Graph., 43((), jul 2024. ISSN 0730-0301. doi: 10.1145/3658187. httpst/::
org 0ece/10.115//// 10..145/3658118
Vincent Sitzmann, Justus Thies, Felix Heide, Matthias Nießner, Gordon Wetzstein, and Michael Zollhofer. Deepvoxels: Learning persistent 3d feature embeddings. In Proceedings of the IEEE Conference Computer Vision and Pattern Recognition, pp. 2437-2446, 2019.
Justus Thies, Michael Zollhöfer, and Matthias Nießner. Deferred neural rendering: Image synthesis using neural textures. ACM Transactions on Graphics (TOG), 38(4): 2019.
Hugues Thomas, Charles R Qi, Jean-eEmanuel Deschaud, Beatriz Marcotegui, François Goulette, and Leonidas J Guibas. Kpconv: Flexible and deformable convolution for point clouds. In Proceedings of the IEEE/CVF international conference on computer vision, pp. 6411-6420, 2019.
Tong Wu, Yu-Jic Yuan, Ling-Xiao Zhang, Jie Yang, Yan-Pei Cao, Ling Qi Yan, and Lin Gao. Recent advances in 3d gaussian splatting. Computational Visual Media, pp. 1-30, 2024.
Chris Wyman. Exploring and expanding the continuum of oit algorithms. In High Performance Graphics, pp. 1-11, 2016.
Zhiwen Yan, Weng Fei Low, Yu Chen, and Gim Hee Lee. Multi-scale 3d gaussian splatting for anti- aliased rendering. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern 2024.
Recognition, pp.
13

---

Published as a conference paper at ICLR 2025
Zehao Yu, Anpei Chen, Binbin Huang, Torsten Sattler, and Andreas Geiger. Mip-splatting Alias- free 3d gaussian splatting. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 19447-19456, 2024.
Jiahui Zhang, Fangneng Zhan, Muyu Xu, Shijian Lu, and Eric Xing. Fregs: 3d gaussian splat- ting with progressive frequency regularization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 14424-21433, 2024.
Zi-Xin Zou, Zhipeng Yu, Yuan-Cher Guo, Yangguang Li, Ding Liang, Yan-Pei Cao, and Song Hai Zhang. Triplane meets gaussian splatting: Fast and generalizable single-view 3d reconstruction with transformers. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10324-10335 10335, 2024.
14

---

Published as a conference paper at ICLR 2025
A IMPLEMENTATION DETAILS ON MOBILE PHONES
For the SDGS-Graphin method, the pre-processing and the lighting steps remain the same as the original 3DGS implementation except for that they are now written GLSL compute shaders. We changed the rasterization step from compute based pipeline to traditional graphic pipeline using instanced draw, where each Gaussian treated as an instance and covered by a triangle pair in vertex shader. The fragment shader then colors the pixels within Gaussian's ' radius. The alpha blending handled by the hardware automatically at the rendering back-end. With the graphic pipeline, all Gaussians rendered using single instanced draw call instead of the per-tile fashion used by 3DGS. The sorting step is also changed from a tile-based sort to global sort, which implemented using GLSL compute shader.
For our method, the pre- prepprocessing and the lighting stages remain the same as the 3DGS method in Vulkan except for that now opacity is calculated in the lighting stage based camera view and SHs. Sorting step is removed and we also pass depth for each Gaussian to the graphic pipeline to calculate the per-Gaussse Ger-Gassiaan weight. The alpha blending operation is changed from using the blending factor to simple summation of the color and weight. We added an extra graphic pass using the Vulkan subpass feature to handle the final normalization. To make the 3DGS- Gra-hie method and our method fair comparison, the render target for both is set to use 16-bit RGBA. Note that the original 3DGS can be implemented using 8-bit RGBA with a slightly lower image quality and better rendering speed, but because our method requires the color and weight to be accumulated, used 16-bit to avoid overflow issue
B PER SCENES EVALUATION METRIC
Table and present the PSNR, SSIM, and LPIPS metrics for each scene within Mip-NeRF360, Tanks & Temples, and Deep Blending datasets, respectively.
C MORE DISCUSSIONS
Compared with gsplat webgl gsplat.tech At the same rendering resolution, our method improve rendering speed from 19-25 fps to 30fps on a Snapdragon gen3. The gsplat implementa- tion runs at a significantly lower resolution and leverages an asynchronous CPU sort running at frequency below the framerate, which exacerbates temporally artifacts under motion. Our imple- mentation does not have these artifacts, which demonstrates the effectiveness of our method.
Moving camera along direction. The alpha and weights are applied equally to the RGB color components. Ratios of different splats maintained along the z-direction with Exponential Weighted Sum Rendering EEXP-WSR), but not with Linear Correction Weighted Sum Rendering (LC-WSR). However, LC-WSR also produces visually plausible results. We conducted the periments to move the camera along direction. In the experiments, we test our EXP-WSR and
EXP-WSR
LC-WSR
EXP-WSR
LC-WSR
Figure Moving camera along direction. EXP-WSR and LC-WSR produces plausible results.
15

---

Published as a conference paper at ICLR 2025
LC-WSR the Bicycle and Garden scenes. As shown in Figure 7 shifting artifacts.
don't observe the color
Densification and pruning for view dependent opacity. The 3DGS densification technique was maintained for method without any modification. And we removed the pruning based on the opacity threshold. There are re- searches exploring other signals, such as mask Lee al. (2024) color [Buld et al. (2024), for densification and pruning. and achieving promising results. Our method will benefit from these works in the future.
Culling in WSR. Culling operates the same 3DGS. As with 3DGS, we render only those Gaussians within the Camera Frustum. Our implementation does sum over all visible Gaussians, we configure the hardware per- form this summation efficiently using hardware supported blending operations.
Figure 8: Failure case. The seat seems be transparent, is dark and the bicycle frame is in bright white.
Failure case. One type of failure that is easy to identify visually apparent transparency dark objects when in front of very light background. Figure shows an example where method fails. However, this could detected with differentiable rendering and thus can be attributed to suboptimal training.
D LIMITATIONS AND FUTURE WORK
Terminaerminnnonn.. In 3DGS pixel can be easily terminated by monitoring if its accumulated al- pha has been saturated. Alternately, we could implement heuristic to halt further evaluation of Gaus- sians whose opacity falls below some threshold, though current WSR implementation does support such an optimization. We implemented our method using the traditional graphics pipeline make efficient use of mobile GPUs, especially the hardware rasterizer. opacity and weight computations are performed in the fragment shader, while blending is handled by the hardware, since every fragment operates independently and does not have access the accu- mulated opacity, we are unable to easily implement early termination. This would require reading the render target's content within the invoking draw pass, which necessitates costly read-modify write operations and requires Vulkan extensions that many mobile devices do not currently support. Additionally, since the screen-space location of each Gaussian determined only after the vertex shader, pixel can only be discarded very late in the pipeline.
our implementation,
Compact Gaussians. Recently, several compact Gaussian methods have been introduced to sig- nificantly reduce the number of Gaussians while maintaining visual performance Jo al. (2024); Lee et al. (2024);] Fan et al. Niedermay et al. (2024); Chen et al. (2024): Morgenstern et al. (2023 Navaneet al. (2023). We believe that sort-free method benefit from the rapid pace of research on compact Gaussians.
16

---

Published as a conference paper at ICLR 2025
Table 6: PSNR scores of our method on the Mip-NeRF360 dataset, the Tanks&Temples dataset, and the Deep Blending dataset.
Mip- N6RF360
Tanks& Tanks&Temples
Deep Blending
Mathod
bicycle flowers garden
stump
treehill room counter kilchen
Avg
Irack
train
Avg
drjohnson
playrsom
Avg
Plenoxels
21.91
20.10
23.49
20.66
22.25
27.59
23.62
23.42
24.67
23.08
23.22
18.93
21.08
23.14
22.98
23,06
INGP Base
20.35
24.60
23.63
22.36
29.27
28.55
25.30
23.26
20.17
21.72
27.75
19.48
INGP Big
22.17
20.65
25.07
23.47
22.37
29.69
26.69
29.48
30.69
25.59
23.38
20.46
21.92
28.26
21.67
24.96
Mip-NoRF360
24.31
21.65
26.88
26.18
22.93
31.47
29.45
31.99
33.40
27.69
24.91
19.52
22.22
29.14
29.66
29.40
3DGS
25.25
21.52
27.41
26.55
22.49
30,63
28.70
30.32
31.98
27.21
25.18
21.09
23.14
28.77
30,04
29.41
Compact 3DGS
20.89
26.81
26.46
22.65
30.48
27.08
25.35
22.07
23.71
29.06
Compressed 3DGS
24.97
21.15
26.75
26.29
22.26
31.14
28.67
30.26
31.35
26.98
24,82
21,86
23.34
28.87
29.89
29.38
LightGanssian
25.20
21.54
26.96
26.77
22.69
31.40
28.48
30.87
31,41
27.13
25.40
21.84
23.44
Ours
24.20
20.45
27.78
25.39
22.01
31,93
29.53
31.38
32.05
27.19
25.28
21.93
23.61
29.25
30.00
29.63
Table 7: SSIM scores of our method on the Mip-NeRF360 dataset, the Tanks&Temple dataset, and the Deep Blending dataset.
Mip-NeRF360
Tanks&Temples
Deep Blending
Method
bicycle flowers garden stump trechill room counter kitchen bonsai
Avg
truck
train
Avg
drjohnson
playroom
Avg
Plenoxels
0.496
0.431
0.606
0.523
0.509
0.8417
0.759
0.648
0.814 0,626 0,774 0.663 0.719
0.787
0.802
0.795
INGP-Bus
0.491
0.450
0.649
0.574
0.518
0.855
0.798
0.818
0.890
0,671 0.779 0.666 0.723
0.839
0.754
0.797
INGP-Big
0.512
0,486
0,701
0.594
0,542
0.871
0.817
0.858
0.906
0.699 0.800 0.689 0.745
0.854
0.779
0.817
MiR-NeRF360
0.685
0,583
0.813
0.744
0.632
0.913
0.894
0.920
0,941
0.792 0.857 0.660 0.759
0.901
0.900
0.901
3DGS
0.771
0.605
0,868
0.775
0.638
0.914
0.905
0.922
0.938
0.815 0.879 0,802 0.841
0.899
0.906
0.903
Compact 3DGS
24.77
20.89
26.81
26.46
22.65
30.88
28.71
30.48
32.08
27.08 25.35 22.07 23.71
29.06
29.87
29.46
Compressed 3DGS
24.97
21.15
26:75
26.29
22.26
31.14
28.67
30.26
31.35
26.98
24.82 21.86 23.34
28.87
29.89
29.38
LightGanssian
21.54
26.96
26.77
22.69
31.40
30.87
27.13 25.40
23.44
Ours
0.744
0,580
0.872
0.728
0.614
0.925
0.909
0.923
0.938
0,804
0.882
0.502 0.842
0.898
0.906
0.902
Table LPIPS scores of our method on the Mip-NeRF360 dataset, the Lanks&Temple dataset, and the Deep Blending dataset.
Mip NeRFN60
Tinks&TTepple
Deep Blending
Method
bicycle flowers garden stump treehill room
counter kitchen bonsai
Avg trick train Avg drjohnson playmom
Avg.
Plenoxels
0.521
0.386
0.503
0.540
0.4186
0.447
0.463 0.335 0.422 0.379
0.521
0.499
INGP-Base
0.487
0.481
0,312
0.450
0.489
0.301
0.342
0.254
0.227
0.371 0,274 0,386 0.330
0.381
0.465
0.423
INGP-Bip
0.446
0,441
0.257
0.421
0.450
0.261
0.306
0.195
0.205
0.331
0.249 0,360 0.305
0.352
0.428
0.390
NeRF360
0.301
0.344
0,170
0.261
0.339
0.211
0.204
0.127
0.176
0.237
0.159 0.354 0.257
0.237
0.252
0,245
3DGS
0.336
0.103
0.210
0.317
0.220
0.204
0.129
0.214
0.148 0.218 0.183
0.244
Compact 3DGS
0.286
0.399
0.161
0.278
0.363
0.209
0.205
0.131
0.193
0,247 0.163 0.240 0.201
0.258
0.258
0.258
Compressed 3DGS
0.240
0.358
0,144
0.250
0.351
0.231
0.215
0.140
0,217
0.238
0.161 0.226 0.194
0.254
0.252
0.253
LightGaussian
0.218
0.352
0.122
0.222
0.338
0.232
0.220
0.141
0,221
0.237 0.155 0.239 0.202
Ours
0.205
0.342
0.097
0.235
0,311
0.197
0.191
0.125
0.199
0,211
0.136 0.219 0.177
0.233
0.225
0.229
17


Reviews:
[{"review_id": "52nDPK5QGX", "reviewer": "Reviewer_FZe3", "summary": "This paper proposed a sort-free Gaussian Splatting pipeline, which reduces the computational overhead of rendering to adapt to scenarios with limited computing resources. The key insight of this paper is that the view dependent sorting in the vanilla 3DGS involves a lot of computational overhead and is difficult to port to mobile devices. Therefore, the authors proposed to use weighted sum and view-dependent opacity to approximate alpha-blending. Experiments demonstrate that proposed method achieves comparable rendering quality and faster rendering speed than the original 3DGS on mobile devices.", "questions": "In the paper, the author points out that for some complex scenes, since a large number of 3D Gaussians are needed for representation, the sorting process will exhaust the resources of mobile devices, making real-time rendering impossible, such as the bicycle scene in Mip-NeRF 360 dataset. However, I tried to visualize the bicycle scene using a gsplat-based webgl viewer on my phone (iPhone 15 Pro Max), and was surprised to find that it achieves real-time rendering, about 20-30fps. This seems to indicate that some optimizations to the 3DGS rendering pipeline (gsplat uses some tricks) can increase the rendering speed on mobile devices without more complex designs. I would like to know the author's opinion on my point of view and more analyses of the key differences that enable real-time performance on mobile devices. And they can test the performance of gsplat on Snapdragon® 8gen3 chipset and compare with their proposed method.\n\nHere is the link of gsplat webgl-viewer https://gsplat.tech", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The author provides a clear analysis of the tile-based sort in the vanilla 3DGS, explains its impact on rendering speed, and explains why it is difficult to implement on other devices.\n- The proposed method speeds up rendering while ensuring rendering quality, and has been verified on consumer mobile devices.\n- The proposed weighted sum approximation alleviates the *pop* phenomenon caused by inconsistent sorting results under different view-directions in the vanilla 3DGS.", "weaknesses": "- The proposed method gets rid of the costly sorting, but a more complex weight and view-dependent opacity are used. Although the author points out in the paper that a general scheme for learning scene representations is bound only by the mathematical constraints of the scene model. According to the experimental results in the paper, the use of simple weighted-sum and view-independent opacity cannot achieve satisfactory rendering results. Does this mean that for rendering processes that are not physically and optically, more complex models must be used, such as introducing more learnable parameters as in the paper?\n- In the conclusion part of the paper, the author mentioned some recent research on compact Gaussian Splatting. According to my understanding of these works, since the methods proposed in these works obtain more compact 3D Gaussian representations, they can reduce the sorting overhead and speed up rendering to a certain extent. Therefore, I think the author should add a comparison of rendering quality, speed and memory usage between the proposed method and these works, such as Compact 3DGS[1], LightGaussian[2] and Compressed 3DGS[3] in the experimental evaluation section.\n\n[1] Compact 3D Gaussian Representation for Radiance Field https://openaccess.thecvf.com/content/CVPR2024/papers/Lee_Compact_3D_Gaussian_Representation_for_Radiance_Field_CVPR_2024_paper.pdf\n\n[2] LightGaussian: Unbounded 3D Gaussian Compression with 15x Reduction and 200+ FPS https://arxiv.org/pdf/2311.17245\n\n[3]  Compressed 3D Gaussian Splatting for Accelerated Novel View Synthesis https://openaccess.thecvf.com/content/CVPR2024/papers/Niedermayr_Compressed_3D_Gaussian_Splatting_for_Accelerated_Novel_View_Synthesis_CVPR_2024_paper.pdf", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "OtJRopNcQ9", "reviewer": "Reviewer_Man9", "summary": "The authors propose a novel rasterization backend for 3D Gaussian splatting (3DGS) that addresses the computational and memory overhead associated with depth sorting. Their primary contribution is replacing traditional alpha blending with a weighted sum rendering approach. The rendering is achieved through direct weighted summation of Gaussians, where weights are determined by a parameterized truncated linear function applied to the product of color and opacity. Additionally, they introduce view-dependent optimizable opacity for individual Gaussians, modeled using spherical harmonics.\nTheir weighted sum rendering (WSR) technique demonstrates comparable rendering quality to conventional 3DGS. To validate the advantages of their sort-free approach, the authors implement both vanilla 3DGS and WSR on the Vulkan API and evaluate performance on mobile GPU hardware, achieving a 1.23x speedup.", "questions": "- Does the method exhibit color shift artifacts during camera movement along the z-direction, as suggested by the concerns regarding linear weighting?\n- Since opacity is not capped at 1, how did you enforce the data range of final color, simply clamp?\n- How do other Gaussian attributes maintain their geometric meaning in this framework? Specifically: Does the mean of Gaussians still correspond to point cloud locations? How about depth extraction?\n- While traditional 3DGS implementations employ culling to manage computational complexity, does this approach require weighted summation of ALL Gaussians? What are the implications for scalability?\n- Please clarify the memory usage analysis: does it encompass only Gaussian attributes or include runtime memory requirements?\nWhat is the memory overhead of spherical harmonics coefficients for view-dependent opacity compared to vanilla 3DGS?\n- Regarding Table 2, could you elaborate on the starred data points showing significantly higher values? How does resource exhaustion due to sorting impact subsequent pipeline stages?\n- Given the potential for hardware-accelerated sorting methods specifically designed for 3DGS, possibly through hardware-software co-design, how might this work adapt to or complement such future developments?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "- The paper aims to address a fundamental bottleneck in 3DGS rendering by proposing a sort-free pipeline, distinguishing itself from previous approaches that primarily focused on reducing Gaussian counts.\n- The investigation of various weight derivation functions (direct sum-up, exponential weighted, and linear correction weighted) demonstrates a relative comprehensive experimental analysis effort.\n- Implementation and evaluation on mobile devices effectively demonstrates the practical benefits of the sort-free approach in resource-constrained environments.\n- The method appears to mitigate \"pop\" artifacts, a persistent challenge in volumetric rendering, providing an additional benefit beyond computational efficiency.", "weaknesses": "- The theoretical foundation for replacing alpha blending with an algebraic function requires stronger justification. While the proposed representation achieves good results, it lacks the physical insights inherent in traditional alpha blending, which models light obstruction during propagation. The introduction of view-dependent opacity appears necessary for acceptable rendering quality, but the paper would benefit from a more rigorous analysis of why this combination works, rather than empirical validation alone.\n- The preference for linear weights over exponential weights raises questions about robustness. When considering camera movement along viewing rays, exponential weights (with β ≈ 1) should theoretically provide more consistent mixing ratios between Gaussians. Linear weights may introduce color shift artifacts due to distance-dependent mixing ratio variations. While the authors claims \"some artifacts remain visible\" then selected linear weight rather than exponential weight, these issues warrant more detailed examination.\n- The method's generalizability is limited by the transformation of opacity into a view-dependent \"black box\" variable. This fundamentally alters the role of opacity, which traditionally serves as a crucial signal for pruning and densification in many 3DGS applications, potentially limiting compatibility with existing and future research in this domain.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "sQjg4OytEe", "reviewer": "Reviewer_b3oc", "summary": "This paper proposes a sort-free variant to the 3DGS algorithm. Because 3DGS is a semi-transparent representation, it requires sorting of all primitives which leads to higher running time, more hardware requirements, and lower compatibility on edge devices. Learning from the traditional sort-free rendering algorithm which replaces the sorting with an estimated weight from depth, this paper proposes to eliminate the sorting process of 3DGS completely. \n\nThis paper further proposes a view-dependent opacity to better simulate the occlusion effect. By learning spherical harmonics to represent the opacity, it allows the 3D Gaussians to appear and disappear at different angles, which could further mimic the occlusion effect.\n\nAs a result, this paper achieves a slightly higher rendering speed and lower GPU memory footprint, better compatibility on edge devices, and comparable rendering quality than 3DGS.", "questions": "1. Can the authors provide some qualitative results on the Bicycle scene?\n2. Can the authors provide some videos showing the removal of the popping effect?\n3. Can the authors show some failure cases of the proposed approximation?\n\nI really want to give a positive rating to this paper, because I know it is very difficult to make a sort-free rendering to achieve the same quality as the sort-based version. However, the marginal speed improvement diminishes the significance of this paper. Furthermore, I hope the authors can demonstrate some failure cases of such approximation methods, as they are quite common in traditional sort-free algorithms. Doing this could give the reader a more comprehensive understanding of the proposed method.", "limitations": "", "rating": 8, "confidence": 3, "soundness": 3, "presentation": 2, "contribution": 3, "strengths": "**Motivation**\n* The motivation of this paper is very clear. It clearly illustrates the drawbacks of the sorting requirement of 3DGS and the possible benefit of removing it. Sort-free transparent object rendering is also a well-studied direction in traditional rendering. Combining the algorithms from traditional computer graphics with 3DGS is well-motivated.\n\n**Method**\n* The proposed method transformed the traditional depth-based weighted rendering to a learnable version to better suit the per-scene optimization used in 3DGS, which provides significant performance improvement. \n* The proposed view-dependent opacity is an innovative approach that mimic the occlusion effect. Because this SH parameters are optimized together, it compensates for some performance loss from incorrect occlusion estimation without sorting.\n\n**Experiments**\n* The performance on normal desktop GPU demonstrates a small improvement in rendering speed and comparable rendering speed. In fact, it is already remarkable that a sort-free rendering algorithm can match the performance of a sorting-based rendering algorithm in a scene full of semi-transparent primitives.\n* The performance improvement on the edge device shows a more significant improvement because of the demanding sorting step.", "weaknesses": "** Motivation **\n* As shown in the paper, the sorting step is usually considered slow, but actually contributes to only 25% of the total rendering time. The real problem preventing 3DGS based method from matching the rendering speed of traditional methods is the alpha blending step. Although this paper removes the sorting step, it still needs the per-pixel alpha blending of Gaussians of calculated weights. As a result, the speed improvement is rather insignificant. \n* Rather than removing the sorting step, many works have proposed to removing the redundant Gaussians directly. These methods seem to provide much more significant speed boost. Of course these two method can be run in parallel, but it still weaken the importance of the proposed method. \n\n** Method **\n* The proposed method is largely borrowed from the traditional sort-free methods. I think this is acceptable because of the long history of sort-free rendering research in traditional computer graphics, it does negatively affect the novelty of the proposed method slightly.\n\n** Experiments**\n* As mentioned above, the improvement on standard desktop GPU is rather insignificant. Since sort-free rendering is essentially an approximation of the sort-based rendering, it might not be a good idea to choose this method for such a small improvement while there is a possibility of very bad performance on some scenes. \n* Continuing from the last point, sort-free approximations are usually inaccurate on small and thin structures. For example, I noticed that the proposed method on the bicycle scene in MipNeRF-360 dataset is somewhat lower than the original 3DGS method. This scene contains very thin and fine structures on the bicycle which could be a better illustration of whether the proposed method suffers from similar artifacts like the traditional methods. \n* Despite the significant rendering speed improvement on the edge devices, the paper lacks a detailed explanation of how the edge device running out of resources leads to such a big decrease in rendering speed.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "P2xEjeqZWm", "reviewer": "Reviewer_uk93", "summary": "This work attempts to solve a key problem with current Gaussian Splatting techniques, the computational load that occurs during rendering as a result of the non-commutativity of the opacity calculation needed during the rendering process. The authors achieve this by a novel weighting of term added to each Gaussian to replace the traditional opacity term. The weighting term allows for an order independent formulation of the computation of the final colour of the a rendered ray through the field. View-dependence is obtained by the introduction of a spherical harmonic based formulation to the new weighting term similar to that currently used in prior-art Gaussian Splatting methods for view-dependent colour. Performance is evaluated against prior-art techniques.", "questions": "1. In section 4.3 the authors reveal that view-dependent opacity is obtained by the addition of a new set of spherical harmonics related to the depth weighting introduced by the authors. In the experimental section, the authors show that this doesn't impact memory usage during rendering and a rationale given in the removal of the sorting step and the potential reduction in the number of Gaussians. However, this appears to be referring to instantaneous memory requirements. How does the introduction of the new set of spherical harmonics for each Gaussian affect post-training storage requirements of the radiance field? Is a greater storage footprint needed for the radiance fields produced by the proposed methods?\n2. Line 53 \"maintain rendering differentiable\" should be \"maintain rendering differentiability\".\n3. Line 141 \"Chris Wyman provide a good survey on these methods\" should be \"Chris Wyman provides a good survey on these methods\"\n4. Line 273, \"However, DIR-WSR does not work well for the complex scenes, \" should be \"However, DIR-WSR does not work well for complex scenes, \"\n5. Line 307 ends with an additional full stop.", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 4, "contribution": 4, "strengths": "This work solves a crucial problem in real-time rendering of Gaussian Splatting based radiance fields. By removing the need for depth-based sorting of the Gaussians before rendering, critical memory requirements are reduced enabling the implementation of the methodology on mobile devices or other applications with limited computational capacity. So I feel that the work represents a strong contribution to the field. Other strengths include:\n1. Clear and easy to read figures and tables clearly detailing the benefits of the proposed method.\n2. A detailed and clear explanation of the proposed method. It is clear what has been done, how this is motivated by previous literature.\n3. A strong experimental validation. Comparisons are made against well-recognized metrics and a the latest state-of-the-art methods. The experimental results support well the conclusions reached.", "weaknesses": "This work is of quite a high quality. I do not see any specific weaknesses in the methodology or the experimental results. There is one specific minor weakness in the experimental section wherein I would like further information on the memory requirements of the proposed method. I detail the exact question I have in the \"Questions\" section below.\nOne final minor issue is the presence of minor grammar errors in the text as I mention in the \"Questions\" section below.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)