A local page for looking at what kiln made, telling it what to change, and asking Claude from the page itself. /kiln studio starts it on your project folder (or reuses the one running): every .glb .gltf .fbx .obj .usdz .3mf .stl under it shows up, and kiln's _original … _final stages are one model you can switch between.

• Look — Lit, Unlit, Clay, Normals, UV checker, Faces (back faces red), wireframe, sizes in metres, bones, animation clips with a scrubber; the previous version beside the current one.
• Annotate — pin a note on a spot (it records the point in Blender coordinates, the object and material hit, the camera, a screenshot and a close-up) or write one about the whole model.
• Ask Claude from the page — with "Ask Claude from Studio" on, the page runs Claude Code itself (claude -p, on its own Blender, never yours): "Work on them with Claude" addresses every open note, a conversation per model and one for the project, New model asks for a model from a sentence or a photo. Safe calls pass; anything else waits for your OK in the page, and paid generation asks unless you set it to Auto in Settings. Measured on the bench: a note asking for a ring twice as big, addressed in one pass — ×1.9, nothing else moved, the note answered — for $0.69 of API-equivalent usage (official Lab MCP: $0.73). Or run /kiln studio in your terminal: Claude reads the open notes, changes the model, re-exports and replies on each.
• Claude in your terminal sees what Studio shows — installed as a plugin, kiln brings a small MCP server, kiln-studio, with nothing more to set up (a standalone-skill clone does not register it). Say "fix this" or "what am I looking at" and Claude reads the model open in the page, its stage, the camera and the note picked, and can grab the image you see. It drives the page too: open a model, turn the view to a note's, switch to clay or normals, a before/after against the previous version, play a clip, and a present mode for a second screen. It replies on notes and leaves its own, and makes variations and finishes when you ask; it never touches a model file itself. Tools and when they are called: references/studio.md § 11.
• Outputs — Web, Game, AR and 3D print for each model. Game (FBX) and AR (a GLB and a USDZ that passes usdchecker --arkit) are made by Studio itself, in seconds, without Claude. Download zips the outputs you pick with a sheet: each file's size and use, the licences.
• On your phone — a QR code shows the model in AR on an iPhone (AR Quick Look), on the same Wi-Fi, through a read-only link that expires after 15 minutes. Android: not tried yet.
• Variations and finishes — new models from a copy of this one ("the same in rusted iron"), one Claude run each, several at once if you allow it; finishes are kept in one file (KHR_materials_variants) and the AR view lets you pick one.
• Check — the Checks tab reads the file in plain words, each with how to fix it: triangles against the detail tier, size and ground contact, texture sizes, compression, the licences the log records, and the fidelity measure against the reference photo.
• Watch it built — once the brief is confirmed, the page opens the model kiln is building and reloads it after each phase; a dot per model shows what kiln is on.
• Every command by name (⌘K), seven themes (high contrast among them), English and French, a playable tutorial on an example model, a tip the first time you meet each feature.

No extra service. Studio is a Python standard-library server bound to 127.0.0.1; only the phone link reaches your local network. Claude runs on the account you choose in Settings — your Claude subscription by default; another Claude account or an API key are supported but not yet tested with a real one. Notes live in the project's .kiln-studio/, ready to commit with the models. references/studio.md is the reference.

Say it will be printed — FDM or resin, a height, your printer's colours — and kiln models for the printer from the first primitive: at size, in closed solids joined into one volume, walls thick enough (0.8 mm FDM, 0.5 mm resin), a flat base, overhangs designed out where nobody looks, relief as geometry, and in several parts when one would print in the air — the windmill above is a body and its sails, laid flat, each checked on its own. STL in millimetres. Every STL ends with tools/print_check.py: open and non-manifold edges, normals, held and floating parts, walls, overhangs, loss against the original, the smallest scale you can shrink it to in the slicer, and PrusaSlicer as a second opinion (references/print.md).

Measured on sessions given the skill and nothing else: a dog house and a lighthouse from a brief, a pumpkin and a ghost from photos, the windmill, and this teapot from three museum photos — printable, and like what was asked.

Stylised figures, not likenesses. Two cats — one held by the ghost, one from a real cat's photo — passed every check and were unacceptable to look at. A stylised figure is another matter: a session made a cartoon dragon from one flat drawing, in four colour parts, from metaball families and one voxel remesh, and a fresh session then made a cartoon fox the same way. So print mode builds a stylised figure that way, and says at CONFIG that a realistic likeness of a real animal or person is out of reach of scripted modelling.

A model you made: flatten it, then check it

