Most people try this once, get confused by file paths or missing nodes, and give up. Don’t do that. This setup takes about 45 minutes if you follow the exact steps below, and once it’s running, you’ll have a fully private, locally hosted image generation system with zero content filters.
No API keys. No cloud servers looking at your prompts. Just your hardware, your models, and full control.
What “Uncensored” Actually Means in ComfyUI
Quick clarification before you waste time downloading the wrong thing.
ComfyUI itself isn’t censored or uncensored — it’s just a node-based UI runner. The restrictions (or lack thereof) come entirely from the model checkpoint you load into it. A Stable Diffusion checkpoint trained without NSFW filtering will generate without those restrictions. A fine-tuned model like DreamShaper, epiCRealism, or certain LoRA-merged variants trained on unrestricted datasets behaves the same way.
So when people say “use ComfyUI uncensored models,” they mean: load a checkpoint that wasn’t safety-filtered during training into ComfyUI and run it locally.
That’s it. No jailbreaks. No hacks. Just the right model running locally on your machine.
The reason this matters? Cloud services like Midjourney, DALL-E, and Adobe Firefly bake restrictions into their infrastructure — not just the model, but the API layer, the moderation pipeline, everything. Local ComfyUI skips all of that. What runs is what you load. If you want a private alternative to cloud platforms, check out uncensored AI image generation with a private setup for a broader comparison first.
Hardware You Actually Need (Be Honest With Yourself)
Here’s the part most guides skip: what you can realistically run.
NVIDIA GPU with 6GB+ VRAM — This is the minimum for SDXL-based models. RTX 3060 works. RTX 3080 is comfortable. RTX 4090 is smooth. If you’re on a 4GB card, you can still run SD 1.5-based models, but SDXL will be painfully slow or crash mid-generation.
AMD GPU (ROCm on Linux) — Technically supported, but the setup is messier. ROCm on Windows is still experimental as of 2026. If you’re on AMD and Linux, it works. Windows AMD users — expect friction.
CPU-only — It works. I’ve done it. A 512×512 image took about 4 minutes on a modern Ryzen 9. Not practical for regular use, but possible if you’re just testing.
RAM — 16GB minimum. 32GB is comfortable when you’re running large models and have other apps open.
Storage — SDXL checkpoints average 6-7GB each. If you’re collecting models (and you will), get a dedicated drive with at least 500GB free.
Step 1: Install ComfyUI the Right Way
Don’t use the standalone portable version if you want flexibility with custom nodes and models. Use the git clone method — it gives you full control.
On Windows:
Open PowerShell and run:
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt
If you don’t have Python 3.10+ installed, do that first. The official Python.org installer works fine — just check “Add to PATH” during setup.
On Mac (Apple Silicon):
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt
Then launch with:
python main.py --force-fp16
The --force-fp16 flag matters on Mac — without it, Metal GPU acceleration won’t kick in properly and you’ll be running on CPU.
On Linux:
Same git clone process. If you’re on Ubuntu and using NVIDIA, make sure CUDA 11.8 or 12.x is installed before you run pip install. Mismatched CUDA versions cause weird errors that look unrelated.
Once installed, launch ComfyUI:
python main.py
It opens at http://127.0.0.1:8188 in your browser. You’ll see the default workflow with an empty checkpoint node. That’s normal. You haven’t loaded a model yet.
Step 2: Get the Right Model Checkpoint
This is where most setups go wrong — people download random files from random places and wonder why nothing works.
Where to download from:
Civitai is the main hub. Hugging Face also hosts many checkpoints. Stick to these two — anything else is a gamble on file integrity.
Which models actually work without restrictions:
For SD 1.5-based (smaller, faster, runs on 4-6GB VRAM):
- epiCRealism — consistently reliable, great photorealism
- Deliberate v6 — solid for most use cases
- AbsoluteReality — popular for portrait-heavy workflows
For SDXL-based (better quality, needs 8GB+ VRAM):
- DreamShaper XL — the most versatile uncensored SDXL checkpoint right now
- Juggernaut XL — insane photorealism, large file but worth it
- RealVisXL — good for realistic outputs with fine detail
I tested DreamShaper XL and Juggernaut XL most extensively. DreamShaper was faster on my RTX 3080, while Juggernaut produced noticeably sharper skin textures and background detail. Pick based on your VRAM and what you’re generating.
What to look for on Civitai:
Check the model’s base (SD 1.5 vs SDXL), the VRAM requirements listed in the notes, and the example images. If a model’s example images look like what you want to generate, download it.
Download the .safetensors file, not .ckpt when possible. Safetensors is the safer, faster format — .ckpt files can theoretically contain malicious code (though rare in practice). Stick to safetensors.
Step 3: Place the Model in the Right Folder
This trips people up every single time.
In your ComfyUI directory, navigate to:
ComfyUI/models/checkpoints/
Drop your .safetensors file there. That’s it.
Restart ComfyUI (Ctrl+C in terminal, then python main.py again). Your model will now appear in the checkpoint dropdown inside the UI.
LoRA placement: If you’re using LoRA files to modify style or behavior:
ComfyUI/models/loras/
VAE placement: Some models need a specific VAE file for proper color output (especially SDXL):
ComfyUI/models/vae/
The most common SDXL VAE is sdxl_vae.safetensors — grab it from Hugging Face (stabilityai/sdxl-vae repository). Without it, some SDXL models produce washed-out or oversaturated colors.
Step 4: Build Your Basic Workflow
ComfyUI is node-based, which looks intimidating but is actually more flexible than Automatic1111’s interface once you get it.
The default workflow loads automatically when you open ComfyUI. It contains:
- Load Checkpoint — where your model connects
- CLIP Text Encode (Prompt) — positive prompt
- CLIP Text Encode (Negative Prompt) — what to avoid
- KSampler — controls steps, CFG scale, sampler
- VAE Decode — converts latent space to visible image
- Save Image — output
For a basic uncensored generation workflow:
Load Checkpoint: Select your downloaded model from the dropdown.
Positive Prompt: Be specific. “A detailed portrait of a woman with red hair, natural lighting, sharp focus, photorealistic” gets better results than vague prompts. The model was trained on specific language patterns — give it what it expects.
Negative Prompt: This matters more than most people realize. A solid baseline negative prompt for photorealistic models:
(worst quality:1.4), (low quality:1.4), (normal quality:1.4), lowres, bad anatomy, bad hands, ((monochrome)), ((grayscale)), watermark, username, blurry, artist name
KSampler settings that work:
- Steps: 25-35 (more steps = more detail, slower)
- CFG Scale: 7-8 (higher = more literal prompt following, can look weird above 12)
- Sampler: DPM++ 2M Karras (most reliable for photorealism)
- Scheduler: Karras
Hit Queue Prompt. Your first generation will take longer — the model is loading into VRAM. After that, subsequent generations on the same model are much faster.
Step 5: Add Custom Nodes That Actually Matter
Vanilla ComfyUI works, but you’re leaving quality on the table without these nodes.
Install ComfyUI Manager first — it makes node installation one-click:
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager
Restart ComfyUI. You’ll see a “Manager” button in the interface now.
Nodes worth installing:
ComfyUI-Impact-Pack — adds face detailer, which fixes the blurry/distorted faces problem that plagues most AI-generated portraits. This alone improved my portrait outputs significantly.
WAS Node Suite — image saving with metadata, better image loading, useful utilities.
ComfyUI Controlnet Auxiliary Preprocessors — if you want to control poses or compositions using reference images.
ComfyUI’s InstantID — for face consistency across multiple generations. This is genuinely useful if you’re doing character work.
The part that trips people up with custom nodes: some require additional pip packages that don’t auto-install. If a node throws an error on startup, open its folder, look for a requirements.txt, and run pip install -r requirements.txt manually.
Step 6: Using LoRAs to Push Past Model Defaults
LoRA (Low-Rank Adaptation) files modify how a base model generates. They’re small (50MB-500MB typically) and stack on top of your checkpoint.
For uncensored use cases, LoRAs let you:
- Add specific styles without changing your base model
- Emphasize or de-emphasize certain content types
- Improve consistency for specific subjects
Loading a LoRA in ComfyUI:
Right-click in the workflow area → Add Node → Loaders → Load LoRA
Connect it between your Load Checkpoint node and your KSampler. The LoRA node has a strength slider (0-1). Start at 0.7 and adjust. Too high and the LoRA overwhelms the base model’s quality. Too low and you don’t notice it.
LoRA stacking — you can chain multiple LoRA nodes. I’ve run three at once without issues, though past two you start seeing quality degradation unless they’re trained to work together.
Grab LoRAs from Civitai same as checkpoints. Check the base model compatibility — an SD 1.5 LoRA won’t work on an SDXL checkpoint.
Step 7: SDXL-Specific Setup (Don’t Skip This)
If you’re running SDXL models specifically, there are a few things that differ from SD 1.5.
Resolution — SDXL was trained at 1024×1024. Generate at that resolution or close to it. Generating at 512×512 with SDXL gives noticeably worse results than SD 1.5 at the same size.
Two-pass generation — SDXL works better with a base + refiner workflow:
- Generate at 1024×1024 with your base checkpoint
- Pass the result through the refiner (SDXL-refiner-1.0 from Stability AI)
The refiner sharpens details significantly. It’s optional but the quality jump is real.
SDXL VAE — mentioned above, but worth repeating: load the SDXL VAE explicitly in your workflow or the colors will look off. Connect it to your VAE Decode node instead of using the VAE baked into the checkpoint.
Memory management — SDXL needs more VRAM. If you’re hitting OOM (out of memory) errors, add these flags when starting ComfyUI:
python main.py --lowvram
Or for extreme memory saving:
python main.py --novram
--lowvram cuts VRAM usage significantly at the cost of speed. --novram runs everything on system RAM — much slower but avoids OOM on lower-end cards.
Common Problems and Actual Fixes
“Model not showing in dropdown” Almost always a file placement issue. Double-check the file is in ComfyUI/models/checkpoints/. Refresh the node (there’s a refresh button in the Load Checkpoint node). Restart ComfyUI if that doesn’t work.
Black images Usually a VAE mismatch. Load the correct VAE for your model explicitly. For SDXL, use the SDXL VAE. For older SD 1.5 models, the built-in VAE usually works, but try vae-ft-mse-840000-ema-pruned.safetensors if you’re getting black outputs.
Purple/pink tinted images Same VAE issue, different symptom. Grab the matching VAE for your model from Hugging Face.
Blurry faces Install ComfyUI-Impact-Pack and add a Face Detailer node after your VAE Decode. Run the face through 15-20 additional steps at 0.5 denoise. The difference is significant.
CUDA out of memory Lower your resolution first. Then try --lowvram flag. If still failing, your GPU genuinely doesn’t have enough VRAM for that model — use a lighter checkpoint.
Custom node errors on startup Each node error usually has a readable message. Google that exact error + “ComfyUI” — the community has fixed most of these. The ComfyUI GitHub issues page and Reddit’s r/comfyui are the two fastest resources.
Generation stuck at 0% Usually means the model failed to load into VRAM. Check terminal output (the window where you ran python main.py) — the actual error shows there, not in the browser interface.
Privacy: What’s Actually Happening Locally
This matters if privacy is your reason for going local.
When you run ComfyUI locally with python main.py, it binds to 127.0.0.1:8188 by default. That’s localhost — nothing leaves your machine. Your prompts, your images, your model files — none of it touches any external server.
The only time data leaves your machine:
- When you download models from Civitai or Hugging Face (obviously)
- If you run ComfyUI with
--listen 0.0.0.0to expose it on your local network - If you install a custom node that phones home (rare, but check what you install)
For remote access to your own machine, use a local tunnel tool like ngrok or Cloudflare Tunnel — but only if you need it. For local-only use, you’re fully isolated.
Compare this to cloud-based tools: when you use Venice AI or similar services, your prompts go to their servers. They may have privacy policies, but it’s not the same as local. If you want a comparison of private cloud options vs fully local, Venice AI’s complete guide on privacy and uncensored generation breaks that down well.
Comparing ComfyUI to Other Local Options
You have choices. Here’s the honest breakdown.
ComfyUI vs Automatic1111 (A1111)
A1111 has a simpler interface — more like a traditional form with sliders and text boxes. Easier to start with. ComfyUI’s node system is more powerful once you learn it, especially for complex workflows with multiple models, LoRAs, and post-processing steps.
If you want fast setup and simple generation, start with A1111. If you want full control and are building workflows, ComfyUI is the better long-term choice.
ComfyUI vs running local models through Cursor
Different use case entirely — local models with Cursor are for text/code generation. ComfyUI is image-only. Not comparable.
ComfyUI vs cloud platforms
Cloud platforms (Midjourney, DALL-E 3, Firefly) have:
- Better defaults and easier prompting
- No setup required
- Content restrictions
- Monthly subscription costs
- Privacy concerns
ComfyUI local has:
- Setup time investment (45 min to 2 hours for first run)
- No recurring cost after hardware
- Full content control
- Complete privacy
- Requires decent hardware
The break-even on cost is roughly 2-3 months of a Midjourney subscription if you’re already running a capable GPU.
What to Do When Quality Isn’t Where You Want It
Most quality issues trace back to three things: model choice, prompt quality, or sampler settings.
Prompt quality matters more than people think. Vague prompts get vague results. Specific prompts get specific results. Compare:
Vague: “a beautiful woman” Specific: “a 30-year-old woman with auburn hair and green eyes, sitting by a window with natural afternoon light, wearing a white linen shirt, shallow depth of field, photorealistic, Canon 5D aesthetic”
The second prompt tells the model exactly what to build. You’ll get a usable image on the first try instead of 20 iterations.
CFG Scale — if your images look oversaturated or “plastic,” lower the CFG from 7 to 5-6. If they’re not following your prompt closely enough, raise it to 8-9.
Sampling steps — going above 40 steps rarely improves quality. Most of my best outputs came from 25-30 steps. More steps = more compute time with diminishing returns past 35.
Upscaling — for high-resolution outputs without the VRAM cost, generate at 768×768 or 1024×1024 and upscale using the Ultimate SD Upscale node. This tiles the upscaling process, so it doesn’t require exponentially more VRAM. I’ve gotten clean 3072×3072 outputs from an RTX 3080 this way.
Building Reusable Workflows
Once you have a workflow that produces good results, save it.
ComfyUI → Save (top right). This exports the workflow as a JSON file. You can reload it anytime, share it, or use it as a template.
I keep a folder of five or six base workflows:
- Portrait (SD 1.5, epiCRealism, face detailer included)
- Photorealistic SDXL (Juggernaut XL, VAE loaded, two-pass refiner)
- Artistic style (DreamShaper with style LoRA stacked)
- High-res upscale pipeline
- ControlNet pose matching
Takes maybe a week of regular use to build these up. After that, most new projects are just swapping checkpoints or adjusting prompts in an existing workflow.
What Nobody Else Will Tell You About This Setup
The honest reality after running this for a while:
Model hoarding is a real problem. You’ll download 20 models trying to find “the one.” Most of them will be 90% similar. Pick two or three good ones and learn them deeply instead.
Prompting for local uncensored models is a skill. The models trained without restrictions often respond differently to prompting than filtered models. What works on Midjourney might not work here, and vice versa. Spend time learning your model’s trigger words — most Civitai model pages list them.
The community matters. r/comfyui on Reddit, the ComfyUI Discord, and the Civitai forums are where problems get solved. Someone has almost certainly hit your exact error before.
Updates break things. ComfyUI updates frequently. Custom nodes sometimes lag behind. If everything breaks after a git pull, check the ComfyUI GitHub issues — someone’s usually already filed the bug and posted a workaround.
If you’re also exploring uncensored text generation locally, the setup process for building an uncensored local image AI model covers the model training side if you ever want to go that deep.
The Practical Starting Point
Don’t overthink the first session. Here’s what to do right now:
- Install ComfyUI via git clone
- Download DreamShaper XL from Civitai (about 6.5GB)
- Place it in
ComfyUI/models/checkpoints/ - Install ComfyUI Manager
- Install Impact Pack through Manager
- Load the default workflow, select your model, write a specific prompt
- Run at 1024×1024, 30 steps, DPM++ 2M Karras, CFG 7
That’s your baseline. Everything else — LoRAs, ControlNet, face detailing, upscaling — layers on top of that once the base setup works.
The whole system running on your own hardware, offline, with no monthly fee and no content filtering. Once it clicks, you won’t want to go back to cloud tools for this type of work.
For more private AI setups and local model guides, the TheBizAIHub home page has a full library of practical tutorials covering everything from local image models to local LLMs.
