SeedVR2.5 GUI version

[naxci1]

There will be a single .exe file (Portable). It will contain everything (Python, Torch, ComfyUI). I don't add the models because they are large files, they will download themselves when they are launched or the user will download them and choose the folder.
The system works with CLI, I tested everything and it works fine, it easily upscales images and videos. I included all the CLI arguments.
I will add them when I'm done.

The easy part is that no one needs to install comfyui or python packages, they will download the single file and run it directly.

[naxci1]

Demo video:

SeedVR2_GUI-demo.mp4

[amrshank92]

Can we process all videos in a folder one by one with this ?

[naxci1]

I've configured it to process both a single file and all files in the directory. I'm currently running tests and will share the results when they're finished so you can try them too.

[urixl]

That's great, where can we get a link?

[naxci1]

It's not finished yet, I'm running tests, the links will be available when they're done.

[naxci1]

For those who want to test it, download and run the beta version, specify the necessary directories in the settings, enter your node settings, and run it. Report any errors you encounter. Thank you.

https://drive.google.com/file/d/1P-NLshHGQJVdUP42D_wqz7cKpVa4EwFZ/view?usp=sharing

[naxci1]

Has anyone tested this? Currently, it works with ComfyU and SeedVR2 installed on the system. I'll add portable versions of all of them later, and the setup will create a ready-to-use system; you won't need to install anything else.

I added split comparison; after processing images or videos, you can perform a comparison with Synchronous, zoom, and it also works in full-screen mode.

I added preview, which wasn't available before. You can take any frame from the uploaded video as an image and compare it by upscaling it. It's like the preview in Topaz video.

When you select an image file, batch_size automatically becomes 1.

I fixed the error in the CLI for black and white images. Have you tried upscaling black and white images in ComfyUi?

Please try it yourselves and report any problems so I can fix them, as I'll create a setup when the full version is ready.

[naxci1]

The new beta version is available for you to try; please report any bugs and suggestions.

https://github.com/naxci1/ComfyUI-SeedVR2.5_new/releases/tag/GUI_v.1.4b

[amrshank92]

Done a quick test. Split view not working. Please add option for scaling factor like in your comfyui template.
Also please add option for prores export.

[naxci1]

Split works flawlessly for me, I guess you haven't installed some pip packages, that's why. They should all be installed in the latest version. I'll try to add ProRes, I'm thinking about adding scaling numbers and some conveniences. There will be two versions, simple and advanced. The simple version will only have a few features, like Topaz style, while the advanced version will have everything.

Has anyone else tested it? Has only one person tried it?

[naxci1]

ArcticLatent/Arctic-Helper#3

ArcticLatent/Arctic-Helper#14

[amrshank92]

I can't shutdown PC after running seedvr. It was same with comfyui. I thought it was some problem with comfyui. It is happening with gui also. Any fix for that. Monitor turns off but CPU Still running.

[naxci1]

Go to Task Manager and check which processes are running and which ones you can't close. If processes like ffmpeg and python can't close, right-click on them and close them.

This isn't a SeedVR2 problem; it's Comfyui that's having trouble closing. SeedVR2 isn't an application; Comfyui is the application.

[amrshank92]

even if I close python from taskmanager, windows won't shutdown. Any tool that can automatically close unnecessary processes

[naxci1]

It seems your Windows installation is also having problems. Open the terminal as administrator and run these commands sequentially, one after the other. Then, restart your PC when everything is finished.

sfc /scannow
Dism /Online /Cleanup-Image /CheckHealth
Dism /Online /Cleanup-Image /ScanHealth
Dism /Online /Cleanup-Image /RestoreHealth

[amrshank92]

Hi, the settings are not being saved. I mean, every time I open the GUI, I have to re-enter settings like resolution, post-processing, whether tiling is enabled, etc.

[naxci1]

In the workflow, press Ctrl+S to save your settings.

[amrshank92]

hi,can you provide an update with prores support

[naxci1]

Yes, it will all happen, I just haven't had the chance to continue lately because I'm very busy with work. I'll try to do it like Topaz.

[skv89]

Wow this is looking really good. Anyway to add Lanczos downscaling to ProRes prior to enhancement?

[naxci1]

I'll try them all; those that work will stay, and those that don't will be removed. I have a lot of ideas in mind right now, but I just need to find the time to code them.

[Bonnie197]

[skv89]

Please don't spam here.

[naxci1]

You can test the 1Click SeedVR2 v.1.5 beta version. I've added pre-processing video and image resizing; since it does this on-fly, the quality will remain the same. You can enlarge using both ratio and pixel settings. You can save the settings and upload them later.

I tried to make it Topaz-style, adding all image and video codecs, and also auto mode. All formats are available in the codec settings. I also added the color settings there. I included ffpmeg and opencv formats. These are the things I've done in two days; I'm planning to add more features.

Before running it, remember that Comfyui and SeedVR2 must be running. First, you need to go into the settings and select the necessary directories.

In the final version, these won't be necessary; everything will be included as a portable version, just like Topaz.

It's still in beta, so there will be bugs. I kindly request that you write to me about any bugs in detail so I can fix them.

https://github.com/naxci1/ComfyUI-SeedVR2.5_new/releases/tag/GUI_v.1.5b

[skv89]

What do you mean comfyui and seedvr2 must be "running"? Do you mean installed? What if I use the desktop version of comfyui instead of the portable version? Will that work also?

[naxci1]

I had already added the chunking feature to FlashVSR in the Comfyui settings, but it would have been beneficial to add it to SeedVR2 as well. Since I initially split the files myself, it didn't occur to me to add it to the Comfyui settings.

[skv89]

For chunking it is better to use frames than time because videos have different frame rates. For my 64gb ram system, I can do 4,000 frames metabatch for 1080p outputs. For my 96gb ram system, I can do 6,000 frames metabatch for 1080p outputs. Maybe it can go even higher but I'm satisfied with this

[naxci1]

Question:

Which would be the most optimal way to render a 2-hour video (approximately 172,800 frames at an average of 24 fps) directly into the ComfyUI interface, regardless of how powerful the system specifications are?

Gemini Answer:

Loading and processing a 2-hour video (approximately 172,800 frames at an average of 24 fps) directly into the ComfyUI interface will almost certainly result in Out of Memory (OOM) or system crashes. ComfyUI's standard nodes, such as VHS_LoadVideo, cannot hold data of this magnitude in memory.

The most optimal and safest method for long projects of this scale is: CLI Mode (Chunking + Temporal Overlap).

The following workflow and parameters provide the most stable configuration for rendering a 2-hour video uninterrupted until morning on a powerful workstation:

1. CLI Mode Configuration (Recommended)
   In CLI mode, processing and writing the video to disk in chunks both eliminates RAM load and keeps VRAM clean.

chunk_size: Should be kept between 100 and 150. Even with a powerful GPU and plenty of system RAM, very high chunk sizes (e.g., 500+) will lead to momentary VRAM bursts due to the temporal structure of the SeedVR2 model.

temporal_overlap: Should be set to 4 or 8 frames. This overlap is critical to prevent scene jumps or flickering at transition points when chunks merge.

2. Why Not Choose ComfyUI + Meta Batch?
   Even if you use Meta Batch within ComfyUI, the process will still get bogged down in the following ways:

The video loader (Load Video) tries to load the entire video into RAM. A 2-hour 1080p or 4K video in raw frame form requires hundreds of gigabytes of RAM, and the Python process crashes.

VRAM garbage collection cycles in the workflow don't work as aggressively as in CLI mode. In long rendering sessions, memory leaks can accumulate within ComfyUI, interrupting the process.

[naxci1]

Question:

Is the chunk in CLI mode in SeedVR2 the same as the metabatch in ComfyUI?

Gemini Answer:

No, they are not exactly the same thing. Although both logically serve the purpose of splitting video, they are structurally different in terms of their working principles and VRAM management methods. The differences between them are as follows:

