SolidWorks vs Inventor vs FreeCAD Fillet Failures — Why Blends Fail and How Each Kernel Handles It

You click “Fillet,” pick an edge, type a radius, and hit the green check. The edge rounds off. Done.

Until it isn’t. Until you get “Fillet operation failed” on a perfectly reasonable-looking edge. Or until the same 2mm radius works on one edge but blows up on the adjacent one. Or until your model rebuilds fine in SolidWorks but the same STEP file fillets differently in Inventor.

These aren’t random bugs. They’re the predictable result of three completely different geometric kernels making three completely different decisions about how to roll a ball along an edge. We decompiled the DLLs, read the exported symbols, and walked through the open-source code to see what’s actually happening.

The three kernels

Every fillet operation in a B-Rep modeler delegates to the geometric kernel — the engine that actually manipulates topology and geometry. The CAD application’s UI is just a wrapper.

• SolidWorks uses Parasolid (Siemens), loaded from pskernel.dll. This same kernel powers NX, Solid Edge, and several other commercial CAD systems. (We first encountered pskernel.dll in our flat pattern deep dive.)
• Autodesk Inventor uses ShapeManager, Autodesk’s proprietary fork of the ACIS kernel (originally from Spatial Technology). The core libraries load as ASMKERN231.dll, ASMAHL231.dll, and ASMBASE231.dll, linked through Inventor’s modeling interface layer Mi-Inv.dll. (For more on the architectural differences between SolidWorks and Inventor, see our earlier post.)
• FreeCAD uses OpenCASCADE Technology (OCCT), an open-source B-Rep kernel. The fillet call goes directly to BRepFilletAPI_MakeFillet — no proprietary wrapper, no hidden logic. (We explored OCCT’s projection pipeline in our FreeCAD TechDraw deep dive.)

These aren’t interchangeable. Each kernel makes fundamentally different architectural choices about how fillets work, how they fail, and what happens at difficult geometry.

What happens inside SolidWorks when you create a fillet

When you invoke a fillet in SolidWorks, the API call goes through IFeatureManager::FeatureFillet3, which accepts 13 parameters:

The Options parameter is a bitmask built from swFeatureFilletOptions_e:

This API call gets translated into the feature data objects — ISimpleFilletFeatureData2 for constant-radius, face, and full-round fillets, or IVariableFilletFeatureData2 for variable-radius fillets. These objects carry properties like CurvatureContinuous, OverflowType, ConstantWidth, AsymmetricFillet, ConicTypeForCrossSectionProfile, and HoldLines.

The DLL call chain

We mapped the full fillet call chain through SolidWorks’ native DLLs:

SolidWorks API (COM)
    → SLDMODU.dll    (moBlend_c, moNetBlend_c, moBlendData_c)
    → sldgcu.dll     (frSwiftFillet_c, gcDirectFillet_c, gcBaseBlendingFunctionBuilder)
    → sldgciParau.dll (gciCflConstEdgeFillet_w, gciCflVertexFillet_w — the Parasolid bridge)
    → pskernel.dll    (PK_EDGE_set_blend_constant — the actual kernel call)

The key architectural detail: pskernel.dll is delay-loaded — SolidWorks doesn’t statically link to Parasolid. The sole bridge is sldgciParau.dll, whose “Cfl” prefix stands for Constant Fillet Library, Parasolid’s fillet recognition and creation subsystem. The wrapper classes (gciCflFilletControls_w, gciCflConstEdgeFillet_w, gciCflVertexFillet_w, gciCflEdgeChamfer_w) map directly to Parasolid’s CFL API.

SolidWorks adds its own intelligence on top: sldgcu.dll contains six BlendingFunctionBuilder subclasses (Cubic, Default, Influence, Linear, Quintic, TangentInfluence) that implement different cross-section profile interpolations, and frSwiftFillet_c handles the instant preview computation.

Where Parasolid takes over

