Why Is My Model Slow? Precision, Bounds, Engines

A slow Rig Cad model is almost always one node doing far more sampling than the part needs. The fix is rarely a faster computer; it is finding that node, reading which of four settings made it expensive, and changing that setting. This article is the diagnostic path: where to look, a symptom table, the cube law behind SDF precision, and what the engine and GPU choices actually change.

Every node reports its own solve time and triangle count in Object Properties, and the Debug tab on an SDF operation shows the sample grid it used and whether the GPU ran. Select nodes from the root downward and read the times: the slow one is usually obvious, and it is usually a single SDF operation or one heavy primitive, not the tree as a whole.

Two things about the solver make the numbers easier to read. Only dirty branches re-solve, so a change to a leaf costs that leaf and its ancestors, while a change to a variable that feeds twenty nodes costs all twenty. And a node that reports empty is not slow, it is broken; everything above it is empty too, and the warning names the branch, so read that before tuning anything.

Table: The common slow cases.

The table's first two rows account for most reports, and both come from one relationship.

An SDF operation samples its field on a grid. The grid edge is the node's bounding box, plus boundingBoxPadding on every side, divided by precision. Three axes means the sample count is that number cubed:

$$N \approx \left(\frac{\text{span} + 2\,\text{padding}}{\text{precision}}\right)^{3}$$

The companion project is a 40 mm blended part. At precision 0.6 it sampled a 135³ grid, about 2.5 million cells, and solved in 0.25 s. At precision 0.3 it sampled 268³, about 19 million cells, and took 1.07 s while producing four times the triangles. Halving precision cost roughly four times the time here because only the surface cells produce work; a fully dense field would have cost eight.

Three consequences:

• Precision is per node. Put a fine precision on the small group that has the detail and a coarse one on the large group that does not. A 0.15 mm precision on a 200 mm enclosure is a billion samples; the same precision on the 12 mm boss that needs it is trivial.
• Padding is not free. It widens the span on every axis before the cube. Use it only when a blend or an offset is being clipped at the bounds, and keep it to a few millimetres.
• Size counts. A part scaled up two times needs eight times the samples at the same precision. Scale precision with the part.

The Signed Distance Fields article explains why the field is sampled at all; Export for the Slicer has the same measurements from the file-size side.

Every SDF operation has an sdfEngine, exposed in the demo as engine:

• Rust LevelSet is the manifold-first mesher and the only one that can run on the GPU. It is the right default for anything that has to print.
• Rust Adaptive is usually the fastest and falls back to LevelSet automatically if its result is not manifold.
• Rust Adaptive v2 uses a topology-safe QEF; reach for it when Adaptive drops thin features.

With LevelSet, gpuSdfPreference decides whether the sample grid runs on WebGPU. Auto uses the GPU when the browser offers one and the grid fits the voxel budget. gpuSdfMaxSamplesPerAxis states that budget as the edge of an equivalent cube, 503 by default, so a flat part can exceed the number on its long axes and still fit. A grid that does not fit falls back to the CPU mesher silently apart from the Debug tab, which is the second row of the symptom table. Lower the budget if solves run out of graphics memory; raise precision if they fall back.

gpuSdfSharpFeatures adds a CPU refinement pass that keeps extrusion rims and corners crisp on the GPU mesher, at the cost of time; the Debug tab reports whether it applied.

Mesh-mode operations cost what their inputs weigh. A sphere at 160 segments is 25 times the triangles of one at 32; a rounded extrude edge was measured at over 200,000 triangles against 220 for a chamfer; and a Boolean of two such meshes is slower than either. The sphereSegments control on the demo makes the first case visible. Fillets and Chamfers covers the second, and Mesh Cleanup covers what to do when a heavy mesh also arrives damaged.

Repeats multiply. A Linear Repeat of a 10,000-triangle child at 5 by 5 is 250,000 triangles before the union that joins them. When copies are identical, tile the profile in 2D and extrude once, as in Repeats and Arrays; the solid never exists 25 times.

1. Find the slow node from its reported solve time.
2. If it is an SDF operation: raise precision, zero the padding, check the Debug tab for a CPU fallback.
3. If it is a primitive or extrude: lower segments, use a chamfer, drop edgeSegments.
4. If it is a repeat: lighten the child, or tile in 2D.
5. Only then reach for decimation, the Decimate step, or a different engine.
6. Model coarse while iterating and refine precision once the geometry is approved; the setting is a number on the node, not a decision you are stuck with.

The Post-Processing stack runs after the node solves, so a slow Shell, Remesh or Infill step shows up as time on the node that owns it; the same diagnostic applies.