Reverse-SynthID

The SynthID Cleaner uses the V3 spectral bypass pipeline to remove watermarks.

Workflow Logic:

• Every image is first checked using the RobustSynthIDExtractor.
• If a watermark is detected: The image undergoes the spectral bypass process.
• If no watermark is detected: The image is copied to the output folder unchanged to prevent accidental watermarking.

Technical Specifications:

• Privacy: Runs entirely locally with no network calls or telemetry.
• Requirements: Uses numpy, scipy, opencv, PyWavelets, and scikit-learn. No PyTorch or GPU is required.
• Dependencies: Uses codebooks located at ../artifacts/spectral_codebook_v3.npz (for bypass) and ../artifacts/codebook/robust_codebook.pkl (for detection).

Use the scripts/download_images.py script to download reference images (black/white) from the Hugging Face dataset. This requires huggingface_hub to be installed.

pip install huggingface_hub
python scripts/download_images.py           # download all
python scripts/download_images.py gemini_black  # download specific folder

To perform a watermark attack and verification using V4, follow these three steps:

1. Build the codebook: Generate the codebook from the enriched hierarchical dataset.
2. Run the attack: Execute the Round-06 all-in-one attack on a batch of images (this is the recommended method).
3. Verify detection: Upload each output image to the Gemini app and run SynthID detection to confirm the presence of the watermark.

For users who prefer not to use the command line, this repository includes a drag-and-drop desktop application for the V3 bypass.

Refer to gui/README.md for specific setup and usage instructions.

The SynthID Cleaner is a desktop application for removing SynthID watermarks from Gemini-generated images.

Automatic Setup

Double-click Launch SynthID Cleaner.command. On the first run, it will automatically create a virtual environment and install all necessary dependencies. This process typically takes a few minutes.

Manual Setup (Terminal)

If you prefer to set up the environment manually via the terminal, run the following commands:

1. Navigate to the gui directory.
2. Create a virtual environment.
3. Activate the environment.
4. Install dependencies from requirements-gui.txt.

cd gui
python3 -m venv venv
source venv/bin/activate
pip install -r requirements-gui.txt

To set up the environment, clone the repository, create a virtual environment, and install the required dependencies. For the Round-06 VAE stage, additional deep learning libraries are required.

git clone https://github.com/aloshdenny/reverse-SynthID.git
cd reverse-SynthID

python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt

# For Round-06 VAE stage:
pip install torch diffusers safetensors accelerate

Before manual validation, you can use the RobustSynthIDExtractor and SpectralCodebookV4 classes to verify if an image has been successfully bypassed by the V4 codebook.

from robust_extractor import RobustSynthIDExtractor
from synthid_bypass_v4 import SpectralCodebookV4

cb = SpectralCodebookV4()
cb.load('artifacts/spectral_codebook_v4.npz')

ext = RobustSynthIDExtractor()
result = ext.detect_from_v4_codebook(image_rgb, cb, 
                                     model='nano-banana-pro-preview')
print(result.is_watermarked, result.confidence, result.phase_match)

Use the SynthIDBypassV4 class to perform the recommended V4 bypass. You must load a SpectralCodebookV4 using a valid .npz artifact. The bypass_v4_file method accepts an input path, output path, the codebook, a strength preset, and the target model name.

import sys
sys.path.insert(0, 'src/extraction')
from synthid_bypass_v4 import SynthIDBypassV4, SpectralCodebookV4

cb = SpectralCodebookV4()
cb.load('artifacts/spectral_codebook_v4.npz')

b = SynthIDBypassV4()
result = b.bypass_v4_file(
    'input.png', 'output.png',
    cb,
    strength='final',                      # or 'nuke' for maximum strength
    model='gemini-3.1-flash-image-preview',
)
print(result.stages_applied)

Use the SynthIDBypass class for V3 bypass operations. This requires a SpectralCodebook loaded from a V3 .npz artifact. The bypass_v3 method operates on an RGB image array.

from src.extraction.synthid_bypass import SynthIDBypass, SpectralCodebook

codebook = SpectralCodebook()
codebook.load('artifacts/spectral_codebook_v3.npz')

bypass = SynthIDBypass()
result = bypass.bypass_v3(image_rgb, codebook, strength='aggressive')

print(f"PSNR: {result.psnr:.1f} dB")
print(f"Profile used: {result.details['profile_resolution']}")