Pith. sign in

REVIEW 3 major objections 5 minor 38 references

trueform: Fast And Robust Mesh CSG Via Topological Aggregation

T0 review · 3 major / 5 minor · reviewed 2026-08-01 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Topological majority votes let mesh booleans stay exact after rounding.

desk verdict Serious, well-engineered contribution; the exactness claim is narrower than the abstract's “we keep it exact,” and the majority-vote guarantee is statistical, but the paper deserves a careful referee. read the letter →

arxiv 2607.15905 v1 pith:QSOUC4WO submitted 2026-07-17 cs.CG

Žiga Sajovic , Dejan Knez This is my paper · ORCID
classification cs.CG MSC 68U05
keywords constructivesolidgeometrymeshbooleanoperationstopologicalaggregationarrangementexactpredicatesmaterialisationnon-manifoldmesheswatertightoutput
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that the only guarantee a mesh-CSG stage can keep after its output is materialised to floating point is index-based topology, not geometry. It proposes to make that topology exact and to recover disputed geometric decisions through topological aggregation: a weighted-majority vote among the disagreeing observations within each topological unit. If correct, the method produces watertight boolean results without exact constructions, answers booleans of any arity from a single arrangement build, and runs up to two orders of magnitude faster than several prior libraries, including in the browser.

What carries the argument

Topological aggregation is the central mechanism: each topological unit (a MEL component for orientation, a relation between components for merging, a domain for classification) collects all its geometric observations and resolves disagreement by weighted-majority vote, where weights are the minimum area of incident faces. The supporting machinery is a five-type classification (VV, VE, VF, EE, EF) of pairwise intersections on a bounded integer ladder, a two-level identity scheme (topological identity plus geometric merge) that keeps the arrangement consistent across faces locally, and an implicit reduced graph that carries the same combinatorial content as a Weiler 3-map without explicit hal

What would settle it

Construct a two-sphere arrangement with a ring of near-coplanar faces at the intersection circle, deliberately round the materialised endpoints so that more than half of the edges in one relation flip their radial order, and then check whether the boolean output changes; the paper itself demonstrates the flipping mechanism, so the adversarial test would raise the corruption ratio past 50% and see whether the method still recovers the intended solid.

Watch

Extended reading notes

Core claim

The central claim is that a mesh-CSG pipeline can stay exactly correct by separating what survives materialisation from what does not. Within the build, the radial order around every intersection edge is decided by exact predicates on the original input planes alone, so no constructed coordinate enters the comparison and the result is exact without exact constructions. Where a decision spans faces and individual geometric observations disagree, the intended answer is recovered by a weighted-majority vote over the observations in that topological unit, which the paper models as a maximum-a-posteriori estimate. This makes the arrangement locally computed, globally consistent through identities

Load-bearing premise

The correctness guarantee is a majority assumption: if materialisation or inconsistent winding corrupts more than half of the observations within a single topological relation, the weighted-majority vote returns the wrong order.

Editorial extensions

If this is right

  • Any boolean expression over the operands is a per-domain bit test, so a family of CSG queries cost one arrangement build plus cheap extractions.
  • The radial order around non-manifold edges is exact without exact constructions, because it is computed from original input planes, which removes the need for precision escalation inside the build.
  • The pipeline keeps partition correctness two to three orders of magnitude longer than per-edge extraction under added construction error, so composed, materialised pipelines can rely on the vote to recover the intended domains.
  • Reported timings show the method is 5.5× to 100× faster than six prior libraries on a 1000-pair benchmark corpus, and its WebAssembly build stays interactive in the browser on the same inputs.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The majority-vote principle could be applied to other geometric reads that a downstream stage makes from materialised coordinates, such as generalized-winding-number classification or ray parity, not just orientation, merging, and domain classification.
  • If the build/extract amortisation holds, a natural next target is interactive CSG-tree editing, where each user edit is an extraction from a precomputed arrangement rather than a rebuild.
  • A concrete stress test suggested by the paper's model: engineer a near-coplanar interface, round the endpoint coordinates to nudge more than half of a relation's edges to the wrong order, and observe whether the output partition flips — this would directly probe the statistical guarantee stated in Appendix A.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper presents trueform, a mesh-CSG pipeline that computes arrangements with integer-exact predicates on snapped coordinates, classifies all contacts into five canonical types, arranges each cut face locally in its own plane, and uses a two-level identity scheme to keep the arrangement consistent without global exact constructions. Around non-manifold edges, radial order is decided by exact predicates on the original input planes. Where a decision spans multiple faces, the method aggregates possibly disagreeing per-edge radial-order observations by a weighted-majority vote within each topological relation, casts this as maximum-a-posteriori estimation, and classifies volumetric domains by per-domain inclusion bitvectors. One arrangement build serves arbitrary boolean expressions of any arity, including open surfaces declared as sheets. The paper reports robustness experiments (two-sphere sweeps, a geological arrangement, Thingi10K, perturbation sweeps), performance scaling experiments, and comparisons against six prior libraries plus browser baselines.

