Load Qwen Model

Let's get the obvious thing out of the way: Load Qwen Model does not call an API and needs no key. The name might make you picture a cloud call; what this node actually does is hoist a full Qwen3-8B language model into your GPU's VRAM so it can run offline, forever, for free. That's the whole selling point of this pack - the "translator" half of it is a local 8B model doing a job on your machine instead of a paid endpoint doing it somewhere else.

It's the first half of a two-node pipeline (this plus Qwen Translator (KO→EN)), and it does exactly one job: load the model once and hand you a handle you feed into the translator. To be clear about what it is not: this Qwen3-8B is not the text encoder inside your checkpoint. Models like Z-Image and Flux Klein ship their own Qwen3 encoder baked in - you don't install that, it runs every generation. This is the separate LLM-as-a-tool pattern, a bolted-on worker that runs before generation to write you a prompt. Don't mix them up, or you'll spend a while looking for a Qwen you never installed.

How it works

Under the hood it's a thin wrapper around HuggingFace's transformers. On load it scans your models/text_encoders/ directory for any subfolder containing a config.json - that's how it builds the model_dir dropdown - then calls AutoModelForCausalLM and AutoTokenizer with your chosen dtype, quantization, and device map. Nothing clever, nothing fragile, and it's the sort of code you can read in two minutes if you want to know exactly what you're running.

One genuinely nice touch: it caches the loaded model keyed on (model_dir, dtype, quantization, device), so re-running your workflow doesn't reload 8 billion parameters from disk. First load is slow; everything after is a cache hit.

The inputs that matter

• model_dir - a dropdown of whatever it found in text_encoders. If it shows (no models found), that's not a bug: you haven't downloaded the model yet (below).
• dtype - bfloat16 by default; also float16 / float32. Leave it alone unless you're fighting crashes.
• quantization - none, 4bit, or 8bit, via bitsandbytes. This is the knob that decides whether the thing fits on your card.
• device - auto, cuda, or cpu. auto is right for almost everyone.

The author's VRAM guidance from the README is worth respecting: 24GB+ can run bfloat16 with no quantization, 12GB+ wants 8bit, and 8GB+ needs 4bit. That's an 8B model - it's not small, and this is where people get burned.

Output: a single qwen_model handle (type QWEN_MODEL) that wires straight into the qwen_model input of the Qwen Translator node.

Installing it

Install the pack through ComfyUI Manager (search "comfyui_qwen_translator_node") or:

cd ComfyUI/custom_nodes
git clone https://github.com/hansol-icelab/comfyui_qwen_translator_node
cd comfyui_qwen_translator_node
pip install -r requirements.txt

Then restart ComfyUI. The requirements pin exact versions of transformers, accelerate, bitsandbytes, and huggingface_hub - installing them can shuffle ComfyUI's own Python deps, so use the same venv ComfyUI runs in and be ready for pip to move some versions around.

Then the part that actually takes time - the model:

pip install huggingface_hub
hf download Qwen/Qwen3-8B --local-dir models/text_encoders/Qwen3-8B

Run that from the ComfyUI root. The folder must contain config.json or the loader won't see it. It's roughly 16GB for the full model, so budget the download accordingly.

Common issues

• (no models found) in the dropdown - the model isn't in models/text_encoders/, or it's missing config.json. The node only lists folders that have one.
• CUDA out of memory - you skipped the quantization step. An unquantized 8B in bf16 wants ~16GB+ VRAM before your checkpoint and VAE get any. Go 8bit, or 4bit if you're under 12GB.
• The model won't leave VRAM. There's no unload node and the cache keeps whatever you loaded. It'll sit there eating memory while your diffusion model runs - restart ComfyUI (or pick a different quantization combo) to free it. For a tool you use for five seconds at the start of a workflow, that's a real quirk to budget around.

For a translator pipeline you're almost always better off on 8bit and accepting a slightly slower first load - the loader isn't the bottleneck, the download was.