Skip to content
Back to search

3d-print-modeling

Design, convert, repair, orient and validate 3D models so they print well and efficiently on FDM, resin or SLS printers: no or little support, short print time, less material, correct fits, single or multi-colour. Use for any request to make something 3D printable or to improve how a model prints: STL, 3MF, slicer, supports, overhangs, bridges, wall thickness, tolerances, print orientation, brackets, enclosures, replacement parts, figurines, miniatures, terrain, cosplay props, print-in-place toys, vases, or turning a game, render, sculpt, scan or AI mesh into a printable file. Asks once for the user's printer, colours and materials and remembers them (default printer: Bambu Lab P1S). Bundles a headless Blender 5 toolkit: printability checker, orientation ranker, review-board renderer, 3MF/STL exporter, solid-modeling helpers, and a slicer driver for Bambu Studio, OrcaSlicer and PrusaSlicer that reports real print time and filament.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/kshaham--3d-print-modeling-skill/badge.svg)](/listings/kshaham--3d-print-modeling-skill)

HTML

<a href="/listings/kshaham--3d-print-modeling-skill"><img src="/api/listings/kshaham--3d-print-modeling-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 271 lines
  1. ---
  2. name: 3d-print-modeling
  3. description: >-
  4. Design, convert, repair, orient and validate 3D models so they print well and
  5. efficiently on FDM, resin or SLS printers: no or little support, short print time,
  6. less material, correct fits, single or multi-colour. Use for any request to make
  7. something 3D printable or to improve how a model prints: STL, 3MF, slicer, supports,
  8. overhangs, bridges, wall thickness, tolerances, print orientation, brackets,
  9. enclosures, replacement parts, figurines, miniatures, terrain, cosplay props,
  10. print-in-place toys, vases, or turning a game, render, sculpt, scan or AI mesh into
  11. a printable file. Asks once for the user's printer, colours and materials and
  12. remembers them (default printer: Bambu Lab P1S). Bundles a headless Blender 5
  13. toolkit: printability checker, orientation ranker, review-board renderer, 3MF/STL
  14. exporter, solid-modeling helpers, and a slicer driver for Bambu Studio, OrcaSlicer
  15. and PrusaSlicer that reports real print time and filament.
  16. ---
  17. # 3D print modeling
  18. Model for the printer, not for the screen. A printable model is a closed solid in
  19. millimetres, shaped so each layer rests on the one below, sized to the machine's nozzle
  20. and build volume, and turned the way that prints fastest with the least support.
  21. Paths below are relative to this skill's folder. Run every tool through
  22. `python scripts/blender_run.py <script> ...`; it finds Blender and hides its noise.
  23. ## 1. Start with the printer profile (ask once, then never again)
  24. Before any modeling, check for a saved profile:
  25. ```
  26. python scripts/printer_profile.py --show
  27. ```
  28. If `"missing"` is empty, use it and ask nothing. Also check your memory for a printer note.
  29. If anything is missing, ask the user these questions together, in one message (use the
  30. question tool if you have one):
  31. 1. **Which 3D printer do you have?** Make and model, or the type (filament, resin, powder
  32. service) with its build volume and nozzle if it is unusual or home-built.
  33. 2. **How many colours can it print at once?** One, or several with a filament changer
  34. (AMS, MMU and similar), several nozzles or tools, or manual swaps at a layer.
  35. 3. **Which materials do you print with?** For example PLA, PETG, ABS/ASA, TPU, nylon, or
  36. which resin.
  37. Save the answers immediately, in both places:
  38. ```
  39. python scripts/printer_profile.py --set printer="Bambu Lab P1S" colors=4 color_system=AMS materials=PLA,PETG,TPU
  40. ```
  41. - A known printer name fills in process, build volume and nozzle (`--printers` lists them).
  42. If `"missing"` still lists `build`, ask for the build volume and set `build=X,Y,Z`.
  43. - **Write the same facts to your persistent memory** if you have one (in Claude Code: a
  44. `user` memory named `3d-printer-profile`, with its line in `MEMORY.md`), noting that the
  45. numbers live in the profile file. Later sessions must find it without asking.
  46. - Ask again only when the user mentions a new printer, nozzle, colour unit or material;
  47. then update both places.
  48. - If the user will not say, proceed with the built-in default printer, a **Bambu Lab P1S**
  49. (filament, 0.4 mm nozzle, 256 mm cube, PLA, one colour), say that you did, and do not
  50. save it.
  51. The profile sets the defaults of every tool (process, build volume, nozzle, material).
  52. Colours and materials shape the design itself: read `references/multicolor.md` when the
  53. job has more than one colour, `references/materials.md` when the material is not PLA.
  54. When a job names a material, pass it to every tool (`--material petg`, or `MATERIAL` in
  55. the template): it changes the bridge and overhang limits, not only the mass estimate.
  56. Everything else about a job (what it is for, sizes of mating parts, where the load pulls,
  57. which faces show) belongs to that job: infer it from the request, and ask only for
  58. dimensions you cannot know.
  59. ## 2. The quality bar
  60. A model that merely exports is not done. It is done when:
  61. - `print_check.py` reports `PASS`, and every warning is fixed or accepted with a reason
  62. you can state;
  63. - it needs **no support**, or the support left is the least possible, rests on the bed,
  64. and you can say why it stays;
  65. - the orientation was chosen on purpose (support, time, strength, visible faces) and is
  66. already applied in the exported file;
  67. - fits, holes and thin features follow the numbers in `references/design-rules.md`;
  68. - you have **looked at the review board** and critiqued it at least twice;
  69. - the user gets 3MF (and STL if wanted), the manifest, the settings that matter and the
  70. expected time and material, from a real slice when a slicer is installed.
  71. ## 3. The path for a new model
  72. 1. **Decide how it prints before drawing it.** Which face sits on the bed, where the
  73. layers run relative to the load, which faces must look good. Sketch a blockout and run
  74. `print_orient.py` on it if the answer is not obvious. Read `references/efficiency.md`.
  75. Find the playbook for the kind of model in `references/model-types.md`.
  76. 2. **Start from the template.** Copy `assets/author_template.py` to
  77. `<project>/print/author_<name>.py`. It is a complete working part: named dimensions,
  78. `printkit` solids, check as a gate, export, manifest, `--review`. Set `MATERIAL`,
  79. replace `build()`.
  80. 3. **Block out the big forms**, then run it with `--review` and read the board. Fix
  81. orientation, bed contact and red areas now, while changes are cheap. When the check
  82. fails the template still renders the board, so look before guessing.
  83. 4. **Add features in printing terms:** holes sized with `pk.hole_d`, horizontal holes as
  84. `pk.teardrop`, ledges turned into 45° chamfers, bed edge chamfered, fits from `pk.FIT`.
  85. Let cutters overshoot by a millimetre and sink joined parts 0.2 mm into each other,
  86. rather than leaving faces exactly flush. For load-bearing or mating parts read
  87. `references/functional-parts.md`; print `assets/author_fit_gauge.py` once to learn the
  88. printer's real clearances.
  89. 5. **Check, look, fix, repeat.** At least two passes of critique → change → re-render.
  90. Record what each pass changed (support area, time, mass before and after).
  91. 6. **Export and hand off** as in section 8.
  92. For precise mechanical parts, a CAD kernel driven by code (build123d, CadQuery, OpenSCAD) is
  93. a good alternative for the geometry if one is installed; export its STL or 3MF and run it
  94. through the same check, orientation and review tools.
  95. ## 4. The path for an existing model
  96. Game assets, sculpts, scans, AI meshes, downloaded STLs, or "make this print better":
  97. 1. `python scripts/blender_run.py print_check.py model.stl` and read every error.
  98. 2. Repair in the order of `references/converting-models.md`: units and scale, thickness,
  99. one closed shell, thin features, base. Keep the source file untouched.
  100. 3. `print_orient.py` for the best way up; apply it with `--apply`.
  101. 4. Reduce support and material by design changes (`references/efficiency.md`), not only by
  102. settings. Split with keyed joints when one piece cannot print well
  103. (`pk.split(obj, "z", height)` returns two halves with pin sockets, and the pegs).
  104. 5. Review board, then export. Report before-and-after numbers.
  105. ## 5. Numbers to keep in your head (FDM, 0.4 mm nozzle)
  106. | Rule | Value |
  107. | --- | --- |
  108. | Wall | 0.8 mm minimum (two lines); 1.2–2.4 mm structural; multiples of 0.45 mm |
  109. | Floor and roof | 3–5 layers |
  110. | Overhang | 45° from vertical; flat ledges become chamfers |
  111. | Bridge | under 30 mm between two anchors, at one height |
  112. | Vertical hole | model +0.2 mm (`pk.hole_d`) |
  113. | Horizontal hole | teardrop above about 6 mm |
  114. | Clearance per side | press 0.05, snug 0.10, slide 0.20, loose 0.35, print-in-place 0.30–0.40 mm |
  115. | Bed edge | 0.4–0.6 mm chamfer, never a round |
  116. | Text | strokes 0.9 mm+, capitals 6 mm+, 0.6 mm deep or high |
  117. | Strength | loads along the layers; walls before infill |
  118. Resin, powder and the reasons behind each number: `references/design-rules.md`.
  119. ## 6. Tools
  120. The Blender tools run as `python scripts/blender_run.py <script> [args]`. Each prints a
  121. readable summary; put `--json-only` right after `blender_run.py` for the report alone.
  122. Flags `--process --nozzle --layer --min-wall --overhang --bridge --gap --build X,Y,Z
  123. --material --unit` override the saved profile on any of the three analysis tools.
  124. `printer_profile.py` and `print_slice.py` are plain Python: run them directly.
  125. | Tool | Does | Typical call |
  126. | --- | --- | --- |
  127. | `printer_profile.py` | saved printer, colours, materials (plain Python) | `python scripts/printer_profile.py --show` |
  128. | `print_check.py` | the gate: closed solid, size, walls, gaps that fuse, overhangs, bridges, mid-air starts, bed contact, cavities, colour changes, rough time/mass. Exit 1 on errors | `print_check.py part.3mf` |
  129. | `print_orient.py` | ranks ways up by support, time, bed contact; `--strong-axis x` for load; `--apply out.3mf` writes the best | `print_orient.py part.stl --top 5` |
  130. | `print_review.py` | eight-tile review board PNG plus the report as JSON | `print_review.py part.3mf review/part.png` |
  131. | `print_export.py` | 3MF and STL in millimetres plus manifest, from a `.blend` | `--blend scene.blend print_export.py --out build/part --format 3mf stl` |
  132. | `print_slice.py` | real time, grams and filament changes from Bambu Studio, OrcaSlicer or PrusaSlicer, using the printer's own presets | `python scripts/print_slice.py out/part.3mf --compare-supports` |
  133. | `self_test.py` | proves the tools work on this machine and Blender version | `self_test.py` |
  134. | `printkit.py` | modeling helpers for author scripts (below) | `import printkit as pk` |
  135. Inputs: `.stl .3mf .obj .ply .glb .gltf .blend`. STL, OBJ and PLY are read as millimetres,
  136. glTF as metres, `.blend` by its scene unit; `--unit` overrides. Several objects in one file
  137. are treated as the parts of one print (one per colour): each must be closed, and they may touch.
  138. **printkit** (one unit = 1 mm; every builder returns a closed solid):
  139. - Solids: `box cylinder sphere prism lathe text`; outlines for `prism`: `rounded_rect slot polygon`.
  140. - Cutters: `teardrop countersink counterbore hex_pocket`.
  141. - Combine: `union cut common copy` (exact booleans; tools are consumed unless `keep=True`),
  142. `split` (two keyed halves with pin sockets, plus the pegs).
  143. - Place: `move rotate mirror to_bed bounds`. Edges: `chamfer(obj, width, "bottom"|"top"|"vertical"|"all"|fn)`.
  144. - Numbers: `FIT`, `SCREW["M3"]`, `hole_d`, `segments_for`.
  145. - Colour: `colour(obj, "#hex", "filament")`. Finish: `clean check export save_blend`.
  146. Read the docstrings in `scripts/printkit.py` before using a helper for the first time.
  147. For modeling beyond these helpers (sculpting, Geometry Nodes, remeshing, modifiers), use the
  148. `blender-*` skills if installed (`blender-core` first), working in millimetres, and bring
  149. the result back through `print_check.py`. Their `blender-asset-qa` gate complements this
  150. one; it does not replace the print checks.
  151. ## 7. Review by looking
  152. ```
  153. python scripts/blender_run.py print_review.py part.3mf review/part.png
  154. ```
  155. Open the PNG with your image reader and look at every tile. Left to right, top then bottom:
  156. 1. **Overhang map from above.** Red needs support, yellow is within 15° of the limit,
  157. green is a bridge short enough to print, blue touches the bed. Bed squares are 10 mm.
  158. Yellow on 45° chamfers, gussets and teardrop roofs is expected: they sit on the limit.
  159. 2. **The part turned over.** The same colours on the underside, where the red lives.
  160. 3. **First layer from below.** Blue is what holds the print to the bed: one or a few solid
  161. shapes, not specks.
  162. 4. **Front**, 5. **Right**, 6. **Top**: proportions and, for multi-colour prints, each part
  163. in its own colour.
  164. 7. **Wall thickness.** Orange is thinner than recommended, red will not print. The view is
  165. the corner that shows the most thin wall (the caption says which), the back otherwise.
  166. 8. **Section through the middle.** Dark is solid material, with the same orange and red on
  167. the surfaces behind the cut: look for unintended hollows, thin skins and trapped
  168. cavities. Move it with `--section x=12` (or `y=`, `z=`).
  169. The report is written beside the image as `<name>.json`; `thin_at` and `gaps.at` in it give
  170. the coordinates of anything the board does not show clearly.
  171. Ask of each board:
  172. - Is there any red, and could a chamfer, teardrop, split or turn remove it?
  173. - Does the first layer hold the part? Is anything tall standing on something small?
  174. - Is anything thinner than two lines, or thicker than it needs to be?
  175. - Will the faces that matter be clean (not supported, not on the bed if it must be smooth)?
  176. - Does it still look like what was asked for, at the size asked for?
  177. Failures seen before:
  178. - a ledge left flat because it looked fine on screen;
  179. - round horizontal holes with drooping tops;
  180. - a part passing the check upright while lying it down halves the time (run `print_orient.py`);
  181. - inlaid text overlapping the body instead of sitting in a pocket;
  182. - letters touching at one point and fusing into a non-manifold edge;
  183. - an inner cavity flipped outward by a normals recalculation, hiding a 0.3 mm wall;
  184. - a model built in metres exported 1000 times too small;
  185. - a cutter ending exactly flush with a wall, leaving a seam the boolean could not close
  186. (the helpers now repair it, but overshoot anyway);
  187. - a colour inlay exported as a separate object, which the slicer then arranged beside the
  188. model instead of inside it;
  189. - a PETG part checked with PLA limits because the material was never passed.
  190. ## 8. Export and hand-off
  191. Author scripts export with `pk.export(part, "out/name", settings=SETTINGS, report=report)`;
  192. existing scenes with `print_export.py`. Both sit the model on Z = 0 in its print orientation
  193. and write `name.3mf`, `name.stl` (if asked), and `name.json` (the manifest).
  194. Then slice it if a slicer is installed: `python scripts/print_slice.py out/name.3mf`
  195. (add `--compare-supports` when any support is left, `--material`, `--walls`, `--infill` to
  196. match what you recommend). It uses the saved printer's own slicer and presets; for the
  197. default Bambu Lab P1S that is Bambu Studio. Quote its time and grams instead of the
  198. checker's estimate, and pass on any warning the slicer raises.
  199. Tell the user, briefly:
  200. - what was made and its size; the files and where they are;
  201. - orientation (already applied) and whether supports are needed, with the reason if so;
  202. - material and the settings that differ from a standard profile (`references/slicing.md`);
  203. - time, grams and layers from `print_slice.py`, or the checker's figures labelled as rough
  204. estimates when no slicer is installed;
  205. - for multi-colour: which colour is filament 1, 2, 3 (the manifest lists them), how many
  206. layers change colour and how many filament changes that costs;
  207. - anything to do after printing, and any warning you accepted and why.
  208. If a print fails, map the symptom to the model with the table in `references/slicing.md`
  209. before changing settings.
  210. ## References
  211. - `references/design-rules.md`: limits for FDM, resin and powder, and what the checker enforces.
  212. - `references/efficiency.md`: orientation, designing supports out, material, time, splitting.
  213. - `references/functional-parts.md`: fits, screws and inserts, strength, snap fits, enclosures.
  214. - `references/multicolor.md`: one object per colour, by colour system; mixed materials.
  215. - `references/materials.md`: what each filament, resin and powder changes in the design.
  216. - `references/converting-models.md`: game, sculpt, scan and AI meshes into printable solids.
  217. - `references/model-types.md`: playbooks for brackets, boxes, figurines, minis, terrain, props,
  218. articulated toys, vases, jigs and replacement parts.
  219. - `references/slicing.md`: hand-off, `print_slice.py`, Bambu Studio and PrusaSlicer notes,
  220. settings to recommend, failure table.
