Where to Put Models: The models Directory and extra_model_paths Explained
If you're searching for "where to put ComfyUI models," you're probably holding a freshly downloaded, several-GB .safetensors file and feeling stuck: the tutorial just says "put it in the models directory," but when you open it there are dozens of subfolders and you don't know which one to drag it into.
This lesson explains ComfyUI's model directory rules clearly: what the default models directory looks like, which subdirectory each model type goes in, how to make the files you put there appear in node dropdown lists, and how to use the official extra_model_paths.yaml to place models on any large drive — even sharing the same files with WebUI.
This page is lesson 4 of the Quick Start. You can follow along as soon as ComfyUI is installed — no prior workflow knowledge required.
What You'll Be Able to Do After This Lesson
- Answer "where do ComfyUI models go" in one sentence: the type-matched subdirectories under
<安装目录>/ComfyUI/models/ - Put checkpoints, LoRAs, VAEs, ControlNets, and upscaling models into the correct subdirectories and find them in the corresponding loader nodes' dropdown lists
- Use the
rkey to refresh (or restart) so models added while running get recognized - Write an
extra_model_paths.yaml: let multiple ComfyUI instances, or even WebUI (A1111), share the same model files and stop downloading duplicates - Distinguish the model directory locations and configuration entry points across the three installation methods: portable package, Comfy Desktop, and manual installation
Your Current Predicament
- You downloaded a roughly 4GB model, the tutorial just said "put it in models," you opened models and found twenty or thirty folders, dropped it in randomly, and now no node can find it
- The model is definitely in there, but it just doesn't show up in the Load Checkpoint dropdown, and refreshing the page doesn't help
- You have both WebUI and ComfyUI installed, the same model gets downloaded twice, and tens of GB of disk space vanish just like that; you want to move it to the D drive but are afraid ComfyUI won't find it
When to Use This Technique
When you need to:
- Find the correct subdirectory for a freshly downloaded model file
- Make ComfyUI recognize models placed outside the default directory (e.g., a dedicated model drive)
- Have multiple ComfyUI instances, or ComfyUI + WebUI, share one set of model files
And you don't want to:
- Re-download all your models every time you switch software or follow a new tutorial
- Pile tens of GB of models in the default location on the C drive
- Spend half a day puzzling over configuration file syntax
🎒 Preparation Before You Start
- Have ComfyUI installed and able to start: for the Windows portable package see Installation: Windows Portable Package; for the desktop version / macOS / Linux see Alternative Installations
- Have a model file on hand: if not, first download the official starter SD1.5 weights v1-5-pruned-emaonly-fp16.safetensors (about 4GB; the next lesson's first image generation also uses it)
- Leave enough disk space: the official documentation reminds that a single generative model is often several GB, and both downloading and syncing require budgeting time and space
- A cup of water ☕ (enough time to finish it while the model downloads)
⚠️ Download Tips for Users in Mainland China
Model files are mostly hosted on Hugging Face and Civitai (the community download sources listed in the official documentation). The official documentation notes that users in mainland China may need to configure a proxy for stable access. Slow downloads don't mean you did anything wrong.
Core Idea
**ComfyUI finds models through "agreed-upon folders." ** The installation package itself is tiny and contains no model files; the ComfyUI models folder is by default at <安装目录>/ComfyUI/models/, with type-based subdirectories underneath. ComfyUI scans these directories at startup (plus the paths configured in extra_model_paths.yaml) and fills the files it finds into the dropdown lists of the corresponding loader nodes (most of their names start with Load).
**"Where to put it" always comes down to two steps: first ask the type, then the directory. ** Checkpoints go in checkpoints, LoRAs in loras, VAEs in vae... Putting a model in the wrong subdirectory is about the same as not putting it there at all — drop a checkpoint into the loras folder and no LoRA node will ever list it.
**The directories can be left unchanged, or you can add to them. ** extra_model_paths.yaml is the official "extra search paths" solution: centralize models on one large drive and point multiple ComfyUI instances, or even WebUI, at it. The entry points differ across the three installation methods:
| Installation Method | Default models Directory | Entry Point for Adding External Paths |
|---|---|---|
| Windows Portable Package | ComfyUI_windows_portable\ComfyUI\models\ | ComfyUI root directory's extra_model_paths.yaml |
| Manual Installation (git clone) | <克隆位置>\ComfyUI\models\ (the cloned repository folder) | Same as above (inside the repository folder) |
| Comfy Desktop | Managed by the desktop version; view via capsule menu → Storage | Storage interface (or its configuration file) |
Why can't it be found even though it's in the right place? Besides location, there are two more dimensions: the file extension must be in the supported list (.ckpt / .pt / .pt2 / .bin / .pth / .safetensors / .pkl / .sft); files added while it's running only enter the list after a refresh. These three things are the stars of the "Pitfall Reminders" later on.
Follow along with me
Step 1: Find your models directory — where ComfyUI models go
Why: The three installation methods use different directory locations; find the door first, then talk about putting things in it.
Windows portable package users
Enter this in File Explorer's address bar (replace ComfyUI_windows_portable with your extraction location, e.g. D:\ComfyUI_windows_portable\ComfyUI\models\):
ComfyUI_windows_portable\ComfyUI\models\Manual installation users
The official manual installation is git clone https://github.com/Comfy-Org/ComfyUI.git; the cloned folder is called ComfyUI, and the models inside it is the models directory:
<你的克隆位置>\ComfyUI\models\Comfy Desktop users
No need to dig through folders: click the capsule menu at the top of the desktop app → open the Storage tab to see the various model directories; click the folder icon next to a directory to open it directly in your system file manager. Official note: on the desktop version, models are shared between multiple instances by default.
You should see: a row of subfolders under the models directory — checkpoints, loras, vae, controlnet, etc.
- I can open my own models directory and see subfolders such as checkpoints
Step 2: Know your directories — which model goes in which folder
Why: Model types and subdirectories must match up; a model placed in the wrong location won't appear in any node.
Common type reference table (subdirectory names are the registered names in the ComfyUI source folder_paths.py):
| Model type | Which subdirectory to put it in | Corresponding loader node (where the dropdown is) |
|---|---|---|
| Checkpoint main model | models/checkpoints/ | Load Checkpoint |
| LoRA | models/loras/ | Load LoRA |
| VAE | models/vae/ | Load VAE |
| ControlNet | models/controlnet/ (models/t2i_adapter/ also counts as this type) | Load ControlNet |
| Diffusion models (DiT / UNet, common in new architectures) | models/diffusion_models/ (the old directory name models/unet/ is also recognized) | Load Diffusion Model |
| Text encoders (CLIP / T5 / Qwen, etc.) | models/text_encoders/ (the old directory name models/clip/ is also recognized) | Load CLIP (use DualCLIPLoader for FLUX and other dual-encoder setups) |
| Upscale models (ESRGAN, etc.) | models/upscale_models/ | Load Upscale Model |
| Embedding | models/embeddings/ | — |
💡 New models often come as "three files, placed separately"
New models like Z-Image-Turbo, Qwen-Image, and Wan2.2 are not a single checkpoint; they are split into three files — a diffusion model (→ diffusion_models), text encoders (→ text_encoders), and a VAE (→ vae) — each placed into its own directory. The model lists in the official tutorials all give paths in this format. For which file goes in which slot, see the tutorial for the corresponding model in Model × Task Overview.
💡 You can further categorize within subdirectories
Each type directory supports nesting: you can create folders such as sd15/ and flux/ under models/checkpoints/ to organize things; ComfyUI scans recursively, and files appear in the dropdown with their subdirectory paths included.
You should see: Using the table above, every model file you have on hand can be assigned to its subdirectory — the first model, v1-5-pruned-emaonly-fp16.safetensors, is a checkpoint and goes into models/checkpoints/.
- Using the table above, I know which subdirectory each of my models belongs in
Step 3: Put the model in place and make it appear in the node list
Why: ComfyUI only scans directories at startup; a running ComfyUI will not automatically discover newly added files.
How to do it:
- Put the model file into the corresponding subdirectory. For your first model, the official beginner pick is SD1.5:
v1-5-pruned-emaonly-fp16.safetensors→models/checkpoints/ - If ComfyUI is running, press
ron the canvas to refresh node definitions; if it still hasn't appeared in the list, restart ComfyUI - Double-click the canvas to search for Load Checkpoint (or drag one out of the node library), then open its dropdown list
You should see: v1-5-pruned-emaonly-fp16.safetensors appears in the Load Checkpoint dropdown list.
💡 Model library sidebar: drag and drop to insert
Click the Models icon in the left sidebar to open the model library: browse by folder tree, search by name; drag a model directly onto the canvas and it will automatically insert the corresponding loader node with the file selected — dragging from checkpoints gives CheckpointLoaderSimple, loras gives LoraLoader, and vae gives VAELoader. If a newly added file doesn't show up, click the refresh button at the top of the panel (the shortcut is likewise r).
With the first model in place, you can actually jump straight to Your First Generation to produce an image; if you want to manage model directories systematically, continue with step 4.
- My model appears in the loader node's dropdown list
Step 4: Add external model paths with extra_model_paths.yaml (portable package / manual installation)
Why: Models are often several GB each. If you want to keep models centralized on a dedicated large drive, or let multiple ComfyUI instances or a WebUI share one copy of the files, this single yaml file is the official solution.
Method A: Copy the official example file (recommended)
- Open the ComfyUI root directory — for the portable package it's
ComfyUI_windows_portable\ComfyUI\, for manual installation it's the repository folder you cloned. Inside there is aextra_model_paths.yaml.example(the official readme file bundled with the portable package also says: rename it toextra_model_paths.yamland then edit it) - Make a copy, rename it to
extra_model_paths.yaml, and keep it in the same directory - Open it with Notepad or any text editor and write the configuration based on where your model library is. Suppose all your models are under
D:\AIModels\models\:
D:\AIModels\
└── models\
├── checkpoints\
├── loras\
├── vae\
└── controlnet\The corresponding minimal configuration (from the official documentation example):
my_custom_config:
base_path: D:\AIModels
loras: models/loras/
checkpoints: models/checkpoints/
vae: models/vae/
controlnet: models/controlnet/How to read it: the top-level my_custom_config is the config block name — call it whatever you like; base_path is the model library root directory; each key below is a model type (matching the types in the step 2 table), and its value is a subdirectory relative to base_path. Just write only the types you actually have.
- Save, restart ComfyUI—the official docs state clearly: changes take effect only after a restart.
You should see: lines like Adding extra search path ... appear in the startup log (each added path makes ComfyUI log one of these); the loader dropdown now includes models from the external directory.
- Adding extra search path appears in the startup log, and models in the external directory can be selected
Method B: If the file doesn't exist, create it yourself
It's fine if you can't find .example—the official docs say: create extra_model_paths.yaml with any text editor and place it in the ComfyUI root directory. For the full list of key names, see the official example file (the source code folder_paths.py is the final authority on key names).
Advanced syntax (all of these appear in the official example file)
- Mount multiple directories under one type: use YAML's
|multiline syntax, one per line:
loras: |
models/loras/
models/LyCORIS/base_pathsupports writing~(the user's home directory); when writing relative paths, they are resolved relative to the directory containing the yaml fileis_default: true: puts this path at the front of the list and makes it the default download directory (e.g., the template library's automatic downloads go there)- You can also mount external custom nodes: add a
custom_nodes: <路径>. Note this doesn't change the default install location for nodes; it only adds another search path; a node's Python dependencies still need to be installed in the corresponding environment
Method C: Share one set of models with the WebUI (A1111)
The official docs give a configuration block for coexisting with the A1111 WebUI. If your WebUI is installed in D:\stable-diffusion-webui\, write it like the official example:
a111:
base_path: D:\stable-diffusion-webui\
checkpoints: models/Stable-diffusion
configs: models/Stable-diffusion
vae: models/VAE
loras: |
models/Lora
models/LyCORIS
upscale_models: |
models/ESRGAN
models/RealESRGAN
models/SwinIR
embeddings: embeddings
hypernetworks: models/hypernetworks
controlnet: models/ControlNetAfter saving and restarting, ComfyUI reads the WebUI's model directories directly—one copy of the models, two apps using them, no re-downloading for either.
Step 5: Comfy Desktop users—add directories via the Storage interface
Why: the desktop version has a graphical interface, and the official recommendation is to add directories directly in the UI instead of hand-writing yaml.
How: click the capsule menu at the top → Storage tab → add your model directory. The official desktop docs give two levels of granularity:
- Shared across all instances: Desktop Settings → Storage → Shared Models → + Add Shared Directory
- For a single instance only: Manage → Storage → Model Directories
You can also edit the config file directly: on Windows it's at C:\Users\<用户名>\AppData\Roaming\ComfyUI\extra_models_config.yaml, on macOS at ~/Library/Application Support/ComfyUI/extra_models_config.yaml. The official docs give three reminders:
- Back up the config file before editing so you can restore it if something breaks; don't overwrite the path configuration generated at install time
- The newer desktop docs add: the file in app data above is used by the old desktop version; the current version prefers using the Storage interface
- You can also put
extra_model_paths.yamlin that instance's ComfyUI folder (<安装目录>/ComfyUI/extra_model_paths.yaml); it will also be loaded at startup
You should see: the directory you added appears in the Storage tab; after a restart, the model library sidebar can browse models in the external directory.
- (Desktop users) I've added the directory in the Storage tab and backed up the config file
Checkpoint ✅
- I can open my models directory in one go and state the full path
- I know which subdirectory checkpoint / LoRA / VAE / ControlNet / upscaler models each go into
- For models added while running, I press
rto refresh (or restart if that doesn't work) so they appear in the dropdown - If external paths are configured:
extra_model_paths.yamlis in the ComfyUI root directory, I restarted after editing, and the log shows Adding extra search path - If sharing with the WebUI: both sides' loaders list the same model files
Pitfall reminders
❌ The model is in place but doesn't show in the dropdown
Go through the official troubleshooting order: confirm the file is in the correct subdirectory (checkpoints in models/checkpoints/, not the models root, and not loras) → press r to refresh node definitions → restart ComfyUI → confirm you're looking at the right loader node. If it still can't be found, check the extension: the supported list is .ckpt / .pt / .pt2 / .bin / .pth / .safetensors / .pkl / .sft. If none of that works, the model itself may not be recognized by the current version—the official reminder is to keep ComfyUI updated and first check the template library for a corresponding workflow; for more model errors (architecture mismatch, load failure), see model loading failures.
❌ .gguf files do nothing after being added
ComfyUI does not natively support GGUF—.gguf isn't in the extension list above. To use GGUF quantized models, first install the community nodes city96/ComfyUI-GGUF, then use the loader it provides. For when GGUF is worth using and how to configure it, see GGUF quantized models.
❌ extra_model_paths.yaml changes don't take effect
The three most common causes:
- Wrong location: the file must be in the ComfyUI root directory (for the portable package,
ComfyUI_windows_portable\ComfyUI\, not the outer folder) - No restart: the official docs explicitly require a restart for changes to take effect
- Wrong filename: Windows Notepad easily saves it as
extra_model_paths.yaml.txt—turn on "show file extensions" in File Explorer to check
If it won't start after editing the config and restarting, that's a startup problem—see what to do if installation fails.
❌ yaml indentation mixes in Tabs and the config can't be read
YAML syntax requires space indentation; the official example file uses 4 spaces throughout. Don't press the Tab key when editing in Notepad; type key names must be aligned under the config block name (like the example above). If you break it, copy .example again and start over.
Advanced tips (optional)
🔧 Change the model directory directly with launch arguments: You can also use launch arguments instead of editing the yaml. --models-directory <目录> points the whole model directory elsewhere; --base-directory <目录> is more thorough, moving models, custom_nodes, input, output, temp, and user all at once. Portable package users edit .bat and add the argument (create the target directory first):
.\python_embeded\python.exe -s ComfyUI\main.py --models-directory D:\AIModels\models --windows-standalone-build
pause🔧 Have ComfyUI read an extra config file: --extra-model-paths-config <路径> can load one or more yaml files in addition to extra_model_paths.yaml—for example, put shared configuration in a separate synced directory and mount it whenever needed.
🔧 Where the template library's automatic downloads are saved: When the template library automatically downloads a missing model, Desktop's Download button saves it directly into the corresponding subdirectory of ComfyUI/models/; the self-hosted version opened in a browser instead triggers a browser download, and you need to place the file into the directory manually. See Template Library for how to use the template library.
🔧 Deleting models: There is no "uninstall model" button in the interface—if you no longer want a model, just go to the corresponding subdirectory and delete the file.
🔧 The official name of the r key: This refresh shortcut corresponds to the setting Comfy.RefreshNodeDefinitions. For more keybindings, see Shortcuts & Interface Quick Reference.
Lesson Summary
✅ ComfyUI Where models go: by default <安装目录>/ComfyUI/models/, and for the portable package ComfyUI_windows_portable\ComfyUI\models\; Comfy Desktop lets you view and manage them in the capsule menu → Storage.
✅ Which model goes in which folder: checkpoint→checkpoints, LoRA→loras, VAE→vae, ControlNet→controlnet, diffusion models→diffusion_models, text encoders→text_encoders, upscalers→upscale_models; file extensions are limited to .ckpt / .pt / .pt2 / .bin / .pth / .safetensors / .pkl / .sft.
✅ Refresh after placing files: press r while running; if that doesn't work, restart, and only then will the models appear in the loader dropdown list.
✅ ComfyUI Model paths can be added: put extra_model_paths.yaml in the ComfyUI root directory, base_path + type key names; one type can mount multiple directories, and you must restart after changes; Desktop uses the Storage interface. This is the official ComfyUI shared-model solution.
Key configuration fields recap:
| Field | Syntax | Description |
|---|---|---|
base_path | Root of the model library (supports ~) | Root of the config block; subpaths are resolved relative to it |
checkpoints / loras / vae / controlnet… | Subdirectories relative to base_path; multiple entries use ` | ` multiple lines |
is_default | true (optional) | Puts the path first and makes it the default download directory |
custom_nodes | External node directory (optional) | Appends node search paths without changing the default install location |
| File location | ComfyUI root directory (next to main.py) | for the portable package it's ComfyUI_windows_portable\ComfyUI\ |
| Takes effect when | restart after saving ComfyUI | officially required |
Next Lesson Preview
With the models in place, the next lesson produces your first image: First Generation: The Default Workflow Explained Node by Node.
You will learn:
- What each of the 6 nodes in the default text-to-image workflow does (Load Checkpoint → Empty Latent Image → CLIP Text Encode → KSampler → VAE Decode → Save Image)
- Where to write positive and negative prompts, and how to use
(关键词:1.2)weight syntax - How to tune KSampler parameters like steps / cfg / denoise
- Press Run (Ctrl+Enter) to generate and save your first image
Don't want to start with SD1.5 and prefer to jump straight into workflows for newer models like Z-Image-Turbo, Qwen-Image, or FLUX? Go to Models × Tasks Overview and pick a page to follow along.