Video Subtitle Remover Pro uses real AI neural networks to remove hard-coded subtitles and text watermarks from videos and images. Unlike simple blur or crop methods, it intelligently fills in removed areas with content that matches the surrounding video.

Based on YaoFANGUK/video-subtitle-remover, enhanced with a professional interface, real LaMa inpainting, multi-engine detection, and a 52-code language picker backed by broader OCR engine coverage.

• Real Video Inpainting -- Temporal Background Exposure (TBE) reconstructs the true background from neighbouring frames where the subtitle is absent. No external model weight downloads required.
• Real AI Inpainting -- LaMa neural network via ONNX Runtime (default, no torch dependency), OpenCV DNN weights, or an explicit PyTorch fallback opt-in
• AUTO Inpaint Routing -- Per-batch routing between TBE and LaMa based on exposure score
• Multi-Engine Detection -- RapidOCR PP-OCRv6 through OpenCV 5 DNN, ONNX Runtime, or OpenVINO > PaddleOCR > Surya (GPL opt-in) > EasyOCR > threshold fallback (automatic)
• Lossless Pipeline -- FFV1 lossless intermediate (only the final encode is lossy) for noticeably cleaner outputs than the legacy mp4v intermediate
• Modern Codec Output -- Pick H.264 / H.265 / AV1 / VVC (H.266) from a dropdown; NVENC/QSV/AMF where available, libx265 / libsvtav1 software fallback, native SVT-AV1 film grain, and VVC when FFmpeg exposes libvvenc
• Opt-in FFmpeg D3D12 Path -- FFmpeg 8.1+ can upload and scale frames with D3D12 and encode H.264/H.265 only after a byte-valid driver smoke; advertised-but-broken codecs and runtime failures fall back through NVENC/QSV/AMF and software
• Precise Multi-region Masks -- Draw or select multiple rectangle/polygon regions, enter exact source-pixel coordinates and start/end seconds or frames, nudge with arrows, resize with Ctrl+arrows, and undo or redo edits
• Moving Region Keyframes -- Scrub to two or more frames, draw rectangle or polygon anchors, and interpolate the mask deterministically through the selected motion span
• Quality-Directed Mask Correction -- Review residual, flicker, and low-confidence frame spans; paint ordered add/subtract corrections with undo/redo; then rerun only the affected frames while reusing the prior cleaned output elsewhere
• Lossless Matte Interchange -- Export exact gray8 FFV1 or PNG-sequence masks with CFR/VFR timestamps, edit them externally, preview replace/add/subtract composition, and import them through strict manifest preflight
• Erase, Translate, and Re-embed -- Opt into one cleanup pass that accepts a translated SRT or sends OCR/Whisper/source-SRT cues to a pluggable local command, then burns the validated result with configurable ASS styling and hash-backed provenance
• Inpaint Preview -- "Test cleanup" runs detect + inpaint on the selected frame so you can A/B settings before committing
• Seamless Boundaries -- Gaussian alpha feathering at every inpaint boundary, no visible cut lines
• Language Support -- 52 selectable OCR language codes in the GUI, with installed OCR engines reporting broader capacity: RapidOCR 100+, PaddleOCR 106, Surya 90+ (GPL opt-in), and EasyOCR 80+; gettext catalogs in locale/<BCP-47 tag>/LC_MESSAGES/vsr.mo are packaged, preserve script/territory fallback, and follow the Windows interface locale
• GPU Acceleration -- NVIDIA CUDA, AMD/Intel DirectML through ONNX Runtime, hardware-decode hints (D3D11 / VAAPI / MFX), CPU fallback
• Subtitle Region Selector -- Scrub to any frame and draw one or more rectangles; use optional start/end seconds to save time-ranged manual masks
• Batch Processing -- Queue files or drag entire folders; per-item cancellation plus safe pause/resume for long videos
• Multi-track Audio + Loudness Normalisation -- Pass through every audio track on Bluray rips; optional per-stream EBU R128 normalisation to LUFS targets (YouTube -14, Apple -16, broadcast -23)
• Quality Self-Test -- PSNR / SSIM report, optional FFmpeg/libvmaf VMAF score, ROI-cropped metrics for the inpaint region, and an optional side-by-side comparison PNG
• CLI + Presets -- python -m backend.processor --pattern ... --preset "YouTube (default)"; six built-in presets + user presets persisted to %APPDATA%
• Chyron vs Subtitle Filter -- Keep persistent text (logos, lower-thirds) and remove dialogue, or vice versa
• Karaoke Grouping -- Per-syllable boxes fuse into a single line mask so highlighted lyrics do not leak through the gaps
• Live Preview During Processing -- 15 FPS throttled preview piped from the backend worker
• Pre-batch ETA Estimate -- 30-frame detect probe seeds the ETA so users see "about X left" from the very first frame
• Pause/Resume Checkpointing -- SHA-256 input fingerprint per file; finished files are skipped and paused videos resume from durable checkpoint frames
• Backend Status -- Help shows OCR/inpaint backends, language picker vs. engine capacity, ONNX/OpenCV providers, required model files, hash state, FFmpeg capability profiles, and the next setup action
• Premium Dark UI -- Cohesive design system with custom controls, rectangular status tiles, responsive workbench scrolling, taskbar progress, and onboarding
• Settings Persistence -- All knobs saved/restored between sessions; versioned schema with backfill migration
• Release Tooling -- Local PyInstaller/NSIS build scripts, dependency checks, support bundles, and winget-ready installer metadata

