QuadBox: Accelerating 3D Gaussian Splatting with Geometry-Aware Boxes

Abstract: 3D Gaussian Splatting (3DGS) has emerged as an advanced technique for real-time novel view synthesis by representing scene geometry and appearance using differentiable Gaussian primitives. However, efficiently computing precise Gaussian-tile intersections remains a critical task in the rasterization pipeline. To this end, we propose QuadBox, a method that leverages four axis-aligned bounding boxes to tightly encapsulate projected Gaussians in a discrete manner. First, we derive a geometry-aware stretching factor that enables the construction of a tile-aligned QuadBox, which covers the elliptical projection and largely excludes irrelevant tiles. Second, we introduce QPass, a single-pass tile traversal algorithm that exhaustively exploits the discrete nature of QuadBox, ensuring that the tile intersection check is performed with simple interval tests. Experiments on public datasets show that our method accelerates the rendering speed of 3DGS by 1.85$\times$. Code is available at \href{https://github.com/Powertony102/QuadBox}{https://github.com/Powertony102/QuadBox}.

• The paper introduces QuadBox, a geometry-aware technique that employs four adaptively stretched bounding boxes to tightly encapsulate projected 2D ellipses.
• It presents the QPass algorithm, a single-pass, branch-free tile traversal method that significantly reduces redundant computations for enhanced GPU performance.
• Experimental results show up to 1.85× speedup and maintained image quality on benchmark datasets, confirming the method’s efficiency and fidelity.

QuadBox: Geometry-Aware Acceleration for 3D Gaussian Splatting

Introduction and Motivation

3D Gaussian Splatting (3DGS) defines the state-of-the-art for real-time novel view synthesis, leveraging differentiable Gaussians as primitives to accurately and efficiently model scene geometry and appearance. The critical challenge addressed by "QuadBox: Accelerating 3D Gaussian Splatting with Geometry-Aware Boxes" (2605.04844) is the computational inefficiency in determining the intersection between projected 2D elliptical Gaussians and the discrete tile structure of a rasterizer. Existing methods, such as single axis-aligned bounding boxes (AABBs), are conservative, causing redundant tile evaluations that reduce throughput. The work introduces a quadrant-aware bounding scheme (QuadBox) and an efficient tile traversal algorithm (QPass) to significantly lower tile redundancy, yielding superior rendering performance without sacrificing visual fidelity.

Geometry-Aware Bounding: The QuadBox Construction

The core innovation is the QuadBox representation—a set of four adaptively stretched AABBs that tightly encapsulate the projected 2D ellipse of each Gaussian in tile-space. The construction starts by filtering out Gaussians with negligible opacity, deriving a confidence region bounded by the ellipse equation corresponding to the desired opacity threshold. The QuadBox is constructed in three phases:

1. Initialization via Opacity Filtering: Only Gaussians with opacity above a minimum threshold are considered, yielding a well-defined elliptical support region for each primitive.
2. DualBox Extraction: The elliptical region is first approximated by extracting bounding regions aligned with the major axis, reducing tile redundancy for elongated Gaussians.
3. Adaptive Stretching: The remaining elliptical support along the minor axis is tightly enclosed by additional bounding boxes. Algebraic closed-form solutions are provided for the maximal ellipse extents in principal directions and for a normalized stretching factor, ensuring precision and efficiency.

This geometry-aware strategy eliminates reliance on a single coarse bounding box, providing much tighter coverage especially for anisotropic ellipses.

Figure 1: Evolution of QuadBox construction: starting with AdR-AABB, progressing to DualBox along the major axis, and completing with four adaptively stretched sub-boxes covering the ellipse's full extent.

Efficient Tile Traversal: The QPass Algorithm

Building on QuadBox, the QPass algorithm introduces a single-pass, branch-free mechanism for tile enumeration. Each QuadBox is decomposed into four quadrants, and the global tile-space bounds are efficiently determined. QPass traverses scanlines along the smaller axis, performing min/max aggregation of sub-boxes' intervals per scanline to avoid redundant tile visits and unnecessary branching—both critical for warp-level parallel efficiency on GPUs.

Figure 2: QPass traverses the tile grid by computing global bounds, scanning along the short axis, and merging tile intervals for branch-free, cache-friendly execution.

Unlike naive implementations that independently process each quadrant (leading to overlapping checks and potential thread divergence), QPass ensures deterministic, cache-friendly memory access and minimal computation, achieving optimal utilization of parallel hardware resources.

Experimental Results

The QuadBox and QPass methodology were integrated into the official 3DGS codebase and evaluated on standard datasets, including Mip-NeRF 360, Deep Blending, and Tanks and Temples. Key findings include:

• Rendering throughput (FPS): On the Mip-NeRF 360 benchmark, vanilla 3DGS achieves 180 FPS, AdR-AABB 305 FPS, while QuadBox+QPass achieves 322 FPS.
• Visual fidelity: QuadBox maintains or slightly improves PSNR and SSIM relative to prior methods, confirming that accelerated pruning does not induce quality degradation.
• Scene robustness: Per-scene analysis demonstrates that QuadBox consistently boosts rendering speeds across both indoor and outdoor scenes.
• Plug-and-play acceleration: Integration with DashGaussian and Compact-3DGS results in >1.85× and >1.64× speedups respectively, demonstrating broad applicability across variant splatting architectures.
• Ablation study: Disabling QPass or reducing bounding box adaptivity reveals clear trade-offs—only the full QuadBox+QPass combination attains both peak speed and maximal image quality.

  Figure 3: Rendering speed (FPS) comparison—QuadBox surpasses AABB (AdR-Gaussian) and vanilla 3DGS during progressive zoom-in.

  

  Figure 4: Qualitative results on Mip-NeRF 360, Deep Blending, and Tanks and Temples; QuadBox matches or improves upon competitors in PSNR and perceptual quality.

Implications and Future Directions

Practically, this work supplies a generic, efficient rasterization strategy that is orthogonal to the optimization details of the underlying scene representation. Its geometry-adaptive culling reduces memory pressure, thread divergence, and computation without loss in fidelity, making it suitable for emerging applications in scalable scene synthesis, robotics, and AR/VR rendering pipelines.

Theoretically, the closed-form derivation of bounding box parameters demonstrates principled exploitation of the elliptical geometry inherent to 3DGS, pointing towards further improvements via non-axis-aligned or adaptive tile structures.

Future developments may include the extension of geometry-aware culling to non-elliptical primitives, integration with hierarchical culling strategies, or modification to support dynamic scenes and time-varying radiance fields.

Conclusion

QuadBox and QPass collectively offer an efficient and precise approach to bounding and traversing discrete tile grids for projected ellipses in 3D Gaussian Splatting. The method surpasses prior work in both rendering speed and coverage tightness, achieving over 1.85× acceleration on leading benchmarks while preserving image quality. Its general, plug-and-play nature and theoretical foundations position it as a valuable component in the modern real-time neural rendering stack.