QuadBox: 3D Gaussian Splatting Optimization

• QuadBox is a geometry-aware optimization method that refines projected Gaussian tiling by replacing a single conservative bound with four tighter axis-aligned boxes.
• It analytically derives sub-box extents from the conic geometry of anisotropic Gaussians, improving tile culling accuracy without altering image formation.
• The integrated QPass algorithm performs a single-pass traversal over the merged tile range, reducing redundant tests and achieving an average rendering speedup of 1.85×.

QuadBox is primarily the name of a rasterization-side acceleration method for 3D Gaussian Splatting (3DGS) that replaces a single conservative axis-aligned bound for each projected Gaussian with a tighter discrete cover formed by four axis-aligned boxes, together with a one-pass traversal procedure called QPass. Its stated goal is to reduce false-positive Gaussian–tile intersections in the preprocess stage of tile-based 3DGS without changing the rendered image formation, and the reported average rendering acceleration is $1.85\times$ on public datasets (Li et al., 6 May 2026). In secondary optimization-oriented descriptions, the same label has also been used informally for box-constrained quadratic models, especially nonconvex quadratic programs over boxes, although that usage is descriptive rather than canonical (Xia et al., 2014).

1. QuadBox in 3D Gaussian Splatting

In 3DGS, a scene is represented by differentiable Gaussian primitives

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$

with rendering performed by front-to-back alpha compositing,

$$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$

where $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$ (Li et al., 6 May 2026). The image plane is partitioned into $16\times 16$ tiles, and the preprocess stage determines which tiles each projected Gaussian overlaps before DuplicateWithKeys, SortPairs, and Render are executed.

The motivation for QuadBox is that projected Gaussians are generally anisotropic, rotated ellipses in screen space, whereas the baseline rasterizer bins them using a single conservative axis-aligned box. The baseline side length is based on $6\sqrt{\lambda_{\max}}$, where $\lambda_{\max}$ is the largest eigenvalue of the 2D covariance; this is robust but loose for long, thin, oblique ellipses (Li et al., 6 May 2026). AdR-Gaussian improves this with an opacity-aware AABB, but still uses one rectangle. QuadBox instead uses four axis-aligned sub-boxes, one per quadrant around the Gaussian center, to obtain a tighter discrete tile cover while preserving conservative coverage (Li et al., 6 May 2026).

This suggests that QuadBox is best understood as a discrete geometry-processing optimization inside the 3DGS rasterization pipeline rather than as a change to the Gaussian representation, training objective, visibility ordering, or compositing rule.

2. Geometry-aware construction

QuadBox starts from the thresholded support of the projected 2D Gaussian. With

$$\Lambda = (\Sigma^{2D})^{-1} = \begin{bmatrix} a & b\ b & c \end{bmatrix},$$

and centered screen coordinates $(x_d,y_d)$, the effective support ellipse is written as

$$F(x_d, y_d) = ax_d^2 + 2bx_dy_d + cy_d^2 - \gamma \leq 0,$$

where $$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$0 is determined by the opacity thresholding rule, with $$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$1 in the reported implementation (Li et al., 6 May 2026).

Two geometric quantities are central. The axis intercepts are

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$2

while the maximal support along a direction $$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$3 is

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$4

with maximizing point

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$5

Specializing to the coordinate axes gives

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$6

and, using

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$7

equivalently

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$8

The defining geometric parameter of QuadBox is the stretching factor

$$\mathcal{G}_i(x) = \exp\left({-\frac{1}{2} (x - \mu_i)^\top {\Sigma}_i^{-1}(x - \mu_i)}\right),$$9

It depends only on the projected conic geometry, not on the center translation or the opacity threshold, satisfies $$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$0, equals $$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$1 when $$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$2, and decreases as the ellipse becomes more oblique in screen coordinates (Li et al., 6 May 2026). The construction is therefore “geometry-aware” in the specific sense that the auxiliary box extents are computed analytically from $$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$3, rather than from heuristic padding.

