A screenshot looks perfectly crisp on your machine and noticeably soft the moment anyone else sees it. Four separate mechanisms cause this, they compound, and each has a specific fix. This page covers all four and how to tell which one is affecting you.
The two rules that fix most cases
Save as PNG, never JPEG — text is exactly the content JPEG handles worst. And display at 100% or exactly 50% of the captured size. Any other scale forces resampling, and resampling softens edges.
Retina capture at 2x
A high-density display packs two physical pixels into each logical one. Screen capture records physical pixels, so a screenshot of a window that measures 1440 logical points across is a 2880-pixel-wide image.
This is genuinely good — you have double the detail. The problem is what happens next. Display that 2880-pixel image at exactly 1440 and every group of 2×2 pixels collapses cleanly into one, giving a sharp result. Display it at any other width and the resampler must compute values that fall between the original pixels, and every hard edge softens.
Documents, chat applications and content management systems routinely resize images to fit a fixed column width — 800 pixels, 1200 pixels, whatever the layout uses. Those numbers essentially never work out to exactly half of your capture.
💡 Why exactly 50% is special
At 50%, each output pixel is the average of exactly four input pixels, in perfect alignment. Nothing has to be estimated. At 47% or 63%, output pixels straddle input pixel boundaries, so each one is a weighted blend of partial neighbours — which is precisely what "blurry" looks like. Integer ratios are sharp; everything else is a compromise.
Capturing at the size you need
Fractional display scaling
Windows commonly runs at 125%, 150% or 175% scaling. These are not whole numbers, and that creates a problem the operating system cannot fully solve.
Applications that declare themselves scaling-aware render directly at the target size and look correct. Applications that do not are rendered at 100% and then bitmap-stretched by the system — the same resampling blur as above, applied before you take the screenshot. The capture is faithfully recording a blurry rendering.
| Scaling | Ratio | Sharp? |
|---|---|---|
| 100% | 1.00 | Yes |
| 125% | 1.25 | Blurry in unaware apps |
| 150% | 1.50 | Blurry in unaware apps |
| 175% | 1.75 | Blurry in unaware apps |
| 200% | 2.00 | Yes — integer |
For screenshots destined for documentation, the most reliable answer is to capture on a display running at 100% or 200%. Anything in between will show the problem in at least some applications.
JPEG on text — the worst combination
This is the most common cause and the easiest to fix.
JPEG compresses by transforming 8×8 blocks into frequency components and discarding the high-frequency ones — the fine detail. That works beautifully for photographs, where tone changes gradually and the discarded detail is close to noise.
Text is the opposite kind of image. A letter's edge is a near-instantaneous jump from black to white, which is pure high frequency — exactly what JPEG throws away. The result is ringing: faint ripples radiating from every edge, and coloured fringes around dark text on light backgrounds.
| Content | Best format | Why |
|---|---|---|
| Interface screenshots | PNG | Lossless; flat colour areas compress extremely well |
| Text and code | PNG | Hard edges preserved exactly |
| Diagrams and charts | PNG or SVG | Same reasoning; SVG is resolution-independent |
| Photographs in a screenshot | PNG, or WebP | PNG is larger but the text stays clean |
| A screenshot that is mostly photo | JPEG q90+, or WebP | Only when there is little text |
The counter-intuitive part: PNG is often smaller than JPEG for screenshots. PNG compresses runs of identical pixels efficiently, and an interface screenshot is largely flat colour — toolbars, backgrounds, panels. JPEG has to encode the compression noise it introduced, so it can end up larger while looking worse.
🚨 Generational loss
Every JPEG save re-compresses. Screenshot → paste into a document → export → upload → the platform re-encodes: each step adds artefacts to the artefacts of the previous one. Text that started crisp becomes visibly mushy after four or five hops, and no step is individually obvious.
Keep the PNG original. If a JPEG is needed, produce it once at the end from the original, never from another JPEG.
What platforms do to your uploads
| Destination | Typical treatment |
|---|---|
| Slack | Preserves the original; the preview is a compressed thumbnail |
| Word / Google Docs | May re-compress on export depending on settings |
| Heavily compresses and resizes — send as a document instead | |
| Most CMS platforms | Resize to a maximum width, often convert to JPEG |
| Social platforms | Always re-encode to their own settings |
| Usually preserved as an attachment; inline images may be resized |
The practical implication: if a screenshot must stay legible, upload it at the size it will be displayed, so the platform has no reason to resize it. Sending a 2880-pixel image into a 700-pixel column guarantees a resample.
Resizing without destroying it
When you must resize, the resampling algorithm matters as much as the ratio.
| Algorithm | Best for | Effect on text |
|---|---|---|
| Nearest neighbour | Pixel art, integer scaling | Perfectly sharp, but jagged at non-integer ratios |
| Bilinear | Fast general use | Soft |
| Bicubic | Photographs | Softer, slight ringing |
| Lanczos | High-quality downscaling | Sharpest for text |
| Box / area | Exact integer reduction | Ideal at exactly 50% |
✅ Never upscale a screenshot
Enlarging adds pixels but no information — the resampler invents intermediate values, and text becomes visibly soft-edged. If a screenshot is too small, retake it: zoom the application, increase its font size, or capture on a higher-resolution display. There is no processing step that recovers detail that was never captured.
Capturing for documentation
- Capture on a 100% or 200% display. Fractional scaling blurs before you begin.
- Zoom the content rather than enlarging the image. Increase the application's font size or browser zoom, then capture — real pixels beat interpolated ones.
- Capture only what matters. A tight crop needs no downscaling to fit a column.
- Save as PNG. Always.
- Match the display width. Capture or downscale to what the layout will use so nothing resamples it again.
- Keep the originals. Layouts change and you will need to re-export.
- Check at 100% zoom in the final destination, not in your image editor.
Browser screenshots at a chosen resolution
This gives exact, reproducible dimensions — which matters for documentation that will be regenerated, because every screenshot then matches without manual work.
Need to crop or resize a screenshot?
Crop to an exact region or resize to precise dimensions in your browser — no upload, no re-compression you did not ask for.
Open the Image Cropper →Summary
- Retina captures are 2x. Display at 100% or exactly 50%; anything else resamples.
- Fractional Windows scaling blurs unaware applications before capture. Use 100% or 200%.
- Always PNG for text. JPEG discards exactly the frequencies that make edges sharp.
- PNG is often smaller than JPEG for interface screenshots.
- Every re-save compounds artefacts. Keep the original and export once.
- Use Lanczos or Box when resizing, not the default bilinear.
- Never upscale. Retake at a larger size instead.
- Upload at display size so the platform has no reason to resize.
Frequently Asked Questions
Why do my Mac screenshots look blurry when I share them?
They are captured at twice the logical resolution, so a screenshot of a 1440-point-wide window is a 2880-pixel image. Displayed at half size it is razor sharp; displayed at any other scale the viewer must resample and everything softens. Sharing tools that resize to fit a fixed width almost never land on exactly 50%.
Should screenshots be PNG or JPEG?
PNG, always. JPEG is designed for photographs, where gradual tonal change hides its artefacts. Text and interface elements are made of hard edges, which is precisely what JPEG handles worst — it produces visible ringing and colour fringing around every letter. PNG is lossless and usually smaller for this kind of content anyway.
Why are my Windows screenshots blurry at 125% scaling?
Fractional scaling means one logical pixel maps to 1.25 physical pixels, which is not a whole number. Applications that are not scaling-aware are rendered at 100% and then stretched by the system, which resamples across pixel boundaries and blurs everything. A screenshot faithfully captures that already-blurred rendering.
How do I resize a screenshot without losing sharpness?
Scale by exact integer fractions — 50%, 25% — and use nearest-neighbour or a sharp resampling filter rather than the default smooth one. Any other percentage forces the resampler to invent pixel values that fall between the originals, which is what softens edges.
Why does my screenshot look worse after uploading it?
The platform re-encoded it. Most sites convert uploads to JPEG at a fixed quality regardless of what you sent, and many also resize to a maximum width. A pristine PNG becomes a re-compressed, resized JPEG, and text is the content type that suffers most from both operations.