Pixel Art Sprite Pipeline

Turn any high-resolution artwork into a crunchy pixel art sprite with a limited color palette and clean outlines, then batch-export color variants as a packed sprite sheet. This workflow is built for game developers who need retro-styled assets at scale.

You’ll go from a full-resolution illustration to a sprite sheet with multiple color variants, complete with a JSON manifest for engine integration.

What You’ll Need

A source image (illustration, photo, or 3D render; any resolution works)
A target sprite size in mind (common sizes: 16x16, 32x32, 64x64)
A color palette for your target art style (optional; you can quantize automatically)

The Pipeline

Image In  ->  Pixelate  ->  Resize  ->  Quantize  ->  Outline  ->  Palette Remap (+ Palette)  ->  Export Batch

Why Quantize before Outline? If you outline first in #000000 and then Quantize down to 4 colors, the quantizer counts black as one of those 4 — 25% of your palette budget gone before you’ve even started. Quantize first to lock in the N most important colors, then add the outline using a color picked from the quantized output (so it joins the existing palette instead of inflating it).

Step-by-Step Walkthrough

1. Image In — Load Your Source Artwork

Add an Image In node and load your source image. This can be anything: a digital painting, a photograph, a 3D render. Higher-resolution sources give you more detail to work with before the pixel art reduction.

For best results, choose source art with a clear silhouette and distinct color regions. Busy backgrounds will muddy the pixel art conversion.

2. Pixelate — Create the Chunky Pixel Look

Add a Pixelate node and connect it to Image In.

This is where the magic starts. Pixelate groups pixels into blocks and averages their color, creating that distinctive retro look at the original resolution.

Set Block Size based on your source resolution and desired output:

Source is 512x512, target sprite is 32x32: set Block Size to 16 (512 / 32 = 16)
Source is 1024x1024, target sprite is 64x64: set Block Size to 16
Source is 256x256, target sprite is 16x16: set Block Size to 16

The preview immediately shows the pixelated result. Adjust the block size until the key features of your subject (eyes, weapon edges, distinctive shapes) are still readable.

Why Pixelate first instead of just resizing? Pixelate and Resize are doing different things, and the choice affects the final pixel colors:

Pixelate (block 16) → Resize Nearest (32×32) — each output pixel is the average of a 16×16 source block. Closest to a “true” downsample. You also see the chunky look at full resolution while you tune Block Size, which makes the visual feedback loop tighter.

Resize Lanczos (32×32) alone — each output pixel is a windowed weighted blend of source pixels. Comparable end pixels, fewer nodes, no full-size preview of the pixelated look. Best when you already know the target size and the source is clean.

Resize Nearest (32×32) alone — each output pixel is a single sampled source pixel (no averaging). Sharpest, blockiest, can produce flickery colors from small misalignments. Best for sources that are already pixel-art, where averaging would muddy intentionally distinct colors.

This recipe uses Pixelate + Resize Nearest because the visual tuning of Block Size is the most beginner-friendly path. If you’ve nailed your sprite size and source quality, Resize Lanczos alone is a perfectly valid one-node alternative.

3. Resize — Scale Down to Sprite Dimensions

Add a Resize node after Pixelate.

Set Width and Height to your target sprite size, for example 64 and 64. The critical setting here is the Filter: set it to Nearest. This preserves the hard pixel edges from the Pixelate step. Bilinear or Lanczos filtering would blur the pixel boundaries and ruin the retro look.

If you want non-square sprites, uncheck Lock Aspect Ratio and set dimensions independently.

4. Quantize — Reduce to a Limited Palette

Add a Quantize node to crunch the color count down to retro levels.

Set Colors to your target count:

4 colors for Game Boy-style restrictions
8 colors for a tight NES-era feel
16 colors for SNES-level richness
32 colors for modern pixel art with smooth gradients

Quantize uses k-means color reduction, so it picks the most visually important colors automatically. The result looks intentionally designed rather than randomly dithered.

Leave Dither off for clean flat-shaded pixel art. Enable it (Bayer 4x4 ordered dithering) if you want broken-up gradients with fewer colors. For Floyd-Steinberg or other dithering algorithms, add a separate Dither node after Quantize.

5. Outline — Add a Sprite Border

Add an Outline node to give your sprite a clean, readable border, essential for sprites that will appear over varied backgrounds.

Key parameters:

Thickness: Set to 1 for a classic 1-pixel outline. Use 2 for larger sprites (64x64+) where a thicker border reads better.
Color: Use the eyedropper to pick the darkest color from the quantized output. This way the outline reuses an existing palette color instead of introducing a new one — crucial when you’ve Quantized to 4 or 8 colors. If you intentionally want the outline outside the palette (e.g., the recolored variants will share the same outline color regardless of remap), set it to a fixed color like #000000.
Position: Outline has three placement modes — Outside (grows outward, keeps all interior detail intact, bounding box expands), Inside (eats into the sprite but keeps the bounding box unchanged), and Center (straddles the edge, half in / half out). Pick Outside for the classic sprite border look.

6. Palette Remap + Palette — Generate Color Variants

Add a Palette node and define named color slots for your variant set. For a dungeon game, you might create:

Slot Name	Color	Use Case
Stone	#808890	Default
Fire	#E04020	Fire element
Ice	#40A0E0	Ice element
Poison	#50C040	Poison element
Shadow	#483060	Dark element

Add a Palette Remap node. Connect the Outline output to its Image input and the Palette to its Palette input. Set the Source Color to the most prominent color in the quantized sprite using the eyedropper — typically the dominant subject color, not the outline color (so the outline survives the remap unchanged across all variants).

Each palette slot now produces a complete recolored sprite variant.

7. Export Batch — Output as a Sprite Sheet

Add an Export Batch node and connect the Palette Remap variants output.

For individual sprite files:

Base Name: slime (produces slime_stone.png, slime_fire.png, etc.)
Format: PNG

For a packed sprite sheet, enable the Sprite Sheet toggle:

Columns: Set to the number of variants (e.g., 5 for 5 color variants in a single row, or 3 for a 3-wide grid)
Padding: 1 pixel between sprites (prevents texture bleeding in most engines)
Power of Two: Enable if your engine requires PoT texture dimensions

The sprite sheet export produces both a PNG atlas and a JSON manifest listing each sprite’s name, position, and dimensions, ready for direct import into Unity, Godot, or your custom engine.

Result

A sprite sheet PNG plus JSON manifest containing all color variants packed into a grid. Each variant has consistent dimensions, limited palette, and clean outlines. The JSON manifest maps each variant name to its position in the atlas.

Variations

Skip the outline for sprites that will have outlines drawn by the engine at runtime (common in modern pixel art games with dynamic outline shaders).
Add Dither after Quantize by inserting a Dither node with Bayer 4x4 pattern for an ordered dithering look that’s more controllable than Floyd-Steinberg. Set the pattern size to match your pixel grid.
Use Palette From Image instead of a manual Palette to pull colors from a reference screenshot of the game you’re matching. Point Palette From Image at a screenshot and set Count to 5-8 to capture the dominant hues.