The paper describes the construction as a three-stage process: initialization via opacity filtering, DualBox extraction using the two quadrants aligned with the major axis, and adaptive stretching to full QuadBox using the factor $$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$4 (Li et al., 6 May 2026). The exact corner formulas of all four sub-boxes are not printed in the text. This suggests that the paper prioritizes the analytic derivation of the stretch factor and the discrete traversal strategy over a symbolic closed-form specification of every box corner.

3. QPass and tile traversal

A naive implementation of four sub-boxes would traverse each rectangle separately, inducing overlap handling, repeated visits, and additional branch divergence. QPass is introduced as a single-pass traversal of the union of the four tile rectangles (Li et al., 6 May 2026).

If the four tile-space sub-boxes are

$$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$5

QPass first aggregates the global tile range,

$$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$6

$$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$7

It then scans along the shorter global axis. For a column-wise scan, the active sub-box set is

$$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$8

and the merged orthogonal interval is

$$C(u) = \sum_{i=1}^{N} T_i(u)\,\alpha_i\,c_i, \quad T_i(u) = \prod_{j=1}^{i-1}(1 - \alpha_j),$$9

All tiles $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$0 in that merged interval are emitted exactly once (Li et al., 6 May 2026).

The significance of QPass is not merely algorithmic neatness. It converts Gaussian–tile intersection into interval tests and min/max reductions over a constant-size set of rectangles, avoiding per-tile ellipse tests, eigen-analysis during traversal, or repeated multi-pass rectangle scans (Li et al., 6 May 2026). This suggests that the practical gain comes from a combination of tighter coverage and a representation whose discrete structure is exploited directly on the GPU.

4. Empirical behavior and operating regime

The reported evaluation uses Mip-NeRF 360, Deep Blending, and Tanks and Temples, with CUDA kernel timing averaged over three trials on NVIDIA A100 and RTX 4090 hardware (Li et al., 6 May 2026). Against vanilla 3DGS on an A100, QuadBox reports:

• Mip-NeRF 360: $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$1 FPS, with PSNR $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$2, SSIM $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$3, and LPIPS $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$4.
• Deep Blending: $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$5 FPS.
• Tanks and Temples: $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$6 FPS.

The abstract summarizes these results as an average rendering acceleration of $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$7 (Li et al., 6 May 2026). The quality metrics remain essentially unchanged, which is consistent with the method’s conservative-coverage role.

The method is also presented as plug-and-play with other 3DGS variants. For DashGaussian, the reported FPS changes are $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$8, $\alpha_i = o_i \mathcal{G}_i^{2D}(u)$9, and $16\times 16$0 on Mip-NeRF 360, Deep Blending, and Tanks and Temples, respectively. For Compact-3DGS, they are $16\times 16$1, $16\times 16$2, and $16\times 16$3 (Li et al., 6 May 2026). This supports the interpretation that QuadBox is orthogonal to scene representation and mainly optimizes Gaussian-to-tile mapping.

The ablation study clarifies the division of labor between geometry and traversal. DualBox is faster but loses quality, with PSNR dropping to $16\times 16$4, SSIM to $16\times 16$5, and LPIPS worsening to $16\times 16$6. QuadBox without QPass, denoted $16\times 16$7, restores quality but only reaches $16\times 16$8 FPS on the RTX 4090 ablation benchmark, whereas full QuadBox reaches $16\times 16$9 FPS with PSNR $6\sqrt{\lambda_{\max}}$0, SSIM $6\sqrt{\lambda_{\max}}$1, and LPIPS $6\sqrt{\lambda_{\max}}$2 (Li et al., 6 May 2026). The stated interpretation is that the four-box geometry is needed for conservative accuracy, while QPass is needed for the geometry to translate into net speedup.

The reported limitations are also specific. QuadBox assumes a positive definite projected 2D covariance so that $6\sqrt{\lambda_{\max}}$3, is tied to an opacity threshold $6\sqrt{\lambda_{\max}}$4, is tailored to tile-based rasterization with $6\sqrt{\lambda_{\max}}$5 tiles, and leaves some continuous-to-discrete box formulas implicit in the text (Li et al., 6 May 2026). This suggests that the method is highly specialized to the preprocessing stage of tile-based Gaussian splatting renderers.

