Why Screenshots and UI Images Should Not Be JPEG
Screenshots, UI mockups, diagrams and charts belong in PNG or lossless WebP. JPEG was designed for continuous-tone photographs, and its compression works by smoothing small blocks of pixels — exactly the wrong operation for thin lines, flat colour and text, where the smoothing shows up as fringing, ringing and grey mush. The file is smaller, but the image stops being usable.
The failure is not subtle once you know where to look, and it is easy to demonstrate: save the same screenshot as JPEG at quality 70 and open it at 100%. Text that was crisp becomes slightly furry, coloured labels pick up a halo, and one-pixel borders develop a shimmer that was not in the original.
What JPEG does to interface pixels
JPEG divides the image into 8 × 8 blocks and discards high-frequency information within each block, then stores colour at reduced resolution. Three consequences follow for interface imagery:
- Text loses its edges. Letterforms are almost entirely high-frequency detail. At moderate quality the strokes thicken and blur, and small sizes become hard to read even though the dimensions are unchanged.
- Flat areas develop visible blocks. A solid white panel compresses to near-uniform values, but block boundaries can still show as faint seams, especially next to sharp edges.
- Colour bleeds. With chroma subsampling, a red icon on white picks up a pink halo, and thin coloured text on a dark background can lose saturation entirely.
None of this is a defect in JPEG. It is a codec doing what it was tuned to do, on content it was never tuned for.
PNG and lossless WebP are the right tools
PNG compresses by predicting each pixel from its neighbours and encoding only the difference, without discarding anything. That preserves hard edges, exact colours and transparency. Lossless WebP applies a more modern predictor plus a palette-friendly mode, and on typical screenshots it usually produces a file 20–40% smaller than PNG with identical pixels.
| Content | Format | Why |
|---|---|---|
| App or web UI screenshot | PNG or lossless WebP | Text, icons and flat panels stay exact |
| Error dialog, config file in an editor | PNG | Readability is the entire point |
| Chart or diagram with labels | PNG or SVG | Thin strokes and text survive |
| Photo-heavy app screen with little text | WebP quality 85+ | Mostly photographic content, mild loss tolerated |
| Marketing mockup with device frame | PNG or lossless WebP | Needs transparency and clean edges |
| Screen recording frame | WebP or PNG | Compression artifacts crawl between frames if lossy |
When JPEG is acceptable for a screenshot
There is a narrow case: a full-screen capture that is mostly photography — a map view, a photo editor with an image filling the canvas, a video player with a film still. If no text needs to stay sharp and the surrounding chrome is minimal, JPEG or lossy WebP at high quality is fine and much smaller.
The test is simple. Zoom to 100% and read the smallest text in the image. If you have to lean in, the format is wrong for that image.
Lossy WebP at quality 90 or above is more forgiving than JPEG on UI content because it does not subsample chroma as aggressively at high settings, but it still smooths edges. When the screenshot is a reference document that someone will read, use lossless.
Dimensions: capture large, publish small
A screenshot taken on a high-density display is often twice the CSS pixel size — a 1440-wide window captured at 2880 px. Publishing it at full size makes a huge file and text that appears oversized. Two workable approaches:
- Downscale by exactly half to 1× for web publishing. The result stays crisp because you are averaging four pixels into one, not inventing detail.
- Keep 2× only when the image is meant to be inspected closely, and say so in the surrounding text.
Never upscale a 1× screenshot to look “high resolution”. It adds bytes and blur, and any compression afterward makes it worse. If a page demands a minimum width, capture again at a wider window instead.
Crop harder than you think
Most screenshots include a browser frame, a dock, a menu bar and empty canvas around the thing being demonstrated. Cropping to the relevant panel is the single largest size reduction available for UI imagery, and it also reads better: the reader sees the dialog, not your desktop.
Cropping also helps compression. A tight crop of a plain panel has very little content to encode, so even PNG comes out small. If you must keep context, blur or blank out unrelated areas rather than leaving customer names and email addresses in a published image.
Small details that matter for UI images
- Redact before you compress. Pixelating or drawing a box over sensitive text is fine; blurring lightly is not, because some blur is reversible.
- Watch 1-pixel borders. They vanish first under lossy compression. Check that table rules and input outlines survive.
- Dark mode screenshots compress differently: large near-black areas are cheap, but antialiased light text on dark backgrounds shows halos badly in JPEG.
- Animated captures. Do not publish a GIF of a UI interaction. A short MP4 or WebM is smaller, smoother and does not dither the colours into noise.
- Keep the resolution honest. A screenshot of a 4K monitor downscaled to 800 px may make text unreadable; crop instead of shrinking when the text is the content.
Fixing a screenshot that is already ruined
If the only copy you have is a JPEG screenshot with visible artifacts, you cannot restore the original detail — the information is gone. What you can do is limit further damage: decode it once, resize once, and save the result as PNG. Re-encoding a JPEG at high quality adds bytes without recovering anything, and converting it back and forth between formats will make the text progressively worse.
If the source still exists, re-take the screenshot. That is almost always faster than repairing one, and it gives you the chance to crop properly and hide anything that should not be public.
FAQ
Is lossless WebP really identical to PNG?
Yes, for the pixels. The decode produces the same RGB values; only the storage format differs. The trade-off is compatibility: very old software may not open WebP, while PNG opens essentially everywhere. For documents and internal references, PNG is the safer choice.
Why does my PNG screenshot weigh 2 MB?
Because it is probably 2880 px wide with photographic content, such as a wallpaper or a photo inside the app. Crop to the interface, downscale to 1×, or switch to lossy WebP if the screen is mostly photographic.
Should I use SVG for UI diagrams?
If you drew the diagram yourself, yes — SVG is tiny, scales without blur, and stays editable. SVG is not an option for a screenshot of an existing app, which is a raster image by nature.
Written by the PixelPress team. Last updated November 19, 2026.