Enlarge photos 2x or 4x on your device — nothing gets uploaded
Drop an image here or click to choose
JPG, PNG, or WebP · upscaled on your device
| Input | Scale | Output | Megapixels | Print size @ 300 dpi |
|---|---|---|---|---|
| 800 × 600 | 2x | 1600 × 1200 | 0.48 → 1.92 MP | 5.33 × 4 in |
| 4x | 3200 × 2400 | 0.48 → 7.68 MP | 10.67 × 8 in | |
| 1024 × 768 | 2x | 2048 × 1536 | 0.79 → 3.15 MP | 6.83 × 5.12 in |
| 4x | 4096 × 3072 | 0.79 → 12.6 MP | 13.65 × 10.24 in | |
| 1920 × 1080 | 2x | 3840 × 2160 | 2.07 → 8.29 MP | 12.8 × 7.2 in (exact 4K UHD) |
| 640 × 640 | 4x | 2560 × 2560 | 0.41 → 6.55 MP | 8.53 × 8.53 in |
Print math is just division: a 1600-px edge at 300 dots per inch is 1600 ÷ 300 = 5.33 inches. Two upscalings don't stack — running 2x twice is not 4x quality; the model invents less plausible detail the further it's pushed from real data. When you need 4x, do it in one pass.
When an editor enlarges a photo, it interpolates: new pixels are weighted averages of their neighbors. It's mathematically correct and visually soft — edges smear, text goes gray. Super-resolution models attack the same job with learned priors instead of averages.
This tool runs esrgan-slim, an ESRGAN-family generator from UpscalerJS (MIT, by Kevin Scott), trained on DIV2K photo pairs. It executes as a TensorFlow.js graph in 64-pixel patches with a 2-px overlap so seams don't show, reconstructed edge by edge. The weights are deliberately small — under a megabyte — which is what makes a browser version viable at all; the trade is a slight softness compared to multi-gigabyte desktop models.
Drop an image, pick 2x for quality or 4x for size, and upscale. The first run downloads the model (under 1 MB) and the TensorFlow.js runtime; after that, everything is cached. Large inputs are capped — about 2000 px on the long side for 2x, 1200 px for 4x — because the output is held uncompressed in memory and a 4x of a big photo can exhaust a browser tab.
Start with an 800×600 web graphic: 480,000 pixels, 0.48 megapixels. At 2x the model emits 1600×1200 — 1,920,000 pixels, four times the pixel count, because both dimensions double. Printed at 300 dpi that's 1600÷300 = 5.33 inches wide and 1200÷300 = 4 inches tall: a clean 5×4 photo. Push to 4x and you get 3200×2400 = 7,680,000 pixels (7.68 MP, sixteen times the original), printing at 10.67×8 inches — a full letter-size page with margin to spare.
The other classic case: a 1920×1080 screenshot upscaled 2x lands on exactly 3840×2160, 4K UHD, pixel for pixel. That's not a coincidence — 4K was defined as double HD in each dimension, which is precisely what a 2x model produces.
2x doubles each dimension — 800×600 becomes 1600×1200, which is 4 times the pixels. 4x quadruples each dimension to 3200×2400, 16 times the pixels. Use 2x when you need a modest enlargement with the best quality (smaller jumps are easier for the model); use 4x when you genuinely need the size, like printing a 10.7×8 inch page at 300 dpi from a small photo.
Partly. A super-resolution model reconstructs plausible detail as it enlarges — edges firm up, textures regain definition — but it can't recover information that was never captured. A photo that's blurry from motion or missed focus improves modestly; a photo that's blurry because it was 80 pixels wide to begin with gains smoothness, not new detail. Upscaling works best on images that are sharp but small.
A normal resize interpolates: it spreads the existing pixels over more space and fills the gaps with mathematical averages, which looks soft. A super-resolution model (ESRGAN, in this tool) is trained on pairs of small and large images, so it predicts what missing detail should look like — straight lines stay straight, text edges stay crisp. The difference is obvious on hard edges and much subtler on smooth gradients like skies.
Yes, and text is where super-resolution shows its biggest advantage over plain resizing, because letterforms are exactly the kind of structured detail the model reconstructs well. A 2x pass on a small screenshot usually returns clearly readable text where bicubic resizing returns gray mush. Very low-resolution text (under about 10 pixels of character height) is past what a 1 MB browser model can save.
No. The model weights (867 KB for 2x, 912 KB for 4x) and the TensorFlow.js runtime load once from a CDN, then everything — decoding, the neural network pass, PNG encoding — happens in your browser using WebAssembly. You can verify it in the network panel: no request ever contains your image.
Memory. Every extra pixel multiplies through the network in 64-px patches, and the output image is held uncompressed in RAM — a 4x upscale of a 2000-px photo is roughly 92 MB of raw pixel data before the PNG is even encoded. The cap (about 1200 px on the long side for 4x, 2000 px for 2x) keeps the tab responsive instead of crashing it.