Uncensored Local Image Generation (2026): FLUX, SDXL, Z-Image

The best way to run an unfiltered image model locally in 2026 is FLUX.1 [dev] (12B, released Aug 2024) or an SDXL 1.0 community checkpoint (3.5B UNet, July 2023), driven through Stable Diffusion WebUI Forge or ComfyUI on your own GPU. Their open weights contain no technically-enforced content filter — the restrictions are policy-based, written into the license, not baked into the model — so running them locally means nothing you generate is screened, scored, or logged by a cloud provider. That is the real value proposition here: privacy and full creative control, not explicit content. FLUX.1 [dev] needs about 6 GB of VRAM at GGUF Q4 (or 16 GB+ for FP8 near-full quality); SDXL runs on 8 GB. Since this guide first ran, two Apache 2.0 newcomers have joined them — Alibaba's Z-Image family (6B, no runtime filter) and Chroma, the deliberately unaligned retrain of FLUX.1 [schnell] — and both get full sections below. This guide is strictly SFW and assumes you generate only legal, consensual, adult content in line with each model's Acceptable Use Policy and your local law.

Age & use disclaimer: This article is for adults (18+) and explains the technical fact that local models are unfiltered. It does not host, link to, or describe explicit material. You are solely responsible for what you generate. Never create content involving minors, real people without consent, or anything illegal in your jurisdiction — those are prohibited by every model license referenced here and by law.

Why does running image models locally remove the content filter?

When you use a hosted image generator — Midjourney, DALL·E, or a FLUX endpoint on someone's API — your prompt passes through two filters you never see: a prompt classifier that rejects flagged requests, and an output classifier that blurs or blocks flagged images. Those filters live on the provider's servers, not in the model. They also mean your prompts and outputs are transmitted, inspected, and often retained.

Open-weight models ship differently. The weights for FLUX.1 [dev] and SDXL 1.0 are just files — there is no classifier wrapped around them. Black Forest Labs' own FLUX.1 [dev] model card spells this out: it carries an Acceptable Use Policy and an Out-of-Scope Use section, but those are policy restrictions, not a filter compiled into the weights. The same is true of SDXL community checkpoints, most of which are explicitly marked uncensored on CivitAI.

So "uncensored local" is not a hack — it is simply the absence of a cloud middleman. The trade-off is honest: you gain privacy and creative latitude, and you take on full legal and ethical responsibility, because no automated system is checking your work anymore. For the broader case on keeping inference off the cloud, see our local AI privacy guide.

Is FLUX uncensored? The honest answer

FLUX.1 [dev] and FLUX.1 [schnell] are uncensored at runtime: the open weights contain no classifier, so when you run them locally in ComfyUI or Forge, nothing screens your prompt or your output. But "no runtime filter" is not the same as "trained on everything" — Black Forest Labs curated FLUX.1's training data, so the base model simply never learned much of what a cloud filter would block. Those are the two halves of the answer, and most people searching "flux uncensored" conflate them.

If runtime privacy is your goal — no prompt logging, no output scoring — base FLUX.1 [dev] already delivers it, today, unmodified. If you want the training gap closed as well, that is what the community ecosystem exists for:

• Chroma (Chroma1-HD) is the significant one: an 8.9B-parameter retrain of FLUX.1 [schnell] by the developer lodestones, pruned down from 12B and retrained on roughly 5M curated images spanning artistic, photographic and niche styles. It ships under Apache 2.0 with no safety alignment applied, and its own model card positions it as a neutral base for further fine-tuning rather than a polished daily driver. Because it inherits [schnell]'s Apache license it is also commercially usable — something no FLUX.1 [dev] derivative can claim.
• FLUX.1 [dev] LoRAs on CivitAI patch specific styles and concepts the base model handles poorly. They load in Forge or ComfyUI exactly like SDXL LoRAs; just remember that anything built on [dev] carries its non-commercial license.

The one FLUX model not to reach for here is FLUX.2 [dev]: its license mandates safety filtering and the reference pipeline ships NSFW and IP filters, so it is the wrong base for an unscreened local setup. And the legal frame at the top of this page applies word for word — running unfiltered weights does not loosen any Acceptable Use Policy or your local law.

