pixel-art-studio
Claude IS the pixel artist — designs and places every pixel directly via Python/Pillow (scripts/pixelstudio.py). No Aseprite, no MCP server. Creates sprites, characters, items, tiles/tilesets, animations (idle/walk/run/attack), applies limited palettes, hue-shifted ramps, dithering, shading, selective outlines, and exports PNG / animated GIF / spritesheet+JSON for game engines. Can also STUDY a pixel-art file the user provides and grow its knowledge base. PREFER THIS SKILL over pixel-art-creator / pixel-art-animator / pixel-art-professional / pixel-art-exporter (those require the aseprite MCP) unless the user explicitly asks for Aseprite. Trigger on pixel art, sprite, sprite sheet, 8-bit, 16-bit, retro game art, tileset, pixel animation, GIF sprite, วาด pixel art, สร้าง sprite, ทำ pixel art, พิกเซล, ตัวละครเกม, ไอคอนเกม, เรียนรู้จากไฟล์ pixel art.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/gamezxz--pixel-art-studio)HTML
<a href="/listings/gamezxz--pixel-art-studio"><img src="/api/listings/gamezxz--pixel-art-studio/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
git clone https://github.com/Gamezxz/pixel-art-studio.git cp -r pixel-art-studio ~/.claude/skills/pixel-art-studio # or <project>/.claude/skills/ pip3 install pillow
Then just ask Claude Code: *"draw a 64x64 dragon boss"*, *"make a 4-frame slime idle animation"*, *"turn this sprite into a Game Boy palette"*.
> Note: SKILL.md examples reference the skill path — adjust the `sys.path.insert` path in the > examples if you install somewhere other than a `.claude/skills/pixel-art-studio` folder.
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 · 133 lines
- ---
- name: pixel-art-studio
- description: Claude IS the pixel artist — designs and places every pixel directly via Python/Pillow (scripts/pixelstudio.py). No Aseprite, no MCP server. Creates sprites, characters, items, tiles/tilesets, animations (idle/walk/run/attack), applies limited palettes, hue-shifted ramps, dithering, shading, selective outlines, and exports PNG / animated GIF / spritesheet+JSON for game engines. Can also STUDY a pixel-art file the user provides and grow its knowledge base. PREFER THIS SKILL over pixel-art-creator / pixel-art-animator / pixel-art-professional / pixel-art-exporter (those require the aseprite MCP) unless the user explicitly asks for Aseprite. Trigger on pixel art, sprite, sprite sheet, 8-bit, 16-bit, retro game art, tileset, pixel animation, GIF sprite, วาด pixel art, สร้าง sprite, ทำ pixel art, พิกเซล, ตัวละครเกม, ไอคอนเกม, เรียนรู้จากไฟล์ pixel art.
- ---
- # Pixel Art Studio
- Self-contained studio: you author a **build script** that draws every pixel with
- `scripts/pixelstudio.py` (Pillow only), render a preview, **look at it with your own
- eyes**, critique, fix, repeat. That see→critique→fix loop is the entire quality engine —
- never skip it. You are the artist; the library is just your hand.
- Requirement: `python3 -c "import PIL"` — if missing, `pip3 install --user pillow`.
- ## The Loop
- 1. **Brief** — decide canvas size, palette (with a hard color budget), style, outline
- rule, light direction. Consult `references/patterns.md` + `references/palettes.md`,
- and check `references/learned/INDEX.md` for a studied style that matches.
- 2. **Build script** — create `pixel-art/<slug>/build.py` in the working directory.
- The script is the artwork's source of truth: it regenerates everything on each run.
- Parametrize shapes (positions, squash, frame offsets) instead of hardcoding every pixel
- twice — animation frames become function calls.
- ```python
- import sys; sys.path.insert(0, "/Users/game/Projects/.claude/skills/pixel-art-studio/scripts")
- from pixelstudio import Sprite, PALETTES, ramp, mix
- BODY = ramp("#38b764", 5) # hue-shifted 5-step ramp from a base color
- s = Sprite(32, 32, palette=BODY + ["#1a1c2c", "#f4f4f4"])
- def draw_slime(squash=0): # parametric → reuse for every frame
- s.ellipse(6, 12 + squash, 25, 27, BODY[0]) # darkest first
- s.ellipse(6, 11 + squash, 24, 26, BODY[2], only="opaque") # restack lighter, shifted to light
- s.outline(BODY[0], where="inside") # selout
- draw_slime()
- s.preview("preview.png", scale=10) # LOOK at this file
- s.stats() # and read these numbers
- ```
- 3. **Run** — `cd pixel-art/<slug> && python3 build.py`
- 4. **LOOK** — Read `preview.png` (plus `s.save_silhouette()` / `s.zoom()` when unsure).
- Critique against the checklist in `references/validations.md`, point by point, honestly.
- 5. **Fix** — edit build.py, rerun. Minimum 2–3 loop passes before showing the user.
- 6. **Deliver** — export master PNG at 1x **and** a display scale (4–8x), GIF/spritesheet
- if animated, then `open` the output files (user preference).
- Work at true pixel size always; scale is an export-time concern and **integer only**.
- ## API — scripts/pixelstudio.py
- Colors everywhere: `"#hex"` | `(r,g,b[,a])` | palette index (int) | `None` = erase.
- Most ops accept `only=` to clip: a color (paint only over that color), `"opaque"`, `"empty"` —
- this is the masking system; the shifted-shape shading recipe in `references/techniques.md` builds on it.
- | Area | Calls |
- |---|---|
- | Canvas | `Sprite(w, h, palette=None, snap=True)` · `s.layer(name)` · `s.frame(i)` · `s.use(frame=, layer=)` |
- | Draw | `px` `line` `rect(fill=)` `circle(cx,cy,r,fill=)` (pixel-perfect) `ellipse` `polygon` `contour` `fill(x,y)` `clear` `get(x,y)` `paste_png` |
- | Pixel-art ops | `outline(c, where="outside"/"inside")` · `mirror_x` `mirror_y` · `shift(dx,dy,wrap=)` · `replace(old,new)` · `dither(box,c1,c2,mix,pattern)` · `gradient_dither(box,colors)` · `noise(box,c,density,seed)` |
- | Color | `ramp(base, steps, hue_shift)` · `mix(c1,c2,t)` · `PALETTES` · `s.set_palette(p, remap=)` · `s.to_palette(p, dither=)` · `s.quantize(n)` |
- | Cleanup (gen/messy art) | `s.harden_alpha(threshold, steps)` · `s.despeckle(min_cluster)` · `s.dedupe_colors(tol)` · `s.dehalo()` · `s.clean(palette=, max_colors=, ...)` · `s.before_after(path)` |
- | Animation | `s.add_frame(copy=True)` · `s.set_duration(ms, frames)` · `s.tag(name, from, to, direction)` · `s.copy_cel(layer, from_frame, to_frames, link=)` · `s.del_frame` |
- | Inspect | `s.preview(path, scale, grid=, labels=)` · `s.zoom(path, x0,y0,x1,y1)` · `s.save_silhouette(path)` · `s.stats()` · `s.save_swatch(path)` · `s.used_colors()` |
- | Export | `s.save_png(path, frame, scale, bg)` · `s.save_gif(path, scale, tag, bg)` · `s.save_spritesheet(path, layout, scale, padding)` (+engine JSON) · `s.save_project` / `Sprite.load_project` / `Sprite.from_png(path, scale="auto", strip_bg=)` |
- ## Knowledge routing
- | Task | Read |
- |---|---|
- | Any new artwork (sizes, chibi/heroic/tall-tactical proportions, silhouette-first order, tiles) | `references/patterns.md` |
- | Color ramps, shading, dithering, AA, outlines, textures | `references/techniques.md` |
- | Animation (frame counts, timing, puppeting, oversized attack cells, stable pivots) | `references/animation.md` |
- | **Humanoid characters (2 arms + 2 legs) — full movement set** (walk/slash/thrust/spellcast/shoot/hurt) | `references/lpc.md` + `scripts/lpc.py` — assemble frames onto the LPC universal sheet (engine-ready layout) |
- | Palette choice, budgets, presets, learned palettes | `references/palettes.md` |
- | Export formats, engines (Unity/Godot/Phaser) | `references/export.md` |
- | Cleaning AI-generated / messy art, palette-locking, the hybrid pipeline | `references/cleanup.md` |
- | Known failure modes — read before finalizing | `references/sharp_edges.md` |
- | Per-iteration critique checklist | `references/validations.md` |
- | Studied styles from user-provided art | `references/learned/INDEX.md` |
- ## Learning from user-provided art
- When the user sends a pixel-art file to learn from (เรียนรู้/ศึกษาไฟล์นี้):
- **Persistence rule:** learning changes the skill project itself. Resolve `<skill>` to the
- directory containing this `SKILL.md` and write durable knowledge only inside that directory.
- The caller's working directory, `./pixel-art/`, clipboard paths, and `<file>_study/` are source
- or temporary analysis locations; they are not the knowledge base. Never leave a completed
- study only in those locations.
- 1. `python3 <skill>/scripts/study.py <file> [--save-palette <name>]`
- → emits `<file>_study/` with `zoom.png`, `swatch.png`, `silhouette.png`, `report.json`.
- 2. **Read zoom.png and swatch.png** — the report gives numbers (true size, palette, ramps,
- dither %, outline darkness); your eyes extract the *techniques*: cluster shapes, AA
- placement, where dither sits, how ramps map onto forms, outline behavior on the light side.
- 3. Write a study card `<skill>/references/learned/NNN-<slug>.md` from
- `<skill>/references/learned/TEMPLATE.md`
- — record pixel-level observations and **imperative rules**, not vibes.
- 4. Add one line to `<skill>/references/learned/INDEX.md` in the same change.
- 5. If the lesson generalizes beyond one visual style (animation, export, validation, cleanup,
- etc.), also update the relevant `<skill>/references/*.md` rule file and Knowledge routing.
- 6. `--save-palette <name>` makes the palette available forever as `Sprite(palette="<name>")`;
- verify that the saved palette data is also under `<skill>`, not beside the input file.
- 7. Before finishing, verify every newly learned durable file resolves under `<skill>`.
- When later creating art in a studied style: open the matching card and follow its rules.
- ## Hybrid pipeline — from generated/messy art (the "B" path)
- When the user wants pixel art from an **image model** (codex-imagegen, SD+LoRA, FLUX, PixelLab
- export, a screenshot, or any messy PNG), this skill is the deterministic cleanup + lock + animate
- layer. Use `references/cleanup.md` for the full playbook. One command does the whole import→clean:
- ```bash
- python3 <skill>/scripts/pixelpipe.py <gen.png> --strip-checker --max-colors 24 --display 6
- # lock to a shared game palette for cross-asset consistency:
- python3 <skill>/scripts/pixelpipe.py <gen.png> --palette my_game
- # learn the style while cleaning:
- python3 <skill>/scripts/pixelpipe.py <gen.png> --strip-checker --study knight_style
- ```
- It recovers the true grid (block-sampling for sloppy upscales), strips baked-in checkerboards,
- hardens alpha, despeckles, dedupes colors, locks the palette, and emits `clean.png` + a
- regenerable `build.py` you keep editing. After cleaning, switch back to the normal Loop
- (edit/animate/palette-swap deterministically) — that's where the skill beats the generator.
- ## Conventions
- - Artworks live in `./pixel-art/<slug>/` (build.py + all outputs together).
- - Never hand-edit exported PNGs — edit build.py and rerun.
- - Randomness only via `noise(seed=)` — renders must be deterministic.
- - Deliverables get `open`ed when done; report includes the 1x master path.
README.md · README · 177 lines
- # 🎨 Pixel Art Studio
- **An Agent Skill that makes Claude a pixel artist — no Aseprite, no MCP server, no image generator.**
- Claude designs and places every pixel directly through Python/Pillow, looks at its own render,
- critiques it against a professional checklist, and iterates until it ships.
- <p align="center">
- <img src="docs/assets/capy_walk_down.gif" height="150" alt="capybara walk down">
- <img src="docs/assets/capy_walk_right.gif" height="150" alt="capybara walk right">
- <img src="docs/assets/slime.gif" height="150" alt="slime idle animation">
- </p>
- *Everything above was drawn pixel-by-pixel by Claude using this skill — characters, shading,
- animation and exports, from a text prompt (and one reference image it studied first).*
- ## Why
- Most "AI pixel art" is diffusion output that ignores the grid. This skill takes the opposite path:
- the LLM is the artist and a tiny deterministic library is its hand. Every color is a decision,
- every pixel is placed on purpose, and the render is reproducible from a build script.
- The quality engine is a **see → critique → fix loop**: Claude renders a contact-sheet preview,
- reads the image with its own vision, critiques it against `references/validations.md`, edits
- the build script, and re-renders — minimum 2–3 passes before delivering.
- ### Two ways to use it
- 1. **Draw from scratch** — Claude authors every pixel via Pillow. No model, fully deterministic,
- infinitely editable. Best for characters, items, tiles, animations you control end-to-end.
- 2. **Hybrid with any generator** — feed a messy/AI-generated PNG through `pixelpipe` and it
- recovers the true grid, strips baked-in backgrounds, hardens alpha, kills orphan noise,
- collapses the color explosion, and **locks the result onto a shared palette** — then hands you
- a build script to keep editing and animating deterministically. Best for richly-detailed art
- where a model's composition shines but you still need clean, consistent, editable pixels.
- ## Install
- ```bash
- git clone https://github.com/Gamezxz/pixel-art-studio.git
- cp -r pixel-art-studio ~/.claude/skills/pixel-art-studio # or <project>/.claude/skills/
- pip3 install pillow
- ```
- Then just ask Claude Code: *"draw a 64x64 dragon boss"*, *"make a 4-frame slime idle animation"*,
- *"turn this sprite into a Game Boy palette"*.
- > Note: SKILL.md examples reference the skill path — adjust the `sys.path.insert` path in the
- > examples if you install somewhere other than a `.claude/skills/pixel-art-studio` folder.
- ## What's inside
- | Piece | What it does |
- |---|---|
- | `scripts/pixelstudio.py` | The drawing engine: frames × layers, pixel-perfect primitives, palette locking, hue-shifted `ramp()`, Bayer dithering, selective outlines, mirror/shift, exports PNG / animated GIF / spritesheet + Aseprite-compatible JSON |
- | `scripts/study.py` | Analyzes any pixel-art file: recovers true resolution from (even sloppy) upscales, strips baked-in checker backgrounds, extracts palettes/ramps/outline/dither stats |
- | `scripts/pixelpipe.py` | **Hybrid pipeline**: turns AI-generated / messy PNGs into clean, palette-locked, editable pixel art — the deterministic cleanup+lock layer on top of any image model |
- | `references/*.md` | The knowledge: proportions & silhouette-first workflow, color/shading/dithering/AA techniques, animation timing tables, palette presets (Game Boy, PICO-8, Sweetie16, C64, Endesga32), export/engine guides, failure modes, and the per-iteration critique checklist |
- | `references/learned/` | The skill grows: study a reference image → write a style card → its rules and palette become available for future artwork |
- | `examples/slime-build.py` | A complete worked example: parametric character, 4-frame idle animation, all export paths |
- | `examples/capybara-4dir.py` | 4-direction character (down/left/right/up) with a 4-frame walk cycle per direction — one parametric draw function per view, spritesheet + engine JSON + per-direction GIFs |
- | `examples/anime-cast.py` | Ten diverse characters in one script — ghost, mushroom, robot, cat mage, skeleton, flame spirit, frog, penguin, bee, moss golem — each a ~20-line function with its own palette and 3-frame idle loop |
- | `scripts/lpc.py` + `references/lpc.md` | **LPC universal sheet contract** for humanoids (2 arms, 2 legs): assembles frames onto the [Liberated Pixel Cup](https://liberatedpixelcup.github.io/Universal-LPC-Spritesheet-Character-Generator/) 64×64 grid (walk/slash/thrust/spellcast/shoot/hurt rows) so output drops into any LPC-aware engine template — only the layout is borrowed, every pixel is original |
- ### LPC-compatible humanoids
- <p align="center">
- <img src="docs/assets/catmage_walk_down.gif" height="110" alt="cat mage walk down">
- <img src="docs/assets/catmage_slash_right.gif" height="110" alt="cat mage slash right">
- <img src="docs/assets/knight_walk_right.gif" height="110" alt="knight walk right">
- <img src="docs/assets/knight_slash_down.gif" height="110" alt="knight spear thrust">
- </p>
- *Cat mage and spear knight, each with idle + 8-frame walk and 6-frame slash × 4 directions,
- on one 832×1344 sheet + engine JSON. Poses are authored once in a small coordinate space and
- drawn through a margin-canvas translator (`references/lpc.md`) so a long weapon never clips
- mid-swing.*
- ### Learned tactical-chibi construction
- <p align="center">
- <img src="docs/assets/tactical_oracle_idle.gif" height="220" alt="original tactical chibi oracle idle">
- </p>
- *The original Verdant Oracle applies a studied tactical-chibi design card: layered cloth,
- selective warm trim, 3/4 depth through overlap/value/scale, and explicit anatomy validation so
- the far eye and arm remain readable instead of accidentally disappearing. Regenerate it with
- `python3 examples/tactical-verdant-oracle.py`.*
- ### Tall tactical proportions + dynamic attacks
- <p align="center">
- <img src="docs/assets/tall_iron_man_repulsor.gif" height="240" alt="Iron Man fan-art repulsor animation in tall tactical pixel style">
- </p>
- *A fan-art test of the 48–64px `tall tactical` preset: 4–5-head anatomy, filled segmented
- arm armor, matching red/gold boots, stable ground pivot, and an oversized 120×72 attack cell
- computed from the full repulsor-beam silhouette. Regenerate with
- `python3 examples/tall-iron-man-repulsor.py`.*
- ### The cast
- <p align="center">
- <img src="docs/assets/cast_ghost.gif" height="80" alt="ghost">
- <img src="docs/assets/cast_mushroom.gif" height="80" alt="mushroom">
- <img src="docs/assets/cast_robot.gif" height="80" alt="robot">
- <img src="docs/assets/cast_catmage.gif" height="80" alt="cat mage">
- <img src="docs/assets/cast_skeleton.gif" height="80" alt="skeleton">
- <img src="docs/assets/cast_flame.gif" height="80" alt="flame spirit">
- <img src="docs/assets/cast_frog.gif" height="80" alt="frog">
- <img src="docs/assets/cast_penguin.gif" height="80" alt="penguin">
- <img src="docs/assets/cast_bee.gif" height="80" alt="bee">
- <img src="docs/assets/cast_golem.gif" height="80" alt="moss golem">
- </p>
- ### 4-direction walk example
- <p align="center">
- <img src="docs/assets/capy_walk_down.gif" height="120" alt="capybara walk down">
- <img src="docs/assets/capy_walk_left.gif" height="120" alt="capybara walk left">
- <img src="docs/assets/capy_walk_right.gif" height="120" alt="capybara walk right">
- <img src="docs/assets/capy_walk_up.gif" height="120" alt="capybara walk up">
- </p>
- *A chibi capybara (sprout + scarf, from a reference photo the skill studied) — 32×32/frame,
- 12 colors, contact-passing walk construction. Regenerate everything with
- `python3 examples/capybara-4dir.py`.*
- ## The workflow
- ```python
- from pixelstudio import Sprite, ramp
- BODY = ramp("#38b764", 5) # hue-shifted 5-step ramp
- s = Sprite(32, 32, palette=BODY + ["#1a1c2c"])
- s.ellipse(6, 12, 25, 27, BODY[0]) # darkest = silhouette
- s.ellipse(5, 11, 23, 26, BODY[2], only="opaque") # restack lighter, shifted to light
- s.outline(BODY[0], where="inside") # selective outline
- s.preview("preview.png", scale=10) # Claude LOOKS at this
- s.stats() # ...and reads these numbers
- s.save_gif("out.gif", scale=6)
- ```
- The build script *is* the artwork — deterministic, diffable, re-renderable.
- Animation frames are function calls with parameters (squash, bob, pose), not hand-copied pixels.
- ## Learning from reference art
- ```bash
- python3 scripts/study.py reference.png --save-palette my_style
- # handles resampled upscales & baked-in checkerboards:
- python3 scripts/study.py sloppy_screenshot.png --scale 6 --strip-checker
- ```
- Claude inspects the analysis, writes an imperative style card into `references/learned/`,
- and applies those rules the next time you ask for art in that style. The capybara above was
- drawn this way — its chibi proportions follow a style card learned off a single reference image.
- ## Hybrid pipeline — clean & lock generated art
- ```bash
- # any image model's output → clean, palette-locked, editable pixel art
- python3 scripts/pixelpipe.py generated.png --strip-checker --max-colors 24
- # lock every asset onto one shared game palette (cross-asset consistency):
- python3 scripts/pixelpipe.py generated.png --palette my_game
- ```
- `pixelpipe` recovers the true pixel grid (block-sampling survives sloppy/resampled upscales —
- no mixels), strips baked-in checkerboards, hardens alpha, despeckles, dedupes colors, and locks
- the palette. It emits a `clean.png` **plus a regenerable `build.py`**, so the "AI-assisted"
- sprite is now as editable as one drawn from scratch — and every asset shares one color
- vocabulary, so a whole cast looks like one game. See `references/cleanup.md`.
- ## License
- MIT © [Gamezxz](https://github.com/Gamezxz)
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.