📌 Original Author Notice (Reverse Alpha Blending)

I am the original author of GeminiWatermarkTool and the reverse alpha-blending restoration method used to remove the visible "Gemini" watermark while preserving image detail (Allen Kuo / allenk).

This project achieves high-precision restoration by using my calibrated 48×48 and 96×96 Reverse-Alpha Masks to invert the blending equation. Since I published this work and these assets, many derivative tools (desktop apps, websites, browser extensions, etc.) have appeared using the same approach and/or directly reusing the masks produced by this project — because the method is deterministic and highly effective.

✅ MIT License reminder
This project is released under the MIT License. Commercial use and ports are allowed.
However, if you redistribute any substantial portion of this project (including code or mask assets), you must:

• Preserve the original copyright notice
• Include the full MIT license text
• (Recommended) Provide attribution with a link back to this repository

📖 For the full technical write-up (including how the Reverse-Alpha Masks were derived and calibrated), see:
Removing Gemini AI Watermarks: A Deep Dive into Reverse Alpha Blending
https://allenkuo.medium.com/removing-gemini-ai-watermarks-a-deep-dive-into-reverse-alpha-blending-bbbd83af2a3f

Gemini Watermark Tool removes Gemini visible watermarks from images using a mathematically accurate reverse alpha blending algorithm.
Unlike many tools that rely entirely on generative inpainting, this project focuses on deterministic reconstruction combined with lightweight AI-assisted cleanup.

The design philosophy is simple:
small, standalone, fast, and reliable.

The entire toolkit is distributed as a portable executable with zero runtime dependencies, making it easy to install, automate, and integrate into scripts or pipelines without complex setup.

Key capabilities include:

• Fast & offline: single executable, no external services or dependencies
• Standalone & portable: small footprint, easy to deploy and use anywhere
• GUI + CLI: drag-and-drop desktop workflow or command-line automation
• Deterministic watermark reconstruction: reverse alpha blending algorithm designed specifically for Gemini watermark overlays
• AI-assisted cleanup: optional GPU-accelerated FDnCNN denoise (NCNN + Vulkan) for residual artifacts
• Smart detection: three-stage NCC detection with confidence scoring to automatically skip non-watermarked images
• Batch processing: process entire directories with preview and progress tracking
• Cross-platform: Windows / Linux / macOS / Android (CLI)
• AI Agent ready: Claude Code Skill + MCP Server for automation and agent workflows

GeminiWatermarkTool now comes with a full graphical desktop application. No command line needed — just open, drag & drop, and process. Supports single-image editing with real-time preview, and batch processing with smart watermark detection.

The desktop GUI provides an interactive workflow for both single-image and batch operations.

GeminiWatermarkTool can now be integrated into AI-agent workflows via MCP server and Claude Code skills. This enables automated watermark processing inside agent-based pipelines.

gwt-integrations — Claude Code Skill + MCP Server for GeminiWatermarkTool

Enable AI coding agents (Claude Code, Cursor, Windsurf, etc.) to use GeminiWatermarkTool directly:

• Drag & drop or open any supported image
• Auto-detect watermark size (48×48 / 96×96) or select manually
• Custom watermark mode: draw a search region interactively, resize with 8-point anchors, fine-tune position with WASD keys
• Multi-scale guided detection (Snap Engine): coarse-to-fine NCC template matching auto-locks to the exact watermark position within your drawn region — supports variable sizes from 32–320px with adjustable search range slider
• Real-time before/after comparison (press V)
• One-key processing (X) and revert (Z)
• Zoom, pan (Space/Alt + drag, mouse wheel), and fit-to-window

Reverse alpha blending is mathematically exact — but only when the image hasn't been resized, recompressed, or processed after watermarking. In practice, many images go through post-processing that breaks the pixel-perfect math, leaving faint residual artifacts after removal.

