aseprite.org Paid content

Aseprite organizes animation around two parallel structures: layers (what an image is made of) and frames/cels (when each part appears). You manage layers like a stack of transparent sheets, then place cels at the intersection of a layer and a frame to build motion. The site's own feature list confirms you can create, copy, move, and drag-and-drop both layers and frames or cels, tag frame ranges to hold several animations in one file, and preview playback in loop, reverse, or ping-pong modes with onion skin as a drawing reference.

Layers: the vertical structure

A layer is a full-width drawing plane. In a sprite, layers stack top-to-bottom, and each one can hold its own content, opacity, and blend mode.

From the documented feature set, layer operations include:

• Create new layers
• Copy existing layers
• Move layers up or down the stack
• Drag & drop to reorder them

Because layers are independent, a typical pixel-art character might separate the body, clothing, and a weapon onto different layers so each can be edited or hidden without redrawing the rest.

Blend modes and compositing

Aseprite composites layers together, and the site lists blend modes as the mechanism for creating color effects. This means a layer's pixels are not simply pasted on top — they are combined with the layers beneath according to the selected mode. That is what lets you do things like a multiply-style shadow layer or an additive glow without flattening your artwork.

Frames and cels: the horizontal (time) structure

If layers are the vertical axis, frames are the horizontal one. A cel is the content of one layer at one frame — the cell where a layer row meets a frame column.

Documented cel and frame operations:

• Create frames or cels
• Copy them
• Move them along the timeline
• Link cels (so the same drawing is reused across frames instead of duplicated)
• Drag & drop to reposition

Linking matters for efficiency: a static background that never changes can be one linked cel spanning many frames rather than a separate drawing per frame.

Tagging frames to hold multiple animations

Rather than keeping one file per action, Aseprite lets you tag sections of frames. Each tag marks a range of frames as a named animation — for example, a "walk" range and a separate "jump" range inside the same sprite file. This keeps related animations together and gives playback a defined region to work with.

Playback modes and preview

Once frames are tagged, playback can be configured. The documented modes are:

You can also change the preview speed, so timing can be tuned without altering the underlying frame count.

Onion skin as an animation reference

Onion skin shows other frames as a reference while you draw the current one — the standard technique for keeping motion smooth and spacing consistent. Aseprite documents:

• Onion skin to see surrounding frames
• Red/Blue mode as an alternative onion skin display

Red/blue mode distinguishes past and future frames by color, which helps when a pose is ambiguous in a single tint.

How the pieces fit together

A practical workflow implied by these features:

1. Build your character or object across layers (body, details, effects).
2. Add frames and draw the content for each layer at each frame as cels.
3. Link cels that don't change to avoid redundant drawing.
4. Tag frame ranges to name each animation.
5. Set a playback mode and speed, then use onion skin to refine timing.

What this means for your decision

If your work is frame-by-frame pixel animation, this layer-plus-cel model with tagging, linked cels, playback modes, and onion skin covers the core loop of sprite animation. The site also notes related output paths — animated GIF, PNG image sequences, and sprite sheets exported as .png with .json data — so the same file can feed both preview and game-engine pipelines. Aseprite is presented as a paid product with a Buy Now option and a Trial Version, so you can evaluate the animation and layer workflow before purchasing.

Aseprite is an animated sprite editor and pixel art tool. It is built for creating and editing pixel art and frame-by-frame sprite animation, then exporting the result as animated GIFs, sprite sheets, PNG image sequences, or texture atlases. It fits game artists, indie developers, and hobbyist pixel artists who need one program to draw, animate, and package sprites for a game engine or asset pipeline.

What Aseprite is designed for

The core use case is pixel art and sprite animation. Aseprite combines drawing tools with an animation timeline, so you can paint individual frames, arrange them into animations, and preview playback without leaving the program.

Typical tasks include:

• Drawing and editing pixel art sprites and tiles.
• Animating characters, effects, or UI elements frame by frame.
• Organizing complex sprites into layers and cels.
• Exporting finished animations as GIFs or sprite sheets for game engines.

Animation and layer features

Aseprite's animation workflow is organized around layers, frames, and cels (the intersection of a layer and a frame).

• Layers: Create, copy, move, and drag-and-drop layers to separate parts of a sprite.
• Frames and cels: Create, copy, move, link, and drag-and-drop frames or cels.
• Frame tags: Tag sections of the timeline so several animations can live in one file.
• Playback modes: Loop a section forward, in reverse, or ping-pong, and change preview speed.
• Onion skin: See other frames as a reference while animating, with different onion skin modes including a red/blue mode.

This structure matters because it lets you keep a whole character's animation set — idle, walk, attack — in a single file instead of scattering it across many documents.

Drawing and color tools

The painting side is tuned for pixel-level control rather than general illustration.

