Mursix Design Assistant

#At a glance

#Lines of code by language

Vendored libraries (three.js, three-mesh-bvh), generated reports, NuGet packages and build output are excluded.

Not counted above: 43,809 lines of Markdown documentation (344 files) and 968,958 lines of JSON data (233 files: catalogs, material tables, fastener-pattern data and test fixtures).

#Lines of code by module

#The problem

Progressive dies are designed in SOLIDWORKS with LogoPress, a commercial plug-in, plus a lot of designer judgment that lives in handbooks and senior designers' heads. Mursix Design Assistant started in July 2025 as a tips-and-checklists task pane for training new designers. It grew into a from-scratch toolchain that covers most of the die design process, adds its own simulation engines, and makes the whole thing scriptable and testable.

 formed part ─► Blank / Unbending ─► Strip Layout ─► Strip Analysis (FEM)
                                         │
                                         ▼
       Standard Parts ◄── Tool Assembly ──► Die Audit · Die Debugger · Deflection
                                         │
                                         ▼
                     Detailing (DWG, BOM) · Mastercam CAM · Revision · Tryout

#Numerical engines (the heavy math)

All solvers are built into a separate assembly with no SOLIDWORKS dependency, so they compile with full optimization and run in tests without CAD.

#1. Strip Analysis: nonlinear shell FEM forming simulation

A station-by-station press simulation of a progressive strip: ram, pad, lifter and cam kinematics, cutting, implicit forming, and tool and press forces. It is written from the ground up and needs no external solver.

Element. A 3-node shell with 5 DOF per node (3 translations + 2 director rotations). The membrane is a CST on the Green–Lagrange strain of each increment, from the surface metric $C_{ab} = \mathbf{v}_a \cdot \mathbf{v}_b$. Bending is the Discrete Kirchhoff Triangle (Batoz 1982). Integration uses 3 in-plane points × 5 Simpson points through the thickness. Internal forces are the exact variation. The tangent combines the exact material and geometric parts; it is non-symmetric, so the solver factors LDU.

Anisotropic plasticity. Plane-stress Hill 1948, built from Lankford coefficients:

$$P_{12} = -\frac{r_0}{1+r_0}, \qquad P_{22} = \frac{r_0(1+r_{90})}{r_{90}(1+r_0)}, \qquad P_{33} = \frac{(r_0+r_{90})(1+2r_{45})}{r_{90}(1+r_0)}$$

Return mapping is closest-point projection (Simo–Taylor):

$$\boldsymbol{\sigma}(\Delta\lambda) = \left(\mathbf{C}^{-1} + \Delta\lambda\,\mathbf{P}\right)^{-1}\mathbf{C}^{-1}\boldsymbol{\sigma}^{\text{trial}}$$

$\Delta\lambda$ comes from a safeguarded Newton iteration with a bisection bracket. The algorithmically consistent tangent is

$$\mathbf{C}^{ep} = \boldsymbol{\Xi} - \frac{(\boldsymbol{\Xi}\mathbf{n})(\boldsymbol{\Xi}\mathbf{n})^{T}}{\mathbf{n}^{T}\boldsymbol{\Xi}\mathbf{n} + \dfrac{H\bar\sigma^{2}}{1 - H\Delta\lambda}}$$

Hardening is isotropic (Swift, Hollomon or tabulated). Forming limits follow the Keeler–Brazier curve, $FLC_0 = (23.3 + 14.13\,t)\,\dfrac{n}{0.21}$.

Sparse direct solver. A supernodal multifrontal $LDL^T$ (or $LDU$ for non-symmetric values), written from scratch:

