CuRast: CUDA Rasterization for Dense Geometry

• CuRast is a CUDA-based software framework that uses a multi-stage compute-driven pipeline to rasterize dense triangle clouds in real time.
• It omits conventional spatial acceleration structures and leverages targeted atomic operations along with on-the-fly geometry compression to maximize throughput.
• Performance benchmarks show 2×–18× speedups over traditional Vulkan pipelines for massive, opaque geometric datasets from photogrammetry and 3D scanning.

CuRast is a CUDA-based software rasterization framework designed for efficient real-time rendering of scenes containing hundreds of millions to billions of triangles, with a specific focus on dense, near-pixel-sized geometry typical of outputs from photogrammetry and 3D reconstruction. Unlike traditional GPU rasterization pipelines, CuRast omits precomputed spatial acceleration structures, instead leveraging a multi-stage compute-driven pipeline and targeted atomic operations to maximize throughput on massive unstructured triangle clouds (Schütz et al., 23 Apr 2026).

1. Motivation and Context

Contemporary hardware-based rasterizers—optimized for versatility and broad feature sets—impose non-trivial overhead for rendering features (such as blending, transparency, and rich G-Buffers) that are unnecessary for large clouds of small, opaque triangles. Workflows in photogrammetry, 3D scanning, and digital sculpting now routinely produce mesh assets with hundreds of millions to billions of triangles, most of which are small enough to be near or below pixel size at render resolution. This granularity exacerbates the inefficiency of driver-managed acceleration structures (e.g., BVHs, cluster hierarchies), especially when frequent mesh updates necessitate costly rebuild steps.

Prior research (e.g., FreePipe, Dreams on PS4, Nanite) established that small triangle rasterization, when performed in compute via atomicMin synchronization on a flat yet tightly packed depth-payload buffer, outperforms traditional fixed-function hardware pipelines for dense geometry. CuRast extends this paradigm, explicitly targeting real-time software rasterization for dense triangle clouds without acceleration structures, while eschewing auxiliary features such as transparency (Schütz et al., 23 Apr 2026).

2. Three-Stage Rasterization Pipeline Architecture

CuRast segments the input triangle set based on triangle size and processes each subset with an algorithm selected for optimal compute and memory efficiency. The pipeline comprises three distinct stages:

• Stage 1: Single-Thread Rasterization (Small Triangles) Each input triangle is mapped to a dedicated CUDA thread. After vertex transformation and bounding box (BBox) computation, triangles whose screen-space BBox covers ≤128 pixels and do not intersect the near plane are immediately rasterized. Rasterization proceeds by iterating inside the BBox: for each covered pixel, barycentric coordinates are computed, depth is interpolated using the inverse depth trick ($1/z$), and the result is packed into a 64-bit word (28 bits for depth, 36 bits for triangle ID). Pixel coverage is resolved with a single atomicMin operation per candidate pixel, ensuring that only the closest fragment wins.
• Stage 2: Warp-Based Rasterization (Medium Triangles) Medium-sized triangles (BBox ≤4096 pixels or frustum-intersecting) are processed by 32-thread CUDA warps. The warp either directly rasterizes the triangle 1D-parallel across covered pixels using atomicMin, or—if the triangle is still too large—subdivides the BBox into 64×64 pixel tiles for further processing.
• Stage 3: Block-Based Rasterization (Large Triangles) For large tiles or triangles with challenging projections, a 64-thread CUDA block is launched per tile. Each thread traverses a subset of pixels within the tile in raster order, performing conservative ray intersection tests (to avoid near-plane clipping artifacts), depth interpolation, and final atomicMin writes.

After rasterization, a deferred per-pixel resolve step interprets the depth buffer and triangle IDs to reconstruct barycentric coordinates and perform shading, including mip-level estimation by local ray intersection and UV footprint computation (Schütz et al., 23 Apr 2026).

3. Data Representation and Compression

CuRast implements on-the-fly geometry compression to reduce memory bandwidth consumption, particularly when rendering repeated instanced geometry:

• Index Compression: For each mesh subrange, the maximum index span is computed, and index values are re-encoded with only the minimum required bits ($\lceil \log_2(\text{span}) \rceil$, 8–32 bits).
• Position Quantization: Vertex positions are quantized to 16 bits within the mesh’s bounding box.
• Path Separation: Separate CUDA kernels are compiled for compressed and uncompressed data to eliminate runtime branching.