1. "Chunk" in CLI Mode (Streaming / Chunk Size)
   How it Works: The chunk_size parameter in CLI mode (e.g., 100 frames) is used to prevent the entire video from being loaded into memory (RAM/VRAM). The code reads (streams) only that chunk size of frames from the video sequentially, processes them, writes them to disk, frees up memory, and moves on to the next set of frames.

Purpose: To prevent system crashes (OOM) on both normal RAM and VRAM. It allows long videos to be processed in chunks without being fully loaded into the system.

Problem: Temporal inconsistencies (flicker/seam) can occur when transitioning between chunk boundaries (e.g., transitioning from frame 100 to frame 101). To prevent this, Temporal Overlap (blending consecutive chunks by overlapping them) is used in the repository.

2. "Meta Batch" (Meta Batch Manager) in ComfyUI
   How it works: In the ComfyUI environment, video frames are already loaded into the system (e.g., 300 frames). Meta Batch divides this loaded frame sequence into smaller subgroups (batches) when sending it to the model's processing (inference) phase.

Purpose: Its aim is simply to reduce the instantaneous load on VRAM (Graphics Card Memory). It feeds more frames to the model in small packets than the model can process at once.

Difference: Meta Batch alone does not interfere with the video's read-from-disk phase; If the video is too long, ComfyUI may consume system RAM or crash even before running the rule (during the Load Video phase).

[skv89]

Seems like Gemini is confusing Chunk with Batch because it sounds like the same thing. I wish there was a way we can process long videos using chunk at the same amount of frames as the batch size with temporal overlap. Right now I use Metabatch and it basically splits up a long video into multiple short videos of a given number of frames. After processing each short video, it writes to disk, so you can see the output file size increase after each "Post-processing batch" for each short video. The issue with Metabatch is that there is a hard break between each "short video" and it is not possible to have temporal overlap across this hard break. Not a big deal really especially if you can do 4,000 or 6,000 frames per metabatch, there will not be that many joints and it is not noticeable or at least not bothering

[naxci1]

Beta version 1.6 has finally been released.

I'm happy to present this new version to you after working on it for two days. It's still in beta, not yet the full release. The full version will have automatic installation, meaning Python and its packages will be ready to use. I've added many new features; please let me know if you find any bugs or want new features if you test it.

I've added Simple and Advanced modes, audible alarms, pre-downscaling, rendering at any interval within the video, preview, split comparison, processing files and directories, and an Auto Safeguard mode (automatically fallsbacks the process without stopping). And many more features...

Please don't forget to comment after testing it.

https://github.com/naxci1/ComfyUI-SeedVR2.5_new/releases/tag/GUI_v.1.6b

@AInVFX/developers @maintainers @contributors @adrientoupet @IceClear @numz

[skv89]

Still get these errors and I made sure I updated FFMPEG using these commands. I know ffmpeg works because I've been using it for Seedvr2/comfyui and other apps

For chunks, I do recommend changing it to frames instead of minutes. So if I have a batch size of 77, I can set a chunk of 770 or 7700.

[naxci1]

Hi @skv89

It seems you haven't installed ffmpeg on your system. First, download the file from the link and extract it to any directory on your PC, for example, in Program Files. Then, as shown in the image, you need to add it to your system paths. My Windows is Turkish, so hopefully you'll understand where it is by looking at the image. After that, ffmpeg should work. You don't need to restart your PC. Just close and reopen SeedVR2. I'll fix the chunk-related bug; it's a simple problem. Have you been able to run any general tests? Besides ffmpeg, you can also export with OpenCV like with ComfyUI.

It seems no one else has shown any interest, which is very unfortunate. Actually, if tests had been done and errors reported to me, I would have quickly created and shared the setup. Everything will come with a Topaz video-like installation; ffmpeg, Python, and packages will be included. So, it will be a one-step installation for everyone. I can later compile it for MAC systems as well.

The ffmpeg directory should only contain 3 files; these files are in the bin directory in the link you downloaded. Add those 3 files to any directory and include that directory in the paths. Windows will automatically run ffmpeg from there when it starts.

https://www.gyan.dev/ffmpeg/builds/ffmpeg-git-essentials.7z

[skv89]

Yea I already had FFMPEG latest full GYAN version installed and in the user and system paths. I can type FFMPEG in any folder as shown in the command prompt screenshot above.

I am able to run SEEDVR2 CLI in command prompt with the help of ChatGPT:

REM ============================================================
REM  Step 1: Run SeedVR2 CLI.
REM
REM  Note on output quality:
REM  The current SeedVR2 CLI exposes --video_backend ffmpeg and --10bit, but does
REM  not expose direct CLI switches for NVENC, p010le, or a user-set bitrate.
REM  In your log, this already produced HEVC Main10 10-bit output around 14.1 Mbps.
REM ============================================================

"%PY%" "%CLI%" "%INPUT%" --output "%TEMPVIDEO%" --model_dir "%MODEL_DIR%" --dit_model "%DIT_MODEL%" --resolution %RESOLUTION% --max_resolution %MAX_RESOLUTION% --batch_size %BATCH_SIZE% --uniform_batch_size --chunk_size %CHUNK_SIZE% --temporal_overlap %TEMPORAL_OVERLAP% --seed %SEED% --color_correction none --input_noise_scale 0 --latent_noise_scale 0 --attention_mode %ATTENTION_MODE% --video_backend ffmpeg --10bit --dit_offload_device %DIT_OFFLOAD_DEVICE% --vae_offload_device %VAE_OFFLOAD_DEVICE% --tensor_offload_device %TENSOR_OFFLOAD_DEVICE% --vae_decode_tiled --vae_decode_tile_size %VAE_DECODE_TILE_SIZE% --vae_decode_tile_overlap %VAE_DECODE_TILE_OVERLAP% --compile_dit --compile_vae --compile_backend %COMPILE_BACKEND% --compile_mode %COMPILE_MODE% --compile_dynamo_cache_size_limit %DYNAMO_CACHE_SIZE_LIMIT% --compile_dynamo_recompile_limit %DYNAMO_RECOMPILE_LIMIT% --cache_dit %DEBUG_FLAG%

if errorlevel 1 (
    echo.
    echo ERROR: SeedVR2 failed for:
    echo "%INPUT%"
    echo.
    echo The final mux/encode step will be skipped for this file.
    echo.
    exit /b 1
)

if not exist "%TEMPVIDEO%" (
    echo.
    echo ERROR: SeedVR2 finished but the temporary video was not found:
    echo "%TEMPVIDEO%"
    echo.
    exit /b 1
)

I think the reason no-one is interested is because those that are on this forum are already knowledgeable and comfortable with using SEEDVR2 in ComfyUI so they are not interested in using a simple GUI version. Those that do not know how to use ComfyUI are not aware of the existence of such a GUI. For me, I like CLI version because I am able to use larger batch sizes with the CLI commands because the recent versions of ComfyUI somehow became much more inefficient with vram usage and it blows up the vram with the same batch size that worked in earlier version of ComfyUI. Also using Chunk is better than using MetaBatchManager for long videos since there is some temporal continuity between chunks but none between Metabatches.

[naxci1]

That's right, everyone on this forum has been here for a while and is used to using Comfy or the CLI version, but my new GUI version has some new features that aren't in the standard CLI and Comfy. Actually, I'll add even more features for ease of use and smoother operation. I've also prepared a GUI in C++, but setting up the interface takes a lot of time, and compiling it each time also takes up a lot of my time, so I decided to continue with PyQt6 for now.

I think that once it's completely finished, this free version will become more widespread instead of spending so much money on Topaz. SeedVR2 is much higher quality and faster. It's just not very well-known yet, and the main problem is that people don't have the technical knowledge to install it or don't want to deal with the settings, so they leave. That's why I'm trying to fix these problems. When it's finished, I'll send it to some people to promote this version.

