Viggle Remake in ComfyUI: Reshoot Any Video With MiniMax H3 (12-16 GB Setup Guide)

What if you could reshoot a finished video without a camera? Viggle Remake does exactly that. It recasts a character or edits a shot while keeping the original motion, camera move, timing and soundtrack.

It is an open release from Viggle, built as two LoRAs on top of MiniMax H3, and it runs in ComfyUI. Thanks to int8 and GGUF files, it now reaches cards with as little as 12 GB of VRAM.

This guide covers what Swap and Edit mode do, every file and folder, the exact install commands, the right file for your GPU, the settings that matter, and fixes for common errors.

What Is Viggle Remake?

Viggle Remake is a video-to-video model for reshooting existing footage. You give it a source clip, one to four painted reference frames and a prompt. It renders the same shot again with your changes.

The camera path, the actor’s movement and the timing stay the same. The soundtrack is carried over too; Viggle’s own words are that sound is “carried, not made”, so a silent clip stays silent.

It builds on Viggle-Animate from late August 2026. Under the hood, both modes are PEFT LoRAs (rank 256) on the stock MiniMax H3 fl2va transformer.

New to H3? Start with my MiniMax H3 ComfyUI guide, then come back here.

Swap Mode vs Edit Mode

The look of the result comes from your painted reference frames. You edit one or more frames from the source in any image editor or AI image tool, then pass them in as references.

A reference can also be pinned to its source frame. Pinning locks the composition at that moment, which helps keep long shots on track.

Tip: an image edit model is the easiest way to paint references. My MOSS-Image Edit guide covers a local option.

Which File for Your GPU

The full bf16 route needs about 124-144 GB of base files and an 80 GB card. For home GPUs, Viggle ships merged files that already contain the LoRA.

Higher PSNR is closer to bf16. Viggle notes the swap numbers are noisy, so use them as a rough ranking.

Here is Viggle’s own VRAM guide (edit example, 226 frames, two pinned references):

Note: Viggle measured these on B200 cards with part of the memory blocked off, not on real 12-16 GB GPUs. Treat them as a starting point.

System RAM matters too. The H3 text encoder is a 32B model in bf16, so ComfyUI will lean on RAM to hold it. My MiniMax H3 out of memory guide covers the RAM and swap side.

Install in ComfyUI (Step by Step)

You need the Hugging Face CLI (pip install -U huggingface_hub) and ffmpeg on your PATH. Run these commands from your ComfyUI folder.

1. Download the base H3 text encoder and VAEs (skip any you already have):

   hf download Comfy-Org/MiniMax-H3 text_encoders/qwen3vl_32b_minimax_h3_bf16.safetensors vae/minimax_h3_video_vae_fp16.safetensors vae/minimax_h3_audio_vae_fp32.safetensors --local-dir models

   Add diffusion_models/minimax_h3_fl2va_bf16.safetensors only if you have an 80 GB card.

2. Download the node pack, workflows and example inputs:

   hf download Viggle/Viggle-Remake --include "comfyui/*" "examples/inputs/*" --local-dir ./Viggle-Remake

3. Copy the node pack into custom nodes:

   cp -r Viggle-Remake/comfyui/ComfyUI-Viggle-Remake custom_nodes/

   On Windows, copy the ComfyUI-Viggle-Remake folder to ComfyUI\custom_nodes\ in Explorer.

4. Get your model file. For int8 (no extra node):

   hf download Viggle/Viggle-Remake --include "int8/*" --local-dir ./Viggle-Remake

   For GGUF, install ComfyUI-GGUF and download one quant, for example Q6_K:

   git clone https://github.com/city96/ComfyUI-GGUF custom_nodes/ComfyUI-GGUF
   pip install -r custom_nodes/ComfyUI-GGUF/requirements.txt
   hf download Viggle/Viggle-Remake --include "gguf/*Q6_K*" --local-dir ./Viggle-Remake

5. Move the model file into ComfyUI/models/diffusion_models/.
6. Start ComfyUI with a VRAM reserve that matches the table, for example:

   python main.py --reserve-vram 6

7. Load a workflow: drag comfyui/workflows/remake_swap_ui.json or remake_edit_ui.json onto the canvas.

Final file layout:

Switch the workflow to int8 or GGUF

The shipped workflows are built for bf16 plus LoRA. For the small-GPU files, make three changes:

1. Delete the Load Diffusion Model node and the LoraLoaderBypassModelOnly node.
2. Add Load Diffusion Model (for int8) or Unet Loader (GGUF), and select your Remake file.
3. Connect its MODEL output to the Viggle Remake Keyframe Until node.

Warning: the int8 and GGUF files already contain the LoRA. Loading a Remake LoRA on top of them applies it twice and wrecks the output.

Workflow, Settings and Frame Counts

The graph uses the three Remake nodes plus stock ComfyUI nodes: BasicGuider, KSamplerSelect (euler), ManualSigmas, SamplerCustomAdvanced, two VAE decodes and Create Video at 24 fps.

