KILN
Keyed Implicit Language & Notation

Your agent can't sculpt.
It can write.

KILN turns text into smooth, stylised 3D game models. Your AI agent writes a model as simple shapes that blend like clay; KILN meshes, paints, rigs and animates it, and your game gets glTF files and Godot scenes. No image generator, no GPU, no Blender.

Pick a styleInstall (1 line)
  • MIT-licensed, free
  • Runs locally, offline
  • No credits, no API key
  • The models are yours

Looking for pixel art? Try PAGAN. Audio? SEGAN. Same design, same workflow.

7,642 triangles, rigged, 3 animations, from this 56-line filemodels/pilot.kiln.yaml
name: pilot
description: bean crew member in a pilot's cap with the airline's wings
class: character
tags: [crew]
status: approved
style_version: 1
parts:
  - capsule: { from: [0, 0.32, 0], to: [0, 0.74, 0], radius: 0.3 }
    color: red
    material: plastic
  - capsule: { from: [0.12, 0.1, 0], to: [0.12, 0.26, 0], radius: 0.1 }
    id: leg_l
    mirror: x
    mirror_id: leg_r
    blend: 0.05
    color: red
    material: plastic
  - capsule: { from: [0.3, 0.6, 0], to: [0.42, 0.38, 0.08], radius: 0.08 }
    id: arm_l
    mirror: x
    mirror_id: arm_r
    blend: 0.04
    color: red
    material: plastic
  - box: { at: [0, 0.56, 0.29], size: [0.09, 0.22, 0.05], round: 0.015 }
    color: navy
    material: fabric
    pattern: { type: stripes, color: gold, size: 0.06, width: 0.3, axis: y }
  - sphere: { at: [0.1, 0.84, 0.23], radius: 0.1 }
    mirror: x
    color: white
    material: plastic
  - sphere: { at: [0.11, 0.85, 0.32], radius: 0.042 }
    mirror: x
    color: black
    material: plastic
  - cylinder: { at: [0, 1.08, 0], radius: 0.25, height: 0.15, round: 0.03 }
    id: cap
    color: navy
    material: fabric
    decal: { image: decals/wings.png, axis: z, at: [0, 1.09, 0.25], size: [0.2, 0.1] }
  - cylinder: { at: [0, 1.0, 0.07], radius: 0.27, height: 0.03, round: 0.012 }
    id: cap
    color: navy_dark
    material: fabric
rig:
  leg_l: { pivot: [0.12, 0.26, 0] }
  arm_l: { pivot: [0.3, 0.6, 0] }
  cap: { pivot: [0, 1.0, 0], meta: { detachable: true }, separate: true }
skin: soft
animations:
  walk: { fps: 12, cycle: { type: waddle } }
  wave: { fps: 8, cycle: { type: wave, arms: [arm_r] } }
  idle: { fps: 6, cycle: { type: breathe } }
variants:
  copilot: { swap: { red: teal } }
The translation layer

You describe it. Your agent writes it.

With the KILN skill (Claude) or the MCP server (any agent), your AI agent becomes the modeller between what you want and the models your game loads.

  1. You English

    "A bean pilot for my airline game. Waddles, waves."

  2. Agent Claude + KILN skill / MCP
    • plans it in metres, writes pilot.kiln.yaml
    • runs kiln lint
    • looks at the turntable
    • fixes what's off
  3. KILN the kiln
    • meshes and paints it
    • rigs and animates it
    • applies the style
    • deterministic builds
  4. Your game any engine
    • pilot.glb
    • pilot.tscn
    • manifest.json
One model, any style

Same text. Your game's look.

A project picks a style: smooth or faceted shapes, triangle budgets, material presets and the look kit (sky, sun, tonemapping, toon bands, outlines). Switch it and every model follows on the next build. These are the same model files, built three times.

Five presets ship (soft toy, low poly, toon, clay, diorama). For your own, give the agent 3-6 screenshots of games you like: it writes a style that extends the closest preset, makes one test model, and puts it beside your inspirations with kiln preview --vs until you say yes.

# styles/cozy.style.toml
extends = "soft_toy"
notes = "Chunky pastel props, heads 0.6 of the body, no outlines"
[look]
saturation = 0.9
sky_top = "#f2b8c6"
Why KILN

Built for a whole game's worth of models

Every picture below is KILN's own output, from the demo project in this site's repository: its previews, its lint, its build.

1 Shapes that blend like clay

Eleven primitives (spheres, capsules, rounded boxes, cylinders, cones, tori, tubes, lathes, extrusions, wedges) that join smoothly where you ask, cut each other, mirror and repeat in rows and rings. Colours are palette names; stripes, bands, dots and checks have clean edges; PAGAN images go on as decals.

Text the agent writes and you can read, diff and review in a pull request.