1. Download or clone this repository
2. Double-click Run_VSR_Pro.bat — first run automatically:
   • Creates a virtual environment
   • Detects your GPU and installs appropriate packages
   • Installs the reviewed RapidOCR/ONNX runtime for the detected hardware
   • Launches the application
   • On later launches, verifies core packages and repairs a broken venv without stdin prompts
   • Use Run_VSR_Pro_Debug.bat for a visible troubleshooting console, or Run_VSR_Pro.ps1 when you prefer launching from PowerShell

After the Windows Package Manager manifest is accepted, signed release installers can also be installed with:

winget install SysAdminDoc.VideoSubtitleRemoverPro

cd VideoSubtitleRemover

# Create virtual environment
python -m venv venv
.\venv\Scripts\activate

# Choose a reviewed profile: cpu, nvidia, or directml.
$profile = "cpu"

# Install PyTorch (Python 3.12/3.13 recommended for CUDA):
# NVIDIA RTX 20/30/40/50-series:
pip install torch>=2.10.0 torchvision>=0.25.0 --constraint "dependency_profiles/$profile.txt" --index-url https://download.pytorch.org/whl/cu128
# CPU:
pip install torch>=2.10.0 torchvision>=0.25.0 --constraint "dependency_profiles/$profile.txt" --index-url https://download.pytorch.org/whl/cpu

# Install dependencies
pip install -r requirements.txt --constraint "dependency_profiles/$profile.txt"

# Run
python VideoSubtitleRemover.py

python setup.py --profile auto selects the reviewed CPU, NVIDIA, or DirectML profile from detected hardware; pass a profile name explicitly for repeatable CI or repair installs. Maintainers update dependency_profiles.json, run python -m backend.dependency_profiles update, review the emitted diffs, and then run python -m backend.dependency_profiles check. Generated constraint and manifest SHA-256 values are included in release evidence. PaddleOCR, EasyOCR, and legacy simple-lama-inpainting remain isolated opt-ins because their OpenCV wheel ownership or NumPy caps conflict with the primary runtime. Python 3.11 is the minimum supported interpreter because the security-reviewed ONNX Runtime CPU/CUDA floor and pinned DirectML release do not provide Python 3.10 wheels.

winget install ffmpeg

Use FFmpeg 8.1.2+ on the 8.1 branch, or 8.0.3+ on the 8.0 branch. VSR decodes untrusted media through FFmpeg, and builds 8.1.0-8.1.1 and 8.0.0-8.0.2 predate the security backports for CVE-2026-8461 (MagicYUV heap out-of-bounds write, RCE) and CVE-2026-30999. Older branches are outside VSR's reviewed support policy; development snapshots and future branches remain unknown until explicitly classified. The self-test, support bundle, and strict release validation block vulnerable, unsupported, and unknown runtimes.

