Load bark model(s)

If you've downloaded a Bark text-to-speech workflow and it throws a wall of "missing node" errors, this is the node behind almost all of them. bark_loader ("Load bark model(s)") is the entry point for every Bark generation in the Audio nodes pack from gitmylo - the same dev who later shipped ComfyUI's LTX-2 tooling, so you're in decent hands. It doesn't generate anything itself; it just gets the three GPT-style models Bark needs into memory and hands them to the generation nodes.

Why three models?

Suno's Bark isn't one big model. It's a three-stage pipeline that pretends the whole "speech" problem is just next-token prediction:

1. text - turns your prompt into semantic tokens, the abstract "meaning of the words" layer.
2. coarse - turns those semantic tokens into the rough shape of audio (2 EnCodec codebooks).
3. fine - fills in the remaining detail (8 codebooks total) for actual listenable sound.

Each stage is a separate checkpoint, and this node loads whichever subset you ask for. That's the whole trick of the node: you pick large or small per stage, or none to skip one entirely.

The inputs that matter

The text, coarse, and fine dropdowns each take large, small, or none. The naming is honest: small is a lighter model that runs on weaker GPUs but sounds noticeably worse. none skips loading that stage - do this if you're only cloning a voice or only doing one stage, and you'll save gigabytes of VRAM.

Two booleans round it out:

• use_cpu - force everything onto CPU. Slow, but it works.
• half - load the weights in fp16. Roughly halves VRAM with a barely-audible quality hit. On a 8GB card this is usually the difference between "runs" and "OOM".

The outputs are what you wire forward: text feeds bark_text_encode, coarse feeds bark_generate_coarse, and fine feeds bark_generate_fine. Models come out wrapped in ComfyUI ModelPatchers, which means Comfy can offload them between VRAM and system RAM when you run other stuff - you don't manage that yourself.

Where the weights come from

On first load it downloads safetensors versions of Bark from GitMylo/bark-safetensors on Hugging Face into ComfyUI/models/bark/, plus a JSON config per model. The text model also pulls in the bert-base-multilingual-cased tokenizer. "First run is slow" is not hyperbole - those checkpoints are a few gigabytes combined, so the first generation can look hung while it's actually just downloading. Let it finish once and it's cached forever.

Installing it

Install the pack once and you've got all 15 nodes in it - this one included. Two ways:

• ComfyUI Manager - search for "Audio nodes" (the pack title) and hit Install.
• Manual:

cd ComfyUI/custom_nodes
git clone https://github.com/gitmylo/ComfyUI-audio-nodes

Then restart ComfyUI. The pack only pins two Python deps in its requirements.txt - funcy and encodec - so it installs cleanly on a portable setup; the transformers/torchaudio bits it imports come along with ComfyUI itself.

Common issues

• OOM at load - you're loading large for all three stages on a small card. Drop to small, flip half on, or set stages you don't need to none.
• Looks stuck on first gen - it's downloading weights. Watch the console for the Hugging Face progress bars.
• Text model won't load - the BERT tokenizer download can fail behind strict proxies; retry and make sure you have network access to huggingface.co.

The one trap: if you load none for a stage and then wire a generation node that needs that model, it fails loudly. Pick none only for stages you're genuinely not running.