5. QuadBox as a descriptive label in box-constrained quadratic optimization

In a separate and nonstandard usage, “QuadBox” has been used descriptively for box-constrained quadratic optimization problems. One such formulation is the box-constrained nonconvex quadratic integer program

$6\sqrt{\lambda_{\max}}$6

subject to

$6\sqrt{\lambda_{\max}}$7

which is reformulated exactly as a mixed-binary convex quadratic program $6\sqrt{\lambda_{\max}}$8 by centering variables, separating parity cases, introducing sign and magnitude binaries, and selecting $6\sqrt{\lambda_{\max}}$9 so that $\lambda_{\max}$0 (Xia et al., 2014). The resulting workflow solves an SDP to obtain $\lambda_{\max}$1, then solves the convexified mixed-binary model in IBM ILOG CPLEX 12.6 (Xia et al., 2014).

A related exact continuous encoding for binary optimization replaces

$\lambda_{\max}$2

with

$\lambda_{\max}$3

and, for $\lambda_{\max}$4,

$\lambda_{\max}$5

This yields a box-plus-quadratic equality formulation treated by $\lambda_{\max}$6-box ADMM, with convergence to KKT points for the developed binary quadratic programming specialization (Wu et al., 2016). This suggests a second technical sense in which “QuadBox-style” can denote quadratic structure imposed on a box domain.

For continuous BoxQP, an exact global branch-and-bound method combines SDP bounds, RLT and triangle inequalities, and optimality-based linear cuts that can fix multiple variables at once. On large-dimensional BoxQP instances up to $\lambda_{\max}$7, this “Fix and Bound” framework is reported as state-of-the-art on large-scale BoxQPs (Locatelli et al., 2022). At the convexification level, further strengthening is obtained by extended triangle inequalities for the lifted set $\lambda_{\max}$8, together with conic strengthenings using trilinear lifts and second-order cone constraints (Anstreicher et al., 15 Jan 2025). For sparse box-constrained quadratic programs, a different line of work integrates RLT into SDP relaxations while exploiting a sparsity graph; when the plus-loop subgraph has no connected component of size $\lambda_{\max}$9 or more, the convex hull is SDP-representable, and under additional logarithmic treewidth and degree conditions a polynomial-size SDP formulation exists (Khajavirad, 26 Jan 2026).

These works are conceptually adjacent but terminologically distinct from the 3DGS method. A plausible implication is that “QuadBox” names two different research motifs: a specific geometry-aware box cover for projected Gaussians, and a descriptive family of box-constrained quadratic models and relaxations.

6. Distinction from QBX and other box-local methods

A common source of confusion is the proximity between “QuadBox” and QBX, the latter standing for Quadrature by Expansion. QBX is a high-order method for singular and nearly singular layer-potential evaluation that exploits local smoothness of the induced field, forms off-surface local expansions, and evaluates those expansions at on-surface or near-surface targets (Klöckner et al., 2012). Adaptive QBX automates parameter selection using coefficient error estimates on curved panels (Klinteberg et al., 2017).

In accelerated QBX, the connection to boxes is algorithmic rather than nominative. A fast 2D Laplace QBX algorithm introduces target confinement regions, box ownership of finite-size QBX centers, suspended centers, and refined interaction lists in a quadtree/FMM coupling, providing rigorous acceleration error bounds for the QBX approximation (Wala et al., 2018). A different 2D Helmholtz scheme, QB2X, constructs a representation valid for all targets in an FMM leaf box by combining local Taylor expansions with plane-wave-type terms that explicitly encode boundary nonlinearity (2207.13762).

These methods share box-local data structures and expansion-based evaluation with the 3DGS QuadBox method, but they address a different problem class: singular integral evaluation rather than Gaussian tile culling (Klöckner et al., 2012). They also differ from the optimization usage, where the “box” is the feasible set of a quadratic program rather than a raster tile lattice or an FMM cell (Xia et al., 2014). The term “QuadBox” therefore sits at the intersection of several box-centric technical traditions, but only one of them—the 2026 3DGS rasterization method—uses it as the formal title of a specific algorithm (Li et al., 6 May 2026).