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. 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)

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 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.

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.

Note: Using Solidean in your internal CI containers is fine. Distributing container images or other artifacts that include the Solidean binary is not permitted under the Community Edition and requires a commercial license.

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:

• Community Edition — free for learning, research, personal projects, and evaluation.
• Indie – Internal Tooling — for small teams building internal tools and pipelines.
• Indie – Redistribution — for small teams embedding Solidean in commercial software.
• Educational Commercial — for commercial products primarily used in education.
• Pro – Internal Tooling — for established companies using Solidean internally.
• Pro – Redistribution — for serious commercial products shipping Solidean.
• Enterprise — custom agreements for cases where standard terms don't fit.

Early adopters will have the option to lock in their pricing as long as their license remains active.

Solidean uses a simple flat annual licensing model.

• No seat counting
• No telemetry
• No license server
• No kill switches

Licenses are renewed yearly. Any versions obtained during an active license term may be used and shipped indefinitely after the license expires.

Contact us to discuss commercial licensing.

The Community Edition is free and includes the full core functionality. It is intended for:

• Learning, research, and education
• Personal projects and experimentation
• Technical evaluation before commercial adoption

It does not cover commercial use, redistribution, or SaaS/hosted deployments. No registration or approval is needed: just download and get started.

A commercial license is required as soon as Solidean is used in any commercial context:

• Internal tools, engineering pipelines, or R&D at a commercial company
• A product or service you sell or distribute to others
• Any deployment where Solidean delivers commercial value

If you're unsure, the safe rule is: if your company makes money and Solidean is involved, you need a license.

The distinction is whether Solidean leaves your organization:

• Internal licenses cover use within your own tools, pipelines, and workflows. Solidean stays inside your organization.
• Redistribution licenses allow you to embed Solidean in software used by external users: desktop applications, server software, or cloud platforms.

However, services that primarily expose Solidean itself (for example "boolean-as-a-service" APIs or SDK wrappers exposing the raw functionality) are outside the scope of standard redistribution licenses. Contact us if your use case is near that boundary.

Indie tiers are designed for small teams and independent developers. Eligibility requires:

• Annual revenue below €350k
• 5 or fewer FTE

For Indie Redistribution, a redistribution license is required once you begin distributing a product that embeds Solidean.

However, payment is deferred until the product exceeds €5,000 in gross revenue or 1,000 copies distributed. This grace period allows early launches and experimentation without immediate licensing cost.

Most cases are covered by standard Indie or Pro licenses. Enterprise comes into play when the standard terms no longer fit. Typical situations:

• Your use case falls outside redistribution restrictions (e.g. boolean-as-a-service, standalone geometry tools, SDK wrappers exposing the raw API)
• You require operational guarantees: SLA, indemnification, or priority support
• Solidean is business-critical infrastructure and legal or procurement requires a custom agreement

Contact us to discuss Enterprise terms.

All non-Enterprise licenses include basic email support:

• Installation assistance
• API clarification
• Confirmation of expected behavior

This does not include guaranteed response times, architecture consulting, performance tuning, or custom development. These are available as separate consulting or support agreements.

Yes, with a Redistribution license.

Indie, Educational, and Pro redistribution tiers all grant the right to embed Solidean in commercial software you distribute to customers.

Restrictions apply to competing geometry SDKs, boolean-as-a-service platforms, and SDK-style wrappers that expose the raw Solidean API. Contact us if your use case is at the boundary.

Yes. Any version obtained during an active license term may be used and shipped indefinitely, even after the license expires.

Renewing your license gives you access to updates and continued support. But you are never forced to upgrade or stop using a version you already have.

Yes. Our company Shaped Code GmbH offers consulting and contracting in geometry processing, computer graphics, and high-performance C++.

This can include integration support, pipeline design, performance tuning, or bespoke algorithm development. Work is billed separately from licensing and scoped to your needs.

Support depends on your edition:

• Community Edition - best-effort support via community channels and email. No guaranteed response times.
• Commercial licenses - priority support with reasonable response times, coordinated debugging, and direct contact with the Solidean team.

Your feedback, regardless of edition, helps shape what we improve next.

We aim to respond quickly. Timelines depend on severity and complexity.

Commercial customers receive priority handling. There is no guaranteed SLA unless explicitly agreed in writing as part of a commercial agreement.

Examples and documentation are available for everyone, regardless of edition.

Commercial customers receive integration support as part of their license. For deeper hands-on help, consulting engagements are available to accelerate your integration.

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.