How to Make Pixel Art (Without Pushing Pixels in Aseprite)

How to make pixel art without pixel-pushing in Aseprite for a week. There are three real paths in 2026: generate pixel art directly from a prompt, convert any high-resolution image to pixel art, or convert a video to a pixel-art animation. Each one solves a different problem. This is the practical guide, including the palette and cleanup tricks that separate decent pixel art from indistinct mush.

Three paths to pixel art in 2026

• Path 1: generate pixel art directly with Quick Sprites (purpose-built model trained on pixel sprites). Best for characters with standard animations.
• Path 2: convert any high-res image to pixel art with True Pixel. Best when you have a character locked in a non-pixel style and want a pixel-art version.
• Path 3: convert a video (or AI-generated animation) into a pixel-art sprite sheet, also via True Pixel. Best for custom animations not in any sprite-library.
• Whichever path you pick, the bottleneck is palette discipline, not generation. Lock a palette early, run all output through it, and your pixel art will look coherent.

The fundamentals: what makes art “pixel art” (not just low-res art)

Pixel art isn’t defined by being small — it’s defined by palette and intent. A 32×32 image with a million colors and gradient blending is just a low-resolution image. Real pixel art has:

• A constrained palette. Typically between 4 and 64 colors. Classic NES palettes use 56 colors total with 4 visible per sprite. Game Boy uses 4 shades of green. Modern indie pixel art often runs 16–32 carefully chosen colors per scene.
• Hard edges, no anti-aliasing. Each pixel is a deliberate decision. No subtle gradients across pixel boundaries.
• Consistent silhouettes that read at the target size. A pixel-art character at 32×32 needs to be recognizable from its silhouette alone — you don’t have detail to spare.
• Transparency where needed. Game-ready pixel art ships on a transparent background. Solid-color backdrops are amateur.

Most beginner attempts at pixel art fail not on the geometry but on the palette. The image has too many subtly different shades, no consistent outline color, and ends up looking like compression artifacts of a real photo rather than deliberate art. Locking the palette is the single most impactful thing you can do.

Path 1: Generate pixel art directly (Quick Sprites)

The fastest path. Quick Sprites runs a model trained specifically on game-ready pixel sprite sheets. Type a prompt, pick an animation style, generate. Output is a transparent PNG at one of three preset sizes (32×32, 48×48, 64×64), already palette-locked, already animation-ready.

This is the right path when:

• You’re starting from scratch and want a pixel-art character right away.
• The animation you need is in the standard menu (four-direction walk, idle, VFX).
• You don’t already have a non-pixel reference of the character.

Limitations: Quick Sprites’ three styles cover the common indie use cases but aren’t infinite. For a custom animation (sword swing, cast, parry) you’ll move to Path 3. For a character locked in a different style first, you’ll move to Path 2.

Path 2: Convert any image to pixel art (True Pixel)

True Pixel takes an arbitrary image and produces pixel-art at a target resolution. The processing chain:

1. Downscale. The input image is intelligently downscaled to your target frame size (e.g. 64×64). True Pixel preserves silhouette features that would be lost in a naive bilinear resize.
2. Palette quantization. All colors in the downscaled image are mapped to your chosen palette — a preset like Game Boy, NES, PICO-8, or a custom palette extracted from the input image itself. Typical palette size: 8 to 32 colors.
3. Edge cleanup. Outlines are sharpened. Anti-aliased pixels at silhouette edges get assigned to either inside or outside the character; no half-tones.
4. Chroma keying / transparency. Solid-color backgrounds in the input are detected and replaced with full transparency for clean game use.
5. Export. Transparent PNG at exact target resolution, ready to drop into your engine.

This is the path when you’ve already locked a character in a non-pixel style — say a hand-painted illustration from AI Image Gen — and want to ship a pixel-art version of the same character. The character’s identity is preserved (same colors, same silhouette, same outfit), but rendered at low resolution with a constrained palette.

One important detail: do the conversion after the character is locked, not before. Generating pixel art directly from a prompt tends to drift between iterations; converting from a locked source produces consistent pixel-art across all your assets.

Path 3: Convert a video to pixel art (True Pixel)

True Pixel also accepts videos as input. Frame-by-frame, every frame goes through the same downscale + palette quantization pipeline, then assembles into either a video output or a sprite sheet. This is the path when you have:

• An AI-generated animation (e.g. from AI Video Gen) of your character doing a custom move that isn’t in any standard sprite library.
• A reference video of a real animation (motion-capture footage, a fighting-game move, anything) that you want to translate into pixel art.
• An existing 3D animation rendered to video that needs to be down-converted into 2D pixel art.

The output is either a pixel-art video (for cinematics) or a sprite sheet (for in-game animation). True Pixel’s shared palette mode is critical here — without it, each frame would quantize to slightly different colors and produce flickering artifacts. Shared palette mode extracts a single palette across all frames, then quantizes every frame against the same color set, giving you flicker-free pixel-art animation.

Picking and locking your palette (the quietly important step)

Your palette determines whether your game looks coherent across hundreds of assets. Three approaches:

• Classic preset palettes. Game Boy (4 colors), NES (52 colors total, 4 per sprite), PICO-8 (16 colors), Pico-8’s “Secret Palette” (additional 16). Using a preset locks you to a recognizable retro aesthetic. True Pixel ships with these as one-click presets.
• Custom palette from your hero asset. Take your most important character or environment piece, extract the dominant 16 colors, and use that palette across every other asset. Result: a custom-feeling but coherent style.
• Curated indie palettes. Sites like Lospec host hand-curated palettes uploaded by pixel artists. Pick one that matches your mood and lock it project-wide.

Whatever you pick, the rule is the same: lock it once, use it everywhere. Mixing palettes between assets is the single most common reason indie pixel-art games look amateurish.

Cleanup and engine prep

The output from any of the three paths is a transparent PNG at exact target resolution. To prep for an engine:

1. Verify transparency. Open in any image viewer that shows the alpha channel as a checkerboard. If the background is solid colored instead, you missed a chroma-key pass.
2. Check the silhouette. Squint at the asset. Can you tell what it is from the silhouette alone? If not, the character will be unreadable in-game and needs a more distinctive outline.
3. Verify the grid. If you’re shipping a sprite sheet, confirm every frame is exactly the same size and aligned to a clean grid. Mismatched frames will misalign in the engine.
4. Optional: import to Aseprite for refinement. AI-generated pixel art is usually 90% there. If you want the last 10%, drop the output into Aseprite and pixel-push edges for an hour. The base AI output gets you to the starting point of where manual pixel art would have stopped after a week.

How to make pixel art for specific game styles

Different game genres have different pixel-art conventions. Pick the one that matches your target:

• Top-down RPG (Stardew Valley, Pokémon). 32×32 or 48×48 character sprites, four-direction walking, 16-color palette. Use Quick Sprites’ “Four Angle Walking” preset.
• Side-scroll platformer (Celeste, Hollow Knight). 32×32 to 96×96 depending on art density, side-facing animations only, larger palette (16–32 colors). Auto-Sprite v2 with a pixel-art reference.
• Beat-em-up (Streets of Rage style). 64×96 or larger, multi-frame attack animations, large palette. Auto-Sprite v2 again — Quick Sprites’ menu doesn’t cover combat moves.
• Puzzle / casual (Threes!, Threes!-style mobile). 64×64 to 128×128, no animation needed, focus on icon-style readability. True Pixel from a clean illustration.
• Demake / retro homage. 16×16 to 32×32, locked to specific platform palette (Game Boy, NES, C64). Always use the appropriate platform palette preset for authenticity.