Software Inpainting addresses this by applying a lightweight cleanup pass after the reverse blending step. It uses gradient-weighted masks derived from the watermark's own alpha channel to target only the residual pixels, leaving the rest of the image untouched.

Three built-in methods are available:

The cleanup controls appear automatically in Custom mode under the Detected Info panel. You can adjust the method, strength (0–100%), and inpaint radius (1–25 px) to fine-tune the result.

AI Denoise uses a GPU-accelerated neural network (FDnCNN) to clean up watermark residuals that conventional inpainting methods struggle with — particularly the faint sparkle edges and corner artifacts left after reverse alpha blending on resized images.

Unlike NS/TELEA which require a binary mask to know which pixels are damaged, AI Denoise examines a 41×41 pixel neighborhood around each point and learns from training data what "normal" image content looks like. Combined with gradient-masked blending from the alpha map, it repairs only the artifact pixels while preserving clean background detail.

Technical details:

• Model: FDnCNN Color, 20-layer Conv+ReLU, FP16 (~1.3 MB embedded in executable)
• Inference: NCNN with Vulkan GPU acceleration, automatic CPU fallback
• Pipeline: gradient mask from alpha map → NCNN inference on padded ROI → per-pixel masked blend
• Performance: < 5 ms per region on modern GPUs, ~20 ms on CPU

AI Denoise is the recommended default when available. The GPU device name is displayed below the controls. If GPU initialization fails, the tool automatically falls back to NS inpainting.

• Drag & drop multiple files or an entire folder to enter batch mode
• Thumbnail atlas preview with filename labels and status overlays (OK / SKIP / FAIL)
• Detection threshold slider (0–100%, 5% steps, 25% recommended) — automatically skip images without watermarks
• Confirmation dialog before overwriting originals
• Non-blocking processing with progress bar and scrollable result log
• Thumbnails refresh after completion to show processed results

The GUI supports multiple render backends for maximum compatibility:

Why D3D11?

• Native Windows API — no additional drivers needed
• WARP fallback — software rendering when no GPU available
• Works in Hyper-V, Docker, Remote Desktop, and other virtualized environments
• Better stability in Windows sandbox configurations

# Auto-select (D3D11 on Windows, OpenGL elsewhere)
GeminiWatermarkTool

# Force specific backend
GeminiWatermarkTool --backend=d3d11
GeminiWatermarkTool --backend=opengl

In addition to the GUI, the command line has been significantly enhanced.

# Process multiple files at once (new!)
GeminiWatermarkTool img1.jpg img2.png img3.webp

Watermark detection is enabled by default in simple mode — images without a detectable watermark are automatically skipped to prevent accidental damage.

# Force processing without detection
GeminiWatermarkTool --force image.jpg

# Custom detection threshold (default: 25%)
GeminiWatermarkTool --threshold 0.40 image.jpg

# Single file with explicit output
GeminiWatermarkTool -i input.jpg -o output.jpg

# Batch directory processing
GeminiWatermarkTool -i ./watermarked_images/ -o ./clean_images/

Inspired by @dannycreations's contribution on watermark presence detection. We took the concept further with a production-grade three-stage algorithm deeply integrated into both CLI and GUI workflows.

Batch processing watermark-free images can cause unnecessary pixel damage. The tool now uses a three-stage NCC (Normalized Cross-Correlation) algorithm to detect watermarks before processing, ensuring only watermarked images are modified:

1. Spatial NCC — correlates the image region with the known alpha map (50% weight, with circuit breaker at 0.25 to short-circuit obvious non-matches)
2. Gradient NCC — Sobel edge matching to detect the star-shaped structural pattern (30% weight)
3. Statistical Variance — texture dampening analysis to distinguish real watermarks from white/flat regions (20% weight)

A combined confidence score determines whether a watermark is present. The default threshold is 25% — images below this score are skipped. This eliminates false positives from white backgrounds or similar-looking content that plagued simpler correlation-based approaches.