Build toolchain floors: the local build requires PyInstaller >= 6.10.0 (CVE-2025-59042 writable-CWD LPE) and the installer requires NSIS >= 3.12 (elevated Low IL temp-directory privilege-escalation hardening); installer/vsr.nsi fails to compile on an older NSIS, and strict release validation flags both.

Run python -m backend.processor --self-test to confirm the installed build's basic, advanced_quality, speech_fallback, and modern_codec profiles. Those profiles report missing filters such as loudnorm, libvmaf, or whisper, missing encoders such as libvvenc, and OpenCV wheel ownership before a long batch starts.

Run python -m backend.cli --ocr-benchmark to score the active OCR detector (RapidOCR ships PP-OCRv6) on synthetic ground-truth subtitle fixtures -- detection recall plus per-frame latency -- and print JSON evidence. Any change to the default detector should be gated on the meets_floors verdict (recall

= 0.8); latency is reported as device-dependent evidence, not a hard gate.

Run python -m backend.cli --inference-smoke to prove the OCR and inpaint backends actually execute: it pushes a generated text image and masked frame through the detector and inpainter, printing the real engine / execution provider (e.g. RapidOCR, ONNX (CUDAExecutionProvider), or a cv2 fallback) and timing, and exits non-zero if a backend that loaded cannot run inference. No model weights are downloaded; add --gpu N to test a CUDA device.

python -m pip install ruff==0.15.20
python -m ruff check backend gui scripts VideoSubtitleRemover.py --no-cache
python scripts/generate_cli_reference.py
python scripts/i18n_catalogs.py check
python -m unittest discover -s tests -v
python -m backend.reference_corpus --json
python tools/local_smoke.py

build_exe.bat is the fail-closed local release command. It runs the Ruff source-hygiene gate and complete unit suite, builds the PyInstaller folder, compiles the production NSIS installer plus a non-elevated extraction harness, smoke-tests every frozen entry point and the extracted installer payload, runs the reference corpus, audits the exact frozen Python components with pip-audit, and applies strict runtime/advisory gates. It exits nonzero at the first failed stage.

The default frozen profile packages RapidOCR/ONNX and excludes the multi-gigabyte PaddleOCR, EasyOCR, and PyTorch fallbacks. Set VSR_ENABLE_FULL_OCR=1 and/or VSR_ENABLE_PYTORCH_LAMA=1 before the build to include those optional runtimes intentionally. sbom.cdx.json is derived from PyInstaller's Analysis-00.toc: required Python libraries and hashed native files reflect the folder that actually ships, while PyInstaller and other build tools are marked with excluded scope. release-verification.json and pip-audit.json record the remaining release proof.

For an isolated CPU smoke without touching the Windows launcher, run the same check in the local container recipe:

docker build -t vsr-pro-smoke .
docker run --rm vsr-pro-smoke

The container path installs only the minimal CPU smoke dependencies (including the canonical onnxruntime>=1.25.0 security floor), records the resolved ONNX Runtime version/providers, runs python -m backend.processor --self-test, then processes a generated tiny image through the CLI with a fixed mask.

1. Launch via Run_VSR_Pro.bat, Run_VSR_Pro_Debug.bat, or Run_VSR_Pro.ps1
2. Add files -- Click to browse, right-click for folders, or drag & drop
3. Select algorithm — LAMA (recommended), STTN, or ProPainter
4. Set language if subtitles are non-English
5. Optionally set region — select a queued item and drag on the preview for a fixed subtitle band, or use the settings card's Set Region action for multi-region and timed ranges. The full selector supports exact rectangle or polygon coordinates, second/frame timing, arrow-key nudging, Ctrl+arrow resizing, and Ctrl+Z/Ctrl+Y history.
6. Start Processing and monitor progress
7. Select a queue item to preview it, use Review mask to confirm detection, and double-click the preview for a larger source frame. Right-click the queue card, or press Menu / Shift+F10 while it is focused, for all per-item actions.

All three modes now do real inpainting. STTN recovers the literal background from adjacent frames where the subtitle is absent -- this works because hard-coded subtitles are sparse in time, and the pixels behind them are revealed whenever the text changes or disappears. LAMA is a single-frame neural fill. ProPainter is a TBE + LaMa refinement hybrid -- it is not the ICCV 2023 ProPainter model or weights (which carry a non-commercial NTU S-Lab license). This implementation uses only MIT-licensed code.

