manifold-rust

3D mesh booleans in pure Rust — exact on clean geometry, robust on real-world geometry.

What this is

Two things in one library:

1. A pure-Rust port of Manifold (Emmett Lalish's C++ geometry kernel, v3.5.4) — union / intersection / difference on triangle meshes, plus constructors, cross-sections, convex hull, Minkowski, SDF meshing and smooth subdivision. The port follows the C++ algorithms and passes every ported C++ test, with exact expected values pinned so no output changes by accident. Where it does better than the C++ on purpose, the code says how and why.

2. A second, original "robust" boolean engine that the C++ library does not have. It accepts the meshes real pipelines actually contain — triangle soup, scans, Thingiverse downloads: non-manifold connectivity, self-intersections, doubled sheets, disconnected shells, internal voids, inside-out bodies. It computes on exact rational arithmetic with a mesh-arrangement formulation (Zhou, Grinspun, Zorin & Jacobson 2016), so its answers are decided by exact predicates rather than by tolerances.

Why you'd use it

• The exact engine is the C++ reference's algorithm, down to the tie-breaking order of the symbolic-perturbation predicates — so results agree with the implementation the rest of the ecosystem uses, with no FFI and clean WASM builds. The few places its output differs are listed in PORTING_PLAN.md.
• The robust engine handles what the exact engine can't. It has been swept over the whole Thingi10K corpus (~10k meshes): 0 NotClosed failures, and every volume disagreement above the sampling-noise floor was arbitrated by an independent Monte-Carlo referee — in the robust engine's favour in every case (~150 arbitrated meshes). The typical exact-engine failure on such input is 2–3× volume overcounting on self-overlapping shells.
• Auto gives you clean data by default. It picks the fast exact engine only when that is provably safe (both operands manifold and free of self-intersections, a cached ~0.2 ms exact scan), and the robust engine otherwise. You do not have to know which kind of mesh you were handed.

Features

• Booleans: union, intersection, difference (also + - ^ operators), n-ary batch and CSG-tree evaluation
• Constructors and modeling: cube / sphere / cylinder, extrude, revolve, convex hull, Minkowski sum & difference, SDF level sets, smooth subdivision, 2D cross-sections
• Mesh repair utilities: repair_orientation() for inside-out bodies, rebuild_solid(rule) to re-derive a solid from the winding numbers when rewinding is not enough, has_self_intersections() as an exact self-scan
• Cooperative cancellation and coarse progress reporting through the whole boolean pipeline (library → C FFI → WASM → demo)
• Optional parallel feature (rayon) — results stay bit-identical to the sequential build; only determinism-preserving sites are parallelized
• C FFI (ffi/manifold_rs.h) and C#/.NET bindings (dotnet/, ManifoldRust on NuGet)
• WASM: an interactive demo runs the whole engine in the browser — https://larsbrubaker.github.io/manifold-rust/

Quickstart — Rust

cargo add manifold-rust

use manifold_rust::linalg::Vec3;
use manifold_rust::manifold::Manifold;
use manifold_rust::types::Error;

let cube = Manifold::cube(Vec3::new(1.0, 1.0, 1.0), true);
let sphere = Manifold::sphere(0.6, 32);

let result = cube.difference(&sphere);
assert_eq!(result.status(), Error::NoError);

println!("volume = {}", result.volume());
println!("area   = {}", result.surface_area());

let mesh = result.get_mesh_gl(0); // vert_properties / tri_verts, ready for a GPU

Messy input — import as soup and let Auto choose the engine:

use manifold_rust::types::{BooleanConfig, BooleanEngine};

// Imports geometry the strict pipeline would reject as NotManifold.
let scan = Manifold::from_mesh_gl_robust(&mesh);

// Per call…
let cut = scan.difference_with_engine(&cutter, BooleanEngine::Auto);

// …or once, process-wide.
BooleanConfig::set_default_engine(BooleanEngine::Auto);
let cut = scan.difference(&cutter);

Geometry that is not even closed imports as empty with Error::NotClosed. The default engine remains Exact, so existing code is unchanged.

Parallel execution (bit-identical results, roughly 2× on heavy boolean workloads):

[dependencies]
manifold-rust = { version = "0.19", features = ["parallel"] }

Quickstart — C# / .NET

dotnet add package ManifoldRust

using ManifoldRust;

using Manifold body = Manifold.FromMesh(vertProperties, triVerts);
using Manifold hole = Manifold.FromMesh(holeVerts, holeTris);

// Check Status on every operand: a failed import is absorbed as empty geometry.
if (body.Status != ManifoldStatus.NoError || hole.Status != ManifoldStatus.NoError)
    throw new InvalidOperationException("bad input mesh");

Manifold.DefaultBooleanEngine = BooleanEngine.Auto;   // robust when it matters

using Manifold result = Manifold.BatchBoolean(new[] { body, hole }, ManifoldOpType.Subtract);
MeshGL mesh = result.GetMeshGL();

There is a double-precision path (FromMesh64 / GetMeshGL64), a robust import (FromMeshRobust), and CancellationToken support. Full binding documentation: dotnet/README.md; the ABI itself is described in ffi/manifold_rs.h.

manifold-sharp — the same library, in C#

The ManifoldRust package above is a P/Invoke binding: it loads this Rust cdylib and calls into it. manifold-sharp is the other thing you might want — a complete pure C# port of manifold-rust, with no native library at all, so it runs anywhere .NET runs, browser-wasm included. It is bit-exact with this crate on identical inputs, and it lives as a submodule of agg-sharp.

The two projects check each other: manifold-sharp's oracle test lane runs the same operations through its port and through this library via the binding, then compares the exported meshes row for row with no slack.

State of the project

• Port: complete. All 18 phases of the C++ engine (v3.5.4) are implemented and every C++ test is ported or covered, and the suite passes. The #[ignore]d tests are slow ones that pass in release, measurement fixtures run on demand, and an open bug pinned until its fix lands. Open work is in PORTING_PLAN.md.
• Performance: at parity with the sequential C++ build. Sphere-minus-sphere at 2 M input triangles: 2.61 s (C++) vs 2.57 s (Rust); a 7 999-sphere grid union: 13.5 s vs 14.5 s — identical triangle counts throughout, peak memory within ~10%. The parallel feature roughly doubles throughput. Reproduce with cargo run --release --example perf_test and --example large_scene_test.
• Robust engine: corpus-validated on Thingi10K. src/robust/mod.rs's header says how it is verified; examples/thingi_sweep.rs and examples/volume_referee.rs are the sweep and the referee, and its open items are in PORTING_PLAN.md.
• Deliberate divergences from C++ are noted in a comment at the code that differs, saying what differs, why, which expected values it moved and what the C# twin (manifold-sharp, which verifies against this tree bit-for-bit) must mirror. They come in two kinds: accuracy fixes we stand behind, and inherited output shapes we would resolve toward the C++ but cannot change unilaterally without breaking that twin; the second kind says what a coordinated fix would take.

Known limits, honestly:

• Very large, heavily self-intersecting meshes can be slow in the robust engine — a handful of the ~10k corpus meshes exceed a 120 s budget and are reported as Cancelled rather than wrong. Speeding up the exact-predicate fallback is the top open item.
• The WASM build is single-threaded; the parallel feature is native-only.
• The robust engine requires input to be closed; anything else imports empty with Error::NotClosed.

Building

cargo build
cargo test --release

Run the upstream C++ tests next to the matching Rust tests (needs the submodule):

git submodule update --init --recursive

./validate-reference.ps1            # or: ./validate-reference.ps1 -Phase phase8

The WASM demo:

cd demo && bun run build:wasm && bun run dev

Support the project

manifold-rust is open source, free to use, and maintained in spare time as a labor of love (friends James Smith and Dan Ruskin help out from time to time). MatterHackers sponsors the work — it uses mesh booleans extensively in production 3D-printing workflows, which is why a dependable pure-Rust kernel exists at all.

• Donate: Buy Me a Coffee
• Star the repo — costs nothing, helps others find it
• Report issues: open an issue; the demo's Copy Debug Info button captures everything a boolean bug report needs
• Contribute: PRs welcome — open an issue first for larger changes

Part of the rust-apps suite — Rust graphics and geometry libraries by Lars Brubaker.

License and credits

Apache-2.0, matching the original Manifold library.

• Emmett Lalish — author of the original Manifold C++ library, which this port follows.
• Lars Brubaker — port author, robust engine.
• MatterHackers — sponsor.