Watermark removal isn't lossy — you've been using the wrong tool

KatySwift — Sun, 05 Jul 2026 09:36:57 +0000

Ask anyone who has tried to remove a watermark from an image and they'll tell you the same thing: you don't get the original back. You get something close. There's a soft, smeared patch where the mark used to be, and if you look at it straight on, you can always tell.

That belief is correct almost every time. It's also the reason a whole category of watermark removal gets done the wrong way.

For one specific kind of watermark — the visible logo Gemini stamps into the corner of its images — you can get the original back. Not a close approximation but the actual pixel values, the ones they held before the mark was ever applied, recovered without a model, without an upload, and without guessing at anything.

The trick is that "removing a watermark" turns out to be two completely different problems wearing the same name.

The word "lossy" is hiding an assumption

When people say watermark removal is lossy, here's the unstated logic underneath:

The watermark covers up part of the photo. Whatever was under it is gone. So removing the watermark means reconstructing the missing part — filling the hole with a best guess.

That logic is airtight, and for most watermarks it's exactly right. If a mark truly destroyed the pixels underneath, then yes, your only option is to invent replacements that look plausible. That's a guess, and a guess is lossy by definition.

But notice what the whole argument rests on: the idea that the pixels underneath are gone.

For a Gemini watermark, they're not gone. They're just mixed.

Nobody's AI painted that logo

Here's the part that trips people up. The image came out of an AI model, so the instinct is that everything about it — including the watermark — is some inscrutable AI thing that needs an equally inscrutable AI thing to undo.

The watermark isn't AI. After the model finishes generating the picture, a plain, deterministic step pastes the logo on top. It's the same alpha compositing that has been in every graphics stack since the 1980s:

watermarked = α · logo + (1 − α) · original

For each pixel the logo touches, the final value is a weighted blend of the logo's color and the original photo's color. α (alpha) is how opaque the logo is at that pixel — 0 means fully transparent, 1 means fully opaque.

Read that formula again with the "lossy" assumption in mind. The original pixel is still in there. It wasn't painted over and thrown away. It was added to the logo, with a known weight. Addition has an inverse.

If it was added, subtract it

Solve the same equation for the thing you actually want:

original = (watermarked − α · logo) / (1 − α)

That's it. That's the whole idea. If you know three things — the final watermarked pixel (you have it), the logo's color (fixed and knowable), and the alpha at that pixel — you can recover the original exactly — no reconstruction, no plausible guess, just arithmetic.

This is why the "close but smeared" outcome doesn't apply here. A smear happens when a tool paints over the region because it thinks the data is gone. This tool doesn't paint. It reverses a calculation that was run in the forward direction a moment earlier.

The catch is the alpha map

There is a catch, though — two of them — and skipping over them would turn this into a sales pitch.

The formula needs α for every pixel, and the logo doesn't ship with its alpha values attached. So you have to recover them first.

The way to do it is almost embarrassingly direct: take the watermark as it appears over a known solid background — a flat color you fully control — and work backward from the blend to figure out how opaque the logo is at each point. Once you've built that alpha map once, it's the same map every time, because Gemini applies the same logo the same way. You measure it once and reuse it forever.

The second catch is the one the "lossless" claims tend to skip over.

Look at the denominator: (1 − α). When the logo is nearly opaque — α close to 1 — you're dividing by a number close to zero. In those pixels the original barely contributed to the blend in the first place, so there's almost nothing left to recover, and the division amplifies whatever tiny errors exist. Where the logo is fully opaque, the original really is gone, and no formula brings it back. Honesty demands saying that out loud.

Add to that the fact that these images are stored in 8 bits per channel. The forward blend already rounded to whole numbers once, which means a sub-pixel of precision was thrown away before you ever got the file. Reversing the math can't un-round it.

So the accurate claim isn't "flawless, always." It's this: across the vast majority of the watermarked region, where the logo is semi-transparent, you get the original pixel back with zero meaningful loss. Only in the small, fully-opaque core is anything actually unrecoverable. That is a categorically different result from a smear across the whole patch — and it's why the "removal is lossy" rule of thumb quietly breaks here.

You have to find the watermark before you touch a pixel

One more piece before the math can run: you need to know where the logo sits, and you can't just trust that it's in the corner. Get the position wrong and you'll happily subtract a logo from a patch of sky that never had one.

A reasonable pipeline does this in stages, cheap checks first:

// 1. Catalog lookup — Gemini emits a small set of known sizes,
//    each with a fixed watermark size and margin.
const candidate = sizeCatalog.match(image.width, image.height);
if (!candidate) return { applied: false }; // not a shape we recognize

// 2. Local anchor search — scan a small region around the
//    expected spot to lock onto the logo's exact offset.
const position = findAnchor(image, candidate.expectedRegion);

// 3. Validation — actually run the reverse blend on that region
//    and check the result is sane before trusting it. This is
//    what stops false positives on images that only look similar.
const restored = reverseAlphaBlend(image, position, alphaMap);
if (!looksRestored(restored)) return { applied: false };

return { applied: true, image: restored };

The validation step is the one that matters most for not lying to the user. It's the difference between "I removed the watermark" and "I mangled a corner of your photo because the dimensions happened to match." If the reverse blend doesn't produce something coherent, the honest move is to report that nothing was done.

It runs in the browser, and nothing leaves it

Because this is arithmetic over a pixel array and not a model inference, there's no reason to send the image anywhere. It decodes into an ImageData buffer via the Canvas API, the math runs over a typed array right there on the page, and a PNG comes back out. No server, no upload, no queue. The whole thing is a few hundred kilobytes of JavaScript.

That's a nice side effect of picking the right tool. The "AI must undo AI" framing would have pushed you toward a hosted model and an upload, for a job that a formula does locally and better.

When you genuinely do need the model

This is the boundary, and it's worth being precise about it, because the point of this article is not "AI is overkill for everything." It's "match the method to the mark."

Reverse alpha blending works when the watermark was blended on top — a known logo, a known compositing step, pixels that were mixed rather than destroyed. Push outside that and it stops applying:

Fully opaque marks over the content — nothing was mixed, so there's nothing to unmix.
Invisible / steganographic watermarks like SynthID, which are woven into the image statistics rather than pasted on top. Subtraction has nothing to grab onto.
Arbitrary objects, text, or logos on a real photo, where there is no known blend formula and the stuff underneath truly is missing.

That last case is the one everyone pictures when they hear "watermark removal," and it is genuinely lossy — because there, you really are reconstructing missing content, and reconstruction means an educated guess. That's the job diffusion-based inpainting was built for, and if you want the counterpart to this article — how a model fills a hole when the pixels really are gone — I wrote a visual walkthrough of how AI inpainting actually works.

The two approaches aren't competitors. They answer different questions. One reverses a known operation. The other invents a plausible one. Using the guessing tool on a problem that has an exact answer is how you end up believing all removal is lossy.

Try it, and read the source

The reverse-alpha approach for Gemini is open source — the algorithm, the size catalog, the detection stages, all of it: gemini-watermark-remover on GitHub (itself a JavaScript port of Allen Kuo's original tool).

If you just want to run it on an image without touching code, there's a browser-based Gemini watermark remover that does exactly the pipeline above — local, no upload, and it tells you when the mark isn't one it can reverse instead of quietly smearing it.