Massively Parallel Localized Geometry Processing

This direction is split into other directions: GPU-accelerated spatial processing. Its last version stays readable and citable here.

Version 1 of 159 papers80 conceptsfrozen 2026-10-04

Traditional geometry processing is often bottlenecked by global dependencies. Tasks like mesh simplification, triangulation, and shortest-path calculation historically required a "global view" of the data to ensure topological consistency. However, a growing body of research demonstrates that by decomposing these global problems into independent, localized operations, we can offload the heavy lifting to massively parallel hardware like GPUs and multi-core clusters.

The core intuition is simple: most geometric properties—such as surface normals, curvature, and even connectivity—can be determined by looking only at a point's immediate neighborhood. By treating every vertex, face, or pixel as an independent agent, we can transform sequential algorithms into high-throughput parallel pipelines.

Decomposing Global Constraints into Local Checks

The most significant hurdle in parallelizing geometry is maintaining a valid surface (e.g., a manifold mesh) without a central coordinator. Recent work overcomes this by replacing global optimization with local geometric checks.

In DMesh++, Sanghyun Son and Matheus Gadelha replace expensive global triangulation with a "Minimum-Ball" algorithm. By using nearest-neighbor search structures to perform local checks, they reduce computational complexity from linear to logarithmic per face. This allows meshes with millions of edges to be optimized in parallel. Similarly, Ruoxi Shi introduces PaMO, which identifies independent regions for simultaneous edge collapses. This strategy allows traditionally sequential mesh simplification to run on the GPU, processing millions of faces in seconds.

Geometry as Sparse Linear Algebra

Another powerful mechanism for parallelization is the reformulation of topological changes as algebraic operations. If a geometric process can be expressed as a matrix-vector multiplication, it can leverage decades of optimization in sparse linear algebra.

Daniel Mlakar and colleagues demonstrated this with AlSub, a framework that recasts mesh subdivision—both the vertex smoothing and the topological splitting—into sparse linear algebra. By moving the entire pipeline onto the GPU, they eliminate the "CPU-GPU bounce" that typically slows down dynamic modeling. This algebraic shift is also seen in Polyhedral Complex Extraction, where Arturs Berzins uses tensor operations to extract the linear pieces of ReLU networks up to 20x faster than previous methods.

Lockless Fusion and Asynchronous Propagation

When merging multiple data sources (like several RGB-D cameras) into a single mesh, the standard approach involves "locking" memory to prevent conflicting updates. This creates a massive bottleneck.

To solve this, Siim Meerits and Hideo Saito proposed a lockless approach to mesh zippering. Instead of deleting overlapping triangles (which requires synchronization), they update triangle states in a way that maximizes GPU throughput.

A similar logic applies to finding shortest paths on a mesh. Anirban Mukhopadhyay and his team developed a task-parallel propagation scheme for geodesic distances. By allowing updates to flow through multiple mesh levels before requiring a global synchronization, they achieved speedups of up to 30x over CPU implementations, making it practical to analyze complex brain folding patterns in real-time.

Neural Implicit Acceleration

The latest frontier in this direction is the use of neural networks as "implicit" geometric solvers. Rather than iterating through a mesh to find a distance, we can train a network to "know" the geometry.

Qijian Zhang and Junhui Hou introduced NeuroGF, which encodes a shape's intrinsic geometry into a compact neural representation. Because neural inference is natively parallel on GPUs, this allows for sub-millisecond geodesic queries—orders of magnitude faster than traditional computational geometry.

Why It Works: The Locality Principle

The success of these methods rests on the Locality Principle: global structure emerges from local interactions. Whether it is Yinlong Liu treating data correspondences as independent geometric constraints for rotation estimation, or Wai Ho Li performing independent surface fitting for every pixel in a range image, the pattern is the same. By breaking the "global" requirement, we unlock the ability to process 3D data at the speed of 2D images, enabling real-time 3D intelligence in everything from nano-drones to surgical simulations.

Papers in this version

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_massively_parallel_localized_geometry_pr_6a05a1e3,
  title = {Massively Parallel Localized Geometry Processing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/massively-parallel-localized-geometry-processing/rdr_6a05a1e3a0da49ef8f8ceaacefe570b3},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-22},
}

This exact version (version 1, frozen text):

@misc{lacuna_massively_parallel_localized_geometry_pr_6a05a1e3_v1,
  title = {Massively Parallel Localized Geometry Processing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/massively-parallel-localized-geometry-processing/rdr_6a05a1e3a0da49ef8f8ceaacefe570b3/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-22},
}