• Palette control: Copy and paste palette entries, drag and drop, resize the palette, and use entries with an alpha value.
• Color wheel: Select color harmonies when picking colors.
• Shading mode: Create light and shadow with the shading ink.
• Pixel-perfect stroke: Produce clean strokes suited to pixel art.
• RotSprite rotation: Reduce extreme pixel distortion when rotating tiny sprites.
• Tiled mode: Create repeating patterns by tiling the image in a 3x3 grid.
• Custom brushes: Build brushes for dithering and other repeated marks.
• Blend modes: Composite layers to create color effects.

Import and export options

Aseprite is often used as the last step before assets reach a game engine, so export formats matter as much as drawing tools.

There is also a command-line interface (CLI) for automating image conversions, which lets you integrate Aseprite into an asset pipeline rather than exporting by hand. Data recovery is available to recover sprites after a crash.

Who it suits, and what to check first

Aseprite is a good fit if your work is pixel art or frame-based sprite animation and you want drawing, animation, and export in one tool. It is less suited to high-resolution digital painting or vector work, since its tools are aimed at pixel-level control.

Before committing, check two practical points:

• Licensing and price: The site links to a Buy Now page and also offers a Trial Version. Confirm current pricing and license terms on the official buy page rather than assuming.
• Pipeline fit: If you need automated exports, verify the CLI covers your target formats and engine workflow.

You can explore the tool through the trial version first, then decide whether the paid license matches how you work.

Aseprite can open or save a PNG image sequence, create and save animated GIF files, export sprite sheets as .png and .json, and create a texture atlas that stores several animations in one file. These are the formats documented on aseprite.org for moving pixel-art and animation work into game engines, web projects, or an asset pipeline. If your target engine expects a single packed image plus a data file, the sprite sheet and texture atlas paths are the relevant ones; if you need a simple shareable animation, GIF is the direct option.

Import and export formats at a glance

How each format fits a project

PNG image sequence

Aseprite can open or save a sequence of images. This matters when your pipeline already works frame-by-frame — for example, when a build script or engine importer expects frame_0001.png, frame_0002.png, and so on. You are not locked into a packed layout, and each frame stays independently editable outside Aseprite.

Animated GIF

You can create animations and save them as .gif files. This is the simplest way to get a moving result out of Aseprite without a companion data file. The trade-off is that GIF is a display format, not a game-asset format: it does not carry the layer or tag structure your project may need later.

Sprite sheet with JSON

Aseprite exports your work to sprite sheets in .png and .json files. The PNG holds the packed frames; the JSON describes where each frame sits. This pairing is what most 2D engines and web runtimes need to slice a sheet back into individual frames at load time. If your engine asks for "a sheet plus a data file," this is the export to use.

Texture atlas

Aseprite can store several animations in one texture atlas. Instead of one sheet per animation, you consolidate multiple animations into a single atlas — useful when you want fewer texture swaps or a tidier asset bundle. The site lists this as a creation capability, so treat it as the packing step for multi-animation projects rather than a separate file extension.

Choosing between them

• Sharing a quick preview or posting an animation: animated GIF.
• Feeding a 2D engine or web runtime that slices frames: sprite sheet .png + .json.
• Combining many animations into one packed image: texture atlas.
• Working with a frame-by-frame pipeline or external compositing: PNG image sequence.

Related capabilities worth knowing

Aseprite also documents a command-line interface (CLI) for integrating the tool into an assets pipeline and automating image conversions. If you are exporting the same formats repeatedly as part of a build, the CLI is the mechanism the site points to for that automation, rather than doing each export by hand.

Data recovery is also listed, so a crash does not necessarily mean losing the sprite you were working on.

Practical notes

• The site describes these import/export paths but does not publish per-format limitations here, so verify frame counts and sheet dimensions against your target engine's own limits.
• Pricing and licensing are handled separately on the site's Buy page; nothing in the format documentation implies the software is free. A trial version is referenced on the site.

Aseprite provides a focused set of pixel art drawing tools: palette management with copy/paste, drag & drop, and resizing; alpha-aware palette entries; a color wheel for selecting harmonies; a shading ink for light and shadow; Pixel Perfect stroke for clean lines; RotSprite rotation to reduce distortion on tiny sprites; tiled mode for repeating patterns; custom brushes for dithering; and blend modes for compositing layers. These are the drawing-side capabilities listed on aseprite.org, and they matter most if you are producing small sprites, tiles, or frame-by-frame animation where palette control and stroke precision affect the final look.

Palette and color control

Aseprite treats the palette as a working surface rather than a fixed list.

• Copy & paste palette entries.
• Drag & drop colors into place.
• Resize the palette.
• Alpha channel: palette entries can carry an alpha value, so a single swatch can represent partial transparency instead of a fully opaque color.
• Color wheel: select color harmonies from the wheel rather than picking each color by hand.