Significance. If the claims hold, the paper makes a strong practical contribution: a fast, header-only, cross-platform CSG library that builds one arrangement and answers a whole family of booleans, handles non-manifold input and open sheets, and still uses exact predicates without exact constructions for its in-build radial structure. The benchmark protocol is clearly specified, based on public data (Thingi10K) and external implementations, with no fitted constants, and the code is released. The limitations section is unusually candid, explicitly acknowledging that the majority vote is statistical and that materialised output can self-intersect. However, the exactness claim is conditional on a majority assumption whose failure modes are acknowledged but not bounded, and the validity oracle used to grade outputs is weaker than the paper's wording suggests. These issues are load-bearing for the paper's central 'exact topology' claim and need to be resolved before acceptance.

major comments (3)
  1. [Abstract, §1.2, §5.1, Appendix A (Eq. 4)] The abstract and Contribution 3 state that the intended answer is 'recovered' by topological aggregation and that 'we keep it exact.' But the guarantee is definitional: Appendix A Eq. (4) identifies the MAP estimate with the weighted majority, and the appendix states that 'the vote returns the intended permutation exactly when a majority of the relation's observations carry it.' Section 5.1 concedes that a configuration can be built to defeat the majority. The §4.1 experiments show that the vote tolerates more error than per-edge reading under the tested noise model, but they do not establish that real materialisation errors are unbiased, independent, or bounded below the 50% threshold in the worst cases described in Figure 2 (a single rounded vertex can flip several radial-order observations at once). The face-spanning decision is therefore a maximum-a-posteriori estimate with a conditi
  2. [§4.3, 'Validity' and §5.1] The validity oracle grades only closure, consistent orientation, signed volume, and surface area. Section 5.1 admits that materialising the output can introduce self-intersections that the exact arrangement did not have. Therefore the paper's claim of 'valid, watertight output' (abstract) and the validity counts in Tables 5 and 7 do not establish that the output is a valid solid in the usual CAD sense; a watertight but self-intersecting mesh is not a valid solid for downstream stages. Either extend the oracle to check self-intersection (e.g., by exact arrangement of the output or at least by reporting crossing counts on a representative subset), or explicitly define 'valid' as 'closed and consistently oriented' and state that self-intersections may remain.
  3. [§4.1, Figure 13] The perturbation experiment models construction error by perturbing non-manifold-edge endpoints independently in a uniform box. This does not exercise the correlated failure mode the paper itself identifies in Figure 2 and §5.1: when adjacent edges share an endpoint, a single rounded vertex can flip several radial-order observations at once, and near-coplanar geometry can make such flips systematic rather than independent. The claimed margin of 'two to three orders of magnitude more construction error' is therefore established for a particular independent-noise model, not for the worst relevant materialisation process. The paper should add a correlated-corruption experiment (e.g., coherently jittering shared vertices, or constructing a near-coplanar configuration tuned to approach the majority threshold) to show how close realistic inputs come to the failure regime, or provide a theoreti