The app automatically selects the best available engine:

Experimental VLM OCR tiers stay default-off. VSR_VLM_OCR=florence2, VSR_VLM_OCR=qwen25vl, and VSR_VLM_OCR=paddleocr-vl try the heavier transformer/PaddleOCR adapters before the table above. For CPU/edge PaddleOCR-VL-1.5, start a local llama.cpp OpenAI-compatible server with the GGUF model, then set VSR_PADDLEOCR_VL=1; use VSR_PADDLEOCR_VL_SERVER_URL when the server is not at http://127.0.0.1:8080/v1. If the server or PaddleOCRVL entrypoint is not available, detection falls back to the normal cascade.

On NVIDIA systems, setup installs onnxruntime-gpu>=1.25.0 for the tested CUDA 12.x ONNX Runtime path; CUDA 13.x currently requires ONNX Runtime nightly/custom wheels rather than the stable PyPI default. ONNX Runtime >=1.25.0 is required for the CPU and CUDA packages -- VSR runs untrusted OCR/inpaint ONNX models through the runtime, and the self-test and strict release validation flag older CPU/CUDA builds as a blocking security advisory. Backend status and release evidence distinguish onnxruntime, onnxruntime-gpu, CUDA package channel, onnxruntime-directml, and the providers reported at runtime. On AMD/Intel systems, setup preflights and installs the latest published/reviewed DirectML wheel, onnxruntime-directml==1.24.4; incompatible Python/platform combinations fail before the environment is changed and point to CPU or the Windows ML audit. DirectML is in sustained engineering, with new Windows ONNX Runtime feature development moving to Windows ML, so diagnostics and release evidence report that lifecycle separately from CPU/CUDA security floors. On Intel systems setup also tries openvino>=2025.0.0 so RapidOCR can use its OpenVINO engine for CPU/iGPU OCR acceleration. OpenCV 5 DNN runs RapidOCR's bundled PP-OCRv6 detection and recognition models on CPU without ONNX Runtime; python -m backend.cli --ocr-benchmark --ocr-engine opencv-dnn records recall, latency, and resident-memory evidence. Set VSR_RAPIDOCR_ENGINE=opencv to force that path, VSR_RAPIDOCR_ENGINE=onnxruntime to force ONNX Runtime, or VSR_RAPIDOCR_ENGINE=openvino to request OpenVINO explicitly. When ONNX Runtime reports DmlExecutionProvider, RapidOCR is initialized with its DirectML provider settings; unsupported RapidOCR versions or missing providers fall back to CPU automatically. OpenVINO initialization failures also fall back to ONNX Runtime. RapidOCR legacy tuple output and current structured object/dict output are both normalized to the same axis-aligned detector boxes. Opt-in ONNX inpainters inspect their model opset_import metadata before creating a DirectML session; if the default ONNX opset is newer than DirectML's supported ceiling, VSR uses the CPU provider instead of failing at session creation. Windows ML is currently audit-only, not a replacement for ONNX Runtime DirectML. Run python -m backend.processor --audit-windows-ml on Windows to check whether the Python bridge, Windows App SDK bootstrap, ONNX Runtime EP device catalog, and a tiny ONNX identity-model smoke run are available. Until that probe passes on real user machines and the default OCR/inpaint models are benchmarked through the Windows ML path, VSR keeps DirectML as the AMD/Intel GPU route.