It's now possible to directly select standard dimensions for a feature; dimensions are actually defined in 3 formats: x upscale, pixel, and standard dimension, which I think is very convenient. Also, as with Topaz video, there's the ease of specifying a desired range of the video and rendering only that part.

[amrshank92]

Tested latest version. Resolution change settings not working. Locked to 720p. Tried all settings and still 720p only. Also Batch size is fixed at 81 . I changed to 57 but when proceesing starts,it is working on 81.

Prores export not working. Getting error code 2

[naxci1]

Hi @amrshank92

Thanks for the test, I'll fix all the bugs and release a new version tomorrow. I actually wanted to add 8K and 16K as well, but SeedVR2 didn't export it, it only exports 4K.

[naxci1]

Hi, I've been working intensely for the past few days and haven't had any time to work on the new version, but I'll try to do it this week.

[skv89]

Hi,can you provide an update for gui with fixes. I am currently not using comfyui because of the windows shutdown issue.

You can try the GUI I posted below. I created it because I was having issues with ComfyUI and I wanted to use the Chunk features and error recovery/resume that ComfyUI does not have. Also much better queue handling and error diagnostic features.

[amrshank92]

I couldn't run that. my comfyui folder don't have a venv folder. Also it doesn't have prores support right ?

[skv89]

I couldn't run that. my comfyui folder don't have a venv folder. Also it doesn't have prores support right ?

My app was designed for the desktop version of comfyui. ComfyUI Portable does not use .venv; it uses python_embeded. The current build assumes a .venv install, so I need to add portable support. For portable installs, the ComfyUI path should point to the folder with custom_nodes and models, usually ...\ComfyUI_windows_portable\ComfyUI, while Python is usually ...\ComfyUI_windows_portable\python_embeded\python.exe.
ProRes support comes from FFmpeg. If your FFmpeg build has prores_ks, then ProRes 422 HQ intermediate output should work. You can check with ffmpeg -encoders | findstr /i prores.

Once I return from vacation in the next few weens, I might update the app with more features and add autodetect for desktop and portable comfyui installs. But no promises. If I do, I will open another thread to avoid confusion between my gui app and the OP's

[skv89]

I couldn't run that. my comfyui folder don't have a venv folder. Also it doesn't have prores support right ?

Ok I posted my new version here. It should work with your portable ComfyUI now.
#597

[skv89]

Because the recent versions of ComfyUI significantly decreased my vram capacity, my batch sizes are reduced by a significant amount and I keep getting freezes and crashes and naxci1's app for some reason doesn't work on my pc so I just used ChatGPT to make my own little app and its been working so far. I don't have time to explain the features because I'm in a rush to board a flight but you guys can try it out. It is not as fancy as naxci1's app and nowhere near as ambitious as his app so I think it would be great if naxci1 can incorporate some of these features into his future all-in-one SEEDVR2 app. The most important things you can do with this app that you can't with ComfyUI is to use the CHUNK feature which provides temporal continuity between chunks for long videos that meta-batch manager does not. Also there are a bunch of error, resume, retry features built in that you can select from. In ComfyUI if it crashes after 12hrs of work, you lose all that work. There's no way to salvage that. But now you can. Make sure you click the two features circled in red in the screenshot above.

SeedVR2_CLI_GUI_v1_0_Public_Defaults_Package.zip

You can open either of these two files to start the app.

[naxci1]

Congratulations! Actually, we could make SeedVR2 even easier to use, allowing more people to utilize it. This increased usage might even lead to the release of a new version. Right now, this treasure is hidden away, and people don't know about it. It's actually a very powerful model; it just needs updating.

[puenktchen]

I really appreciate what you are trying to do here but i would have wished you had created a web frontend instead of a regular gui application so we could use it with a docker image for runpod.io or simplepod.ai.

[naxci1]

But those are separate issues; what people want most is ease of setup and use, like Topaz Video. There are already ready-made Docker files online for Cloud GPUs. It's then possible to gather them all on a single page.

[puenktchen]

There are already ready-made Docker files online for Cloud GPUs. It's then possible to gather them all on a single page.

Provided that those docker images already have all the necessary ComfyUI extensions and a usable workflow installed, it's still that horrible tech-nerds grid interface without access to the chunk-feature of the cli.

[naxci1]

Hello everyone, the new version will be online very soon. I've fixed all the issues and also changed the directory structure. It will come with automatic installation soon, and it will work flawlessly with AMD, Intel, and Nvidia GPUs, as well as CPUs.

https://github.com/naxci1/1Click_SeedVR2.5

[naxci1]

1‑Click SeedVR2.5 — GUI Reference Guide

Version 1.7 Beta · A high‑performance AI video restoration GUI built on the ByteDance SeedVR2 architecture.

Note

This document covers the graphical interface only. It is a complete, control‑by‑control reference for the desktop app — every checkbox, field, dropdown and button is documented below. Command‑line usage, installation and environment setup are intentionally out of scope here.

---

1. Project Overview & Key Features

1‑Click SeedVR2.5 is a high‑performance AI video‑restoration GUI optimized for the ByteDance SeedVR2 diffusion‑transformer (DiT) architecture. It wraps the heavyweight upscaling engine in a fully visual workflow so that restoring and upscaling footage — from a single still frame to multi‑hour 20th‑century film archives — is driven entirely through panels, dropdowns and a live comparison viewer.

Key Features

Feature	What it gives you
Portable python_embeded integration	The GUI launches the upscaling engine through a configurable Python executable (the bundled portable python_embeded, or any interpreter you point it at). No global Python install is assumed; paths are resolved through the Settings window.
Multi‑stage pipeline	A staged DiT → VAE‑decode → encode pipeline with automatic fallbacks (tile throttling, batch step‑down, dynamic‑shape clamps) so heavy jobs degrade gracefully instead of crashing.
Native preview workflow	A one‑click Preview captures a single frame, upscales it, and drops you straight into a live split‑screen original‑vs‑result comparison — no full render required.
Simple & Advanced modes	A clean default surface for quick jobs, with an Advanced toggle that reveals memory, performance, caching and debugging controls.
Container‑aware export	A two‑step Container → Codec workflow plus a full image‑sequence pipeline (TIFF/PNG/DPX/EXR) for archival masters.
Broad hardware support	NVIDIA CUDA, AMD ROCm, Intel XPU and CPU fallback, with single‑ and multi‑GPU inference.

---

2. Complete GUI Settings Directory

This section walks through every section of the interface and documents every individual control — its purpose, its effect on upscale quality, and its impact on performance/VRAM.

Note

Controls marked [Advanced] are hidden in Simple Mode and only appear once you toggle Advanced Mode in the header bar.

2.0 Header Bar

Control	Type	Purpose
About	Button	Opens the About dialog (version / credits).
GitHub	Button	Opens the project page in your browser.
Simple / Advanced Mode	Toggle	Switches between the streamlined surface and the full control set. Advanced reveals BlockSwap memory, Performance, Quality Control, Model Cache and Debug groups.
Settings	Button	Opens Paths & Configuration (Python executable, script folder, FFmpeg, models directory).

---

2.1 File & Path Selection

File and folder paths are managed through the 📁 Folders dialog and global drag‑and‑drop.

Control	Type	Behavior
Input Mode	Dropdown	File → process a single video/image. Folder → batch‑process every supported media file in a directory.
Input Path	Text field + Browse	Path to a video, image, or directory. Supports drag‑and‑drop anywhere on the window — a "Drop supported media anywhere to import" overlay appears while dragging, and dropping a file immediately loads it into the viewer.
Output Path	Text field + Browse	Optional. Leave blank to auto‑name the result directly beside the input file.

Drag‑and‑drop behavior. Dropping a supported video/image onto the window loads it into the input player and refreshes the metadata label. Supported input video types include .mp4 .mov .mkv .avi .webm .mpeg .mpg .m4v .wmv .flv .mts .m2ts; supported image types include .png .tif .tiff .jpg .jpeg .dpx .exr.

