Runs on 8GB VRAM: Qwen-Image-2.1-Turbo “Uncensored” — Local Deployment in 8 Steps (With ComfyUI Workflow)

AtomicChat has been publishing GGUF repos on HuggingFace back-to-back these past two days: a quantized denoiser for Qwen-Image-2.1-Turbo, and a text encoder with a rather provocative name — “Uncensored.”

People in the comments are already fantasizing about what an “unlocked” model can generate. Before getting into the technical details, let’s pour some cold water on that: the official model card’s own testing shows that swapping in this encoder with 45 sensitive prompts produced zero output changes. What it generates is essentially identical to the official version.

So what’s the point? Can an 8GB RTX 5060 actually run it? Yes — we tested it and it works. The ComfyUI workflow below was developed step by step through real-world trial and error on an RTX 5060 (8GB VRAM). All 5 pitfalls in Section 3 and 4 prompt sets in Section 4 have been verified on real hardware — not armchair theorizing.

Test results: First image takes about 2 minutes (including model initialization/loading). Every subsequent generation is about 1 minute.

This article covers everything: how to download 4 model files, where to put them, a ready-to-use workflow, solutions to 5 real-world pitfalls, 4 “uncensored” prompt sets, and a quantization selection table based on the official 48-prompt test data.

Key Insight: What “Uncensored” Changes Is Not the Image — It’s the “Refusal” Weights

Qwen-Image-2.1 uses three components: the denoiser (paints the image) + text encoder (understands prompts) + VAE (decodes the image).

This “uncensored” version only modifies the text encoder: it projects out the single weight direction in Qwen3-VL-8B responsible for “refusal.” Official test results:

• Encoder used as a chat model: harmful request refusal rate drops from 88.9% → 1.2%, while MMLU general capability remains unchanged (77.35%)
• Encoder used for image generation: 45 sensitive prompts produce 0 output flips before/after the swap — because the native pipeline never had a content filter to begin with

In short: this is not an “unlocked version” — it’s an “encoder with no refusal tendency.” For image generation, the value lies in: a ready-to-use Qwen3-VL encoder GGUF where the Q8_0 variant only causes a 0.037 image deviation (nearly lossless); plus, when running locally, no one controls what you generate.

Let’s take a look at the generated image results 👇

1. Download List: 4 Files — Name / Size / Direct Link / Destination

The following files have been individually verified via the HuggingFace official API:

⚠️ Three pitfalls to watch out for:

• Don’t download the BF16 denoiser (14.23GB — instant OOM on 8GB VRAM). Make sure the filename contains AD-Q4_K.
• The encoder repo has 6 quantization levels; for 8GB cards, use Q8_0 (loaded into RAM) — don’t grab AD-Q2_K (image output visibly degrades).
• The denoiser and encoder filenames look very similar: the one with Abliterated-Uncensored is the encoder (goes into CLIPLoader), the one without is the denoiser (goes into Unet Loader). Mixing them up causes an immediate error — see Pitfall 2 in Section 3.

Download self-check: all 4 files in place + sizes match (4.20GB / 8.71GB / 1.16GB / 644MB) → success.

📜 License note: The license for Qwen-Image-2.1 official weights has changed from Apache 2.0 to the Qwen Research License (HuggingFace official model card license_name=qwen-research, verified 2026-10-11). Fine for personal learning and testing, but read the official LICENSE before any commercial use.

2. ComfyUI Workflow: Drag and Use (11 Nodes, Pre-Wired)

The workflow JSON is ready — download and drag it directly into the ComfyUI canvas to import:

Qwen-Image-2.1-Turbo_Uncensored_ComfyUI_Workflow.json

Step 1: Prerequisites

• Update ComfyUI to the latest version (native Qwen-Image-2.1 support landed in 0.37+)
• Install custom nodes via Manager:
  • ComfyUI-GGUF (city96 — loads GGUF denoiser/encoder)
  • ComfyUI-KJNodes (kijai — needed for precisely reproducing the Turbo scheduler)
  • Comfyroll Studio (for aspect ratio control — search “Comfyroll” in Manager and pick the card whose description includes “Aspect Ratio”)
• Community patch ComfyUI-GGUF-Qwen3VL-TE: Run git clone https://github.com/pottokao-dotcom/comfyui-gguf-qwen3vl-te in the custom_nodes directory, fully restart ComfyUI. When the console shows [GGUF-Qwen3VL-TE] ComfyUI-GGUF patched, the patch is active. (Why this is required — see Pitfall 3 in Section 3.)

Step 2: Place the Models

Put the 4 files into their respective directories per the Section 1 table. ComfyUI Desktop users note: the model directory is the shared directory (e.g., E:\Comfy-Desktop\ComfyUI-Shared\models\ containing diffusion_models/, text_encoders/, vae/). Don’t drop files into the bundled models folder inside the installer package.

