A replica-aircraft builder models an FW-190 fuselage skin in SolidWorks. Lofted surface, roughly 1.2 metres long, tapering and curving in both directions. They try Flat Wrap. SolidWorks flattens a strip down the middle and nothing else. They try Flatten Surface. It runs, produces a shape that’s 30% larger than the original, and when they cut aluminium to the pattern and try to form it, the edges don’t align by inches.

The issue isn’t a SolidWorks bug. It’s that sheet-metal flattening in SolidWorks — and in every parametric CAD kernel — is mathematically limited to a specific class of surfaces. Compound-curvature parts are outside that class, and the result of asking SolidWorks to flatten them is either nothing, or the wrong shape confidently presented as correct.

This post is about the geometry that decides whether a surface can be flattened at all, why Flat Wrap and sheet-metal flat patterns succeed on some parts and fail on others, and what happens when you reach for a different tool — specifically Rhino’s Squish command — to handle the compound-curvature case.

The mathematical line: Gaussian curvature

Take any point on a surface and consider the two principal curvatures at that point — the maximum and minimum curvatures of the normal sections through it. Multiply them. That product is Gaussian curvature, K.

  • K = 0 everywhere: the surface is developable. It can be unrolled onto a plane without stretching, compressing, or tearing. A cylinder, a cone, and any tangent-plane surface traced by a single line family fall in this category.
  • K ≠ 0 somewhere: the surface has compound curvature. Isometric flattening to a plane is mathematically impossible without distortion.

This is Gauss’s Theorema Egregium — Gaussian curvature is an intrinsic property of the surface. No amount of folding, rolling, or unrolling can change it. If the 3D surface has non-zero K at some point, the 2D flat version of that point has K = 0 (a plane has K = 0 everywhere), which means something has to give. Either the area at that point expands or contracts, or the local lengths change. Physical sheet metal handles this by actually stretching — drawn aluminium panels thin and neck during forming. CAD software can’t stretch a digital surface, so it either refuses to flatten or generates a pattern with known distortion.

Aircraft skins, boat hulls, lampshades with double curvature, automotive exterior panels — all non-developable. Cylindrical ducts, cones, and ruled surfaces with a straight generator — developable.

What SolidWorks sheet metal actually does

The sheet-metal environment in SolidWorks is built on a specific assumption: the part is made of flat regions joined by cylindrical bends. Each flat region has K = 0 by definition. Each bend is a partial cylinder, also K = 0. The entire sheet-metal body is therefore developable piecewise, and the flat pattern is produced by rotating each bend around its bend axis until the adjacent flats are coplanar.

Decompiling SolidWorks.Interop.sldworks.dll shows the flatten path going through IFeatureManager::InsertSheetMetalFlattenFeature, which invokes the internal kernel’s unfold operation. That operation reads the bend graph built during sheet-metal construction — each bend knows its axis, angle, radius, and the two adjacent flat faces — and walks the graph, applying 2D rigid transforms to each face until they all live in the same plane. There’s no curvature analysis, no stretching calculation. It’s pure topology and rotation.

This is why Convert to Sheet Metal on a part SolidWorks thinks has bends works, and why trying to convert a patterned solid body into sheet metal produces long rebuild times without gaining anything useful. The sheet-metal flatten is a graph-walker, not a surface flattener.

Flat Wrap — the special case

Flat Wrap is the feature people reach for when the part isn’t formal sheet metal but they want something flattened. It appears in the Sheet Metal toolbar and takes a face on the model, a point to start from, and optionally a set of sketches or curves to project onto the flattened result.

Under the hood, Flat Wrap does exactly one thing: it takes a single developable surface and unrolls it, using the start point as a reference. If the selected face is cylindrical, conical, or a tangent developable (K = 0), Flat Wrap produces the correct planar representation. If it isn’t — if the face has any Gaussian curvature — Flat Wrap either fails silently, produces a degenerate result, or flattens only the portion of the face that happens to be developable.

The replica-aircraft fuselage case: the lofted skin has K ≠ 0 across almost its entire span (that’s what gives the compound curvature), so Flat Wrap can only unroll the thin ruled-surface strip near the centre. Everything else is mathematically unflattable by this algorithm.

There’s a second trap: Flat Wrap of a face on a solid body produces a reference surface, not a new sheet-metal body. You can project annotations, sketches, and hole patterns onto it, but you can’t then treat it as a manufacturable flat pattern with material properties or bend lines. It’s a geometry tool, not a production tool.