The real work happens in pskernel.dll. We dumped the exports and found 1,291 functions, of which 21 are directly related to blend (fillet) operations:

Legacy short-name functions (Parasolid’s original Fortran-era API):

• BLECHK — check blend validity
• BLECRB — create blend
• BLECVR — blend cover (surface generation)
• BLEENQ — blend enquiry
• BLEFIX — fix blend issues
• BLEFXF — fix blend on faces
• BLEREM — remove blend
• BLNAFF — blend name affinity
• BLNDVX — blend vertex

Modern PK_ API (the current Parasolid interface):

Notice something here. Parasolid doesn’t call them “fillets” — it calls them “blends.” A fillet in SolidWorks terminology is a “blend” at the kernel level. This distinction matters: Parasolid’s PK_EDGE_set_blend_constant is a surface operation that creates a rolling-ball blend surface between two adjacent faces. The fillet you see is the trimmed result after this blend surface intersects the neighboring geometry.

The function PK_BODY_fix_blends is particularly telling — it’s a repair function that attempts to fix blends that have gone wrong during model modification. When SolidWorks shows you a rebuild error on a fillet, it’s often because this function failed to find a valid blend configuration after upstream geometry changed.

Parasolid’s overflow handling

SolidWorks exposes three overflow modes through swFilletOverFlowType_e:

But Parasolid internally supports four overflow strategies — ov_smooth (smooth extension), ov_cliff (blend tangent to only one face at the boundary), ov_cliff_end, and ov_notch. SolidWorks only exposes three of these through the API. The “cliff” overflow — where the blend surface is tangent to only one adjacent face and runs along an edge in the other — is a specialized case that Parasolid handles automatically when ov_smooth fails.

When a fillet radius exceeds the available face width, the overflow type determines whether Parasolid extends the blend surface beyond the face edge or clips it. This is a common source of “fillet failed” errors — the default mode picks a strategy that doesn’t always work for the geometry at hand.

Profile types

SolidWorks supports four cross-section profile types through swFeatureFilletProfileType_e:

The CurvatureContinuous flag (separate from profile type) upgrades the blend from G1 to G2 continuity — matching curvature, not just tangency, at the blend boundaries. This requires Parasolid to compute higher-order surface patches and is significantly more computationally expensive.

What happens inside Inventor when you create a fillet

Inventor’s fillet operation flows through a different architecture. The COM API exposes FilletFeature, FilletDefinition, and specialized edge-set objects. The fillet type is one of three values from FilletTypeEnum:

The modeling interface layer

When you dig below the COM API, Inventor’s internal architecture becomes visible. The Mi-Inv.dll (Modeling Interface for Inventor) exports the actual C++ classes that do the work:

The diagnostic classes are significant. MIxDiagBlendEdgesFailed captures an MIxoutcome object plus the specific entities and 3D points where the failure occurred. This is how Inventor can highlight exactly where a fillet failed — the kernel reports the failure location back through structured diagnostics.

The reblend system

Inventor has something SolidWorks doesn’t expose at the same level: an explicit reblend system. When you modify a face that has fillets on it (taper, tweak, or other operations), Inventor doesn’t just rebuild the fillet from scratch. Instead, it uses MIxTaperReblend and MIxTweakReblend to intelligently re-derive the blend surface based on how the underlying face changed.

The nm.dll (Name Manager) tracks blend relationships through NMxTagMgrBlend, NMxTagMgrTaperReblend, and NMxTagMgrTweakReblend. These tag managers maintain the topological identity of blended faces across model edits — when a face is tweaked, the name manager knows which blend needs to be recomputed and how.

Inventor’s rolling ball options

The FilletFeature interface exposes several properties that reveal how ShapeManager handles the geometry:

The RollingBallWherePossible property is a clue about ShapeManager’s internal strategy. Unlike Parasolid, which uses rolling-ball blending as its primary method, ShapeManager apparently has multiple blend algorithms and selects rolling-ball only when it determines the geometry is suitable. When it isn’t, it falls back to an alternative method — likely a surface-fitting approach.

ShapeManager’s kernel architecture — ASMBLND231.dll

We found the actual ACIS blend kernel in an unexpected location: C:/Program Files/Common Files/Autodesk Shared/Components/2026/1.10.0/ASMBLND231.dll — a massive DLL with 5,800 exports dedicated entirely to blend operations.

The key ACIS blend API functions we found:

ACIS also provides 9 different radius-law functions for variable-radius specification:

This is significantly more radius-law variety than what Parasolid exposes — ACIS lets you define the radius as a spline curve, a rotated ellipse, or a fixed-width constraint, while Parasolid provides constant, variable (with control points), and chamfer modes.

ACIS also uses a session-based blend processing model (api_init_blend_ss → api_do_one_blend_ss → api_concl_blend_ss) that processes blends one at a time within a session context, allowing the kernel to maintain state between blends.

Inventor’s Mi-Inv.dll depends on several additional ShapeManager/ACIS libraries:

The ivtagm.dll exports show AgmSurfaceAdjustor with setBlendBackParam and kNoBlendBack — these control how blend surfaces are adjusted when they interact with adjacent geometry.

Constant vs variable radius in Inventor

Inventor separates its edge sets into FilletConstantRadiusEdgeSet and FilletVariableRadiusEdgeSet:

Constant radius properties:

• Radius — single radius value
• AllFillets / AllRounds — select all concave/convex edges
• ContinuityType — surface continuity setting
• InvertedFillet — flip the fillet direction

Variable radius properties:

• StartRadius / EndRadius — radius at each end
• IntermediateRadiusItem / IntermediateRadiusCount — additional radius control points
• ContinuityType — surface continuity setting

What happens inside FreeCAD when you create a fillet

FreeCAD’s fillet implementation is fully readable — it’s open source. The PartDesign module’s FeatureFillet.cpp shows the complete pipeline:

// From FreeCAD src/Mod/PartDesign/App/FeatureFillet.cpp
BRepFilletAPI_MakeFillet mkFillet(shape.getShape());
for (auto& e : edges) {
    const auto& edge = e.getShape();
    mkFillet.Add(radius1, radius2, TopoDS::Edge(edge));
}
return makeElementShape(mkFillet, shape, op);

That’s it. The entire fillet operation is five lines of kernel calls. FreeCAD creates a BRepFilletAPI_MakeFillet object, adds edges with radii, and calls Shape() to get the result.

The lower-level TopoShapeExpansion.cpp adds one validation step — checking that each edge actually belongs to the input shape:

if (!shape.findShape(edge)) {
    FC_THROWM(Base::CADKernelError, "edge does not belong to the shape");
}
mkFillet.Add(radius1, radius2, TopoDS::Edge(edge));

OpenCASCADE’s BRepFilletAPI_MakeFillet

OpenCASCADE’s fillet implementation uses the ChFi3d (Chamfer/Fillet 3D) algorithm internally. The BRepFilletAPI_MakeFillet class:

1. Takes a TopoDS_Shape (the solid body)
2. Accepts edges via Add() with radius parameters
3. Internally creates ChFi3d_FilBuilder which walks along each edge
4. For each edge, computes a rolling-ball spine curve using a ChFiDS_Spine data structure
5. Marches along the spine in discrete steps, computing contact curves at each step using Blend_Function (face-to-face), Blend_SurfRstFunction (edge-to-face), or Blend_RstRstFunction (edge-to-edge)
6. At each step, solves constraint equations using Blend_FuncInv and Blend_SurfCurvFuncInv inverse function solvers
7. Generates blend surfaces from three possible representations: ChFi3d_Rational (NURBS circular arcs), ChFi3d_QuasiAngular (angle-parameterized), or ChFi3d_Polynomial (polynomial approximation)
8. Trims the blend surfaces against adjacent faces and rebuilds topology

