pixscii
pixscii is an MCP server for generating, editing, composing, and animating pixel art and scenes.
Search and fetch bundled sprites as PNGs.
Generate deterministic procedural characters from seeds with configurable species, armor, weapon, helm, skin, and palette.
Convert images (URL or base64) into palette-quantized pixel art.
Create canvases and draw pixels, lines, rectangles, fills, and mirrors; inspect hex grids and undo.
Compose layers, build tilemaps, stitch spritesheets, and export scaled PNGs.
Animate sprites/characters with idle, walk, attack, hurt, bounce, or blink motions.
Animate multi-actor scenes along paths, with optional tile/sprite/color backgrounds, returning frame PNGs.
Use high-level one-call scene animation or lower-level canvas editing for precise control.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@pixscii animate a scene with a hero walking across grass and stone tiles"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
pixscii
LLMs can't draw. This MCP can. A pixel art animation toolkit for AI agents.
Sister project of artscii. While artscii provides terminal ASCII art, pixscii gives AI agents a full pixel art workbench — generate characters, animate scenes, draw sprites, and export PNGs. Offline, deterministic, zero latency.
One Call Animation
animate_scene {
"width": 128, "height": 48,
"background": { "tiles": [["tree","grass","grass","sand","stone","wall","wall","door"]] },
"actors": [
{ "seed": "hero", "species": "human", "armor": "plate", "weapon": "sword",
"motion": "walk", "from": {"x":0,"y":28}, "to": {"x":96,"y":28} },
{ "seed": "mage", "species": "elf", "armor": "cloth", "weapon": "staff",
"motion": "walk", "from": {"x":-16,"y":30}, "to": {"x":72,"y":30} },
{ "seed": "guard", "species": "skeleton", "motion": "idle",
"from": {"x":108,"y":28}, "to": {"x":108,"y":28} }
],
"frames": 24, "delay": 150
}One tool call. 3 characters, tiled background, 24 frames. 9ms.
The LLM translates a scene description into structured input. pixscii executes it instantly.
Related MCP server: Aseprite MCP
Quick Start
npx pixsciiOr add to your MCP client config:
{
"mcpServers": {
"pixscii": {
"command": "npx",
"args": ["-y", "pixscii"]
}
}
}Tools (25)
High-Level — Full scenes in one call
Tool | Description |
| Text description → animated scene with characters, background, and motion |
Source — Create or load a canvas
Tool | Description |
| New blank canvas with optional fill color |
| Load a bundled sprite into an editable canvas |
| Generate a procedural pixel character |
| Quantize any image (URL or base64) to pixel art |
| Browse the sprite library |
| Endless symmetric robots, aliens and critters from a mask and a seed, or an asymmetric nebula |
| A 24×24 person, cat or elf as a baby, an adult or old |
| Generate a landscape from a seed: sky by time of day, sun or moon, stars, clouds, mountains, hills, sea, forest, ground, rain |
Mutate — Draw on a canvas
Tool | Description |
| Set individual pixels (batch up to 512) |
| Bresenham line between two points |
| Rectangle — outline or filled |
| Flood fill from a point (with leak detection) |
| Mirror left half to right half |
| Draw geometry as crisp pixel art: rect, circle, ellipse, polygon, line, curve, with dithered fills and gradients |
| Revert the last drawing operation |
Observe — Read the canvas state
Tool | Description |
| View the canvas as a hex character grid |
Compose & Output
Tool | Description |
| Animate actors across a scene with per-frame positions |
| Layer multiple canvases/sprites into a scene |
| Build a map from a tile grid |
| Stitch frames into a single PNG (horizontal/vertical/grid) |
| Animate a sprite with pixel motion (idle, walk, attack...) |
| Render a canvas to scaled PNG |
Palette — Recolor by mood
Tool | Description |
| List palettes and their named slots (filter by schema) |
| Switch a canvas to another palette: same schema keeps pixels, others map by slot name or nearest color |
Shapes: Write Geometry, Get Pixels
LLMs can't place pixels well, but they write coordinates fine. shapes rasterizes geometry at pixel centers with no anti-aliasing, so every pixel is one palette index. Soft fills come from ordered dithering:
shapes {
"width": 128, "height": 72, "palette": "scene-dusk",
"shapes": [
{ "type": "rect", "x": 0, "y": 0, "w": 128, "h": 46, "fill": { "gradient": ["sky-top", "sky-mid", "sky-low"] } },
{ "type": "circle", "cx": 92, "cy": 40, "r": 9, "fill": "sun" },
{ "type": "polygon", "points": [[0,46],[22,26],[40,38],[62,20],[90,42],[128,40],[128,48],[0,48]], "fill": "far" },
{ "type": "rect", "x": 0, "y": 46, "w": 128, "h": 26, "fill": { "gradient": ["water", "near"] } },
{ "type": "curve", "points": [[34,56],[44,44],[56,56]], "color": "accent" }
]
}Then repalette to scene-sea or scene-night for the same picture in another mood. In code: drawShapes(sprite, shapes, palette).
Landscapes from a Seed
landscape builds a whole scene from a seed in the scene schema, so one seed is one place you can show in any mood:
landscape { "seed": "harbor-town", "preset": "dusk" }
landscape { "seed": "harbor-town", "preset": "dusk", "palette": "scene-night" }
landscape { "seed": "pine-ridge", "time": "dawn", "layers": ["sky", "sun", "mountains", "forest", "ground"] }Presets match the scene palettes: dawn, home, school, night, sea, storm, window, forest, dusk, stars. Layers: sky (dithered gradient), stars, sun or moon (with a halo, and glitter on water), clouds, mountains (midpoint-displacement ridge), hills (value noise), sea (waves), forest (pines and round trees), ground, rain. Default size 128×72. In code: landscape({ seed, preset }).
Creatures and Beings
creature mirrors a mask filled by the seed (body, maybe-body, empty), drops stray pixels, outlines it, lights it from the top and gives it eyes. Kinds: robot, alien, critter, plus nebula (asymmetric noise cloud with caught stars). being draws a person, cat or elf at a life stage from shapes: babies have big heads and no legs, old people white hair and a cane, old elves a staff, old cats a rounder body and a lowered tail.
creature { "seed": "voyager-7", "kind": "robot" }
being { "species": "elf", "stage": "old", "palette": "scene-forest" }Both use the scene schema, so they sit on a landscape in the same palette.
Three Layers of Control
Layer 1: animate_scene → full scene in one call (fast path)
Layer 2: sequence/compose → manual frame composition (precise control)
Layer 3: pixel/line/rect → individual pixel editing (full control)Start with animate_scene for a fast draft. Drop to lower layers to refine.
Example: One-Call Scene Animation
→ animate_scene {
width: 80, height: 40,
background: { tiles: [["grass","grass","stone","wall","door","wall"]] },
actors: [{
seed: "hero-girl", species: "human", armor: "cloth",
motion: "walk", from: {x:0, y:24}, to: {x:60, y:24}
}],
frames: 16, delay: 120
}
← 16 frame PNGs + frame_ids
→ spritesheet { frames: [frame_ids], direction: "horizontal" }
← single strip PNG with all 16 framesTwo calls: one to generate, one to assemble. Done.
Example: Drawing a Sprite from Scratch
→ create { width: 16, height: 16, fill: "." }
← canvas_id + hex grid
→ rect { canvas_id, x: 3, y: 5, w: 10, h: 9, color: "1" }
→ fill { canvas_id, x: 7, y: 7, color: "8" }
← filled: 56 pixels, leaked: false (grid returned — agent verifies)
→ inspect { canvas_id }
← agent reads grid, spots issue, fixes with pixel tool
→ export { canvas_id, scale: 4 }
← 64x64 PNGThe Hex Grid Protocol
Every pixel is one character. The agent reads and writes in the same alphabet:
0-F = PICO-8 palette colors (0=black, 7=white, 8=red, ...)
. = transparent 0123456789ABCDEF
0: ................
1: .....111111.....
2: .....177771.....
3: .....177771.....
4: ...1111111111...
5: ...1888888881...
6: ...1788888881...~80 tokens for a full 16x16 sprite. The LLM reads this like source code and reasons about it spatially.
Bundled Assets
22 sprites across 4 categories:
Items: sword, shield, potion, key, bow, coin
Tiles: grass, stone, water, wall, door, tree, sand, dirt
Effects: slash, sparkle, explosion, heal
UI: heart-full, heart-empty, arrow-up, cursor
648 procedural characters: 4 species (human, elf, dwarf, skeleton) x 3 armors x 3 weapons x 3 helms x 6 skin tones.
13 palettes: pico8 (default), grayscale, gameboy, and 10 scene moods (scene-dawn, home, school, night, sea, storm, window, forest, dusk, stars)
The scene palettes share one schema: the same 16 named slots (ink, sky-top, sky-mid, sky-low, sun, cloud, far, mid, near, ground, water, foam, accent, skin, cloth, light). Draw once with those slots, then render with any scene palette to get the same picture in another mood. In code: SCENE.ground, slotIndex(palette, 'water'), remapPalette(sprite, from, to).
6 motion types: idle, walk, attack, hurt, bounce, blink
CLI
npx pixscii import sprite.png --id my-sword --category items
npx pixscii export sword --scale 4 --out sword.pngUse in the Browser: pixscii/core
Everything that draws, composes and renders also runs without Node. pixscii/core has no Node built-ins, no sharp and no MCP:
import { createEmpty, drawRect, registerPalette, getPalette, renderToRGBA } from 'pixscii/core';
registerPalette({
id: 'dusk',
name: 'Dusk',
colors: [
{ index: 0, hex: '#1A1016', name: 'sky' },
{ index: 1, hex: '#E88FB0', name: 'sun' },
{ index: 2, hex: '#3A2433', name: 'ground' },
],
});
let scene = createEmpty(32, 18, 0);
scene = drawRect(scene, 13, 4, 6, 6, 1, true);
scene = drawRect(scene, 0, 12, 32, 6, 2, true);
const { width, height, data } = renderToRGBA(scene, getPalette('dusk'), 8);
canvas.getContext('2d')!.putImageData(new ImageData(new Uint8ClampedArray(data), width, height), 0, 0);Bundled sprites, palettes and characters load through an asset source. In Node the MCP server and CLI use the files in sprites/. Elsewhere, pass anything that can read those files:
import { setAssetSource, loadPalettes } from 'pixscii/core';
setAssetSource({
readJSON: (file) => fetch(`/pixscii/sprites/${file}`).then((r) => r.json()),
list: async (dir) => (dir === 'palettes' ? ['pico8.json', 'gameboy.json', 'grayscale.json'] : []),
});
await loadPalettes();Development
npm install
npm run dev # Start MCP server (stdio)
npm run build # Compile TypeScript
npm test # Run testssrc/core/ pure TypeScript, runs anywhere (exported as pixscii/core)
src/node/ sprites/ on disk, PNG encode and image import (sharp), CLI
src/mcp/ MCP server and toolssrc/core/boundary.test.ts fails if anything in core imports a Node built-in, sharp, MCP or a file outside core.
See ROADMAP.md for where pixscii is going: shapes, procedural landscapes and creatures.
License
MIT
Available Tools
19 toolsanimateB
Animate a sprite or character with pixel motion. Returns multiple PNG frames or a spritesheet.
Inputs: motion (required), id, seed, scale, +1 more.
animate_sceneA
Create a full animated scene in one call. Generate characters, place them on a background, and animate them along paths. Returns multiple PNG frames.
Inputs: width (required), actors (required), height (required), delay, +4 more.
characterA
Generate a procedural pixel character sprite. Same seed always produces the same character. 648 unique combinations.
Inputs: seed (required), helm, skin, armor, +4 more.
composeB
Compose multiple sprites into a single scene. Place sprites at specific x,y positions on a canvas.
Inputs: width (required), height (required), layers (required), scale, +1 more.
convertA
Convert an image (URL or base64) to pixel art by quantizing to a palette. Returns both the PNG and sprite data.
Inputs: source (required), scale, width, height, +1 more.
createA
Create a new blank canvas for drawing. Returns canvas ID and hex grid for inspection.
Inputs: width (required), height (required), fill, palette.
exportA
Export a canvas as a scaled PNG image.
Inputs: canvas_id (required), scale.
fillA
Flood fill from a point on a canvas. Returns the updated grid so you can verify the result.
Inputs: x (required), y (required), color (required), canvas_id (required).
getA
Get a sprite as a PNG image by its ID. Returns a scaled pixel art PNG.
Inputs: id (required), scale, palette.
inspectA
Read the current pixel state of a canvas as a hex character grid. For canvases >32px, provide x,y,w,h to inspect a region.
Inputs: canvas_id (required), h, w, x, +1 more.
lineA
Draw a line between two points on a canvas using Bresenham's algorithm.
Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more.
mirrorA
Mirror a canvas horizontally (left half copied to right half). Returns the updated grid.
Inputs: canvas_id (required), axis_x.
pixelA
Set individual pixels on a canvas. Batch up to 512 pixels per call.
Inputs: pixels (required), canvas_id (required).
rectB
Draw a rectangle on a canvas (outline or filled).
Inputs: h (required), w (required), x (required), y (required), +3 more.
searchA
Search the sprite library by keyword, category, or get a random sprite. Returns a text listing of matching sprites.
Inputs: query, random, category.
sequenceB
Animate actors across a scene. Each actor has a pose cycle and a path of positions. Returns one PNG per frame.
Inputs: width (required), actors (required), height (required), delay, +3 more.
spritesheetA
Stitch multiple canvases into a single PNG spritesheet. Supports horizontal, vertical, or grid layout.
Inputs: frames (required), gap, scale, columns, +2 more.
tilemapB
Build a tilemap from a 2D grid of tile IDs. Each cell becomes a 16x16 tile.
Inputs: grid (required), scale, palette.
undoA
Revert the last drawing operation on a canvas. Single-step undo.
Inputs: canvas_id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Most tools are distinct, but the three animation tools (animate, sequence, animate_scene) have overlapping purposes, making it unclear which to choose for scene-level animation. Other tool boundaries are clear.
All tool names are single lowercase words, providing a consistent style. However, some names like 'get' and 'create' are generic and less self-explanatory, but the overall pattern is uniform.
With 19 tools, the surface is somewhat heavy, but each tool addresses a specific aspect of pixel art creation, composition, and animation. The count is near the upper bound of acceptable for the range of features.
The server covers drawing, editing, library access, composition, export, and animation, providing a comprehensive workflow. Missing features like canvas deletion or rotation are minor and do not block core usage.
Maintenance
Related MCP Connectors
Generate authentic pixel art - sprites, animations, and tilesets - from any MCP client
MCP server for Flux AI image generation
Make animated videos by asking Claude, Cursor or any MCP client. Your AI writes it, we render it.
Generate, edit, style-match, turn, and animate game-ready pixel art at exact sizes.
Related MCP Servers
- AlicenseBqualityDmaintenanceMCP server for Aseprite — create, edit, and export pixel art sprites, animations, and sprite sheets from any AI assistant.438MIT
- AlicenseBqualityBmaintenanceAn MCP server that lets AI agents create and edit Aseprite sprites headlessly, enabling pixel art, animation, and export via 98 tools.15641MIT
- FlicenseAqualityDmaintenanceAn MCP server that enables AI coding agents to create pixel art programmatically by providing canvas manipulation tools and PNG export.1031 npm9-
- AlicenseNot gradedqualityCmaintenanceAn MCP server that lets AI agents draw in a live Aseprite editor or headless mode, featuring one-action Unity sprite-sheet export, art-QA sweeps, and game-dev tools.93 PyPI8MIT