ComfyUI is downloaded from one place — the project's own repository at
github.com/comfyanonymous/ComfyUI
— but in three different shapes, and the
shape decides how much you install by hand. The Windows standalone (portable)
build is a compressed archive on that repository's Releases page: it carries
its own embedded Python, so you unpack it and start it. ComfyUI Desktop, from
comfy.org, is a packaged application with an ordinary installer, which is
the shortest path if you never want to see a command line. A git clone of
the repository is the manual path: you supply the Python environment and a
PyTorch build that matches your CUDA driver, and in exchange you get the
version control that node development and bug reports need. Take the portable
build on Windows with an NVIDIA card, Desktop if you want one installer and
automatic updates, and the clone on Linux, on macOS, or whenever you intend to
track the source. Version numbers move weekly, so read the current one off the
Releases page rather than off any guide, including this one.
Downloading ComfyUI is the short half. The long half is what has to be on disk
before a video workflow will run: the diffusion weights, the text encoder and
the VAE files each belong in their own model folder, the workflow JSON comes
from the model's own repository, and the first run is slow enough that a
misplaced file costs an hour before it announces itself. The generator above
builds that checklist for one configuration — which file goes in which folder,
which JSON to load, the two settings that override what the node shows — and
the sections below cover the install paths, the portable build, the
post-download setup and a plain step-by-step list.
The measured half of this page is narrower than the method, and it is worth
saying so plainly rather than implying coverage this site does not have.
MiniMax H3 is the first preset measured here, on an owned RTX 3060 12GB —
every wall time, peak-VRAM and peak-system-RAM number on this page came off
that bench. Other models and other cards will be added as they are measured,
not estimated.
ComfyUI install: three paths and what each needs
A ComfyUI install is one of three things, and the difference is entirely about
who provides Python. The standalone Windows build ships an embedded
interpreter and a matching PyTorch, so nothing on your system is touched and
nothing has to agree with anything else. ComfyUI Desktop bundles the same
runtime behind a conventional installer and keeps its own application data
directory. A manual install from git clone uses your Python: create a
virtual environment, install the PyTorch build that matches your driver's CUDA
level first, then install the repository's own requirements, then start
main.py.
What all three need from the machine is the same short list. On Windows and
Linux, an NVIDIA GPU with a recent driver, because the CUDA level your driver
reports is what decides which PyTorch wheel you may install — install PyTorch
before the requirements file, not after, or you will get a CPU-only build and
wonder why nothing uses the card. Disk space is dominated by weights rather
than by the program: model files for a local video model are tens of
gigabytes, the application is not. CPU-only and AMD installs exist and are
documented in the repository's README; they are not what the presets on this
page were measured on.
Pick the manual path if you will be reading node source, filing issues against
a specific commit, or running on Linux or macOS. Pick one of the packaged
builds otherwise — a broken Python environment is the most expensive way to
learn what pip does.
ComfyUI portable: the Windows standalone build
The ComfyUI portable build is the Windows standalone archive published on the
repository's Releases page. It is not a different program: it is the same
ComfyUI with an embedded Python, a matching PyTorch and the launch scripts
already wired, which is why it is the download most Windows guides assume.
Unpack it somewhere short and local — a path like D:\ComfyUI — and not into
Program Files, Desktop, or any folder a sync client watches. Two reasons:
Windows path-length limits bite deep node trees, and a cloud-sync client will
happily try to upload every model file you add.
Inside the extracted folder you get the ComfyUI directory itself, an embedded
Python directory, an update folder holding the scripts that pull a newer
build, and the launch batch files. run_nvidia_gpu.bat is the one to use on an
NVIDIA card; run_cpu.bat exists for machines without one and is not a
practical way to run a video model. Starting either opens a local server and
prints its address in the console — that address, not a file, is the interface.
Updating is the reason to keep the folder intact: run the update script in the
update folder rather than downloading a fresh archive, because a fresh
archive means re-placing every model file and re-installing every custom node.
When you do move to a new extraction, point it at your existing models with
extra_model_paths.yaml instead of copying tens of gigabytes twice.
ComfyUI setup after the download: folders, nodes, first launch
Once the download is unpacked, ComfyUI setup is almost entirely about where
files go: there is one directory per kind of file under ComfyUI/models, and a
loader node reads exactly one of them — the folder table below
lists the pairs. A file in the wrong directory is not an error message — it is
an empty dropdown, which is why the generator at the top of this page prints
the target directory next to every file it lists rather than leaving you to
match names by eye. If your weights already live somewhere else, edit
extra_model_paths.yaml in the ComfyUI directory instead of copying them.
Custom nodes live in ComfyUI/custom_nodes, one directory per node pack, and
each pack is code that runs in the same Python as ComfyUI. Install one at a
time and restart in between: when a startup fails or a node turns red, the pack
you added last is the answer.
First launch is worth treating as a check rather than a formality. Start the
server, open the interface, and open every loader dropdown before you queue
anything — a name saved inside a workflow JSON is not proof that the file is on
this machine. The MiniMax H3 preset below is that check written out with
numbers: exact folders, exact loaders, and a deliberately tiny render whose
only job is to prove the install.
How to install ComfyUI: a step-by-step checklist
How to install ComfyUI, start to finish, on a Windows machine with an NVIDIA
card — the shortest route, and the one the rest of this page assumes:
- Update the NVIDIA driver, then note the CUDA level it reports. Everything
downstream is chosen to match it.
- Open the Releases page of
github.com/comfyanonymous/ComfyUI
and download the current Windows standalone archive.
- Extract it to a short local path such as
D:\ComfyUI. Not Program Files,
not a synced folder.
- Run
run_nvidia_gpu.bat. Wait for the console to print the server address,
open it, and confirm the empty interface loads. Stop here if it does not —
nothing below fixes a server that will not start.
- Download the model files your workflow needs and put each one in its own
directory under
ComfyUI/models. This is the step that goes wrong most
often; the checklist at the top of this page prints the pairs for one
configuration.
- Install only the custom node packs your workflow actually names, one at a
time, restarting after each.
- Load the workflow JSON, open every loader, and select the filenames that are
really installed rather than the ones the JSON remembers.
- Run a deliberately small render first. Save that graph as your baseline,
then change one thing per run.
On Linux, replace steps 2–4 with a git clone, a virtual environment, a
PyTorch build matching your driver, the repository's requirements file and
python main.py. On a Mac with Apple silicon there is no NVIDIA driver, so
skip step 1 too: take the Desktop installer from comfy.org, or clone and use
the default PyTorch build for that platform. Steps 5 to 8 are identical; none
of the presets on this page were measured on a Mac.
MiniMax H3 preset: setup on an RTX 3060 12GB
Everything from here down is the MiniMax H3 preset, written against the
official Comfy-Org templates and verified on the bench described above. Read
it as the worked example of the method: the folder names, the loader checks
and the smoke-test numbers are H3's, and the shape of each step is not.
Set up MiniMax H3 in ComfyUI in five steps
Quick answer: This guide is for first-time MiniMax H3 users setting up an
official ComfyUI workflow. Update ComfyUI, place the diffusion model, text
encoder, video VAE and audio VAE in their model folders, import the task JSON,
verify every loader inside the collapsed subgraph, and queue the smoke test
before changing settings.
- Update ComfyUI — Use
ComfyUI 0.30.0 or newer,
update Manager and restart before importing the workflow.
- Download files — Download the workflow's diffusion model, text encoder,
video VAE and audio VAE.
- Use correct folders — Keep diffusion, encoder and VAE files in their
separate model directories.
- Import JSON — Drag the official workflow into ComfyUI and select your
installed filenames.
- Run a short test — Queue a short moderate-resolution test. Once it
succeeds, save that workflow as your clean baseline before adding cache,
LoRAs or longer clips.
Put each file in the right folder
Use the
Comfy-Org MiniMax H3 repository
as the current file index. Download only the variants required by your chosen
workflow.
ComfyUI/models/diffusion_models/
ComfyUI/models/text_encoders/
ComfyUI/models/vae/
Do not rename files just to match a screenshot. Open the loader dropdown and
select the filename that is actually installed. If it is missing, rescan models
or restart ComfyUI.
Choose T2V, I2V or R2V
Start with T2V when you only need a prompt, I2V when an image must anchor the
result, and R2V when the graph needs reference media. Node and override notes on
this page were checked against
Comfy-Org/workflow_templates@7837633a…;
record that revision with your clean copy.
Open the T2V subgraph before Queue Prompt
The outer video_minimax_h3_t2v.json canvas is intentionally small: three
documentation notes, a ResolutionSelector, a SaveVideo node and one collapsed
subgraph. The loaders, prompt conditioning, sampler and decoders sit inside that
subgraph. Open it before the first queue, because a missing filename or red node
can otherwise stay hidden.
| Loader group | Expected location or setting | Failure signal |
|---|
UNETLoader | Diffusion checkpoint in models/diffusion_models | Empty dropdown usually means the file is missing, incomplete or in the wrong folder. |
CLIPLoader | Qwen3-VL encoder in models/text_encoders; type remains minimax | A mismatched encoder or type can fail before sampling begins. |
VAELoader ×2 | Video VAE and audio VAE in models/vae | Missing video decode, missing audio or a loader error after sampling. |
| Sampler and output | res_multistep, simple, 20 steps, denoise 1 in the pinned template | Do not tune these until all four files load and one clean output saves. |
- Select a real installed filename in every loader; do not rely on the name
saved in the JSON.
- Set the source image or reference media before testing I2V or R2V.
- Fix the seed while debugging so one change can be compared with the next.
- Resolve missing nodes, reload the JSON, and restart before installing another
node pack.
Source boundary: node names, connections and shipped settings above were
parsed from the
pinned official T2V JSON,
checked August 19, 2026. See the template overview for task and
file differences.
Two settings that override what the node shows
A connected input overrides the number still displayed in its widget. In the
pinned official T2V JSON,
width, height and length are link-driven, so the visible values on the H3 node
are not necessarily the values that execute.
Resolution
The H3 node displays 1344 × 768, but the linked ResolutionSelector ships at
16:9, 0.4 megapixels and a multiple of 32. The template's own size reference maps
that setting to 864 × 480. When an exact canvas matters, disconnect the width
and height links and enter the dimensions directly.
Duration
The linked math node snaps duration to the model's 17-frame block grid. Five
seconds becomes 124 frames, or 5.1667 seconds at 24 fps; ten seconds becomes
243 frames, or 10.125 seconds. For a benchmark or bug report, record frames and
fps instead of only the rounded duration entered in the control.
Run the 512 × 288 smoke test before anything else
Queue a short diagnostic clip before your real prompt. This site's gate is
512 × 288 at 22 frames. On one RTX 3060 12GB test bench, the official T2V and I2V
smoke workflows and the site's R2V smoke workflow completed in 51.8–55.6 seconds.
These are three single observations, not averages or a cross-GPU ranking.
Peak VRAM stayed between 11,591 and 11,689 MiB, or about 94–95% of the card's
reported capacity, while peak guest RAM stayed between 42,348 and 43,176 MiB. On
this bench, the small smoke job was therefore an installation gate, not a
low-memory profile. It does not establish a universal minimum for another GPU,
operating system or workflow build; use the VRAM and system RAM
evidence before generalising.
A successful smoke test establishes only that:
- Every loader resolved to a real file and the encoder loaded as
minimax.
- The graph sampled, decoded and saved one complete video.
- The audio path produced a track when that tested workflow enabled it.
- This exact machine survived this exact short run.
Save the passing JSON as a clean baseline, then change one variable per run.
Treat caching and other acceleration as a separate experiment; the
cache-node record compares them against an unaccelerated
baseline.
Test conditions and dates
Physical GPU 0 was an RTX 3060 12GB with 12,288 MiB. The KVM guest had 16 vCPU,
about 47 GiB RAM and no swap on Ubuntu 24.04; driver 580.173.02, CUDA 13.0,
ComfyUI 0.31.0 at bf4c9a08…, Python 3.12.3 and PyTorch 2.13.0+cu130 were used
with no third-party custom nodes, cache node, Turbo LoRA or SageAttention. Each workflow used 24 fps, 20 steps, a fixed seed,
res_multistep, simple and denoise 1. T2V and I2V were measured August 20,
2026 with native audio on; R2V was measured August 13, 2026 with audio off.
Fix the workflow before tuning quality
Model dropdown is empty
Check the folder, filename and file completion, then restart ComfyUI. A partial
download may appear on disk but fail to load.
Red missing nodes
Install the exact named custom-node repository. Restart and reload the JSON
before installing another pack.
OOM before step one
The text encoder or model handoff may be the problem. A lower sampler resolution
cannot fix every pre-sampling OOM.
Output has no audio
Confirm the workflow includes the audio VAE and audio path. Some optimized
community workflows intentionally disable audio.
Open the symptom-led troubleshooting guide.
MiniMax H3 ComfyUI questions
How do I download the official MiniMax H3 ComfyUI template JSON?
The workflows hub hosts frozen copies of the official Comfy-Org T2V, I2V and R2V
JSON templates, with the pinned revision, SHA-256 and MIT notice. Choose the task
first, download that JSON, and then select the model files installed on your
machine.
What files and folders does MiniMax H3 ComfyUI require?
Each kind of file — diffusion, text encoder, video VAE and audio VAE — has its
own directory under ComfyUI/models; the folder table lists
the pairs.
Which MiniMax H3 ComfyUI template should I use for T2V, I2V or R2V?
Start with T2V if you only have a prompt. Use I2V when a source image must
control composition or identity, and use R2V when the workflow needs reference
media. Run a short test before enabling audio or increasing frames.
Why does the MiniMax H3 ComfyUI template output 864 × 480 instead of 1344 × 768?
The width and height on the H3 node are inputs fed by a link from the
ResolutionSelector node, and a connected input overrides whatever the widget
still displays. The official template ships that selector at 16:9 and 0.4
megapixels, which its own size reference maps to 864 × 480. Disconnect the two
links and type the numbers into the node when a specific canvas matters.
How many frames does a 5-second MiniMax H3 ComfyUI workflow generate?
124 frames at 24 fps, which is 5.1667 seconds rather than 5. The official
template converts a duration in seconds into a frame count with a math expression
that snaps up to the model 17-frame block grid, so a valid length is 17k + 5. Ask
for ten seconds and the same expression returns 243 frames.
Next step
Once the clean MiniMax H3 ComfyUI workflow passes its smoke test, keep that JSON
unchanged and open the task-specific workflow guide before
increasing resolution, duration or adding acceleration. If the clean graph fails,
diagnose the loader or memory symptom first instead of tuning quality around it.