Which open image models are genuinely unfiltered (and which aren't)?

Not every open model is filter-free. This is the part people get wrong, so here is the verified state of play in mid-2026. Note the important exception: when Black Forest Labs shipped FLUX.2, its open [dev] checkpoint introduced mandatory safety filtering in the license and pipeline — a real change from FLUX.1.

A few honest reads on this table. FLUX.1 [dev] and SDXL 1.0 remain the two go-to bases for full creative control, because their weights carry no compiled-in classifier and the mature community checkpoint/LoRA ecosystem is built around them. FLUX.1 [schnell] is the most permissively licensed (Apache 2.0) and the fastest (1–4 steps), making it a clean commercial-friendly base. FLUX.2 [dev] is newer and higher fidelity (32B), but its license adds mandatory safety filtering, so it is not the model to reach for if your priority is an unscreened local pipeline. FLUX.2 [klein] (4B, Apache 2.0) is the lightweight open option but is less battle-tested for community fine-tunes. The three 2025 arrivals — Qwen-Image, Chroma1-HD and Z-Image Turbo — are all Apache 2.0 with no runtime filter, and each gets its own treatment below.

If your question is simply "what is the best local image generation model," filter aside: for most people it is FLUX.1 [dev] for prompt adherence and photorealism, SDXL 1.0 for style and LoRA breadth, Qwen-Image for readable text inside images, and Z-Image Turbo for speed on small cards. Our best local image models compared roundup ranks all of them on verified specs.

For a deeper VRAM-and-setup walkthrough of the FLUX family specifically, see our guide to running FLUX.1 locally.

What about Z-Image and Qwen-Image?

Both of Alibaba's open image models — Z-Image (6B) and Qwen-Image (20B) — are Apache 2.0, open-weight, and carry no runtime filter, so locally they are exactly as unscreened as FLUX.1 or SDXL. What they lack, for now, is the uncensored checkpoint and LoRA ecosystem that makes SDXL and FLUX the practical picks.

Z-Image is the one to watch. Tongyi Lab (the Qwen group inside Alibaba) released the distilled Z-Image Turbo on November 27, 2025: 6B parameters, Apache 2.0, a 1024px image in roughly 2–3 seconds on an RTX 4090 at just 8 steps. It fits in ~8 GB of VRAM at FP8 and ~6 GB as a community GGUF, which makes it the cheapest genuinely modern model to run. Tongyi has since published the non-distilled Z-Image base on Hugging Face, also Apache 2.0, with full classifier-free guidance intact — and the model card explicitly positions it as the foundation for LoRA training and fine-tunes. A small, fast, permissively licensed, unfiltered base is exactly the recipe that made SDXL's community ecosystem explode, so this is the most plausible successor lineage. Setup is a three-file ComfyUI job; our Z-Image Turbo in ComfyUI guide walks it end to end.

Qwen-Image (20B MMDiT, released August 4, 2025) is the heavyweight of the Apache-licensed group: unmatched among local models at rendering readable text inside images, with no runtime filter in the weights. But it is big — around 40 GB at BF16, realistically 8–13 GB via GGUF or Nunchaku 4-bit with a Lightning LoRA — and the community has not built an uncensored fine-tune scene around it. Choose it for posters, signage and typography rather than as a creative-control base. VRAM tiers and formats are in our Qwen-Image local guide.

Per-model filter behavior at a glance

The useful question is not "is there a filter?" but where the restriction lives: in a runtime classifier (absent when you run locally), in the license (a legal commitment you make), or in the training data (baked into what the model ever learned to draw). Here is the map:

Read down the last two columns and the practical strategy is clear: SDXL for the mature ecosystem today, Chroma if you want an Apache-licensed FLUX-quality base, Z-Image as the bet on where the ecosystem goes next.

How much VRAM do you need to run these locally?

The honest answer: less than you think, thanks to GGUF quantization. SDXL is light; FLUX.1 [dev] scales from a 6 GB card up to a 24 GB workstation depending on the precision you pick. Figures below are drawn from Black Forest Labs' guidance and the widely-used community GGUF builds.

The practical takeaway is that SDXL is the universal starting point — it runs on basically any modern 8 GB GPU and has the largest checkpoint library — while FLUX.1 [dev] is the quality upgrade that scales with your hardware. If you are under 8 GB, start with SDXL at lower resolution before touching FLUX — or run a Z-Image Turbo GGUF quant, which fits ~6 GB cards and still looks thoroughly modern.

First-hand note on speed (approximate)

On my own RTX 3090 (24 GB), generating a 1024×1024 image with SDXL 1.0 at fp16 lands around 4–6 seconds for 30 steps, while FLUX.1 [dev] at GGUF Q8 takes roughly 20–30 seconds for a comparable image, both fully GPU-resident. These are single-machine ballpark numbers, not a controlled benchmark — your steps, sampler, resolution and CPU offload settings will move them. The pattern that holds everywhere: the instant any layer spills to system RAM, generation time multiplies. Keep the whole model on the GPU.

How do you set this up — Forge or ComfyUI?

Two front-ends dominate local image generation, and both run all the models above without any external filter:

1. Stable Diffusion WebUI Forge is the friendliest path. It is an optimized fork of the classic Automatic1111 WebUI with much better memory management and native FLUX support, so a 6–8 GB card can run FLUX GGUF that the original WebUI choked on. You drop a checkpoint into a folder, pick it from a dropdown, and generate. Start with our Stable Diffusion Forge setup guide.
2. ComfyUI is the power-user choice — a node-based canvas where you wire the model, samplers, LoRAs and upscalers together. It is the standard for FLUX and FLUX.2 workflows and gives you precise control over every stage, at the cost of a steeper learning curve. Our complete ComfyUI guide walks the full install and your first FLUX workflow.

Either way the model files live on your disk, the GPU does the work, and nothing leaves the machine. For a turbo-fast modern workflow specifically, our Z-Image Turbo in ComfyUI walkthrough shows the node pattern that also applies to FLUX.

You can verify the model details yourself on the FLUX.1 [dev] model card and the SDXL 1.0 model card before downloading anything.

What about LoRAs and the CivitAI ecosystem?

This is where local generation really earns the "full creative control" label. A LoRA (Low-Rank Adaptation) is a small add-on file — often 50–250 MB — that teaches a base model a specific style, character, or concept without retraining the whole thing. CivitAI hosts thousands of community checkpoints and LoRAs, most built on SDXL with a growing FLUX section, and most marked uncensored by default.

The lineages worth knowing, by base model:

• Pony Diffusion V6 XL (SDXL) — a heavily fine-tuned checkpoint trained on roughly 2.6M aesthetically-ranked images with explicit score/rating tags. It is the backbone of a huge stylized-art ecosystem.
• Illustrious XL (SDXL) — an anime model (v0.1 released Sep 30, 2024; v1.0 on Feb 11, 2025) that blends natural-language and Danbooru-style tag prompting and pushes native resolution up to 1536×1536.
• Chroma1-HD (FLUX.1 [schnell]) — the FLUX side of the story: 8.9B parameters, Apache 2.0, retrained without safety alignment and published explicitly as a base for further fine-tunes. If you want FLUX-class quality with SDXL-style community freedom, this is the lineage to follow.
• Z-Image base (Z-Image) — too new to have a mature scene, but its non-distilled weights keep full CFG for clean LoRA training, and Apache 2.0 plus a 6B footprint make it the cheapest serious base to fine-tune on consumer hardware right now.

Because these are community fine-tunes with no built-in filter, the responsibility shifts entirely to you. CivitAI's own terms, and every base model's license, prohibit minor-involving content, non-consensual depictions of real people, and other illegal uses — local generation does not exempt you from any of that. Treat the ecosystem as professional creative tooling, because that is what keeps it sustainable.

Legal and ethical guardrails (read this before you generate)

Removing the cloud filter does not remove the law. Every model license referenced here — FLUX.1, FLUX.2, SDXL, and the CivitAI community terms — explicitly forbids the same things, and they are the same things that are illegal:

• Never generate content involving minors. This is non-negotiable, prohibited by every license, and a serious crime in essentially every jurisdiction.
• No non-consensual imagery of real people — no deepfakes, no likeness of an identifiable individual without consent.
• Respect commercial licensing. FLUX.1 [dev] and FLUX.2 [dev] are non-commercial; SDXL and FLUX.1 [schnell]/[klein] 4B are more permissive. Check before you sell anything.
• Know your local law. Adult content that is legal to generate privately in one country may be illegal to create or possess in another.

The privacy benefit of local generation is real and legitimate — your creative work stays on your hardware. But "private" is not "lawless." The honest framing is that you have traded an automated gatekeeper for personal accountability.

Key Takeaways

1. Local = no cloud filter, not "no rules." FLUX.1 [dev] (12B) and SDXL 1.0 (3.5B UNet) carry no technically-enforced content filter in their weights — the restrictions are policy-based — so local generation is unscreened and private, but you remain bound by each license's Acceptable Use Policy and the law.
2. FLUX.1 [dev] and SDXL 1.0 are the go-to bases for full creative control. FLUX.1 [schnell] (Apache 2.0) is the most permissive and fastest; FLUX.2 [dev] (32B, Nov 2025) is higher fidelity but adds mandatory safety filtering, so it is not the unscreened pick.
3. VRAM is approachable. SDXL runs on 8 GB; FLUX.1 [dev] scales from ~6 GB (GGUF Q4) to ~24 GB (FP16). FP8 on a 16 GB card gives near-full quality at roughly 40–55s per image.
4. Forge or ComfyUI run everything locally. Forge is the easy on-ramp; ComfyUI is the node-based power tool standard for FLUX workflows.
5. The CivitAI LoRA/checkpoint ecosystem (Pony V6 XL, Illustrious XL) is the engine of creative control on SDXL — and it shifts full legal responsibility to you.
6. The Apache 2.0 newcomers redraw the map. Z-Image (6B, Tongyi Lab) and Qwen-Image (20B) ship unfiltered at runtime under permissive licenses, and Chroma1-HD (8.9B, retrained from FLUX.1 [schnell] with no safety alignment) is the deliberate uncensored fine-tuning base on the FLUX side.

Next Steps

• New to local diffusion? Begin with the easiest front-end in our Stable Diffusion Forge setup guide.
• Want node-level control and FLUX workflows? Work through the complete ComfyUI guide.
• Sizing FLUX to your GPU? Read Run FLUX.1 Locally for the full VRAM and quant breakdown.
• Care about keeping everything off the cloud? Our local AI privacy guide covers the why and the how.
• Want a fast modern workflow? See Z-Image Turbo in ComfyUI.
• Comparing every current model on quality, speed and license? The best local image models compared roundup has the verified spec tables.
• Need readable text inside your images? Start with the Qwen-Image local guide.