The algorithm tracks failures through ChFiDS_ErrorStatus: WalkingFailure (the marching algorithm couldn’t continue), TwistedSurface (self-intersecting result), Error (generic), or Ok. The builder also reports NbFaultyContours() and NbFaultyVertices() — but these diagnostics are minimal compared to what Parasolid and ShapeManager provide.

What FreeCAD can’t do

Looking at the code, FreeCAD’s PartDesign fillet has significant limitations compared to SolidWorks and Inventor:

• No variable radius — the PartDesign Fillet class only exposes a single Radius property. The underlying BRepFilletAPI_MakeFillet::Add() accepts radius1 and radius2 (start/end), and OpenCASCADE does support variable-radius fillets through SetRadius() with ChFiDS_FilSpine, but FreeCAD’s PartDesign module doesn’t expose this.
• No face fillet — no equivalent to SolidWorks’ face fillet or Inventor’s kFaceFillet.
• No full round fillet — no three-face blend support.
• No curvature-continuous option — G2 blending is available in OCCT but not exposed.
• No overflow control — no equivalent to SolidWorks’ OverflowType.
• No setback vertices — no corner control at blend intersections.
• No partial edge fillets — can’t fillet a portion of an edge.
• No conic profiles — only circular cross-sections.

The Part module’s FeatureFillet.cpp does support per-edge radius1/radius2 values (start and end radius), giving some variable radius capability — but this is separate from PartDesign and less commonly used.

Error handling: a crash guard

FreeCAD’s error handling is notably defensive:

// Signal handler for segfault protection (Linux only)
#if defined(__GNUC__) && defined(FC_OS_LINUX)
    Base::SignalException se;
#endif

That SignalException is a signal handler that catches SIGSEGV — a segmentation fault. OpenCASCADE’s fillet algorithm can crash the process on certain geometry, and FreeCAD installs a signal handler to convert the crash into a catchable C++ exception. This is a well-known issue: OCCT’s ChFi3d algorithm has edge cases where it dereferences null pointers or runs into infinite loops on degenerate geometry.

The catch block is equally telling:

catch (...) {
    return new App::DocumentObjectExecReturn(
        "Fillet operation failed. The selected edges may contain geometry "
        "that cannot be filleted together. "
        "Try filleting edges individually or with a smaller radius.");
}

The generic catch-all with a user-facing suggestion to “try filleting edges individually” reflects a real limitation of OpenCASCADE’s approach: multi-edge fillets are significantly less robust than single-edge fillets in OCCT.

Robustness comparison: where each kernel struggles

Parasolid (SolidWorks)

Strengths:

• Mature rolling-ball algorithm with decades of refinement
• PK_BODY_fix_blends provides automatic blend repair
• PK_EDGE_check_blends allows pre-validation before committing
• Strong support for multi-edge blends with proper intersection handling
• Four profile types including curvature-continuous (G2)
• Overflow handling with three distinct strategies

Weaknesses:

• Thin-wall geometry is the classic failure case — when the fillet radius approaches the wall thickness, Parasolid can fail to find a valid trim
• Complex multi-fillet intersections at vertices can produce unexpected results
• The “keep features” option doesn’t always preserve the intended geometry when fillets interact with bosses or cuts
• Propagation along tangent edges sometimes extends further than expected

ShapeManager/ACIS (Inventor)

Strengths:

• The reblend system (MIxTaperReblend, MIxTweakReblend) makes fillets more resilient to upstream model changes
• Structured diagnostic reporting through MIxDiagBlendEdgesFailed pinpoints exactly where and why a fillet failed
• RollingBallWherePossible suggests multiple internal algorithms with automatic fallback
• The name manager (NMxTagMgrBlend) provides robust topological tracking through edits
• Strong face-fillet and full-round support at the kernel level

