Skip to main content
skill CX Codex

spritekiln-splash-to-model — Claude Code skill for art-to-model

spritekiln-splash-to-model is a Claude Code skill that turns a character image into a SpriteKiln spec. It activates for requests to create a model, sprite, or animation from concept art.

MIT ★ 177 updated 2026-11-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add LucasJRamos/spritekiln --skill spritekiln-splash-to-model -a claude-code
Open on GitHub

What spritekiln-splash-to-model does

The skill guides the agent from a character reference to a SpriteKiln YAML spec. It starts by recording proportions, defining traits that should remain recognizable, and preparing a palette. Then the agent builds the shape and compares it with the art. The model is checked from all eight directions, including views the reference does not show.

Reference preparation and comparison use the spritekiln CLI, including spritekiln ref compare and spritekiln review. Busy backgrounds may need the optional splash extra, which uses rembg. When the image is cropped above the feet, IoU no longer gives a meaningful comparison; the skill calls for judging the visible proportions instead.

What it helps with

  • build a SpriteKiln YAML spec from character art
  • retain recognizable features in a 64 px sprite
  • compare a model's silhouette and palette with its reference
  • work out views absent from the original image

Example prompts for the agent

  • Turn this character image into a SpriteKiln model.
  • Create a SpriteKiln spec and sprite from this concept art.
  • Build the character model and animations from this reference.

How to install spritekiln-splash-to-model

1Skills CLI (Vercel)

npx skills add LucasJRamos/spritekiln --skill spritekiln-splash-to-model -a claude-code

2Manually: put the files in place

~/.claude/skills/spritekiln-splash-to-model/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/spritekiln-splash-to-model/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about spritekiln-splash-to-model

How do I install spritekiln-splash-to-model in Claude Code?

Run npx skills add LucasJRamos/spritekiln --skill spritekiln-splash-to-model -a claude-code. The skill file is placed at ~/.claude/skills/spritekiln-splash-to-model/SKILL.md.

What does spritekiln-splash-to-model do?

It guides the agent in turning character art into a SpriteKiln YAML spec, then checking the model's shape and colours against the reference from eight directions.

What does spritekiln-splash-to-model need to run?

It uses the spritekiln CLI. For complex backgrounds, the optional splash extra with rembg can handle background removal.

Source text

SKILL.md · MIT
---
name: spritekiln-splash-to-model
description: Turn an original splash or concept art into a SpriteKiln model (spec YAML) faithful to the art and legible at 64 px in 8 directions. Use when the user provides a character image and asks for its model, sprite or animations.
---

# From a splash art to a model

Goal: capture the character's **identity** (silhouette, proportions, striking shapes, palette), not the
brush strokes. At 64 px only what is big and contrasted survives. Read [workflow.md](workflow.md),
[modeling.md](modeling.md) and [spec.md](SPEC.md) first.

## 1. Prepare the reference
```
spritekiln new <name> --extends --ref <path/splash.png>   # <specs>/characters/<name>/ with splash.png; a humanoid
                                                      #    extends the template (drop --extends to copy it)
spritekiln ref prep <specs>/characters/<name>/splash.png    # -> splash_ref/: cutout.png, cutout_pitch38.png,
                                                      #    palette.yaml, ref.json (proportions)
```
- Look at the original splash **and** `cutout.png`. The background is removed from the border inwards, so
  flat, gradient and vignetted backgrounds work, and openings such as the gap between the legs stay
  transparent. If it cut wrong: try `--tol` 4–15 (colour step, default 9), ask for a PNG with
  transparency, or install the `splash` extra (rembg) for busy backgrounds.
- Decide which **direction** the art shows (front = `s`, 3/4 front = `se`/`sw`, profile = `e`/`w`).

## 2. Write the brief (top of the spec)
Before any geometry, fill `brief:` while looking at the image:
```yaml
brief:
  summary: one sentence on who this is and how they carry themselves
  reference: splash.png (seen from se)
  proportions: "head = 1/4 of the height; shoulders 1.6x the hips; short legs"
  head: "high ponytail past the shoulders, side-swept fringe, soft jaw, pointed chin; eyes only (face: minimal)"
  must_keep: [3-6 traits that identify the character from afar]
  simplify: [what will vanish or merge at 64 px]
  palette_notes: [dominant materials and colours]
```
At most 5–6 `must_keep`. Small ornaments become a colour spot or vanish. Exaggerate what is iconic (hat,
weapon, hair, cape): at 64 px, exaggeration is fidelity. The head is never a detail to drop: with stylized
proportions it is about a fifth of the sprite. `head` says what the splash's hair and face are, in the terms
of the head and hair kits, and how much face the project's style (`face`) shows.

## 3. Palette
`splash_ref/palette.yaml` has colour families with hue-shifted ramps ready (`fam1`, `fam2`...). Copy it to
the project's palettes folder as `<name>.yaml`, **rename** the ramps (skin, cloth, hair, metal...), drop
background or noise families and merge near-identical ones. Adjust with
`spritekiln palette ramp "#hex" --steps 5`. 3–6 materials plus one emissive is ideal. In the spec:
`palette: [gothic, ../../palettes/<name>.yaml]` (gothic brings the `fx_*` ramps and basics).

