This server provides AI assistants with comprehensive programmatic control over Aseprite to create, edit, and export pixel art and animated sprites, offering 104 tools across 17 categories.
Canvas & Layer Management
Create new sprites with custom dimensions
Add, rename, duplicate, reorder, delete, and group layers; set visibility, opacity, and blend modes (19 modes)
Add and navigate frames, set frame durations
Drawing
Plot individual pixels, draw lines, rectangles, circles, ellipses, polygons, and paths
Flood-fill areas and apply linear gradient fills to rectangular regions
Target specific layers/frames, with optional cel creation
Animation
Add, delete, copy, and duplicate frames and frame ranges
Copy and propagate cels across frames and layers
Tween cel positions, opacity, and scale with easing; oscillate positions using sine-wave motion
Create and manage animation tags (forward, reverse, pingpong)
Configure onion skin settings
Palette & Color
Get and set the sprite palette; apply retro presets (Game Boy, PICO-8, C64, etc.)
Generate color ramps with hue shifting, quantize to palette, remap colors
Switch color modes (RGB, grayscale, indexed)
Effects & Transforms
Add outlines, replace colors, adjust HSL, apply ordered dithering
Flip layers horizontally/vertically, rotate (90°/180°/270°), resize, and crop the canvas
Slices & Tilemaps
Create named slice regions with 9-patch centers and pivot points
Create tilemap layers, edit tileset tiles, place tiles on a grid
Export & Import
Export to PNG, GIF, JPG, and sprite sheets (with metadata)
Per-layer/per-tag exports, import images as layers, duplicate sprite files
Inspection & Analysis
Read individual pixel colors or rectangular regions (RGBA/hex)
Get full sprite metadata (size, layers, frames, tags, durations)
Render onion skin ghosts, diff frames, get color histograms
Quality & Scene Tools
Validate scene consistency, audit animations for overlaps and out-of-range activity
Sanitize animation layer order and coverage
Copy layers between different sprite files
Preview, Workflow & Scripting
Start/stop a local HTTP preview server for exported files
Retrieve a step-by-step animation workflow guide for LLMs
Execute arbitrary Lua scripts as an escape hatch for unsupported operations
Provides tools for interacting with the Aseprite API, enabling management of sprites, animations, and layers.
Click on "Install 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., "@Aseprite MCP create a new 256x256 sprite and draw a simple tree"
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.
A Python MCP server that gives AI assistants full control over Aseprite for creating pixel art and animated sprites.
104 tools across 17 categories — canvas, drawing, layers, animation, palettes, effects, slices, tilemaps, exports, visual-feedback/analysis tools, and a raw Lua escape hatch. The tool set is designed so an LLM has everything it needs to produce good pixel art, not just primitives: shading ramps with hue shifting, ordered dithering, outlines, retro palette presets with quantization, onion-skin renders, and frame diffing for animation work.
Both were created end-to-end by Claude Fable 5 through this server's MCP tools — drawing, checking its own work with scaled export_frame previews and render_onion_skin, then exporting. The tasks recreate the benchmark from Draw Me a Swordsman by Lj Miranda, whose findings inspired this server's expanded toolset.
Related MCP server: Aseprite-MCP
Category | Tools | Description |
6 | Create sprites, manage layers/frames, set the active state | |
14 | Pixels, lines, rectangles, circles, ellipses, polygons, paths, fills, gradients | |
3 | Draw and measure text with bitmap sprite-sheet or TrueType fonts | |
7 | Delete, rename, duplicate, reorder, blend modes, merge, flatten | |
4 | Move, copy, and erase rectangular regions or colors | |
5 | Outlines, color replacement, HSL adjustment, ordered dithering | |
24 | Frames, cels, tags, tweening with easing, propagation | |
8 | Get/set palettes, retro presets, color ramps, quantization, color modes | |
4 | Flip, rotate, resize, crop | |
5 | Named regions, 9-patch centers, pivot points | |
5 | Tilemap layers, tileset editing, tile placement | |
7 | PNG, GIF, sprite sheets, per-layer/per-tag export, image import | |
3 | Read pixels and sprite metadata | |
3 | Onion-skin renders, frame diffing, color statistics | |
4 | Validate and sanitize animation consistency | |
1 | Copy layers between sprite files | |
3 | Local HTTP preview server, workflow guide | |
1 | Raw Lua escape hatch for anything not covered above |
Tool | Description |
| Create a new sprite with the given dimensions |
| Add a new layer, optionally inside a named group |
| Add a new (optionally nested) group layer |
| Append a new frame |
| Set the active frame |
| Set one frame's duration in ms |
| Set the active layer (optionally creating it) |
All _at variants target a specific layer/frame and can create the cel on demand. Coordinates are sprite-global.
Tool | Description |
| Plot individual pixels with per-pixel colors |
| Plot pixels on a specific layer/frame |
| Lines with thickness |
| Outlined or filled rectangles |
| Outlined or filled circles |
| Outlined or filled ellipses with separate x/y radii |
| Outlined or filled polygons from a point list |
| Polyline through a point list with thickness |
| Paint-bucket flood fill |
| Smooth linear gradient fill in a rectangle |
Aseprite's Lua API has no text drawing, so glyphs are rasterised on the server and composited into the sprite. Two font backends are supported: bitmap sprite-sheet fonts (the right choice for pixel art — glyphs are already pixels and size scales them by whole numbers) and TrueType .ttf/.otf files, rendered without antialiasing unless you ask for it.
Fonts are discovered in ~/.aseprite-mcp/fonts: a bitmap font is a directory containing font.json plus its sheet PNGs; a TrueType font is just the font file. Installed system fonts are listed too. font also accepts a direct path.
Tool | Description |
| List the bitmap and TrueType fonts available to |
| Width, height, advance and baseline extents — size a panel or centre a label without redrawing to find out |
| Draw text with anchors, faux bold, outline, drop shadow and letter spacing |
Call measure_text first when the layout depends on the text: it returns the same metrics draw_text will use, so a label can be centred or a plate sized in one pass.
measure_text(text="MODERATOR", font="minecraft", size=2, bold=1)
-> width=115 height=15 advance_width=117 above_baseline=14 below_baseline=1 left_bearing=0
draw_text(filename="badge.aseprite", text="MODERATOR", x=64, y=17,
font="minecraft", size=2, anchor="baseline", bold=1,
color="#FFFFFF", shadow_color="#14237A")Anchors are topleft/top/topright, left/center/right, bottomleft/bottom/bottomright, plus baselineleft/baseline/baselineright for pinning several labels to one baseline. Outline and shadow grow the stamp but never move the glyphs.
{
"name": "my-font",
"letter_gap": 1,
"space_width": 3,
"sheets": [{
"file": "sheet.png",
"cell_w": 8, "cell_h": 8,
"ascent": 7,
"chars": [" !\"#$%&'()*+,-./", "0123456789:;<=>?"]
}],
"overrides": {
"86": {"ascent": 7, "rows": ["#...#", "#...#", ".#.#.", "..#.."]}
}
}Each sheet carries its own ascent, so sheets with different cell sizes still share a baseline — that is how a compact ASCII sheet and a taller accented sheet combine into one run. origin shifts the cell grid when the sheet has a margin, ink_rule: "dark" reads sheets that use an opaque white background to delimit variable-width glyph boxes, and advance: "box" takes the advance from the box rather than the ink. overrides replaces individual glyphs with hand-drawn rows, which is useful when a sheet ships a glyph that is off-centre or too tall to sit on the line.
Tool | Description |
| Delete a layer by name |
| Rename a layer |
| Duplicate a layer with all cels, opacity, and blend mode, optionally into a group |
| Move a layer to a position in the stack |
| Set blend mode (multiply, screen, overlay, ... 19 modes) |
| Merge a layer into the one below it |
| Flatten all layers into one |
Tool | Description |
| Cut a rectangle of pixels and paste it elsewhere |
| Copy a rectangle to another position, layer, or frame |
| Make a rectangle transparent |
| Magic-eraser: make all pixels of a color transparent (with tolerance) |
The pixel-art toolbox: clean outlines, palette-respecting blends, and shading variants.
Tool | Description |
| Add a 1px outline around all opaque pixels |
| Replace one color with another (with tolerance), preserving alpha |
| Shift hue/saturation/lightness of a cel — palette swaps, night scenes, shadows |
| Two-color gradient using Bayer 4×4 ordered dithering |
| Uniform dithered mix of two colors at a given density |
Tool | Description |
| Append N frames with optional duration |
| Delete a frame |
| Set every frame's duration |
| Duplicate a frame range N times |
| Copy all cels of a frame to other frames |
| Cel lifecycle on a layer/frame |
| Copy selected layers' cels across a frame range |
| Place a cel at x,y |
| Set a single cel's opacity |
| Shift cels by a delta across frames |
| Linear position tween across frames |
| Position tween with easing (ease_in/out, smoothstep) |
| Opacity tween with easing |
| Scale tween with easing and anchor |
| Sine-wave motion (bobbing, breathing, hovering) |
| Animation tags with direction (forward/reverse/pingpong) |
| Layer-level visibility and opacity |
| Configure onion-skin UI prefs (see |
| Sprite metadata: size, layers, frames, durations, tags |
Tool | Description |
| Read the palette as hex colors |
| Set the palette from a list of hex colors |
| List built-in retro palettes |
| Apply a preset: |
| Build a dark→light shading ramp with hue shifting from a base color |
| Snap every pixel to the nearest palette color |
| Remap specific colors across a frame range |
| Convert between RGB, grayscale, and indexed |
Tool | Description |
| Flip a cel horizontally or vertically |
| Rotate a cel 90/180/270° |
| Scale the sprite to new dimensions |
| Crop to a rectangle |
Tool | Description |
| Create a named rectangular region |
| Set the 9-patch stretchable center |
| Set the pivot point |
| List all slices with bounds, centers, pivots as JSON |
| Delete a slice |
Tool | Description |
| Add a tilemap layer with its own tileset and tile grid |
| Paint pixels into a tileset tile (auto-appends new tiles) |
| Place tiles on the map by grid position |
| Read which tile occupies a grid cell |
| Tile size, tile count, and map dimensions as JSON |
Tool | Description |
| Export to PNG, GIF, JPG, ... |
| Export one frame as PNG with integer upscaling — the core visual-feedback loop: draw, export at 8×, look, iterate |
| Sprite sheet (horizontal/vertical/rows/columns/packed) with optional JSON metadata and per-tag filtering |
| One PNG per layer |
| Export an animation tag as GIF or PNG sequence |
| Import a PNG into a layer (references, premade parts) |
| Duplicate the .aseprite file |
Tool | Description |
| Read one pixel's RGBA |
| Read a rectangle of pixels as JSON |
| Sprite metadata (also listed under Animation) |
Batch-mode equivalents of what a human artist gets from the Aseprite UI.
Tool | Description |
| Render a frame over translucent ghosts of neighboring frames — check motion continuity without opening Aseprite |
| Diff two frames: changed pixel count, percentage, bounding box |
| Color histogram of a frame — catches palette drift and near-duplicate colors |
Tool | Description |
| Create missing cels for layers across a frame range |
| Report missing layers/cels as JSON |
| Audit frames for overlaps and out-of-range layer activity |
| Normalize layer order, coverage, and overlaps |
Tool | Description |
| Copy layers by name from one .aseprite file to another |
Tool | Description |
| Serve exported files over local HTTP |
| Returns a step-by-step workflow guide for the LLM |
Tool | Description |
| Execute arbitrary Aseprite Lua (API docs) in batch mode. The escape hatch when no dedicated tool fits: one script can batch many operations into a single Aseprite launch. Remember to |
Plan the palette first: generate_color_ramp for each material (skin, armor, blade), or apply_palette_preset for a retro look.
Build in layers: background / body / equipment / effects, so parts can be animated and edited independently.
Draw coarse to fine: silhouette with draw_rectangle_at / draw_ellipse_at / fill_area_at, then refine with draw_pixels_at.
Look at your work: export_frame at 8×, inspect, fix, repeat. Use get_color_stats to keep the palette tight.
Shade with intent: adjust_hsl for shadow layers, apply_dither_gradient for blends, outline_cel for readability.
Animate with the cel tools: propagate_cels, then tween_cel_positions_eased / oscillate_cel_positions; verify with render_onion_skin and compare_frames; export with export_tag.
Build and run the Docker image:
docker build -t aseprite-mcp:latest .
docker run -it --rm aseprite-mcp:latestOr use the provided build scripts:
Linux/macOS: chmod +x build-docker.sh && ./build-docker.sh
Windows: .\build-docker.ps1
# Production
docker-compose up aseprite-mcp
# Development mode
docker-compose --profile dev up aseprite-mcp-devSee DOCKER.md for detailed Docker setup instructions.
To have the container install Aseprite via SteamCMD at startup, provide Steam credentials:
# Create a .env with STEAM_USERNAME/STEAM_PASSWORD (and optional STEAM_GUARD_CODE)
# Then
docker run --rm -i --env-file .env aseprite-mcp:latestIf installed, the binary will be at /opt/steamapps/common/Aseprite/aseprite and ASEPRITE_PATH will be picked up automatically.
Python 3.13+
uv package manager
Aseprite (set ASEPRITE_PATH in .env if it is not on your PATH)
{
"mcpServers": {
"aseprite": {
"command": "/opt/homebrew/bin/uv",
"args": [
"--directory",
"/path/to/repo",
"run",
"-m",
"aseprite_mcp"
]
}
}
}Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Generate authentic pixel art - sprites, animations, and tilesets - from any MCP client
Build and run visual creative-production workflows from your AI agent.
Generate game assets with AI: sprites, 3D models, animations, sound effects, music, and voices.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/diivi/aseprite-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server