When blurred or pixelated text can be recovered

Blurred and pixelated text recovery has three separate jobs: inverse filtering, candidate matching, and cosmetic enhancement. They produce different kinds of evidence. This page compares them and explains why a visually convincing result can still be wrong.

Provenance. The local experiment ran on 2026-11-08 against one anonymised screenshot containing heavily blurred text. The source image, account names and candidate strings are withheld. More than 40 tools and method families were surveyed; deterministic deconvolution, OCR, learned deblurring, super-resolution and known-font candidate matching were run locally. No image was uploaded to a third-party service. Figures below are from that run and have no published artifact.

TL;DR:

• Uniform mosaic pixelation can sometimes be reversed when the font, block grid and rendering parameters are known. Tools such as Depix and Unredacter rely on those conditions.¹²
• Smooth blur calls for a different model. Inverse filters estimate a point-spread function (PSF); candidate attacks render possible text, blur it and compare the result with the observed pixels.³⁴
• The local known-font search recovered exact short synthetic controls at Gaussian sigma 4, 6, 8 and 10. On the real crop, 72 parameter runs produced 53 different best strings.
• A wrong candidate had the best pixel fit in one comparison. The actual string did not appear among the five best-scoring candidates.
• AI super-resolution can make a result easier to read by inventing plausible structure. That output has no forensic reliability.

Match method to transformation

Transformation	Useful approach	What counts as evidence
Uniform block mosaic	Depix, Unredacter, rendered-font matching	A stable answer under the exact font, block size, crop and colours
Gaussian or defocus blur	Blind deconvolution, Wiener or Richardson-Lucy filtering	Improved structure on known-text controls, then stable target output
Motion blur	PSF estimation and motion-aware deblurring	A credible kernel and stable output across nearby parameters
Known text candidates	Render-and-compare search	A large error gap plus agreement across renderers and parameter perturbations
Multiple video frames	Frame alignment and information stacking	Detail that repeats across frames
Severe single-frame blur with unknown rendering	No general recovery method	Usually only weak hypotheses
Any input needing a cosmetic preview	Learned super-resolution or generative restoration	Clearly labelled synthesis, never recovered text

Depix and Unredacter are not general deblurring tools. Their published approaches depend on a regular pixel grid and a reproducible text renderer.¹² A smooth Gaussian-looking smear has no such grid, so feeding it to a mosaic solver supplies the wrong forward model.

The forward model determines the result

A blur model approximates how the original text became the observed pixels. A candidate scorer needs the font file, weight, size, position, colour, antialiasing, crop and PSF. Small changes to any of them can change the winning string.

The mask score used in the local experiment was a mean squared error after fitting the candidate’s intensity:

score = mean((target - amplitude * blurred_render)^2)

A separate RGB check fitted each colour channel independently.

A known-font beam search extends the current best prefixes one character at a time. It is tractable for short strings and a constrained alphabet. It is also sensitive to the starting position, font size, blur radius and beam width. A scoreboard records hypotheses; it does not establish which string existed before the blur.

DataBlur’s public study demonstrates this class of attack with controlled text, fonts and blur parameters. Its recovery rates describe the performance of one attacker under its test conditions, not a general ceiling or a promise for arbitrary screenshots.⁴

What the local run showed

Check	Result	Interpretation
Exact short synthetic controls, Gaussian sigma 4, 6, 8 and 10	Recovered by the known-font search	The implementation recovers the control when the blur parameters are known exactly
Real target across 72 parameter runs	53 distinct best strings	Perturbing font, size, position and sigma changed the best string in most runs, showing sensitivity to every input assumption
Fixed-candidate comparison	A wrong string achieved the best fit	Lowest error is not identification
Five automatically generated options	Actual string absent	A top-N list can miss the truth entirely
Tesseract and EasyOCR	Inconsistent fragments or no detections	OCR cannot restore missing structure
Richardson-Lucy and Wiener sweeps	Ringing and unstable artifacts	Inverse filtering amplified noise
Restormer, Real-ESRGAN, SwinIR, NAFNet, DeblurGANv2 and DocDiff	Cosmetic changes without verified text	Learned enhancement did not provide evidence
Kernel-Diff	A shifted sparse motion kernel and no readable text	The inferred blur family did not fit the target
UnPixel decode	Explicitly untrustworthy placeholder	The tool correctly refused a confident answer

The strongest result is the disagreement between methods. One parameter configuration can favour a wrong string while another configuration of the same forward model favours something else. This is consistent with heavy blur suppressing the high spatial frequencies that distinguish letterforms; many input strings produce nearly identical output pixels.