Step 3: Wire Up the Nodes (Double-click the canvas to search for node names)

Node list:

• Unet Loader (GGUF) → select Qwen-Image-2.1-Turbo-AD-Q4_K.gguf from the dropdown
• CLIPLoader (GGUF) (note: no space between “CLIP” and “Loader”) → select Qwen-Image-2.1-Turbo-Abliterated-Uncensored-Q8_0.gguf, set type to qwen_image
• Load VAE → select qwen_image_2.1_vae_bf16.safetensors
• CLIP Text Encode (positive): enter your prompt; clip connects to node 2
• CLIP Text Encode (negative): leave empty; clip connects to node 2 (Turbo uses cfg=1, no need for negative prompts)
• KSamplerSelect: select euler
• CustomSigmas (KJNodes): paste the official Turbo 9 values: 1.0, 0.978453, 0.95418, 0.926626, 0.89508, 0.845148, 0.704534, 0.414568, 0.0. interpolate_to_steps must be set to 8 (confirmed from KJNodes source code: when the count ≠ steps+1, it performs logarithmic interpolation and destroys the official schedule; when 9 = 8+1, values are used as-is). Separate numbers with English commas + spaces.
• SamplerCustom: model←1, positive←4, negative←5, sampler←7, sigmas←8, latent_image←12; add_noise=true, noise_seed random, cfg=1.0
• VAE Decode (vae←3, samples←9) → Save Image
• CR Aspect Ratio (Comfyroll, image ratio): select a preset from the dropdown, e.g., SDXL - 16:9 landscape 1344x768 (horizontal), SDXL - 9:16 portrait 768x1344 (vertical/phone wallpaper), SDXL - 1:1 square 1024x1024 (square). For custom dimensions, select custom and manually enter width / height below. Its empty_latent output connects directly to the sampler — no need for an Empty Latent Image node.

Wiring check order: three model nodes → two prompt nodes → one sampler set → decode & save. Scan through in this order before hitting Queue — a single missing connection causes an error.

Lazy Version (Skip KJNodes)

Just use KSampler: steps 8, cfg 1.0, sampler euler, scheduler simple. It will generate images, but the official team has warned that Turbo without its own scheduler will have quality drift. To reproduce the official output precisely, use the SamplerCustom version above.

3. Real-World Pitfall Log: 5 Issues Found and Solved on Real Hardware

The official model card explicitly states this uncensored encoder has “Not run yet in ComfyUI” — the official team hasn’t even tested it in ComfyUI themselves. The following 5 pitfalls represent the full process of clearing the untested territory, each with its solution.

Pitfall 1: Error on workflow import — CustomSigmas “cannot convert to INT”

Symptom: After dragging the JSON onto the canvas and clicking Queue, CustomSigmas reports an error: the input value 1.0, 0.978453, ... for interpolate_to_steps cannot be converted to INT.

Cause: When hand-writing ComfyUI API-format JSON, the order of widget parameters in inputs must match the declaration order in the plugin’s source code INPUT_TYPES — the frontend maps widget values by position during import. The first version of the JSON placed interpolate_to_steps before sigmas_string, causing the long number sequence to be injected into the INT input box.

Solution: Re-download the workflow JSON from Section 2 (delete the old version). Lesson: always generate hand-written workflow JSON with a script that follows source code order + validation — never arrange widgets manually.

Pitfall 2: Unet Loader reports “Unexpected architecture type: ‘qwen3vl’” — denoiser/encoder mixed up

Symptom: Node 1 (Unet Loader) reports: Unexpected architecture type in GGUF file: 'qwen3vl'.

Cause: The dropdown selected the encoder file Qwen-Image-2.1-Turbo-Abliterated-Uncensored-AD-Q4_K.gguf (qwen3vl architecture), but Unet Loader only accepts the denoiser. The filenames in the two repos are extremely similar.

Solution: Change Node 1 to the denoiser: Qwen-Image-2.1-Turbo-AD-Q4_K.gguf (filename has no Abliterated-Uncensored, 4.20GB). Memory rule: with Abliterated-Uncensored = encoder (goes into CLIPLoader), without = denoiser (goes into Unet Loader).

Pitfall 3: Dimension explosion at sampling step 0 — [4096] vs [1, 512, 12288]

Symptom: Denoiser loads successfully (log shows Requested to load QwenImage21 → loaded completely), but sampling blows up at 0/8: Given normalized_shape=[4096], expected input with shape [*4096], but got input of size[1, 512, 12288].

Cause: ComfyUI-GGUF currently cannot correctly load the Qwen3-VL GGUF encoder — it mistakes it for a FLUX.2 klein 9B encoder (evidence: an unexpected Requested to load Flux2TEModel_ line appears in the log), outputting 12288-dim conditioning, while the denoiser’s txt_in expects 4096-dim.