minor comments (5)
  1. [§4.1, Figure 12 caption] The 'original planes 0/191' row is described as the in-build exact reading; the caption should state explicitly that this is not an additional method but the exact ordering used inside trueform before materialisation.
  2. [Table 3] The 'per-edge' column reports the number of correctly partitioned relations, but the column header alone could be misread as the number of failures, especially since the row label 'relations split' precedes it. Add 'correct' to the column header.
  3. [§2.1, Table 1] The zero-pattern decision tree abbreviates v1,v2,v3 without repeating their definitions in the table. Since the table is meant to be self-contained, consider adding the definitions or a reference to the equations above it.
  4. [Appendix A] The statement that adjacent-edge correlation 'is local and does not bias the majority' is an assertion, not a demonstrated property. If kept, it should be softened to a stated assumption or supported by the new correlated-corruption experiment recommended above.
  5. [§4.2] The build/extract timing reports 'the minimum over repeated runs.' A sentence stating the number of repeats per case would help reproducibility; currently only 'best of five' appears for the swarm and browser figures.

Circularity Check

1 steps flagged · score 4.0 of 10

One acknowledged definitional step in the aggregation guarantee; the in-build exactness and all external benchmarks are independent.

  1. self definitional [Appendix A, 'Epistemic status'; cf. §1.2 contribution 3, §5.1]
    "the operative guarantee is definitional: the vote returns the intended permutation exactly when a majority of the relation’s observations carry it."

    The paper's central claim is that topological aggregation recovers the 'intended answer' from disagreeing observations. Appendix A defines the intended category as the estimator's output: after the Dirichlet-MAP derivation, the intended category is the weighted-count argmax, i.e. the majority. Thus the stated guarantee 'vote returns the intended permutation exactly when a majority ... carry it' is true by construction, a restatement of the rule rather than an independent theorem; for materialised cross-face decisions, 'correct' and 'majority' are the same predicate. §5.1 concedes the guarantee is statistical, not worst-case, so the circularity is acknowledged and scoped, but the abstract's 'we keep it exact' still inherits this definitional character.

full rationale

This is not a case of fitted parameters called predictions or a load-bearing self-citation chain. The build's central mathematical content is self-contained: the in-build radial order is decided by exact degree-two sign tests on the original input planes (§2.3), so 'exact without exact constructions' does not reduce to an input assumption. The empirical claims are anchored outside the paper: pairwise and N-ary comparisons against Geogram, EMBER, CGAL, Cherchi et al., MeshLib, and Manifold on the Thingi10K corpus, with a fixed watertightness oracle, and the browser comparison against Manifold and three-bvh-csg. The only circular step is the aggregation guarantee in Appendix A, which the paper itself labels definitional and whose worst-case failure it concedes in §5.1; this is a genuine limitation but a scoped one. The code citation [S*25] is availability of the implementation, not an imported uniqueness theorem. Overall the derivation chain is self-contained except for one acknowledged definitional guarantee, so score 4.

Assumptions & free parameters 3 free parameters · 5 assumptions · 0 invented entities

No continuum constants are fitted to external data. The ledger is dominated by the snapped-grid/tolerance choices and by the statistical majority model; the latter is the load-bearing assumption for robustness. No new physical or mathematical entities are postulated.

free parameters (3)
  • integer grid resolution = int32 (float input) or int64 (double input), with 128/256-bit predicate ladder
    All exactness is relative to the snapped integer grid; inputs beyond the wider grid's range must be rescaled (§2.1, §5.1). The choice is made from input type, not fitted.
  • tolerance band length = user-declared length
    An optional tolerance re-classifies near-coincident features as coincident in stage one and the 2D segment arrangement; it can change the arrangement topology (§2.1).
  • radial observation weight = minimum area of faces incident to the non-manifold edge
    Weights in the relation vote are chosen as min incident face area so near-degenerate slivers contribute least; this is a design choice, not fitted to data (§2.4, Appendix A).
