Published: 2024-04-27
Updated: 2026-08-27
Dmitry Lambin
Comparing 3D Boolean Libraries — 2026 Benchmark
The results below show MeshLib performance compared to other 3D boolean libraries.
3D boolean operations — union, intersection, and difference of triangle meshes — sit at the core of CAD, 3D printing, medical-device design, and AEC pipelines. They sound trivial (combine two meshes) but in production they are where pipelines fail: non-manifold inputs, self-intersections, near-coplanar faces, inconsistent winding, and degenerate triangles all break naive implementations.
This article summarises the headline results of our independent 2026 benchmark of nine mesh boolean libraries. The full per-library, per-case, per-iteration data is in the downloadable PDF report below.
Summary
- On the 2M-triangle Nefertiti dataset (Union), MeshLib computes the boolean in 0.093 s — ≈3× faster than Manifold (the strongest OSS baseline) and ≈150× faster than Blender (via trimesh).
- On a 280K-triangle dental scan with degenerate geometry, CGAL hangs and MCut fails, while MeshLib finishes in 44 ms.
- MeshLib 3.1.3 is markedly faster than the 3.0.6 build used in our 2024 benchmark — the result of continued work in the boolean core.
- All inputs and runners are open-source. Full per-library breakdown is in the PDF report below.
Popular open-source Mesh boolean libraries
MeshLib | MCut | Manifold | CinoLib + RobustMesh | CGAL | Rhino 3D | Libigl | Trimesh-Manifold | Trimesh-Blender | |
|---|---|---|---|---|---|---|---|---|---|
License | Licensing options | LGPL 3/Paid support | Apache 2.0 | MIT | Open-Source / Commercial | Commercial, with three models | GPL 3, MPL 2 | MIT · Manifold Apache-2.0 | MIT · Blender GPL-2.0+ |
We selected nine libraries by popularity, industry adoption, and ease of independent reproduction. Each is listed with the exact version we tested, the current license, and the date of the most recent release as of June 27, 2026.
Methodology in brief. Primary machine: Apple M5 MacBook Air (10-core CPU, 32 GB unified memory), macOS 26. All numbers on this page come from this machine; a Windows x86 cross-run is in the report. We report min over 10 iterations per (library × case × operation); mesh I/O is excluded from the timer; default threading — no OMP_NUM_THREADS overrides — matches how libraries are used in practice. Bracketed (N) values in the PDF tables include one-time geometric pre-computation (e.g., AABB build, Manifold conversion). Full install notes per library and raw timing.json per iteration are in the PDF report.
License-sensitive notes. CGAL’s Polygon Mesh Processing module is GPL — using it in a closed-source product requires a commercial license from GeometryFactory. Trimesh-Blender invokes Blender’s bpy module under GPL-2.0+. MCut is now dual-licensed LGPL-3.0 / GPL-3.0 with a commercial alternative. Manifold (Apache-2.0) and MeshLib’s commercial license are the two licensing-friendly options for proprietary products at production scale.
Input meshes, per-library runners, screenshots, and raw outputs (scripts, timing JSON, result meshes) are published in our shared cloud workspace — SharePoint link. The benchmark source code will be opened publicly later.
Two algorithmic schools of mesh booleans
Before the results, a quick framing of why libraries behave so differently. Modern mesh-boolean implementations fall into two camps.
Exact-arithmetic school
CGAL, CinoLib (indirect predicates). Rational arithmetic or hybrid floating-point + symbolic perturbation every geometric predicate is provably correct. The cost: 10×–100× slower, and combinatorial blow-up on many near-coplanar faces (why CGAL hangs on dental scans).
Robust floating-point school
MeshLib, Manifold, MCut. Stay in IEEE-754 but invest in carefully-built robust predicates (adaptive precision, SoS tie-breaking). The result: 10×–100× faster, tolerant of edge cases, at the price of custom, hand-engineered predicate code.
libigl sits between the two — it borrows CGAL’s exact kernel, inheriting both the correctness guarantees and the speed penalty. Trimesh-Blender and Rhino 3D are application-level kernels tuned over decades for content-creation robustness, not throughput.
3D Boolean Comparison Results
Nefertiti Case
This scenario involves large meshes (2M Triangles each) with complex topology, representing a common challenge in 3D boolean operations.
Union
Meshes were slightly shifted.
Intersection
Meshes were slightly shifted.
Difference A-B
Meshes were slightly shifted.
MeshLib 3.1.3.249 | MCut | Manifold | CinoLib + RobustMesh | CGAL | Rhino 3D | Libigl | Trimesh-Manifold | Trimesh-Blender | |
|---|---|---|---|---|---|---|---|---|---|
Nefertity – Union | 0.09 (0.26) | 83 | 0.27 (1.0) | 6.6 | 4.4 | 27 | 21 | 1.0 | 14 |
Nefertity – Intersection | 0.08 (0.23) | 83 | 0.19 (0.89) | 7.1 | 3.6 | 27 | 21 | 0.94 | 13 |
Nefertity – Difference | 0.08 (0.23) | 83 | 0.21 (0.92) | 7.5 | 3.8 | 28 | 23 | 1.0 | 14 |
Annotations
- All the results are in Seconds.
- Red numbers: Indicate that the operation was performed, but the result is incorrect.
- (Numbers in braces): Denote necessary geometric computations that should be performed once.
- N/D: Stands for “No Data,” meaning it was not measured.
Takeaway. On clean 2M-triangle geometry MeshLib is the fastest by a wide margin — ≈0.09 s per operation, about 3× ahead of Manifold (the strongest OSS engine) and 40–150× ahead of the exact-arithmetic and application-level engines. Every library returns a correct result here; the separation is purely throughput.
Dental Case
In this case, we simulate dental models (≈500K Triangles) with degeneracies and coinciding surfaces, reflecting real-world scenarios encountered in medical applications.
Union
Intersection
Difference A-B
MeshLib 3.1.3.249 | MCut | Manifold | CinoLib + RobustMesh | CGAL | Rhino 3D | Libigl | Trimesh-Manifold | Trimesh-Blender | |
|---|---|---|---|---|---|---|---|---|---|
Dental – Union | 0.04 (0.06) | Fail | 0.05 (0.14) | 1.0 | Fail | 7.8 | 4.3 | 0.15 | 4.1 |
Dental – Intersection | 0.05 (0.08) | Fail | 0.04 (0.14) | 1.0 | Hang | 7.8 | 4.3 | 0.15 | 3.9 |
Dental – Difference A-B | 0.05 (0.07) | Fail | 0.05 (0.15) | 0.96 | Hang | 7.8 | 4.4 | 0.15 | 4.2 |
Annotations
- All the results are in Seconds.
- Red numbers: Indicate that the operation was performed, but the result is incorrect.
- (Numbers in braces): Denote necessary geometric computations that should be performed once.
- Fail: Indicates that the library rejected to process the operation.
Takeaway. The dental scan is where robustness shows: degenerate triangles and coinciding surfaces make MCut fail and CGAL hang outright, while MeshLib stays correct and finishes in ≈0.045 s — roughly 20–180× faster than the engines that survive the input at all.
Simple Objects Case
In this case, we compare how algorithms behave when handling complex geometries.
Holed, Not Intersected
Boolean Union of meshes, one with a hole aside from the intersection part.
Holed Intersected
Self-Intersections
MeshLib | MCut | Manifold | CinoLib + RobustMesh | CGAL | Rhino 3D | Libigl | Trimesh-Manifold | Trimesh-Blender | |
|---|---|---|---|---|---|---|---|---|---|
Holed, Not Intersected | Yes | Yes | No | Yes | Yes | Yes | No | No | Yes |
Holed, Intersected | No* | No | No | Yes | No | Yes | No | No | Yes |
Self-Intersections | No** | No | Yes | Yes | No | Yes | Yes | Yes | Yes |
Annotations
- Yes – the operation is supported.
- No – the operation is not supported.
- Red: Indicate that the operation was performed, but the result is incorrect.
* 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. Further, to understand why Mesh Boolean operations might fail and how to avoid such outcomes, our team has prepared an informative piece. So click here to learn why 3D Boolean operations don’t deliver the desired results sometimes.
Takeaway. These qualitative cases separate “returns a mesh” from “returns the right mesh.” MeshLib and the exact engines apply strict CSG semantics (a hole is respected, a self-intersection is rejected as ill-defined), whereas the content-creation kernels (Blender, Rhino) happily produce a watertight—but geometrically different—solid. Which behaviour is “correct” depends on whether you are doing parametric CAD or content authoring.
Why 3D boolean operations fail in practice (and how each library handles it)
Four edge cases distinguish a library that "works on a tutorial" from one that "ships in production."
Non-manifold geometry
Real-world scans and repaired meshes often contain edges shared by more than two triangles. CGAL and libigl reject such input. Manifold requires repair upstream, while MeshLib auto-converts meshes before computing the boolean. Trimesh-Blender and Rhino 3D tolerate these cases more gracefully.
Self-intersections in the input
Boolean operations on self-intersecting meshes are mathematically unstable. CGAL refuses such input, while MCut often fails on degenerate geometry. MeshLib auto-cleans and continues processing, though additional cleanup may still be needed downstream.
Coplanar or near-coplanar faces
Floating-point precision makes coplanar triangles difficult to classify. CGAL and CinoLib solve this exactly but with a major speed penalty. MeshLib and Manifold use robust predicates that handle common real-world cases much faster.
Winding direction and
"inside vs outside."
When closed surfaces overlap, boolean results depend on surface orientation. Trimesh-Blender and Rhino 3D ignore orientation semantics, while MeshLib, CGAL, and Manifold use strict CSG rules with explicit winding behavior.
Deeper walk-through: Why 3D boolean operations don’t always deliver the desired results →
MeshLib vs each library — pairwise deep-dives
Comparison | Read |
|---|---|
MeshLib vs CGAL | CGAL alternative for 3D boolean operations |
MeshLib vs Manifold | Manifold alternative for 3D boolean operations |
MeshLib vs libigl | libigl alternative for 3D boolean operations |
MeshLib vs MCut | MCut alternative for 3D boolean operations |
MeshLib vs CinoLib | CinoLib alternative for 3D boolean operations |
MeshLib vs Trimesh (Blender / Manifold backends) | Top Python libraries for 3D geometry |
MeshLib vs Rhino 3D | Rhino 3D alternative for 3D boolean operations |
MeshLib vs Geogram | Geogram alternative for 3D boolean operations |
MeshLib vs VTK | VTK alternative comparison |
MeshLib vs MeshLab | MeshLib vs MeshLab |
How to choose a mesh boolean library for your project
A short decision guide based on this benchmark:
RECOMMENDED
MeshLib
Best for
Large production meshes, medical scans, and commercial boolean pipelines.
Why
Fastest benchmark result with strong robustness on degenerate real-world geometry.
Tradeoffs
Commercial license required for deployment.
RECOMMENDED
Manifold
Best for
General-purpose CSG where permissive licensing matters.
Why
Strong open-source option with good performance, active maintenance, and production use.
Tradeoffs
Slower than MeshLib on large or difficult meshes.
RECOMMENDED
Trimesh + Manifold
Best for
Prototypes, scripts, and simple Python-based geometry workflows.
Why
Uses the Manifold backend with a simple install and familiar Python API.
Tradeoffs
Not the best choice for maximum production performance.
RECOMMENDED
CGAL or CinoLib
Best for
Academic or research cases where provable exactness matters more than speed.
Why
Exact or indirect predicates can resolve difficult numerical cases reliably.
Tradeoffs
Major performance penalty on large real-world meshes.
RECOMMENDED
Rhino native → MeshLib
Best for
Rhino, Grasshopper, and AEC workflows that need tight integration first.
Why
Rhino native boolean is convenient inside the ecosystem; MeshLib is stronger for larger meshes.
Tradeoffs
Native boolean may not scale well on heavier geometry.
RECOMMENDED
Any OSS option
Best for
Small clean meshes under 100K triangles with simple boolean needs.
Why
Most libraries can handle simple clean geometry well enough.
Tradeoffs
License and integration model matter more than benchmark speed.
Frequently Asked Questions
What is the fastest 3D boolean library in 2026?
For commercial deployments where licensing allows, MeshLib (≈0.09 s Union on a 2M-triangle mesh). For fully-permissive OSS, Manifold (Apache-2.0, ≈0.5 s Union on the same mesh).
Why do mesh boolean operations fail?
The most common causes are non-manifold input, self-intersecting input, near-coplanar faces, and inconsistent winding. Different libraries handle each of these differently — see the section above for the per-library breakdown, and our deeper walk-through at Why 3D Boolean Operations Don’t Always Deliver the Desired Results.
How does MeshLib compare to CGAL for boolean operations?
On a 2M-triangle Nefertiti dataset MeshLib runs Union in 0.093 s while CGAL takes 4.4 s — a 47× difference. On a dental scan with degenerate geometry, CGAL hangs entirely while MeshLib finishes in 44 ms. The full head-to-head is in CGAL alternative for 3D boolean operations.
What's the best Python library for mesh boolean operations?
For prototyping: trimesh with the Manifold backend (trimesh.boolean.union(meshes, engine='manifold')). For production with large meshes: meshlib (pip install meshlib), about 11× faster than Trimesh-Manifold on the Nefertiti dataset.
Is MeshLib free for commercial use?
No — MeshLib uses a dual license. The core library is free for non-commercial use; commercial deployment requires a paid license. See meshlib.io/license for terms and pricing.
Can I run mesh booleans on non-manifold meshes?
It depends on the library. CGAL and libigl reject non-manifold input outright. Manifold requires upstream repair. MeshLib auto-converts to manifold form before computing the boolean. CinoLib handles it natively via indirect predicates.
Why choose MeshLib SDK for 3D boolean operations?
MeshLib leads in 3D processing, offering advanced 3D boolean operations, known for their speed and precision. As an open-source 3D geometry library, it supports C++, Python, C, and JavaScript, offering versatility and easy integration into various projects. MeshLib’s recognition as the fastest tool for 3D boolean operations on the market accelerates project timelines, while its accuracy ensures the highest quality of 3D models. Besides MeshLib is based on robust algorithms and calculations you may learn more about here link. This combination of features makes MeshLib an essential resource for anyone looking to develop undertake sophisticated 3D modeling and application development.
Try MeshLib now
Booleans, mesh repair, decimation and ICP — in your browser, as JavaScript and WebAssembly. No install, no sign-up.
Open live demoOr install the SDK — free to evaluate