Optional model paths such as VSR_LAMA_ONNX, VSR_MIGAN_ONNX, VSR_FASTDVDNET, VSR_TRANSNETV2, VSR_VACE_CKPT_DIR, and VSR_VIDEOPAINTER_CKPT_DIR, and VSR_FLOED_WEIGHTS are checked against a local adapter manifest before loading. Known SHA-256 mismatches fall back instead of deserializing the file. Legacy adapters without a pinned hash still run, but new strict adapters can require a known hash unless VSR_ALLOW_UNVERIFIED_MODELS=1 is set and recorded in release evidence. Local release evidence also writes release-advisories.json; strict mode blocks unallowed high/critical dependency advisories. The reviewed OpenCV 5.0.0.93 wheel bundles libpng 1.6.57, so older vulnerable OpenCV builds no longer receive a release exception. Wan2.1-VACE is available as an opt-in registry mode: set VSR_VACE=1, install the reviewed upstream vace package, then either set VSR_VACE_CKPT_DIR to a local Wan-AI/Wan2.1-VACE-1.3B snapshot or set VSR_VACE_AUTO_FETCH=1 with huggingface-hub installed to fetch it into the app model cache. VideoPainter is available only as a strict local research adapter: set VSR_VIDEOPAINTER=1, review the upstream research/non-commercial and CogVideoX license terms, set VSR_VIDEOPAINTER_CKPT_DIR to a local checkpoint root, set VSR_VIDEOPAINTER_COMMAND to a local wrapper that accepts --input-video, --mask-video, and --output-video, and opt in with VSR_ALLOW_UNVERIFIED_MODELS=1 for unpinned research weights. FloED is available as a strict local research adapter: set VSR_FLOED=1, set VSR_FLOED_WEIGHTS or VSR_FLOED_CKPT_DIR to a reviewed FloED checkpoint, set VSR_FLOED_COMMAND to a local wrapper that accepts --input-dir, --mask-dir, and --output-dir, and opt in with VSR_ALLOW_UNVERIFIED_MODELS=1 for unpinned research weights. MatAnyone 2 is available as an opt-in mask refinement path for decorated or thin subtitle masks: pass --matanyone-refine, set VSR_MATANYONE=1, install the reviewed upstream matanyone2 package, and set VSR_MATANYONE_PATH to a local checkpoint or snapshot after reviewing the NTU S-Lab License 1.0 terms. Unpinned PyTorch checkpoints require VSR_ALLOW_UNVERIFIED_MODELS=1; malformed or missing alpha mattes fall back to the original OCR/SAM mask. CoTracker3 can fill OCR-empty masks inside a video batch by propagating sparse points from the nearest detected subtitle mask: pass --cotracker-propagate, set VSR_COTRACKER=1, and set either VSR_COTRACKER_REPO to a reviewed local co-tracker checkout or VSR_COTRACKER_REF to a full 40-character commit SHA before any torch.hub load is allowed. Tags and branches are rejected because they can move after review. Set VSR_COTRACKER_MODE=online only if you need the online model; the default uses the offline CoTracker3 entrypoint. VapourSynth .vpy input executes Python and therefore requires both VSR_VAPOURSYNTH=1 and VSR_VAPOURSYNTH_SCRIPT_DIR pointing to a reviewed script directory. Scripts that resolve outside that directory are rejected, including through symlinks. NVIDIA users can request PyNvVideoCodec decode with --decode-accel pynv or --decode-accel nvdec after installing NVIDIA's PyNvVideoCodec package. The decoder uses GPU-backed surfaces when available, then converts to CPU BGR frames for the current OpenCV/OCR/inpaint pipeline; missing packages or failed opens fall back to software decode. Smooth-background clips can trade precision for throughput with --rife-fast-stride N: VSR inpaints keyframes every N frames, asks Practical-RIFE to synthesize the skipped cleaned frames when practical-rife is installed, and duplicates the nearer cleaned keyframe across scene cuts or missing RIFE adapters. The legacy simple-lama-inpainting PyTorch backend is disabled unless VSR_ENABLE_PYTORCH_LAMA=1 is set, because broken native torch wheels can crash the GUI process during import. Its NumPy <2 cap also conflicts with the primary OpenCV runtime, so use a separate legacy environment. Prefer VSR_LAMA_ONNX or VSR_OPENCV_LAMA for automatic LaMa acceleration.

Process files from the command line:

python -m backend.processor -i input.mp4 -o output.mp4 -m lama --lang en --crf 20

For OCR-empty frames with speech, the optional Whisper fallback can mask the bottom subtitle band. The default backend is faster-whisper; FFmpeg 8 builds that include the whisper filter can instead use a local whisper.cpp ggml model without Python ML dependencies:

python -m backend.processor -i input.mp4 -o output.mp4 --whisper-fallback --whisper-backend ffmpeg --ffmpeg-whisper-model C:\models\ggml-base.en.bin

