You spend twenty minutes getting the perfect screenshot. Sharp text, clean edges, exactly the detail you wanted to show off. Then you drop it into Discord or post it to Reddit, open it on the other side, and something’s off. Softer. Muddier. The text has grown a faint fuzz, and the comparison you were trying to win now looks like a wash.
You didn’t imagine it, and your file probably wasn’t touched. What got touched is the version everyone actually looks at.
What platforms do to your pixels
Every large platform that handles images generates its own versions of what you upload. Previews, thumbnails, resized copies for different screens, re-encoded variants to save bandwidth. The original file may well survive somewhere behind a click, but the thing that renders in the chat window or the feed is usually a processed copy, scaled to fit the layout and often re-encoded on the way.
Each step is individually reasonable. Scaling keeps layouts fast. Re-encoding saves the platform real money at their traffic volumes. But the steps stack, and they hit hardest exactly where careful screenshots carry their meaning: fine text, one-pixel edges, subtle grain, gentle gradients. The kinds of detail that survive a casual photo just fine get averaged out of a UI screenshot or a graphics comparison.
The rules for when this happens, which sizes trigger scaling, which formats get converted, are platform internals. They differ between apps, between the web and mobile clients of the same platform, and they change without announcements. Any blog post that tells you the exact current thresholds is either fresh or wrong. So skip memorizing thresholds and learn the two-minute diagnosis instead.
See exactly what got eaten
This is the part almost nobody does, and it settles the question for your platform and your file, as of today.
- Post your image wherever it’s going.
- Open what the platform displays (the preview in the chat or feed, not the download-original button) and save that version.
- Put the original and the round-tripped copy under a comparison slider at matched size and drag across your text and edges.
If the two sides match, your pipeline is clean and the blur lives somewhere else (more on that below). If they don’t, you’ll see precisely what the platform ate, and you can decide whether it matters for what you’re sharing. I ran this on a screenshot the first time mostly to prove myself wrong, and the roundtrip had softened every letter edge in the image while leaving the photo areas looking fine. Which is exactly why casual photos survive and comparisons die.
One rule for the test itself: the comparison tool must not add its own compression, or you’re measuring two platforms at once. imgi serves your exact uploaded bytes, no re-encoding, which is the reason it works as the reference side of this experiment.
The fixes, in order of effort
Resize before you upload. If the platform is going to scale your 4K screenshot down to fit a feed, do the scaling yourself in a proper editor first. Your downscale, done once with a decent filter, beats a platform’s fast-path resize, and a file that already fits the layout is less likely to trigger aggressive processing at all.
Use PNG where text matters. Lossy formats and re-encoders are hardest on exactly what screenshots need most. The format guide covers the tradeoffs, but the short version for text and UI is: start lossless, because you don’t control what happens downstream.
Share a link instead of an upload when quality is the point. This is the structural fix. An image attached to a post belongs to the platform’s pipeline. An image behind a link belongs to whoever hosts it. For anything where pixel fidelity is the argument, a graphics comparison, an upscale test, texture work, upload the originals to imgi and post the link; viewers get the exact bytes, and the platform only ever touches the link preview. For a pair of images, you get a draggable before and after instead of two attachments, which usually makes the point better anyway.
For animations, pick the format by destination. Animated comparisons have their own compatibility maze, and the GIF versus MP4 guide maps it.
When it isn’t the platform
An honest detour, because sometimes the blur is homemade. Check these before blaming the pipeline:
- Browser or OS zoom. A page at 110% zoom renders every image slightly resampled. Check that you’re viewing at 100%, and use any built-in actual-size control when you’re judging sharpness.
- High-DPI mismatch. A 1920-wide screenshot viewed in a smaller layout slot gets scaled by your own screen setup before any platform touches it.
- Screenshots of screenshots. Cropping a screenshot out of another screenshot, or saving an image out of a chat and re-posting it, adds a generation of processing per hop. Each hop looks fine. Three hops don’t.
- The source was soft to begin with. Comparing your memory of a scene against the file is how a lot of imaginary platform blur gets diagnosed. The slider test above catches this too, since the roundtrip will come back identical.
The habit that ends the problem
Keep originals, share links to originals, and attach copies only where convenience beats fidelity. It costs nothing, and it holds no matter what any platform’s pipeline decides to do next quarter.