MeshLib vs Manifold: 3D Boolean Operations Benchmark

If you need fast, reliable mesh booleans in an open-source stack, two names come up immediately: MeshLib and Manifold. Manifold is the strongest open-source engine in our 2026 benchmark, which makes this the closest match-up of the whole series. Below we compare the two head-to-head on large scans, degenerate dental meshes, and edge-case geometry, so you can pick the right tool for your pipeline.

What is MeshLib?

MeshLib is an open-source 3D geometry SDK built around a high-performance C++ core, with first-class bindings for Python, C#, C, and JavaScript. Its boolean engine is designed for production workloads: it combines speed with tolerance to imperfect real-world input, automatically converting non-manifold meshes into a processable form. That focus on both throughput and robustness is why MeshLib powers applications from dental CAD to 3D printing.

What is Manifold?

Manifold is an open-source C++ geometry kernel released under the Apache-2.0 license. Its defining idea is in the name: every mesh it produces is guaranteed to be manifold, which makes results safe to feed into downstream operations. Thanks to that guarantee and its strong performance, Manifold has been adopted as the boolean backend by other popular tools — for example, trimesh can delegate its boolean operations to Manifold. In our 2026 benchmark it is the strongest open-source baseline.

MeshLib vs Manifold comparison results

Testing setup — Apple M5 MacBook Air (10-core CPU, 32 GB unified memory), macOS 26. We report the minimum over 10 iterations per operation; mesh I/O is excluded from the timings. To access the input and result meshes used in our tests, visit this link.

Nefertiti Case

This scenario involves large meshes (2M Triangles each) with complex topology, representing a common challenge in 3D boolean operations.

Meshes were slightly shifted.

Meshes were slightly shifted.

Meshes were slightly shifted.

	MeshLib 3.1.3.249	Manifold
Nefertity – Union​	0.09 (0.26)	0.27 (1.0)
Nefertity – Intersection	0.08 (0.23)	0.19 (0.89)
Nefertity – Difference	0.08 (0.23)	0.21 (0.92)

Comments

On clean 2-million-triangle meshes both libraries return correct results — here the comparison is purely about speed. MeshLib completes the union in 0.09 seconds versus 0.27 seconds for Manifold, roughly a 3× advantage that holds for intersection and difference as well. Numbers in braces are one-time geometric precomputations, and even with those included MeshLib stays ahead.

Dental Case

In this case, we simulate dental models (≈500K Triangles) with degeneracies and coinciding surfaces, reflecting real-world scenarios encountered in medical applications.

	MeshLib 3.1.3.249	Manifold
Dental – Union​	0.04 (0.06)	0.05 (0.14)
Dental – Intersection	0.05 (0.08)	0.04 (0.14)
Dental – Difference A-B	0.05 (0.07)	0.05 (0.15)

Comments

The dental scan, with its degenerate triangles and coinciding surfaces, is where most engines break — but not these two. Manifold matches MeshLib almost second-for-second (0.04–0.05 s per operation), and both produce correct output. This case confirms why Manifold is the strongest open-source baseline in our benchmark; MeshLib keeps a small edge once one-time preprocessing is counted.

Simple Objects Case

In this case, we compare how algorithms behave when handling complex geometries.

Boolean Union of meshes, one with a hole aside from the intersection part.

Boolean Union of meshes, one with a hole into the intersection part.

Boolean Union of meshes, one with self-intersections into meshes’ intersection part.

	MeshLib	Manifold
Holed, Not Intersected	Yes	No
Holed Intersected	No*	No
Self- Intersections	No**	Yes

Comments

The qualitative cases reveal the main practical difference. Manifold declines both scenarios that involve meshes with holes: it requires watertight, manifold input by design, while MeshLib processes the hole that stays clear of the intersection zone. Manifold does return a result on self-intersecting input, an operation MeshLib deliberately treats as ill-defined.

* MeshLib does not support the representation of non-manifold meshes and automatically converts them to a manifold form.** The results of such operations are not well-defined, leading to a mesh with numerous inconsistencies, such as self-intersections and degeneracies. In fact, it is not a secret that MeshBoolean operations may eventually fail outright. To explain why this might happen and what to do to avoid such outcomes, we invite you to read this overview of reasons for flawed Mesh Boolean operations.

Why choose MeshLib SDK for 3D boolean operations over Manifold?

Manifold is an excellent free engine — permissively licensed, fast, and robust on scanned data. MeshLib’s case is straightforward: about 3× more throughput on heavy meshes, tolerance to open and non-manifold input that Manifold rejects by design, bindings for C++, Python, C#, C, and JavaScript, and a commercially supported SDK with professional maintenance. If booleans sit on your product’s critical path, that combination is hard to pass up.