Jiwon

CGVI Graduate from UCL

3 minute read

GESs

Introduction: Solving the “Popping” Artifact

3D Gaussian Splatting (3DGS) has set the gold standard for real-time radiance field rendering. However, it relies on \(\alpha\)-blending, which requires primitives to be sorted from front to back. To stay fast, most 3DGS implementations use tile-based sorting approximations. The side effect? Popping artifacts, visual flickering where colors jump or disappear as the camera moves.

Gaussian-enhanced Surfels (GESs), a new approach from Zhejiang University (SIGGRAPH 2025), fundamentally solves this by removing the sorting requirement entirely. By combining 2D opaque surfels with 3D Gaussians, they achieve over 600 FPS at 1080p with perfect view consistency.

Paper Info

  • Title: When Gaussian Meets Surfel: Ultra-fast High-fidelity Radiance Field Rendering
  • Authors: Keyang Ye, Tianjia Shao, Kun Zhou
  • Conference: SIGGRAPH 2025
  • Paper Link: ArXiv

Core Architecture: Bi-scale Representation

GESs

The researchers propose a bi-scale representation that treats a 3D scene as a solid surface enhanced by a volumetric detail layer.

1. Coarse Scale: 2D Opaque Surfels

The foundation of the scene consists of $N$ surfels. Unlike the “fuzzy” primitives in standard 3DGS, these surfels are fully opaque circular discs.

  • Attributes: \(S = \{p_i, r_i, s_i, SH_i\}\) (Position, Rotation, Scale, Spherical Harmonics).
  • Role: They approximate the “surface radiance field,” representing the primary geometry and dominant colors of the scene.

2. Fine Scale: 3D Gaussians

To handle high-frequency details (like hair, grass, or complex reflections) that a flat surfel cannot capture, the model adds a few 3D Gaussians.

  • Attributes: \(G = \{p_i, \sigma_i, r_i, s_i, SH_i\}\) (including maximum opacity \(\sigma_i\)).
  • Role: They supplement the scene appearance in areas where the surfel radiance field is insufficient.

Technical Deep Dive: Sorting-Free Rendering

The “magic” of GESs happens in its two-pass rendering pipeline, which leverages the programmable graphics pipeline (OpenGL) to bypass sorting.

Pass 1: Surfel Rasterization

The opaque surfels are rendered through a standard graphics pipeline. The GPU performs a hardware-level Z-test to determine visibility.

  • Output: A color map \(C_s\) and a depth map \(D_s\). Since surfels are opaque, this pass is extremely efficient and perfectly consistent across views.

Pass 2: Order-Independent Gaussian Splatting

In this pass, 3D Gaussians are splatted. Instead of sorting them, the system uses the depth map \(D_s\) from Pass 1 as a reference.

  • Depth Testing: A Gaussian is only processed if its center depth \(d_i\) is less than the surfel depth \(d_s\) (plus a small adaptive offset $$epsilon$$ to prevent clipping).
  • Accumulation: The Gaussian colors are accumulated pixel-wise without considering their relative order.

The final pixel color \(C\) is computed using a weighted combination: \(C = \frac{C_s W_s + C_G}{W_s + W_G}\) where \(W_s=1\) (the fixed weight for the opaque surfel) and \(C_G, W_G\) are the accumulated Gaussian color and weight. Because this entire process is sorting-free, it bypasses the biggest bottleneck in 3DGS.

Technical Deep Dive: Optimization Strategy

Optimizing opaque surfels is mathematically difficult because they are non-differentiable (they don’t have “soft” edges to provide gradients). GESs solve this with a Coarse-to-Fine strategy using an Opacity Modulating Parameter \(w_i\).

The \(w_i\) Evolution

The opacity \(\alpha_i\) at a point \((x,y)\) on a surfel is defined as: \(\alpha_{i}(x,y) = \min(1, w_{i} G(x,y))\) where \(G(x,y)\) is a standard Gaussian function.

  1. Early iterations (\(w_i \approx 0.1\)): Surfels act like translucent Gaussians. Gradients can flow through them, allowing the AI to move and scale them to the correct positions.
  2. Transition: As training continues, \(w_i\) is gradually increased. The “fuzzy” edges of the surfel shrink, and the center becomes opaque.
  3. Finalization (\(w_i = 255\)): The surfels become solid, opaque discs.

Once the surfels are stabilized (around 20k iterations), the 3D Gaussians are added and jointly optimized to fill in the visual gaps.

Results & Performance

GESs

GESs achieve a unique balance of speed, quality, and consistency.

Quantitative Comparison (Mip-NeRF360 Dataset)

Method PSNR \(\uparrow\) FPS (1080p) \(\uparrow\) View Consistency (FLIP) \(\downarrow\)
3DGS 27.43 185 0.041
SortFreeGS 27.19 321 0.034
3D-GES (Ours) 27.38 675 0.032
Speedy-GES 27.07 1135 -

Key Takeaways

  • Speed: 3D-GES is over 3.6x faster than vanilla 3DGS. The “Speedy” extension reaches over 1000 FPS, making it ideal for high-refresh-rate VR.
  • Consistency: Because it uses a Z-buffer for the main geometry, there is zero “popping.” The scene feels as solid as a traditional mesh.
  • Geometry: The explicit surfel layer makes it much easier to extract clean 3D meshes and calculate physical collisions compared to standard “cloud-like” Gaussian sets.

Conclusion

Gaussian-enhanced Surfels (GESs) prove that we don’t have to sacrifice visual quality for rendering speed. By rethinking the fundamental representation of the scene—splitting it into a solid base and a detailed mist—they have unlocked the next level of real-time radiance field performance.

You May Also Enjoy