Solution: Install the community patch ComfyUI-GGUF-Qwen3VL-TE (specifically designed for this error — the error message in the author’s docs matches ours character for character). git clone into custom_nodes, fully restart. When the console shows [GGUF-Qwen3VL-TE] ComfyUI-GGUF patched, the patch is active. No new nodes added; no workflow changes needed.

Pitfall 4: After installing the patch, “Missing vision tower” error

Symptom: After the patch takes effect, Node 2 (CLIPLoader) reports: [GGUF-Qwen3VL-TE] Missing vision tower for '...Abliterated-Uncensored-Q8_0.gguf', prompting you to place an mmproj file in the text_encoders directory.

Cause: Once the patch takes over, the Qwen3-VL encoder is loaded in its “complete form” — including the vision projector (mmproj, the component handling multimodality / image editing). The patch locates the mmproj by filename matching and refuses to load if it can’t find one.

Solution: Download mmproj-Qwen-Image-2.1-Turbo-Abliterated-Uncensored-F16.gguf (Download, ~1.16GB) from the same repo and place it in the text_encoders directory — same directory as the encoder, do not rename either file. Pure text-to-image doesn’t use it, but the patch strictly requires the file to exist.

Pitfall 5: Aspect ratio node can’t connect — input boxes can’t automatically become slots

Symptom: The width / height outputs of CR Aspect Ratio hang unconnected, not linked to any node.

Cause: Empty Latent Image’s width/height are input boxes (widgets), not connectable slots. ComfyUI doesn’t automatically convert widgets to slots when importing API-format JSON — both wires get silently swallowed.

Solution: The updated workflow uses a different wiring — remove Empty Latent Image and connect CR Aspect Ratio’s built-in empty_latent output (directly outputs a latent) → the sampler’s latent_image. All standard slot-to-slot connections. Re-download the JSON from Section 2, delete the old nodes from the canvas, and re-drag.

After clearing all 5 pitfalls, a single Queue passes: on the RTX 5060 (8GB), first image takes about 2 minutes (including model initialization), every subsequent generation is about 1 minute.

4. Uncensored Prompts: 4 Tested Sets + 1 Comparison Experiment

Let’s be upfront: official testing shows both encoders produce 0 output flips. So the prompts below demonstrate not “the image looks different” but “the freedom of running locally where no one controls what you generate” — that’s the only practical meaning of “uncensored” for image generation.

Parameters from the proven working config: steps 8, CFG 1.0, euler + 9 official sigmas, negative prompt left empty, ratio as needed.

Set 1: Dark Horror (the category mainstream platforms love to ban)

• Interior of a gloomy Gothic cathedral, flickering candlelight, a skeleton king wearing a crown of thorns seated on a bone throne, blood-red moonlight streaming through stained glass, dark fantasy oil painting style
• Abandoned hospital corridor, bloody handprints on the walls, dark red liquid dripping from the ceiling, thick fog, horror movie still quality

Set 2: Dystopian Satire (topics DALL-E / MJ refuse outright)

• Cyberpunk slum, giant holographic billboard playing a smiling politician, crowds queuing in the rain for rations below, neon and garbage, cinematic composition
• Protest crowd holding placards reading “WE ARE WATCHING”, riot police forming a human wall, tear gas smoke at dusk with backlight, photojournalism style

Set 3: Sensitive Text Posters (Qwen-Image’s signature strength: rendering text)

• Underground bar neon sign reading “NO RULES”, rainy night street reflections, wet asphalt gleaming

Set 4: War / History (graphic scenes, frequently throttled by platforms)

• WWII battlefield, soldiers leaping from trenches in a charge, smoke-filled air, black and white documentary style, heavy film grain
• Medieval siege, burning arrows streaking through the night sky, flames engulfing the city walls, epic oil painting composition

Comparison experiment (recommended as a video): Use the same prompts, generate one image with the uncensored encoder and one with the official encoder, place them side by side and let viewers spot the difference — they almost certainly won’t. That itself is the most powerful counterintuitive proof, directly closing the loop with the claim in Section 2.

5. Quantization Selection Table (Based on Official 48-Prompt Test Data)

Lower LPIPS = closer to original BF16. Official conclusion verbatim: “Q8_0 if it fits. AD-Q4_K is the pick at 4 bits.”

Denoiser:

Encoder:

Note: The AD- prefix refers to AtomicChat’s importance-matrix quantization, which at the same file size stays closer to the original than regular quantization.

A Final Word

Running locally does not mean there are no rules. The official model card explicitly states: do not create content involving minors, and do not create non-consensual intimate or derogatory images of real people. The technology itself is neutral — how you use it has boundaries.

启明破晓 @hiwise_aigc · Oct 10