Free tool, no signup

AI Pixel Art Fixer

Turn “pixel-style” AI images into real, grid-aligned pixel art. Free, no signup. Drop an image, get true pixels back.

$0Free, no watermarks
77%Exact native size
94%Grid alignment

Standard engine on pixel-bench: 4,300 distorted images. No other tool clears 5% exact size.

EngineBoth free here. Neural gives the best quality; switch any time and we re-run the same upload.

Drop an image here, click to browse, or paste from your clipboard

PNG · JPG · WebP: AI generations, bad upscales, JPEG-crushed sprites

Output--
Grid--
Source--
Time--
Palette--
Palette & finish

Palette & finish

Clean the color noise after the grid is rebuilt.

Dither matrixOrdered dithering
Dither strength0 = off · 1–3 subtle · 10 strong
Off
px
Auto
Load an image to apply changes
Standard vs Neural

Standard is instant and open. Neural rebuilds the hard ones.

The standard engine measures the implied grid and snaps it. It’s deterministic, instant, and open source. The neural engine goes further: trained on real pixel art, it reconstructs detail, palettes, and clean alpha that generic snappers smear away. It’s exclusive to this site, and still free. Choose either engine above and switch between them on the same upload.

Standard

Open source

Deterministic, instant, open source. The same image gives the same result every time.

Exact size77%
Grid aligned94%
API$0.002
  • Measures the implied grid and snaps every cell to a single true pixel
  • Runs entirely in your browser: your image never leaves it
  • Python reference, fast Rust port and a full writeup on GitHub
  • You can force a pixel size by hand when the grid is ambiguous

Best for clean upscales and images with a clear implied grid.

Neural

RD exclusive · Free

Our highest-quality engine: our own reconstruction model, trained on real pixel art. It rebuilds clean pixels where the grid is barely visible.

On the siteFree
API$0.005
Only onRD
  • Recovers detail, palettes, and clean alpha the standard engine can’t
  • Handles the hard cases: heavy blur, warped grids, JPEG crush, mushy detail
  • Optional target width and height on the API
  • Processed securely on our servers and not retained

Best for badly blurred, warped or JPEG-crushed images and painterly fakes.

AI-generated koi pond garden, fixed
AI-generated koi pond garden, original
OriginalFixed
Swipe sideways to compare
Koi pond: AI render → 115×116 true pixelsStandard example
AI-generated battle mech, fixed
AI-generated battle mech, original
OriginalFixed
Swipe sideways to compare
Battle mech: AI render → 157×150 true pixelsStandard example
Why it matters

“Pixel-style” isn’t pixel art

General-purpose AI models output images that look like pixel art but aren’t: the “pixels” drift off-grid, blur into each other, use thousands of nearly identical colors, and there’s no clean transparency.

Game engines don’t care how it looks. They need the real thing. Tiles that align to a grid, sprites that pack into atlases, palettes you can actually swap, edges that cut out cleanly. That’s the difference between an image and an asset.

The Fixer measures the implied grid, snaps every cell to a single true pixel, and rebuilds the image at its native resolution: real pixels, ready for engines, editors, and palettes.

Touch and drag on the frog to zoom in. Those aren’t clean pixels: they’re soft, smeared, and off the grid.

AI-generated frog on a lily pad that only looks like pixel artPixel-style, not pixel art
Skip the cleanup

Or skip the conversion entirely

Retro Diffusion generates real pixel art from the start: grid-aligned, palette-locked, animation-ready. Built by a working pixel artist and designed for game developers and artists, so what you make drops straight into your game. New accounts start with $0.50 of balance, no card needed. Your balance never expires.

RD Pro$0.18Pro quality, any size, per image
RD Fast$0.03Quick drafts and ideas, per image
RD Pro
RD Pro
RD Fast
RD Plus
Bulk on the API

Bulk fixing on the API