assumptions (5)
  • domain assumption Input floats can be snapped onto the integer grid without changing the intended topology.
    Section 2.1 and §5.1: predicates and arrangement are exact only on snapped coordinates; topology is assumed to be either preserved or redefined by the snapping.
  • domain assumption Face primitives are convex or triangulated upstream; degenerate collinear chains contribute nothing.
    Section 2.1: fan triangulation from any vertex requires convexity; non-convex input is triangulated upstream, which can alter exact contacts.
  • domain assumption The intended radial order is constant along each non-manifold polyline, so every edge is a noisy reading of one shared permutation.
    Section 4.1: relation grouping and voting rely on this; Appendix A acknowledges independence is an idealization because adjacent edges share endpoints.
  • ad hoc to paper A majority of observations per relation are uncorrupted.
    Section 5.1: this is the statistical guarantee; an adversary can engineer >50% flips and defeat the vote.
  • domain assumption Closed, consistently oriented output (“watertight”) is the relevant validity criterion.
    Section 4.3 oracle uses this criterion; §5.1 admits materialised output may self-intersect, so self-intersection freedom is not part of the validity claim.

how reviews work

0 comments
Cite this review

Pith. "Pith review of trueform: Fast And Robust Mesh CSG Via Topological Aggregation." pith.science (2026). https://pith.science/paper/QSOUC4WO

@misc{pith2026260715905,
  author       = {Pith},
  title        = {Pith review of: trueform: Fast And Robust Mesh CSG Via Topological Aggregation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QSOUC4WO}},
  note         = {Machine review of arXiv:2607.15905}
}
read the original abstract

Mesh CSG output is consumed in floating point: however exact the computation, every emitted coordinate is materialised -- rounded to a representable position -- and the next stage can observe crossings and orderings the exact result never had. Only index-based topology survives materialisation. We keep it exact: within the build, the arrangement's radial structure is ordered by exact predicates on the original input planes -- exact without exact constructions -- and where a decision spans faces, the intended answer is recovered by topological aggregation: a majority vote over the disagreeing geometric observations within their topological unit. We compute the arrangement locally with integer-exact predicates, every stage a graph problem on graphs it never explicitly constructs. Pairwise intersections are classified into five canonical types (VV, VE, VF, EE, EF), each cut face is arranged in its own plane, and a two-level identity keeps the result consistent across faces with no global structure. The arrangement and its domain partition are built once and queried arbitrarily often: a boolean of any arity is a per-domain bit test, volumetric regions read straight off the partition, and open surfaces -- declared as oriented sheets -- cut volumes through the same algebra. The method is implemented in the header-only trueform library, in C++ with Python and TypeScript bindings. Compared to prior art, it produces valid, watertight output while running up to two orders of magnitude faster, and stays interactive in the browser.

Figures

Figures reproduced from arXiv: 2607.15905 by the authors.

