We introduce two fundamental advances to the NanoVDB data structure: dynamic GPU-native topological updates, and a voxel-sequential access paradigm that dramatically accelerates point-wise and stencil-based operators on sparse grids. NanoVDB's linearized memory layout has delivered strong GPU performance, and the Index-Grid concept introduced in the fVDB framework [Williams et al 2024] provided topology/data separation and optimal compactness of storage in sparse machine learning workloads. However, all these prior iterations of NanoVDB assume a static topology that has precluded use of this data structure in simulation and dynamic geometric processes. We eliminate this limitation by introducing a suite of dynamic topology operators -- morphological dilation, grid merging, pruning, and cross-resolution coarsening and refinement. These operators use bit-parallel algorithms to reconstruct grids containing hundreds of millions of voxels in just a few milliseconds. We also introduce a voxel-sequential access paradigm and data structure for GPU kernels operating on sparse data. We stream active voxels as a flat linear sequence, minimizing or eliminating the need for tree traversal in the process. This achieves compute density and regularity that allow even complex stencil-based operators to approach peak memory bandwidth, with minimal storage overhead. Together, these contributions remove the read-only constraint from NanoVDB, establishing it as a high-performance primary representation for dynamic GPU simulation and geometry manipulation. We evaluate the efficacy of our newly introduced operators in benchmarks sourced from applications such as 3D reconstruction, fluid simulation, and large-scale mesh voxelization.
Figures & tables
Figure 1. We demonstrate our enhancements to NanoVDB in three diverse applications that rely on dynamic sparse grids. From left to right: Large-Scale Voxelization of a 2.8M-triangle hairball mesh ( McGuire, 2017 ) (left hemisphere in green), our MeshToGrid implementation generates a sparse index grid with 9.88 B active voxels and UDF values stored in a sidecar (right hemisphere in blue) in 3.24 s; Fluid Simulation of fire using the ghost fluid method ( Nguyen et al., 2002 ; Nguyen et al., 2001 ; Hong et al., 2007 ) to track the combustion flame front using a truncated signed distance field; a Reality Capture processing pipeline which fuses a TSDF surface mesh, on the left, and derives a Euclidean signed distance field (ESDF), on the right, to facilitate collision checking and path planning from an input LiDAR sweep or a sequence of depth images. Hardware details in Appendix A .
Figure 2. Feature comparison of VDB iterations Our proposed enhancements combine the highly compact storage of NanoVDB Index-Grids, the GPU-compatibility of all NanoVDB iterations, support for GPU-native topology modification operations, and a new voxel-sequential access paradigm
Figure 3. Branching factor and voxel span for each level of the NanoVDB tree ( LOG2DIM=5,4,3 ). Each node represents a span of 23⋅LOG2DIM voxels, at the leaf level. The root holds an unbounded, hash-keyed list of nTiles tiles.
Figure 4. Process pipeline of topological operators. For each step we indicate whether it is operation-specific (outlined in green) or generic (outlined in grey) across all operations. [ Step 1 ; op-specific] A candidate set of root tiles (each spanning 40963 voxels) is introduced to conservatively cover the resulting topology. [ Step 2 ; generic] For each candidate root tile, we allocate a dense bit map (representing the upper tree node) encoding the presence of each lower tree node (spanning 1283 voxels each; top row) and each leaf node ( 83 voxels each; bottom row). [ Step 3 ; op-specific] Depending on the operation, we mark in parallel all lower/leaf nodes that must be materialized, using the previously allocated bitmap scratchpads. [ Step 4 ; generic] We enumerate all necessary tree nodes (pruning empty ones) and monolithically allocate storage for the resulting Index-Grid. [ Step 5 ; generic] The connectivity of the tree is rebuilt in parallel from the lower/leaf bitmap scratchpads. [ Step 6 ; op-specific] The previous stage leaves a properly allocated sparse bitmap that tightly covers the active voxel set, but with no voxels yet marked active; we populate the active voxel flags in an operation-dependent way to complete the operation. [ Step 7 ; generic (not pictured)] A final bottom-up sweep updates any remaining metadata (voxel offsets, bounding boxes, checksum etc).
Figure 5. Topology Enumeration via Linearized Scratchpads. To facilitate parallel reconstruction, we map the tree onto a conceptually dense intermediate representation of serialized bit-mask arrays. Each candidate root tile is associated with one Mask<5> in the upperMasks array and a block of 323 Mask<4> entries in the lowerMasks array. This layout resolves any coordinate to a specific bit via O(1) spatial-to-index mapping, capturing the exact occupancy of the next epoch before the final NanoVDB buffer is materialized.
Figure 6. Leaf-major to tap-major transposition. Per-leaf neighbor-influence stencils (left) are reorganized into one bitmask per stencil offset (right), enabling warp-collective processing.
Figure 7. VBM metadata for a W=32 block. The 32 active voxels at sequential indices 64…95 (orange) span four leaf nodes of the underlying Index-Grid; a few active voxels with indices outside this block appear in cyan. The metadata for the block reduces to a single firstLeafID=100 (the leaf containing the first voxel in the block) plus a 32-bit jumpMap whose set bits at positions 10 , 19 , and 28 mark the intra-block offsets at which each subsequent leaf begins.
Figure 8
Figure 8. Starting from an input LiDAR sweep or a sequence of depth images, we fuse a TSDF surface mesh and subsequently derive a Euclidean signed distance field (ESDF) to facilitate collision checking and path planning. Mai City synthetic LiDAR (top row, voxel size 0.33 m) and Replica office0 RGB-D (bottom row, voxel size 0.05 m), with (a) input sensor sweeps coloured by time (Mai City) and by source-pixel RGB (Replica), (b) fused TSDF mesh with the underlying voxel grid drawn as a faint wireframe scaffold, and (c) the mesh rendered translucently over a horizontal slice of the derived ESDF (turbo colormap, red = far from any obstacle).
Workload
nvblox
Open3D
Ours
Voxels
GB
Mai City 700 f LiDAR TSDF
10 cm
n/a
1.25 cm
938.7 M
37.1
Mai City 700 f TSDF → ESDF
10 cm
n/a
3 cm
1.28 B
30.6
Replica 8 × 2000 f TSDF
10 mm
5 mm †
3 mm
109 M
10.3
Replica 8 × 2000 f ESDF
10 mm
n/a
3 mm
438 M
10.3
KITTI seq 02 4661 f TSDF
20 cm
n/a
10 cm
427 M
19.8
KITTI seq 00 100 f ESDF
5 cm
n/a
2 cm
1.67 B
38.6
Table 1. Voxel-size scale ceiling on a single 48 GB RTX 6000 Ada GPU. Finest voxel each system completes; ours reaches the listed active voxel count and peak GPU memory at its finest voxel. Open3D has no LiDAR TSDF and no ESDF integrator. † Open3D succeeds on 6/8 Replica scenes at 5 mm and crashes ( illegal memory access ) at 3 mm on all eight; we list 5 mm as its finest universal ceiling. Per-voxel-size timing tables and the full nvblox-config are in Appendix B .
Figure 9. WENO5 narrow-band reinitialization throughput for two dispatch policies—VBM (voxel-sequential, one thread per active voxel) and the accessor baseline (tree traversal, one thread per leaf slot)—against mean leaf occupancy ≡activeVoxels/(nLeaves⋅512) within active 8³ leaf tiles, decreasing left to right. Timing is per-call time of one inner WENO5 iteration. VBM holds near 20 Gvoxel-updates/s, its launch sized by the active set alone, while the accessor falls from 14.0 to 9.8 as more threads land on inactive slots; VBM speedup reaches 1.98×, rising as occupancy drops. Marker color denotes rebuild dilation width. Hardware details in Appendix A .
Figure 10. Left: Flame interface narrow-band. Right: Dynamic fire sim
Figure 11. Dilate (26-connected) and Prune ( ∣ϕ∣≤1 ) against the best prior NanoVDB route—rebuild from active coordinates through voxelsToGrid —and OpenVDB’s TBB-parallel host implementation. Both operators run on identical input topologies: a flame front level set at 12 resolutions, 128×192×128 to 1792×2688×1792 , 0.98 M to 567 M active voxels. Axes are logarithmic, so the margins are wider than they look. At the largest input dilate is 183× faster than the rebuild and 76× faster than the host, in 139× less device memory (356 MiB against 48.2 GiB); prune is 12.1× and 10.6× faster, in 7× less (2.49 GiB against 16.9 GiB). (a), (b): median wall time per call. (c), (d): peak device memory (the omitted host series has no device allocation).
Figure 12. Large-scale NanoVDB voxelization of a 2.8M-triangle hairball mesh ( McGuire, 2017 ) . At voxel size 0.001 and narrow-band half-width 2 , our MeshToGrid implementation generates a sparse index grid with 9.88 B active voxels and UDF values stored in a sidecar in 3.24 s; the result is rendered directly with NanoVDB’s hierarchical digital differential analyzer (HDDA). Hardware details in Appendix A .
Appendix figures & tables7 assets
Supplementary material from the paper’s appendix.
Appendix
Figure 13. Qualitative comparison on three of the reality-capture workloads. Top: Replica office0 depth-TSDF mesh at 5 mm (500 frames, ceiling clipped); nvblox’s 83 -block padding shows as thicker walls. Middle: Mai City seq 00 LiDAR-TSDF mesh at 10 cm on a 60 × 40 m chunk; ours and VDBFusion show the cleanest sidewalk and lamp-post detail. Bottom: Replica office0 ESDF horizontal slice at z=−0.4 m (5 mm voxels, R=1 m) with iso-contours at 0.05 / 0.10 / 0.25 / 0.50 m; the zoom inset (red box) highlights the resolution gap.
Workload
nvblox @ (60 m, 3× )
nvblox @ defaults (10 m, 4× )
Ours @ defaults-matched
Mai City TSDF (700 f)
OOM at 5 cm
OOM at 5 cm *
1 cm (1.20 B voxels, 45.9 GB)
Mai City ESDF (700 f)
OOM at 5 cm
OOM at 5 cm *
2 cm (30.0 GB)
KITTI TSDF (seqs 00/02/05)
OOM at 10 cm (all)
seq 02: OOM at 10 cm * ; seqs 00/05: OOM at 5 cm †
5 cm / 5 cm / 3 cm
KITTI ESDF (100 f, 3 seqs)
OOM at 3 cm
OOM at 2 cm †
1 cm (28–32 GB)
Appendix
Table 2. Sensitivity of scaling results to chosen values of (LiDAR max integration distance, voxel truncation)
Ours
nvblox
VDBFusion
Dataset / seq
Voxel
ms/f
GB
ms/f
GB
ms/f
Mai City 700 f
40 cm
3.44
0.17
19.52
0.93
130.04
20 cm
3.80
0.29
19.06
1.14
240.02
10 cm
5.07
0.77
18.03
1.98
474.15
5 cm
11.22
4.47
OOM
—
965.28
3 cm
19.98
9.30
—
—
1666.65
Appendix
Table 3. LiDAR TSDF on Mai City synthetic Velodyne sweeps and KITTI Odometry real-sensor LiDAR. Per-frame integration time and peak GPU memory (CPU peak host RSS for VDBFusion); faster GPU time per row in bold. nvblox is configured with lidar_projective_integrator_max_integration_distance_m = 60 m and projective_integrator_truncation_distance_vox = 3.0 to match our 60 m-range LiDAR fusion and our 3 × truncation; nvblox’s upstream defaults of 10 m and 4.0 × would clip its input to a ± 10 m strip and widen its band by 33%. nvblox first OOMs at 5 cm on Mai City and at 10 cm on every KITTI sequence we tested. Ours scales through 1.25 cm on Mai City at 37.1 GB / 938.7 M voxels and OOMs at 1.0 cm; KITTI seq 00 and seq 02 OOM at 5 cm while the smaller seq 05 reaches 5 cm at 33.3 GB on 726 M voxels, and all three KITTI sequences OOM at 3 cm. VDBFusion is 38–94 × slower than ours on Mai City across 40–2 cm and 22–41 × slower on KITTI across 40–10 cm; on KITTI 5 cm VDBFusion runs cleanly on its CPU-side RAM where ours OOMs on the GPU, and on the seq 05 / 5 cm cell where both run, VDBFusion is 27 × slower. We did not run VDBFusion at KITTI 3 cm: extrapolating from the seq 02 / 5 cm cell’s 96 GB peak host RSS, the 3 cm runs would exceed available system memory.
Voxel
Ours (ms/f)
nvblox (ms/f)
Speedup
20 cm
5.8
20.1
3.5 ×
10 cm
7.7
21.6
2.8 ×
5 cm
15.6
53.2
3.4 ×
3 cm
27.1
146.8
5.4 ×
2 cm
41.7
351.7
8.4 ×
1.5 cm
59.1
678.6
11.5 ×
Appendix
Table 4. KITTI Odometry occupancy mapping. Per-voxel-size means over the three sequences {00, 02, 05}. nvblox is configured to match our 60 m LiDAR range and 3 × truncation (its defaults of 10 m and 4.0 × clip the input to a thin strip and widen the band). nvblox first OOMs at 1 cm on every sequence (its hash allocator’s resize step requests a single contiguous block of ∼ 2 M slot entries that the 48 GB device can no longer supply); ours scales to 2.35 B active voxels in 44.1 GB at seq 05 / 5 mm. The split rows show finer voxels where ours continues running past nvblox’s ceiling.
Figure 14. The TSDF + ESDF pipeline pushed to the highest resolution each system can run on a single 48 GB GPU. 5 cm is roughly the finest setting at which the block-hash TSDF systems we compare against (nvblox, Open3D, VDBFusion) remain stable on Replica scenes; NanoVDB’s index-grid lets us reach 4 mm ( 12.5× finer), at which point the mesh resolves individual chair backs and the ESDF iso-contours (drawn every 5 cm of distance, in white) become smooth and dense rather than blocky and pixelated.
Ours
nvblox
Open3D CUDA
Dataset
Voxel
TSDF
ESDF
TSDF
ESDF
TSDF
(ms/f)
(ms)
(ms/f)
(ms)
(ms/f)
Replica 8×2000 f
20 mm
2.64
38.46
0.81
75.60
0.25
10 mm
5.23
125.83
6.43
529.54
0.26
5 mm
19.05
617.71
OOM
OOM
0.42 ‡
4 mm
28.06
926.85
OOM
OOM
0.41 ‡
Appendix
Table 5. Depth TSDF and ESDF on Replica (8 scenes × 2000 frames; mean) and 7-Scenes chess (3000 frames). Per-frame TSDF time and cold post-TSDF ESDF sweep time; fastest TSDF / ESDF per row in bold. Open3D and nvblox have no ESDF integrator on 7-Scenes in our setup; we ran nvblox only on Replica. nvblox is configured with projective_integrator_max_integration_distance_m = 8 m to match the depth ranges in Replica’s NICE-SLAM rendering, slightly above its upstream default of 7 m. nvblox fails with allocator OOM during its hash-resize step from Replica 5 mm onward; Open3D fails with illegal memory access from its CUDA integrator on a staircase — 8/8 Replica scenes succeed at 10 mm and coarser, 6/8 at 5 mm, 2/8 at 4 mm (office0 and office1 only), 0/8 at 3 mm. Ours scales monotonically through Replica 3 mm and 7-Scenes 3 mm with no per-frame creep across the 3000-frame chess trajectory (peak 10.6 GB at chess 3 mm).
Ours
nvblox
Dataset / seq
Voxel
ESDF voxels
Cold (ms)
Warm ( μ s)
Peak (GB)
Cold (ms)
Peak (GB)
Mai City 700 f
20 cm
38.7 M
129.0
25 μ s
2.04
174.5
1.67
10 cm
129.4 M
416.4
32 μ s
4.17
740.4
2.50
5 cm
459.2 M
1628.0
59 μ s
11.82
OOM
—
3 cm
1.28 B
5567.9
266 μ s
30.59
OOM
—
2 cm
OOM
—
—
—
OOM
—
Appendix
Table 6. LiDAR ESDF on Mai City over the full 700-frame trajectory and on KITTI Odometry over a 100-frame TSDF prefix per sequence. Active voxel count, cold ESDF time, dirty-mask idempotent time, and peak GPU memory. nvblox is configured to match our 60 m LiDAR range and 3 × truncation. nvblox first OOMs at Mai City 5 cm (TSDF substrate fails) and at KITTI seq 02 / 5 cm; on KITTI seq 00 and seq 05 nvblox runs at 5 cm but OOMs at 3 cm. Ours scales to 1.67 B active voxels at 38.6 GB on KITTI seq 00 / 2 cm and 1.28 B voxels at 30.6 GB on Mai City 700-frame / 3 cm.