Fixing a whole asset folder, or wiring cleanup into your pipeline? The Pixel Art Fixer is available on the Retro Diffusion API for bulk use, alongside generation, animation, and every editing tool. Sign in and create a key under “Developer Tools” to get started. Learn more about the API →

$0.002Standard, per call
$0.005Neural, per call
PNG, JPEG or WebP as raw base64, a data URI, or a public HTTPS image_url
Charged before running, refunded automatically if a call fails
Neural takes an optional target width and height
120 requests a minute per key once you’ve made a purchase
import base64
from pathlib import Path
import requests

response = requests.post(
    "https://api.retrodiffusion.ai/v2/pixel-fixer/standard",
    headers={"X-RD-Token": "YOUR_API_KEY"},
    # URL input avoids carrying a large source in the request body.
    json={"image_url": "https://cdn.example.com/soft-sprite.png"},
    timeout=120,
)
response.raise_for_status()

# The response contains exactly one raw base64 PNG.
fixed = response.json()["base64_images"][0]
Path("fixed-sprite.png").write_bytes(base64.b64decode(fixed))
Fixed pixel art: Wizard’s library
Wizard’s library174×130
Fixed pixel art: Snowy mountain cabins
Snowy mountain cabins121×91
Fixed pixel art: Desert steam train
Desert steam train157×118
Fixed pixel art: Dragon on a treasure hoard
Dragon on a treasure hoard357×268
Fixed pixel art: Raven in a meadow
Raven in a meadow207×155
FAQ

Frequently asked questions

Anything else? Ask in our Discord, the team hangs out there.

Yes. Free, no signup, no watermarks. Fix as many images as you like.

Standard is a deterministic grid detector and snapper, and it’s open source. Neural is a machine learning reconstruction that handles the hard cases: heavy blur, warped grids, mushy detail. It’s exclusive to retrodiffusion.ai, and still free.

The standard engine runs entirely in your browser. Neural images are sent securely to our CPU reconstruction service for processing and are not retained.

Output from general AI models that imitates the look of pixel art without the structure: uneven pseudo-pixels, thousands of colors, no grid, no clean alpha. It can’t be tiled, palette-swapped, or edited pixel-by-pixel until it’s converted.

AI generations from any model, bad upscales, JPEG-crushed sprites, and screenshots of pixel art. The clearer the implied grid, the better the snap, and you can force a pixel size manually.

That’s what Retro Diffusion is for: models that generate real, grid-aligned pixel art directly, with styles, animation, and tilesets. It’s free to start, no card needed.

Benchmark

Measured against every other tool

Anyone can claim their converter is the best. So we built an open benchmark, pixel-bench, that takes real pixel art, distorts it the way AI models and bad upscales do (fractional scaling, blur, JPEG, noise, grid drift, painterly mush), and scores how faithfully each tool rebuilds the original. Across 4,300 distorted images spanning 43 kinds of damage, here is how the standard engine compares to the other popular fixers.

77%Exact native size
84%Within 1 pixel
94%Grid alignment
Benchmark chart: the Pixel Art Fixer recovers the exact native size on 77% of images, within one pixel on 84%, and aligns the grid on 94%, far ahead of PixelDetector, unfake.py, PixelSnapper, and a naive baseline.

That is the standard, open-source engine, not the neural one. It recovers the exact native resolution on 77% of images, where no other tool clears 5%, and its detected grid lines land on the true grid more than nine times out of ten. It leads every category, from clean upscales to heavy mush and painterly fakes. Full methodology, every metric, and per-category results are in the open pixel-bench repo →

Explore the benchmark on pixel-bench
Open source

The standard engine is open source

The deterministic grid detector behind the standard engine is free and open source: the full Python reference, a fast Rust port, and a deep writeup of how the detection works. Read it, run it, fork it, or wire it into your own pipeline.

Retro-Diffusion / pixel-art-fixerPublic

Measures the implied grid of upscaled or AI “pixel-style” art and snaps every cell to a single true pixel at its native resolution.

Python referenceThe full detector
Rust portFast native build
WriteupHow detection works