Figure 1
Figure 1. Volumetric domains and N-ary booleans. Left: a Stanford bunny arranged against 60 axis-aligned cutting planes (20 per axis) and split into its 3459 interior volumetric cells, each a separate watertight solid (coloured arbitrarily). Right: the union of a sphere with 200 Fibonacci-placed bunnies (sphere ∪ bunnies) — 22M input triangles arranged in 0.5 s — a 201-operand boolean with every face coloured by the operand i… view at source ↗
Figure 2
Figure 2. The observed wedge. Intended: four triangles T1,T2,T3,T4 meeting at a non-manifold edge e. T2 and T3 are near-coplanar; T4 is near-degenerate with apex close to the edge axis. The intended radial order is T1,T2,T3,T4. Buckets: whenever a vertex is quantised, snap￾rounded, or format-converted, it lands at one of the nearby representable values in its bucket. T2 and T3 are close enough that their buckets overlap; T4’s… view at source ↗
Figure 3
Figure 3. Mesh arrangements often divide a volume into regions of interest. When those regions are cut parametrically, primitives end up coplanar by construction. Here, a box is split into sub-domains D1,D2 by an internal rectangle R whose vertices sit at midpoints of cube edges; the four intersection points (and edges) are shown in red. SoS removes the coplanarity by deterministic but arbitrary perturbation: each red vertex … view at source ↗
Figures from the paper (13 more)
Figure 4
Figure 4. Figure 4: Pipeline overview. The build is a single forward pass over the N operands (Section 2): pairwise intersection emits tagged records, each cut face is arranged in its local plane, the cut sub-faces and reused manifold links form the implicit reduced graph, topological-sco…
Figure 5
Figure 5. Figure 5: Two-stage local arrangement on face A, which meets faces B, C, D. Left: 3D configuration with three intersection edges and six boundary vertices on A. Middle left: those edges in A’s local plane, labelled e0,e1,e2 (the intersections of A with B, C, D). Middle right: th…
Figure 6
Figure 6. Figure 6: Left: the reduced graph R holds MEL components c1,..., c4 joined by a relation r — the equivalence class of non-manifold edges along a polyline that share the incident-component set {c1,c2,c3,c4}. Right: each edge in r realises as a wedge ring with cyclic order ρe = (c…
Figure 7
Figure 7. Figure 7: A non-manifold domain with fins (Mode 2). A single body, shown translucent, wraps two open patches — half-inserted intrusion surfaces — as fins, each part of the body’s boundary. Teal traces where a fin meets the body: a non-manifold edge whose two sides are fused into…
Figure 8
Figure 8. Figure 8: An intersection polyline along which five MEL compo￾nents meet, bounding a domain. Four of its five non-manifold edges are incident to c1,...,c4 alone and form a relation r1 with canoni￾cal permutation ρ1 = (c1,c2,c3,c4); the remaining edge is incident to a fifth compo…
Figure 9
Figure 9. Figure 9: Cross-component nesting. Q sits inside P without touch￾ing it, so they form two separate connected components. P’s outside is the outermost region, inside nothing, and seeds for free (b = 0, no ray). Q’s outside is the gap between the two surfaces, which may lie inside…
Figure 10
Figure 10. Figure 10: Open operands: sheets. A box and three disconnected spheres (volumes, M) with two undulating horizon surfaces declared as sheets (T , B). Left: the inputs. Middle: the strata as ordinary boolean expressions — a sheet’s operand bit reads “behind its normal”, so interse…
Figure 12
Figure 12. Figure 12: Two unit UV spheres (32×32), one offset by d along the pole axis, arranged as d is swept over 191 values. Each row re￾ports a reading of the radial order across the sweep at ε = 0: green where the relation is partitioned correctly, red where it is mispar￾titioned. Rea…
Figure 13
Figure 13. Figure 13: Domain-partition correctness under added construc￾tion error, in double precision, across the twenty-two model config￾urations of Section 4.1 (fifteen standard meshes as model/rotated￾copy pairs, seven as random-rotation arrangements), 1000 per￾turbed trials per ε. Ea…
Figure 14
Figure 14. Figure 14: Operand count, not triangle count, drives the build. Build time of 1989 random N-ary unions of Thingi10K meshes against total input triangles, one point per union, coloured by operand count N (full geometry-to-build time, M4 Max). The sam￾pling generalises the EMBER p…
Figure 16
Figure 16. Figure 16: Where the build time goes: the arrangement build of [PITH_FULL_IMAGE:figures/full_fig_p017_16.png]
Figure 17
Figure 17. Figure 17: Pairwise booleans against prior art. Per-operation wall-clock time (log scale) over 1000 random Thingi10K pairs at 100k–1M triangles, one boolean per pair, full geometry-to-output timing under the protocol above (best of K, M4 Max). Each vio￾lin is the distribution ov…
Figure 19
Figure 19. Figure 19: and [PITH_FULL_IMAGE:figures/full_fig_p019_19.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

38 extracted references · 7 canonical work pages

  1. [1]

    : Indirect predicates for geometric constructions

    Attene M. : Indirect predicates for geometric constructions. Computer-Aided Design 126 (2020), Article 102856. http://dx.doi.org/10.1016/j.cad.2020.102856 doi:10.1016/j.cad.2020.102856

    arXiv 2020

  2. [2]

    : Interval arithmetic yields efficient dynamic filters for computational geometry

    Br \"o nnimann H., Burnikel C., Pion S. : Interval arithmetic yields efficient dynamic filters for computational geometry. In Proceedings of the Fourteenth Annual Symposium on Computational Geometry (SCG '98) (1998), ACM, pp. 165--174. http://dx.doi.org/10.1145/276884.276903 doi:10.1145/276884.276903

    arXiv 1998

  3. [3]

    : Fast algorithm for extracting domains and regions from three-dimensional triangular surface meshes

    Bohm S., Runge E. : Fast algorithm for extracting domains and regions from three-dimensional triangular surface meshes. Computer-Aided Design 180 (2025), Article 103824. http://dx.doi.org/10.1016/j.cad.2024.103824 doi:10.1016/j.cad.2024.103824

    arXiv 2025

  4. [4]

    : Exact and robust (self-)intersections for polygonal meshes

    Campen M., Kobbelt L. : Exact and robust (self-)intersections for polygonal meshes. Computer Graphics Forum 29, 2 (2010), 397--406. http://dx.doi.org/10.1111/j.1467-8659.2009.01609.x doi:10.1111/j.1467-8659.2009.01609.x

    arXiv 2010

  5. [5]

    : Polygonal boundary evaluation of Minkowski sums and swept volumes

    Campen M., Kobbelt L. : Polygonal boundary evaluation of Minkowski sums and swept volumes. Computer Graphics Forum 29, 5 (2010), 1613--1622. http://dx.doi.org/10.1111/j.1467-8659.2010.01770.x doi:10.1111/j.1467-8659.2010.01770.x

    arXiv 2010

  6. [6]

    : Fast and robust mesh arrangements using floating-point arithmetic

    Cherchi G., Livesu M., Scateni R., Attene M. : Fast and robust mesh arrangements using floating-point arithmetic. ACM Transactions on Graphics 39, 6 (2020), Article 250. SIGGRAPH Asia 2020. http://dx.doi.org/10.1145/3414685.3417818 doi:10.1145/3414685.3417818

    arXiv 2020

  7. [7]

    : Interactive and robust mesh booleans

    Cherchi G., Pellacini F., Attene M., Livesu M. : Interactive and robust mesh booleans. ACM Transactions on Graphics 41, 6 (2022), Article 214. SIGGRAPH Asia 2022. http://dx.doi.org/10.1145/3550454.3555460 doi:10.1145/3550454.3555460

    arXiv 2022

  8. [8]

    : Interactive and Robust Mesh Booleans : reference implementation, 2024

    Cherchi G., Pellacini F., Attene M., Livesu M. : Interactive and Robust Mesh Booleans : reference implementation, 2024. Commit 7bd6c26 . URL: https://github.com/gcherchi/InteractiveAndRobustMeshBooleans

    2024

Show all 38 references
  1. [9]

    H., Mallet J.-L

    Caumon G., Sword C. H., Mallet J.-L. : Constrained modifications of non-manifold B -reps. In Proceedings of the 8th ACM Symposium on Solid Modeling and Applications (SM '03) (2003), pp. 310--315. http://dx.doi.org/10.1145/781606.781657 doi:10.1145/781606.781657

    2003

  2. [10]

    : QuickCSG : Arbitrary and Faster Boolean Combinations of N Solids

    Douze M., Franco J.-S., Raffin B. : QuickCSG : Arbitrary and Faster Boolean Combinations of N Solids . Tech. Rep. RR-8687, INRIA, 2015. URL: https://inria.hal.science/hal-01121419

    2015

  3. [11]

    Devillers O., Lazard S., Lenhart W. J. : 3 D snap rounding. In 34th International Symposium on Computational Geometry (SoCG 2018) (2018), vol. 99 of LIPIcs, Schloss Dagstuhl-Leibniz-Zentrum f \"u r Informatik, pp. 30:1--30:14. http://dx.doi.org/10.4230/LIPIcs.SoCG.2018.30 doi:...

    2018 doi

  4. [12]

    Edelsbrunner H., M \"u cke E. P. : Simulation of simplicity: A technique to cope with degenerate cases in geometric algorithms. ACM Transactions on Graphics 9, 1 (1990), 66--104. http://dx.doi.org/10.1145/77635.77639 doi:10.1145/77635.77639

    1990

  5. [14]

    : Boolean operations on 3 D selective Nef complexes: Data structure, algorithms, optimized implementation and experiments

    Hachenberger P., Kettner L., Mehlhorn K. : Boolean operations on 3 D selective Nef complexes: Data structure, algorithms, optimized implementation and experiments. Computational Geometry 38, 1--2 (2007), 64--99. http://dx.doi.org/10.1016/j.comgeo.2006.11.001 doi:10.1016/j.comg...

    2007 doi

  6. [15]

    URL: https://github.com/gkjohnson/three-bvh-csg

    Johnson G., Contributors : three-bvh-csg : Performant csg for three.js built on three-mesh-bvh, 2024. URL: https://github.com/gkjohnson/three-bvh-csg

    2024

  7. [16]

    : Robust inside-outside segmentation using generalized winding numbers

    Jacobson A., Kavan L., Sorkine-Hornung O. : Robust inside-outside segmentation using generalized winding numbers. ACM Transactions on Graphics 32, 4 (2013), Article 33. http://dx.doi.org/10.1145/2461912.2461916 doi:10.1145/2461912.2461916

    2013

  8. [17]

    : Manifold : a library dedicated to creating and operating on manifold triangle meshes, 2023

    Lalish E. : Manifold : a library dedicated to creating and operating on manifold triangle meshes, 2023. URL: https://github.com/elalish/manifold

    2023

  9. [18]

    : Geogram : a library of geometric algorithms, 2024

    L \'e vy B. : Geogram : a library of geometric algorithms, 2024. URL: https://github.com/BrunoLevy/geogram

    2024

  10. [19]

    : Exact predicates, exact constructions and combinatorics for mesh CSG

    L \'e vy B. : Exact predicates, exact constructions and combinatorics for mesh CSG . arXiv preprint arXiv:2405.12949v2 (2025). URL: https://arxiv.org/abs/2405.12949, http://dx.doi.org/10.48550/arXiv.2405.12949 doi:10.48550/arXiv.2405.12949

    2025 doi arXiv

  11. [20]

    : Extension of the notion of map and subdivisions of a three-dimensional space

    Lienhardt P. : Extension of the notion of map and subdivisions of a three-dimensional space. In STACS 88, 5th Annual Symposium on Theoretical Aspects of Computer Science (1988), vol. 294 of Lecture Notes in Computer Science, Springer, pp. 301--311. http://dx.doi.org/10.1007/BF...

    1988 doi

  12. [21]

    Loriot S., Rouxel-Labb \'e M., Tournois J., Yaz I. O. : Polygon Mesh Processing -- Corefinement and Boolean Operations, 5.5.2 ed., 2023. URL: https://doc.cgal.org/5.5.2/Manual/packages.html\#PkgPolygonMeshProcessing

    2023

  13. [22]

    URL: https://meshlib.io/

    MeshInspector : MeshLib : 3 D processing library, 2024. URL: https://meshlib.io/

    2024

  14. [23]

    : FPG : A code generator for fast and certified geometric predicates

    Meyer A., Pion S. : FPG : A code generator for fast and certified geometric predicates. In Real Numbers and Computers (Santiago de Compostela, Spain, 2008), pp. 47--60. URL: https://inria.hal.science/inria-00344297

    2008

  15. [24]

    : Geometric rounding and feature separation in meshes

    Milenkovi \'c V., Sacks E. : Geometric rounding and feature separation in meshes. Computer-Aided Design 108 (2019), 12--18. http://dx.doi.org/10.1016/j.cad.2018.10.001 doi:10.1016/j.cad.2018.10.001

    2019 doi

  16. [25]

    : Merging BSP trees yields polyhedral set operations

    Naylor B., Amanatides J., Thibault W. : Merging BSP trees yields polyhedral set operations. In Proceedings of SIGGRAPH '90 (1990), vol. 24 of ACM SIGGRAPH Computer Graphics, pp. 115--124. http://dx.doi.org/10.1145/97879.97894 doi:10.1145/97879.97894

    1990

  17. [26]

    : Beitr \"a ge zur Theorie der Polyeder

    Nef W. : Beitr \"a ge zur Theorie der Polyeder . Herbert Lang, Bern, 1978

    1978

  18. [27]

    : Fast exact booleans for iterated CSG using octree-embedded BSP s

    Nehring-Wirxel J., Trettner P., Kobbelt L. : Fast exact booleans for iterated CSG using octree-embedded BSP s. Computer-Aided Design 135 (2021), Article 103015. http://dx.doi.org/10.1016/j.cad.2021.103015 doi:10.1016/j.cad.2021.103015

    2021

  19. [28]

    : RINGMesh : A programming library for developing mesh-based geomodeling applications

    Pellerin J., Botella A., Bonneau F., Mazuyer A., Chauvin B., L \'e vy B., Caumon G. : RINGMesh : A programming library for developing mesh-based geomodeling applications. Computers & Geosciences 104 (2017), 93--100. http://dx.doi.org/10.1016/j.cageo.2017.03.005 doi:10.1016/j.c...

    2017 doi

  20. [29]

    : trueform : the STL for geometry

    Sajovic Z ., et al. : trueform : the STL for geometry. Polydera, 2025. URL: https://github.com/polydera/trueform

    2025

  21. [30]

    Shewchuk J. R. : Adaptive precision floating-point arithmetic and fast robust geometric predicates. Discrete & Computational Geometry 18, 3 (1997), 305--363. http://dx.doi.org/10.1007/PL00009321 doi:10.1007/PL00009321

    1997 doi

  22. [31]

    Community edition, arm64 preview build 2026-04-07-be517c

    Solidean : Solidean : a mesh-processing toolkit for exact-arithmetic booleans, 2026. Community edition, arm64 preview build 2026-04-07-be517c . URL: https://solidean.com/

    2026

  23. [32]

    : Interactive modeling of mechanical objects

    Tymms C., Grinspun E., Zorin D. : Interactive modeling of mechanical objects. Computer Graphics Forum 35, 7 (2016), 145--155. http://dx.doi.org/10.1111/cgf.13013 doi:10.1111/cgf.13013

    2016 doi

  24. [33]

    URL: https://doc.cgal.org/5.5.2/Manual/packages.html

    The CGAL Project : CGAL User and Reference Manual , 5.5.2 ed., 2023. URL: https://doc.cgal.org/5.5.2/Manual/packages.html

    2023

  25. [34]

    : EMBER : Exact mesh booleans via efficient and robust local arrangements

    Trettner P., Nehring-Wirxel J., Kobbelt L. : EMBER : Exact mesh booleans via efficient and robust local arrangements. ACM Transactions on Graphics 41, 4 (2022), Article 39. SIGGRAPH 2022. http://dx.doi.org/10.1145/3528223.3530181 doi:10.1145/3528223.3530181

    2022

  26. [35]

    : 3 D Snap Rounding

    Valque L. : 3 D Snap Rounding . Master's thesis, Universit \'e de Lyon, 2019. URL: https://inria.hal.science/hal-02393625

    2019

  27. [36]

    : Edge-based data structures for solid modeling in curved-surface environments

    Weiler K. : Edge-based data structures for solid modeling in curved-surface environments. IEEE Computer Graphics and Applications 5, 1 (1985), 21--40. http://dx.doi.org/10.1109/MCG.1985.276271 doi:10.1109/MCG.1985.276271

    1985

  28. [37]

    URL: https://openscad.org/

    Wolf C., OpenSCAD contributors : OpenSCAD : The programmers solid 3D cad modeller, 2010. URL: https://openscad.org/

    2010

  29. [38]

    : Mesh arrangements for solid geometry

    Zhou Q., Grinspun E., Zorin D., Jacobson A. : Mesh arrangements for solid geometry. ACM Transactions on Graphics 35, 4 (2016), Article 39. SIGGRAPH 2016. http://dx.doi.org/10.1145/2897824.2925901 doi:10.1145/2897824.2925901

    2016

  30. [39]

    : Thingi10K : A dataset of 10,000 3 D -printing models

    Zhou Q., Jacobson A. : Thingi10K : A dataset of 10,000 3 D -printing models. arXiv preprint arXiv:1605.04797 (2016). URL: https://arxiv.org/abs/1605.04797

    2016 arXiv

Pith tools

Reviewed August 1, 2026 · model on record in the stance chip above.