3d-parametric-models

Files (22)

• SKILL.md
• Makefile.tmpl · assets/templates/
• parametric-box.scad · assets/templates/
• evals.json · evals/
• box-hardcoded.scad · evals/files/
• broken.stl · evals/files/
• cable-clip.scad · evals/files/
• part.stl · evals/files/
• trigger_queries.json · evals/
• bambu-lab.md · references/
• blender.md · references/
• design-for-printing.md · references/
• fusion360.md · references/
• mesh-and-stl.md · references/
• openscad-cli.md · references/
• openscad-for-llms.md · references/
• openscad-language.md · references/
• mesh_tool.py · scripts/
• preflight.sh · scripts/
• render.sh · scripts/
• scad_params.py · scripts/
• scaffold.py · scripts/

SKILL.md (first lines)

# 3D Parametric Models — script OpenSCAD, edit STL/3MF, then (optionally) print

Build and edit 3D models the way you write software: as **parametric code** you can
read, diff, version, and regenerate — not hand-pushed vertices. Two capabilities sit
at the core, and each stands on its own:

1. **Model by scripting OpenSCAD** — describe a solid with primitives + boolean ops +
   named parameters; OpenSCAD is text-first and fully declarative, which is exactly
   what an LLM is good at, and one command renders a watertight mesh.
2. **Edit meshes programmatically** — a small Python toolkit (trimesh/manifold3d)
   inspects, validates, repairs, measures, scales, booleans, arranges, and converts
   any STL/3MF/OBJ that already exists — including files you downloaded, which carry
   no parametric history.

3D **printing is a common destination, not the point**: when you want a physical
object, a slicer (Bambu Studio / OrcaSlicer) turns the model into a print — and this
skill documents that path well — but the modeling and mesh-editing work is just as
useful for visualization, asset pipelines, conversion, measurement, and CAD interop.

```
            ┌──────────── model ────────────┐        ┌──────── (optional) make ───────┐
 idea ──► parametric .scad ──► render.sh ──► .stl / .3mf ──► mesh_tool.py (validate/edit) ──► slice ──► print
          (OpenSCAD code)      (OpenSCAD CLI)                (trimesh/manifold3d)            (Bambu / Orca)
   ▲                                                              │
   └────── tune named parameters / scad_params.py batch ◄────────┘   edit ANY existing mesh, print or not
```

## Pick the right engine (don't fight the tool)

| The request… | Use | Why |
|---|---|---|
| Mechanical / functional part — bracket, box, enclosure, mount, holder, knob, gear, jig, adapter, spacer | **OpenSCAD** (`render.sh`) | Exact dimensions, named parameters, reproducible, manifold output, LLM-writable |
| "Make it adjustable / customizable / in several sizes" | **OpenSCAD + `scad_params.py batch`** | One file → many STLs from a parameter grid |
| Edit a mesh that already exists (a downloaded STL/3MF): scale, cut a hole, boolean, repair, measure, convert | **`mesh_tool.py`** (trimesh/manifold3d) | Mesh editing without a GUI; STL has no parametric history to recover |
| Organic / sculpted / artistic shape (figurine, character, terrain) | **Blender** (or a generative tool), then validate | OpenSCAD is poor at freeform; see `references/blender.md` |
| User already has it in Fusion 360 / wants assemblies, fillets, drawings | **Fusion 360**, export STEP/3MF | See `references/fusion360.md` for the bridge |

Default to **OpenSCAD** for anything dimensional. Reach for mesh tools to *modify*
existing files, and the Fusion/Blender references to *translate* a user's existing
workflow into this one.

## Facts that prevent broken work

- **Everything is millimeters. Z is up. The build plate is XY at z = 0.** STL/OpenSCAD
  are unitless and slicers assume mm — a model authored in "inches" prints 25.4× too
  small. Sit the finished part on the bed (min z = 0) so the slicer doesn't have to.
