Other libraries claim robustness, but always with caveats: a few degenerate cases here, a tolerance tweak there. Solidean is different: our core is based on exact predicates and constructions, proven in peer-reviewed research. If the input requirements are satisfied, there is no wrong result, ever.
pathological mesh inputs resolve cleanly
Exact usually means slow. Solidean proves otherwise: our kernels are built for parallelism and focus computation only where meshes actually interact. The result is performance that beats even most inexact boolean libraries while staying 100% robust.
17 million tris/s in a high-complexity intersection (Ryzen 5900X)
Traditional mesh booleans degrade with every operation: tiny errors add up until deep CSG trees or timestepped simulations collapse. Solidean is different: our exact arithmetic and topological guarantees keep results stable, no matter how many times you chain operations. That means you can iterate freely without ever worrying about drift or failure.
chained booleans across any number of steps with no drift
Messy inputs are the norm: disconnected triangles, non-manifolds, self-intersections. Most boolean engines choke or pass the mess downstream. Solidean does the opposite: because our core is exact, we can always reconstruct a watertight, manifold output mesh. And you decide the format: triangle soup, indexed mesh, half-edge structures, or even high-precision coordinates when you need them.
unstructured inputs are cleanly connected after booleans
Most boolean libraries strip or scramble per-face attributes: materials, UVs, boundary conditions, colors. Solidean doesn't. By assigning each input face a simple tracking ID, we propagate that information through the entire pipeline. At the end, you know exactly which input surface created each output facet, making attribute reconstruction trivial.
full provenance & attributes intact after complex CSG tree
auto result = ctx->execute(*arithmetic,
[&](solidean::Operation& op)
{
auto mA = op.importFromTrianglesF32(trianglesA);
auto mB = op.importFromTrianglesF32(trianglesB);
auto mR = op.intersection(mA, mB);
return op.exportToTrianglesF32(mR);
});
auto resultTris = result->getTrianglesF32();
with ctx.create_operation(arithmetic) as op:
mA = op.import_from_triangles_f32(triangles_a)
mB = op.import_from_triangles_f32(triangles_b)
mR = op.intersection(mA, mB)
result = op.export_to_triangles_f32(mR)
result_tris = result.get_data(solidean.DataSlot.TrianglesF32)
See also: Getting Started · Operation Concept · Examples · Tutorials · Guides · API Reference
Our boolean core builds on the EMBER mesh booleans method (a peer-reviewed, exact, and robust approach to high-performance mesh arrangements that appeared at SIGGRAPH 2022) and extends it into a production-ready SDK engineered for speed, scale, and full attribute preservation.
Start immediately with the Community Edition. Commercial licenses are available for internal tooling and product redistribution.
Download and go
Teams, pipelines, and R&D
Products and platforms
Start with the free Community Edition for evaluation, research, and non-commercial work. Commercial licensing covers internal tooling, redistribution, and enterprise deployments.
Most libraries force a trade-off: fast but fragile, or robust but painfully slow. Solidean is the first system to deliver mathematical exactness and high performance together, even on standard CPUs.
Our results stay stable after unlimited chained operations, so you get both fearless robustness and practical speed in one package.
Under the hood, Solidean runs on an exact arithmetic pipeline:
This is made possible by a new method for exact predicates and a custom compiler framework that generates fixed-width generalized integer kernels. This is our core performance engine.
Solidean is based on exact predicates and constructions, not floating-point heuristics. If the inputs meet the documented requirements, there is literally no possible “wrong” result. Every edge case is handled.
For well-defined solids and “supersolids,” we guarantee mathematically correct outputs.
For geometrically broken inputs (holes, missing faces), our healing step produces a watertight result suitable for further processing, though the exact healing may differ from what a human would choose.
In short: no epsilon hacks, no hidden corner cases.
(Aside from the usual fixable implementation details that any software may have)
Solidean provides a modern C++ API as its core, backed by a low-level C API.
Official bindings are available for Python (C# and Rust are under development), making it easy to integrate into different toolchains.
We support x86-64 Windows and Linux out of the box, with builds delivered as dynamic libraries and example integration code for each language, e.g. via CMake for C++.
Support for android, macOS, iOS, and ARM64 is in development, other languages and platforms are added based on demand.
Yes. Solidean creates solid meshes after any boolean operation.
Solid meshes can always be exported as manifold meshes.
These guaranteed watertight results are suitable for downstream meshing, printing, or simulation.
Optional modes let you choose between raw triangle soups, indexed meshes, or half-edge structures depending on your pipeline needs.
Solidean has the following tiers:
Early adopters will have the option to lock in their pricing as long as their license remains active.