A model finished by hand often has faces that should be flat and are not, and sits a degree off. tools/flatten.py makes nearly flat faces exactly flat and lays the base on the bed — on the windmill above, 629 mm of first layer become 3,317 — and touches nothing else: curves, folds, bevels and real slopes stay, no vertex moves past the tolerance, the input is never overwritten.

/kiln inspect model.stl     # print mode: print_check's verdict
/kiln cleanup model.stl     # print mode: flatten.py, then print_check again, before and after shown

Limits

• Printed, four of them. The forge, the lighthouse, the Art Deco box and the windmill were printed as kiln exported them, on a Bambu Lab P1S in PLA (photos). The box's bayonet lid turns, locks and holds with the box upside down. The fit test print was not printed; the rest was checked by PrusaSlicer 2.9.6 and by renders, not on a bed.
• FDM, checked with PrusaSlicer's default profile. No resin slicing, no orientation search, no support generation, no build-volume check.
• Scaled down in the slicer, a model loses its thin walls. print_check says how far — "do not shrink below 40 %" for the windmill's body, 67 % for the lighthouse.
• Parts are glued or pressed, never moving. 0.2 mm a side is a usual clearance, not measured here; tools/fit_coupon.py writes the test print that measures it on your printer.
• Decorative objects, not mechanical parts. A bracket, or a box whose lid must close, belongs in a CAD tool (build123d, CadQuery, OpenSCAD).
• No multi-material file. A colour is painted, or printed as its own part.
• Self-intersections are counted, not repaired, and flatten.py does not fill holes.

The full list is in references/print.md § What it does not check. The teapot photo is the Auckland War Memorial Museum's, CC BY 4.0, via Wikimedia Commons.

1. Read the photo before modeling. An inventory of every part and how it meets the next, from enlarged crops; the real size, the camera's height and angle — asked, or stated as assumptions. Given a 3D mesh generated from the same photo, its proportions are measured instead (TRELLIS.2, locally) — never shipped.
2. Texture from scans, not noise. A Poly Haven CC0 texture set of the material family, chosen by eye against the photo, tinted to its palette, worn by the form.
3. Measure against the photo. plugin/tools/fidelity_check.py renders the model at the photo's camera under a studio light and lists the gaps — silhouette per height band, materials, metal that cannot exist.
4. Look at every joint. Each end of a long part that touches another is rendered alone: a part that joins another enters it.
5. Ship, and measure the file that ships. Optimized (Draco, WebP), validated, re-measured as a GLB — what the user gets, not the .blend.

/kiln animate picks the route from the subject, because no single method held up across all of them (references/animation.md has every measurement):

UniMate was measured unusable for quadruped walking — on a cat, a Shiba, a horse and the model author's own robot dog — so a quadruped never goes to it.

What this showcase is, and is not. Each UniMate tile is the sample, out of 4, that motion_loop.py kept for looping best, then approved by a reviewer — some prompts tried (wave, dance, run) were left out. The scripted tiles are deterministic. These come from scripts (examples/animation/showcase.sh), not from an interactive session.

Organic characters

A character is built as one skin — families of metaballs or overlapping volumes, joined by a single voxel remesh — so it bends without seams at the shoulders, hips and neck. Then:

• A learned auto-rig. A humanoid, or a mesh kiln did not build (a generated one), is rigged by SkinTokens (MIT, runs locally) and handed back with kiln's skeleton: Mixamo names, weights cleaned, eyelid and ear bones added. A quadruped kiln built keeps its own rig, which walked better. On the bench, skin crossing skin when the character bends: 3.15 % → 0 % on a low-poly villager, 1.34 % → 0 % on a chibi, 0.74 % → 0.45 % on a generated humanoid, against 2.2.0's rig.
• Ready-made humanoid moves. tools/presets.py puts 22 motions (walk, run, jump, dance…; 43 clips, NVIDIA Kimodo, commercial use allowed) on a kiln-named humanoid, with the feet planted, the arms kept out of the body, and --loop for a closed in-place cycle.
• Looped clips that close — one clip per file, the last key equal to the first; a walk loop for a game, beside the whole take.

Limits, measured: the auto-rig was compared on one pose of two humanoids, and runs differ; a generated humanoid with a hand fused to its hip keeps skin through skin on its arms; SkinTokens needs about 5.6 GB on disk and 7 GB of memory per mesh. references/characters.md has every table.