• Ordering: geometric nested dissection with weighted-median separators and a balance penalty, falling back to minimum degree at the leaves.
• Supervariables group each node's DOFs.
• Execution: a parallel task-graph schedule with SIMD kernels (System.Numerics.Vector).
• Stability check: counts negative pivots (Sylvester's law of inertia) to detect instability.
• Reproducibility: greedy element coloring keeps parallel assembly bit-identical from run to run.

Contact and friction.

• Rigid faceted tools sit in an AABB tree, with feature-preserving smoothed normals.
• Top and bottom skins are offset along the director.
• Normal contact is a C¹-smoothed penalty.
• Friction is Coulomb, capped at shear yield, with elastic-slip regularization.
• Edge-to-surface contact samples sharp tool edges every 0.25 t and spreads the force barycentrically onto the sheet. Rim contact handles cut sheet edges against tool walls.

Nonlinear solution. Adaptive implicit static increments: Newton with line search and cut-back, and a ram-step growth rule (×1.5 / ×1.2 / ×0.7). Contact freezes when Newton cycles, and steps are capped.

Mesh operations. Cuts split elements along the true outline, giving 0.07 mm edge error on a Ø6 pierce instead of 0.7 mm from deleting elements. Before each stroke, longest-edge bisection refines until every element is at most $\tfrac{\pi}{8}(R + t/2)$ (a 22.5° arc rule).

Results

• Full 11-station production strip (1.25 mm mesh): forms end to end in 3,459 s. The previous contact model failed at station 8.
  • Station 2 thins 13.6 %.
  • The ironed extrusion at station 7 reaches 0.715 mm minimum thickness at $\bar\varepsilon = 0.54$.
  • Bottom-dead-center form forces are 58.6 kN upper and 108.2 kN lower.
• Performance work:
  • Parallel closest-point search cut contact time from 108 s to 40 s.
  • The ram-step rule cut station-2 Newton iterations from 1,290 to 442.
  • Edge-contact cost dropped 38 % (112.8 s → 70.0 s) with bit-identical results.
  • Factoring 57.7k DOF takes about 145 ms.
• Verification: 30/30 element checks (patch test, tangent consistency, Hill-48, cantilever, and a $2\pi EI/L$ moment rolling a strip into a full circle) and 57/57 forming checks (U-channel draw, hole flange, wrap over an edge, and others).
• Cutting force by shearing length: on a 13-station strip, charging only the outline that actually shears metal changed the estimate from 397 to 205 US tons, with a staggered peak of 128 tons.

#2. Blank development: one-step inverse FEM

Develops the flat blank of a formed or drawn part and maps strain, thinning and stress against the material. Results are benchmarked against LogoPress, and it adds capabilities LogoPress lacks.

• Kinematics: $\mathbf{F} = \mathbf{I} - \nabla\hat{\mathbf{u}}$, $\mathbf{G} = \mathbf{F}^T\mathbf{F}$, principal stretches $\lambda = c^{-1/2}$, thickness ratio $t/t_0 = 1/(\lambda_A\lambda_B)$, Hencky strains.
• Constitutive law: deformation theory, $\boldsymbol\sigma = E_s\,\mathbf{M}^{-1}\boldsymbol\varepsilon$, with a secant modulus $E_s = \min(\bar\sigma(\bar\varepsilon)/\bar\varepsilon,\;E)$.
• Solver: damped Newton–Raphson with line search and a triangle-flip guard, plus a Levenberg–Marquardt fallback. Linear solves use banded LU after reverse Cuthill–McKee ordering, falling back to ILU(0)-BiCGSTAB and then GMRES.
• Initial guess: a mesh parameterization cascade, ABF++ → ABF → LSCM, with an ARAP correction when distortion is high.
• Remeshing: isotropic, at target edge length $L = \sqrt{4A/(\sqrt{3}N)}$.
• Beyond LogoPress: normal and planar anisotropy ($r_0, r_{45}, r_{90}$ with a rolling direction). On a cup with $\bar r = 2$, thinning drops from 4.87 % to 4.23 %. With $\Delta r = +1$ the blank shows the expected earing pattern.

Result: on the reference part, blank area lands within 0.3 % and perimeter within 0.5 % of LogoPress (6,756–6,798 mm² vs 6,771.65 mm²). The spread across mesh densities is 0.06 %. Also ships as a .NET 8 command-line tool.

#3. Deflection: contact FEA of punches and form blocks

Computes how far a punch or form block deflects under load, through its whole load path to the die shoe. It reports pass/warn/fail against sourced limits and shows which heel, key, screw or dowel carries the side load.

• Elements: quadratic tet10 with 4-point Gauss integration. Meshing is by gmsh.
• Contact: node-to-face penalty, compression-only active set, with stick/slip decided per joint.
• Screws: preload springs plus a Timoshenko lateral spring:

$$k = \frac{12EI/L^3}{1+\Phi}, \qquad \Phi = \frac{12EI}{\kappa G A L^2}, \qquad \kappa = \frac{6(1+\nu)}{7+6\nu}$$

• Contact updates without refactoring: when the contact set changes, exact low-rank Woodbury updates are applied to the existing factorization whenever that is cheaper than about 70 % of a refactor.

Validation:

On a 366,291-DOF production die, body-aware ordering cut factor fill from 795 M to 566 M entries and work from $11.4\times10^{12}$ to $6.3\times10^{12}$ flops.

#4. Draw Designer: axisymmetric deep drawing

Plans the draw sequence of a round cup (number of draws, diameters, radii, clearances, ironing passes, press loads) and then simulates it.

• Blank: $D_0 = \sqrt{4V/(\pi t)}$, with $V$ taken from an exact Pappus volume of the solid's section.
• Critical draw load: $F = 2\pi r_p t K \left(\tfrac{n}{e}\right)^n A^{n+1}$, where $A = \dfrac{1+\bar r}{\sqrt{1+2\bar r}}$.
• Ironing: height $h_1 = h_0\,\dfrac{t_0(d+t_0)}{t_1(d+t_1)}$ and force $F = \pi(d+t_1)\,t_1\,R_m \ln\!\dfrac{t_0}{t_1}\left(1 + \dfrac{\mu}{\tan\alpha}\right)$, with equal strain per pass.
• Simulation: incremental axisymmetric membrane FE with Hill-48 normal anisotropy, Swift hardening, return mapping, zoned Coulomb friction, and Newton with backtracking.
• Optimizer: pushes reduction ratios until each draw sits under 90 % of its split load, then tightens the sequence to save draws.

#5. Unbending and overform

Sheet-metal unbend-by-steps for strip stations, as a parametric feature.

• Developed length: $L = \theta(r_i + Kt)$. Overform keeps $L$, so the radius tightens: $(\theta+\Delta)(r_i' + Kt) = L$.
• K-factor: a constant, DIN 6935 ($k = 0.65 + 0.5\log_{10}(r/s)$, $K = k/2$), or SOLIDWORKS/LogoPress bend tables. Tables are read by a standalone .xls (BIFF8) and .xlsx parser with no Office dependency.
• Conical bends: unrolled with the exact cone isometry $(s,\varphi) \mapsto (s,\ \varphi\sin\alpha)$, with −0.041 % volume error.

#6. Nesting

Part nesting for strip layouts, benchmarked against LogoPress.

• Placement: no-fit polygons $NFP = O \oplus (-P)$ from Clipper2 Minkowski sums at 1 µm resolution, with a bottom-left tie-break.
• Search: a genetic algorithm over part order and rotation, with order-preserving crossover.
• Geometry: Douglas–Peucker simplification and minimum-area bounding boxes from hull edges.

Result: 44–50 % material loss on the 13-body reference sample over 10 seeds, against about 45 % in the LogoPress tutorial.

#7. Die Debugger: kinematics and collision

Animates a full tool assembly through one press stroke in the browser.

• Ram motion: the crank-slider law $h = r(1+\cos\theta) + \sqrt{L^2 - r^2\sin^2\theta} - L$. Strippers and lifters move as spring-loaded floating stacks.
• Collision sweep: one SAH-built bounding volume hierarchy per part. Broad phase on AABBs and Z range, then sampling along relative travel with golden-section refinement of minimum clearances.
• Classification: a rule table sorts every contact as crash, clearance, intended, seat or spring.
• Scale: a 503-part production die (1.13 M triangles) under a 600k-triangle budget. It can also email the die as an animated AR (USDZ) model, shrunk from 36 MB to 14 MB.

#8. Smaller solvers and engineering models

• Cam Designer:
  • Retraction $s = (h_c - h)\tan\beta$.
  • Ram force $V = \dfrac{aH}{1-a\mu_2}$, where $a = \dfrac{\tan\beta + \mu_1}{1 - \mu_1\tan\beta}$. A non-positive denominator is reported as a friction jam.
  • 16 checks, e.g. driver angle 20–40°, return springs ≥ 1.25 × stripping force.
• Linkage Designer: knee joints by circle–circle intersection and travel by bracketed bisection. It matched the built SOLIDWORKS mechanism exactly: 0.9257 in and 2.3000 in of pusher travel for 1 in and 2 in of ram.
• Die Audit:
  • Press tonnage through the stroke at constant crank torque, $F(h) = F_\text{rated}\cdot\dfrac{\text{lever}(h_\text{rated})}{\text{lever}(h)}$.
  • A snap-through reverse-load bound.
  • Shaped-punch clearance from outlines sampled every 0.25 mm.
  • Spring resonance from $N_a = \dfrac{Gd^4}{8D^3k}$.
• Strip sizing: pitch $= \text{along} + w\,t$, width $= \text{across} + 2e\,t$, utilization $= A_\text{blank}/(\text{pitch}\cdot\text{width})$, with a 360° sweep in 0.5° steps.
• Draw blanks: grown by a raster distance field until area × t equals part volume, so the outline cannot fold over itself.
• Punch stepping: groups punches into stepped lengths so cutting forces peak at different times.
• Fastener clamp force: VDI 2230 (±25 %).
• Spring sizing: compression bands and DADCO force-curve interpolation.
• Handbook search: field-weighted BM25 ($k_1 = 1.2$, $b = 0.75$) over 195 topic cards and 631 figure crops, with concept expansion and phrase bonuses.

#Die design automation

• Strip Layout: detects bends from the carrier face, develops the blank, sizes the strip, schedules bend angles per station, and builds the strip assembly, punches and die.
  • Rebuilt a 13-station, 10-punch strip and matched it against the LogoPress-built original.
  • Builds mirrored (left/right-hand) versions of a complete die, including re-placing its standard parts.
• Tool Assembly: builds the die set from a template.
  • Sizes the chase to the tools plus 1.75 in per end.
  • Fits station punches to the closed backup.
  • Adds die, pad and stripper inserts.
  • Lets lifters give way to inserts.
  • A full production die builds unattended in 10–25 minutes.
• Standard Parts: turns a vendor order code into a solid and a solid back into a code.
  • 24 component families: 22 Dayton catalog pages transcribed, 33 DADCO models with 339 strokes, 380 Raymond rows, Danly die-set selection by shut height, and ASME/ISO fasteners.
  • A 30,000-punch offline sweep checks every dimension callout.
  • Mounts parts through the plate stack with shop-standard holes.
  • Suggests fastener patterns learned from past designs.
• Design Checks: 114 calculators (bending 20, cutting 15, die components 20, drawing 18, press 20, springs 21). Each one fills from the SOLIDWORKS selection, cites its Handbook page, and is fuzz-tested with 400 random inputs.
• Die Audit: one pass/warn/fail scorecard for a whole die. It combines 28 calculators fed from the model with assembly rules (slug paths, dowels, screws, spring and lifter travel, pilot lead, heel engagement), and every finding cites its source. 376 offline checks pass.
• Shop Standards: an editable, sourced hole standard that cuts Hole Wizard holes and colors faces by machining class. The colors survive SLDPRT, Parasolid and STEP import into Mastercam.
• Materials: ~1,000 sourced materials compiled to a .sldmat and installed at startup. Random-sample audits against the sources caught and fixed 94 stainless values that had been entered in the wrong unit.
• Detailing: exports manufactured parts to STEP plus metadata and drives an external drawing generator for company DWG prints, BOM, steel order and hole tables. An 87-part die exports and draws in about 6 minutes, or about 1 minute when nothing changed.
• Revision: diffs die revisions by persistent component reference into about 20 shop-meaningful change classes (e.g. hole_moved, purchased_swap), with unit-aware tolerances. Reports go out as JSON, HTML and XLSX.
• Die Protection, Tryout, Quote: sensor and timing plans, setup sheets, maintenance plans and tryout logs, and a pre-CAD cost model (material, scrap credit, press rate, die build hours).
• Strip Concepts (Python/FreeCAD): STEP → part graph → four scored strip layouts → designer review page → the plan SOLIDWORKS builds.

#Platform and integrations

• Add-in host: a COM add-in with 66 ribbon commands. Heavy results open as local web pages served by the add-in. Document state persists in custom properties and sidecar files keyed by persistent reference, never by absolute path.
• JSON API: a single Api(json) entry point with 67 features and 404 operations. Features self-register through attributes, so adding one needs no project edit.
• MCP server: lets AI agents drive SOLIDWORKS.
  • Transport: Streamable HTTP / JSON-RPC on localhost with a bearer token.
  • 6 tools, 13 resources and 8 workflow prompts.
  • Three-layer enforcement of model edits: the agent must choose the modify tool, the policy file must allow it, and the router checks again on its own. Every call is written to an audit log.
• In-SOLIDWORKS AI assistant: a per-document chat whose tools are generated from the API description.
  • Runs on Claude, or on a local 31B model through an OpenAI-compatible server.
  • "Progressive feature activation" loads features one at a time to fit a 64k context window.
  • Read-only by default.
• VBA Editor: a clean-room replacement for SOLIDWORKS's VBA 7.1 editor.
  • Parses 777 of 779 real macros.
  • Runtime with 275 VBA functions; runs 1,000,000 loop iterations in about 1 s.
  • Reads and writes .swp files, with UserForms and a debugger that contains crashes instead of taking SOLIDWORKS down.
  • C#/VB.NET macros compile through Roslyn in a separate process.
• Mastercam 2027 NET-Hook: reads a CAM manifest exported from SOLIDWORKS and creates hole and pocket operations (15 of 15 hole ops created live). A hot-reload bridge loads each build into a collectible AssemblyLoadContext, so Mastercam never needs a restart.
• AutoCAD export: batch-exports every drawing to a master DWG through AutoCAD COM automation, with templates, XREFs and AutoLISP block renaming (6,688 lines of C# + 2,529 of LISP).
• War Room: an ASP.NET (net9.0) shop-floor service with a web front end and GLB 3D export. Checklists sync from the add-in with Microsoft sign-in and an offline outbox.
• Installer: versioned installs with rollback and a machine-wide ceiling on what AI agents may do.

#Testing and engineering process

• 41 offline suites, run by one script that writes dated result pages, with a nightly runner. Examples:

  Suite	Result
  MCP server	27/27
  API transactions	20/20
  Snapshots	54/54
  Design-verb planners	197 checks
  Die Debugger	105/105
  Cam Designer	27/27
  Tool Assembly engines	197 checks
  Die Audit	376 checks
  FEM elements	30/30
  Forming	57/57
  VBA runtime	45/45

• 889 live cases run against a real SOLIDWORKS session. The last full sweep passed 762 of 806 (94.5 %).

• Agent evaluations: a Python harness drives an LLM against the live MCP server with 39 hand-written tasks plus generated ones, and exports trajectories for fine-tuning. A local 31B model scored 22/23 on the core set.

• Dev bridge: compiles and runs C# scripts inside SOLIDWORKS on its UI thread, with a job queue, a dialog guard and a crash watchdog that relaunches SOLIDWORKS and reopens documents. This is what makes unattended live testing possible.

• Benchmarking: the in-house engines are measured against LogoPress output on the same parts, with every comparison marked as matched, explained or still open.

• AI-assisted development: built with a multi-agent workflow (Claude Code as lead, Codex workers on scoped tasks, coordination files for the one shared SOLIDWORKS instance). A living self-audit tracks each module's maturity and known bugs.

#Honest status

• Production-ready: Strip Layout, Standard Parts, Design Checks, Die Audit, Die Debugger, Blank, Deflection, Nesting, VBA Editor and the API/MCP layer are working and tested.
• Strip Analysis: forms complete production strips. Through-thickness squeeze, in-stroke remeshing and springback display are still open.
• Prototypes: Mastercam CAM and Strip Concepts.
• Rates to be confirmed: Quote and some Die Protection values wait on shop-confirmed numbers.
• Legacy: the first-generation modules from 2025 (Live Tips, Validate Design, DieAnalysis) are kept but superseded.