Deconvolution has a narrower role than enhancement

Richardson-Lucy and Wiener filtering estimate an inverse of the blur process. They can improve mild defocus when the PSF is close and the image retains useful high-frequency content. Iterative filtering also amplifies noise and produces ringing around strong edges.⁵

Blind methods estimate the PSF as well as the image. Kernel-Diff uses a diffusion model for the kernel and a second network for non-blind deblurring.³ That added flexibility does not guarantee a physically correct kernel for an atypical text crop.

Learned super-resolution models such as Real-ESRGAN address a different problem: synthesising a plausible high-resolution image from a low-resolution input.⁶ Their output can be useful for presentation. It should not be used to attribute a username, account number, licence plate or other identifier.

Validation that catches false confidence

1. Create known-text controls with the same renderer. Recovery on an exact control checks the implementation, not the real target’s unknown model.
2. Perturb the parameters. Vary font weight, size, position and PSF. A trustworthy answer stays stable; the local target produced 53 best strings across 72 runs.
3. Use an independent renderer. Agreement between Pillow, a browser canvas or another text engine is stronger than repeated fits from one implementation.
4. Measure alternatives, not only the favourite. Record the runner-up error and the full candidate list. A small gap means ambiguity remains.
5. Check ground truth when it exists. The local actual string scored worse than a wrong alternative, which invalidated the apparent recovery.
6. Keep OCR separate from restoration. OCR detects and recognises surviving structure; it cannot validate structure invented by an earlier model.

What to do about it

Practice	Lever	Rests on
Use Depix or Unredacter only after confirming uniform mosaic and exact rendering parameters	Inspect the block grid, font, crop and colours	Tool requirements12
Fit the renderer against unblurred text from the same UI before attempting candidate matching	Font file, weight, size, position and timestamp calibration	Local font-fit experiment
Require stability across parameter perturbations and at least one independent renderer	Repeated candidate scoring	53 distinct best strings across 72 local runs
Return ranked options with sharp and forward-blurred renders	Candidate-scoring interface	The actual string was absent from the five generated options
Label learned-restoration output as synthesis	Output schema and review process	Real-ESRGAN’s super-resolution objective6
Prefer opaque redaction over blur for sensitive text	Solid boxes, cropping or regeneration without the sensitive region	Candidate attacks exploit surviving low-frequency information4
Ask for a second source or an unredacted original when the identifier matters	Provenance, not image processing	The local inverse filters did not recover readable text

Reproducing the candidate method

The minimal algorithm is independent of the imaging library:

fit font and position against readable text from the same UI
for each candidate:
    sharp = render(candidate, font, size, position, colour)
    blurred = apply_psf(sharp, candidate_sigma)
    score[candidate] = compare(blurred, observed_pixels)
return candidates ordered by score, plus their sharp and blurred renders

Keep the sharp and forward-blurred outputs beside every score. They expose the assumption that produced a candidate and make parameter disagreements visible. Ground truth may be supplied to report its rank, but it should not suppress generation of the other options.

For sensitive material, the safer workflow is to replace the region with an opaque rectangle or publish a newly generated image that never contained the sensitive pixels. Blur and mosaic preserve information that a constrained attacker can sometimes exploit.⁴²

Related docs

• Model routing and vision fallbacks covers how a coding agent reads images and why OCR descriptions remain lossy.

References

1. beurtschipper, “Depix: recover passwords from pixelized screenshots,” GitHub. https://github.com/beurtschipper/Depix ↩ ↩² ↩³

2. Bishop Fox, “Unredacter: redacted text recovery tool,” GitHub. https://github.com/BishopFox/unredacter ↩ ↩² ↩³ ↩⁴

3. Yash Sanghvi et al., “Kernel-Diff: diffusion-based blind image deblurring,” GitHub. https://github.com/sanghviyashiitb/kernel-diff-eccv24 ↩ ↩²

4. DataBlur, “Blur Recovery Study,” DataBlur Blog. https://datablur.app/blog/blur-recovery-study ↩ ↩² ↩³ ↩⁴

5. scikit-image developers, “Restoration and reconstruction,” scikit-image API. https://scikit-image.org/docs/stable/api/skimage.restoration.html ↩

6. Xintao Wang et al., “Real-ESRGAN: general image restoration,” GitHub. https://github.com/xinntao/Real-ESRGAN ↩ ↩²

Linked from

• Which model runs which agent work: model routing in a coding-agent harness

Link graph: 1 doc links here, this page links to 1