FrameMend Portable

Modification notice: This README was modified from linkedlist771/SoraWatermarkCleaner by the FrameMend Portable fork; see CHANGELOG.md.

Sora watermark remover for Windows — an independent portable fork optimized for NVIDIA GeForce RTX GPUs with CUDA acceleration and expanded temporal cleanup.

RC.13 prerelease identity: the release tag is windows-cuda-v0.1.0-rc.13, with FrameMend-Portable-Windows-CUDA-v0.1.0-rc.13.zip and its adjacent .zip.sha256 file as the only eligible public binary assets. When available, download those exact named files from the Releases page; do not use GitHub's automatically generated source-code archives as the portable app. This document does not by itself establish that an asset is currently available; verify the immutable release record and checksum on the Releases page. The bounded RC.13 evidence is recorded in the release notes; it does not establish universal hardware, stability, compatibility, or visual-quality guarantees.

Technical license warning: RC.13's audit still contains unresolved model- rights and redistribution entries, including the detector weights and PCM weights. This is not legal advice, and this build is not represented as fully license-cleared. Acknowledging a warning records that it was reviewed; it does not create permission, cure a licensing issue, or grant additional rights.

English | Русский | Українська | Deutsch | Chahta Anumpa | 中文

Documentation: Complete Windows user guide · Visual Windows quick start · Detailed one-click portable guide · CLI reference · Source, Python, and Web interfaces · RC.13 release notes

Independent-fork notice: FrameMend Portable is an independent fork of SoraWatermarkCleaner, created by linkedlist771 and distributed under Apache-2.0. It is not affiliated with or endorsed by linkedlist771, OpenAI, or NVIDIA.

This fork's Windows portability, RTX 50-series CUDA profile, batch queue, four-engine cleaning path, advanced scene/track-safe temporal cleanup, optional NVIDIA VFX cleanup and Video Super Resolution processing, NVENC path, interrupted-batch recovery, and source-preservation hardening were developed by Andrei Pemberton (@andreipemberton) in collaboration with Lilitari, an AI collaborator credited by name rather than through a GitHub account. The FrameMend fork repository and releases are maintained and published by Andrei Pemberton.

FrameMend Portable detects the moving Sora watermark with a YOLO model and inpaints the detected region. Use it only on videos you own or are authorized to modify.

Fork development history is tracked in CHANGELOG.md.

Project description: FrameMend Portable is an independent, Windows-portable Sora watermark remover with multi-file batch processing, individual clean outputs, LaMa, E2FGVI-HQ, ProPainter, experimental DiffuEraser, source-faithful NVENC and lossless-master output profiles, optional same-resolution NVIDIA VFX cleanup and upscaling, RTX 50-series CUDA tuning, expanded temporal cleanup, manual interrupted-batch recovery, and five selectable Web UI locales. CUDA is required for all temporal engines and NVIDIA VFX processing; LaMa has a slower CPU fallback. Developed by Andrei Pemberton with AI collaborator Lilitari.

Watermark removed sora_watermark_removed.mp4

Original sora_watermark_original.mp4

What this fork improves