SolidWorks Flatten Surface — and its distortion problem

Surface → Flatten Surface is a different beast. It exists specifically to handle non-developable surfaces — and it tells you, in the Property Manager, that this is what it’s for. You select the surface to flatten, pick a vertex or edge as the anchor, optionally define internal constraint regions, and it produces a planar representation.

What it’s doing internally is more interesting than the documentation admits. The algorithm appears to be a finite-element-style relaxation: the surface is discretised into a triangulated mesh, and the solver minimises an energy function that penalises both area changes and edge-length changes per triangle, subject to the anchor constraint. This is close to what academic papers call constrained parameterisation — the same problem solved in different ways by different solvers.

FreeCAD’s implementation in src/Mod/Surface/App/ and the Nurbs workbench uses a similar approach but exposes more parameters. The OCC kernel’s BRepOffsetAPI_MakeFilling and GeomPlate_BuildPlateSurface can be configured with explicit continuity, deflection, and tension weights — which is why FreeCAD users sometimes get better results on compound surfaces than SolidWorks users, despite the less polished UI. The trade-offs are explicit instead of hidden.

Flatten Surface in SolidWorks hides the trade-offs. It runs, produces a result, and doesn’t tell you how much the flattened shape distorts from a true physical flatten. A 1.2 m fuselage skin flattened this way can grow by 5–30% in area depending on curvature concentration, with the error non-uniformly distributed. If you cut the pattern and try to form it, the panel either doesn’t reach the edges of the frame or buckles where the solver compressed area.

There’s a specific case where Flatten Surface works well: mildly curved panels where the Gaussian curvature is small but non-zero (thin-gauge automotive panels, shallow-drawn enclosures). The distortion is small enough that forming the actual sheet metal can absorb the error. For steeply compound surfaces, the output is geometry the solver produces without telling you it isn’t physically accurate.

Rhino’s two flatten commands

Rhino exposes the same problem through two distinct commands with different algorithmic foundations, and choosing the right one depends on the surface.

UnrollSrf

UnrollSrf is Rhino’s equivalent of SolidWorks Flat Wrap. It only works on developable surfaces — the Rhino documentation says this explicitly, but the error message when it fails is vague enough that people miss it.

The algorithm requires K = 0 along the full surface. Rhino checks this by computing Gaussian curvature at a sample grid and rejecting surfaces where the maximum K exceeds a tolerance (controllable via the AbsoluteTolerance system setting divided by the surface’s bounding box diagonal). If the surface passes, Rhino walks its ruling lines — the straight-line generator that defines a developable — and unrolls each ruling onto the plane.

The failure mode is the same as Flat Wrap: lofted surfaces, patches with NURBS tensor-product structure, anything approximated from scan data. UnrollSrf returns an error, and the common workaround — “just offset it first and then unroll the offset” — doesn’t actually help because offsetting doesn’t change K.

Squish

Squish is categorically different. It doesn’t require developable input. It accepts mesh or NURBS (which it internally meshes) and flattens via stress-based relaxation.

The algorithm treats the 3D surface as a mesh of triangles and defines an energy function over the 2D mapping:

$$ E = \sum_{t \in triangles} w_a \cdot (A_{2D}(t) - A_{3D}(t))^2 + w_e \cdot \sum_{e \in edges(t)} (L_{2D}(e) - L_{3D}(e))^2 $$

Each triangle’s area change and each edge’s length change contribute to the energy, weighted by parameters the user can set. The solver iterates, moving 2D vertices to minimise E, subject to the boundary conditions. The output is a 2D layout that is the closest achievable approximation to isometry — it preserves what it can and makes the compromises visible via a distortion colour map.

The distortion map is the critical output. Rhino’s Squish colours the flattened mesh by per-triangle strain: red regions compressed, blue regions stretched, green near-unchanged. A fabricator looking at this map knows where the physical material will need to stretch or draw, and can plan darts, relief cuts, or multi-piece splits accordingly.

For the FW-190 fuselage, the Squish result on a single skin panel shows concentrations of compression near the cockpit taper and stretch along the tail — exactly matching where a sheet-metal shop would need to add shrinking and stretching operations to form the real panel. It’s not a lie about being flat; it’s a planar approximation with the errors labelled.

