Seat/Floating Subscription
Flexible access for internal teams
- Per-user or floating seats
- Perfect for internal tools, pipelines, and R&D
- Early adopters can secure favorable long-term pricing
- Commercial support, priority bug fixes, and feature input
Solidean — A Boolean Revolution.
Exact, robust, high-performance mesh booleans for mission-critical 3D pipelines.
- Mathematically Exact
- 100% Robustness
- Iteration-Proof Booleans
- Clean Topology
- Attribute & Provenance Tracking
- Millions of Tris/s
Booleans Should Work. They Don't.
- Fail unpredictably on real-world geometry
- Require constant manual cleanup and supervision
- Too slow for complex or repeated operations
- Force teams into complicated, inefficient workarounds
- Limit product features — some ideas never ship
Solidean: Booleans You Can Rely On.
- Exact predicates & constructions (no epsilons)
- Support for non-manifold and self-intersecting inputs
- Iteration-proof: stable after unlimited operations
- High-performance even for millions of triangles
- Clean manifold output topology for any input mesh
Core Capabilities
Robustness Without Exceptions
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.
- Mathematically exact: no epsilons, no heuristics
- All edge cases handled — not most — all
- Guaranteed correct results after unlimited operations
pathological mesh inputs resolve cleanly
Exactness Without Compromise on Speed
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.
- Millions of triangles per second on commodity CPUs
- Parallel architecture that saturates dozens of cores with ease
- No slowdown, even after hundreds of chained operations
17 million tris/s in a high-complexity intersection (Ryzen 5900X)
Fearless Booleans, Even After Hundreds of Steps
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.
- Stable results after unlimited boolean operations
- Clean, manifold topology available at every step
- Attribute and face IDs tracked across the entire chain
- Predictable performance for deep CSG trees and simulations
chained booleans across any number of steps with no drift
Clean Topology, Every Time
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.
- Guaranteed watertight manifold outputs
- Flexible export: soups, indexed meshes, or half-edges
- Optional cleanup: Delaunay remeshing, vertex/edge pruning
- Exact locations available, floats/doubles for easy use
unstructured inputs are cleanly connected after booleans
Attributes That Survive Every Boolean
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.
- Face IDs preserved through unlimited chained operations
- Full reconstruction of materials, UVs, and boundary conditions
- High-performance: attribute transfer happens at the end only
full provenance & attributes intact after complex CSG tree
Quick API Glimpse
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 Technology — From Research to Production
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.
Exactness & Robustness
- Exact geometric predicates and constructions
- Fixed-point homogeneous coordinates representing all results
- Correctness after arbitrarily many boolean operations
Performance
- Novel fixed-width arithmetic kernels for predictable throughput
- Consistent performance for deeply nested CSG trees
- Parallel architecture for millions of triangles/sec on consumer CPUs
Versatility
- Handling of non-manifold, self-intersecting inputs
- Mesh healing for inputs with holes and missing sections
- Manifold outputs even from unstructured meshes
- Attribute transport across operations via tracking IDs
Pricing & Licensing
Choose the model that fits your workflow today — with tailored terms for our early adopter partners.
OEM / Product Integration
Embed Solidean into your products
- Redistribution rights for desktop, server, or cloud software
- Flexible commercial models: per-product, per-unit, or revenue-share
- Includes direct access to our team and opportunities to influence the roadmap
Academic & Research
Free for non-commercial work
- No-cost licenses for research, teaching, and student projects
- Full core functionality for non-commercial use
- Attribution to the EMBER paper required
- Smooth transitions from academic to commercial use
We don't publish a fixed price list — instead, we work with each early adopter to create terms that fit your team size, product type, and support needs. Get in touch to discuss a plan that gives you the full capabilities of Solidean while locking in favorable early-adopter terms.
FAQ
How is Solidean different from other mesh boolean libraries?
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:
- Guaranteed manifold, watertight outputs
- No floating-point tolerances or epsilon hacks
- Handles degenerate and near-degenerate inputs without failing
This is made possible by a new method for exact predicates and a custom compiler framework that generates fixed-width generalized integer kernels — our core performance engine.
How robust is it really — can it fail?
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)
Which languages and platforms are supported?
Solidean provides a modern C++ API as its core, backed by a low-level C API.
Official bindings are available for C# and Python, 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 macOS, iOS, and ARM64 is in development, other languages and platforms are added based on demand.
Can I get manifold outputs guaranteed?
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.