• A generator's GLB, repaired end to end (bench brief repair-trellis-glb, a raw TRELLIS output): 191,520 triangles, 11.4 MB, 13,732 non-manifold and 10,220 open edges → 9,000 triangles, 0.63 MB, 0 and 0: the glass globe, too thin to survive a remesh, refilled with a lathe shape fitted to its profile, the whole closed by a voxel remesh and decimated with Blender's Collapse — 16 minutes, $3.89 of API-equivalent usage. On the official Lab MCP: the same 0 and 0, 0.93 MB.
• A generated lantern finished as a game asset (ref-lantern-trellis): shape kept, surface rebuilt, 0.946 against the real lantern's 3D model (2.2.0: 0.934 — how it is scored).
• From a sentence, through the free Hugging Face Spaces (ai-mushrooms): a FLUX.1-schnell concept, then TRELLIS.2 (MIT, one 89 s call), decimated to 8,991 triangles, textured, shipped at 279 KB — 12 minutes, $3.80. kiln 2.2.0 went to Hunyuan3D-2 for the same brief, whose licence excludes the EU, the UK and South Korea; 3.0 uses it only when asked.

About the usage column. On a Claude Pro or Max subscription, these sessions are included in your plan's usage — there is nothing extra to pay. The dollar figure is what the same session would have cost on the Anthropic API (Claude Code's total_cost_usd); the bench uses it to compare versions, and as a rough measure of how much of your plan's usage a run takes. kiln itself never pays for a service (rule 5).

_{Shape score: mean silhouette overlap with the real asset from front, back, sides and top (bench/gt_compare.py); openwork views left out for the chair. Size is assumed when a brief gives none, and a single photo does not give it: every lantern came out 20 to 50 % taller than the real one. One run per brief, and runs of the same skill differ by about ±0.02–0.03. 3.0 costs about 40 % more than 2.2.0: the new checks (render reviews, UV, printability), the learned auto-rig, closed loops and the photo projection are extra work in the session. Three photo briefs and the generator repair were re-run after fixes the bench itself found — what changed and why is in the CHANGELOG.}

Close, not identical, on purpose. kiln stops at a few dollars of API-equivalent usage per object. img2threejs, which rebuilds an image as Three.js code through eight vision-reviewed passes, keeps finer surface detail: on the same lantern its likeness was comparable — 0.866 against kiln v7's 0.861 (2.0 era) — at about three times the usage, estimated on a run stopped after three of its eight passes (benchmarks § 4).

What did not improve is published too: the benchmarks — eighteen versions of one lantern, what each fix broke, how the bench was kept honest — and every number, render and GLB under 1 MB on the bench-results branch, except the humanoid derived from Hunyuan3D, whose licence keeps it out.

How long it takes

Time Claude spent on whole headless sessions in the bench (auto mode, every question answered in the brief, so no time waiting for you), Blender 5.2.2, skill 3.0, one run each, October 2026. An interactive session adds your answers.

_{¹ The free Hugging Face quota was spent that day: the session fell back to scripted modelling, as the skill says to, and paid for nothing.}

Single steps, measured where stated:

The bench ran on an Apple M4 Pro with 24 GB of memory, macOS, Blender 5.2.2.

_{Licences read on 2026-10-16. This is a summary, not legal advice: read the licence before shipping anything commercial.}

As a standalone skill

git clone https://github.com/elithril/blender-kiln.git ~/.claude/skills/blender-kiln

Restart Claude Code, then run /kiln setup. The skill itself lives in plugin/; the repository root links SKILL.md, references and tools to it, so a clone works as a skill directory as it is. On Windows, enable symlinks in git (core.symlinks) or install as a plugin.

Layout

