DEV Community: Yu Robin

How AI Removes Watermarks From Images — A Developer's Guide to Image Inpainting

Yu Robin — Thu, 30 Jul 2026 13:53:02 +0000

If you've ever uploaded a photo to an online tool and watched a watermark vanish in seconds, you've seen image inpainting at work. It looks like magic: a semi-transparent logo sitting on top of a sky, a face, or a product shot simply… disappears, and the pixels underneath look convincingly reconstructed.

This post breaks down what's actually happening under the hood. We'll cover the progression from classical pixel-filling to modern deep-learning approaches, look at real code, and discuss the engineering tradeoffs you'll hit if you build (or integrate) one of these systems yourself.

Quick note on ethics: Watermark removal has legitimate uses — cleaning up your own assets, restoring old scanned photos, removing your own branding from drafts, processing images you have rights to. Removing watermarks to use someone else's copyrighted work without permission is not one of them. Treat the techniques below as you would any image-editing capability.

The core problem: it's not "removal", it's "reconstruction"

A watermark isn't a layer you can peel off. Once an image is rasterized, the watermark's pixels are baked into the underlying image. "Removing" it really means:

Detecting where the watermark pixels are (producing a mask).
Reconstructing what the image probably looked like underneath those masked pixels.

Step 2 is the hard part, and it's a classic computer-vision problem called inpainting — filling in missing or corrupted regions of an image using clues from the surrounding pixels.

┌──────────────┐      ┌──────────────┐      ┌──────────────┐
│  Input image │  →   │  + Mask of   │  →   │  Inpainting  │  →  Clean image
│  (with mark) │      │  watermark   │      │   model      │
└──────────────┘      └──────────────┘      └──────────────┘

So an "AI watermark remover" is really two problems chained together: segmentation (find the mark) and inpainting (fill the hole). Let's look at how each evolved.

Step 1 — Producing the mask

You need a binary mask telling the inpainting model which pixels to replace. Depending on the watermark, there are a few strategies:

Manual or UI-assisted masking

For a consumer tool, the user paints over the watermark with a brush. Simple and reliable — you don't need to detect anything, the user tells you exactly where to work. This is what most "brush and erase" editors do.

Template matching (for a known, repeated logo)

If the same watermark is stamped repeatedly (think a stock-photo site's diagonal pattern), you can extract one instance as a template and use normalized cross-correlation to find all occurrences:

import cv2
import numpy as np

img = cv2.imread("watermarked.png", cv2.IMREAD_GRAYSCALE)
template = cv2.imread("logo_patch.png", cv2.IMREAD_GRAYSCALE)

res = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)
threshold = 0.8
loc = np.where(res >= threshold)

mask = np.zeros_like(img)
h, w = template.shape
for pt in zip(*loc[::-1]):
    mask[pt[1]:pt[1]+h, pt[0]:pt[0]+w] = 255   # mark the region to inpaint

This is fast and deterministic, but it only works when you already know the watermark's exact appearance.

Learned segmentation

For arbitrary watermarks — text overlays, varied logos, signatures — a small segmentation model (U-Net or similar) trained on (watermarked image, mask) pairs is the flexible answer. The harder case is translucent watermarks, where the mark is a blend of a color and the background. A good mask then carries per-pixel opacity rather than just on/off, which the inpainter can use to subtract the watermark color rather than blindly overwriting.

Step 2 — Filling the hole: the inpainting evolution

The classical era: diffusion and patch-based

OpenCV still ships two classic algorithms via cv2.inpaint:

Telea (Fast Marching Method) — propagates from the boundary inward. Great for thin scratches and small dots.
Navier-Stokes — treats the region as a fluid-flow problem, carrying edge information into the hole.

# radius 3 — works for thin scratches / small spots
result = cv2.inpaint(img, mask, 3, cv2.INPAINT_TELEA)

These are instant and need no GPU, but they fall over for large regions. They blur across big gaps and ignore global structure. For a 200×80 logo slapped across a textured background, they produce obvious smears.

