Pixel Art Fixer recovers the exact grid on 77% of 4,300 damaged images

Three detectors vote before a fourth channel gets a say

Grid recovery starts with three cheap, phase-invariant detectors: autocorrelation, run-length combs, and shift self-similarity. They vote first, and agreement is taken as the answer, on the argument that they fail on different images, so agreement between them is strong evidence. When they disagree, a fused evidence stack arbitrates per axis instead of letting one detector win outright. That stack combines spectral analysis, a tile-Rayleigh term, within-cell variance, and a round-trip score the document calls distillability. The arbitration rules are written around the specific traps that break simpler tools, which is the more interesting part: octave and harmonic confusions, where a period at 2x or half the truth scores nearly as well as the truth itself, content scale mistaken for pixel scale, and disagreement between axes that no single channel resolves. The whole structure is an answer to single-heuristic detectors, where patching one class of image silently regresses another.

Structure is voted on, color is read from the original pixels

Reconstruction runs in two stages because placement and colour fail in different ways. A small adaptive colour quantization is used only to decide structure: each cell votes among clean, flat quantized labels, so region boundaries and outlines come out crisp rather than smeared by bilinear resampling. Colour is then taken from the original, un-quantized pixels carrying the winning label, which is what keeps a rare highlight or a 1px accent from being clamped away. That is the claimed route to snapper-clean lines without a snapper's colour loss, and the accuracy section backs it with a number: when the recovered size is right, colours land within a mean CIELAB difference of about 1.6, which the document calls barely perceptible. The same passage states the ceiling, that there is a limit to what pure image processing can recover from a badly damaged image, and sends the hardest inputs to a neural version instead.

77% exact recovery, with the remainder measured against that same ceiling

The accuracy figures come from pixel-bench, an open benchmark that distorts native pixel art through 43 categories of real-world damage: fractional and non-square upscales, blur, JPEG, noise, grid drift, AI-upscaler mush, painterly fake-pixel texture, broken outlines and dead pixels. Across 100 source images and 4,300 distorted inputs, Pixel Art Fixer recovers the exact native size on 77% of images, lands within one pixel on 84%, and puts its detected grid lines on the true grid 94% of the time. The same table gives PixelDetector 4%, 7% and 80%, unfake.py 3%, 8% and 67%, PixelSnapper 4%, 19% and 63%, and a naive baseline 2%, 4% and 50%. Read as a whole, the table also marks where the tool stops: nearly a quarter of inputs do not come back at exact size, and the seven point gap between exact and within-one-pixel is the set of images where the recovered grid is close but not native.

The benchmark, the baselines and the methodology share one owner

Every number in that table comes from a repository the same organization publishes, and the full methodology, the per-category tables and the reproduction instructions are kept there rather than here. That is a reasonable place for them, and it also means the comparison runs against baselines this project selected: PixelDetector, unfake.py, PixelSnapper and its own naive baseline. Nothing here states how the baseline versions were pinned, what the 100 source images are, or whether the 43 damage categories are weighted equally, so a claim that the tool leads all 43 categories, including a deliberately extreme kitchen sink that stacks every kind of damage at once, can only be checked by leaving this repository. What the repository does carry is four example images, a dragon, a frog, a koi pond and a lighthouse, plus a docs directory, and the last push is dated 2026-07-15 with no tagged releases attached.

One dependency-free binary set against a Python reference

Two implementations live here and are described as producing the same answers, so the choice is about context rather than output. The python/ directory is the reference implementation, the one to read when the intent is to extend the method, and it needs Python 3.9+ along with numpy and further libraries whose list is cut off partway through the sentence that introduces it. The rust/ directory is the native core, shipped as one dependency-free binary and claimed to be 11-24x faster than the reference at 2.5-4x lower memory, converting a typical image in well under a second. Those ratios are the project's own comparison between its two halves, measured on its own hardware, and they are the only performance numbers anywhere in the document apart from the accuracy table. The MIT license in the root covers the code rather than the hosted service, and with no GitHub releases there is no tag to install either implementation from.

The pitch points at a web page while the repository ships code

The top of the document is a call to action: drop an image in a browser and get pixel art back, free, with no install and no setup. The two addresses do not match, since the call to action points at retrodiffusion.ai/pixel-art-fixer while the site entry recorded for this project is the longer www.retrodiffusion.ai/tools/pixel-art-fixer path. Free describes the hosted tool; the code in this repository is MIT and runs on your own machine, where the Python path needs an interpreter and the Rust path needs a build. The same opening stretch lists six ways generated and upscaled images fail: implied pixels that do not line up to a clean lattice, a cell that is 6.38 pixels wide instead of 6, edges blurred or dithered by bilinear resampling, a 32x32 sprite delivered as a 1024x1024 PNG with thousands of near-duplicate colors and no clean alpha, and JPEG's 8x8 block lattice fighting the real art grid. Until those are undone, none of it can be tiled, palette-swapped, animated or edited pixel by pixel.

A pixel snapper locks onto the sprite, not the pixel

The argument against existing tools is worth keeping separate from the accuracy table, because it explains the failures rather than ranking scores. Nearest-neighbor and fixed-integer downscaling assume one global integer cell size and a phase-0 origin, and fake pixel art violates both, in scale and in phase, so a fixed grid slices straight through cells. Pixel snapper utilities look for a single dominant period, and that period is regularly the content scale, a sprite, a texture, a face, rather than the pixel scale. The octave trap is called out separately: a period at 2x or half the truth scores nearly as well as the truth itself. That is why a lone cue, whether edges, autocorrelation or an FFT peak, is treated as brittle, and why the project runs several channels that fail on different images and then arbitrates the disagreements by axis.

Editorial conclusion

Treat this as a well-argued classical image processing tool with a self-published benchmark rather than a settled claim. The multi-detector consensus and the placement-then-color split are the parts worth reading, and the accuracy table is reproducible in principle because the methodology lives in a public sibling repository. Before adopting it, check the four baselines in that table and the 100 source images for yourself, expect a fifth of inputs to miss the exact native size, and remember that the hardest cases are handed to a neural version that is not described in this document. The last push to the repository is dated 2026-07-15 and there are no tagged releases, so pin a commit.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. Retro-Diffusion/pixel-art-fixer on GitHub