The DXF comes back from the shop and half the edges are gone. The drawing view looks correct on screen, the Save As DXF runs without errors, but the file a laser cutter opens has a rectangle where there used to be a contoured profile. If this part started life as a STEP import, the chain of failures is almost always the same, and the root cause is not in the DXF export — it’s in the imported body.

This post walks through why STEP imports silently produce DXFs that are missing geometry, what SolidWorks is actually doing under the hood during the export, and how to catch the problem at import time so it never reaches the drawing.

The failure pattern most people see first

You open a supplier’s STEP file. It comes in clean — one solid body, no error dialogs, shaded view looks correct. You drop it into an assembly or build a drawing from it. Dimensions work. Projected views line up. You Save As DXF for laser or waterjet and open the output.

Some edges are missing. Some are there but broken into short line segments that don’t reconnect. Views that were clearly contoured are now simple outlines. On forum threads, the accepted advice is almost always the same: “try toggling display quality to Draft” or “turn off high-quality mode for that view.” That sometimes produces a more complete outline — but you’ve traded accuracy for completeness. The draft-quality version is a rasterised approximation of the edges, not the real B-rep curves.

The real problem is that the STEP file contained topology errors — surfaces that aren’t properly joined, gaps between faces, or tiny invalid edges — and SolidWorks tolerated them for shaded display but can’t handle them when the drawing view has to be converted to high quality for DXF output.

What high-quality mode actually does

Drawing views have two display modes. Draft quality traces the visible silhouette using the view’s tessellation — essentially the same mesh that shades the preview window. High quality computes the projected edges from the underlying B-rep: it walks the solid’s topology, finds every edge that is visible from the view direction, trims edges against occluding faces, and writes the result as exact 2D curves.

DXF and DWG export forces high quality on every view before writing the file. This is documented but easy to miss: the format stores 2D geometry as lines, arcs, and splines, and those have to come from somewhere. SolidWorks generates them by asking the solid for its projected edges, which requires a fully closed, topologically valid body.

If the body is invalid — even subtly — the high-quality projection fails. The view either falls back to a degraded representation or drops the affected edges silently. You get no error, no warning dialog. The export completes. The DXF is just incomplete.

Decompiling SolidWorks.Interop.sldworks.dll shows the relevant path: IDrawingDoc::SaveAs3 calls into the view-conversion layer which invokes IView::HideView toggles and then IView::SetDisplayMode3. When that call hits a view backed by an invalid body, the internal return code is swallowed — the COM method returns success, but a flag on the view indicates partial conversion. Nothing in the standard UI surfaces that flag, so the user sees a clean Save As and a broken file.

Why STEP imports produce this specifically

STEP (ISO 10303-242) stores geometry as explicit surface definitions — NURBS patches with trim curves — plus topology that describes which patches connect to which others. The format is a strict mathematical description, but it is lossy in a specific way: the coordinates are stored as floating-point numbers, and the translating application rounds them to its own precision before writing.

When SolidWorks imports a STEP file, it reads each face’s geometry and then tries to reconcile the topology. If two faces that should share an edge have endpoint coordinates that differ by more than SolidWorks’s tolerance — usually 1e-8 metres internally but higher for imports — the topology stitching fails. The face gets imported, but it’s floating next to the neighbouring face with no shared edge. The body contains the face; the body’s topology says nothing connects it.

This is what “unhealed surface” means in the Import Diagnostics dialog. The face is there, but the edge that should let you project, fillet, or export it is missing.

FreeCAD’s implementation in src/Mod/Part/App/TopoShape.cpp shows the same problem from the other side. The read() method for STEP calls STEPControl_Reader::TransferRoots and then explicitly runs BRepBuilderAPI_Sewing with a configurable tolerance — because OpenCASCADE (which FreeCAD wraps) knows that STEP files almost never come in with edges aligned to sub-micron precision, and the sewing step is what turns a pile of patches into a watertight solid. SolidWorks does the equivalent internally, but the tolerance is hardcoded per-import unless you intervene.