Patch-based methods (PatchMatch, used by Photoshop's Content-Aware Fill) did much better by copying similar patches from elsewhere in the image. But they assume the missing content exists somewhere in the frame — true for grass or sky, false for a face half-covered by a watermark.

The deep-learning era

This is where results started looking like actual reconstruction. A few milestones worth knowing:

Method	Key idea	Strength
Context Encoders (2016)	First CNN encoder-decoder for inpainting	Learned global context
Partial Convolutions (2018)	Convolutions that ignore masked pixels	Clean boundaries, no color bleed
Gated Convolutions (2019)	Learned soft gating per layer	Handles irregular masks better
LaMa (2021)	Fast Fourier convolutions → huge receptive field	State-of-the-art quality, fast
Diffusion-based (2022+)	Iterative denoising conditioned on context	Spectacular, but slow

The reason a watermark sitting across a complex region (a reflection, a patterned shirt) can be filled convincingly is that these models have learned a strong prior of what natural images look like. Given the surrounding context, they hallucinate a plausible continuation. It may not be the exact original pixel — but it's usually perceptually close enough that you can't tell.

A closer look: Partial Convolutions

The breakthrough insight in partial convolutions is elegant. A regular convolution slides a kernel over the image and blends everything under the kernel — including masked (invalid) pixels you told it to ignore. That's why naive CNN inpainting bleeds watermark color outward.

A partial convolution instead computes its output from valid (unmasked) pixels only, and renormalizes:

import torch
import torch.nn as nn
import torch.nn.functional as F

class PartialConv(nn.Module):
    def __init__(self, in_ch, out_ch, kernel_size, padding=0):
        super().__init__()
        # weight is frozen to all-ones; only the conv learns
        self.input_conv = nn.Conv2d(in_ch, out_ch, kernel_size, padding=padding)
        self.mask_conv = nn.Conv2d(in_ch, out_ch, kernel_size,
                                   padding=padding, bias=False)
        with torch.no_grad():
            self.mask_conv.weight.fill_(1.0)
        self.mask_conv.weight.requires_grad = False

    def forward(self, x, mask):
        # mask: 1.0 for valid pixels, 0.0 for holes
        output = self.input_conv(x * mask)
        with torch.no_grad():
            mask_sum = self.mask_conv(mask)          # count of valid pixels in window
            valid_window = self.mask_conv.weight.numel()  # total pixels in kernel
            new_mask = (mask_sum > 0).float()

        # renormalize so the output only depends on valid pixels
        norm = valid_window / mask_sum.clamp(min=1e-8)
        output = output * norm
        return output, new_mask

The mask shrinks layer by layer (a hole gets "eaten" from the edges), and at every step the network only ever mixes information it was actually allowed to see. The result: no color bleeding from the watermark into the repaired region.

A closer look: LaMa

LaMa (Large Mask inpainting) is the workhorse you'll reach for first, because it hits the sweet spot of quality and speed. Its secret sauce is Fast Fourier Convolutions (FFC): instead of convolving only in the spatial domain, FFC mixes information in the frequency domain, giving each layer an essentially global receptive field with the first layer.

Why does that matter for watermarks? A watermark often spans a large chunk of the image. A regular CNN needs many stacked layers before its receptive field grows large enough to "see" the whole mark at once. FFC sees the whole thing immediately, which is why LaMa reconstructs repeating structures and long lines (think a watermark crossing a fence or brick wall) far better than earlier CNNs — and in a single forward pass.

You can run a pretrained LaMa locally on a GPU:

# pip install simple-lama-inpainting
from simple_lama_inpainting import SimpleLama
from PIL import Image

image = Image.open("watermarked.png").convert("RGB")
mask   = Image.open("mask.png").convert("L")   # white = area to remove

lama = SimpleLama()
clean = lama(image, mask)
clean.save("clean.png")

Diffusion models: beautiful but expensive

The latest inpainting uses pretrained diffusion models (Stable Diffusion's inpainting variant, etc.), conditioned on the unmasked context. Results can be stunning and follow text prompts ("a clear blue sky") — but each generation requires tens to hundreds of denoising steps, so latency and cost are an order of magnitude higher than LaMa. For a high-throughput service, diffusion is usually reserved for the hard cases or upscaled final passes.

The engineering reality

If you're building a product around this — or evaluating one — the model is maybe a third of the work. The rest is engineering:

Latency and throughput. A LaMa forward pass on a 1024px image is a few hundred milliseconds on a decent GPU. Diffusion inpainting is seconds. Batch size, image resolution caps, and GPU pooling dominate your unit economics.

Mask quality is everything. "Garbage in, garbage out" applies brutally here. A mask that's too tight leaves watermark residue; too loose erases real detail. Consumer tools hide this with UI (brush size) or learned segmentation.

Translucent vs. opaque watermarks. A solid white logo is one problem; a 30%-opacity gray logo is another. The latter requires estimating and subtracting the overlay, not just painting over it.

Safety and storage. Users are (rightly) nervous about uploading sensitive images to a server. Processing in-memory and deleting promptly, supporting ephemeral sessions, and eventually client-side inference (WebGPU / WASM) all matter for trust.

If you'd rather not stand up all of that infrastructure, there are hosted options that package the segmentation + inpainting pipeline behind a simple API and web UI — for example, Watermark Remover AI exposes this as a drag-and-drop tool with API access, which is convenient for evaluating the technique before committing to building your own.

Try it yourself: a minimal pipeline

Here's a self-contained sketch tying mask + inpainting together, using a user-supplied mask and LaMa:

from simple_lama_inpainting import SimpleLama
from PIL import Image, ImageDraw

# 1. Load image
image = Image.open("photo.png").convert("RGB")

# 2. Create a mask (here: a user "painted" rectangle over the watermark)
mask = Image.new("L", image.size, 0)
draw = ImageDraw.Draw(mask)
draw.rectangle([180, 60, 520, 140], fill=255)
mask.save("mask.png")

# 3. Inpaint
clean = SimpleLama()(image, mask)
clean.save("clean.png")

print(f"Done. Removed region {image.size} -> {clean.size}")

A good next exercise: replace the hand-drawn mask with a thresholding step that detects a translucent logo, then measure reconstruction quality (PSNR/SSIM against a known clean version).

Wrapping up

AI watermark removal is a tidy case study in how modern computer vision composes two ideas — segmentation to localize, inpainting to reconstruct — and how the inpainting side has moved from local pixel diffusion → patch copying → partial convolutions → FFC-based (LaMa) → diffusion models, each trading off quality against speed and cost.

The mental model worth taking away: the model isn't recovering the "true" pixels. It's sampling from a learned distribution of plausible natural images conditioned on the surrounding context. That's why it can look perfect and still be a fabrication — and why, for anything where pixel-level accuracy matters (forensics, medical, legal), you treat these outputs as reconstructions, not ground truth.

If you want to see the end-user result without building the pipeline, give the Gemini Watermark Remover demo a try — drop in an image you own and watch the mask + inpainting pipeline do its thing. Then come back and build your own.

What's your go-to inpainting model? I'm curious whether more teams will move to client-side inference as WebGPU matures — let me know in the comments.

How Meccha Chameleon Reinvents Hide-and-Seek with Painting Mechanics

Yu Robin — Sun, 28 Jun 2026 09:32:30 +0000

A deep dive into the game design, strategy depth, and viral community reception of 2026's most surprising indie hit.

TL;DR: Meccha Chameleon is a multiplayer hide-and-seek game where players manually paint their characters to camouflage. It sold 7M copies, hit 152K peak Twitch viewers, and was made by one developer. Here's why the design works.

The One-Mechanic Game Design Philosophy

As game developers, we often overcomplicate things. More mechanics, more systems, more features. Then along comes a game like Meccha Chameleon to remind us: one brilliant mechanic, executed perfectly, is enough.

Released June 9, 2026 by solo developer lemorion_1224, Meccha Chameleon takes the universally understood game of hide-and-seek and adds exactly one twist: you paint yourself to blend in.

That's it. That's the whole pitch. And somehow, it's enough to create an experience that has sold over 7 million copies and broken Twitch streaming records.

Let's break down why this design works so well — and what we can learn from it.

The Core Mechanic: Painting as Gameplay

In Meccha Chameleon, players are divided into Hiders and Seekers. Hiders start with a white chameleon body and must paint it to match the environment using three tools:

┌─────────────────┬──────────────────────────────────────────────┐
│ Tool            │ Function                                      │
├─────────────────┼──────────────────────────────────────────────┤
│ Color Wheel     │ Manual color selection for precise matching  │
│ Eyedropper      │ Sample colors directly from the environment  │
│ Rotation Lock   │ Control orientation to match scene objects    │
└─────────────────┴──────────────────────────────────────────────┘

This creates an elegant three-layer skill system:

Color accuracy (technical skill) — How well can you match the environment's colors?
Pose selection (strategic skill) — Does your body shape make sense in context?
Positioning (tactical skill) — Where in the map gives you the best chance of going unnoticed?

Each layer compounds on the others. Perfect color with a bad pose = you get caught. Perfect pose in a terrible location = you get caught. All three must align for true invisibility.

Why This Feels Different from Prop Hunt

The immediate comparison everyone makes is to Prop Hunt (Garry's Mod) or similar disguise-based games. But Meccha Chameleon's approach is fundamentally different:

Prop Hunt: You become an object. The game handles the disguise. Your job is positioning.

Meccha Chameleon: You paint yourself to match the environment. The game gives you the tools. Your job is artistry, observation, and execution.

This distinction is critical because it shifts the cognitive load from where to hide to how to hide. Players aren't just finding a spot — they're actively creating their camouflage in real-time. This has profound implications for gameplay flow:

# Simplified decision tree for a Meccha Chameleon hider

def hide(hider, environment):
    location = choose_position(environment)     # Where?
    colors = sample_environment(location)       # What colors?
    paint(hider, colors, tool="eyedropper")     # Apply base coat
    pose = select_contextual_pose(location)      # What shape?
    rotate_to_match(hider, nearby_objects)       # Match orientation

    while round_active:
        refine_paint(hider)                      # Keep improving!
        if seeker_nearby:
            freeze()                             # Don't move

Notice the key insight: painting is continuous. You can keep refining your camouflage even while seekers are active. This creates a tense push-pull dynamic where hiders are constantly making micro-adjustments under pressure.

The Three Game Modes and Their Design Intent

Normal Mode — The Foundation

Classic hide-and-seek. Hiders paint and hide, seekers hunt. This mode teaches players the core skills and serves as the competitive baseline. Design intent: mastery through repetition.

Infection Mode — The Social Dynamite

Tagged hiders become seekers. The last hider standing wins. This is the Among Us effect — escalating paranoia, shifting alliances, and spectacular final stands. Design intent: social tension and highlight generation. This mode is specifically designed to create streamable moments.

Double Mode — The Speed Test

Everyone hides, then everyone seeks. Most finds wins. Design intent: fast-paced party energy. This is the mode for large groups and casual sessions, designed to minimize downtime and maximize laughs.

Each mode uses the same core painting mechanic but creates completely different emotional experiences. That's efficient game design.

The Streaming Factor: A Design for Virality

Whether intentional or not, Meccha Chameleon is engineered for streaming culture:

Factor	Why It Works for Streaming
Asymmetric roles	Viewers see both perspectives, creating natural commentary opportunities
Visual clarity	A 30-second explanation is all viewers need to understand the game
Clippable moments	Every round produces at least one highlight-worthy event
Reaction-friendly	Near-misses, perfect blends, and chaotic infections generate instant reactions
Low cost of failure	Getting caught is funny, not frustrating — keeps the energy positive

The numbers validate this design. At peak, Meccha Chameleon had 152,000 concurrent viewers across 334 live channels on Twitch. It's become a staple on Kick and YouTube as well. The top Japanese streamer ChaosFB777 leads the global viewership leaderboard for the game.

Lessons for Game Developers

After spending hours with Meccha Chameleon (and even more watching others play), here are the design takeaways I think are most relevant:

1. One mechanic done perfectly beats five done adequately

Meccha Chameleon doesn't need progression systems, loot boxes, battle passes, or daily challenges. The painting mechanic is the game, and it's deep enough to support hundreds of hours of play.

2. Make failure entertaining

In most competitive games, failure feels bad. In Meccha Chameleon, getting caught is hilarious — both for the catcher and the caught. This keeps the experience positive and replayable.

3. Design for spectators

If your game is multiplayer, ask yourself: "Would I want to watch this?" Meccha Chameleon passes this test effortlessly because the visual storytelling is built into the mechanics.

4. Low barrier, discoverable depth

New players understand Meccha Chameleon in 30 seconds. But 50 hours later, they're still learning new techniques. That's the holy grail of game design.

5. Social-first design

Every mechanic serves the social experience. Painting is a skill, but it's also a conversation topic. Getting caught is a loss, but it's also a shared joke. The game is designed to create stories.

Try It Yourself

If you're a game developer, a gamer, or both — Meccha Chameleon is worth studying and worth playing. There's a free browser version that lets you experience the core loop without commitment, and the full version on Steam unlocks all three modes and maps.

Check out the official site at mecchachameleon.pro for the browser version, strategy guides, and community resources.

It's rare to see a game this elegant succeed at this scale. Meccha Chameleon isn't just a great game — it's a masterclass in minimal, mechanics-driven design that every developer can learn from.

What games do you think nail the "one mechanic done perfectly" philosophy? Drop your examples in the comments. And if you've played Meccha Chameleon, I'd love to hear your best hiding strategy.

A Free 1v1 Tactical Shooter with Unique Agents & Precise Gunplay

Yu Robin — Thu, 19 Jun 2025 12:03:01 +0000

Hey fellow devs and gamers! 🎮

I'm excited to share Falorant - a free-to-play 1v1 tactical shooter I've been developing that combines:

🔥 Unique Agent Abilities - Each character has special skills to outplay opponents
🎯 Precision Gunplay - Tight mechanics rewarding skill and strategy
⚡ Fast-Paced Matches - Quick 1v1 duels for intense, bite-sized action

Why I Built This:
I wanted to create a tactical shooter that captures the depth of competitive games while being accessible for quick sessions. The 1v1 format creates tense, personal showdowns where every decision matters.

link: https://falorant.pro/

Scaling Ludoteca: How We Built a Browser-Based Multiplayer Game Hub

Yu Robin — Fri, 13 Jun 2025 08:15:21 +0000

Announcing Ludoteca.fun – Your instant-play destination for card games, board games, and classics with thousands of players worldwide! No plugins, no downloads – just pure HTML5 gaming.

Questions for Fellow Devs:
Scaling: How would you optimize WebSocket bandwidth for 10K+ CCU?
Anti-Cheat: Best practices for client-side prediction without exposing game logic?

link: https://ludoteca.fun/

Building a Sheep Battle Royale in WebGL: Lessons from ‘Crazy Cattle 3D’

Yu Robin — Fri, 13 Jun 2025 08:02:28 +0000

Introducing Crazy Cattle 3D – a chaotic single-player battle royale where you play as a sheep ramming others off the map! No downloads, just woolly mayhem in your browser.Balancing realistic sheep physics with arcade-style fun. Too much realism made controls sluggish; too little killed the comedy.

link: https://crazycattle3d.one/crazy-cow-3d/

Building Shell Shockers: How We Made a Web-Based Multiplayer FPS

Yu Robin — Fri, 13 Jun 2025 07:50:23 +0000

🥚 Crack Open the Fun!
I'm excited to share Shell Shockers - a crazy multiplayer FPS where you battle as armed eggs! No downloads needed, just pure web-based mayhem. Try it now and let me know what you think!

Tech Stack Breakdown:
Three.js for 3D rendering (all those egg-citing explosions!)
WebSocket for real-time multiplayer (up to 20 players per match)
Howler.js for immersive audio (that satisfying "pew pew" egg gunfire)
PhysicsJS for collision detection (because eggs should bounce!)

link:https://shellshock.pro/

Building an Merge Fellas Game with Phaser & Matter.js – Tips Needed!

Yu Robin — Fri, 13 Jun 2025 07:29:27 +0000

Hey dev.to community! I just launched Merge Fellas, a quirky merge game where you combine Italian ingredients. It’s built with Phaser for rendering and Matter.js for physics. Would love your feedback!

link: https://mergefellas.net/