When to use which: if the Gaussian curvature analysis (Analyze → Surface → Curvature) shows K below your tolerance across the whole surface, use UnrollSrf and get an exact flatten. If K is non-zero anywhere, UnrollSrf will fail. Use Squish and read the distortion map to decide whether the part is producible in one piece or needs splitting.

The export flow from Rhino back to the laser

Once Squish produces a 2D layout, it’s in Rhino as a curve-and-surface representation. Exporting to DXF for a laser cutter or waterjet takes a few specific steps, and skipping them produces DXFs that cutters choke on.

1. Select only the 2D flatten output (not the distortion mesh).
2. File → Export Selected → .dxf
3. In the DXF export options:
   - Scheme: "2007 Lines" or "2007 Natural" (NOT Polylines for curved output)
   - Split closed curves: off (cutters prefer closed polylines)
   - Join lines to polylines: on
   - Export all objects in one layer: off (keep Squish's layer separation)
4. Open the DXF in LibreCAD or a neutral viewer.
   Verify curve count matches expectations.

The Scheme setting matters. “Polylines” schemes approximate curves as straight-line segments — this is the Rhino equivalent of the draft-quality trap when exporting DXF from SolidWorks drawings, and it has the same consequence: a pattern that looks smooth in CAD but cuts as a faceted polygon. For laser and waterjet, keep curves as arcs and splines wherever possible.

The layer separation preserves Squish’s boundary vs interior distinction, which the cutter can use to sequence cuts (perimeter last, interior holes first). Flattening everything to a single layer makes this harder for downstream CAM.

Once the DXF is clean, the metadata and layer conventions fabricators need still apply — material, thickness, part ID in a consistent layer scheme.

When SolidWorks can still help: the hybrid flow

For parts that have a mix of developable regions and compound-curvature regions, a hybrid flow often gives the best result:

  1. Model the developable regions as sheet metal in SolidWorks. These get clean flat patterns via the standard unfold, complete with bend lines and relief cuts.
  2. Model the compound regions as lofted or boundary surfaces, not as sheet metal.
  3. Export the compound surfaces as STEP to Rhino.
  4. Run Squish in Rhino, read the distortion map, decide on seams and darts.
  5. Export DXF for both sets, merge them in the shop-floor file.

This is how aircraft skin panels are handled professionally. The cockpit frame and stringers are sheet metal (developable bends, clean flat patterns). The skin is compound, squished in Rhino or a dedicated tool like ExactFlat, and the two meet at defined seam lines. The SolidWorks side handles what it’s good at — parametric sheet metal with bend information — and the Rhino side handles what SolidWorks can’t handle at all.

How SolidWorks creates flat patterns for DXF export covers the sheet-metal side of this in detail. The compound-curvature side genuinely needs a different tool.

Checking before you commit

Before starting a sheet-metal or flat-wrap workflow on any non-obvious part, run the Gaussian curvature check.

In SolidWorks: View → Display → Curvature shows K as a colour map on the selected face. Default legend runs green (near zero) to red (high positive K) to blue (high negative K). A surface that’s entirely green can be flattened. Anything with red or blue regions can’t — not by sheet metal, not by Flat Wrap, and Flatten Surface will distort.

In Rhino: Analyze → Surface → Curvature Analysis with Style set to “Gaussian” gives the same visualisation. Rhino additionally exposes the numerical min/max K, which SolidWorks hides.

This takes thirty seconds and saves hours of trying to make the wrong tool work on the wrong surface. For any part coming out of a scanner, a freeform surface modeller, or a lofted construction, this is the first thing to check before choosing a flatten strategy.

The short version

Sheet-metal flattening and Flat Wrap in SolidWorks are developable-surface algorithms — K must be zero everywhere or they fail. Compound-curvature parts aren’t flattenable by those tools, full stop. Flatten Surface attempts it but hides the distortion. Rhino’s UnrollSrf is the same developable-only algorithm; Squish is a distinct stress-based relaxation that produces a distortion-labelled approximation for compound surfaces. The right workflow for complex parts splits the work: developable regions stay in SolidWorks sheet metal, compound regions go to Rhino Squish (or a commercial tool built for the same problem), and the DXFs merge at the shop floor.

For teams running batch DXF export out of SolidWorks for mixed parts — some sheet metal, some assembled from tab-and-slot weldments, some that need hybrid treatment — knowing which category a part falls into before the export runs is what keeps the DXF pipeline honest. A tool like CadShift handles the developable side cleanly and fails loudly on the cases it can’t, which is the right behaviour — silent wrong flattens are worse than no flatten.