Use LLMs as a high-speed interface layer for engineering systems. Keep final outputs deterministic and validated with tests, rules, and traceable sources.
Strong ideas (kept and reinforced):
What is often missing (added in this expanded version):
Treat LLM as:
Do not treat LLM as:
Compensation pattern: strict I/O, tests, reference examples, deterministic execution, and acceptance checks.
Best results in engineering usually come from this stack:
Engineer task -> prompt -> LLM (code/template/plan)
|
v
deterministic executor
(CAD API / Python / solver / simulator / parser / CI)
|
v
validation (unit tests, rules, baseline comparisons)
|
v
result (file, report, export, DB write)
Key point: LLM does not "produce" the final engineering result directly. It generates instructions and code. The final result comes from deterministic execution plus verification.
These are high-success scenarios because they are repetitive, text/table heavy, API-friendly, and testable.
Tasks that automate well:
Indirect but very effective:
Example: part-number validator (Python)
import re
RULE = re.compile(r"^[A-Z]{2}-\d{4}-[A-Z]{2}\d{2}$") # Example: AB-1024-XY05
def validate_part_number(pn: str) -> bool:
return bool(RULE.match(pn))
candidates = ["AB-1024-XY05", "ab-1024-XY05", "AB-102-XY05"]
for pn in candidates:
print(pn, "OK" if validate_part_number(pn) else "FAIL")
LLM value: rapid generation of validation logic, CLI tools, PyQt mini-apps, and plugin scaffolds while the engineer controls rules and examples.
Strong use cases:
Example: fast voltage-drop utility skeleton
from dataclasses import dataclass
@dataclass
class Line:
length_m: float
current_a: float
voltage_v: float
r_ohm_per_km: float # Conductor resistance at defined temperature
def voltage_drop_percent(line: Line) -> float:
# Simplified single-phase model: dU = I * R
# R = r_ohm_per_km * (L / 1000)
r_total = line.r_ohm_per_km * (line.length_m / 1000.0)
du = line.current_a * r_total
return du / line.voltage_v * 100.0
l = Line(length_m=80, current_a=32, voltage_v=230, r_ohm_per_km=1.15)
print(f"Voltage drop: {voltage_drop_percent(l):.2f}%")
You can ask the LLM to add:
Important: formulas and correction factors must be validated against your applicable standards (IEC/NEC/internal rules). LLM accelerates implementation, not compliance approval.
High-impact automation:
Example: motor-start function block skeleton in Structured Text
FUNCTION_BLOCK FB_MotorStart
VAR_INPUT
StartCmd : BOOL;
StopCmd : BOOL;
EStopOk : BOOL;
InterlockOk : BOOL;
FeedbackOn : BOOL;
END_VAR
VAR_OUTPUT
RunOut : BOOL;
Fault : BOOL;
END_VAR
VAR
latchedRun : BOOL;
tFeedback : TON;
END_VAR
// Latching start command
IF StopCmd OR NOT EStopOk THEN
latchedRun := FALSE;
ELSIF StartCmd AND InterlockOk THEN
latchedRun := TRUE;
END_IF;
RunOut := latchedRun AND EStopOk AND InterlockOk;
// Feedback supervision (simplified)
tFeedback(IN := RunOut AND NOT FeedbackOn, PT := T#3S);
IF tFeedback.Q THEN
Fault := TRUE;
latchedRun := FALSE;
END_IF;
LLM helps by generating the initial skeleton, diagnostics, state handling, timers, docs, and simulation test-case drafts.
Engineer responsibility remains non-negotiable: safety logic, stop conditions, fail-safe behavior, sensor-fault scenarios, and site standards.
Immediate value areas:
Example flow: requirement extraction to JSON
Prompt idea: "Transform this source text into JSON with schema id, requirement, rationale, verification_method, priority."
Then:
High-return targets:
Example: minimal SCPI identification wrapper
import pyvisa
def read_idn(resource: str) -> str:
rm = pyvisa.ResourceManager()
inst = rm.open_resource(resource)
inst.timeout = 5000
return inst.query("*IDN?").strip()
print(read_idn("USB0::0x0000::0x0000::INSTR"))
LLM can quickly add retries, connection diagnostics, structured logs, CSV/JSON export, CLI UX, and test-run summaries.
Task: batch export all sheet metal components from an assembly to DXF, with folders and logs.
Why LLM helps fast:
Safe rollout sequence:
Prompt template for CAD script generation
Context:
- CAD: SolidWorks 2023
- Language: VBA (or C#)
- Object: active assembly (.sldasm)
Task:
- Find all sheet-metal parts, including nested subassemblies
- Export each to ./ExportDXF/<PartNumber>/
- File naming: <PartNumber>_<ConfigName>.dxf
Constraints:
- Skip suppressed components
- Never overwrite files (append suffix instead)
- Write log.csv with part, config, status, message
Acceptance criteria:
- For a 10-part sheet-metal test assembly, produce 10+ DXFs (depending on configs)
- Log must have no empty fields and include error codes
Task: extract parameters from datasheets (for example, pressure transmitters) and create structured records.
Typical challenge: PDFs can be text-native or scanned images.
Recommended pipeline:
pdfplumber, camelot, tabula) and normalize.Minimal JSON schema example
{
"tag": "PT-101",
"device_type": "Pressure Transmitter",
"manufacturer": "ACME",
"model": "X200",
"range": {"min": 0, "max": 10, "unit": "bar"},
"output": "4-20 mA + HART",
"supply": {"min": 12, "max": 30, "unit": "VDC"},
"process_connection": "G1/2",
"materials": {"wetted": "316L"},
"ip_rating": "IP67",
"source": {"file": "datasheet_x200.pdf", "page": 3}
}
Key tactic: require strict JSON-only output from the model.
Prompt template for table extraction
You are given a table image (page 3). Return JSON only with this schema:
- manufacturer (string)
- model (string)
- range.min (number), range.max (number), range.unit (string)
- supply.min (number), supply.max (number), supply.unit (string)
- output (string)
- ip_rating (string)
Use null when a value is missing.
Task: answer questions like torque, tolerance, and labeling rules with source references.
RAG flow:
PDF/docs -> chunking -> embeddings -> vector DB
|
v
user query
|
v
top-k retrieved fragments
|
v
LLM answer + source citations
Practical rule: store standard version, effective date, and internal exceptions close to each indexed source.
Sometimes the highest ROI is a small service, not a full "agent."
Examples:
FastAPI skeleton example
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Input(BaseModel):
length_m: float
current_a: float
voltage_v: float
r_ohm_per_km: float
@app.post("/voltage-drop")
def voltage_drop(inp: Input):
r_total = inp.r_ohm_per_km * (inp.length_m / 1000.0)
du = inp.current_a * r_total
return {"drop_percent": du / inp.voltage_v * 100.0}
LLM can quickly add OpenAPI docs, validation, logs, Dockerfile, and test coverage.
1) Context
- Tool/version: (SolidWorks 2023 / EPLAN / TIA Portal / KiCad / Python 3.11)
- Language: (VBA/C#/Python/ST)
- Environment constraints: (offline, stdlib-only, access limits)
2) Inputs
- What comes in? (file, folder, CSV, parameters)
- At least one sample input
3) Outputs
- What should be produced? (files, report, JSON, model changes)
- Strict output format
4) Rules
- Naming, units, standards, exceptions
- Error definitions
5) Acceptance criteria
- 3-5 verifiable checks
- Preferably test cases (input -> expected output)
Prompt additions that improve reliability:
pytest unit tests for formula edge cases."mypy) and linting (ruff) config."This reduces silent logic failures significantly.
Minimum set of practices that works in production:
Practical rule: LLM accelerates artifact generation (code, docs, tables), but responsibility for engineering decisions remains with qualified engineers and validated deterministic tools.
Week 1: choose 1-2 pain points
Week 2: prototype
Week 3: quality wrapping
Week 4: production pilot
LLMs are not about "let AI design for me." They are about:
The engineer role shifts from interface operator to automation architect: define rules, verify outputs, and build reproducible workflows.
Use these tag jumps to move across related posts:
Published articles connected by these tags:
]]>Below is why FreeCAD can be called the "king" of open-source CAD, where it genuinely approaches commercial systems (SolidWorks, Inventor, Solid Edge, Creo, Fusion 360, NX), and where it still trails.
FreeCAD was built around parametric modeling from the start: sketches, constraints, a feature tree, expressions, and geometry reuse. That philosophy is what engineers pay for in "big" CAD systems.
Within one application (plus add-ons), FreeCAD covers multiple worlds:
Commercial systems can do this too, but often through modular licensing. In FreeCAD, this breadth comes from workbenches and community-driven development.
Historically one of FreeCAD's most painful issues was broken references to faces/edges after model changes (the topological naming problem). In 1.0, mitigation landed in the core. This is not about comfort - it is about the reliability of parametric workflows.
For enclosures, brackets, plates, adapters, fixtures, machining parts, and 3D printing, FreeCAD is very close. The core parametric approach (sketches + features + tree) is mature, and 1.0 makes model edits survive thanks to better reference robustness.
For typical engineering geometry (dimension chains, symmetry, tangency, parallelism, expressions/parameters), FreeCAD covers around 80-90% of what most users need from mainstream mechanical CAD. Differences usually come down to comfort, diagnosing over-constraints, UX polish, and performance on very large sketches.
The built-in Assembly Workbench in FreeCAD 1.0 is a major step: assemblies are no longer only the domain of add-ons. External assembly workbenches remain popular - A2plus, for example, is installable via the Addon Manager. For small to mid-sized assemblies, layout work, basic kinematic checks, and fit verification, FreeCAD is often already "enough." For very large assemblies and complex constraint networks, limitations show up faster.
STEP remains the industrial workhorse for exchanging 3D models, and FreeCAD fits well into STEP-based workflows - especially as a viewer, editor, and geometry-prep tool. Commercial CAD often moves ahead through "native" ecosystems within a single vendor and more predictable importers for complex models.
Large assemblies, performance, manageability. Commercial CAD is usually stronger in performance on thousands of components, simplification tools (defeature, lightweight modes), out-of-the-box configuration/variant management, and enterprise-level interference/clearance analysis.
Drawings and standards-based documentation at scale. TechDraw is workable, but commercial CAD often does better with automated drawing workflows, stability of view-to-model links in complex cases, rich libraries of standard annotations/tolerances/BOMs, and PDM integration. If drawings are your main deliverable, the difference is felt more strongly.
High-end surfacing (Class-A) and specialized modules. For complex surfacing, industrial design, and cosmetic quality at the level of top modules (NX/Creo/SW Premium, etc.), FreeCAD is usually not the first choice. The same goes for narrow, industry-specific toolsets: mold design, advanced sheet metal forming, rule-based piping, wiring harnesses, and PLM-specific integrations.
PDM/PLM and enterprise integration. Commercial CAD wins on ecosystem: data management, access control, revisions, approvals, traceability, and ERP/PLM connectors.
FreeCAD 1.x earns the "king of open-source CAD" title thanks to its combination of parametrics, breadth of tasks, and development pace. The 1.0 release was a turning point for parametric robustness and assemblies, and 1.1 (already in RC) shows the project did not stop at a milestone version.
Why you can forget about Visio for quick diagrams.
In engineering and office work, "heavy software" is a recurring drag. To draw a simple flowchart or script logic, we reach for Visio, Lucidchart, or even CAD. That is slow, costly, and overkill when ideas just need to land somewhere. Excalidraw fixes this with a fast, open-source, hand-drawn canvas that runs in the browser.
Below is how to integrate it into your workflow if you are an engineer or script developer.
You do not draw components from scratch. Excalidraw ships with community libraries:
How: Click Library → Browse libraries → add what you need once and reuse.
Prefer code over mouse? Excalidraw imports Mermaid.
Result: zero time on manual alignment.
Excalidraw files are JSON, not flat images.
Practical tip: export as .svg so diagrams scale without losing quality when embedded in docs or sites.
Need a quick remote review? No accounts required.
Steps: open excalidraw.com → Live Collaboration → share the link. Data is end-to-end encrypted; the server cannot read your drawing.
Do not launch heavy tools for quick thinking. Excalidraw covers ~90% of everyday needs for processes, network topologies, and script logic:
Try sketching your next algorithm here: https://excalidraw.com/
]]>In this article, we explore how to use the Chromium engine (via Puppeteer or Playwright) and JavaScript to automatically generate, validate, and nest DXF files.
For an engineer, a browser is not just a page viewer; it is a powerful vector rendering engine (SVG/Canvas) with hardware acceleration support.
Cross-platform: Generation works identically on Windows, Linux servers, and inside Docker containers.
Visual Debugging: You see exactly what goes to the machine.
Library Availability: The NPM ecosystem (Maker.js, OpenJSCAD) allows for 2D geometry manipulation faster than LISP or VBA.
Solution Architecture
The automation workflow for nesting or generating a flat pattern looks like this:
Frontend/Logic: A JS script generates part geometry (SVG path) based on parameters.
Engine (Chromium): The headless browser renders the geometry, calculates intersections (for nesting), or converts Bezier curves into arcs/polylines.
Output: Result serialization into DXF format.
Technical Implementation
Instead of drawing lines manually, we leverage the DOM for calculations.
Stack:
Node.js - Runtime environment.
Puppeteer - Headless Chromium control.
Maker.js - Library for CAD operations and DXF export.
Code Example (Node.js)
const puppeteer = require('puppeteer');
const fs = require('fs');
(async () => {
// 1. Launch a "clean" browser
const browser = await puppeteer.launch();
const page = await browser.newPage();
// 2. Inject construction logic (e.g., box flat pattern)
// In a real project, maker.js would be injected here
const dxfContent = await page.evaluate(() => {
// Assume makerjs is loaded in the page context
const model = new makerjs.models.Rectangle(100, 50);
// Add holes or bend lines
const hole = new makerjs.paths.Circle([10, 10], 5);
makerjs.model.addPath(model, hole, 'hole_1');
// Export to DXF string
return makerjs.exporter.toDXF(model, { units: 'mm' });
});
// 3. Save file for production
fs.writeFileSync('flat-pattern.dxf', dxfContent);
console.log('DXF generated successfully.');
await browser.close();
})();
Interactive Example
With MDX, you can even embed interactive elements directly in the post. Launch the DXF circle generator below, tweak the snippet, and download the updated DXF instantly:
Checking auth status…
Application for Nesting
Nesting algorithms (like SVGnest or Deepnest) require heavy geometry calculations. Running them within the Chromium environment allows the use of WebAssembly (WASM) modules. This accelerates part placement calculations significantly compared to pure JS and allows for immediate export to DXF.
Summary
Using Chromium for CAD tasks removes the dependency on server-side SolidWorks or AutoCAD licenses. This enables the construction of cloud configurations (CPQ) that deliver ready-to-cut files for laser cutting instantly.
]]>In this article, we look at how to use LLMs (GPT-4, Claude 3.5, Llama 3) to control CAD software and process technical data.
LLMs are poor at spatial reasoning (they can't "imagine" a 3D assembly well). However, they are excellent at understanding the APIs of CAD software (SolidWorks, AutoCAD, Fusion 360) and writing the scripts to manipulate that geometry.
The biggest friction in CAD automation is looking up API documentation. Writing a VBA macro for SolidWorks or a Python script for Blender used to take hours of searching forums.
Modern LLMs have indexed these API docs. You can now prompt for functionality rather than syntax.
Real-world Use Case: Batch export all sheet metal components from an assembly to DXF.
Code Example (Python + pyautocad)
Instead of writing this from scratch, an engineer can generate this boilerplate instantly:
from pyautocad import Autocad, APoint
# Generated by LLM to automate repetitive drawing tasks
def draw_gear_profile(teeth, module):
acad = Autocad(create_if_not_exists=True)
radius = (teeth * module) / 2
center = APoint(0, 0)
# LLM understands specific engineering libraries
acad.model.AddCircle(center, radius)
print(f"Gear profile created: m{module} z{teeth}")
draw_gear_profile(20, 2)
Engineers deal with thousands of PDF datasheets and legacy 2D drawings. Extracting parameters (tolerance, material, weight) manually is error-prone.
Multimodal LLMs can "read" screenshots of technical drawings or tables and structure that data into JSON for your ERP or PDM system.
Instead of flipping through a 500-page PDF to find the bolt torque specification for an M12 grade 8.8 screw, you can build a RAG (Retrieval-Augmented Generation) system.
Input: "Torque for M12 8.8"
System: Retrieves specific page from uploaded ISO PDF.
Output: "81 Nm (Source: ISO 898-1, Table 4)"
Interactive Prompt Builder
Try this structure when asking an AI to write CAD scripts for you:
Context: "I am using SolidWorks 2023 API with VBA."
Task: "Write a macro that traverses the feature tree."
Constraint: "Identify all features with 'suppressed' state and unsuppress them."
Summary
Don't ask the AI to design the part. Ask the AI to write the code that automates the boring parts of the design process. This shifts the engineer's role from "operator" to "architect of automation."
]]>