FAQ

FAQ (Developer)

Short, developer-focused answers about Solidean's API, arithmetic model, and reference docs.

This FAQ focuses on API and engineering questions for Solidean. For business, licensing, and high-level product FAQs, see the main FAQ.

See also: Troubleshooting, Changelog, API Reference, Getting Started.

Does using float inputs make results inexact?

No. Floats are treated as storage only. On import, data is mapped into an exact arithmetic per your ExactArithmetic/ArithmeticKernel. All operations run exactly; export format determines only how results are serialized (triangles, indexed, half-edge, etc.).

When do I choose MeshType::Solid, Supersolid, or NonSupersolid?

These flags communicate guarantees you make about the mesh:

  • Solid: closed, consistent volume; fastest path.
  • Supersolid: allows self-/surface intersections and nesting; still has well-defined Booleans.
  • NonSupersolid: no guarantees (holes, border non-manifold, partial); most ops require upgrading via Operation::Heal first.

What’s the difference between Result and ExecuteResult?

  • Result: API/usage outcome (invalid args, licensing, wrong handles, etc.). Non-zero means the call failed.
  • ExecuteResult: data quality diagnostics from Context::Execute (e.g., "input wasn't truly supersolid"). Execution may still produce a mesh in best-effort mode; treat non-OK as a signal to fix inputs or flags.

Is multithreading automatic?

Yes by default (ExecuteMode::Multithreaded). You can force single-threaded or diagnostic runs using ExecuteMode::Singlethreaded / Debug. Debug adds verification overhead; use in development, not benchmarks.

How do I reuse results across operations?

Record work in an Operation, then call Context::Execute. To pass results to another operation: Operation::Output → materialized Mesh → Operation::Input in the next op. Using a MeshOperand from one op in another is invalid by design.

How do I get consistent, connected output meshes?

Use Operation::ExportMesh with:

  • ExportFormat::IndexedTriangles / IndexedPolygons or a half-edge format for rich topology.
  • ExportOption::Manifold (and optionally PreferLargerManifolds) to guarantee manifoldness via vertex duplication only.
  • Choose positions via VertexPositionF32/F64/Exact/Planes depending on needs.

Alternatively, Operation::ExportToIndexedTrianglesF32 also produces topologically connected outputs.

  1. Import with MeshType::NonSupersolid / appropriate builder flags (Allow*).
  2. Run Operation::Heal to upgrade to supersolid.
  3. (If needed) Operation::SelfUnion to get solid.
  4. Perform Booleans.
  5. Export with your desired format/options.

How do tracking IDs work?

Enable on input surfaces via SurfaceBuilder::TrackID, TrackIDRaw, or TrackPrimitiveIDs. Alternatively, use the import functions that end with WithID. IDs propagate through operations (including cuts/splits). Export with ExportOption::PrimitiveID to retrieve them (or, again, with the functions that end with WithID). See the reference for flag semantics and ID structure.

Why do my float exports differ bitwise from inputs?

Export is not a byte-for-byte pass-through: exact internal reps may remap to float with minor rounding and connectivity changes (deduplication, T-junction resolution, manifold guarantees). If you need exact structure, export exact positions or supporting planes, not floats. (Though, usually, we try to keep the exact bit representation where possible.)

How do I check if a mesh is (super)solid?

Use queries: Operation::QueryIsSolid and Operation::QueryIsSupersolid. For defect analysis, export the defect network via ExportFormat::DefectNetwork (segments + defect values).

Performance tips?

  • Only enable AllowSelfIntersections / AllowSurfaceIntersections / AllowNestedComponents when needed.
  • Use MeshType::Solid (aka the default) whenever possible.
  • Prefer Multithreaded mode; avoid Debug for production runs.
  • Use unrolled or indexed export without postprocessing if the increased quality is not required.
  • For many Booleans in a chain, materialize only what you need; rely on the optimizer for transient operands.

If performance is still a concern, contact support. We continuously optimize across common use cases.

Versioning: where do I find changes?

We use YEAR.NR (e.g., 2025.1). See the Changelog. Early adopters can influence priorities; breaking changes are avoided where possible, but interfaces may evolve.