Create a new pixel-art document and make it active. Every other tool works on this file. Coordinates are 0-based with the origin at the TOP-LEFT, x growing right and y growing down. Choose a small canvas: 16-32 px for characters and items, 64-128 px for scenes. Set frames up front when planning an animation.

Point the server at an existing .aseprite file (absolute path, or a path inside the art folder) and make it active. Use this to continue work on a file, or to work on art the user already has.

Report a document's size, colour mode, layer list, frame list (with durations) and tags. Call this when you need to re-orient before editing, or to confirm a change landed.

Add a layer. Good practice for pixel art: separate layers for outline, base colour blocks, shading and highlights, so you can revise one without touching the others.

Change a layer's opacity, visibility, blend mode, or rename it.

Delete a layer and everything drawn on it.

Merge a layer into the one beneath it. Use at the end of a piece, or to flatten shading into a base layer.

Insert empty frames. Frame indices are 0-based. Use mode to control where they land relative to an existing frame. Frames start empty, so draw into each one afterwards (aseprite_draw accepts a frame argument).

Delete a frame. Refuses to remove the last remaining frame.

Set frame durations in milliseconds. Applies to a range when from/to are given, otherwise to every frame. 100 ms = 10 fps is a good default; 40-80 ms suits fast actions like a run cycle.

Copy a frame (all layers) to the next slot. The fastest way to build an animation: duplicate, then move or redraw only the parts that change.

Reorder the timeline by moving one frame to another position.

Copy one layer's artwork from one frame to another (a cel = one layer on one frame). Useful for holding poses, or stamping a base drawing across a new animation.

Create or update a named animation tag spanning a frame range (e.g. "walk" frames 0-5). Tags are what game engines export as separate animations, and users can play them in the Aseprite timeline.

Delete an animation tag by name.

Restrict playback/export looping to a frame range of the whole sprite.

Replace the document palette with an explicit colour list. In indexed mode this is the actual set of colours the artwork can use - which is how you keep a piece to a tight, coherent palette.

Apply a well-known retro palette by name, or load one from a .gpl/.ase file. Great starting point for a coherent piece. Presets: pico8, gameboy, nes, db16, db32, sweetie16, endesga32.

List the document's current palette as hex colours.

Reduce the artwork to N colours (k-means) and snap every pixel to the result. Use this to tame a messy palette or to hit a retro constraint like 16 colours.

Change the canvas size without scaling the artwork. Use it to add room for an attack animation or breathing space around a character.

Crop every frame to a rectangle. Use to trim dead space around the artwork.

Scale the whole sprite (all frames and layers). Use integer factors like 2 or 4 for pixel-art upscaling; non-integer scaling blurs pixels unless Aseprite is set to nearest neighbour.

Flatten all visible layers into one. Do this last, once the composition is settled.

Flip, rotate by 90/180/270, or add a 1 px outline to the artwork. Outlines are the classic way to make sprite art read clearly against any background.

Replace every pixel of one colour with another across the whole document. Handy for recolouring a character, or swapping a shade across all frames at once.

Erase a rectangular region (make it transparent) on a layer, across frames.

Draw a rectangular block of pixels - the main tool for putting actual artwork into a sprite. The origin is the top-left of the canvas; x grows right, y grows down.

Two ways to pass data:

1. pixels: array of rows, each row an array of hex colours. null or "." leaves the pixel transparent.

2. rows + key: rows given as compact strings where each character is looked up in key. Much shorter for larger art - for example rows: ["kksskk","kssssk"] with key: {"k":"#1a1c2c","s":"#ffcd75"}.

All rows must be the same length. Drawing only touches the pixels you supply; everything else on the canvas is left alone. To keep revisions cheap, send one small block per part (outline, fill, shading) rather than repainting the whole sprite.

Paint a set of individual pixels, each with its own colour, on one layer. Unlike aseprite_pixels this does not need a rectangular block, so it suits touching up scattered details, adding a highlight, or fixing stray pixels.

Draw a whole animation in one call: pass one character grid per frame and the tool writes each grid into its own frame. This is the fastest, most token-efficient way to produce a multi-frame animation. Grids are applied on a single layer; use x/y to offset them.

Draw geometric primitives. Pass ops: an array of drawing operations applied in order, all in one call. Coordinates are 0-based from the top-left.

Operations: {op:"pixel", x, y, color} one pixel {op:"line", x1, y1, x2, y2, color} Bresenham line {op:"rect", x, y, w, h, color, filled:false} rectangle (w/h in pixels) {op:"ellipse", cx, cy, rx, ry, color, filled:false} ellipse; rx=ry for a circle {op:"polygon", points:[[x,y],...], color, filled:false} {op:"spline", points:[[x,y],...], color} smooth Catmull-Rom curve (good for tails, hair, limbs) {op:"fill", x, y, color, tolerance:0} flood fill from a seed pixel {op:"clear", x, y, w, h} make a region transparent {op:"gradient", x, y, w, h, from, to, bands:8, direction:"vertical"} banded ramp (classic pixel-art shading) {op:"dither", x, y, w, h, colors:[a,b], matrix:"bayer4", ratio:0.5} ordered dithering {op:"pattern", x, y, w, h, tile:[["#111","."],["#222","#333"]]} repeating 2-D tile {op:"text", text:"Hi", x, y, color, scale:1} built-in 5x7 pixel font

Each op may override layer and frame. Colors accept "#rrggbb", "#rrggbbaa" or a name.

Apply the same set of drawing operations to several frames, optionally shifting them per frame. This is how you animate motion efficiently: describe the moving part once and give each frame an offset.

With no frames argument the ops are drawn on every frame. Pass frames as an array of indices, or of objects like {index:2, dx:3, dy:-1} to move the drawing by (dx, dy) on that frame.

Draw text with the built-in 5x7 pixel font. Suitable for labels, UI mockups and small titles. Non-ASCII characters render as "?". Use scale 2 or 3 for larger text that stays crisp.

Render a frame to a PNG image so you can actually LOOK at the artwork and judge it. Use this after drawing, and before telling the user the piece is finished. Set includeAscii: true to also get an exact character map of the pixels, which is the most precise way to verify positions and colours.

Render a frame with the previous frame ghosted red and the next frame ghosted cyan. This is how animators check that motion reads correctly between frames - use it to verify the arc of a swing, a walk, or a bounce.

Read the final composited colour at a single pixel. Returns hex plus RGBA.

Dump a frame as text rows, one character per pixel, with a palette legend. Cheaper and more precise than an image when you only need to verify exact pixel positions or check a symmetric arrangement. "." is transparent.

Export the sprite as a flat PNG. By default every visible layer is composited and the first frame is written. Pass frame for a specific frame, or scale to upscale (integer scales keep pixels crisp).

Export the animation as an animated GIF, using each frame's own duration. This is the quickest way to show the user a moving preview of what you animated.

Export every frame as its own numbered PNG (hero_000.png, hero_001.png, ...). Use this when an engine or artist wants individual frames rather than a packed sheet.

Export a sprite sheet PNG plus optional JSON metadata - the standard way to hand pixel-art animations to a game engine. Use tag to export a single animation, sheetType to choose the layout, and padding options to avoid bleeding between tiles when the sheet is scaled.

Bring an external image into the pipeline. With asNewSprite it becomes a new document (useful for tracing over a reference, or for slicing an existing sprite sheet by hand). Otherwise it is drawn onto a layer of the active document at (x, y) - handy for stamping a palette reference, a logo, or a texture into a piece.

Report the Aseprite installation the server found, the workspace folders it uses, and the active document. Call this first if a tool fails, or to learn where files are being written.