Detection is enabled by default in simple/drag-and-drop mode and disabled by default in standard (-i / -o) mode. In the GUI, the threshold is adjustable via a slider (0–100%, 5% steps) with a recommended 25% default.

Best for: slides, documents, UI screenshots, diagrams, logos.

Focus on the bottom example (text-heavy slide).
Generative inpainting often breaks text: warped edges, wrong spacing, invented strokes.
GeminiWatermarkTool reverses the blending equation to recover pixels, keeping text crisp.

Important: This tool removes visible watermarks only. It does NOT remove SynthID.

SynthID is Google DeepMind's invisible watermarking technology embedded in AI-generated images. Unlike visible watermarks:

• Invisible to human eyes
• Integrated during generation (not added afterward)
• Extremely robust against common image manipulations

Our extensive research revealed a fundamental truth:

SynthID is not a watermark added to an image — it IS the image.

SynthID operates as a Statistical Bias during generation. Every pixel choice is subtly influenced by Google's private key using Tournament Sampling. The watermark and visual content are inseparably bound.

Visible Watermark:  Image + Overlay = Result     ✓ Removable (this tool)
SynthID:            Biased Generation = Image    ✗ Cannot separate

Conclusion: Removing SynthID while preserving image quality is currently not feasible.

📄 Full SynthID Research Report →

• SynthID Image Watermark Research Report

Download the latest release from the Releases page.

Downloaded binaries are not code-signed, so your OS may show a security warning on first launch. This is normal for open-source software distributed outside app stores.

xattr -dr com.apple.quarantine GeminiWatermarkTool
chmod +x GeminiWatermarkTool

Unblock-File .\GeminiWatermarkTool.exe

chmod +x GeminiWatermarkTool
./GeminiWatermarkTool

USE AT YOUR OWN RISK

This tool modifies image files. While it is designed to work reliably, unexpected results may occur due to:

• Variations in Gemini's watermark implementation
• Corrupted or unusual image formats
• Edge cases not covered by testing

Always back up your original images before processing.

The author assumes no responsibility for any data loss, image corruption, or unintended modifications. By using this tool, you acknowledge that you understand these risks.

Don't need the GUI? The CLI is designed for maximum simplicity — one drag, one drop, done.

1. Download GeminiWatermarkTool-Windows-x64.exe
2. Drag an image file onto the executable
3. ✅ Done! The watermark is removed in-place — no terminal, no arguments

# Simple mode - just provide a filename
GeminiWatermarkTool watermarked.jpg

# Specify output file (preserves original)
GeminiWatermarkTool -i watermarked.jpg -o clean.jpg

# Batch processing - entire directory
GeminiWatermarkTool -i ./input_folder/ -o ./output_folder/

Supported formats: .jpg, .jpeg, .png, .webp, .bmp

⚠️ Warning: Simple mode overwrites the original file permanently. Always back up important images before processing.

Region syntax:

Examples:

# Standard removal with AI denoise cleanup
GeminiWatermarkTool -i input.jpg -o clean.jpg --denoise ai

# Batch with AI denoise (all files)
GeminiWatermarkTool -i ./photos/ -o ./clean/ --denoise ai

# Fallback for images that fail detection: search bottom-right area with snap
GeminiWatermarkTool -i ./photos/ -o ./clean/ \
    --fallback-region br:auto --snap --denoise ai

# Resized watermarks: expand snap search to 320px
GeminiWatermarkTool -i ./photos/ -o ./clean/ \
    --fallback-region br:80,80,200,200 --snap --snap-max-size 320 --denoise ai

# Force process at explicit region (all images have watermark at same spot)
GeminiWatermarkTool -i ./photos/ -o ./clean/ \
    --force --region 500,800,160,160 --snap --denoise ai --sigma 75

Note: When no --denoise is specified, the CLI behaves identically to previous versions (no cleanup pass). All existing scripts and agent integrations continue to work unchanged.

