Taggerine Tagger

Of the three taggers in this pack, Taggerine is the one you've never heard of - and the one with the most interesting mechanics. It wraps lodestones' "Taggerine" model, a DINOv3-class vision transformer that does something almost no other tagger does: it reads your image at its native aspect ratio instead of squashing it into a square.

That matters more than it sounds. The usual tagger pipeline (WD14, Camie, PixAI) resizes everything to a square, which means tall character shots and wide group scenes get squeezed and lose detail in the process. Taggerine instead scales the long edge to your max_size and keeps proportions, so a full-body vertical composition actually gets seen at full resolution along its important axis. That's the whole pitch, and it's a real one.

How it works

This node doesn't just load weights - it ships the whole architecture. The pack contains a hand-rolled DINOv3 ViT-H implementation: 32 transformer blocks, 20 attention heads, four register tokens, RoPE position embeddings, gated MLPs. The tagger_proto.safetensors checkpoint gets split into backbone and a low-rank classification head, which is a detail worth knowing only because it means the model is genuinely custom rather than a tweaked WD14.

Expect it to be the heavy one in the pack. A ViT-H backbone at 512px is a lot of compute. On a CUDA card the backbone runs in bfloat16 (Ampere or newer; it falls back to fp32 on older hardware), which keeps it usable on a 6–8GB card, but on CPU this will be slow enough to test your patience. This is the GPU-only member of the family.

Inputs and outputs

The usual trio plus one special knob:

• threshold (0.5) - confidence cutoff, same story as every tagger.
• max_size (512, range 224–1024) - the long edge, in steps of 16. 512 is a good default; push toward 768+ if you're tagging images where small details (eye colors, accessories) matter, and accept the speed hit.
• replace_underscores (on) and exclude_tags - behave exactly like Camie's.
• model_path / vocab_path - your two downloaded files, defaulting to the pack's models/ folder.

Outputs are all_tags plus category streams: artist_tags, character_tags, copyright_tags, general_tags, meta_tags, species_tags, style_tags, lore_tags. That's the second differentiator - Taggerine's vocabulary knows categories the others don't bother with. species_tags and lore_tags don't exist on Camie or WD14, and style_tags beyond artist attribution is genuinely rare. (There's a colorist category in the vocab, but the node folds it into general.)

Installing it

Same pack install as the others - ComfyUI Manager, search "ComfyUI-Tagger", or:

cd ComfyUI/custom_nodes
git clone https://github.com/sln77/ComfyUI-Tagger
# restart ComfyUI

Then download tagger_proto.safetensors and tagger_vocab_with_categories_and_alias_updated.json from lodestones/taggerine and point the node at them. It needs safetensors and torch, both of which ship with ComfyUI, so no extra pip installs - unlike the PixAI node in this same pack, which has a hidden timm dependency.

The honest take

Taggerine is a "because I can" tagger, not a "because I must" one. It's obscure - there's barely any community discussion of it, and if you can't find the model files or they feel hard to source, Camie or WD14 is the sane fallback. But the aspect-ratio-preserving inference and the species/style/lore categories make it worth keeping installed for the cases where they matter: tagging tall character art, or wanting more than the same five categories every other model emits. Wire its all_tags into a Tag Combiner alongside a square-input tagger and you've got a genuinely better ensemble than either alone.