- **A printable solid must be watertight + 2-manifold with outward normals.** OpenSCAD
  CSG (union/difference/intersection) produces this *by construction*; downloaded or
  mesh-edited models may not — always run `mesh_tool.py info FILE` before slicing.
- **The OpenSCAD CLI defaults `.stl` to ASCII**, not binary (a real, long-standing quirk:
  the GUI defaults to binary, the command line to ASCII). ASCII STL is ~3× larger. The
  bundled `render.sh` forces **binary** (`--export-format binstl`); if you call `openscad`
  directly and want small files, pass `--export-format binstl` yourself.
- **Prefer 3MF over STL for Bambu.** 3MF carries mm units, color, materials, and per-object
  settings, is smaller, and is *required* for AMS multicolor. Emit STL only for legacy tools.
- **The Manifold backend is now default** in OpenSCAD nightlies (since 2025-08-17) and is
  dramatically faster for booleans; older builds (incl. 2021.01) use CGAL. `render.sh`
  auto-passes `--backend=manifold` when the build supports it. (The old `--enable=manifold`
  was removed; the selector is `--backend=manifold|cgal`.)
- **Print-fit clearances are printer-specific — never hardcode blindly.** Good FDM starting
  points: ~0.1 mm tight/press, ~0.2 mm snug, ~0.3–0.4 mm sliding/loose. Drive every mating
  gap from ONE `clearance` variable and tell the user to print a tolerance test once.
- **Design against gravity:** unsupported overhangs ≤ ~45° from vertical (modern printers
  reach ~50–70°), unsupported bridges ≤ ~10 mm, walls ≥ 0.8 mm (2× a 0.4 mm nozzle),
  horizontal holes as teardrops or ≥ 2 mm, chamfer build-plate edges to fight elephant's
  foot. Full numbers in `references/design-for-printing.md`.
- **FDM parts are anisotropic:** the Z (layer-to-layer) bond is only ~30–55% as strong as
  in-plane. Orient so loads run *along* layers, like wood grain — this often competes with
  minimizing supports, so surface the tradeoff instead of choosing silently.
- **Add `eps` overlap (≈0.01 mm) to boolean cuts/joins** so coincident faces don't create
  zero-thickness walls or z-fighting. Idiomatic OpenSCAD; see the templates.

## Preflight

Check the toolchain and get exact install commands for whatever is missing:

```bash
bash scripts/preflight.sh
```

It verifies OpenSCAD (+ Manifold backend), the Python mesh stack, and any slicer,
then prints per-OS install lines. You need OpenSCAD *or* the Python stack to start;
both for the full loop.

## Make a part in one command (scaffold)

Stand up a runnable parametric project — a Customizer-annotated `.scad`, a Makefile,
a parameter set, a batch grid, helper scripts, and a README:

```bash
python3 scripts/scaffold.py my-box           # -> ./my-box/
cd my-box && make                            # -> my-box.stl (needs openscad on PATH or $OPENSCAD)
python3 mesh_tool.py info my-box.stl         # confirm watertight + manifold + size
make 3mf            # my-box.3mf (preferred for Bambu)
make variants       # render every combo in variants.json into ./build/
make png            # preview (headless server: xvfb-run -a make png)
```

`scaffold.py my-thing --starter blank` gives a minimal stub instead of the box+lid example.

## Quick start — author, render, validate, iterate

The core inner loop without scaffolding:

**1. Write parametric `.scad`** (parameters at the top, geometry from small modules):

```scad
// shelf-bracket.scad — units mm, Z up, sits on bed
/* [Size] */
length = 60;      // [20:200]
height = 50;      // [20:200]
thick  = 4;       // [2:0.5:10]   plate thickness (>= 2x nozzle)
hole_d = 4.5;     // [3:0.5:8]    M4 clearance hole
/* [Quality] */
fn = 48;          // [16:8:128]
$fn = fn;
eps = 0.01;

module bracket() {

From kryptobaseddev/awesome-skills, MIT.

More from kryptobaseddev/awesome-skills