parts:
  - capsule: { from: [0, 0.32, 0], to: [0, 0.74, 0], radius: 0.3 }
    color: red                      # a palette name
  - capsule: { from: [0.3, 0.6, 0], to: [0.42, 0.38, 0.08], radius: 0.08 }
    id: arm_l
    mirror: x                       # write the left one...
    mirror_id: arm_r                # ...the right is its own part
    blend: 0.04                     # melts into the body, like clay
  - box: { at: [0, 0.56, 0.29], size: [0.09, 0.22, 0.05], round: 0.015 }
    pattern: { type: stripes, color: gold, size: 0.06, axis: y }
  - cylinder: { at: [0, 0.81, 0], radius: 0.26, height: 0.04 }
    cut: true                       # holes and openings

2 It looks at its own work

Previews render on any machine, no GPU or display: a turntable from 8 sides and 3 heights, close-ups of any part, animation filmstrips, a line-up at one scale. The skill tells the agent to look before it reports, because nobody judges proportions blind.

KILN's turntable of the knight: 8 sides from below, eye level and above

3 It checks its own work

A linter for 3D: floating pieces, parts too thin to mesh, models off the ground, wrong size for the class, blown triangle budgets. A real one, from the archer's first draft:

W103 the model is 2 separate pieces: a floating part, or a gap between parts that should touch

The archer's first draft: the bow floats beside the hand
draft
Fixed: the bow is in the archer's hand
fixed: 0 warnings
@@ -4,6 +4,6 @@ tags: [siege, soldier]-status: draft+status: approved style_version: 1 parts:-  - torus: { at: [0.72, 0.55, 0.05], radius: 0.36, thickness: 0.022, rotate: [0, 0, 90] }+  - torus: { at: [0.5, 0.55, 0.05], radius: 0.36, thickness: 0.022, rotate: [0, 0, 90] }     id: arm_l@@ -11,5 +11,5 @@     material: wood-  - box: { at: [0.72, 0.55, -0.15], size: [0.2, 0.9, 0.4] }+  - box: { at: [0.5, 0.55, -0.15], size: [0.2, 0.9, 0.4] }     cut: true-  - capsule: { from: [0.72, 0.2, 0.05], to: [0.72, 0.9, 0.05], radius: 0.012 }+  - capsule: { from: [0.5, 0.2, 0.05], to: [0.5, 0.9, 0.05], radius: 0.012 }     id: arm_l

4 Rigs and animation

Give a part an id and a pivot and it moves. Rigid skins for machines and props; soft skins for creatures, one mesh that bends where its parts blend. Write poses frame by frame, or let a cycle write them. Gameplay data rides along: meta: { hitzone: head } becomes node metadata in the engine.

rig:
  arm: { pivot: [0, 1.78, 0], meta: { fires: true } }
skin: rigid                  # or soft: one mesh that bends
animations:
  fire:
    fps: 12
    loop: false
    poses:
      - {}
      - { arm: { rotate: [35, 0, 0] } }
      - { arm: { rotate: [80, 0, 0] } }
      - { arm: { rotate: [120, 0, 0] } }
  # or a cycle: walk, waddle, hop, bob, spin,
  # swing, breathe, wave, chain
KILN's filmstrip of the trebuchet's fire animation, front and side

5 Game-ready output

kiln build writes binary glTF (.glb) with parts, skins, animations, variants and LODs, within the style's triangle budget. For Godot: a scene per model with the style's materials (toon bands, outlines, rim light) and a look kit per style (sky, sun, tonemapper, SSAO, glow). kiln build --verify-godot loads it all in headless Godot. manifest.json is the contract for any engine.

add_child(load("res://assets/kiln/looks/soft_toy.tscn").instantiate())  # once per scene
var pilot = load("res://assets/kiln/models/pilot.tscn").instantiate()
add_child(pilot)
pilot.get_node("AnimationPlayer").play("wave")
The demo models running in Godot 4 with the soft_toy look kit
{
 "pilot": {
  "glb": "models/pilot.glb",
  "scene": "models/pilot.tscn",
  "height": 1.15,
  "triangles": 7642,
  "parts": {
   "cap": {
    "pivot": [0, 1, 0],
    "meta": {
     "detachable": true
    }
   },
   "…": "5 more"
  },
  "animations": {
   "walk": {
    "loop": true,
    "fps": 12
   },
   "…": "2 more"
  },
  "variants": ["copilot"]
 }
}

6 Everything at one scale

Models are written in metres. kiln lineup stands them on one ground line beside a 1 m bar, so a 1.2 m bean doesn't end up taller than the door. Lint W108 flags sizes that don't fit their class.

KILN's line-up: pilot, passenger, knight, archer, barrel, seat and tree at one scale

7 Free asset packs, in your style

Text is bad at dense foliage and realistic rocks. For those, bring in CC0 packs (Kenney, KayKit, Quaternius): KILN scales them, stands them on the ground, snaps their colours to your palette and gives them your style's materials, so they match. CREDITS.md writes itself.

$ kiln import rock.glb --licence CC0-1.0 \
    --author Kenney --height 1.5

Licences that forbid it (NC, ND, "no AI") are refused by the skill.

8 A project that remembers