• A self-bootstrapping, location-independent Windows launcher
• An updater-aware portable layout. RC.12 must be installed manually once; later eligible releases can be offered at Web startup and are applied only after immutable GitHub release metadata, the exact ZIP digest, the internal managed-file inventory, and the final launcher.dat commit marker agree
• A private CPython 3.13.15 runtime and FFmpeg kept inside the extracted folder
• PyTorch 2.13.0 and TorchVision 0.28.0 on CUDA 13.0, with native RTX 50-series (sm_120) support
• A coordinated runtime security refresh to pip 26.2.1, Gradio 6.25.0, FastAPI 0.141.1, Starlette 1.6.0, Pillow 12.3.0, and Requests 2.34.2, plus Diffusers 0.40.0's sharded-checkpoint path-validation fix, while retaining tested Transformers 5.14.1 and moving FFmpeg to retained stable build n8.1.2-34-g9b6c8969e0
• The bounded DiffuEraser gate described below was repeated under Diffusers 0.40.0: the 22×264×264 synthetic CUDA probe passed on an RTX 5070 Ti with exact outside-mask pixels. This is final-runtime evidence for that bounded probe only, not representative real-video validation
• Click-to-browse multi-video selection, repeated add-more selection, and drag-and-drop
• An independent Remove watermarks toggle plus optional NVIDIA same-resolution Denoise and Deblur controls plus optional upscaling. Cleanup-only, upscale-only, and any supported chain can run without watermark removal; only a batch with every processing stage disabled is rejected
• Denoise and Deblur can be selected independently or together. The advanced chain runs Denoise → Deblur → Upscale and warns about possible texture loss, halos, ringing, and overprocessing
• A supported CLI and Python batch API backed by the same framemend.pipeline service as the Web UI, including processing, recovery, diagnostics, model preparation, license inspection, and cancellation
• Selectable English, Russian, Ukrainian, German, and modern Choctaw web UI; English is always the default
• Four cleaning engines: fast frame-batched LaMa, E2FGVI-HQ, optional ProPainter, and experimental DiffuEraser
• Optional NVIDIA VFX Denoise and/or Deblur at the source resolution, followed sequentially by optional Video Super Resolution with one final encode. Native *_clean masters are always retained when watermark removal is used
• Hard scene cuts and watermark-track jumps split temporal inference, so unrelated shots or watermark positions are not mixed in one model window
• Selectable Conservative, Standard, and Wider mask coverage with validated scene-local box smoothing and bounded gap recovery
• Selectable balanced, high-quality H.264, and FFV1 lossless-master output profiles, with NVENC acceleration and automatic x264 fallback
• Exact no-reencode passthrough when no watermark is detected
• Bit-for-bit compatible audio copying, with high-quality AAC only as a compatibility fallback
• Source frame-rate, color tags, container metadata, and chapters preserved where the edited output format permits
• A complete hash-locked Windows dependency set plus SHA-256 verification and atomic installation for Python, pip, FFmpeg, and all three model files
• App-local Microsoft C++ runtime files, so PyTorch does not depend on a preinstalled Visual C++ Redistributable
• Local caches, models, temporary files, logs, and outputs — no dependency on a developer's AppData or Torch cache
• Audio-merge recovery that preserves a successfully cleaned video
• Atomic batch_state.json manifests and a localized, manual Recover interrupted batch panel that revalidates finished files and retries only pending or interrupted work. Schema 3 adds strong source digests and keeps recoverable schema-1/schema-2 manifests loadable without discarding completed outputs. A narrow legacy Gradio-cache check can prove timestamp-only rewrites without weakening path, size, or changed-content rejection
• Recovery validation and bounded errors are visible; controls and a server-side single-flight lock prevent duplicate Resume requests; the Web UI publishes only outputs newly completed by the current resume attempt
• Local-only Gradio binding on 127.0.0.1 by default

CUDA requirement — read this first

Mode	Requirement	Notes
LaMa (Fast)	NVIDIA CUDA recommended, not mandatory	Has a much slower CPU fallback
E2FGVI-HQ (Temporal Quality)	NVIDIA GPU with working CUDA driver required	Established temporal option; model downloads on demand
ProPainter (High Quality)	NVIDIA CUDA required	Optional ~0.19 GiB non-commercial model pack
DiffuEraser (Experimental)	NVIDIA CUDA required	Adds ~8.86 GiB after ProPainter; extremely slow; one bounded 22×264×264 synthetic CUDA probe passed on an RTX 5070 Ti, not representative real-video validation
NVIDIA Denoise/Deblur and Video Super Resolution (optional)	NVIDIA CUDA required	Pinned NVIDIA VFX 0.1.0.1; first use requires NVIDIA-terms acceptance and downloads about 468 MiB
High-quality output	Compatible NVIDIA driver/GPU recommended	NVENC P7/CQ16; automatically falls back to x264
Lossless master	CPU FFV1 encoder included	Very large MKV; intended for archival/editing

The bootstrap fixes the runtime at PyTorch 2.13.0+cu130 and TorchVision 0.28.0+cu130, with native sm_120 support. Users do not need to install the CUDA Toolkit, system Python, Git, FFmpeg, or modify PATH. They do need a current NVIDIA display driver for CUDA modes. Do not install an optional backend's upstream requirements over this runtime: DiffuEraser's upstream pins an older Torch build that would remove the proven RTX 50-series path.

The refreshed private runtime uses CPython 3.13.15 and pip 26.2.1. Gradio 6.25.0, FastAPI 0.141.1, Starlette 1.6.0, Pillow 12.3.0, and Requests 2.34.2 replace the preceding Web/runtime stack. During a verified runtime rebuild, the launcher preserves a valid existing Gradio upload-cache hash seed so interrupted-batch recovery can continue to authenticate compatible cached uploads; it does not weaken source-content validation.

One-click portable Windows use

Requirements

