All blog posts

Why your AI pixel art looks blurry.

AI-generated pixel art is usually a continuous-tone image with a pixel-art aesthetic. Spot the symptom, find the implied grid, and reconstruct a real source you can scale, tile, and ship.

The short version: stop trying to rescue the 1024 image. Find the grid it implies, downscale to that grid with nearest-neighbor, and treat the small result as the source of truth.

The problem

"Pixel art" from a generator usually isn't pixel art.

Real pixel art is built one cell at a time. Each cell holds a single colour, every edge is a hard step between two cells, and the whole image lives on a tidy palette of maybe four to thirty-two colours. The grid is explicit, the edges are intentional, and the file size is tiny because the information is.

The image a generator hands you usually looks like pixel art at thumbnail size, then falls apart the moment you scale it, tile it, or open it in an editor. The cells have soft gradients between them. The edges that should be hard are anti-aliased into ramps. The palette balloons to hundreds or thousands of colours. It is a 1024 x 1024 raster wearing a pixel-art costume.

You cannot polish that image into a real source by scaling, sharpening, or quantising the big version. The information you want — one colour per cell, on a known grid — has to be reconstructed by sampling the implied grid underneath.

Drop an AI image and see the source it implies

Original — continuous-tone
Reconstructed — 32 × 32
0colours in original0in reconstructionsource: synthetic faux sample
Implied source grid

The sample reconstructs cleanly at 32. Switch the grid to 24 or 48and turn on the overlay to watch the lines slice through cells — that drift is Tell #2 of a faux-pixel image.

The synthetic sample on mount is a small sprite bilinear-upscaled to 256, then reconstructed back. Drop your own image to do the same on whatever the generator handed you.

Rule one

Recognise the three tells of a faux-pixel image.

Before you can fix it, you have to see it. The same three symptoms show up on almost every generated image trying to look like pixel art, and once you know them you cannot un-see them.

What makes a generated image fail the pixel-art test

Tell 1

Anti-aliased edges between cells.

Look at where two coloured blocks meet. A real pixel-art edge is a hard step. A faux edge has a row of in-between pixels averaging the two colours.

Tell 2

Cell boundaries that drift off the grid.

Lay a candidate grid over the image. On real pixel art every cell starts at an integer pixel position. On a faux image the cells slip, with widths like 17, 16, 17, 18 instead of a uniform 16.

Tell 3

A palette of hundreds instead of a handful.

Open the image in any tool that can count unique colours. Real pixel art rarely needs more than thirty-two. A faux image will usually report several hundred to several thousand.

Any one of these is enough to confirm the image is a continuous-tone raster. Usually all three are present at once.

Rule two

Find the implied source grid.

The generator was prompted to make pixel art, so it almost always picks an implied cell size when it composes the image. Your job is to guess it. Common values are 16, 24, 32, 48, and 64. Start with 32 for character art, 16 for items and icons, 64 for scenes.

To verify the guess, overlay a grid of that size on the original and look at the cell boundaries. If most of them land where the colour blocks visually change, you have the right size. If the grid slices through what should be a single cell, try the next size up or down. The right grid is the one where almost every cell holds one dominant colour.

Rule three

Downscale with nearest-neighbor, then snap the palette.

Once the grid is known, downscale the large image to that exact grid using nearest-neighbor sampling. Not bilinear, not Lanczos, not any smoothing filter. Nearest-neighbor reads a single pixel from each cell and keeps it; smoothing filters average across cells and reintroduce the soft edges you are trying to delete.

The output of that step is a tiny image — often 16 x 16 or 32 x 32 — that already feels more like pixel art than the big source did. Optionally, snap each pixel to a small palette of N colours to clean up any remaining drift. The small image, not the big one, is the new source of truth. Anything you need later — a 256-pixel preview, a 512-pixel store asset, a tiled background — comes from scaling this small source by whole numbers.

Reconstruct, don't rescue

From smudge to source in four steps

01

Spot the symptom

Confirm the image fails one or more of the three tells: soft edges, off-grid cells, oversized palette.

02

Find the grid

Pick the cell size by eye, then overlay it. Common values: 16, 24, 32, 48, 64.

03

Downscale + snap

Resample to that grid with nearest-neighbor only. Optionally snap to a small palette.

04

Scale at clean multiples

Treat the small image as the source. Upscale by whole numbers for previews, store assets, or in-game use.

Each step is mechanical and reversible. The judgement call is only in step two — picking the grid the generator implied.

Use cases

Where a reconstructed source actually ships.

Discord avatars and forum profile images are the easy case. A 32 x 32 reconstructed source scaled by nearest-neighbor to 128 or 256 looks crisp at every size the platform renders it at, including the tiny corner of a notification badge.

Game sprites are the next case. Whether you are dropping the reconstructed asset into Godot, Unity, or a custom engine, the small source is what the engine should hold. Set the texture filter to nearest, scale by camera or transform at integer factors, and the sprite stays sharp across any device pixel ratio. Watch-face motifs follow the same rule, with the added constraint that the visible safe area should hold the important pixels.

Pixelpond workflow

Reconstruct, don't rescue.

Reconstruct, don't rescue

The Pixelpond Engine's Upload view is built for exactly this step. Drop the generated image, pick the canvas size that matches the implied grid, and the engine reconstructs a clean source onto an explicit grid you can keep editing. The file never leaves your machine — see converting an image to pixel art for the feature in full.

The same recipe works without the engine — see the SplitPanels below for Aseprite, ImageMagick, and shader options — but the engine collapses the three manual steps into one drop-and-pick, then lets you keep working on the result instead of round-tripping through another tool.

"Reconstruct, don't rescue" is the studio's whole way of working in four words: let the machine hand you the fast, rough version, then rebuild it clean instead of polishing the mess. Move fast to get the source, slow down to make it yours.

The same recipe in other tools

Aseprite

Sprite ▸ Sprite Size, Nearest.

Set the target dimensions, choose Nearest neighbour for the resize method, and lock the result as the new canvas size.

ImageMagick

-resize 32x -filter point.

The point filter is ImageMagick's name for nearest-neighbor. Resize to the implied grid, then upscale at a clean factor.

Godot / Unity

Pixelating shader or nearest filter.

If you cannot do the reconstruction offline, a pixelating shader at the engine level can approximate it, with the texture filter set to nearest.

Different verbs, identical mechanics: pick a small target size, sample by nearest-neighbor, and treat the small result as the source.

Reconstruct, don't rescue

A reconstruction recipe in six bullets

  • Confirm the image fails one of the three tells: soft edges, off-grid cells, or oversized palette.
  • Pick the implied source grid: 16, 24, 32, 48, or 64 covers most cases.
  • Overlay the grid on the original to verify it lands on the visible colour blocks.
  • Downscale to the grid using nearest-neighbor only; never bilinear, never Lanczos.
  • Optionally snap the result to a small palette of four to thirty-two colours.
  • Treat the small source as the new source of truth. Scale up by whole numbers for ship sizes.

Next

Scaling the reconstructed source.

Once you have a clean 32 x 32 source, the question becomes how to display it at every size the destination needs — the avatar, the in-game sprite, the watch-face preview, the icon — without smoothing creeping back in. Scaling pixel art without blur covers the second half of the recipe: integer multiples, renderer settings, and the four places blur tends to sneak in.

And if the reconstruction left stray specks or a faint halo around the edges, cleaning up a messy AI sprite clears them in about a minute before you scale anything.