🆕 Gemini 3.5 watermark profile supported, with automatic legacy fallback (v0.3.1) — the CLI tries the current Gemini 3.5+ profile first; if detection skips, it automatically retries with the legacy (pre-3.5) profile. Disable with --no-legacy, or pin legacy directly with --legacy. Details below.

🎬 Veo Video Watermark Remover v0.6.1 is out — full Gemini 3.5 video watermark removal across Windows / Linux / macOS. Auto-detect for 1080p + 720p (standard and compact diamond variants), adaptive per-frame alpha via bisection feedback, tick-exact transcoder timing, audio passthrough + AI denoise. Drag-and-drop simple, no cloud, no AI hallucination — just the same reverse alpha blending math, evolved for video. Details below.

▶️ Watch: GeminiWatermarkTool — Quick Start & Feature Overview

📌 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 supports the new Gemini 3.5 watermark layout out of the box. Starting with Gemini 3.5, Google shifted the watermark position and updated its alpha map relative to legacy Gemini outputs. The tool targets the new profile by default and ships a one-click Legacy toggle for pre-3.5 outputs — no command-line flags or re-calibration needed.

Both profiles use the same deterministic reverse alpha blending pipeline — switching profiles only changes the alpha map and position formula, not the math.

The CLI default now handles mixed Gemini-3.5+ and pre-3.5 inputs without the user having to script the retry. When the current-profile detector returns skipped (confidence below threshold), the CLI automatically runs the same image through the legacy profile before reporting the final outcome. Behaviour matrix:

The safety contract is unchanged: each profile attempt is still gated by the confidence threshold, so non-Gemini images skip on both V2 and V1 and remain untouched. The GUI is unchanged — its Legacy checkbox is explicit, no automatic fallback.

The CLI now returns distinct exit codes so scripts can chain retries without inspecting stdout or checking for an output file:

Batch directory mode (-i somedir -o somedir) keeps lenient semantics: exit 0 unless something actually fails, since partial skips are normal when scanning a folder.

Example Windows shell chain:

GeminiWatermarkTool.exe -i image.png -o clean.png
if %ERRORLEVEL% equ 1 (
    rem auto-fallback tried both V2 and V1 and skipped; user may want --force
    GeminiWatermarkTool.exe -i image.png -o clean.png --force
)

GeminiWatermarkTool now supports removing Google Veo and Gemini 3.5 video watermarks across Windows, Linux, and macOS. The same reverse alpha blending engine, evolved for video — direct mp4-to-mp4, with audio preserved, mathematically deterministic.

VeoWatermarkRemover v0.6.1-demo — Download →

• Gemini 3.5 diamond watermark (default, no flag needed) — auto-detected per file:
  • 1080p: 1920×1080 landscape, 1080×1920 portrait (validated end-to-end)
  • 720p: 1280×720 landscape, 720×1280 portrait — both standard (48×48) and compact (44×44) diamond variants
• Legacy "Veo" text watermark (--legacy) — pre-Gemini-3.5 outputs still supported
• Audio passthrough — original audio kept without re-encoding
• AI denoise — GPU-accelerated FDnCNN cleanup (Vulkan, automatic CPU fallback)
• Cross-platform binaries — Windows x64, Linux x64, macOS Universal (Intel + Apple Silicon)

• Multi-frame detection probe — auto-detect probes 12 frames spread across the video, so intro fade-ins / splash screens no longer cause false SKIPs.
• Adaptive per-frame alpha via bisection feedback — applies a candidate intensity, evaluates whether the result matches the surrounding background, and adjusts up (residue) or down (over-subtraction) for up to 5 rounds per frame. Visual-consistency goal rather than predictive accuracy, so neighbouring frames that look similar also remove similarly.
• Per-shot seed + per-frame change cap — a stable per-video baseline anchors the bisection, and a ±0.05 per-frame movement cap prevents single-frame metric noise from causing visible flashes on content with heavy foreground motion.
• Tick-exact transcoder timing — output frame count, duration, and FPS metadata match input exactly. No drift in NLE / editor alignment (fix for previous releases that silently dropped 1-3 tail frames).
• --variant 720p-1 / --variant 720p-2 escape hatch when auto-detect can't lock on (very rare with the multi-frame probe).
• --sigma tuning — --sigma 15 for anime / illustration content, --sigma 25 when default AI denoise feels too aggressive.

# Default — Gemini 3.5 diamond removal (1080p + 720p auto-detected)
GeminiWatermarkTool-Video video.mp4