BRIEF.md (what the game needs, every decision) and STYLE.md (how it looks) are the agent's memory between sessions. Models carry a status and a style version; kiln style bump flags older models for review, and kiln status lists what's left.

9 Built for agents

A Claude skill that teaches the workflow, an MCP server (20 tools, previews come back as images) for any agent, --json on every command, and kiln.api for generator scripts: walls with merlons, fences, stairs, forests, crowds.

How it compares

Three ways to get 3D from an agent

Facts as of October 2026. Pick what fits your game.

Image / text-to-3D generatorsMeshy, Tripo, Rodin, Hunyuan3DAgent-driven BlenderBlender MCP serversKILN
How models are madeA neural model generates a mesh from a prompt or an imageThe agent drives Blender step by step through tool callsThe agent writes a source file in a text notation that KILN compiles
Models are stored asMeshes (.glb, .fbx).blend filesText in git: diffable, reviewable, editable by hand or by agent
Cost / accessCloud credits or a subscription; open-weight models need a large GPUFree; needs Blender installedFree, MIT, offline, CPU only
MeshesDense or uneven triangles; often needs clean-upWhatever the agent buildsClosed meshes within the style's triangle budget, LODs on request
Style across a gamePer prompt / reference imageNone built inProject-wide styles and palettes; change one, every model follows
Rigs and animationAuto-rigging on some services, mostly humanoidsPossible, by handPivots, rigid or soft skins, poses and cycles in the notation
Quality checksNoneNone built inA linter and previews the agent reads, so it fixes its own mistakes
Engine outputglTF / FBXWhatever Blender exportsglTF + manifest.json for any engine; Godot scenes, materials and look kits
DeterministicNoDepends on the agentYes: same text, same model

Where KILN loses: it isn't a sculptor. Realistic or finely detailed models (faces, hands, foliage) are beyond simple blended shapes: use a CC0 pack or a generator for those. KILN wins on a whole game's worth of stylised models that match, move and stay maintainable.

Install

One line, then ask

Requires Python 3.11+. Pin a tag so your models build the same way next year (v0.2.0 is current).

$ pip install "kiln @ git+https://github.com/lukasgolino/KILN@v0.2.0"  # install KILN (Python 3.11+)
$ kiln skill install  # copy the skill into this repo's .claude/skills/

Then ask Claude: "I'm making a cosy siege game in the style of these screenshots; start with a bean knight that waddles."

Open source

Free, for good

KILN is MIT-licensed. Every released version stays free to use, change and ship, commercially or not. No account, no telemetry, no cloud: it runs on your machine.

  • Source, issues and releases on GitHub
  • Current release: v0.2.0, see the changelog
  • Contributing: open an issue first for notation changes; every feature lands with tests, builds stay deterministic, and anything that changes the notation or built models gets a version bump.
  • Game repos pin a tag, so your models never change under you.
  • Sister libraries: PAGAN (pixel art) and SEGAN (audio), same design, same workflow. KILN reads PAGAN palettes and puts PAGAN images on models as decals.
The KILN icon, a clay pot with googly eyes

MIT · free forever · made with KILN

FAQ

Straight answers

Is KILN an AI 3D generator?

No. KILN doesn't generate: it compiles. Your AI agent writes KILN source files (shapes, colours, rigs, animations); KILN checks them, meshes them and builds them. The quality comes from the agent's modelling and KILN's mesher, not from a neural network, so results are exact, repeatable and editable.

What does it cost?

Nothing beyond the agent you already use. KILN is MIT-licensed and runs on your CPU: no credits, no API key, no GPU. If you have a Claude subscription, that's all you need.

Do I need Blender?

No. KILN meshes, paints, rigs and exports by itself, and its previews render without a GPU or display. Blender is still handy for one-off hand edits of a built .glb.

Can it match the look of a game I like?

Yes, within stylised 3D. Give your agent 3-6 screenshots; it writes a style that extends the closest preset (soft toy, low poly, toon, clay, diorama), tunes shapes, materials and lighting, and compares a test model beside your screenshots until you approve. Inspirations are reference only: never copy another game's characters.

What can't it do well?

Realism and fine detail: faces with expressions, fingers, dense foliage, realistic rocks. Use free CC0 packs for those (KILN recolours them to your palette and style), or a generator.

Which agents work with it?

Any agent that speaks MCP (Claude Code, Claude Desktop, Cursor, your own). The KILN skill, which teaches the full workflow, is for Claude. Without either, the CLI's --json output is easy for any program to drive.

Which engines?

Any engine that loads glTF: manifest.json describes every model, part, pivot, animation and variant. Godot 4 also gets scenes with the style's materials and a look kit per style, verified in headless Godot.

How is it related to PAGAN?

KILN is PAGAN's 3D sibling: PAGAN writes pixel art as text, KILN writes smooth 3D. They share the palette format and the workflow (BRIEF.md, STYLE.md, lint, previews, build), and PAGAN images go on KILN models as decals. SEGAN does the same for audio.

Who owns the models?

You do. KILN runs locally; nothing is uploaded and nothing is claimed.

More in the docs.