Weaknesses:

• The ShapeManager fork diverged from mainline ACIS years ago, and some fixes in one don’t propagate to the other
• Variable-radius fillets can be less predictable than Parasolid’s, particularly at edge chain transitions
• The “AllFillets” / “AllRounds” convenience methods in FilletConstantRadiusEdgeSet can select edges you didn’t expect
• Performance on high-edge-count operations lags behind Parasolid in our testing

OpenCASCADE (FreeCAD)

Strengths:

• Completely transparent algorithm — you can read the source and understand every decision
• The ChFi3d_FilBuilder spine-based approach handles most common single-edge fillet cases well
• No licensing restrictions on the kernel
• BRepAlgo::IsValid post-check with ShapeFix_ShapeTolerance provides automatic tolerance repair

Weaknesses:

• Adjacent fillet collision is a 10-year-old unresolved bug — when fillets on adjacent edges meet at a tangent point with no linear segment remaining, OCCT fails. Commercial kernels handle this by deleting the intermediate face and connecting fillets as tangents. OCCT has no such fallback. (OCCT tracker #25478)
• Multi-edge fillets are the primary failure mode — OCCT struggles when multiple fillet surfaces must intersect at a vertex
• No crash protection on Windows (the SignalException handler is Linux-only). BRepFilletAPI_MakeChamfer errors sometimes can’t even be caught with try/catch before the crash occurs
• The algorithm can produce self-intersecting surfaces (TwistedSurface status) on high-curvature geometry
• No blend repair equivalent to Parasolid’s PK_BODY_fix_blends or ACIS’s api_fix_blends
• No pre-validation — you can’t check if a fillet will succeed before trying it
• As of OCCT 7.5.0, approximately 25 open bugs on fillet/chamfer functionality, with version-specific regressions (operations that worked in 7.3 crashed in 7.4, fixed again in 7.6)
• PartDesign only exposes constant-radius, single-radius fillets despite OCCT supporting more

The verdict: which is more robust?

Based on our analysis of the actual kernel code and APIs:

Parasolid (SolidWorks) is the most robust overall. The combination of PK_EDGE_check_blends for pre-validation, PK_BODY_fix_blends for automatic repair, four profile types, three overflow strategies, and decades of industrial refinement gives it the broadest success rate across different geometry types. The 21 dedicated blend functions in pskernel.dll reflect an enormous investment in edge-case handling.

ShapeManager (Inventor) is close behind, with better failure diagnostics. When Inventor’s fillets fail, the MIxDiagBlendEdgesFailed class tells you exactly which edges failed and where. The reblend system makes Inventor fillets more resilient to parametric model changes — where SolidWorks might show a rebuild error, Inventor can often re-derive the blend. The RollingBallWherePossible fallback system suggests more algorithmic flexibility than Parasolid’s more uniform approach.

OpenCASCADE (FreeCAD) is the least robust for production geometry. The lack of pre-validation, the need for segfault protection, and the limited PartDesign exposure (constant-radius only, no face fillet, no full round) put it behind the commercial kernels. The underlying OCCT algorithms are mathematically sound, but the implementation’s edge-case handling — particularly at multi-fillet vertices — doesn’t match what Parasolid and ShapeManager provide.

For CadShift users migrating models between systems, this means fillets created in SolidWorks may need to be recreated when brought into FreeCAD — the geometric kernel behind each system makes different assumptions about what constitutes a valid blend, and a fillet that “just works” in Parasolid might fail in OCCT on the same geometry. Understanding these kernel-level differences is key to planning CAD file migrations that don’t leave you debugging fillet failures for days.

SolidWorks vs Inventor vs FreeCAD Fillet Comparison Table

Three capabilities separate the CAD systems in practice: whether the kernel supports G2 curvature continuity at the blend boundary, whether you can shape the fillet cross-section with a conic/rho parameter, and how each system handles degenerate edge geometry (zero-length edges, near-tangent faces, and thin-wall conditions where the fillet radius exceeds the wall thickness).

The conic rho capability is the most visible gap when moving from SolidWorks to other systems. Class A surfacing and industrial design work depend on conic profile control — in Inventor, achieving the same visual result requires a hand-built lofted surface. In FreeCAD, there is no path at all within PartDesign.

What this means for the person actually using the fillet tool

The kernel differences aren’t academic. They dictate which buttons exist in the UI, which workarounds you need, and which designs are practical in each system.

Feature gaps that change your workflow

We compared every fillet property exposed by the SolidWorks and Inventor APIs. Some capabilities exist in one system but not the other — not because the developers forgot, but because the underlying kernel either supports it natively or doesn’t.

Things SolidWorks can do that Inventor cannot:

Things Inventor can do that SolidWorks cannot:

The practical impact on daily design work

Partial edge fillets are the biggest gap Inventor users feel. In SolidWorks, you can fillet the middle 60% of an edge in a single operation — you just set the start and end offsets on IPartialEdgeFilletData. In Inventor, you need to add a reference plane, split the edge with a sketch, then fillet the resulting segment. That’s three features instead of one, and they all need to update when the base geometry changes. On complex consumer product models with dozens of partial fillets, this multiplies into significant feature tree bloat.

Conic profile fillets matter for Class A surfacing. SolidWorks’ conic rho parameter lets you continuously vary the cross-section shape from flat (rho → 0) to sharp (rho → 1), with the standard circular fillet at rho = 0.5. Inventor only offers G1 or G2 continuity — you get tangent or curvature-matching at the boundary, but you can’t control the shape between the boundaries. For industrial design work where the fillet cross-section is an aesthetic decision, this means Inventor users resort to lofted surfaces where SolidWorks users just type a rho value.

Asymmetric fillets come up constantly in mold design, casting, and anywhere a part has draft. When one face slopes away from the fillet, a symmetric radius creates an uneven visual edge. SolidWorks handles this with the swFeatureFilletAsymmetric flag and separate R1/R2 parameters. Inventor users either accept the visual asymmetry or manually create a lofted blend — which is far more fragile in the parametric model.

Overflow control is the difference between a fillet that “just works” on thin geometry and one that doesn’t. When a fillet radius is larger than an adjacent face, SolidWorks lets you choose whether to extend the edge or trim against the surface. Inventor leaves this decision to the ShapeManager kernel — and when ShapeManager chooses wrong, the fillet fails with no option to guide it.

Conversely, Inventor’s reblend system gives it an advantage in large assembly workflows. When you apply a draft or tweak a face in Inventor, existing fillets on that face don’t rebuild from scratch — the MIxTaperReblend and MIxTweakReblend classes re-derive the blend incrementally. In SolidWorks, every fillet downstream of a geometry change regenerates completely. On complex models with cascading fillets, this means Inventor’s rebuild is both faster and more likely to succeed after upstream changes.

FreeCAD’s limitations hit immediately. No variable radius, no face fillet, no full round, no conic profiles, no partial edges, no overflow control, no setback vertices. The PartDesign fillet has exactly one parameter: radius. For simple constant-radius edge fillets on straightforward geometry, this works fine. For anything else, you’re either dropping to the Part workbench (which offers per-edge start/end radii but no GUI for it) or building surfaces manually. The gap between FreeCAD and the commercial tools isn’t gradual — it’s a cliff.

The “it works in SolidWorks but fails in Inventor” scenarios

When teams migrate models between systems — or when CadShift converts files across formats — certain fillet configurations are predictable failure points:

1. Partial edge fillets can’t be transferred. The STEP file carries the final geometry (including the fillet surface), but if the model is rebuilt parametrically in Inventor, the partial edge fillet must be replaced with a split-edge workaround.

2. Conic profile fillets export as trimmed NURBS surfaces. Inventor reads the geometry fine, but if you try to edit the fillet, it becomes a standard circular fillet — the conic rho information is lost. The visual result changes.

3. Asymmetric fillets that rely on SolidWorks’ R1/R2 parameters will need manual recreation in Inventor, typically as face fillets with careful face selection.

4. Overflow-dependent fillets — fillets that only succeed because SolidWorks uses “keep surface” overflow — will often fail when the same geometry is filleted fresh in Inventor, because ShapeManager’s default overflow behavior differs from Parasolid’s.

For detailed guidance on maintaining geometric fidelity across platforms, see our CAD interoperability guide and our breakdown of common CAD file format problems.

Reference: Parasolid blend functions in pskernel.dll

Reference: SolidWorks fillet type hierarchy

swFeatureFilletType_e
├── swFeatureFilletType_Simple
│   ├── Constant radius (single radius on all edges)
│   ├── Multiple radius (different radius per edge)
│   └── Asymmetric (different radius each side)
├── swFeatureFilletType_VariableRadius
│   ├── Smooth transition
│   └── Straight transition
├── swFeatureFilletType_Face
│   └── Face-to-face blend with hold lines
└── swFeatureFilletType_FullRound
    └── Three-face tangent blend

Reference: Inventor fillet class hierarchy (from Mi-Inv.dll)

MIxBlend (base blend operation)
├── MIxEdgeFillet (edge-based)
├── MIxFaceFillet (face-to-face)
├── MIxFullRoundFillet (three-face)
├── MIxFilletShape (result shape)
└── MIxFilletWeld (weld-specific fillet)

MIxReblendFace (re-derive blend after edit)
├── MIxTaperReblend (after taper modification)
└── MIxTweakReblend (after face tweak)

Diagnostics:
├── MIxDiagBlendEdgesFailed
└── MIxDiagChamferEdgesFailed

Takeaways

• SolidWorks calls fillets “blends” at the kernel level — Parasolid’s PK_EDGE_set_blend_constant is what actually creates the surface when you click the fillet button. The 7 legacy BLE* functions and 14 modern PK_*_blend_* functions represent over 30 years of blend algorithm development.

• Inventor has the best failure diagnostics — the MIxDiagBlendEdgesFailed class captures exactly which edges failed and the 3D location of the failure, enabling the precise error highlighting Inventor shows in its UI. Its reblend system makes fillets more resilient to parametric changes than SolidWorks.

• OpenCASCADE’s fillet can crash the process — FreeCAD installs a Linux-only signal handler to catch segfaults from OCCT’s ChFi3d algorithm. The entire PartDesign fillet is five lines of kernel calls with no pre-validation or blend repair.

• Parasolid is the most robust overall — pre-validation (PK_EDGE_check_blends), automatic repair (PK_BODY_fix_blends), four profile types, and three overflow strategies give it the widest success rate across geometry types.

• When migrating between systems, expect fillet differences — a model that fillets cleanly in SolidWorks may fail in FreeCAD on the same geometry, because the three kernels make fundamentally different decisions about surface generation, trimming, and intersection handling. See our guide to converting CAD files between formats and our STEP format deep dive for how geometry transfers across kernel boundaries. For a full platform comparison including price, learning curve, and CAM integration, see our full SolidWorks vs Fusion 360 vs Inventor comparison.

This analysis is based on decompilation of SolidWorks 2025 (pskernel.dll, SolidWorks.Interop.sldworks.dll, SolidWorks.Interop.swconst.dll), Autodesk Inventor 2026 (Mi-Inv.dll, nm.dll, DcKernel.dll, ivtagm.dll, Autodesk.Inventor.Interop.dll), and FreeCAD source code (OpenCASCADE BRepFilletAPI_MakeFillet). CadShift uses this kernel-level understanding to build more reliable CAD automation and file conversion tools.