The localization workflow can erase the original burned-in text and re-embed a translated UTF-8 SRT in the same run. Supplying the translated captions is the simplest deterministic path:

python -m backend.processor -i input.mp4 -o localized.mp4 --translated-srt captions.es.srt --translation-style "FontSize=24,Outline=2"

To generate captions, provide a source SRT or let the existing OCR collection (and then an enabled Whisper fallback) supply source cues. VSR invokes the selected command directly without a shell and sends one bounded JSON document on stdin; VSR does not include or contact a translation service. The chosen command controls how cue text is handled:

python -m backend.processor -i input.mp4 -o localized.mp4 --translate --translation-source-srt captions.en.srt --translation-source-lang en --translation-target-lang es --translation-command C:\tools\translate.py

The request schema is vsr.translation_request.v1 with sourceLanguage, targetLanguage, and cues entries containing index and text. The command must return vsr.translation_response.v1 with a translations array in the same order and length. Timing and cue identifiers stay unchanged; empty, malformed, oversized, or count-mismatched results fail the job. Generated source and translated SRTs are saved beside the video. The reproducibility sidecar records their names, SHA-256 hashes, provider, source kind, languages, and final embed status without recording caption text. The workflow is off by default and cannot be combined with the separate --restyle pass.

Embedded subtitle tracks can be inspected or remuxed without OCR, frame decode, inpainting, or video re-encode:

python -m backend.processor -i input.mkv --soft-subtitle-dry-run
python -m backend.processor --pattern "inputs/*.mkv" --soft-subtitle-dry-run --soft-subtitle-plan-json soft-plan.json
python -m backend.processor -i input.mkv -o stripped.mkv --strip-soft-subtitles

When the input is a directory of images, --output-frames writes the cleaned frames as individual PNGs instead of encoding a video:

python -m backend.processor -i frames_dir/ -o cleaned_dir/ --output-frames

In the GUI, queued videos with embedded subtitle tracks show a track summary; right-click the item to fast strip, fast remux/keep, or continue with burned-in cleanup.

Pattern batches and GUI batches write vsr-batch-summary.json and vsr-batch-summary.md next to their outputs when they finish. The report records each input, selected output path, codec/duration/subtitle preflight data, source-aware output-quality warning, planned action, final status, and elapsed time for skipped, checkpointed, paused, remuxed, processed, or failed files. They also break each item down by decode, OCR, mask, inpaint, encode, mux, and quality-analysis time, with a run-level slowest-stage summary for diagnosing slow hardware, OCR, model, or muxing bottlenecks. Before processing, CLI and GUI batches compare source codec/resolution/bitrate against the selected output codec and CRF; risky settings are shown as preflight warnings, and the report records the safer recommendation plus that the user continued after the warning. When quality reports are enabled, batch summaries also include a passed, review, or unknown quality gate using ROI metrics, a cheap residual-text score, and an adjacent-frame temporal flicker score, plus any quality-sheet preview path for review-needed outputs. A failed gate changes the batch row status to review-needed; skipped and remux-only rows are marked not_applicable. Review-needed queue items expose Retry with suggested settings, which applies the quality gate's ladder step to that item only and records the before/after retry config in the next batch report. When the gate identifies residual text, adjacent-frame flicker, or a low-confidence detection, Correct mask opens the flagged frame span in an internal editor. Paint missing mask pixels or subtract over-masked pixels, optionally propagate the stroke through the bounded span, and use undo/redo before preparing the retry. VSR persists the ordered corrections with exact frame bounds and, when the prior cleaned output is still available, reprocesses only those ranges while copying the previously cleaned frames everywhere else.

Masks and soft alpha mattes can round-trip through an external compositor without the old lossy .mask.mp4 artifact. FFV1 writes <output>.mask.mkv; PNG mode writes <output>.mask/frame_########.png. Both formats include <output>.mask.json with exact source frame bounds, CFR/VFR timestamps, durations, dimensions, and the export hash:

python -m backend.processor -i input.mp4 -o cleaned.mp4 --export-mask --mask-export-format ffv1
python -m backend.processor -i input.mp4 -o cleaned.mp4 --export-mask --mask-export-format png
python -m backend.processor -i input.mp4 -o revised.mp4 --import-mask cleaned.mask.json --mask-import-mode replace