The tool automatically detects the appropriate watermark size based on image dimensions:

Use --force-small or --force-large to override automatic detection.

All binaries are statically linked with no external runtime dependencies.

AI Denoise uses Vulkan for GPU acceleration. Most modern GPUs (NVIDIA, AMD, Intel) with up-to-date drivers support Vulkan. If no Vulkan GPU is detected, inference automatically falls back to CPU (OpenMP multi-threaded).

The watermark is semi-transparent. If the original background was similar to the watermark color, the difference may be subtle. Try viewing at 100% zoom in the watermark area (bottom-right corner).

Use --force-small or --force-large to manually specify:

GeminiWatermarkTool -i image.jpg -o output.jpg --force-small

Make sure the output path is writable and the file isn't open in another program.

• Only removes Gemini visible watermarks (the semi-transparent logo in bottom-right)
• Does NOT remove SynthID invisible watermarks — see why
• Designed for Gemini's current watermark pattern (as of 2025)

# Clone vcpkg
git clone https://github.com/microsoft/vcpkg.git
cd vcpkg

# Bootstrap
./bootstrap-vcpkg.sh    # Linux/macOS
.\bootstrap-vcpkg.bat   # Windows

# Set environment variable
export VCPKG_ROOT="$HOME/vcpkg"       # Linux/macOS (add to .bashrc)
$env:VCPKG_ROOT = "C:\vcpkg"          # Windows PowerShell

The project uses CMakePresets.json for cross-platform configuration.

# Clone with submodules (NCNN source)
git clone --recursive https://github.com/allenk/GeminiWatermarkTool.git

# Or if already cloned:
git submodule update --init --recursive

# List available presets
cmake --list-presets

cmake --preset windows-x64-Release
cmake --build --preset windows-x64-Release

cmake --preset linux-x64-Release
cmake --build --preset linux-x64-Release

macOS requires separate builds for each architecture:

# Build x64
cmake -B build-x64 -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake \
  -DVCPKG_TARGET_TRIPLET=x64-osx \
  -DCMAKE_OSX_ARCHITECTURES=x86_64
cmake --build build-x64

# Build arm64
cmake -B build-arm64 -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake \
  -DVCPKG_TARGET_TRIPLET=arm64-osx \
  -DCMAKE_OSX_ARCHITECTURES=arm64
cmake --build build-arm64

# Create Universal Binary
lipo -create build-x64/GeminiWatermarkTool build-arm64/GeminiWatermarkTool \
  -output GeminiWatermarkTool

Requires Android NDK:

export ANDROID_NDK_HOME="/path/to/android-ndk"

cmake --preset android-arm64-Release
cmake --build --preset android-arm64-Release

All presets enable ENABLE_AI_DENOISE=ON by default. To build without AI, set -DENABLE_AI_DENOISE=OFF manually.

cmake -B build -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake \
  -DVCPKG_TARGET_TRIPLET=x64-linux

cmake --build build

