Frequently Asked Questions

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.

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)

Yes. Solidean handles non-manifold edges, self-intersections, and even soups of disconnected polygons. Because the underlying method is exact, we can always reconstruct a consistent output topology, including manifold watertight meshes if requested.

The core API works directly with meshes in memory — as raw triangle soups or indexed triangle meshes. Import and export are exposed at that level for maximum flexibility.

Polygons cannot be directly imported at the current time because they are almost never exactly planar in floating point coordinates. Users are expected to choose their preferred triangulation beforehand. Tracking IDs can still point to the original faces so that no information is lost.

For convenience, our demo code includes simple loaders for OBJ, OFF, and STL. Most teams already have their own I/O pipeline, so this keeps Solidean focused on what it does best: robust, exact booleans.

Additional direct format support (e.g. 3MF, glTF) is on our roadmap and can be added based on demand.

Yes. Solidean tracks a 64-bit ID per input face through every operation. After the boolean, you know exactly which input faces created each output facet, keeping full provenance. This makes it trivial to reconstruct:

• Materials
• UV coordinates
• Boundary conditions (for CAE)
• Colors or per-face metadata

Performance remains high since this bookkeeping is lightweight and the final remapping is done in user space.

We regularly process meshes in the range of millions of triangles per second on a standard workstation CPU.

Complexity scales with the actual intersection region, not the total size of the input.

Memory use grows roughly linearly with the number of triangles produced.

No. Unlike inexact approaches, Solidean is iteration-proof:

• Results remain stable even after hundreds of chained booleans.
• Performance remains predictable — scaling with the complexity of the result surface, not with the depth of the boolean tree. This is critical for deep CSG workflows and time-stepped simulations, where intermediate instability is unacceptable.

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.

At its simplest, you pass your mesh data (triangles or indexed triangles in memory) into Solidean, run a boolean, and export the result back to memory.

Most teams can get a first integration working in under an hour.

Our demo code shows concrete examples for common pipelines (loading OBJ/OFF/STL, running a boolean, exporting to triangles).

If you prefer, our team can also implement the initial integration as a short consulting engagement.

Yes. Solidean is designed to be automation-friendly:

• Works headless (no GUI dependencies)
• Distributed as a single .dll/.so library
• Compatible with Docker and containerized runners

This makes it straightforward to integrate into CI/CD pipelines and automated workflows.

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.

Our focus today is on seat and floating licenses:

• Named seats are tied to individual developers.
• Floating seats can be shared across a team, checked out from a license server as needed.

This model keeps integration simple and scales cleanly from small teams to larger engineering groups.

Our current focus is on seat and floating licenses for early adopters.

That said, we’re open to discussing OEM and redistribution agreements for embedding Solidean into desktop, server, or cloud products — typically as part of longer-term partnerships where embedding is strategic.

We don’t offer perpetual “buy-once” licenses at this time.

To keep support and updates sustainable, Solidean is provided as a subscription. This way early adopters always receive the latest fixes, performance improvements, and features without hidden upgrade costs.

Yes. Beyond Solidean, our company Shaped Code GmbH offers premium consulting and contracting in geometry processing.

This can include first-integration support, pipeline design, performance tuning, or bespoke algorithm development. Work is billed hourly and scoped to your needs.

Consulting is optional and separate from Solidean licensing — many teams start with product seats only and add services later if they want to accelerate.

Yes. Solidean is free for non-commercial research, teaching, and student projects:

• All core features are included.
• We simply ask for attribution to the EMBER paper.
• Transitioning from an academic to a commercial license is seamless when needed.

Yes. As an early adopter, you can secure favorable long-term pricing and direct input into our roadmap.

We work with each team to align licensing with their workflow and budget. If Solidean solves a major bottleneck for you, we want the business case to be obvious — whether that means saving months of engineer time, eliminating manual cleanup, or unlocking new features in your product.

At this stage, Solidean is used in very different ways — from automated print farms to CAE preprocessing pipelines.

Instead of a one-size-fits-all list, we work directly with early adopters to set terms that reflect:

• Team size and license type (named vs floating)
• Intended use (internal tooling vs redistribution)
• Required level of support and collaboration

This ensures early users get the full value of Solidean without overpaying for features they don’t need.

All commercial subscriptions include priority support from the Solidean team:

• Bug reports are triaged immediately.
• Critical issues are prioritized for hotfixes.
• Guidance on best practices and integration is available through direct contact.

We treat early adopters as partners — your feedback directly influences what we improve next.

Our commitment is to respond quickly and fix issues as soon as possible.

While turnaround depends on the complexity of the problem, our track record is measured in days, not months.

Yes. Early adopters receive hands-on integration support: example code, calls with our engineers, and help adapting Solidean to your pipeline.

We want your first integration to succeed quickly, so you can prove value and move forward with confidence.

Yes. For teams that want hands-on help, we offer premium geometry processing services on an hourly basis: integration assistance, algorithm & pipeline design, performance tuning, and custom features.

Engagements are lightweight to start and can scale as needed. If you’re an early adopter, our commercial terms include an easy path to add consulting when it makes sense.

Our immediate focus is strengthening the core capabilities: robustness, performance, iteration-proof booleans, manifold outputs, attributes, and healing.

In addition, we’re actively working on:

• Deterministic parallelism → identical results across machines and thread counts
• Exact offsets and morphological operations → expanding beyond booleans into shells, fillets, and sweeps
• Improved mesh healing → more natural, intuitive reconstructions for broken inputs
• Extended query API → distance, point, and range queries for advanced workflows
• Broader platform support → macOS, iOS, and ARM64 builds in progress
• Additional language bindings and mesh formats → e.g. 3MF, glTF, driven by user demand

Early adopters get access to prototypes and influence what we prioritize next.

No. All improvements to the boolean core are included in existing subscriptions.

For major new modules beyond booleans (e.g. advanced meshing or specialized CAE extensions), we may introduce separate packages — but the core will continue to improve without hidden costs.

Yes. Automated print prep is one of the strongest fits:

• Unioning and intersecting complex lattice or support structures
• Repairing broken or self-intersecting meshes before slicing
• Guaranteeing watertight, manifold outputs for downstream slicers

This eliminates hours of manual cleanup and dramatically reduces failed prints.

Absolutely. CAE workflows often fail at the boolean step, producing non-manifold or inconsistent meshes that downstream solvers reject.

Solidean ensures consistent, watertight geometries that meshing tools can handle directly.

Attributes can also carry boundary conditions or material IDs across operations without manual rework.

Yes. Iteration-proof booleans are critical for subtractive manufacturing, where each tool cut is modeled as a boolean operation.

Because Solidean remains stable after unlimited operations, long milling simulations no longer accumulate numerical errors or break.

Solidean’s robustness and attribute preservation also benefit VFX and game pipelines:

• Reliable booleans for destruction and CSG modeling
• Stable outputs even with self-intersecting or scanned geometry
• Attribute transfer ensures UVs, materials, and colors survive complex edits

This reduces manual cleanup and accelerates iteration on assets.

Yes. Kitbashed levels often contain large amounts of hidden or overlapping geometry where meshes are simply pushed into each other. Solidean can compute scene unions so only the correct outer surface remains, eliminating internal faces and T-junctions.

• Removes hidden overlap geometry from kitbashed assets
• Produces a single watertight surface suitable for modern virtualized geometry (e.g., nanite-like systems)
• Keeps materials/UVs via attribute tracking for clean re-bakes
• Reduces draw/overdraw and improves streaming efficiency

The result is leaner geometry, fewer runtime surprises, and better performance—especially at scale.

For simple one-off models, manual fixes may work. But in automated or large-scale pipelines, this doesn’t scale:

• Engineers and artists spend hundreds of hours per month repairing meshes
• Failures in CI or automated workflows block entire pipelines
• Manual workarounds limit product features and throughput

Solidean eliminates those bottlenecks by making mesh booleans robust, repeatable, and automation-friendly.