A mesh doesn't know what it is
The original design behind a CAD part has crisp notions of a planar face, a cylindrical bore, a fillet blending two walls. The moment it is exported to a mesh for printing or sharing, all of that is thrown away — what survives is positions and triangles, an undifferentiated shell approximating the shape. The structure a designer thinks in ("this part has eleven surfaces") is simply gone.
That missing structure is useful for almost everything you might do next: selecting a whole face to measure it, checking wall thickness, finding the holes, telling flat from curved, colouring each surface on its own. All of it is easy once you know which triangles belong together, and awkward or impossible when you don't. MeshSeg recovers it — and names each surface by type.
Technical architecture and process
The application relies on a neural network trained exclusively on the ABC dataset. The system operates through a two-step pipeline:
- Prediction. The model evaluates the mesh to predict a surface type for every face, and determines whether each mesh edge constitutes a true border between two different surfaces.
- Segmentation. A multicut process translates these predictions into cohesive regions, maintaining the integrity of smooth surfaces even where they meet tangentially — so a fillet running into the face it rounds off stays one surface, not a shattered band of triangles.
To prioritise data privacy and instant execution, MeshSeg runs entirely client-side without requiring a server. The surface operators and region processing run in a C++ core compiled to WebAssembly (WASM), while the neural network uses ONNX Runtime via WebGPU (with a WASM fallback) inside a Web Worker, so the page stays responsive while a part is being analysed.
Note on this page: the four parts in the demo above replay a segmentation that was computed ahead of time and shipped as a small table of labels, so the teaser loads instantly and ships no model. The architecture described here is what produces that result in the full app, where the same computation runs on a mesh you provide.
Performance and accuracy results
The model's performance was evaluated on parts it was never exposed to during training, using the B-rep faces of the original STEP files as ground truth (faces of one type that meet tangentially, under 5°, are merged into one visible surface). Boundary F1 serves as the primary evaluation metric because area-based scores can obscure accuracy on small, critical surfaces like fillets — and on false cuts hidden inside large ones.
Beyond the held-out ABC test set, the same pipeline was run unchanged on two independent CAD sources — Autodesk's Fusion 360 Gallery (parts designed in Fusion 360) and MFCAD++ (synthetic machined blocks) — to check that it generalises past the dataset it was trained on.
| Metric | ABC test | Fusion 360 Gallery | MFCAD++ | Fusion + MFCAD++ pooled |
|---|---|---|---|---|
| parts | 1,107 | 947 | 990 | 1,937 |
| boundary F1 | 98.91% | 98.10% | 99.94% | 99.22% |
| boundary precision / recall | 98.61 / 99.22% | 97.95 / 98.25% | 99.95 / 99.94% | 99.17 / 99.28% |
| mIoU (by area) | 0.9779 | 0.9703 | 0.9975 | 0.9842 |
| area in its own surface's region | 98.70% | 98.39% | 99.97% | 99.20% |
| region count exact | 78.2% | 83.2% | 96.2% | 89.8% |
| region count within ±20% | 96.0% | 92.8% | 100% | 96.5% |
| too few / too many regions | 8.0 / 13.7% | 6.5 / 10.2% | 2.2 / 1.6% | 4.3 / 5.8% |
| true surfaces lost (best IoU < 0.5) | 2.10% | 4.39% | 0.11% | 1.54% |
| fillets found (IoU ≥ 0.5) | 88.0% | 88.9% | 95.9% | 90.2% |
All figures are on parts the model never saw in training. Ground truth is the B-rep faces of the STEP files.
The headline is a boundary F1 of 98.91% on held-out ABC parts, holding up across both outside sources (a pooled 99.22%). The hardest cases are the ones you would expect: tori, and small fillets whose tangent border lives in a strip only a triangle or two deep — most lost surfaces are merges into a neighbour of the same type, almost never a surface split in two. Fillet recovery at ~88% is called out on its own because fillets are both the easiest surfaces to miss and often the ones that matter most for printing and machining.
Why it runs in the browser
This is the same principle behind the rest of MeshTune. Your geometry is yours; it should not have to travel to a server to be understood. The segmentation runs where your other mesh work already runs — in the tab, on your machine — so a model you are not ready to share never leaves it.
Surface-aware meshes are a foundation for a lot of what comes next in MeshTune — smarter selection, per-surface analysis, cleaner print preparation. This is the first piece of it, and the parts above are the proof.