gemini-watermark-tool/
├── CMakeLists.txt              # Main build configuration
├── CMakePresets.json           # Cross-platform build presets
├── vcpkg.json                  # Dependencies manifest
├── src/
│   ├── core/                   # Core engine (CLI + GUI shared)
│   │   ├── watermark_engine.hpp/cpp
│   │   ├── watermark_detector.hpp/cpp
│   │   ├── blend_modes.hpp/cpp
│   │   ├── ai_denoise.hpp/cpp         # NCNN FDnCNN denoiser
│   │   ├── ai_denoise_model.cpp       # Embedded model weights (isolated TU)
│   │   ├── ncnn_shim.hpp              # Vulkan loader shim for NCNN
│   │   └── types.hpp
│   ├── cli/                    # CLI application
│   │   └── cli_app.hpp/cpp
│   ├── utils/                  # Utilities
│   │   ├── ascii_logo.hpp
│   │   └── path_formatter.hpp
│   ├── main.cpp                # Entry point (CLI/GUI dispatcher)
│   └── gui/                    # Desktop GUI (ImGui + SDL3)
│       ├── gui_app.hpp/cpp           # GUI entry point
│       ├── app/
│       │   ├── app_state.hpp         # Application state
│       │   └── app_controller.hpp/cpp # Logic controller
│       ├── widgets/
│       │   ├── main_window.hpp/cpp   # Main window + menus
│       │   └── image_preview.hpp/cpp # Image viewer + batch view
│       ├── backend/
│       │   ├── render_backend.hpp/cpp  # Backend interface + factory
│       │   ├── opengl_backend.hpp/cpp  # OpenGL 3.3 implementation
│       │   └── d3d11_backend.hpp/cpp   # Direct3D 11 implementation (Windows)
│       └── resources/
│           └── style.hpp             # Theme and layout constants
├── external/
│   └── ncnn/                         # NCNN source (git submodule)
│       └── model-convert/output/     # Converted FDnCNN model headers
├── report/
│   └── synthid_research.md     # SynthID research documentation
└── resources/
    ├── app.ico                 # Windows application icon
    └── app.rc.in               # Windows resource template

All dependencies are managed via vcpkg and statically linked:

Gemini applies visible watermarks using alpha blending:

watermarked = α × logo + (1 - α) × original

By statistically analyzing and comparing values related to Alpha, we can reconstruct an Alpha Map that is either correct or very close to it.

Solving for the original pixel:

original = (watermarked - α × logo) / (1 - α)
         = (watermarked - alpha_map) / (1 - α)

This mathematical inversion produces exact restoration of the original pixels.

When images have been resized or recompressed after watermarking, the exact math no longer holds perfectly. Two approaches are available for cleaning up residual artifacts:

Software Inpainting (NS / TELEA / Gaussian):

1. Compute gradient magnitude from watermark alpha channel
2. Build soft weight mask: stronger where alpha gradient is high
3. Apply selected inpainting method (NS / TELEA / Gaussian blend)
4. Blend result using weight mask — only affected pixels are modified

AI Denoise (FDnCNN, recommended):

1. Compute gradient mask from alpha map (locate sparkle edges)
2. Run FDnCNN inference on padded ROI (Vulkan GPU or CPU)
   Input:  [R, G, B, sigma/255] → Output: denoised clean image
3. Per-pixel masked blend: mask × denoised + (1-mask) × original
   → Only edge artifacts repaired, clean background untouched

This tool is provided for personal and educational use only.

The removal of watermarks may have legal implications depending on your jurisdiction and the intended use of the images. Users are solely responsible for ensuring their use of this tool complies with applicable laws, terms of service, and intellectual property rights.

The author does not condone or encourage the misuse of this tool for copyright infringement, misrepresentation, or any other unlawful purposes.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM THE USE OF THIS SOFTWARE.

MIT License

Allen Kuo (@allenk)

• GitHub: https://github.com/allenk
• LinkedIn: https://www.linkedin.com/in/allen-kuo-7b513a45/
• Medium: https://allenkuo.medium.com

Quick start:

# Install the integration (after GeminiWatermarkTool is on PATH)
git clone https://github.com/allenk/gwt-integrations.git
cd gwt-integrations
python install.py

After installation, AI agents can process watermarks conversationally:

"Remove the Gemini watermark from screenshot.png using AI denoise"
"Batch process all images in ./photos/ with fallback snap detection"

See gwt-integrations README for full setup instructions and MCP configuration.

• Removing Gemini AI Watermarks: A Deep Dive into Reverse Alpha Blending
• SynthID Image Watermark Research Report
• SynthID Research Report — Why invisible watermarks cannot be removed
• gwt-integrations — Claude Code Skill + MCP Server for AI agent automation

This project incorporates the following open-source components:

Full license texts for these components are available in their respective repositories.

If this tool helped you, consider giving it a ⭐