## 4. Blockout
Start from a template (`humanoid`, or `side_humanoid` for a side view) or a similar spec. Over a base, give
only the keys that change (`bones: {torso_rot: {pos: ...}}`, `ik: {leg_L: {lengths: [...]}}`):
1. **World scale:** total height 1.6–2.0; adjust the pelvis height (`torso_rot.pos`) and the IK lengths.
2. **Big masses:** torso, hips and legs as ellipsoids and cones; the head's size with the `head` bone
   scale (its shape and the hair come in step 5).
3. `pose --dirs all` and `ref compare <spec> <splash> --dir <dir>`.
4. Iterate until the **camera-corrected IoU ≥ 0.65** in the art's direction and no band hint is large.
   Each silhouette is scaled to its own bounding box, so a hat tip, a raised weapon or a flared hem moves
   the whole comparison: when an extremity changes, read the overlay on the sheet, not only the number.
   `ref compare` squashes the splash by cos(pitch) like the game camera sees a front view; against the raw
   splash the IoU tops out near 0.56, so do not chase raw numbers. The hints say at which height the sprite
   is too wide or too narrow: fix the part at that height. Do not chase IoU above ~0.85; the splash has its
   own perspective and pose, and legibility matters more.

## 5. Striking shapes and materials
First the **head and the hair**, as `brief.head` says: fit the `head` kit (`jaw`, `chin`, `width`) and a
hair kit (`hair`, `ponytail`, `bun`) with their params, or model them yourself ([modeling.md](modeling.md),
"Heads, faces and hair"). Look at them with `pose --focus head --dirs all` next to the splash's face.

Then one `must_keep` at a time (horns = `tube`), adding its entry to `review.keep` as you go
([spec.md](SPEC.md): the parts or materials that show the trait, and the directions where it must). A weapon, shield, helmet, hood, hat, cape, belt or pouch
starts from a kit (`spritekiln kits`; `use:` with its params, recoloured through materials); model your own
only when no kit comes close. After each one: `pose --dirs all`. Check the **8 directions**, not only the
art's; invent what the splash does not show, coherently, and record the decision in `brief`.

## 6. Final comparison and review
```
spritekiln ref compare <spec> <splash> --dir <dir>          # -> out/compare_<dir>.png + .json
spritekiln review <spec> --ref <splash> --ref-dir <dir> [--bg <game floor>] [--tint <scene light>]
```
Open the comparison sheet (reference | sprite | silhouette overlay | 8 directions | palettes) and the review
sheet. `ref compare` also says where the sprite's colour departs from the splash's at the same height ("bands
20-30% to 40-50%: render #2a2f3a is much darker than the reference #8a2030"): a coat in the wrong colour, a
sprite far darker than the art. A splash is painted under its own light, so treat these as places to look, not
numbers to match. Then an art-direction pass ([art-direction.md](art-direction.md)); apply the high-priority
fixes.

## 7. Animate
With the model approved, follow [animation.md](animation.md). The personality of the splash (heavy, agile,
arrogant) must show in the idle and in the timing of the attack.

## Pitfalls
- A splash with a dynamic pose (raised leg, raised weapon): compare against a similar animation frame
  (`--anim attack --frame 2`) instead of the rest pose.
- A cropped splash (no feet): the IoU is meaningless; compare only the proportions of the visible part and
  say so.
- A weapon bigger than the body: keep it out of the comparison (note it in the brief) and check margins in
  QA.

## More
Reference files in this folder: [workflow.md](workflow.md), [style.md](style.md), [SPEC.md](SPEC.md), [modeling.md](modeling.md), [animation.md](animation.md), [art-direction.md](art-direction.md), [recipe.md](recipe.md).

© LucasJRamos · MIT · LucasJRamos/spritekiln

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set10

The whole set →
spritekiln spritekiln is a Claude Code rule for building SpriteKiln sprites from YAML specs. It activates on files matching specs/**/*.yaml. CX Codex +1 ★ 177repo stars animator The animator subagent for Claude Code builds and polishes SpriteKiln animations. It handles per-frame timing, anticipation, and overlap checks across eight directional views. CX Codex ★ 177repo stars character-modeler character-modeler is a Claude Code subagent that models SpriteKiln characters, monsters, and props from a brief or splash art. It checks the silhouette from 8 directions. CX Codex ★ 177repo stars pixel-art-director pixel-art-director is a Claude Code subagent that reviews SpriteKiln renders and animations. It evaluates silhouettes, contrast, and faces before asset sign-off without editing project files. CX Codex ★ 177repo stars pxforge-splash-to-model pxforge-splash-to-model is a Claude Code skill that turns splash art into a SpriteKiln YAML model. It runs when you supply a character image to generate a model, sprite or animations. CX Codex +1 ★ 177repo stars spritekiln-animation spritekiln-animation is a Claude Code skill for building and tuning animations from a SpriteKiln spec. It covers small pixel-art characters in eight directions and marks gameplay events. CX Codex +1 ★ 177repo stars pxforge-animation pxforge-animation is a Claude Code skill that builds and tunes 8-directional pixel art animations in SpriteKiln specs. It handles periodic cycles, attack keys, and gameplay sockets. CX Codex +1 ★ 177repo stars spritekiln spritekiln is a Claude Code skill for making and editing animated pixel-art characters, monsters, and props in eight directions. Before the project's first asset, it asks about the art style. CX Codex +1 ★ 177repo stars

Project sponsors

Companies that keep this analytics open