---
title: Weighted Sum Rendering (WSR) Overview
url: https://www.emergentmind.com/topics/weighted-sum-rendering-wsr
type: topic
---

# Weighted Sum Rendering (WSR) Overview

Weighted Sum Rendering (WSR) defines a family of sort-free, order-independent compositing algorithms for 3D Gaussian Splatting (3DGS), enabling real-time, high-fidelity view synthesis by replacing traditional, non-commutative alpha blending with commutative weighted sums. WSR achieves this by introducing depth- or transmittance-dependent weights into the blending process, eliminating the need for costly per-pixel splat sorting and associated "popping" artifacts. Modern frameworks such as Duplex-GS generalize WSR with proxy-cell hierarchies and physically-motivated weights, providing both efficiency and correct occlusion handling for photorealistic scene rendering on desktops and resource-constrained devices [2508.03180] [2410.18931].

## 1. Mathematical Formulation and Derivation

WSR originates as a relaxation of classic front-to-back alpha blending, which requires strict depth sorting because the OVER operator is non-commutative. Given $N$ 3D Gaussian splats, the standard approach computes opacity and composited color per-pixel as:

$$
\alpha_i = \sigma_i G_i'(x'), \qquad
T_i = \prod_{j=1}^{i-1}(1 - \alpha_j), \qquad
C(x') = \sum_{i=1}^N T_i \alpha_i c_i.
$$

Here $\alpha_i$ is the opacity of splat $i$, $G'_i(x')$ is its projected kernel at pixel $x'$, $T_i$ is accumulated transmittance, and $c_i$ its color. Sorting overhead scales with the number of contributing Gaussians per-ray and compromises temporal coherence, causing popping artifacts.

WSR discards the non-commutative OVER, replacing it with a commutative weighted sum. The color is expressed as:

$$
C = \frac{w_B c_B + \sum_{i=1}^N \alpha_i w(d_i) c_i}{w_B + \sum_{i=1}^N \alpha_i w(d_i)}
$$

where $c_B$, $w_B$ denote background color/weight, and $w(d_i)$ is a depth-dependent blend weight for splat $i$ at depth $d_i$. Both numerator and denominator are purely accumulative sums, enabling arbitrary compositing order with perfect temporal stability.

Notable instantiations of $w(d)$:
- **Direct**: $w(d) = 1$ (DIR-WSR).
- **Exponential**: $w(d) = \exp(-\sigma d^\beta)$ with learned $\sigma, \beta$ (EXP-WSR).
- **Linear-Corrected**: $w(d) = \max(0, 1 - d/\tau)\,v_i$ for learned $\tau$ and per-splat $v_i$ (LC-WSR).

WSR admits extensions such as the physically-inspired kernel of Duplex-GS, which introduces proxy-cell groups and cell-level transmittance to re-enable early ray termination and restore monotonic occlusion [2508.03180].

## 2. Order-Independence and Differentiability

Additivity in both numerator and denominator of the WSR equation guarantees commutativity and thus order-independence; any per-pixel splat accumulation order yields the same result. Temporal popping is eliminated, as even small changes in active splat lists do not yield visible blend discontinuities across frames.

WSR is fully differentiable. Its parameter set includes Gaussian means, covariances, opacity parameters, color bases (often SH), cell-proxy weights, and weight-function learnables ($\sigma, \beta, v_i$). In practice, end-to-end learning is performed using a sum of $\ell_1$ pixel error and multi-scale DSSIM losses, optimizing global and local parameters jointly via custom CUDA or Vulkan kernels [2410.18931].

## 3. Hierarchical Proxies and Cell-Based WSR

Duplex-GS generalizes WSR by grouping Gaussians into $M$ proxy "cells," each defined by a bounding ellipsoid and carrying a feature vector for decoding $K$ Gaussians inside. Cell-level sorting replaces per-splat sorting: only the $M \ll N$ cells are depth-sorted, and within each cell the Gaussians are composited without internal ordering. Transmittance per-cell is computed in front-to-back order, and early termination is triggered when accumulated transmittance drops below a small threshold $\varepsilon$.

Color compositing in the cell-proxy extension is:

$$
C(x') = \frac{\sum_{n=1}^M w_n \sum_{k=1}^K \alpha_{n,k}\,c_{n,k}}{\sum_{n=1}^M w_n \sum_{k=1}^K \alpha_{n,k}}
$$

with $w_n = v_n T_n^{\text{cell}}$ for cell scalar $v_n$ and sorted cell transmittance $T_n^{\text{cell}}$ [2508.03180].

Cell search rasterization is employed: only visible proxy cells are rasterized, reducing memory and sorting overhead by 50–90%. Each visible cell is dynamically decoded, and all contained Gaussians contribute only as needed, enabling efficient real-time performance.

## 4. Algorithmic Implementation and Mobile Pipelines

On the GPU, WSR is implemented to exploit order-independence for both desktop and mobile hardware. A typical mobile pipeline proceeds as follows [2410.18931]:

- Project 3D Gaussians or proxy cells to screen space.
- Evaluate per-splat color and opacity (often in a vertex or compute shader).
- Omit sorting passes; pass view depth as an attribute.
- In the fragment shader, accumulate per-fragment color and weight:
  ```
  accumColor += α_i w(d_i) c_i
  accumWeight += α_i w(d_i)
  ```
- After rasterization, normalize final color per-pixel as $C = \text{accumColor}/(w_B + \text{accumWeight})$.
- For cell-based WSR, proxy cells are sorted, and early ray termination is supported via per-cell transmittance tracking [2508.03180].

This structure leverages built-in additive blending and supports single instanced draw calls, yielding high throughput. On Snapdragon 8 Gen 3, WSR achieves $\sim1.23\times$ render speedup and 63% memory footprint compared to sort-based 3DGS at $1920\times1080$ [2410.18931].

## 5. Artifact Elimination and Physical Limitations

Classic alpha blending incurs "popping" artifacts (discrete color jumps) with minor splat order changes due to sorting non-commutativity. WSR, being a commutative sum, is temporally stable and immune to popping. However, vanilla WSR variants (including LC-WSR) lack physical early ray termination: all splats contribute regardless of occlusion, which can lead to transparency artifacts—background "bleeds" through dense or opaque regions.

The proxy-cell and transmittance-controlled WSR in Duplex-GS addresses this by:
- Introducing cell-level transmittance and enabling early termination at the proxy-cell level.
- Guaranteeing monotonic occlusion such that rays do not traverse through fully opaque foreground, eliminating "see-through" ghosts [2508.03180].

This distinction is pivotal for achieving both realism and computational efficiency in large, complex scenes.

## 6. Quantitative Performance and Limitations

Empirical evaluations on datasets such as Mip-NeRF360, Tanks&Temples, DeepBlending, and BungeeNeRF demonstrate:

| Dataset         | FPS (Duplex-GS) | FPS (LC-WSR) | Speedup | Sort Reduction (%) | Memory Reduction (%) |
|-----------------|-----------------|--------------|---------|--------------------|----------------------|
| Mip-NeRF360     | 184             | 77           | 2.4×    | 54%                | 53%                 |
| Tanks&Temples   | 147             | 89           | 1.65×   |                    |                     |
| DeepBlending    | 232             | 114          | 2.0×    |                    |                     |
| BungeeNeRF      | 124             | 31           | 4.0×    | 87%                | 87%                 |

LC-WSR (WSR with linear depth correction) achieves competitive or better quality relative to classic 3DGS by PSNR, SSIM, and LPIPS metrics, with exemplary temporal stability and sharp edge reproduction [2410.18931]. Proxy-cell WSR maintains or improves perceptual quality while reducing radix-sort overhead by 52–87% and achieving O(1)-sorting complexity for most rays [2508.03180].

Limitations include reliance on learned weight functions to mimic physical occlusion and the lack of exact physical correctness in the vanilla (non-proxy) WSR approach. Although per-fragment weight computation introduces some overhead, the aggregate throughput remains higher than traditional sort-dependent methods, especially on parallel hardware.

## 7. Significance and Prospective Developments

Weighted Sum Rendering constitutes a paradigm shift in differentiable graphics and 3D neural scene representations. By enabling sort-free, temporally coherent, and hardware-efficient view synthesis, WSR unlocks interactive performance for scalable 3DGS applications on both high-end and mobile devices.

The introduction of hierarchical proxy-based compositing (as in Duplex-GS) further bridges the trade-off between physical fidelity and rendering throughput, suggesting a generalizable methodology for future real-time neural rendering and graphics systems. Ongoing development focuses on enhancing physically-accurate occlusion, supporting adaptive cell layouts, and integrating more expressive learned weighting schemes [2508.03180] [2410.18931].

Source: https://www.emergentmind.com/topics/weighted-sum-rendering-wsr