Always pair the swap file with the swap sigmas and the edit file with the edit sigmas. Mixing them up is an easy mistake when you swap loaders.

The prompt must follow H3’s six-section format, with timestamps that fit your frame count. The repo’s PROMPTING.md has the template, and my MiniMax H3 prompt guide explains the sections.

In the prompt, refer to your reference images as <Picture 1>, <Picture 2> and so on, up to four.

Remake Your Own Video

1. Pick a clip you own or have permission to change, ideally under 12 seconds.
2. Convert it to 24 fps:

   ffmpeg -i in.mp4 -r 24 source.mp4

3. Trim to a valid length (17n+5 frames, for example 226 frames, about 9.4 seconds).
4. Paint 1-4 reference frames: export a frame, change the character or scene in an image editor, and save it as PNG.
5. Load the clip and references in the Viggle Remake Conditioning node, and pin a reference to its frame if you want that composition locked.
6. Write the six-section prompt and queue. Output lands in ComfyUI/output/viggle_remake/.

Longer films go shot by shot. Viggle also ships an MCP server in mcp/ that lets a coding agent such as Claude Code split a film into windows, paint keyframes, write prompts and splice the result.

Need a clip to start from? My MiniMax H3 text-to-video workflow can make one, and Tessera can upscale the remake afterwards.

Quality, Limits and Licence

• Speed: Viggle measured about 95 seconds per 832×480, 226-frame render on a B200 after loading. Consumer cards will be much slower, and Viggle did not publish home-GPU times.
• Known failures: non-humanoid characters in one long take, small artifacts in fine detail, and timing drift in multi-shot clips rendered without pins.
• Licence: the weights fall under the MiniMax H3 Community License. Commercial products must show “MiniMax H3” in the UI, include the licence and NOTICE file, and need written permission from MiniMax above US$20 million annual revenue.
• Code: the inference, ComfyUI and MCP code is Apache 2.0.

Use it responsibly: the model cannot check identity or consent. Viggle says to use it only on footage you have the right to change and on people who agreed, and to label results as AI-generated. Never put a real person into a video without their permission.

Troubleshooting

“CUDA error: invalid argument” with GGUF

The weights fit, but there is no room for activations. Raise --reserve-vram by 2 and try again.

int8 runs out of memory at 1280×736

Without a CUDA 13 PyTorch build, comfy-kitchen falls back to a memory-hungry matmul. Use a GGUF file for high resolution instead.

“You need pytorch with cu130 or higher”

The fast int8 kernels are off, but the fallback still gives correct output. It is a speed warning, not an error.

“Mismatch dtype between input and weight” on GGUF

Harmless. It comes from F32 norm weights inside the GGUF file.

The change barely shows up

On the bf16 route, use LoraLoaderBypassModelOnly. The plain LoraLoaderModelOnly rounds away much of the LoRA at bf16. Also make sure your reference frame clearly shows the change.

Error about frame count or prompt timestamps

The clip must be 24 fps and 17n+5 frames between 90 and 345. Prompt timestamps must end inside that length.

Viggle nodes are red or missing

Check that the folder is ComfyUI/custom_nodes/ComfyUI-Viggle-Remake (not nested twice) and restart ComfyUI. Viggle tested ComfyUI 0.42.0, so update if you are older.

My Take

Viggle Remake is the most practical open “reshoot” tool I have seen for MiniMax H3. Keeping the original motion and soundtrack is what makes it useful for real edits, not just demos.

On a 16 GB card I would start with the edit int8 file at 832×480 and 124 frames, get one clean result, then push length. Remember it is heavy: plan for lots of system RAM and long renders on home hardware.

FAQ

Is Viggle Remake free?

Yes, the weights are free to download under the MiniMax H3 Community License, and the code is Apache 2.0. Large commercial users need permission from MiniMax.

Can Viggle Remake run on 12 GB VRAM?

Viggle lists 12 GB as possible at 832×480 with the Q4_K_M or Q8_0 GGUF and --reserve-vram 8. Those numbers were emulated, so expect some tuning.

What is the difference between Swap and Edit?

Swap replaces people or characters. Edit changes objects, the background, weather or lighting while keeping the people.

Do I need the full MiniMax H3 model?

Not on small GPUs. The int8 and GGUF Remake files replace the H3 transformer, but you still need the H3 text encoder and the two VAEs.

Does Viggle Remake keep the audio?

Yes, it carries over the source soundtrack. It does not create new sound.

How long can a remake be?

Up to 345 frames per render, with up to 294 frames (about 12 seconds) recommended. Longer videos are split into windows.

Can I use it on videos of other people?

Only with their consent and the right to change the footage. Viggle asks users to label outputs as AI-generated.

Sources

• Hugging Face: Viggle/Viggle-Remake (model card)
• Viggle Remake COMFYUI.md (install, VRAM table, troubleshooting)
• ComfyUI Wiki: Viggle Remake news
• Viggle announcement on X
• GitHub: city96/ComfyUI-GGUF