gemini-watermark-and-synthid-remover

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

gemini-watermark-and-synthid-remover

★ 32 Open GitHub ↗

Cross platform CLI tool for removing watermarks from images and videos generated by Google Gemini, Veo, and NotebookLM.

Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# wmr: Watermark Remover

[![GitHub release](https://img.shields.io/github/v/release/froggeric/gemini-watermark-and-synthid-remover?label=release)](https://github.com/froggeric/gemini-watermark-and-synthid-remover/releases)
[![CI](https://img.shields.io/github/actions/workflow/status/froggeric/gemini-watermark-and-synthid-remover/release.yml?branch=main&label=CI)](https://github.com/froggeric/gemini-watermark-and-synthid-remover/actions/workflows/release.yml)
[![macOS](https://img.shields.io/badge/macOS-signed%20%26%20notarized-brightgreen)](https://github.com/froggeric/gemini-watermark-and-synthid-remover/releases)
[![C++20](https://img.shields.io/badge/C%2B%2B-20-blue.svg)](https://isocpp.org/std/the-standard)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/froggeric/gemini-watermark-and-synthid-remover/main/LICENSE)

A fast command-line tool that removes **visible** watermarks from images and videos generated by Google **Gemini**, **Veo**, and **NotebookLM**, and can scrub the invisible **SynthID** watermark via lossy SDXL regeneration. Each download is self-contained and runs on a clean system with nothing to install. macOS builds are Developer ID signed and Apple-notarized, so they pass Gatekeeper with no extra steps.

## Supported watermarks

| Watermark | Found on | Removal method | Status |
|-----------|----------|----------------|--------|
| Gemini diamond logo | Gemini images | Exact reverse alpha-blend | ✅ Full |
| Veo video watermark | Veo videos | Per-frame reverse alpha-blend | ✅ Full |
| NotebookLM logo + wordmark | NotebookLM videos | Per-scene AI inpaint (MI-GAN) | ✅ Full |
| SynthID (invisible) | Gemini images | Lossy SDXL img2img regen | ⚠️ Lossy; validated against Google's official SynthID verifier (manual, rate-limited) |

`detect` locates the **visible** watermark without modifying the file. wmr does **not** detect SynthID: Google's "Verify with SynthID" is a manual in-app tool (no API wmr can drive), and the spectral detector we shipped before 1.16.0 had no discriminative power (it scored ROC AUC 0.20 on images labeled by that Google verifier). See [`docs/research/synthid-spectral-removal-record.md`](docs/research/synthid-spectral-removal-record.md) for the evidence.

## Quick start

### 1. Download

Grab a prebuilt binary from the [Releases page](https://github.com/froggeric/gemini-watermark-and-synthid-remover/releases) (no build step). Every package is self-contained (bundles the AI models and any runtime libraries it needs).

| Asset | Platform | Run |
|-------|----------|-----|
| `wmr-macos-arm64.zip` | macOS 14+ (Apple Silicon) | `unzip wmr-macos-arm64.zip && cd wmr-macos-arm64 && ./wmr` |
| `wmr-macos-x86_64.zip` | macOS 14+ (Intel) | `unzip wmr-macos-x86_64.zip && cd wmr-macos-x86_64 && ./wmr` |
| `wmr-linux-x86_64.tar.gz` | Linux | `tar xzf wmr-linux-x86_64.tar.gz && cd wmr-linux-x86_64 && ./wmr` |
| `wmr-windows-x86_64.zip` | Windows | extract, run `wmr.exe` |

- **macOS** ships native **CoreML** MI-GAN (Neural Engine, ~28 ms/frame). macOS 14+ required.
- **Linux/Windows** ship **ONNX Runtime** MI-GAN (~225 ms/frame, CPU).
- AI denoise (FDnCNN) uses the GPU via Vulkan/MoltenVK when available, else the CPU.
- macOS builds are Developer ID signed and notarized, so Gatekeeper allows them on first launch (a one-time online check). If Gatekeeper still blocks a build (for example on an offline machine), run `xattr -dr com.apple.quarantine <extracted-dir>`.
- Third-party licenses: [`LICENSE-THIRD-PARTY.md`](LICENSE-THIRD-PARTY.md).

### 2. Remove your watermark

```bash
# Gemini image (auto-detects + removes the sparkle logo)
wmr remove image.png -o clean.png

# Gemini / Veo video (auto-detects the watermark position + size)
wmr video video.mp4 -o clean.mp4

# Veo legacy text watermark
wmr video veo.mp4 --legacy -o clean.mp4

# NotebookLM video (auto-detects the logo + wordmark)
wmr video notebooklm.mp4 --notebooklm -o clean.mp4

# SynthID invisible watermark (lossy SDXL regen)
wmr synthid image.png -o clean.png
```

Batch a folder: `wmr remove folder/ -o cleaned/ --recursive`.

> **Which command?** Image → `remove` · Gemini/Veo video → `video` · NotebookLM video → `video --notebooklm` · Invisible (SynthID) → `synthid` · Just locate → `detect`

> **Gemini 3.6 Flash images:** the visible diamond's position is auto-detected, so
> `wmr remove` just works. If a mark is too faint to confirm (blends with a light
> background), force its position: `wmr remove img.png --geo-preset gemini36-portrait -o clean.png`
> (named presets per resolution) or `wmr remove img.png --rect x,y,w,h -o clean.png`
> (exact box). Use `wmr detect img.png -v` to read the detected geometry.

Supported inputs: PNG / JPEG / WebP images; MP4 and other FFmpeg-supported video.

## Usage reference

| Command | Does |
|---------|------|
| `remove` (default) | Auto-detect + remove visible watermarks |
| `visible` | Remove only the visible watermark |
| `synthid` | Scrub only the SynthID invisible watermark (lossy SDXL regen) |
| `video` | Remove watermarks from video (Gemini / Veo / NotebookLM) |
| `detect` | Detect the visible watermark without modifying |

### Common flags

| Flag | Applies to | Description |
|------|------------|-------------|
| `-o, --output` | most | Output path (required for files; batch defaults to `cleaned/`) |
| `-f, --force` | remove, visible, synthid, video | Skip detection, assume a watermark is present |
| `--force-small` / `--force-large` | remove, visible | Force 48×48 / 96×96 Gemini logo size |
| `--legacy` | remove, visible, detect | Pin legacy Gemini (pre-3.5) V1 still-image profile |
| `--no-legacy` | remove, visible, detect | Pin current (Gemini 3.5+) V2 profile; disable auto-fallback |
| `--rect x,y,w,h` | remove, visible, detect | Force the watermark box (overrides auto-geometry); removal happens there even on a faint mark |
| `--geo-preset <name>` | remove, visible, detect | Named geometry, e.g. `gemini36-portrait` (896×1200) |
| `--no-auto-geometry` | remove, visible, detect | Skip the content-based position search; use the model |
| `--legacy` | video | Use the Veo legacy text profile |
| `-r, --recursive` | remove | Process directories recursively |
| `-v, --verbose` / `-V, --version` | all | Verbosity / version |

### SynthID flags

wmr does **not** detect SynthID (Google's "Verify with SynthID" is a manual in-app tool with no API; and the spectral detector we shipped before 1.16.0 had no discriminative power and was removed). The only SynthID operation is `--synthid-attack regen`, a lossy SDXL img2img scrub validated against that official verifier.

| Flag | Description |
|------|-------------|
| `--synthid-attack regen` | SynthID attack (default `regen`; the only method). On `remove`, regen runs only when this flag is passed. On `synthid`, regen runs by default |
| `--regen-strength` | img2img strength, 0.02 to 0.15 (default 0.10) |
| `--regen-steps` | sampler steps (default 50) |
| `--regen-no-download` | refuse the first-run model fetch (errors if the model is absent) |
| `--regen-no-tile` | disable tiled img2img (whole-image; fails above ~1024px on most GPUs) |
| `--regen-model-path` / `--regen-vae-path` | point at a local model / VAE instead of the pinned download |
| `--regen-backend {auto\|cpu\|metal\|vulkan\|coreml}` | runtime backend (default `auto`) |

#### `--synthid-attack regen` (the only validated SynthID scrub)

`--synthid-attack regen` runs a low-strength SDXL img2img regeneration of the whole image. This is the only attack the published literature reports as validated against SynthID-Image.

```bash
wmr synthid image.png -o clean.png                            # SynthID scrub (regen is the default here)
wmr remove image.png --synthid-attack regen -o clean.png      # visible diamond first, then regen
```

**Backend selection + platform availability (1.16.2).** The regen path runs on every platform. macOS Apple Silicon defaults to the native CoreML pipeline (fast); Linux, Windows, and macOS Intel run the sdcpp CPU backend (correct, but slow). All backends use the same SDXL base model and the same deterministic-Euler img2img schedule, so the validated strength (0.10 @ 50 steps = 5 denoise steps) applies uniformly.

| Backend | Platform | Performance | Notes |
|---------|----------|-------------|-------|
| `auto` (default) | all | macOS Apple Silicon ~10s/tile (CoreML); else CPU | macOS prefers CoreML when the models are present; Linux/Windows/mac-Intel fall back to CPU. |
| `coreml` | macOS Apple Silicon | ~10s/tile + ~50s load (one-time) | Native CoreML SDXL, ~3.4x faster than CPU on M4. |
| `cpu` | all | ~231s/tile (896x1200) | sdcpp via stable-diffusion.cpp. The default on the Linux/Windows/macOS Intel release binaries. |
| `metal` | macOS Apple Silicon (arm64 binary only) | not recommended | sdcpp Metal backend; unstable upstream on Apple Silicon, prefer `auto`/`coreml`. |

On macOS with `WMR_BUILD_AI_COREML_SD`, the `auto` backend prefers CoreML when models
are present at `$WMR_COREML_SD_MODELS_DIR` (defaults to `~/.cache/wmr/coreml-sdxl/`).

Be aware of the tradeoffs before you use it:

- **It is lossy, and at the strength that actually scrubs SynthID you will see it.**
  Output fidelity varies with content: measured ~29 to 41 dB PSNR versus the input across
  a varied test set at strength 0.10 (busy content changes more; smooth content less). The
  default strength is **0.10**, validated as the minimum that reliably removes the
  invisible watermark (see the next bullet). At that strength expect visible **smoothing
  and minor simplification**, because SDXL regeneration is less powerful than the original
  model that produced the image. Raise strength only if you accept more change; lowering it
  is **not recommended**: lighter strengths do not reliably clear SynthID on all content
  (see `docs/research/synthid-light-reconstruction-attacks.md`).
- **Model acquisition.** The CPU backend downloads ~6.5 GB + ~335 MB on first use (the SDXL
  base checkpoint and the fp16-fix VAE, SHA256-pinned, cached in `~/.cache/wmr/`). The
  CoreML backend (~4.5 GB) is also auto-downloaded from HuggingFace on first use (see below). Neither is bundled.
- **It leaves a forensic footprint.** A regen-attacked image is itself a detectable
  diffusion output; an attacker looking for "tampering" can spot it. This is an attack on
  the watermark, not an invisibility guarantee.
- **Verification is manual, not in-process.** Google ships an official verifier — "Verify with SynthID" in the Gemini app, plus an early-access [SynthID Detector](https://deepmind.google/models/synthid/) portal — but it is a human-facing UI (no API; the Gemini-app check caps near ~10/day), so `wmr` cannot confirm a given output on its own. The removal is still verifiable, though:
  The default strength 0.10 was validated against Google's own "Verify with SynthID"
  detector: across a varied 9-image set, including an image-to-image generation that
  carries SynthID **twice**, every output cleared the watermark, confirmed over **two
  rounds** of checks. This is a small sample (the detector is rate-limited to ~10
  checks/day), not a large-scale proof, but it spans posters, mockups, and AI art and
  includes the hardest known case. Lighter strengths (0.04-0.08) cleared normal
  singly-watermarked images but missed the double-watermark case, so 0.10 is the default.
- **It does NOT remove the visible Gemini diamond.** At strength 0.10 the img2img pass
  leaves the visible mark largely intact. Run `wmr remove` (the reverse-blend) first, or
  use `wmr remove --synthid-attack regen` which runs the visible removal before
  regen. `wmr synthid` (SynthidOnly mode) operates on the image as given.
- **Up to 4K is preserved** via tiled img2img (default on; `--regen-no-tile` disables it).
  Tiles overlap and are cosine-feathered, so seams are not visible at typical viewing
  distances.

##### CoreML backend (macOS, faster)

The CoreML backend uses native CoreML models compiled from `apple/ml-stable-diffusion`
tag 1.1.1. It is faster than CPU (~3.4x on M4 for a single image) and replaces the
broken Metal/Vulkan mac path.

**Model acquisition.** The app auto-downloads the CoreML models (~4.5 GB total) from
`huggingface.co/froggeric/wmr` on first use (cached in `~/.cache/wmr/coreml-sdxl/`).
No manual conversion is needed. To refuse the download, pass `--regen-no-download`
(errors if models are absent). Set `$WMR_COREML_SD_MODELS_DIR` to place them elsewhere.

**Manual conversion (fallback).** If you prefer to convert the models yourself, use
`apple/ml-stable-diffusion` tag 1.1.1:

1. `git clone https://github.com/apple/ml-stable-diffusion && cd ml-stable-diffusion && git checkout 1.1.1`
2. In a Python 3.12 venv install `torch==2.7.0 coremltools==9.0 diffusers==0.39.0 transformers==4.51.3 pytest`, and apply the one-line `_cast` patch in `coremltools/converters/mil/frontend/torch/ops.py` (`.item()` length-1 arrays before the cast).
3. Convert the models. **You must pass `--custom-vae-version madebyollin/sdxl-vae-fp16-fix`**: the SDXL base VAE overflows in fp16 and darkens every decode by ~15/255 without it.
   `python -m python_coreml_stable_diffusion.torch2coreml --convert-text-encoder --convert-unet --convert-vae-decoder --convert-vae-encoder --custom-vae-version madebyollin/sdxl-vae-fp16-fix --model-version stabilityai/stable-diffusion-xl-base-1.0 -o ~/.cache/wmr/coreml-sdxl`
4. Bake the empty-prompt embeddings by running `scripts/gen_coreml_sd_empty_prompt.py` from the `wmr` repo (same venv) -> `~/.cache/wmr/coreml-sdxl/empty_prompt_embeds.bin`.

Output: `.mlpackage` directories (UNet, VAE encoder/decoder, two text encoders) plus the
embeds `.bin` in `~/.cache/wmr/coreml-sdxl/`.

**Performance.** On M4 (16 GB): ~50s one-time model load, then ~9s per 1024-tile. A large
(4K-class) image regenerates in about **2 minutes** on CoreML versus about **15 minutes**
on the CPU backend on the same machine, a substantial improvement. Per-tile, CoreML is
~9s vs the CPU backend's ~143s. The UNet currently runs on CoreML's CPU path; GPU/ANE
placement is future work that would cut this further.

This mode is behind `WMR_BUILD_REGEN` + `WMR_BUILD_AI_COREML_SD`. Release macOS arm64
binaries ship both enabled. A lean build omits them and will print a rebuild hint if
you pass `--synthid-attack regen`.

### Video flags

| Flag | Description |
|------|-------------|
| `--notebooklm` | Target the NotebookLM logo + wordmark |
| `--rect x,y,w,h` | Manual watermark rect (overrides auto-detect; Gemini/Veo and NotebookLM) |
| `--notebooklm-method {auto\|ns\|migan}` | Inpaint method override (`auto` = platform default: MI-GAN-everywhere on Apple Silicon, complexity-gated elsewhere) |
| `--complexity-threshold` | NS↔MI-GAN gate (default 15; consulted only on non-arm64 `auto`) |
| `--variant` | Force geometry: `720p-1`, `720p-2`, `1080p` (otherwise it is auto-detected) |
| `--no-auto-geometry` | Skip the content-based geometry search, fall back to the resolution guess |
| `--no-edge-cleanup` | Pure reverse-blend; skip the Gemini diamond edge cleanup (on by default) |
| `--scenes` | Split multi-scene videos into separate files |
| `--scene-threshold` | Scene-cut sensitivity 0.0–1.0 (default 0.3) |
| `--crf` / `--preset` / `--codec` | Encode settings (default CRF 14, `slow`, `libx264`) |
| `--inpaint-strength` | 0.0–1.0 (default 0.85) |

**Measuring a NotebookLM `--rect`:** if auto-detection misses, grab a full-resolution frame and measure the mark's `x,y,width,height` in any image editor:

```bash
ffmpeg -ss 30 -i input.mp4 -frames:v 1 frame.png   # then measure the mark in frame.png
```

Leave ~1px border around the mark, and pick a frame where it's clearly visible (it can be faint or absent on some scenes).

### Residual cleanup (optional)

The default visible removal is a pure reverse-alpha-blend (the exact mathematical
inversion, no blur). Optionally clean up residual artifacts from an imperfect reversal
with `--denoise`. The opt-in cleanup is **residual-only** (it only touches pixels where
the reverse-blend left a real residual, so it never blurs a clean removal).

```bash
wmr remove in.png -o out.png                   # default: exact reverse-blend, no cleanup
wmr remove in.png --denoise ns -o out.png      # residual-only Navier-Stokes
wmr remove in.png --denoise telea -o out.png   # residual-only Telea
wmr remove in.png --denoise ai -o out.png      # AI (FDnCNN, release builds only)
wmr remove in.png --strength 150 -o out.png    # cleanup strength (0-300%)
```

| Flag | Range | Default | Notes |
|------|-------|---------|-------|
| `--denoise` | `off\|soft\|ns\|telea` (release adds `ai`) | `off` | Residual cleanup method (`off` = exact reverse-blend, no cleanup) |
| `--sigma` | 1–150 | 50 | FDnCNN noise level (AI only) |
| `--strength` | 0–300 % | 120 | Cleanup strength |
| `--radius` | 1–25 | 10 | Gaussian/TELEA/NS radius |

The default is `off` (exact reverse-blend, no cleanup) in every build. Release binaries also offer the `ai` method (FDnCNN); source/dev builds omit it (build with `WMR_AI_DENOISE=1` to enable, see [Build from source](#build-from-source)).

## How it works

**Visible watermarks (Gemini, Veo)** are alpha-blended overlays: `watermarked = α·logo + (1−α)·original`. With the logo and its alpha map known, removal inverts the blend exactly: `original = (watermarked − α·logo)/(1−α)`. This reverse-blend is the default and is mathematically exact; the optional `--denoise ns|telea` cleanup is **residual-only**: it predicts the clean content with `cv::inpaint` and blends it in only where the reversal left a real residual, never blurring a clean removal.

The watermark's size depends on the output resolution: **48×48** for small images (short side ≤1024; Gemini 3.6 (Gemini 3.5 used 36×36)) and **96×96** for larger ones, in the bottom-right corner. wmr **auto-detects the corner and size** via a polarity-invariant NCC template match against native per-size alpha captures, anchored on the predicted position then widened to the corner, so no manual geometry is needed (`wmr remove` just works). Templates are captured per size and never resized: the watermark's intensity is source-dependent, and resizing would smear the anti-aliased edges the exact reversal depends on. For a faint mark the auto-detect can't confirm, force the position with `--rect x,y,w,h` or `--geo-preset <name>`. Video applies the same reverse-blend per frame, with shot-level detection and anchor-based fallback so no frame is skipped; the 48px Gemini video mark is removed with the same clean per-size alpha capture used for still images, and a residual-gated edge cleanup repairs the faint border/halo at the diamond's edge (a safe no-op when the mark sits on a clean background); audio is passed through untouched.

**NotebookLM** marks are semi-transparent and color-adaptive (not a reversible alpha overlay), so they're removed by **AI inpainting** rather than reverse-blending. [MI-GAN](https://github.com/Picsart-AI-Research/MI-GAN) (MIT, ICCV 2023) synthesizes the missing region; on Apple Silicon it runs on the Neural Engine (~28 ms/frame), elsewhere on ONNX Runtime CPU, falling back to Navier-Stokes. The mark is auto-detected per video via template matching (polarity-invariant, stable across scene cuts). On Apple Silicon every scene uses MI-GAN by default; elsewhere a complexity gate picks MI-GAN for textured backgrounds and NS for uniform ones. `--notebooklm-method` overrides.

**SynthID** invisible watermarks are content-conditional neural watermarks (arXiv 2510.09263) Google attaches to Gemini image output ([Google's SynthID page](https://deepmind.google/models/synthid/)). wmr does **not** detect SynthID: Google's "Verify with SynthID" is a manual in-app tool with no API, and the spectral detector shipped before 1.16.0 had no discriminative power (ROC AUC 0.20 on Google-verifier-labeled images). The only SynthID operation wmr performs is `--synthid-attack regen`: a lossy SDXL img2img regeneration of the whole image, the single attack the published literature reports as validated, and the one we validated against Google's official verifier. It is opt-in on `remove` and the default on `synthid`. Google exposes no verifier API (only the manual in-app tool), so success cannot be confirmed in-process; see the [SynthID flags](#synthid-flags) section for its tradeoffs (lossy, ~6.5 GB download, leaves a forensic footprint) and [`docs/research/synthid-spectral-removal-record.md`](docs/research/synthid-spectral-removal-record.md) for the evidence behind removing detection.

## Performance

| Path | Speed | Notes |
|------|-------|-------|
| Gemini image (reverse-blend + AI) | milliseconds | GPU denoise when Vulkan/MoltenVK is present, else CPU |
| NotebookLM, macOS Apple Silicon | ~28 ms/frame | CoreML on the Neural Engine |
| NotebookLM, Linux/Windows | ~225 ms/frame | ONNX Runtime CPU |
| Video encode | x264, CRF 14, `slow` | Pipeline is encode-bound, not inpaint-bound |

## Build from source

Requires CMake 3.21+, a C++20 compiler, Ninja.

**vcpkg (all platforms):**
```bash
cmake -B build -S . -GNinja
cmake --build build
```

**macOS (Homebrew):** `scripts/build.sh` self-heals stale caches and verifies formulas:
```bash
brew install cmake ninja opencv ffmpeg fmt spdlog cli11 catch2
scripts/build.sh                 # release + tests
```

With AI denoise + MI-GAN (matches the release binaries; macOS uses CoreML, no ORT):
```bash
brew install vulkan-volk vulkan-loader vulkan-headers molten-vk
WMR_AI_MIGAN=1 WMR_AI_DENOISE=1 scripts/build.sh
```

Tests: `ctest --test-dir build --output-on-failure`.

## Architecture

Single-pass C++20 tool. Everything compiles into one `wmr` binary. Pipeline: **detect → remove → inpaint**, orchestrated by `WatermarkEngine`.

```
src/
├── core/        engine, alpha blend, inpaint, ai_denoise, migan_inpainter, regenerator
├── detection/   NCC visible detector, still geometry
├── video/       FFmpeg reader/writer, processor, scene + NotebookLM detectors
├── cli/         CLI11 subcommands, batch processor
└── main.cpp
assets/          embedded alpha-map PNGs + AI models (.mlpackage / .onnx, Git LFS)
tests/           Catch2 unit + integration
```

See [`CLAUDE.md`](CLAUDE.md) for the full architecture deep-dive, and [`CHANGELOG.md`](CHANGELOG.md) for version history.

## Contributing

PRs welcome. Tests use Catch2; integration tests need the project root as CWD (they look for `test-images/`). Build with tests via `scripts/build.sh`, then `ctest --test-dir build --output-on-failure`. See [`CLAUDE.md`](CLAUDE.md) for conventions, platform quirks, and the design notes behind each watermark path.

### Help wanted: faster SynthID regen on Linux & Windows

`--synthid-attack regen` now runs everywhere, but off Apple Silicon it is CPU-only and slow (minutes per image). The Linux and Windows release binaries ship CPU-only because the sdcpp ([leejet/stable-diffusion.cpp](https://github.com/leejet/stable-diffusion.cpp) + ggml) GPU backends have build gaps we could not CI-validate yet (Vulkan needs `glslc` + the loader on the linux runner; sdcpp-on-MSVC was never green in CI). If you work with **Vulkan or CUDA on ggml / stable-diffusion.cpp** and can help wire and validate a GPU regen backend for Linux/Windows, that is the biggest speedup left. A good first step: build locally with `WMR_BUILD_REGEN=ON` (no `WMR_REGEN_CPU_ONLY`), point `--regen-backend vulkan`/`cuda` at a GPU, and report the timings and whether the output still clears Google's SynthID verifier. Open an issue to coordinate.

Other welcome contributions: new watermark profiles (still or video geometry/alpha captures), higher-fidelity or faster inpaint backends, and video SynthID.

## Credits

Built on research and code from:

- [GeminiWatermarkTool](https://github.com/allenk/GeminiWatermarkTool) & [VeoWatermarkRemover](https://github.com/allenk/VeoWatermarkRemover): reverse alpha-blend, NCC detection, inpainting, FDnCNN conversion (Allen Kuo)
- [reverse-SynthID](https://github.com/aloshdenny/reverse-SynthID): SynthID spectral analysis
- [Picsart-AI-Research/MI-GAN](https://github.com/Picsart-AI-Research/MI-GAN): MI-GAN inpainting (MIT, ICCV 2023)
- [KAIR/FDnCNN](https://github.com/csjcai/KAIR) · [Tencent/ncnn](https://github.com/Tencent/ncnn) · [zeux/volk](https://github.com/zeux/volk) · [microsoft/onnxruntime](https://github.com/microsoft/onnxruntime): AI inference stack

## License

MIT. Bundled third-party licenses (NCNN, volk, KAIR/FDnCNN, MI-GAN, ONNX Runtime, OpenCV) are in [`LICENSE-THIRD-PARTY.md`](LICENSE-THIRD-PARTY.md).

gemini-watermark-and-synthid-remover

Download

Today's picks

Was this content helpful?

Recent Feedback

gemini-watermark-and-synthid-remover

Download

Today's picks

Was this content helpful?

Recent Feedback

Download README