A plugin install ships only plugin/ — about 5 MB (2.2 MB of ready-made motions, 1.4 MB of Studio's page):

plugin/
├── .claude-plugin/plugin.json
├── SKILL.md
├── LICENSE
├── NOTICE                        # third-party code and licences kiln adapts (image-to-3dlab, SkinTokens patch, …)
├── .mcp.json                     # the kiln-studio MCP server: what you look at in Studio, from Claude Code
├── tools/                        # checks: fidelity_check, print_check, uv_check, review_renders, check_usdz · build: template_profile, flatten, fit_coupon, photo_project, cutout · rig and motion: autorig, quadruped, presets (+ motions/), retarget, motion_measure, motion_loop, bind_rigid_parts, unimate (+ patch) · export: export_outputs, glb_to_fbx, glb_to_usdz · Blender: open_blender, blender_mcp_start · verify_docs, verify_blender
├── studio/                       # Kiln Studio: studio.py (CLI), server.py, studiolib.py, checks.py, worker.py (Claude from the page) + approval_hook.py, mcp_server.py, phoneshare.py (AR by QR code), handoff.py (downloads), blender_live.py, static/ (the page), tests
└── references/
    ├── ai-generation.md
    ├── animation.md
    ├── batch-mode.md
    ├── blender-mcp.md
    ├── characters.md
    ├── cli-tools.md
    ├── commands.md
    ├── export-targets.md
    ├── log-format.md
    ├── naming-conventions.md
    ├── photo-projection.md
    ├── pipeline-brief.md
    ├── pipeline-import-cleanup.md
    ├── review-rounds.md
    ├── pipeline-optimize-export.md
    ├── pipeline-rig-animate.md
    ├── pipeline-source.md
    ├── print.md
    ├── reference-fidelity.md
    ├── setup-install.md
    ├── setup.md
    ├── sourcing-strategy.md
    ├── studio.md
    ├── texturing-strategy.md
    ├── topology-rules.md
    ├── uv-materials.md
    └── validation-checklist.md

The skill drives a live Blender through the Blender MCP addon. Below is SM_Barrel built, cleaned and exported inside a running Blender session — object named to convention, sitting on Z=0, ready to export:

The MCP pass and the headless scripted pass agree to the byte — 111.9 kB GLB either way, same 2,202 triangles, same three materials.

Check the integrations before you search

All the integrations ship off, as shown here. Iron rule 23 has kiln check them before any search or generation: on mcp-for-blender 2.1.9 and later, get_addon_status() lists each library and generator as on or off, and a search on one that is off says which box to tick. Older servers are harsher: while an integration is off, the addon does not register its commands at all, so a search does not come back "disabled" — it comes back

Unknown command type: search_polyhaven_assets

which reads like a version mismatch. There, get_polyhaven_status, get_sketchfab_status, get_hunyuan3d_status and get_hyper3d_status are registered unconditionally and return the fix step by step — including the Sketchfab API key, which nothing else surfaces. Tick the boxes in the MCP panel of the 3D Viewport sidebar (press N if hidden); no reconnection needed.

Fifteen props across three themes, modelled from scratch by script, cleaned, audited, rendered and exported — headless, on one laptop, no cloud service, no paid API. They were produced by the scripts in examples/gallery/, written to the skill's rules, not by an interactive run of the skill: treat them as reference output and a conventions check (docs/gallery.md).

Total: ~7,600 lines of SKILL.md and references — the production knowledge Claude reads.

plugin/tools/verify_docs.py runs on every push (.github/workflows/verify.yml) and checks that this documentation is still true — text only, no Blender, a few seconds:

• iron rules form one unbroken 1..N sequence across plugin/SKILL.md and batch-mode.md
• every cited rule N exists and means what the citation claims
• the rule count below matches reality, and every line count in the structure table is within 15% of the file it describes
• every referenced file exists, and none point outside the plugin directory
• every README image resolves
• no bare pip install (it fails on any PEP 668 Python)
• the plugin manifest is valid and its source is a real directory
• documented commands use the invocable /kiln <sub> form

plugin/tools/test_verify_docs.py seeds each of those regressions and asserts the checker catches it — 24/24 (20 seeded regressions, 4 that must stay silent). Every case is a mistake that was actually made here, including two renumberings that left a reference pointing at the wrong rule.

plugin/tools/verify_blender.py (.github/workflows/blender.yml, weekly and on demand) re-checks what needed Blender to establish — the documented bpy API still exists, the Principled sockets the docs name are real, Rigify's deform-bone counts still match the tiers PHASE 5c routes on, geometry nodes still need the modifier applied before export, USDZ still exports natively into a conforming archive, and rule 10's weld — the code in validation-checklist.md, run as written — still keeps a faceted mesh's shading and closes the tear a split-edge mesh opens at its first pose; on synthetic rigs built in the check, the quadruped walk stays bent and in step, a bone-parented part follows its bone once folded, and a clip cut mid-swing loops back to its exact period. It also fails on any Blender DeprecationWarning reached by the docs or the gallery — its first run surfaced Material.use_nodes, slated for removal in 6.0. Each check guards a shipped bug; this notices when a Blender release makes one wrong again.

plugin/tools/unimate.py drift (.github/workflows/unimate-drift.yml, weekly) clones UniMate's upstream HEAD and checks kiln's patch still applies to it — the text-to-motion model of phase 5d is a research project that changed its pipeline, checkpoints and licence within days of kiln first measuring it.

plugin/tools/test_fidelity_check.py runs in blender.yml and seeds what the review tool claims to measure — a model against its own render (IoU 0.998), the same model 20 % wider (measured +20.3 %), an unloaded texture (refused), a .blend (warned), the triangle range (kept under twice its top, a reduction proposed past it), dark metal (reported; the same colour as non-metal, silent), metal in hard scattered islands (reported; one soft region, silent), metal painted mostly as non-metal (reported), grain measured but never listed as a gap, joint close-ups (a rod resting on a sphere rendered; sunk or free, not), --view and --azimuth on a 2 x 1 x 1 box, the face measure, and a photo with no transparency (refused), and the measure saved for Kiln Studio (fidelity.json with the model's hash, one log line per run), and a lower body 14 % wider under a camera 15° above, told as the photo's perspective — 38/38. Its first run caught the tool framing views by height only: anything wider than tall was clipped, a box measured 1:1 instead of 2:1. plugin/tools/test_print_check.py builds the meshes a print can fail on — open, inverted, floating, too thin, a cavity, a loss against the original, a carved cup against its closed reference, the smallest scale of a 2 mm plate — and checks each verdict, with PrusaSlicer when it is there, and an assembly of colour parts — 67/67. plugin/tools/test_flatten.py seeds what flattening must and must not touch: a jittered top made flat, a cylinder, a sphere, a dome, a wave, a 5° slope, a 0.2 mm step and a 0.2 mm bevel left alone, a tilted model laid on the bed — 22/22; each case after the first was added when a real model broke the tool. plugin/tools/test_fit_coupon.py reads the coupon's holes and peg back from the STLs, not from the tool's report — each size to the micron, both parts closed, diamond and round — 18/18. plugin/tools/test_review_renders.py renders a seeded block and reads the images back: one per view and mode, the subject spanning the frame, a close-up aimed at nothing refused, a close-up at negative coordinates read as a value, a rigged GLB framed without its bone sphere, a texture and vertex colours shown in colour, a close-up behind a taller part seen along its normal — 12/12. plugin/tools/test_uv_check.py seeds the unwraps the UV check must and must not flag: a clean Smart UV Project sphere as .blend and GLB (silent), no UV with and without a texture, stacked, collapsed, stretched and mirrored UVs — 9/9. plugin/tools/test_template_profile.py reads a seeded turned part back through template_profile.py — radii, a free rod, a rod pressed against the body — 4/4.

The skill enforces 31 rules (26 core + 5 batch-specific). Key ones, by their real number — the full text is in plugin/SKILL.md and plugin/references/batch-mode.md:

• Rule 1 — always get_scene_info() before each phase
• Rule 2 — always look() at the model at the end of every phase that changed geometry or materials, two angles after texturing
• Rule 4 — never hard-cap poly count: alert if out of range, never block
• Rule 5 — never spend money: a free service that answers HTTP 402 has stopped being free, so switch source; never remove a watermark
• Rule 6 — never silently destroy: decimate, simplify, delete are always proposed
• Rule 7 — always keep the .blend file
• Rule 18 — never export_apply=True for glTF: modifiers balloon file size
• Rule 19 — always run the material export audit before a glTF export
• Rule 20 — never gltf-transform optimize: use individual steps
• Rule 22 — frame the viewport before screenshotting it, or the shot shows an apparently empty scene
• Rule 23 — always check integration status before searching a marketplace: on older servers a disabled integration answers Unknown command type, not "disabled"
• Rule 25 — rename every import to the naming convention, whatever its source
• Rule 26 — never pick a rig without measuring vertices ÷ deform bones: a Rigify human needs ~3,200 vertices to be worth it
• Rule 30 — between batch assets, clear the scene by removing datablocks, never with read_homefile()

Two storage modes, configurable at pipeline start:

Compact (default) — minimal footprint, the .blend is the recovery point; one folder per use:

generated-assets/
└── wooden-chair/
    ├── wooden-chair_original.glb
    ├── wooden-chair_preview.glb     (a copy of _original: opens in macOS Quick Look)
    ├── wooden-chair.blend
    ├── wooden-chair_log.md
    ├── web/    wooden-chair_final.glb                         (a website: Draco, WebP)
    ├── game/   wooden-chair_game.fbx                          (Unity, Unreal)
    ├── ar/     wooden-chair_ar.usdz, wooden-chair_ar.glb      (iPhone and Vision Pro, Android)
    └── print/  wooden-chair_print.3mf, wooden-chair_print_seat.stl, …   (3D printing)

A folder is made only when its output is asked for. Full storage also keeps the intermediate stages at the root (_clean, _textured, _optimized).

Batch mode — assets grouped under a batch folder with manifest and report:

generated-assets/
└── batch-corporate-office-2026-04-02/
    ├── batch-manifest.yaml
    ├── batch-report.md
    ├── desk/
    ├── chair/
    └── keyboard/

At the end of a multi-asset session, Kiln proposes a cleanup of intermediate files with per-asset size breakdown.