Remove a Watermark Without Losing Quality: Does the Resolution Survive? (Tested)
Yes — removing a watermark in this tool does not shrink, downscale, or blur your image. It runs entirely in your browser, processes the photo at its exact native pixel size, and exports a PNG at the same dimensions. We confirmed this two independent ways: first by reading the app's own code (it reads img.naturalWidth × naturalHeight and builds a canvas of that size), and second by running the same Telea inpainting engine the browser tool uses on a 12-megapixel and a 24-megapixel image. Both came back at full resolution, and every pixel outside the area you painted was byte-for-byte identical to the original (PNG round-trip difference = 0). The only thing that changes is inside the mark you removed — that region is reconstructed by inpainting, which is the removal itself, not a quality downgrade of the rest of the photo. So a 4K photo stays 4K.
How we checked it (source code + a real run)
We didn't take the marketing line on faith. The tool is a static client-side page, so its behavior is readable in the source. Two facts from app.js settle the resolution question before we even ran anything:
- It never downscales on load. On upload it sets
W = img.naturalWidth; H = img.naturalHeight;thenview.width = W; view.height = H; ctx.drawImage(img, 0, 0);(app.js lines 32–35). The working canvas is built at the image's own pixel size. - It outputs at that same size. After inpainting, the result is handed back as
new ImageData(new Uint8ClampedArray(buf), W, H)(lines 245–246) — same width, same height, no resize step anywhere.
To prove the engine behaves that way in practice, we ran the identical Telea fast-marching algorithm (app.js line 110 names it “Telea's Fast-Marching Method”) on two photo-like test images and measured the output against the input. Every number below is from that run.
Finding 1: the resolution is preserved exactly
We fed the engine a 4000×3000 image (12 megapixels, a typical 4K-class photo) and a 6000×4000 image (24 megapixels). The output dimensions matched the input to the pixel — nothing was scaled down to fit a limit.
| Input image | Input size | Output size | Dimensions preserved? |
|---|---|---|---|
| 12 MP photo | 4000×3000 | 4000×3000 | Yes |
| 24 MP photo | 6000×4000 | 6000×4000 | Yes |
This is the opposite of what many server-side “free” removers do: those re-encode and often cap width (e.g. 1000–2000 px) to save bandwidth. A client-side tool has no reason to, and this one doesn't.
Finding 2: untouched pixels are byte-identical
Inpainting only fills the region you paint. We compared the result to the original pixel by pixel, excluding the painted area. The untouched pixels were unchanged — a mean difference of 0.0, with the single largest channel difference being 1 (and that 1 sits on the 1-pixel boundary we added to the mask, not inside the photo). We also re-loaded the exported PNG and compared it to the result: difference = 0. The default export is genuinely lossless.
| Input image | Untouched pixels | Max channel diff vs original | Mean diff | PNG round-trip diff |
|---|---|---|---|---|
| 12 MP | 11,960,857 | 1 (mask edge only) | 0.0 | 0 |
| 24 MP | 23,916,971 | 1 (mask edge only) | 0.0 | 0 |
Inside the painted mark, ~100% of pixels were changed — that is the watermark being removed, exactly what you asked for. The point is that everything around it is preserved perfectly.
The honest trade-off: only the mark is rebuilt
“No quality loss” means two different things, and we want to be precise. The tool does not lose resolution or recompress the parts you didn't touch. But the pixels under the watermark are a reconstruction, not the original content — inpainting invents a plausible fill. On a plain background that fill is nearly invisible; on a busy, detailed area it can leave a soft patch that a forensic check can spot (we measured this in our detection test). So the resolution is intact; the information inside the removed mark is gone and approximated. That is true of every inpainting tool, not a flaw unique to this one.
Practical ceiling: how big can the photo be?
The app's own code warns when an image gets very large: if (W * H > 40000000) it shows “Image is very large; processing may be slow or limited by browser memory” (app.js line 33). That is about 40 megapixels — roughly an 8000×5000 photo. Below that, processing is normal. Above it, speed and success depend on your machine and your browser's canvas limits, not on the tool imposing a downscale. In our test both the 12 MP and 24 MP cases ran and exported at full size with no quality step-down.
Output format: keep it PNG for fidelity
The export line reads var type = fmt.value === 'jpeg' ? 'image/jpeg' : 'image/png'; (app.js line 255). The default is PNG, which is lossless — that is why our round-trip difference was 0 and untouched pixels survived exactly. If you switch the format selector to JPEG, the whole image, including the pristine untouched areas, is recompressed with ordinary JPEG quality loss. For any work where you care about fidelity, leave it on PNG and only convert to JPEG later if a destination requires it.
- Paint tightly. A smaller mask means less reconstructed area and a smaller, cleaner edit.
- Stay on PNG. The default export keeps every untouched pixel perfect; JPEG would recompress them.
- Know the ceiling. Up to ~40 MP processes normally; far beyond that, your browser's memory, not the tool, sets the limit.
- The mark is gone, not recovered. Resolution is preserved; the content under the mark is approximated — keep the original if you ever need to prove what was there.
For the mechanics on specific surfaces, our text test, logo test, and product-photo test show how the same engine behaves on captions, logos, and supplier marks.
FAQ
Does removing a watermark lower the image resolution? No. The tool processes the photo at its native pixel size and exports at the same size. We verified 4000×3000 in → 4000×3000 out, and 6000×4000 → 6000×4000.
Will my untouched pixels change? No. Outside the painted region, the result is byte-identical to the original (PNG round-trip difference = 0; mean per-pixel difference 0.0).
Does it recompress the photo? Not by default. The default export is lossless PNG. Only if you choose JPEG does the whole image get JPEG compression.
What is the largest photo it handles? Normal up to about 40 megapixels (the app's own notice threshold); beyond that, browser memory and canvas limits decide, not a forced downscale.
Is the watermark area still ‘original’? No — that region is reconstructed by inpainting. The resolution is intact, but the underlying content there is approximated. That is the removal, and it is true of every inpainting tool.