The practical effect: you can build a limited palette, keep transparency as part of the palette itself, and derive related colors from the wheel instead of guessing hex values.

Stroke and rotation tools

Shading ink

The shading ink is for creating light and shadow. Instead of painting a separate highlight or shadow color manually, you use the shading mode to apply that relationship directly.

Pixel Perfect stroke

Pixel Perfect stroke is designed to create clean strokes for pixel art. It addresses the common problem of a freehand line leaving doubled or "staircase" pixels at corners.

RotSprite rotation

RotSprite rotation avoids extreme pixel distortion when rotating tiny sprites. Rotating a small sprite with ordinary interpolation tends to smear or destroy the pixel grid; RotSprite is the option intended for that case.

Pattern, brush, and compositing tools

Tiled mode is a preview/working aid: you see the image repeated in a 3x3 grid so you can judge whether edges line up. Custom brushes are aimed specifically at dithering, which is otherwise tedious to place pixel by pixel. Blend modes operate at the layer level, so color effects come from how layers combine rather than from painting them in directly.

How these tools fit together

A typical pixel art workflow on this toolset looks like this:

1. Set up a palette, resizing it as needed and using alpha entries where transparency is part of the design.
2. Pick colors from the color wheel, using harmonies to keep the palette coherent.
3. Draw with Pixel Perfect stroke for outlines and the shading ink for light and shadow.
4. Use custom brushes for dithering and tiled mode to verify repeating patterns.
5. Rotate small sprites with RotSprite when a sprite needs to turn.
6. Composite layers with blend modes for color effects.

What to check before choosing it

These are drawing features, not a full list of the application. If your decision depends on animation handling, layer organization, or file import/export, those are separate areas covered elsewhere on the site. The drawing toolset above is the relevant evidence if your question is specifically whether Aseprite can handle palette-driven pixel art, clean strokes, small-sprite rotation, dithering, and layer compositing.

You can get Aseprite directly from its official site, aseprite.org, which offers both a Buy Now purchase option and a Trial Version. From the same site you can reach the documentation, FAQ, tutorials, and community channels including Discord, a Steam community, and the /r/aseprite subreddit. If you want to follow or contribute to development, the GitHub repository, devblog, and roadmap are also linked.

Getting Aseprite

The official site provides two starting points:

• Buy Now — a purchase link at aseprite.org/buy/, also shown in the site header.
• Trial Version — a free trial option listed alongside the purchase entry.

The site also shows a Sign in option in the header, so an account is part of the site experience. The page does not state pricing details, license terms, or whether the trial is time-limited, so check the buy page and trial page directly for current conditions.

Documentation and Learning Resources

If you want to learn the tool or look up a specific feature, these official resources are linked from the site:

• Docs / Quick reference — reference material for features and shortcuts.
• FAQ — answers to common questions.
• Tutorial — guided learning material.
• Blog — news and articles.

These are useful when you hit a specific question, such as how onion skinning works or how to export a sprite sheet, rather than reading everything end to end.

Community and Support

For help from other users or to share work, the site points to:

If something is broken or behaving unexpectedly, check Known Issues before filing a Bug Report — it may already be documented.

Development and Contributing

Aseprite's development is public-facing through several channels:

• GitHub — source and issue tracking.
• Devblog — development updates.
• Roadmap — planned direction.
• Contribute — how to get involved.

These are the right places if you want to follow releases, understand what's coming, or contribute code or feedback rather than just use the tool.

What Aseprite Is, in Short

Aseprite is an animated sprite editor and pixel art tool. Its feature set centers on:

• Animation & Layers — organize, copy, move, and drag-and-drop layers; create, copy, move, and link frames or cels; tag frame sections to hold multiple animations in one file; loop sections forward, reverse, or ping-pong; onion skin with red/blue modes.
• Color & Painting — palette control with alpha values, color wheel harmonies, shading ink, pixel-perfect strokes, RotSprite rotation, tiled mode, custom brushes for dithering, and blend modes.
• Import & Export — PNG image sequences, animated GIF, sprite sheets as .png and .json, texture atlases, data recovery after a crash, and a command-line interface (CLI) for automating conversions in an asset pipeline.

That combination is why it's used for game sprites and pixel art assets where frame-by-frame animation and clean export matter.

A Practical Starting Path

1. Open aseprite.org and choose Buy Now or the Trial Version depending on whether you want to evaluate first.
2. Skim the Quick reference and Docs for the features you'll use most (layers, frames, export).
3. If you get stuck, search the FAQ and Known Issues before posting.
4. Ask in Discord, Steam Community, or /r/aseprite for hands-on help.
5. Follow GitHub, the devblog, or the roadmap if you want to track or contribute to development.

The site footer also links Terms of Service, Privacy, and Support, which are worth checking for account and licensing questions.