Output directory behavior. When the Output Path is empty, results are written next to the source file using the naming convention seedvr2_<input_stem>.<ext>. When a folder is supplied, results are written into it. In batch (Folder) mode, results land in a sibling <foldername>_upscaled directory.

Tip

Leave the Output Path blank to auto‑name the result next to the input file. This is the recommended workflow because it keeps masters and sources together and avoids stray subfolders.

---

2.2 Core Model Configuration

Found in the AI Model and Processing Settings group boxes on the Adjustments tab.

DiT Model Selection

A single dropdown selects the diffusion‑transformer weights. Selecting a DiT model auto‑selects the compatible VAE behind the scenes.

Model file	Size	Precision / Notes
seedvr2_ema_3b-Q4_K_M.gguf	3B	4‑bit GGUF quant — smallest VRAM footprint, fastest, lowest fidelity.
seedvr2_ema_3b-Q8_0.gguf	3B	8‑bit GGUF quant — default. Best balance of quality, speed and VRAM for the 3B family.
seedvr2_ema_3b_fp8_e4m3fn.safetensors	3B	FP8 — near‑FP16 quality at reduced VRAM on FP8‑capable GPUs.
seedvr2_ema_3b_fp16.safetensors	3B	Full FP16 — highest 3B fidelity, highest 3B VRAM cost.
seedvr2_ema_7b-Q4_K_M.gguf	7B	4‑bit GGUF quant of the larger model — more detail than 3B at moderate VRAM.
seedvr2_ema_7b_fp8_e4m3fn_mixed_block35_fp16.safetensors	7B	Mixed FP8/FP16 — high 7B quality with reduced VRAM.
seedvr2_ema_7b_fp16.safetensors	7B	Full FP16 7B — top‑tier fidelity, heaviest VRAM.
seedvr2_ema_7b_sharp-Q4_K_M.gguf	7B "sharp"	Sharpening‑tuned 4‑bit variant.
seedvr2_ema_7b_sharp_fp8_e4m3fn_mixed_block35_fp16.safetensors	7B "sharp"	Sharpening‑tuned mixed FP8/FP16.
seedvr2_ema_7b_sharp_fp16.safetensors	7B "sharp"	Sharpening‑tuned full FP16.

Note

Precision trade‑offs. Lower bit‑widths (Q4 → Q8 → FP8 → FP16) progressively raise both quality and VRAM/compute cost. The 3B family is the practical choice for consumer GPUs; the 7B family yields the highest detail but demands substantially more VRAM. The "sharp" variants bias toward edge/detail emphasis.

VAE Model Selection

The VAE decoder (e.g. ema_vae_fp16.safetensors) turns the model's latent output back into pixels. It is auto‑selected to match the chosen DiT model, so there is normally no manual VAE picker to manage — the GUI keeps the pairing consistent for you. The VAE decode phase is the single most VRAM‑intensive stage of the pipeline, which is why it has its own tiling and tile‑clamp safeguards (see §2.4).

Resolution

Resolution is governed by Pre‑Downscale, Resolution Mode, Resolution, and Max Resolution.

Control	Type	Options / Range	Effect
Pre‑Downscale	Dropdown	1:1 (passthrough), 2:1 (halve via Lanczos), 3:1 (reduce to ⅓ via Lanczos)	Shrinks the input before upscaling. Lowering the working resolution dramatically cuts VRAM and time, and can clean up noisy sources by giving the model a smaller, denser base to rebuild from.
Resolution Mode	Dropdown	Pixel, X Times, Standard	Chooses how the target is expressed.
Resolution	Spin / Dropdown (mode‑dependent)	Pixel: target short‑side in px · X Times: 1x–5x multiplier · Standard: 480, 720 (HD), 1080 (FHD), 1440 (2K), 2160 (4K)	The actual target.
Max Resolution	Spin	Int, 0 = no limit	Hard ceiling on the output short side, regardless of mode.

Short‑side scaling mechanics. Targets are applied to the short side of the frame; the long side scales proportionally, so the aspect ratio is always preserved (aspect‑ratio protection). In X Times mode, the multiplier is applied to the (post‑pre‑downscale) input short side. Higher targets sharply increase VRAM use during VAE decode — this is the primary lever behind out‑of‑memory risk.

Seed Configuration