This is why the same STEP file sometimes imports clean and sometimes doesn’t: it depends on the precision the exporting system wrote and whether that precision sits above or below SolidWorks’s internal threshold.

Diagnosing the import before you draw it

Two tools exist for this, and you should run both on any STEP import headed for DXF output.

Import Diagnostics

When you first open a STEP file, SolidWorks offers to run Import Diagnostics. If you dismiss that dialog, you can re-run it any time from the feature tree: right-click the imported body → Import Diagnostics. The tool scans the body for faulty faces (self-intersecting, degenerate, or non-manifold) and gaps between faces (unhealed edges that should connect).

Attempt to Heal All closes small gaps by extending surfaces to meet. It works on maybe 70–80% of real-world STEP imports. The remaining cases need manual repair with the surfacing toolbar.

What most people miss: Import Diagnostics is not just about visual correctness. A gap between two faces that is half a micron wide will heal automatically in the preview, but if it doesn’t get healed in the body, it will break DXF export. Always run this step, even if the model looks perfect.

The Check command

Tools → Check is the forgotten sibling. It’s faster than Import Diagnostics — it uses the Parasolid kernel’s internal validator directly — but it doesn’t attempt to fix anything. Use it as a preflight check on bodies that have been through Import Diagnostics already, to catch the cases where healing left subtle invalidities.

Check reports four categories: invalid faces, bad edges, short edges (below the minimum length), and self-intersections. Anything in the first three will almost certainly degrade the DXF. Self-intersections are rarer from STEP imports but show up in lofted surfaces that were approximated during translation.

API-level checking for batch pipelines

If you’re importing STEP files as part of an automated pipeline, call the diagnostics from code. The COM interface exposes IModelDocExtension::CheckBodies:

var ext = (ModelDocExtension)model.Extension;
var part = (PartDoc)model;
var bodies = (object[])part.GetBodies2((int)swBodyType_e.swSolidBody, false);

foreach (Body2 body in bodies)
{
    int checkStatus = 0;
    ext.CheckBodies(
        body,
        true,   // check faces
        true,   // check edges
        true,   // check short edges
        out checkStatus);

    if (checkStatus != 0)
    {
        // checkStatus is a bitmask: 1=invalid faces, 2=bad edges,
        // 4=short edges, 8=self-intersecting
        Console.WriteLine($"Body check failed: 0x{checkStatus:X}");
    }
}

The status bitmask is documented in the API help as swBodyCheckFlags_e, but the decompiled SolidWorks.Interop.swconst.dll also lists a swCheckSelfIntersect flag at bit 3 that isn’t in the public docs. Worth checking if you’re tracking down intermittent DXF failures.

If you run CadShift for batch DXF export, the add-in runs this check automatically on every body before it writes a DXF, and flags the ones that fail so you know which imported parts need surgery before the next batch.

Fixing surfaces when Heal All gives up

For the 20% of cases Import Diagnostics can’t resolve, the sequence is usually:

1. Identify the problem face. Import Diagnostics highlights it. If Check found it, use Tools → Check → What's Wrong to select.

2. Delete the faulty face. Insert → Face → Delete with the Delete option (not Delete and Patch or Delete and Fill — those try to close the hole with a new surface, which defeats the purpose).

3. Reconstruct cleanly. The fastest method depends on the face geometry:

  • Planar face: Surface → Planar Surface bounded by the surrounding edges
  • Simple curvature: Surface → Loft or Surface → Boundary Surface using the adjacent edges as guides
  • Fillet-like transitions: Surface → Fillet between the neighbouring surfaces
  • Everything else: Surface → Fill with all surrounding edges selected as curve-constraint inputs

4. Knit the result. Surface → Knit with “Try to form solid” checked. This is the step that rebuilds topology. If the knit succeeds and produces a solid, you’re done. If it produces a surface body, there’s still a gap somewhere.