Instancing is handled in Stage 1 by looping over each mesh instance, directly permuting the model matrix. Stages 2 and 3 process per-instance triangles as generated during Stage 1 (Schütz et al., 23 Apr 2026).

4. Mathematical Formulation

Key computational steps are specified mathematically:

• Perspective Projection:

$f = 1 / \tan(\mathrm{fovy}/2)$, with $P = [f/\mathrm{aspect},\ f,\ -1]$; $$\mathrm{NDC}_{x,y} = (\mathrm{view}_{x,y} \cdot P_{x,y}) / \mathrm{view}_z$$, $\mathrm{NDC}_z = \mathrm{view}_z$ (linear depth).

• Depth Interpolation (via $1/z$ trick):

$$\mathrm{depthI} = v \cdot (1/z_0) + s \cdot (1/z_1) + t \cdot (1/z_2)$$

$\mathrm{depth} = 1.0 / \mathrm{depthI}$

• Index Bit Requirement:

$$\text{bitsPerIndex} = \lceil \log_2 (\text{maxIndex} - \text{minIndex}) \rceil$$

AtomicMin is used for synchronization during fragment writes: $\lceil \log_2(\text{span}) \rceil$0 These formulas govern the triangle transformation, rasterization, and depth comparison process (Schütz et al., 23 Apr 2026).

5. Performance Analysis

Performance benchmarks on NVIDIA RTX 4070, 4090, and 5090 were conducted for input scenes ranging from 197,000 triangles (Sponza) to 13.6 billion triangles (Zorah):

• Dense Unique Meshes: CuRast outperforms Vulkan by 2–5× (e.g., 400M triangle Venice: CuRast 6.9 ms, Vulkan PIP 37 ms; 28M triangle Komainu Kobe: CuRast 0.865 ms, Vulkan ID 2.79 ms).
• Large Instanced Scenes: Speedups grow to 12× or beyond (3B triangle Lantern Instanced: CuRast 17 ms, Vulkan ID 142 ms; Zorah, 13.6B reference, ∼18× speedup).
• Low-Poly Scenes: On scenes with many small meshes (e.g., Sponza, 197,000 triangles), Vulkan is 7–13× faster.

A summary of results is provided in the table below:

Scene	Triangles	CuRast Time	Vulkan VK-ID	Relative Speed
Sponza	197 K			Vulkan 7–13× faster
Lantern (unique)	1 M	0.21 ms	0.056 ms	CuRast 4× slower
Komainu Kobe	28 M	0.865 ms	2.79 ms	CuRast 3× faster
Venice (compressed)	400 M	6.9 ms	37 ms (PIP)	CuRast 5–6× faster
Zorah	13.6 B (visible)	69 ms	1250 ms (PIP)	CuRast ∼18× faster

These results confirm substantial advantages for massive, dense triangle clouds, but a strong disadvantage compared to hardware pipelines for fine-grained low-poly scene composition (Schütz et al., 23 Apr 2026).

6. Limitations and Application Scope

CuRast is optimized for dense, opaque geometry—scenes with few mesh nodes but extremely high triangle counts, as commonly generated in photogrammetry. Current support is limited to opaque shading; blending and transparency are not implemented. The design does not scale efficiently to scenes comprising tens of thousands of low-poly meshes, and Vulkan remains significantly faster in such regimes. Large triangles are only handled in a robust but not highly optimized fashion, with the bulk of compute resources expended in Stage 1 for small triangles (Schütz et al., 23 Apr 2026).

7. Prospects for Extension

Future work for CuRast centers on:

1. Scaling mesh node handling for scenes with tens of thousands of meshes—necessary for integration into complex, game-scale applications.
2. Incorporating hierarchical and clustered LOD management (e.g., Nanite-style cluster streaming, meshoptimizer clusters) to avoid brute-force rendering of distant or very large geometry.
3. Adding a dedicated transparency and blending stage, decoupled from the opaque rasterization path to preserve performance.
4. Exploring optimizations in fragment traversal (non-BBox traversal), vertex reuse, and further compression techniques (e.g., targeting as low as 9 bits/triangle).

A plausible implication is that CuRast’s design is best suited for dense 3D reconstructions and offline or interactive visualization demands common in scientific, industrial, and digital heritage domains, rather than feature-rich interactive or cinematic rendering (Schütz et al., 23 Apr 2026).