FL PenguinVL Load Model

Every workflow in this pack starts here. FL PenguinVL Load Model is the entry node - it downloads Tencent's Penguin-VL from HuggingFace on first use, caches it, and hands the loaded model to any of the three query nodes (Image, Video, Batch). Everything else is just asking questions. This node is where you decide how much VRAM you're willing to burn, and it's the only one with any real install friction, so it's the one to get right.

What's actually happening

Penguin-VL is Tencent AI Lab's open vision-language model, released under Apache-2.0. The 2B variant is a Qwen3-1.7B backbone with a vision encoder bolted on; the 8B is the same idea on Qwen3-8B. Because it's a custom architecture, the loader sets trust_remote_code=True and pulls a few hundred MB of code from HuggingFace along with the weights - normal for a model this new, but worth knowing when you're asked to allow remote code.

The node's job breaks into three stages, and the code is refreshingly honest about one of them. First it downloads the checkpoint with huggingface_hub into ComfyUI/models/penguin_vl/Penguin-VL-2B/ (or -8B), then it loads the model, then the processor. There's a baked-in workaround in there too: it nulls out vision_encoder in the config before loading to dodge a crash in transformers' meta-device context, then relies on the main checkpoint to supply the vision weights. You don't need to care about that - just know "it didn't load on my first try" is not a sign you did something wrong.

The inputs that actually matter

• model_variant - 2B (~6 GB VRAM in bf16) or 8B (~18 GB). The whole pack's resource question in one dropdown.
• precision - leave on auto. The tooltip says that's fp16 on CUDA, but the real behavior is better: auto prefers bf16 when your GPU supports it, and that's not a cosmetic choice. The vision encoder overflows in fp16, which is why bf16 is the sane default. fp32 is for CPU. Don't manually pick fp16 thinking you're saving VRAM - you're trading correctness for nothing.
• device - auto (CUDA if present, else CPU). Fine as is.

The optional ones: use_4bit drops the 2B to ~3 GB and the 8B to ~8 GB, which is how you run the big model on a mid-range card - but it needs bitsandbytes, which is not installed by the pack's requirements (it's commented out as optional). You'll pip install bitsandbytes yourself. force_reload re-downloads and reloads; leave it off unless a download corrupted.

Install and first run

The easy path is ComfyUI Manager - search "FL PenguinVL". Manual is the same as every FL pack:

cd ComfyUI/custom_nodes
git clone https://github.com/filliptm/comfyui-fl-penguinvl.git
cd comfyui-fl-penguinvl
pip install -r requirements.txt

Then restart ComfyUI. The heavy dependency is transformers (plus torch, accelerate, safetensors) - if you already run Qwen or Llava nodes you already have all of it. The first run downloads the model, which is a multi-GB download; watch the console for the progress bar, and don't panic that it's slow.

Where people get burned

The 8B variant at ~18 GB bf16 is not a joke on an 8 GB card - that's the single most common mistake. If you have 8 GB, run the 2B or flip on 4-bit. Also know the loader keeps one model in VRAM: switching from 2B to 8B (or back) unloads the old one, so you'll eat the reload time when you swap. And a word on custom nodes generally: this pack runs Tencent's remote code from HuggingFace with trust_remote_code=True, and every custom node executes arbitrary Python on load. Penguin-VL is a legit, Apache-2.0 model from a major lab - just don't make it your first and only custom node install without reading a bit about the ecosystem's security history. The node itself has no issues; the habit is the thing worth keeping.

The output is a single model wire - plug it into Image Query, Video Query, or Batch Image Query. That's the whole circuit.