5. Re-check with Import Diagnostics and Check. Both, in that order.

For parts where this would take longer than the part took to model in the first place, consider re-exporting the STEP from the source system at a tighter tolerance. Most CAD kernels let you set the export tolerance — SolidWorks itself exposes this as the System Options → Export → STEP → Output coordinate system precision setting. A STEP file written at 1e-7 precision imports cleanly into anything; one written at 1e-4 will break on import almost everywhere.

The drawing-view trap

Even with a valid body, there’s one more place DXF export can lose edges: the drawing view itself.

Drawing views cache their geometry. When you create a view from a healthy model and later modify the model, the view updates on rebuild — but if the model was invalid when the view was first created, the view’s cached projection is already broken. Fixing the model later won’t automatically fix the view.

The symptom: you’ve fixed the import, Check reports clean, but DXF export still drops edges. The fix: right-click the view → Rebuild View (or delete and recreate it). This forces SolidWorks to regenerate the high-quality projection from the now-valid body.

This matters more than it should. Watch for it specifically on views that were created during the troubleshooting cycle — they carry the broken state forward even after the underlying issue is resolved. It’s the same category of cached-state bug that affects how SolidWorks creates flat patterns for DXF export, where the flatten sub-feature holds onto old geometry until rebuilt.

Why the “turn off high quality” workaround is a trap

It works often enough that it’s repeated on every forum thread, but it’s a workaround, not a fix. Draft-quality export traces the view’s current tessellation — a triangle mesh generated for screen display — and writes the silhouette as straight line segments.

For a rectangular bracket you might not notice. For anything with arcs, splines, or tight corners, the DXF looks smooth on screen but the laser cutter or CNC runs it as a faceted polygon. Cutting tolerances degrade from the sub-thousandth-of-an-inch accuracy that high-quality projection gives you to roughly the tessellation density — typically 0.01 to 0.1 inches depending on the view scale.

If the shop re-imports that DXF and dimensions it, the numbers will be slightly off. Hole centres drift. Radii become polygonal. If they’re checking their work against your drawing, the measurements won’t match. You’ve moved the problem from “visible missing edges” to “invisible wrong edges.”

The fix is always to heal the body, not to degrade the export. Teams that produce DXFs fabricators can actually use never ship draft-quality as a long-term solution.

Putting it in a checklist

For every STEP import that’s going to a drawing:

  1. On import: run Import Diagnostics. Do not dismiss the dialog.
  2. After Heal All: run Tools → Check. Confirm zero errors across all four categories.
  3. On the body: verify it’s a solid body, not a surface body. If it’s surface, Knit it into a solid.
  4. On the drawing view: if the view was created while the model was broken, Rebuild View after fixing the model.
  5. Before DXF export: confirm the view is in High Quality mode (View palette → Display Style → shaded with edges is fine, but the cached display style that SaveAs triggers must succeed).
  6. After DXF export: open the DXF in a neutral viewer (not the source CAD) and confirm edge count matches expectations. This is the step most pipelines skip.

That last check — opening the DXF in something other than SolidWorks — is the one that catches the silent failures. SolidWorks caches the drawing and shows you a rendered preview that may not match what it wrote to disk.

The short version

STEP imports carry invisible topology errors that SolidWorks tolerates for shading but not for DXF export. The export path forces high-quality view projection, which requires valid topology, which the imported body may lack. The failure mode is silent: clean Save As, broken DXF. Import Diagnostics and Check together catch 95% of these at import time, before the errors propagate into drawings. The “disable high quality” workaround trades visible failures for invisible ones and should not be used for production exports.

If you’re handling imported STEP files in volume, pushing the checks into an automated pipeline (either your own API script or a tool like CadShift that runs them as part of batch DXF export) turns a recurring shop-floor problem into a preflight check that fails loudly at import time instead of silently at export time.