Edit the referenced artifact while keeping the manifest beside it, then import in replace, add, or subtract mode. VSR validates every frame, dimension, frame count, timestamp, duration, and timing mode before processing begins. The output reproducibility sidecar records the imported artifact's current SHA-256, whether it differs from the exported hash, and the deterministic mask composition order. Review mask shows that composed result before a run.

Long video runs can pause at safe frame-batch boundaries. In the GUI, click Pause batch while processing; the current video writes checkpoint frames under the selected work directory, or under %APPDATA%\VideoSubtitleRemoverPro\checkpoints\ when no work directory is set, and returns to the queue as Paused. Starting the batch again resumes from the first missing frame. In the CLI, press Ctrl-C once to request the same safe pause; re-run the same command to resume. If the input, output path, frame count, frame rate, size, or processing settings changed, VSR warns and restarts that file from the beginning instead of trusting stale checkpoint frames.

Use the Edge-case clip GitHub issue form before adding real media to tests/clips/. Real fixtures must be short, redistributable with this MIT-licensed project, and manifest-backed with SHA-256, source URL, license proof URL, retrieval date, rights confirmation, reproduction settings, and metric floors. Good starting sources are NASA public-domain media, Library of Congress public-domain media, Wikimedia Commons compatible-license files, or a clip you shot and grant as CC0.

This table is generated from the live argparse actions and their category, default, range, visibility, and deprecation metadata. Regenerate it with python scripts/generate_cli_reference.py --write.

--config accepts the same manual region schema used by the GUI. Use subtitle_area for one global rectangle, subtitle_areas for multiple global rectangles, subtitle_region_spans for frame-time-specific masks, or subtitle_region_keyframes for an interpolated moving rectangle/polygon:

{
  "subtitle_region_spans": [
    {"rect": [80, 720, 1180, 820], "start": 0.0, "end": 14.5},
    {"rect": [120, 40, 900, 150], "start": 14.5, "end": 0.0}
  ],
  "sttn_skip_detection": true
}

Moving-region tracks use source-pixel coordinates and require at least two same-shape anchors. Polygon anchors keep the same vertex count across the track:

{
  "subtitle_region_keyframes": [
    {
      "keyframes": [
        {"time": 2.0, "polygon": [80, 700, 420, 700, 420, 790, 80, 790]},
        {"time": 8.0, "polygon": [520, 680, 860, 680, 860, 770, 520, 770]}
      ]
    }
  ],
  "sttn_skip_detection": true
}

end: 0.0 means the region stays active through the end of the processed range. With sttn_skip_detection enabled, inactive timed ranges produce an empty mask instead of reusing a previous manual mask.

Queue-card Copy CLI command output includes a schema version and repeatable --set FIELD=JSON values for every non-default per-item processing control. This keeps fields without a dedicated legacy flag reproducible too. Use --validate-config to inspect the complete resolved canonical config.

Settings are stored in %APPDATA%\VideoSubtitleRemoverPro\settings.json and persist across sessions.

These fields are accepted by --set FIELD=JSON and JSON config overlays. The table is generated directly from ProcessingConfig in registry order.

The D3D12 option stays off by default because advertised FFmpeg capabilities do not prove that a display driver accepts a codec profile. Each selected codec must first produce and re-read a complete 30-frame MP4. Processing then uses D3D12 frame upload and scale_d3d12; interlaced SDR input also tries deinterlace_d3d12. A failed smoke or processing command automatically moves to the existing NVENC/QSV/AMF chain and then to the software encoder.

At 150% and 200%, the minimum 980x720 window switches to a compact, vertically scrollable layout so actions stay keyboard reachable without horizontal scrolling. The setting is under Detailed controls and applies to both the default and high-contrast themes after restart.

The same panel offers a restart-applied interface language selector with System, English, and every compiled catalog discovered under locale/ or the per-user %APPDATA%\VideoSubtitleRemoverPro\locale\ directory. Translation contributors can refresh the POT template, merge PO files, build the bundled pseudo-locale, validate placeholders/plurals/UTF-8, compile MO files, and print coverage in one deterministic command:

python scripts/i18n_catalogs.py update

Use python scripts/i18n_catalogs.py check in review or CI; it fails when the template, PO keys, pseudo-locale, or compiled catalogs drift.

.\venv\Scripts\activate
pip uninstall -y torch torchvision
pip install torch>=2.10.0 torchvision>=0.25.0 --index-url https://download.pytorch.org/whl/cu128

• GUI log panel (collapsible, click "Open Log File" for full log)
• File log: %APPDATA%\VideoSubtitleRemoverPro\vsr_pro.log (5MB rotating)
• About -> Support bundle saves a redacted .zip with runtime facts, dependency versions, settings summary, recent log lines, and batch report evidence, including per-stage timing summaries. CLI equivalent: python -m backend.cli --support-bundle support.zip
• About -> Model cache can export/import a portable cache bundle. CLI equivalents: python -m backend.cli --model-cache-export models.zip and python -m backend.cli --model-cache-import models.zip

VideoSubtitleRemover/
|-- VideoSubtitleRemover.py   # Main GUI application
|-- Dockerfile                # Local CPU-only smoke container recipe
|-- .dockerignore             # Excludes build outputs, models, and venvs
|-- gui/
|   |-- app.py                # Main Tk shell and shared UI state
|   |-- processing_controller.py  # Queue worker, pause/stop, reports, notify
|   |-- preview_controller.py     # Preview, A/B compare, inline region editor
|   |-- quality_controller.py     # Quality review, retry, report helpers
|   |-- support_controller.py     # Support bundle, model cache, About panels
|   |-- widgets.py            # Custom Tk controls
|   |-- config.py             # GUI config, queue state, presets
|   `-- theme.py              # Design tokens
|-- backend/
|   |-- __init__.py           # Module exports
|   |-- processor.py          # Legacy import/CLI compatibility shim
|   |-- detection.py          # OCR cascade and detector routing
|   |-- tracking.py           # Kalman, pHash, karaoke helpers
|   |-- io.py                 # Capture, ffprobe, intermediate writers
|   |-- cli.py                # Command-line entry point
|   |-- resume_checkpoint.py  # Durable pause/resume checkpoint helpers
|   |-- inpainters/           # Built-in STTN/LaMa/ProPainter/AUTO paths
|   |-- presets.py            # Shared preset library (GUI + CLI)
|   |-- adapter_manifest.py   # Optional model provenance and hash policy
|   `-- model_hashes.py       # Vendored SHA-256 weight hashes
|-- docs/
|   |-- architecture.md       # Pipeline map for new contributors
|   |-- edge_case_corpus.md   # Community regression-corpus guide
|   `-- archive/              # Retired audits and completed checklists
|-- ROADMAP.md                # Active incomplete work
|-- RESEARCH.md               # Current research synthesis
|-- setup.py                  # First-time environment setup
|-- Run_VSR_Pro.bat           # Windows launcher
|-- Run_VSR_Pro_Debug.bat     # Windows launcher with a visible console
|-- Run_VSR_Pro.ps1           # PowerShell launcher
|-- build_exe.bat             # PyInstaller build script
|-- requirements.txt          # Python dependencies
|-- tests/                    # Focused regression coverage for hardened paths
|-- tools/                    # Local developer smoke helpers
|-- .github/                  # Issue templates
|-- assets/                   # Application assets
|-- models/                   # AI model weights (auto-downloaded)
`-- output/                   # Default output location

See docs/architecture.md for a walkthrough of the detect -> tracker -> mask -> TBE -> refine -> mux pipeline and the "add a new feature" checklist.

Planning entry points: ROADMAP.md for active incomplete work and RESEARCH.md for current research synthesis. Retired audits and completed checklists live under docs/archive/.

• Original project: YaoFANGUK/video-subtitle-remover
• LaMa inpainting: simple-lama-inpainting
• EasyOCR: JaidedAI/EasyOCR
• STTN: Learning Joint Spatial-Temporal Transformations
• ProPainter (research reference): sczhou/ProPainter -- VSR's "ProPainter" mode is a TBE + LaMa hybrid inspired by the concept; it does not use the upstream ProPainter code or weights

This project is licensed under the MIT License.