• 64-bit Windows 10 22H2 or Windows 11
• Internet access on first launch
• A writable extracted folder
• A current NVIDIA driver for E2FGVI-HQ (and for fast LaMa/NVENC processing)

Start it

1. Verify RC.13 on the Releases page, then download the FrameMend-Portable-Windows-CUDA-v0.1.0-rc.13.zip starter and its adjacent .zip.sha256. Those canonical URLs do not by themselves prove availability; confirm the immutable release record and checksum before use.
2. Extract the complete ZIP to a normal writable folder.
3. Double-click run.bat.
4. Leave the first-launch window open while the private runtime is prepared.
5. The app opens in your browser; select one video or a whole batch in the same queue.

For the shortest and most predictable Windows paths, fully extract to a drive-root folder such as C:\FrameMend-Portable-Windows-CUDA-v0.1.0-rc.13\ or D:\FrameMend-Portable-Windows-CUDA-v0.1.0-rc.13\. Do not run the app from inside the ZIP. The application also uses short, collision-safe staging names, so enabling the system-wide Windows long-path policy is not required.

The small starter ZIP intentionally omits the multi-gigabyte runtime and model weights. Its first launch downloads verified CPython 3.13.15 and pip 26.2.1 artifacts, the hash-locked PyTorch 2.13.0+cu130 and TorchVision 0.28.0+cu130 wheels, and pinned FFmpeg n8.1.2-34-g9b6c8969e0. The detector and cleaning-model packs remain on demand, are checked by exact size and SHA-256, and stay inside the portable folder. NVIDIA VFX is also omitted. After explicit acceptance of NVIDIA's separate terms, selecting the post-process downloads and verifies the pinned official nvidia-vfx 0.1.0.1 wheel (about 468 MiB downloaded and 793 MiB installed) under user_data. The public lean ZIP does not redistribute NVIDIA's wheel, DLLs, or models. After the one-time download, the folder can be moved to another location or drive without installing system-wide software.

All mutable files stay under:

models/       verified model files
user_data/    outputs, caches, logs, temporary files, and Gradio uploads
python/       private Python and CUDA runtime
ffmpeg/       private FFmpeg and ffprobe

Portable update prompts

RC.12 is the first updater-enabled package, so an RC.11-or-earlier installation cannot discover or install it by itself. Download and extract RC.12 manually as described above. After that one-time transition, run.bat checks at startup for a newer release on the configured channel. The update prompt defaults to No: no update ZIP is downloaded and no managed application file is changed unless the user explicitly agrees.

An offline computer, timeout, GitHub API limit, malformed response, mutable release, or failed verification never blocks normal startup; FrameMend records a bounded local diagnostic and opens the installed version. The normal CLI never prompts and never installs an update implicitly.

Automatic apply is limited to an exact, immutable GitHub release from andreipemberton/framemend-portable. The selected ZIP digest must match GitHub's immutable asset metadata, its UPDATE_MANIFEST.json must match every managed application file, and launcher.dat must bind that exact manifest. FrameMend stages and validates the application before replacing managed files, preserves rollback copies, and installs launcher.dat last as the commit marker before reopening the app.

The updater never owns or deletes user_data/, models/, python/, or ffmpeg/. Outputs, caches, logs, recovery manifests, accepted-term markers, downloaded model packs, optional NVIDIA components, and the private runtime remain in place. If a release cannot be proven immutable and internally consistent, FrameMend may report it but will not auto-apply it.

After an accepted application update reopens FrameMend, a PowerShell-only contract check runs before private Python, PyTorch, or CUDA. It compares the release's runtime schema and exact requirements digest plus the pinned Python, pip, PyTorch, TorchVision, FFmpeg, and app-local runtime identities. A matching runtime is reused. A stale runtime is rebuilt from the new release's hash-locked dependencies first, while the last committed python/ folder is moved to the fixed .fmold rollback folder. FrameMend retains exactly one immediate previous runtime generation; the fixed six-character name keeps the verified Windows path budget deterministic. If setup is interrupted after promotion but before the new runtime marker is committed, the next launch restores the validated .fmold generation. This is how a later release can upgrade PyTorch without bundling or directly overwriting the multi-gigabyte private runtime in the lean updater ZIP. The portable release's dependency pins are authoritative; custom dependency versions are supported through source installations with a separately managed environment, not by modifying the portable private runtime.

Crash diagnostics

