Every resize is a guess about pixels that don’t exist

A digital image is a grid of samples — pixels — not a continuous picture. When you ask for 800 pixels where 4000 used to be, or 4000 where 800 were, something has to decide what color each new pixel should be. That decision procedure is the resampling filter, and the filter you use is the difference between “crisp resize” and “why is this blurry”.

The four filters you’ll actually meet

Nearest-neighbor is the brute: each output pixel copies the closest input pixel. Zero blur, but also zero blending — diagonal lines turn to staircases, and shrinking skips pixels entirely (a 2-pixel-wide line can vanish). Use it for pixel art and flat UI graphics where you want hard pixels. Never for photos.

Bilinear averages the 4 nearest pixels weighted by distance. Fast, smooth, and soft — fine for thumbnails and previews, visibly mushy for big reductions because it only ever looks at 4 of the available samples.

Bicubic averages 16 pixels with a cubic weighting curve. It’s the default in Photoshop, GIMP, and the high-quality canvas path this site uses (imageSmoothingQuality: 'high'). Slightly sharper than bilinear down, slightly softer up — the all-rounder.

Lanczos (sinc-based) looks at a larger neighborhood still and preserves the most edge contrast. The trade-off is ringing: faint halos on hard edges, visible on text and line art. For photographs it’s often the best choice; for graphics with sharp edges it can look worse than bicubic.

Downscaling: the aliasing trap

Shrinking seems safe — you’re throwing information away, not inventing it. But throw it away naively and you get aliasing: fine repetitive detail (fabric weave, roof tiles, hair) folds into moiré patterns and shimmer, because the sampler can’t tell a pattern from noise once the spacing drops below the new pixel grid.

The fix is that good filters effectively blur before discarding — averaging enough of the neighborhood that high-frequency patterns wash out instead of folding back. Practical rules:

• Down to 50–75%? Any decent filter does well; differences are subtle.
• Beyond ~4× reduction (e.g. 6000→800px), resize in two steps — 6000→2400, then 2400→800 — so each stage averages enough neighbors to prevent shimmer.
• Sharpen last. Downscaling softens micro-contrast; a light unsharp mask after the final size restores snap. Do it at output size, never before.

Upscaling: where the blur comes from

Enlarging is the inverse problem: you need pixels that were never sampled. Every classical filter interpolates — it fits a smooth curve through the known pixels and reads off the gaps. Smooth curves mean smooth edges, and smooth edges read to your eye as blur.

Rough guide for classical resampling (bicubic/Lanczos):

• Up to ~110–125%: invisible at arm’s length. Safe.
• 125–150%: soft but usable for web; sharpen lightly after.
• 150–200%: clearly soft; acceptable only for backgrounds or low-detail shots.
• Beyond 200%: classical filters are done — this is AI-upscaler territory (waifu2x, Real-ESRGAN, Topaz), which hallucinate plausible detail instead of interpolating.

When NOT to upscale goes deeper on the cases where enlarging is the wrong tool entirely — and what to do instead.

One more silent variable: the color space

Most filters run on the raw sRGB-encoded values, which aren’t linear in brightness. Averaging encoded values slightly darkens midtones and can shift saturated edges — usually invisible, occasionally visible on graphics with large saturated areas. If a resized logo looks subtly off-color, this is why; professional tools offer “linear-light” resampling for exactly this reason. For photos at normal sizes, don’t lose sleep over it.

Frequently asked questions

Which resampling algorithm does this tool use?

The browser's high-quality canvas resampler — a smooth interpolation comparable to bicubic. For downscaling photos it is effectively indistinguishable from Lanczos at normal viewing sizes; for enlarging, no algorithm can invent detail that isn't there, which is why we recommend staying under ~150%.

Why do resized screenshots look worse than resized photos?

Screenshots and UI graphics have hard edges — a 1px line either exists or doesn't. Smooth interpolators (bilinear, bicubic) blend edges into gray fuzz, and Lanczos can ring around them. For pixel-art or flat UI, nearest-neighbor downscale to an exact fraction (½, ¼) or re-render at the target size instead of resampling.

Is bicubic or Lanczos better for downsizing photos?

Lanczos keeps slightly more micro-contrast; bicubic is a touch smoother. In practice the difference at 50–75% reduction is subtle — sharpening after downscale matters more. For reductions beyond ~4×, downsize in two steps (e.g. 4000→2000→1000) to avoid aliasing shimmer.

Why does a 50% resize look sharper than the original?

Because it is — per pixel. Downscaling averages noise and small defects away, and the lens/sensor limits of the original shot get compressed below visibility. This is the 'downsampled sharpness' effect reviewers exploit when they show phones beating dedicated cameras at web sizes.