SeedVR2 generation is conditioned on a seed. The GUI runs with a fixed, deterministic seed (313), which means repeated runs of the same source with the same settings produce identical, reproducible output — important for archive work where consistency across re‑renders matters. (Deterministic generation eliminates the run‑to‑run variation you'd get from a random seed.)

---

2.3 Export & Encoding Settings

Found on the Codec Settings tab. An Output Type selector at the top switches the whole tab between Video Export and Image Sequence Export.

Container Formats & Output Formats

Control	Type	Options
Output Type	Dropdown	Video or Image Seq. — toggles the entire export pipeline.
Container	Dropdown	MP4, MOV, MKV, WEBM. Filters the Video Codec list to compatible codecs only.
Image Sequence Format	Dropdown	.png, .tif, .tiff, .jpg, .jpeg, .dpx, .exr (when Output Type = Image Seq.).
Image Bit Depth	Dropdown	8‑bit, 10‑bit, 12‑bit, 16‑bit, 32‑bit.

Note

TIFF / PNG for masters. For archival masters, an image sequence in 16‑bit TIFF (uncompressed) or PNG/DPX/EXR avoids inter‑frame compression artifacts entirely — at the cost of large files. MP4 with a modern codec is the right choice for distribution.

Video Codecs

The Container selection filters which codecs are available:

Container	Available Codecs
MOV	ProRes 422 HQ, ProRes 4444 XQ
MP4	H.264 High, H.265 Main, H.265 Main10, AV1
MKV	VP9

• AV1 (libaom‑av1) — modern, high‑efficiency codec; excellent quality‑per‑bit for distribution. Uses -row-mt 1 row‑based multithreading and a -cpu-used speed knob (0 = slow/best → 8 = fast).
• NVENC (hardware acceleration) — where available, hardware H.264/H.265 encoders offload encoding to the GPU's dedicated media engine (e.g. -preset p4), trading a little quality for very fast, low‑CPU encodes.
• ProRes (422 HQ / 4444 XQ) — intra‑frame, archival‑grade quality with 10‑/12‑bit color (yuv422p10le / yuva444p12le). Large files, but ideal as an editing/restoration master.

Encoder Arguments

Control	Type	Options / Effect
Video Backend	Dropdown	ffmpeg (recommended, high‑quality, full codec/10‑bit support) or opencv (fallback VideoWriter; MP4/AVI only, no 10‑bit).
Bitrate Mode	Dropdown	VBR/CRF (quality‑targeted) or CBR (constant bitrate).
Quality Level (CRF mode)	Dropdown	Max (CRF 18, largest/best), High (CRF 23), Medium (CRF 28), Low (CRF 32, smallest).
Target Bitrate (CBR mode)	Dropdown	1–180 Mbps presets.
10‑bit Output	Checkbox	Forces a 10‑bit pixel format for codecs that support it (smoother gradients, less banding).

Custom FFmpeg flags. Per‑codec profiles inject the appropriate FFmpeg arguments automatically — for example AV1 adds -row-mt 1 (row multithreading) and a -cpu-used CPU‑utilization/speed flag, NVENC sets a -preset, and ProRes sets -profile:v and a 10/12‑bit -pix_fmt. CRF vs Bitrate: CRF (via Quality Level) targets a constant perceptual quality and lets the file size float; CBR (via Target Bitrate) pins the bitrate and lets quality float — use CRF for masters, CBR when you need a predictable file size/stream rate.

Audio Modes

A single Audio dropdown controls the audio track of the output:

Mode	FFmpeg behavior
Copy Audio	-c:a copy — passes the source audio through untouched (no re‑encode, lossless, fastest).
AAC	-c:a aac -b:a 192k — re‑encode to AAC.
PCM	-c:a pcm_s24le — uncompressed 24‑bit PCM (archival).
AC3	-c:a ac3 -b:a 448k — Dolby Digital.
FLAC	-c:a flac — lossless compressed.
No Audio (Mute/Strip)	-an — strips the audio track entirely.

---

2.4 Execution & Hardware Optimization (VRAM Management)

These controls live across the Processing Settings, Device Management, Memory (BlockSwap) [Advanced], VAE Tiling, Performance [Advanced] and Model Cache [Advanced] groups.

Batch Size & Uniform Batch Size

Control	Type	Range / Rule	Effect
Batch Size	Stepper (− / +)	Must be 4k+1 (1, 5, 9, 13, 17, …); typed values snap automatically; ±4 buttons step it	Number of frames processed in parallel per pass. This is the dominant VRAM lever — memory scales roughly linearly with batch size. Larger batches are faster and give the temporal model more context, but are the first thing to reduce on OOM.
Uniform Batch Size	Checkbox	—	Forces every batch to the same size (no smaller "remainder" final batch), which keeps VRAM behavior predictable across the whole job.

Warning

Batch size and target resolution together determine peak VRAM. If you hit Out‑Of‑Memory, reduce Batch Size by one 4k+1 step before touching anything else.

Offloading Toggles (Trading RAM for VRAM safety)

Control	Type	Options	Effect
DiT Offload to CPU	Dropdown	none, cpu	Moves DiT weights to system RAM when idle, freeing VRAM for active computation.
VAE Offload to CPU	Dropdown	none, cpu	Offloads the VAE to RAM between phases — valuable because VAE decode is the heaviest VRAM stage.
Tensor Offload	Dropdown	none, cpu	Offloads intermediate tensors to RAM.

Offloading trades system RAM (and a little PCIe transfer time) for VRAM headroom. On constrained GPUs, enabling CPU offload for DiT and/or VAE is often the difference between completing a job and crashing.

Memory (BlockSwap) [Advanced]

Control	Type	Range	Effect
Blocks to Swap	Spin	0–36 (0 = disabled)	Swaps a number of transformer blocks between GPU and CPU on demand, sharply lowering peak VRAM at the cost of throughput.
Swap I/O Components	Checkbox	—	Also swaps the model's input/output components for additional VRAM savings.

Attention Modes [Advanced]

A single Attention Mode dropdown selects the attention kernel used inside the transformer:

Mode	What it does
sdpa	PyTorch's built‑in scaled‑dot‑product attention — the universal, always‑available baseline.
flash_attn_2	Flash Attention 2 — fused, memory‑efficient attention; speeds up the transformer and lowers attention memory on supported GPUs.
flash_attn_3	Flash Attention 3 — newer FA generation with further speedups on the latest hardware.
sageattn_2	SageAttention 2 — quantized attention kernel for faster inference.
sageattn_3	SageAttention 3 — latest SageAttention; maximizes attention throughput on capable GPUs.

Note

Flash/Sage kernels accelerate the attention portion of the DiT and reduce its memory use, but they require a compatible GPU and a correctly built backend (e.g. Triton support underpins several of these kernels). If a kernel isn't available on your system, fall back to sdpa.

Model Caching (--cache_dit / --cache_vae) [Advanced]

Control	Type	Effect
Cache DiT	Checkbox	Keeps the DiT model resident/cached across work units.
Cache VAE	Checkbox	Keeps the VAE resident/cached across work units.

Caching keeps models loaded so they aren't repeatedly re‑initialized — a clear win when streaming a long video or batch‑processing a directory, where the same model is reused across many chunks/files. It is bypassed for trivial single‑frame work (e.g. a single‑image preview), where there's nothing to amortize the cache against. Note also that on multi‑GPU without streaming, caching is automatically disabled because workers must cache within their own chunk loops.

VAE Tiling & Decode Tile‑Size Clamping

Control	Type	Range	Effect
Encode Tiled	Checkbox	—	Tiles the VAE encode pass to bound its VRAM.
Encode Tile Size	Spin	128–4096 (default 1024)	Tile dimension for encode.
Encode Tile Overlap	Spin	0–512	Overlap between encode tiles (reduces seams).
Decode Tiled	Checkbox	—	Tiles the VAE decode pass — the heaviest stage.
Decode Tile Size	Spin	128–4096 (default 1024)	Tile dimension for decode.
Decode Tile Overlap	Spin	0–512	Overlap between decode tiles.
Tile Debug	Dropdown	false, encode, decode	Visual/diagnostic tiling overlay.

Warning

VAE Decode Tile‑Size Clamping (1024 → 256). VAE decode is where most OOM crashes happen. To prevent them, the pipeline throttles the decode tile size down from 1024 toward 256 as part of its automatic recovery stages — decoding the frame in smaller tiles uses far less peak VRAM. This clamp is what lets very high‑resolution decodes complete on limited GPUs instead of crashing.

Streaming Mode & Chunk Controls

Control	Type	Range / Default	Effect
Enable Video Chunking	Checkbox	—	Splits long videos into time‑based segments processed one at a time.
Chunk Duration (Minutes)	Spin	1–120 min (default 3)	Segment length. Converted at runtime as minutes × 60 × source_FPS frames.
Temporal Overlap	Spin	Int	Frames shared between consecutive chunks to keep motion continuous across segment boundaries.
Prepend Frames	Spin	Int	Extra leading frames fed into each chunk for temporal context.
Skip First Frames	Spin	Int	Skips N frames at the start of the source.
Load Cap Frames	Spin	0 = all	Caps how many frames are loaded (Preview temporarily sets this to a small value and restores it afterward).
Only Frames	Spin	0 = no limit	Caps frames per VAE‑decode chunk to prevent OOM.

How huge archives stay safe. With chunking enabled, the pipeline splits a massive video — think 50,000+ frame 20th‑century archives — into digestible segments (for example, ~2,700‑frame chunks for a few minutes of footage), upscales each segment independently with a temporal overlap to avoid visible seams, and streams the results to disk. Because only one chunk's worth of frames is ever resident at once, peak VRAM stays bounded no matter how long the source is. Chunked outputs are written as ordered parts (e.g. seedvr2_output_part_NNN_MMMMM.<ext>).

Device Management

Control	Type	Effect
GPU Device	Checkable dropdown	Select one or more GPUs. Auto/CPU are exclusive; multiple GPU N entries can be checked together for multi‑GPU inference.

---

2.5 Quality Control [Advanced] & Color

Control	Type	Range	Effect
Input Noise Scale	Double spin	0.0–1.0	Injects noise on the input. Reduces artifacts at high resolutions.
Latent Noise Scale	Double spin	0.0–1.0	Noise in latent space — softens detail when needed.
Color Correction	Dropdown	lab, wavelet, wavelet_adaptive, hsv, adain, none	Post‑process color matching of the result back toward the source.

2.6 Debug [Advanced]

Control	Type	Effect
Verbose Debug	Checkbox	Enables detailed logging from the engine into the log pane.
Auto Tune	Checkbox	Pre‑flight VRAM detection; forces VAE tile overlap to 32 and auto‑reduces batch size on OOM (up to 5 retries) instead of crashing.
Sound Notifications	Checkbox	Plays a system sound on completion/error.

---

2.7 Verification & Preview

The preview workflow lets you judge results on a single frame before committing to a full render.

Preview Capture Button (⚡)

Clicking ⚡ Preview captures the current frame from the timeline, upscales it as a single frame, and shows original vs upscaled side‑by‑side. Internally it:

• Saves the captured source frame as a temporary 16‑bit TIFF (seedvr2_preview_input_frame_001.tiff).
• Temporarily sets batch size to 1 (single‑frame) and a small load cap, then restores your real settings when the preview finishes.
• Writes the upscaled result as seedvr2_preview_frame_<timestamp>.tiff.

Direct Output Generation (no subfolders)

The preview output is written directly beside the source video, not into a generated subfolder. The pipeline detects that the preview target is a concrete image file path (ending in an image extension such as .tiff) and writes to that exact filename, creating only its parent directory — so the comparison engine always finds the file exactly where it expects it.

Live Split‑Screen Mode

When the preview completes, the dual QPixmap comparison engine:

1. Loads both TIFFs directly from their tracked on‑disk paths — bypassing the UI text fields entirely.
2. Validates each load (QPixmap not null) before assigning the left (original) and right (upscaled) sides.
3. Programmatically forces the UI into split‑view instantly (checks the split‑mode button and switches the viewer layout), so you drop straight into a draggable‑divider, zoom/pan comparison without any extra clicks.

---

3. Optimization & Archive Restoration Recommendations

Maximizing modern high‑end NVIDIA GPUs (≈16 GB VRAM)

Tip

16 GB sweet spot.

• DiT Model: seedvr2_ema_3b-Q8_0.gguf (default) for the best quality/VRAM balance; step up to a 7B FP8 variant only if you have headroom to spare.
• Attention: Flash Attention 2/3 or SageAttention 2/3 if your build supports them — faster and lighter than sdpa.
• Batch Size: Start around 9–13 (4k+1) at 1080p targets and increase while VRAM allows; back off one step on OOM.
• VAE Decode: Enable Decode Tiled and rely on the 1024 → 256 tile clamp for high‑resolution targets.
• Offload: Leave DiT/VAE offload at none while you have VRAM headroom; flip VAE offload to cpu first if you approach the limit.
• Auto Tune: On, as a safety net for occasional OOM spikes.

Restoring heavy / long 20th‑century film archives (OOM‑safe)

Tip

Long‑archive recipe (avoid OOM on 50k+ frame sources):

• Enable Video Chunking with a Chunk Duration of 2–3 minutes so each segment is a few thousand frames (≈2,700) rather than the whole film.
• Set a small Temporal Overlap (and a few Prepend Frames) to keep motion seamless across chunk boundaries.
• Turn on Cache DiT and Cache VAE — caching pays off precisely in streaming/long jobs because the models are reused across every chunk.
• Enable DiT Offload → cpu and VAE Offload → cpu to trade abundant system RAM for scarce VRAM.
• Keep Batch Size conservative (5–9) and VAE Decode Tiled on so the heavy decode phase stays clamped.
• For a true archival master, export an Image Sequence in 16‑bit TIFF (or ProRes 4444 XQ for a video master) rather than a lossy MP4.
• Use a fixed deterministic seed (the GUI default) so re‑renders of the same reel match exactly.

---

4. Changelog & Recent Upgrades

Latest crucial updates

• Fixed Preview subfolder bug. Preview outputs now sit cleanly next to the input video instead of being dropped inside a newly created subfolder. The saver detects a direct image file path (e.g. ..._preview_upscaled.tiff), creates only the parent directory, and writes the upscale to that exact filename — so the split‑screen view always locates the result.
• Fixed Split‑Screen view responsiveness. The comparison engine now performs automatic internal path tracking (loading both TIFFs from their tracked disk paths), load validation (skipping null pixmaps and falling back gracefully), and automated layout switching (programmatically forcing the UI into split‑view the instant a preview completes).
• Safe dynamic‑shape execution. Implemented compile_dynamic=True with CUDA‑Graph capture disabled for dynamic‑shape‑safe runs, plus dynamic‑shape memory clamp adaptations (including the VAE decode tile‑size step‑down) so variable‑resolution and variable‑length jobs complete without VRAM crashes.

Earlier in v1.7 Beta

• Auto Tune (replaces "Auto Safeguard"): pre‑flight VRAM detection, forced VAE tile overlap of 32, and automatic batch‑size reduction on OOM (up to 5 retries).
• Container‑driven codec selection: the Container dropdown filters the Video Codec list to compatible codecs only.
• Broader hardware detection: NVIDIA CUDA, Intel XPU, AMD ROCm and CPU fallback.

---

License

Apache License 2.0 — see LICENSE.

© ByteDance Seed (SeedVR2 model) · Naxci1 (1‑Click GUI)

Links

• 🌟 GitHub Repository
• 🔬 Original SeedVR2 Project

[skv89]

I really hope more people are aware of this and use it.

[amrshank92]

isn't it available yet. ? couldn't find download option.

[naxci1]

Hi.

The application is ready. I spent two days preparing and testing it, fixing bugs. I haven't seen any other errors yet. You don't need the comfyui directory for it to work; you need to specify the ffmpeg directory. Other directories will be included in the setup file, so you won't need to specify them separately. However, for now, you should select the directories in the settings section as they are in separate directories. Test it, and if you encounter any problems, please let me know.

https://github.com/naxci1/1Click_SeedVR2.5/releases/download/v1.7b/SeedVR2_GUI.exe

[naxci1]

Meanwhile, my GitHub Copilot Pro account wasn't enough, and I ran out of AI credits while coding, so I bought the GitHub Copilot Pro+ package, half of which I used up yesterday. Since I'm coding with Claude Opus 4.8, the credits are depleted very quickly. I hope it's worth it; I'll do the final tests and start installing the setup.

[naxci1]

I also made some additions for future development, for example, multi-GPU wasn't working properly, which I fixed. VRAM leaks, splitting, and overflows were also addressed in the code. Someone sent a PR for Intel GPUs, and I added that to the code as well; now it works on all GPUs and CPUs. Of course, I couldn't do practical tests because I don't have those GPUs, but it would be great if tests could be done so we can fix any bugs.

[naxci1]

When previewing any frame in the video, I used to do it in PNG format, but I converted it to TIFF 16-bit for a higher quality output. It's also possible to compare it with split mode; before video processing, it shows how it will look by displaying just one frame as an image. In the video preview section, you can select the desired frame and preview it. Additionally, you can select any section of the video and upscale only that section, just like with Topaz video. None of these features were available in the old SeedVR2.

[naxci1]

Hi @amrshank92 @skv89 @urixl

Were you able to test it? Were there any problems?

[amrshank92]

Prores export not working. Error code 2
Too slow. Tried a 47 second video. It took more than 2 hour to complete. on comfy ui ,it took only 30 minutes.

[naxci1]

Hi @amrshank92

I exported it using Propes and had no problems. Please send me the full log so we can examine the issue. Start the debug process, copy the log using the "copy log" button in the bottom right corner, and send it to me. Also, what is your system specifications? RAM, VRAM, GPU.

[naxci1]

Hi.

The 1.8 beta version of the application is almost finished, and I've completely redesigned the layout for a more visually appealing and user-friendly experience. You can see this in the image below. Many bugs have also been fixed.

[naxci1]

version 1.8 beta

https://github.com/naxci1/1Click_SeedVR2.5

[amrshank92]

Error code 2

inference_cli.py: error: unrecognized arguments: --source_fps 25.000000 --resolution_mode pixel --pre_downscale 1 --ffmpeg_video_args ["-c:v", "libx265", "-preset", "medium", "-crf", "23", "-pix_fmt", "yuv420p10le", "-profile:v", "main10", "-r", "25.0", "-c:a", "copy"]

[naxci1]

At the top of the application, click the 'show log' button when starting the process and copy the entire log to see what the problem is.

[naxci1]

Hi @amrshank92

Based on your other comments above, it seems there's a problem with your computer; even ComfyUI isn't working correctly. So the problem might be related to those. The system needs to function properly for this application to work correctly.

[amrshank92]

I can run comfyui portable without any issues and I ran seedvr2 just now and it works.

Here is the log

▶ F:\AIVE\ComfyUI_windows_portable_nvidia\ComfyUI_windows_portable\python_embeded\python.exe F:\AIVE\ComfyUI_windows_portable_nvidia\ComfyUI_windows_portable\ComfyUI\custom_nodes\ComfyUI-SeedVR2_VideoUpscaler\inference_cli.py E:/REEL/5/AR.mov --output E:\REEL\5\AR_sv2.mp4 --output_format mp4 --source_fps 25.000000 --resolution_mode pixel --resolution 1080 --max_resolution 0 --pre_downscale 1 --dit_model seedvr2_ema_3b-Q8_0.gguf --attention_mode sageattn_3 --batch_size 57 --load_cap 0 --skip_first_frames 0 --vae_encode_tile_size 544 --vae_encode_tile_overlap 32 --vae_decode_tile_size 544 --vae_decode_tile_overlap 32 --color_correction wavelet --input_noise_scale 0.00 --latent_noise_scale 0.00 --temporal_overlap 1 --prepend_frames 4 --dit_offload_device none --vae_offload_device cpu --tensor_offload_device none --blocks_to_swap 18 --seed 313 --video_backend ffmpeg --tile_debug false --cuda_device 0 --model_dir F:\AIVE\ComfyUI_windows_portable_nvidia\ComfyUI_windows_portable\ComfyUI\models\SEEDVR2 --10bit --vae_encode_tiled --vae_decode_tiled --swap_io_components --compile_backend inductor --compile_mode default --ffmpeg_video_args ["-c:v", "libx264", "-preset", "medium", "-crf", "18", "-pix_fmt", "yuv420p", "-r", "25.0", "-c:a", "copy"]
usage: inference_cli.py [-h] [--output OUTPUT]
[--output_format {mp4,png,None}]
[--video_backend {opencv,ffmpeg}] [--10bit]
[--model_dir MODEL_DIR]
[--dit_model {seedvr2_ema_3b-Q4_K_M.gguf,seedvr2_ema_3b-Q8_0.gguf,seedvr2_ema_3b_fp8_e4m3fn.safetensors,seedvr2_ema_3b_fp16.safetensors,seedvr2_ema_7b-Q4_K_M.gguf,seedvr2_ema_7b_fp8_e4m3fn_mixed_block35_fp16.safetensors,seedvr2_ema_7b_fp16.safetensors,seedvr2_ema_7b_sharp-Q4_K_M.gguf,seedvr2_ema_7b_sharp_fp8_e4m3fn_mixed_block35_fp16.safetensors,seedvr2_ema_7b_sharp_fp16.safetensors}]
[--resolution RESOLUTION]
[--max_resolution MAX_RESOLUTION]
[--batch_size BATCH_SIZE] [--uniform_batch_size]
[--seed SEED] [--skip_first_frames SKIP_FIRST_FRAMES]
[--load_cap LOAD_CAP] [--chunk_size CHUNK_SIZE]
[--prepend_frames PREPEND_FRAMES]
[--temporal_overlap TEMPORAL_OVERLAP]
[--color_correction {lab,wavelet,wavelet_adaptive,hsv,adain,none}]
[--input_noise_scale INPUT_NOISE_SCALE]
[--latent_noise_scale LATENT_NOISE_SCALE]
[--cuda_device CUDA_DEVICE]
[--dit_offload_device DIT_OFFLOAD_DEVICE]
[--vae_offload_device VAE_OFFLOAD_DEVICE]
[--tensor_offload_device TENSOR_OFFLOAD_DEVICE]
[--blocks_to_swap BLOCKS_TO_SWAP]
[--swap_io_components] [--vae_encode_tiled]
[--vae_encode_tile_size VAE_ENCODE_TILE_SIZE]
[--vae_encode_tile_overlap VAE_ENCODE_TILE_OVERLAP]
[--vae_decode_tiled]
[--vae_decode_tile_size VAE_DECODE_TILE_SIZE]
[--vae_decode_tile_overlap VAE_DECODE_TILE_OVERLAP]
[--tile_debug {false,encode,decode}]
[--attention_mode {sdpa,flash_attn_2,flash_attn_3,sageattn_2,sageattn_3}]
[--compile_dit] [--compile_vae]
[--compile_backend {inductor,cudagraphs}]
[--compile_mode {default,reduce-overhead,max-autotune,max-autotune-no-cudagraphs}]
[--compile_fullgraph] [--compile_dynamic]
[--compile_dynamo_cache_size_limit COMPILE_DYNAMO_CACHE_SIZE_LIMIT]
[--compile_dynamo_recompile_limit COMPILE_DYNAMO_RECOMPILE_LIMIT]
[--cache_dit] [--cache_vae] [--debug]
input
inference_cli.py: error: unrecognized arguments: --source_fps 25.000000 --resolution_mode pixel --pre_downscale 1 --ffmpeg_video_args ["-c:v", "libx264", "-preset", "medium", "-crf", "18", "-pix_fmt", "yuv420p", "-r", "25.0", "-c:a", "copy"]
📊 Initial CUDA memory: 22.77GB free / 23.99GB total
⚡ SeedVR2 optimizations check: SageAttention ✅ | Flash Attention ✅ | Triton ✅
❌ Process exited with code 2.

[naxci1]

I apparently modified some code in the inference_cli.py file, which is why it didn't work. I'm sorry. So I'll attach the full setup file; you can try that instead.

[naxci1]

1-Click SeedVR 2.5 — Installation Guide & Important Information

Thank you for choosing 1-Click SeedVR 2.5! Please read the following details carefully before and after installing the application.

📥 Automated Dependency Downloads
AI Models & Python Environment: The installer will automatically download the necessary core AI model weights (models.zip ~3.99 GB) and the pre-configured embedded Python environment (python_embeded.7z ~2.67 GB) directly from HuggingFace.

Duration Notice: Due to the large size of these high-fidelity assets, the downloading and extraction process may take some time depending on your internet connection speed and storage performance. Please do not close the installation wizard until it is fully complete.

Shortcut: Once the setup finishes successfully, a launch shortcut icon will automatically appear on your Desktop.

⚙️ Environment & Path Configuration
All-In-One Portability: Everything required to run the tool—including FFmpeg, SeedVR2 core architectures, and all specialized Python packages—is completely self-contained within the application directory.

Zero External Dependencies: You do not need to manually install Python, CUDA toolkits, or any other external software on your system.

Custom Installation Directory: If you choose to install this software into a custom directory rather than the default path, make sure to open the Settings panel inside the application GUI upon your first launch and verify that all internal paths are pointed correctly to your custom location.

🐛 Bug Reports & Feedback
If you encounter any issues, run into VRAM limits, or have feature proposals for future updates, please report them directly in the Issues section of this repository.

Thank you everyone for your support!

https://github.com/naxci1/1Click_SeedVR2.5

[amrshank92]

only source code there

[naxci1]

Yes, there were some errors, so I had to recompile, and now it's ready; you can download and try it. I did a selective download of the model files, but it's better to download them all.

[amrshank92]

Tested. Everything works now, including ProRes export.
I tried exporting the same video at two different resolutions: the 1080p export became incredibly slow after encoding and took 2 hours to finish, while the 720p export completed in only 20 minutes.

[naxci1]

High-resolution batch tiles and other settings need to be configured correctly; otherwise, processing will be slow. If VRAM is insufficient, the settings should be reduced.

[Mertsudo]

Hello @naxci1 thanks for your hardwork is linux support planned?

[naxci1]

Hi @Mertsudo

I plan to make a version for Mac and Linux once the full release is finished, but I don't own those systems yet, so it's not clear how I'll test them.

[snailspacestudios]

Sorry, very new to this. I am getting an error.

[naxci1]

Hi @snailspacestudios

You need to check the paths in the settings; perhaps you created it in a different directory, in which case you need to select the correct paths under that directory.

[snailspacestudios]

thank you for the reply and all the effort i see in this community and on this project @naxci1

i did a default install, made no changes, and ive tried to manually point the path to ffmpeg. unsure if relevent, but i haven't gotten seedvr2 to install correctly in comfy either.

Traceback (most recent call last):
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\utils\import_utils.py", line 1015, in get_module
return importlib.import_module("." + module_name, self.name)
~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\standalone-env\Lib\importlib_init.py", line 88, in import_module
return _bootstrap._gcd_import(name[level:], package, level)
~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "", line 1387, in _gcd_import
File "", line 1360, in _find_and_load
File "", line 1331, in _find_and_load_unlocked
File "", line 935, in _load_unlocked
File "", line 1023, in exec_module
File "", line 488, in _call_with_frames_removed
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\loaders\single_file_model.py", line 28, in
from .single_file_utils import (
...<33 lines>...
)
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\loaders\single_file_utils.py", line 53, in
from transformers import AutoImageProcessor
File "", line 1412, in _handle_fromlist
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\utils\import_utils.py", line 2226, in getattr
module = self._get_module(self._class_to_module[name])
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\utils\import_utils.py", line 2460, in _get_module
raise e
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\utils\import_utils.py", line 2458, in get_module
return importlib.import_module("." + module_name, self.name)
~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\standalone-env\Lib\importlib_init.py", line 88, in import_module
return _bootstrap._gcd_import(name[level:], package, level)
~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\models\auto\image_processing_auto.py", line 24, in
from ...image_processing_utils import ImageProcessingMixin
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\image_processing_utils.py", line 34, in
from .processing_utils import ImagesKwargs, Unpack
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\processing_utils.py", line 62, in
from .utils.type_validators import (
...<9 lines>...
)
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\utils\type_validators.py", line 19, in
from ..activations import ACT2FN
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\activations.py", line 22, in
from .integrations.hub_kernels import use_kernel_forward_from_hub
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\integrations\hub_kernels.py", line 25, in
from .flash_attention import flash_attention_forward
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\integrations\flash_attention.py", line 9, in
use_top_left_mask = flash_attn_supports_top_left_mask()
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\modeling_flash_attention_utils.py", line 43, in flash_attn_supports_top_left_mask
if is_flash_attn_2_available() or is_flash_attn_3_available() or is_flash_attn_4_available():
~~~~~~~~~~~~~~~~~~~~~~~~~^^
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\transformers\utils\import_utils.py", line 965, in is_flash_attn_2_available
pkg.replace("", "-") for pkg in PACKAGE_DISTRIBUTION_MAPPING["flash_attn"]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^
KeyError: 'flash_attn'

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\nodes.py", line 2212, in load_custom_node
module_spec.loader.exec_module(module)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^
File "", line 1023, in exec_module
File "", line 488, in call_with_frames_removed
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\custom_nodes\seedvr2_videoupscaler_init.py", line 7, in
from .src.interfaces import comfy_entrypoint, SeedVR2Extension
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\custom_nodes\seedvr2_videoupscaler\src\interfaces_init_.py", line 8, in
from .video_upscaler import SeedVR2VideoUpscaler
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\custom_nodes\seedvr2_videoupscaler\src\interfaces\video_upscaler.py", line 10, in
from ..utils.downloads import download_weight
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\custom_nodes\seedvr2_videoupscaler\src\utils\downloads.py", line 14, in
from .model_registry import MODEL_REGISTRY, DEFAULT_VAE
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\custom_nodes\seedvr2_videoupscaler\src\utils\model_registry.py", line 14, in
from ..models.video_vae_v3.modules.attn_video_vae import VideoAutoencoderKLWrapper
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI\custom_nodes\seedvr2_videoupscaler\src\models\video_vae_v3\modules\attn_video_vae.py", line 20, in
from diffusers.models.autoencoders.vae import DecoderOutput, DiagonalGaussianDistribution
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\autoencoders_init_.py", line 1, in
from .autoencoder_asym_kl import AsymmetricAutoencoderKL
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\autoencoders\autoencoder_asym_kl.py", line 21, in
from .vae import AutoencoderMixin, DecoderOutput, DiagonalGaussianDistribution, Encoder, MaskConditionDecoder
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\autoencoders\vae.py", line 24, in
from ..unets.unet_2d_blocks import (
...<4 lines>...
)
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\unets_init_.py", line 6, in
from .unet_2d import UNet2DModel
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\unets\unet_2d.py", line 23, in
from .unet_2d_blocks import UNetMidBlock2D, get_down_block, get_up_block
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\unets\unet_2d_blocks.py", line 36, in
from ..transformers.dual_transformer_2d import DualTransformer2DModel
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\transformers_init_.py", line 6, in
from .auraflow_transformer_2d import AuraFlowTransformer2DModel
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\models\transformers\auraflow_transformer_2d.py", line 23, in
from ...loaders import FromOriginalModelMixin, PeftAdapterMixin
File "", line 1412, in _handle_fromlist
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\utils\import_utils.py", line 1005, in getattr
module = self._get_module(self._class_to_module[name])
File "C:\Users\snail\ComfyUI-Installs\ComfyUI (1)\ComfyUI.venv\Lib\site-packages\diffusers\utils\import_utils.py", line 1017, in _get_module
raise RuntimeError(
...<2 lines>...
) from e
RuntimeError: Failed to import diffusers.loaders.single_file_model because of the following error (look up to see its traceback):
'flash_attn'

[naxci1]

@snailspacestudios

You don't need to install comfyui or any other application to use 1Click SeedVR2.5

https://github.com/naxci1/1Click_SeedVR2.5/releases/tag/v1.8b

Just download and install this file from this link. If you have any problems,

https://github.com/naxci1/1Click_SeedVR2.5/issues

you can open an issue at this link.

I've already included all the embeds in this application; the setup will download everything automatically during installation.

[skv89]

I tried running v1.8b and it just gives me an error at the very beginning saying CUDA not available on this system and log only shows Exit Code 1.

[naxci1]

Is the CUDA Toolkit installed on your system? And if so, are the paths specified in Vinvodvs? What is your GPU model?

[skv89]

Yep I do. RTX 6000 Pro.

Additionally the default paths are not correct. It was looking for the inference_cli.py in the dist folder but it was actually in the seedvr2_videoupscaler folder.

My own GUI app (that requires ComfyUI to be installed) works perfectly for my system though but I was just going to test yours to see if I could offer suggestions to improve since you are creating a one-click end-user friendly app that everyone can use where my app is specific for my own needs. Eventhough I couldn't use your app right now, I do recommend that you consider adding these resize filters as they are actually slightly superior to Lanczos.

I asked ChatGPT to help me calculate the perfect chunk sizes where there will be zero padding (wasted) frames. This actually speeds up the processing quite a noticeable amount, which makes sense since the no longer need to generate those padded frames only to be deleted. However, your app only allows setting chunk size by minutes. You will need to allow changing chunk size by frame count instead of minute count in order to do this. I think this is a very important feature because it actually speeds up processing.

I asked ChatGPT to help me optimize the system ram usage to avoid converting the whole chunk to float32 at once before writing which create system-RAM spikes and creates OOM errors. It doesn't overwrite anything the inference_cli.py but creates a separate inference_cli_steamwrite.py file that the GUI uses. It works wonders! I can use much larger chunk sizes, which means less chunk to chunk seams and more efficient processing due to less loading and unloading of models required when using larger chunks.

I also asked ChatGPT to create different modes for resuming to make it similar to Topaz type resumes. I tried it and it works.

Since I process long videos at once that takes many hours, sometimes I need to stop to use my computer for something urgent. I added a Close MP4 writer / stop now button to force termination but still try to preserve the progress file.

Then I can load up this incomplete file and resume directly from it since the app counts the number of frames. I tested this and it works perfectly. There were no detectable transition at the seam where it resumed. It was completely smooth transition in the video.

[naxci1]

I think the problem will be fixed if you choose 13.0 for CUDA_PATH instead of 12.9. Because I optimized all the code for CUDA 13. Actually, the latest version is 13.3, and newer versions affect performance. That's why it's always better to install the latest version. Thanks a lot for the other suggestions. I'm taking note of them all and trying to implement them in the next version. I can't do anything until the 1st of the month because I've run out of AI credits.

[skv89]

I installed the latest CUDA 13.3 but still same error. Oh well for now.