After bootstrap and preflight finish, each app-server start writes a local run folder under user_data/logs/runs/<run-id>/. It contains console.log (mirrored console output), gpu.csv (periodic GPU telemetry), faults.log (Python fault diagnostics), and activity.json (batch/model/video phase markers). status.running.json exists while the run is active and is normally replaced by status.completed.json or status.failed.json when it ends.

These files stay local and are not uploaded. Run folders remain until you delete them, so remove unneeded folders manually from time to time. Logs can contain video filenames and full filesystem paths; review them before sharing. A forced reboot, driver reset, or system crash can leave status.running.json behind. That means only that the app did not record a graceful finish, not that it caused the crash.

Build the public starter or a local developer FullOffline archive

The maintainer builder creates the small first-run starter by default:

powershell.exe -NoProfile -ExecutionPolicy Bypass `
  -File .\scripts\portable\build_windows_portable.ps1

For local development only, the explicit FullOffline mode can preassemble the core runtime, FFmpeg, and three core model files:

powershell.exe -NoProfile -ExecutionPolicy Bypass `
  -File .\scripts\portable\build_windows_portable.ps1 `
  -FullOffline -RequireCuda

The builder emits a ZIP64 archive, a .sha256 checksum, schema-6 PORTABLE_BUILD.json, an exact UPDATE_MANIFEST.json managed-file inventory, and the manifest-bound launcher.dat commit marker under dist/. It copies an explicit application allowlist rather than packaging the maintainer's existing environment. Release builds refuse a dirty source tree. -AllowDirty produces only an unpacked -DEVELOPMENT-LOCAL-ONLY starter stage; it deliberately emits no ZIP, checksum, update manifest, or launcher.dat and must not be published.

FullOffline is developer-local tooling only. CI and release scripts must not upload it. The intended RC.13 public release boundary is the lean starter ZIP plus its SHA-256 file only, until FFmpeg corresponding-source handling, a runtime SBOM, Microsoft DLL redistribution rights, and every model-license entry are resolved.

Cleaning modes

LaMa — fast

LaMa processes detected watermark crops in GPU batches. On an RTX 5070 Ti the automatic profile uses FP16 YOLO detection batches of 16 and safe FP32 LaMa batches of 8. LaMa can run on CPU, but video processing will be substantially slower.

E2FGVI-HQ — temporal quality

E2FGVI-HQ processes ordered frames in overlapping clips so it can use temporal context and reduce frame-to-frame flicker. The RTX 5070 Ti profile defaults to:

• 24-frame clips with 6-frame overlap
• 5-frame neighbor radius and at most 3 reference frames
• 128-pixel stable crop margin
• 4-pixel backend mask padding plus the selected coverage preset
• 1.25-million-pixel padded crop cap
• BF16 inference with a small FP32 deformable-convolution section

E2FGVI-HQ and its checkpoint are licensed under CC BY-NC 4.0 and are for non-commercial use unless separate permission is obtained.

All temporal modes now stop their reference windows at detected hard scene cuts and watermark-track boundaries. This specifically avoids feeding unrelated shots or a different watermark corner into one temporal inference window, a common cause of tearing and ghosted reconstruction.

ProPainter — optional high quality

ProPainter uses propagation and transformer-based video inpainting for harder motion and texture cases. Its verified on-demand pack is approximately 0.19 GiB and is not included in the starter ZIP. Review and accept the S-Lab License 1.0 non-commercial terms before installing it:

.\python\python.exe -m framemend.model_packs install propainter --accept-noncommercial

DiffuEraser — experimental

DiffuEraser adds diffusion refinement on top of a ProPainter prior. Its own verified pack adds approximately 8.86 GiB; with the ProPainter dependency, the optional download is about 9.05 GiB total. The portable adapter uses native PyTorch SDPA, bounded native-resolution crops, and block-level CPU offload so a 16 GB GPU has a feasible path, but offload makes it extremely slow.

.\python\python.exe -m framemend.model_packs install diffueraser --accept-noncommercial

Validation status: model manifests, resumable downloads, dependency isolation, adapter imports, clip boundaries, and CPU/offload wiring have automated coverage. Under Diffusers 0.40.0, a bounded synthetic CUDA inference passed on an RTX 5070 Ti at the backend's minimum supported crop above 256 pixels: 22 frames at 264×264 with two-step PCM. Model load took 24.643 seconds and inference took 19.186 seconds. Pixels outside the mask matched exactly; peak PyTorch allocation/reservation was 5,716,349,440/5,989,466,112 bytes, and both counters returned to 33,554,432 bytes after teardown. Driver-reported total use was 5,093 MiB before and 4,969 MiB after the probe. This was a minimum-compliant synthetic probe, not representative real-video visual-quality, duration, or stability validation. DiffuEraser remains experimental and extremely slow; use E2FGVI-HQ or ProPainter for dependable work.

Mask coverage and temporal stabilization

The Web UI exposes one Mask coverage choice for every cleaning engine:

• Conservative stabilizes verified detections with no additional preset padding. It preserves the most source imagery but can leave faint watermark edges.
• Standard is the default and recommended setting. It applies robust scene-local box smoothing, recovers only short supported detection gaps, and adds a modest resolution-aware margin.
• Wider uses a longer temporal window, bridges somewhat longer supported gaps, and expands the mask further for stubborn username or translucent edges. It asks the cleaner to reconstruct more genuine image area.

Every preset prevents an isolated detection from seeding a shot-wide track, stops at hard scene cuts and watermark-location jumps, and refuses to fill long unsupported gaps. Wider does not improve YOLO recall; it changes bounded temporal recovery and expands the masks around retained detections.

Optional NVIDIA cleanup and upscaling (RC.9)

RC.9 separates NVIDIA Denoise, Deblur, and upscaling into independent controls. It runs inside this PyTorch/Gradio portable app; ComfyUI is not required. Every NVIDIA stage requires 64-bit Windows, the bundled CPython 3.13.15 runtime, an NVIDIA GeForce RTX GPU with working CUDA support, and a compatible current NVIDIA driver. Either Studio or Game Ready drivers can work; Studio is the conservative recommendation for long creator workloads, but driver branch alone is not a guarantee of stability.

• Denoise: Off by default. When enabled, it has its own Low (default), Medium, High, or Ultra strength.
• Deblur: Independently Off by default, with its own Low (default), Medium, High, or Ultra strength.
• Both cleanup effects may be enabled together. The UI then shows an advanced warning about texture loss, halos, ringing, and overprocessing.
• Upscale: Off by default.
• Target: UHD by default, with aspect-preserving FHD, QHD, UHD, and 1.5x/2x/3x/4x choices. The source is never warped or downscaled to satisfy a target.
• Upscale model: Standard High by default; Standard Ultra, Clean-source High, and Clean-source Ultra are also available. Standard modes suit typical compressed video; clean-source modes are intended for already-clean, high-bitrate input.
• Codec: Auto by default. Auto selects H.264 when both output dimensions are at most 4096 pixels and HEVC when either dimension is above 4096. Explicit H.264 above that envelope is rejected with guidance; any dimension above 8192 is rejected.

The NVIDIA terms control appears whenever cleanup or upscaling is selected. First use requires explicit acceptance of the NVIDIA Software License Agreement, AI Product Terms, and Open Model License. The app then downloads and verifies the pinned official nvidia-vfx 0.1.0.1 wheel. Its roughly 468 MiB download expands to about 793 MiB under user_data; the public lean ZIP does not redistribute NVIDIA's wheel, DLLs, or models.

The processing choices and output names are:

Processing	Output
Watermark removal only	*_clean
Direct Denoise / Deblur	*_denoised / *_deblurred
Direct Denoise + Deblur	*_denoised_deblurred
Direct upscale	*_upscaled
Direct cleanup + upscale	*_denoised_upscaled / *_deblurred_upscaled
Direct Denoise + Deblur + upscale	*_denoised_deblurred_upscaled
Watermark + cleanup	*_clean_denoised / *_clean_deblurred
Watermark + Denoise + Deblur	*_clean_denoised_deblurred
Watermark + upscale	*_clean_upscaled
Watermark + one cleanup + upscale	*_clean_denoised_upscaled / *_clean_deblurred_upscaled
Watermark + both cleanups + upscale	*_clean_denoised_deblurred_upscaled

Watermark removal may be turned off for Denoise-only, Deblur-only, both cleanups, upscale-only, or any supported cleanup-plus-upscale chain. The app rejects only a batch in which watermark removal, both cleanup effects, and upscaling are all disabled. Originals are never modified.

When watermark removal is enabled, all videos are cleaned sequentially and each native *_clean master is published first. The detector and cleaner are then fully released before one isolated NVIDIA worker starts. For each frame, the worker executes strictly:

decode → optional Denoise → optional Deblur → optional Upscale → one download/final encode

Denoise → Deblur → Upscale is a FrameMend engineering inference. NVIDIA documents Denoise and Deblur as same-resolution operations and identifies Deblur as useful before super resolution, but it does not prescribe the order of the two cleanup effects. Deblurring noisy material can amplify artifacts; inspect a two-cleanup result carefully.

Cleanup precedes upscaling, but no cleanup intermediate is saved when upscaling follows it. The native *_clean master is always retained and published when watermark removal is enabled, even if later NVIDIA processing is skipped, cancelled, or fails. With watermark removal disabled, the worker receives the untouched source directly and creates only the selected NVIDIA derivative.

H.264 output uses NVENC when its preflight succeeds; HEVC uses the matching HEVC NVENC encoder and hvc1 tagging for MP4 compatibility. If NVENC preflight fails, the console and logs visibly report the matching x264 or x265 software fallback. NVIDIA derivatives are still lossy even when the container is MKV. Compatible audio, metadata, chapters, and ancillary streams are preserved where the output container permits.

Video Super Resolution may reconstruct plausible fine detail; it cannot recover information that was never present in the source. The NVIDIA Python API is applied per frame, so this integration does not claim temporal awareness. Keep the original and, when watermark removal is enabled, the native *_clean master as archival/editing sources. Inspect derivatives for faces, text, thin lines, fast motion, oversmoothing, and ringing. Upscaling improves presentation, not watermark-removal accuracy.

The initial NVIDIA path supports constant-frame-rate, unrotated, square-pixel SDR 8-bit input. HDR/10-bit, variable-frame-rate, rotated, and anamorphic sources are skipped rather than silently converted or warped. For accepted inputs, the RGB pipe uses an explicit source-aware color range and conversion matrix instead of FFmpeg's implicit defaults. See NVIDIA's Python API and Video Super Resolution documentation for the underlying API and filter constraints.

The earlier two-effect cleanup-plus-upscale implementation passed its bounded rc.8 gate on 2026-08-03 on an RTX 5070 Ti. RC.9's new three-effect Denoise → Deblur → Upscale chain separately passed its bounded RTX 5070 Ti matrix on the same date: three consecutive full-chain runs, cleanup-only modes, HEVC above 4096, cancellation and recovery, audio/cadence checks, worker exit, and VRAM return all completed without OOM or driver reset. Synthetic visual inspection found visible edge smoothing and mild halo/ringing after the full chain, so the combined path remains an advanced, source-dependent option rather than a universal quality recommendation.

Output quality and source preservation

The web UI defaults to High quality — recommended. On CUDA systems this uses NVENC P7, CQ16, full-resolution multipass analysis, and no source-bitrate-derived ceiling. It is still H.264 and therefore still lossy, but no resizing or upscaling is applied during the watermark-removal encode. Optional NVIDIA cleanup/upscaling uses its own single final encode. The balanced watermark-removal profile retains the smaller/faster P6/CQ18 behavior.

Lossless master stores the cleaned BGR frames as FFV1 level 3 in MKV. It does not introduce another lossy video generation, but files are very large and native Windows/browser playback support is limited; VLC, mpv, FFmpeg, or an FFV1-capable editor is recommended.

When the detector finds no watermark in any decoded frame, a normal output is copied byte-for-byte to its same-container _clean name instead of being decoded and encoded again. If lossless-master MKV was selected, the original streams are losslessly remuxed into MKV without re-encoding. For edited videos, compatible source audio is stream-copied without re-encoding; AAC conversion is used only when the output container cannot accept the original audio codec.

Batch video processing

Use Browse and add videos to open the Windows multi-file picker. Hold Ctrl or Shift to select several files, click the button again to add another selection, or drag multiple MP4, MOV, AVI, or MKV files into the list. Leave Remove watermarks enabled to clean the batch, or turn it off for direct NVIDIA cleanup, upscaling, or both. Then click Process selected videos once.

The permanent folder is shown in the Web UI. Portable batches are stored under:

<portable-folder>\user_data\gradio_outputs\
processed_YYYYMMDD_HHMMSS_xxxxxx\

A source-run Web UI defaults to <repository>\gradio_outputs\processed_YYYYMMDD_HHMMSS_xxxxxx\, or to the same path beneath FRAMEMEND_DATA_DIR when that variable is set. The supported CLI defaults to user_data\cli_outputs\processed_<timestamp>_<id>\; --output-dir selects a batch directory and --output requires exactly one resolved input.

When removal is enabled, videos run sequentially to keep GPU memory stable while the detector and selected cleaner remain loaded for the cleaning phase. In direct NVIDIA mode, neither is loaded: the original inputs are handed to an isolated NVIDIA worker, which loads the selected effect or effects once for the queue and exits afterward. As soon as a video finishes, it appears in the completed-files list and remains in the displayed output folder. Normal clean outputs retain the source container suffix, such as name_clean.mp4 or name_clean.mov; lossless masters use name_clean.mkv. Numeric suffixes are added only for collisions. The web UI no longer waits for or creates a combined results ZIP.

When watermark removal and either NVIDIA stage are enabled, the app creates and retains the native clean outputs, unloads the remover, and then processes all successful items in one NVIDIA phase. The exact suffix follows the table above. If NVIDIA cleanup and upscaling are both selected, only the final NVIDIA derivative is encoded; no cleanup-only intermediate is saved.

When watermark removal is disabled, the original inputs go directly to the selected NVIDIA stage or stages. There is no name_clean.* intermediate, and every original remains untouched.

Use Stop current batch to request cancellation without waiting behind the GPU queue. During NVIDIA processing, the supervisor checks that signal and terminates the worker process tree safely; all completed outputs, native clean masters, and original inputs remain available. If a cleaner or verified download is currently running, it stops cooperatively at the next safe point.

Interrupted-batch recovery

The shared Web UI/CLI pipeline writes schema-3 batch_state.json atomically after setup and after every validated item or stage. It records exact settings, source fingerprints, intended outputs, completed validations, failures, cancellation, and pending work. On a later launch, a localized Recover interrupted batch panel is shown only when a recoverable manifest exists.

Recovery is always manual. Resume restores the exact saved settings, revalidates existing outputs, retains valid completed files, and retries only pending or interrupted work. Dismiss marks the batch abandoned without deleting sources, outputs, logs, or the manifest. A failed later item never removes an earlier validated result. New manifests persist a strong SHA-256 identity for every source. A timestamp-only rewrite is accepted only when the bytes still match that identity. RC.11's legacy Web compatibility path is limited to a configured Gradio content-addressed upload cache and verifies its seeded digest; arbitrary paths and path, size, or content changes remain rejected. Recoverable schema-1 and schema-2 manifests remain loadable and upgrade atomically to schema 3 on the next write. CLI users run framemend recover.

While recovery runs, Resume, Dismiss, and the selector are disabled and a server-side single-flight lock rejects duplicates. Validation and bounded failure details are shown in the status area. Only files newly completed by the current attempt are published to the Web UI; older validated outputs remain in their displayed folder without being rehashed.

Default/Web batch folders keep batch_state.json beside their media. Reused CLI --output-dir or --output destinations keep collision-safe recovery records under .framemend-batches\<batch-id>\batch_state.json; use framemend recover --root <output-folder> to list them.

Supported command line and Python pipeline

Portable users run framemend-cli.bat. Source or installed-package users run framemend or python -m framemend. The supported commands are:

• framemend process
• framemend recover
• framemend doctor
• framemend models status|install
• framemend licenses [--json]
• framemend web [--open-browser]

process accepts multiple files or directories, searches directories non-recursively unless --recursive is supplied, and supports watermark removal, either or both cleanup effects, upscaling, and every supported chain. The CLI never accepts component terms implicitly. See the complete CLI reference for flags, output rules, examples, recovery, and exit codes.

The Web UI, CLI, and supported Python batch API are adapters over framemend.pipeline. RC.9 is a clean namespace break: there is no sorawm import shim, SoraWM alias, or SORAWM_* environment-variable fallback. Existing recoverable batch data is migrated for data preservation, not API compatibility. See the developer guide.

Web UI languages

The selector at the top of the local page provides:

• English (en, default)
• Russian / Русский (ru)
• Ukrainian / Українська (uk)
• German / Deutsch (de)
• Modern Choctaw / Chahta Anumpa (cho)

These are the five selectable in-app locales. The Chinese README is a documentation translation only; Chinese is not currently a sixth Web UI locale.

The Choctaw localization uses contemporary Choctaw Nation orthography where a documented equivalent is available and retains clear English technical terms where no standardized software term could be verified. Community review is welcome.

Source installation

The portable launcher above is recommended for Windows users. Developers can instead install from source with uv:

uv sync

The reproducible source baseline is CPython 3.13.15. On supported Windows/Linux x86-64 systems, this project selects PyTorch 2.13.0 with CUDA 13.0. FFmpeg must be installed or placed in ffmpeg/ for a manual source environment.

Run the supported Web command without opening a browser:

python -m framemend web

Add --open-browser only when desired. Portable run.bat remains the browser-oriented launcher.

Supported Python batch usage:

from pathlib import Path

from framemend import BatchRequest, BatchSettings, process_batch

result = process_batch(
    BatchRequest(
        inputs=(Path("input.mp4"),),
        output_dir=Path("outputs"),
        settings=BatchSettings(
            watermark=True,
            cleaner="lama",
            accept_unresolved_licenses=True,
        ),
    )
)

for output in result.outputs:
    print(output)

Advanced overrides

Portable defaults are appropriate for an RTX 5070 Ti. Optional environment variables include:

• FRAMEMEND_DETECTION_BATCH_SIZE
• FRAMEMEND_INPAINT_BATCH_SIZE
• FRAMEMEND_USE_NVENC=0 to force software x264
• FRAMEMEND_OUTPUT_QUALITY=balanced|source_faithful|lossless_master
• FRAMEMEND_MASK_COVERAGE=conservative|standard|wider
• FRAMEMEND_NVENC_PRESET, FRAMEMEND_NVENC_CQ, and FRAMEMEND_NVENC_MULTIPASS
• FRAMEMEND_GRADIO_PORT to request a fixed local port
• FRAMEMEND_E2FGVI_CLIP_LENGTH
• FRAMEMEND_E2FGVI_OVERLAP
• FRAMEMEND_E2FGVI_NEIGHBOR_STRIDE
• FRAMEMEND_E2FGVI_MAX_REFS
• FRAMEMEND_E2FGVI_ROI_MARGIN
• FRAMEMEND_E2FGVI_MASK_PADDING
• FRAMEMEND_E2FGVI_MAX_ROI_PIXELS
• FRAMEMEND_E2FGVI_BF16
• FRAMEMEND_E2FGVI_COMPILE

Dataset

The original author published the labelled detector dataset on Hugging Face.

License and notices

Technical compliance audit, not legal advice. Unresolved entries remain unresolved; FrameMend Portable RC.13 is not represented as fully license-cleared. Accepting terms or acknowledging a warning does not grant permission and does not replace a rights review for the intended use and redistribution.

FrameMend Portable remains an Apache-2.0 fork of SoraWatermarkCleaner by linkedlist771. The root LICENSE is preserved. FrameMend Portable is independent and is not affiliated with or endorsed by linkedlist771, OpenAI, or NVIDIA. Optional/runtime components retain their own licenses and unresolved status:

• Ultralytics remains temporarily distributed under AGPL-3.0, with the complete AGPL text and source location included. The detector-weight rights remain unresolved; the AGPL distribution posture does not resolve them.
• E2FGVI-HQ and ProPainter have non-commercial terms, Stable Diffusion components have their own OpenRAIL terms, and NVIDIA VFX requires separate NVIDIA terms.
• LaMa/Big-LaMa and SpyNet/OpenMMLab code and weight provenance are recorded separately. A code license is not automatically a license for model weights; entries remain unverified where weight rights are not independently established.
• The pinned PCM weight repository declares no license. Its status is unresolved, not Apache-2.0.
• The portable FFmpeg build is GPL. FullOffline remains local developer tooling and is not a public release asset.

Review THIRD_PARTY_NOTICES.md and the machine-readable THIRD_PARTY_COMPONENTS.json before use, redistribution, or commercial deployment.

Citation

Please preserve the original project's citation:

@misc{sorawatermarkcleaner2025,
  author = {linkedlist771},
  title = {SoraWatermarkCleaner},
  year = {2025},
  url = {https://github.com/linkedlist771/SoraWatermarkCleaner}
}

Acknowledgments

• linkedlist771 for the original SoraWatermarkCleaner project and detector
• Andrei Pemberton (@andreipemberton) and Lilitari (AI collaborator, credited by name and not a GitHub account) for this fork's portable Windows runtime, CUDA/RTX 50-series optimization, streaming batch queue, five selectable Web UI locales, four-engine integration, scene/track temporal safety, optional verified model packs, sequential NVIDIA VFX cleanup/upscaling, interrupted-batch recovery, source-preserving output profiles, NVENC path, and reliability improvements
• IOPaint for the LaMa integration on which the focused runtime path is based
• E2FGVI for the temporal inpainting architecture
• ProPainter and DiffuEraser for their optional video-inpainting architectures
• NVIDIA Video Effects for the optional separately licensed Video Super Resolution runtime. This project is not endorsed by or affiliated with NVIDIA.
• Ultralytics YOLO for object detection