README.md · README · 197 lines
  1. # 3D Print Modeling: an agent skill
  2. Ask your coding agent for a part, and get a model that actually prints: no supports where they
  3. can be designed out, the right way up, walls and holes sized for your nozzle, and a file your
  4. slicer opens ready to go.
  5. This is a skill for agents that can run commands on your computer, such as
  6. [Claude Code](https://claude.com/claude-code) or Codex. It gives the agent a method for
  7. designing printable models and a set of tools, run in headless [Blender](https://www.blender.org),
  8. to check its own work before handing you a file.
  9. ![Review board for a bracket that prints with no support](docs/review-board.png)
  10. *The agent renders a board like this for every model and looks at it: overhangs, the first
  11. layer, wall thickness and a section. This bracket needs no support.*
  12. ## What you can ask for
  13. - "Design a wall bracket for two M4 screws that holds a 25 mm pipe."
  14. - "Make a box with a snap-fit lid for a 70 × 50 mm circuit board, printed in PETG."
  15. - "This STL needs supports everywhere. Can you make it print better?"
  16. - "Turn this game model into a 120 mm figurine I can print."
  17. - "Make a name tag with the letters inlaid in a second colour."
  18. - "Split this helmet so it fits my printer, with pins to line the halves up."
  19. It works for any kind of model: brackets, enclosures, replacement parts, figurines, miniatures,
  20. terrain, props, print-in-place toys, vases. It covers filament (FDM), resin and powder (SLS)
  21. printers.
  22. ## Get started
  23. **1. Install [Blender](https://www.blender.org/download/) 5.0 or newer.** No add-ons needed.
  24. You also need Python 3.9 or newer, which most systems already have.
  25. **2. Put the skill in your agent's skills folder.**
  26. Claude Code:
  27. ```
  28. git clone https://github.com/kshaham/3d-print-modeling-skill ~/.claude/skills/3d-print-modeling
  29. ```
  30. Codex:
  31. ```
  32. git clone https://github.com/kshaham/3d-print-modeling-skill ~/.codex/skills/3d-print-modeling
  33. ```
  34. On Windows, `~` is your user folder, for example `C:\Users\you\.claude\skills\3d-print-modeling`.
  35. **3. Check that it works** (a few seconds):
  36. ```
  37. cd ~/.claude/skills/3d-print-modeling
  38. python scripts/blender_run.py self_test.py
  39. ```
  40. It should end with `SELF-TEST PASS 30 of 30`. If it says Blender was not found, tell it where
  41. Blender is once:
  42. ```
  43. python scripts/blender_run.py --set-blender "/path/to/blender"
  44. ```
  45. **4. Start a new session with your agent and ask for something printable.** The first time, it
  46. asks three questions and remembers the answers:
  47. 1. Which 3D printer do you have?
  48. 2. How many colours can it print at once?
  49. 3. Which materials do you print with?
  50. Until you answer, it assumes a Bambu Lab P1S with a 0.4 mm nozzle and PLA.
  51. ## What you get back
  52. - `part.3mf` (and `part.stl` if you want it), in millimetres, already turned the way it should
  53. print and sitting on the bed.
  54. - `part.json`: size, parts and colours, the check results and the slicer settings that matter.
  55. - A review board image like the one above.
  56. - A short note: orientation, whether supports are needed and why, material, settings, and the
  57. expected time and filament.
  58. ## How it keeps models printable
  59. The agent does not just draw a shape and export it. For every model it runs a printability
  60. check and fixes what the check finds:
  61. ```
  62. PASS fdm on Bambu Lab P1S 60 x 30 x 40 mm 892 triangles 1 part(s) 1 shell(s) 11.86 cm3
  63. bed contact 1690 mm2 support needed on 0 mm2 (0.0 cm3) bridges 0 mid-air starts 0
  64. thinnest wall 3.96 mm rough estimate 9.0 g pla, 25 min, 200 layers
  65. ```
  66. The check covers:
  67. - **Is it a real solid?** Holes in the mesh, inside-out or overlapping pieces, wrong units.
  68. - **Does it fit?** Against your printer's build volume.
  69. - **Will each layer have something under it?** Overhangs past 45°, bridges that are too long
  70. for the material, and parts that start in mid-air.
  71. - **Is anything too thin, or too close?** Walls below what your nozzle can print, and gaps so
  72. small that moving parts would fuse.
  73. - **Will it stay on the bed?** First-layer contact, tall narrow parts, centre of mass.
  74. - **Resin and powder:** sealed cavities that would trap resin or powder.
  75. - **Colour:** how many layers change filament, which is what makes multi-colour prints slow.
  76. Here is the same board for a deliberately bad model. Red needs support, orange is a wall too
  77. thin to print well, blue is the only part touching the bed:
  78. ![Review board for a flawed model](docs/review-flawed.png)
  79. When a problem can be designed away, the agent does that rather than adding supports: a 45°
  80. chamfer under a ledge, a teardrop instead of a round hole on its side, a different way up, or a
  81. split into two parts that each print flat.
  82. ## Real print times from your slicer
  83. If Bambu Studio, OrcaSlicer or PrusaSlicer is installed, the agent slices the finished model
  84. with your printer's own profile and quotes real numbers:
  85. ```
  86. python scripts/print_slice.py out/wall-bracket.3mf --compare-supports
  87. SLICED wall-bracket.3mf with bambu-studio.exe for Bambu Lab P1S 0.4 nozzle, 0.20mm Standard @BBL X1C, Bambu PLA Basic @BBL P1S 0.4 nozzle
  88. no supports 22 min 8.4 g 2.77 m 200 layers
  89. with supports 22 min 8.4 g 2.77 m 200 layers
  90. supports cost 0 min and 0.0 g
  91. ```
  92. Multi-colour models are exported so that Bambu Studio opens them as one object with a filament
  93. already assigned to each colour.
  94. Without a slicer the agent still gives an estimate, and says that it is a rough one.
  95. ## Using the tools yourself
  96. Everything the agent uses also works from a terminal, on any model file
  97. (`.stl .3mf .obj .ply .glb .gltf .blend`):
  98. | Command | What it does |
  99. | --- | --- |
  100. | `python scripts/blender_run.py print_check.py model.stl` | printability report; exit code 1 if the model fails |
  101. | `python scripts/blender_run.py print_orient.py model.stl --top 5` | ranks the ways the model can sit on the bed |
  102. | `python scripts/blender_run.py print_orient.py model.stl --apply best.3mf` | writes the best orientation |
  103. | `python scripts/blender_run.py print_review.py model.stl review.png` | renders the review board |
  104. | `python scripts/print_slice.py model.3mf --compare-supports` | real time and filament from your slicer |
  105. | `python scripts/printer_profile.py --show` | the saved printer, colours and materials |
  106. | `python scripts/printer_profile.py --set printer="Prusa MK4S" colors=1 materials=PLA,PETG` | change them |
  107. | `python scripts/printer_profile.py --printers` | printers known by name |
  108. | `python scripts/blender_run.py assets/author_template.py --review --out out` | builds the example bracket |
  109. | `python scripts/blender_run.py assets/author_fit_gauge.py --out out` | builds a clearance gauge for your printer |
  110. Add `--material petg`, `--nozzle 0.6`, `--process resin` and similar to any check to override
  111. the saved printer.
  112. ## What is inside
  113. | Path | What it is |
  114. | --- | --- |
  115. | `SKILL.md` | the instructions the agent follows |
  116. | `references/` | design rules for each process, printing efficiently, functional parts and fits, multi-colour, materials, converting existing models, playbooks per kind of model, slicer hand-off |
  117. | `scripts/` | the checker, orientation ranker, review renderer, exporter, slicer driver, printer profile, modeling helpers and self-test |
  118. | `assets/` | a complete example part to copy, and the clearance gauge |
  119. ## What has and has not been tested
  120. - Developed and tested on Windows with Blender 5.2, Bambu Studio 2.9 and PrusaSlicer 2.9.
  121. - macOS and Linux should work (the tools look for Blender and the slicers in their usual
  122. places there) but have not been tested. Reports are welcome.
  123. - OrcaSlicer takes the same path as Bambu Studio but has not been tested.
  124. - The multi-colour hand-off was verified through Bambu Studio's command line, not by hand in
  125. its window.
  126. - The checker's own time and mass figures are estimates for comparing two versions of a design.
  127. Use the slicer's numbers when the time matters.
  128. - Models are built as meshes in Blender. For precise mechanical parts that is usually enough;
  129. the skill says when a CAD kernel would serve better.
  130. - Nothing here replaces a test print. Printed parts are not certified for safety-critical use.
  131. ## Troubleshooting
  132. | Problem | Fix |
  133. | --- | --- |
  134. | `Blender not found` | `python scripts/blender_run.py --set-blender "/path/to/blender"` |
  135. | `no slicer found` | install your slicer, or `python scripts/print_slice.py --set-slicer "/path/to/slicer"` |
  136. | The agent does not use the skill | check the folder name and location, then start a new session; ask for it by name ("use the 3d-print-modeling skill") |
  137. | It asks about your printer again | `python scripts/printer_profile.py --show` should list your printer; if not, set it as in the table above |
  138. | A check result looks wrong | run `python scripts/blender_run.py self_test.py` and open an issue with its output and the model |
  139. ## Contributing
  140. Issues and pull requests are welcome, especially test reports from macOS, Linux, OrcaSlicer and
  141. other printers. Run the self-test before and after a change.
  142. ## Licence and credits
  143. [MIT](LICENSE). Blender discovery in `scripts/blender_run.py` is adapted from
  144. [EL4CTEO/blender-skills](https://github.com/EL4CTEO/blender-skills) (MIT); see
  145. `THIRD_PARTY_NOTICES.md`.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.