# Pre-Gemini-3.5 video with "Veo" text watermark
GeminiWatermarkTool-Video --legacy old_veo_video.mp4

# Anime / illustration content (lighter AI denoise)
GeminiWatermarkTool-Video --sigma 15 video.mp4

Some content with very strong per-frame motion or foreground objects overlapping the watermark region can still leave a small residue on a few frames. For those, the manual touch-up workflow (ffmpeg decompose → GUI hand-fix the problem frames → ffmpeg recompose) covers the gap; most clips need only a handful of touch-ups.

The Veo feature is currently distributed via the standalone VeoWatermarkRemover demo repo. When the pipeline is fully stable across all observed content classes, it will be merged into GeminiWatermarkTool as a unified release supporting both image and video watermark removal.

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 16–320px with adjustable Min Size and Max Size sliders (Min Size default 16px covers Gemini preview-tier watermarks ~28px)
• 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, deployed across Google services including Gemini, Imagen, Lyria, and Veo.

It is best understood as a family of technologies rather than a single algorithm — text, image, audio, and video each use different underlying mechanisms. For images specifically, according to Gowal et al. (2025), SynthID-Image is a post-hoc, model-independent encoder-decoder approach: the watermark is added by a trained encoder after the image has been generated.

Key properties:

• Invisible to human eyes
• Robust against common image transformations (compression, noise, rotation, color changes, etc.)
• Adversarially trained to resist most simple removal attacks

Even though the watermark is technically "added" by the encoder, the encoder is a deep neural network trained adversarially. The perturbation it adds is distributed in a high-dimensional learned representation, not as a fixed pixel pattern. As a result:

• Random or symmetric attacks tend to be orthogonal to the encoder's learned direction
• Most common transformations were already part of the encoder's training augmentation
• The watermark is entangled with image features rather than localized

In practice, removing SynthID without significantly degrading image quality is currently not feasible with publicly available tools.

📄 Full SynthID Research Report →

Download the latest release from the Releases page.

A separate, much smaller CLI-only build is published alongside each release for users who do not need the desktop GUI (servers, CI pipelines, scripted batch processing). gwt-mini keeps full functionality — reverse alpha blending, three-stage NCC detection, snap search, and AI denoise (NCNN + embedded FDnCNN weights) — and drops only the ImGui / SDL3 / GPU-backend stack. Windows and Linux builds are additionally UPX-compressed.

CLI flags are identical to the full build — see CLI — Quick Start.

Caveats:

• Some corporate antivirus engines (Defender ATP, CrowdStrike, etc.) may flag UPX-packed executables as suspicious. If that is a concern, use the full GeminiWatermarkTool binary instead — it is not packed.
• UPX adds a small one-off decompression cost at startup (~20–50 ms).
• macOS is not UPX-compressed: UPX interacts badly with codesigning and Gatekeeper on modern macOS.

To build gwt-mini yourself, see Build — gwt-mini (minimal CLI) below.

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

# Gemini preview images (small ~28px watermark): use lower snap-threshold
GeminiWatermarkTool -i preview.jpg -o clean.jpg \
    --fallback-region br:auto --snap --snap-threshold 0.30 --denoise ai --sigma 13 --strength 175

# 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

For the published gwt-mini variant: GUI off, AI denoise on, no video pipeline.

# Linux
cmake -B build-mini -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_GUI=OFF \
  -DENABLE_AI_DENOISE=ON \
  -DENABLE_VIDEO=OFF \
  -DVCPKG_MANIFEST_FEATURES="ai-denoise" \
  -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake
cmake --build build-mini
strip build-mini/GeminiWatermarkTool
# Optional: shrink further with UPX
upx --best --lzma build-mini/GeminiWatermarkTool

On Windows add -DVCPKG_TARGET_TRIPLET=x64-windows-static -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded. On macOS build x86_64 and arm64 separately, then lipo -create them into a universal binary (same recipe as mac-universal-Release, just with the flags above).

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.

If GeminiWatermarkTool saved you time and you'd like to help keep it going, you can support via Ko-fi or PayPal — both go to the same place; pick whichever works for you (a few users have reported Ko-fi checkout issues from their region, so PayPal is the dependable fallback). Every public release goes through GitHub Actions CI on Windows / Linux / macOS / Android, and the binaries live in the Releases section — small contributions help cover runner minutes and storage so the project can keep building cross-platform binaries for free. Not required, just appreciated.

Bug reports, sample images / videos, and pull requests remain the most valuable contributions and always will be — opening an issue with content the tool can't handle is often more useful than a one-off donation.

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 ⭐