Benchmarks

ordito runs on the GPU, and the libraries most mesh-processing code reaches for do not. This page compares the two on the same inputs: ordito on CUDA against eleven reference libraries — trimesh, libigl, Open3D, SciPy, NumPy, potpourri3d (geometry-central), MeshLab (through PyMeshLab), PyVista (VTK), MeshLib, PyMeshFix and PyTorch3D, the one other library with GPU kernels.

Every comparison times the same quantity on both sides, and the correctness suite checks that the two answers agree. A time is the median of repeated calls from Python, including the wait for the GPU to finish, so it is what a caller measures. The inputs are real 3D scans from the Stanford repository (from 16 thousand to 28 million triangles) and synthetic meshes that each stress one cost driver: many components, long boundaries, needle triangles, high valence.

Measured on GPU: NVIDIA GeForce RTX 5090 · CPU: Intel Xeon w7-2495X

Summary

How long each library takes relative to ordito, over every function both implement: ordito is 1x, and a library at 30x takes thirty times as long. Each function counts once: its ratio is first averaged over the inputs it was measured on, then the functions are averaged. Both averages are geometric means, the usual way to combine ratios: a 10x win and a 10x loss cancel out.

Libraries are compared on different sets of functions, so each bar measures one library against ordito, not the libraries against each other. The libraries closest to ordito are the ones whose functions are mostly fast, compiled code on small inputs; the gaps grow with the input.

By module

ordito's speedup per module, against the fastest library measured on each input — the toughest comparison available for each function. Each module has its own page, with a chart for every function.

Highlights

The comparisons with the widest field of libraries. Each chart shows one input, with ordito at 1x and every other library's time relative to it; each module's page has every function and every input.

Signed distance to a mesh

Signed distance from a point set to a triangle mesh, the widest field among the spatial queries.

Nearest neighbours, k = 7

Seven nearest neighbours of every query point, against CPU trees and PyTorch3D's GPU kernel.

Nearest neighbour, k = 1

The same query with a single neighbour. Every library with a tree, ordito included, builds it over the cloud inside the timed call, and the build is most of the work: about two thirds of ordito's time.

Quadric decimation

Edge-collapse simplification under the quadric error metric, against five independent decimators.

Minimal oriented bounding box

Every library here searches for the minimum-volume box, not the PCA box, so the bars compare the same optimisation.

Convex hull

Blue-noise sampling

Poisson-disk sampling of a surface: four different algorithms for the same distribution.

Geodesic distance

Geodesic distance from a source vertex by the heat method, including building the solver.

Repair: merging duplicate vertices

Repair: consistent winding

Re-orienting every face to agree with its neighbours, a whole-mesh propagation.

Connected components

Unique edges

The undirected edge list, the first step of most topology code.

Taubin smoothing

Voxelizing a mesh

Boundary edges, a loss

Listing the edges on a mesh's boundary is a single pass that serial C++ finishes in less time than a GPU round trip takes. ordito loses this one, as it does most operations whose whole cost is a few tens of microseconds; the module pages show the rest.

Reproduce

The suite lives in benchmarks/; its README describes the inputs and every comparison in detail. It needs Linux, an NVIDIA GPU and the CUDA toolkit:

git clone https://github.com/lucagrementieri/ordito
cd ordito
uv sync --group bench --no-install-package pytorch3d
uv sync --group bench

mkdir -p results
for f in benchmarks/test_*.py; do
  uv run pytest "$f" --device=cuda --bench-all-libs \
    --benchmark-json="results/$(basename "$f" .py).json" -q
done

uv run python -m benchmarks.tools.render_docs results

The last command redraws every chart on this page and on the module pages from your own run. Absolute times depend on the hardware; the ratios are what carries over.

A ratio holds only for the library, the input and the hardware it was measured on: besides its size, a mesh's number of components, boundary length and triangle shapes move it. A few functions have little parallel work at realistic sizes (a sequential pass over one small boundary loop), and a fast single-threaded C++ implementation beats them; the module pages show those cases beside the others.