---

license: apache-2.0

language:

• en

base_model: Qwen/Qwen3.5-0.8B-Base

pipeline_tag: text-generation

tags:

• gguf
• quantized
• danbooru
• image-tagging
• stable-diffusion
• text-to-image
• llama-cpp
• text-generation

---

BooruNL-0.8B

A small, fast, uncensored model that converts a plain English description of a character or scene

into a clean list of authorized danbooru tags. Fine-tuned from

Qwen3.5-0.8B-Base on 124,000 human-labelled

description → tag pairs, covering the full tag vocabulary including explicit content.

Model files

| File | Size | Notes |

|:-----|-----:|:------|

| BooruNL-0.8B-Q6_K.gguf | 600 MB | Recommended. ~15× faster than HF, within 1% quality. |

| BooruNL-0.8B-Q8_0.gguf | 800 MB | Highest fidelity GGUF; negligible quality gain over Q6_K. |

| BooruNL-0.8B-Q4_K_M.gguf | 500 MB | Smallest; slight quality loss on complex prompts. |

| BooruNL-0.8B-mmproj-f16.gguf | 205 MB | Vision encoder (F16), extracted from the base model. Not useful for tag generation — see note below. |

| model.safetensors (HF) | 1.6 GB | Full bfloat16 weights for fine-tuning or research. |

Quick start

GGUF (recommended)

from llama_cpp import Llama

llm = Llama(model_path="BooruNL-0.8B-Q6_K.gguf", n_gpu_layers=-1, n_ctx=2048)

prompt = """### Input:
Tag this prompt: A gothic punk girl with two-tone black and blonde hair in twin buns, yellow eyes, \
spiked choker, frilly black sailor-collar shirt, two-tone cardigan, red plaid skirt, \
torn fishnet thigh-highs, lying on her back on rumpled bed sheets.
### Tags:
"""

result = llm(prompt, max_tokens=256, temperature=0.05, repeat_penalty=1.3, echo=False)
print(result["choices"][0]["text"])

Output:

1girl, solo_focus, goth_fashion, punk, black_hair, blonde_hair, multicolored_hair, twin_buns,
two-tone_hair, yellow_eyes, piercing, ear_piercing, earrings, spiked_choker, choker, cardigan,
frilled_shirt, plaid_clothes, plaid_skirt, red_skirt, fishnets, thighhighs, on_back, lying

HuggingFace transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "cooperdk/BooruNL-0.8B"  # or local path
tok   = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, attn_implementation="sdpa"
).to("cuda").eval()

prompt = """### Input:
Tag this prompt: A solo slim red-haired girl with freckles and very small breasts, wearing a maid outfit.
### Tags:
"""

ids = tok(prompt, return_tensors="pt").to("cuda")
with torch.no_grad():
    out = model.generate(**ids, max_new_tokens=256, do_sample=False,
                         repetition_penalty=1.3)
tags = tok.decode(out[0][ids.input_ids.shape[1]:], skip_special_tokens=True).strip()
print(tags)

Output:

1girl, solo, maid, red_hair, breasts, freckles, small_breasts

Prompt format

The model accepts any natural instruction prefix. All of the following work:

Tag this prompt: <description>
Convert this to danbooru tags: <description>
danbooru tags for: <description>
<description>         ← bare description also works

The output is a clean comma-separated tag list with no preamble. Rating tags (rating:safe,

rating:explicit, etc.) are not emitted — the model was trained without them in the target, since

rating is metadata rather than appearance. Add your preferred rating tag separately.

JSON object output

The model can also emit a zone-keyed JSON object that groups tags by semantic category:

llm = Llama(model_path="BooruNL-0.8B-Q6_K.gguf", n_gpu_layers=-1, n_ctx=2048)

prompt = """### Input:
Output as JSON. Convert this to danbooru tags: A solo slim red-haired girl with freckles \
and very small breasts, wearing a maid outfit.
### Tags:
"""

result = llm(prompt, max_tokens=512, temperature=0.05, repeat_penalty=1.3, echo=False)
print(result["choices"][0]["text"])

Output:

{"RATING": ["s"], "SUBJECT": ["1girl", "solo"], "HAIR": ["red_hair"], "BODY": ["breasts", "freckles", "small_breasts"], "ATTIRE_STATE": ["slim"]}

A richer description populates more zones, including STYLE, SCENE, PROP, ACTION, and META:

### Input:
Turn this description into danbooru tags, output as JSON:
A sole female kneeling on a beach under a blue sky with clouds and a mountainous horizon during
the day, with a full body official art second-party source shot at a dutch angle. She has long
light purple hair in low twintails with a white bow, a hair bow, a white flower, a white
headwear, a yellow scrunchie, a purple ribbon, a white ribbon, a wrist scrunchie, and a leg
ribbon. She wears a frilled one-piece swimsuit with frills, a sun hat with a hat ribbon, and a
white bow. Her bare shoulders are exposed, her medium breasts are visible, her navel is covered,
and she is barefoot with a thigh shown. She has blue eyes and an open-mouth smile with a blush,
looking at viewer while doing a hat tug with her hands on hat. The scene includes a beach chair,
a beach umbrella, a bird, flower petals, a sand sculpture, a sandcastle, a ball, a beachball,
a bucket, and flowers.
### Tags:

{"RATING": ["s"], "SUBJECT": ["1girl", "solo"], "STYLE": ["swimsuit"], "HAIR": ["light_purple_hair", "long_hair", "low_twintails", "twintails"], "FACE": ["blue_eyes"], "BODY": ["breasts", "medium_breasts", "thighs"], "ATTIRE": ["bow", "hair_bow", "hat", "hat_ribbon", "purple_ribbon", "ribbon", "scrunchie", "sun_hat", "white_bow", "white_flower", "white_headwear", "yellow_scrunchie", "frilled_one-piece_swimsuit", "frills", "one-piece_swimsuit", "white_ribbon", "wrist_scrunchie", "leg_ribbon"], "ATTIRE_STATE": ["bare_shoulders", "barefoot", "covered_navel"], "STATE": ["hands_on_headwear", "kneeling"], "SCENE": ["beach_chair", "bird", "petals", "sand_sculpture", "sand_castle", "beach_umbrella", "blue_sky", "cloud", "day", "mountainous_horizon", "sky"], "PROP": ["ball", "beachball", "bucket", "flower", "umbrella"], "ACTION": ["hat_tug"], "EXPRESSION": [":d", "blush", "looking_at_viewer", "open_mouth", "smile"], "META": ["dutch_angle", "full_body", "official_art", "second-party_source"]}

The JSON object is generated model-natively — no post-processing or conversion is applied.

The model outputs valid JSON directly.

Tags are sorted into up to 25 named zones covering the full danbooru taxonomy. Which keys

appear depends entirely on the input — only populated zones are emitted. A fully described

explicit scene might produce RATING, SUBJECT, STYLE, HAIR, FACE, BODY, ATTIRE,

ATTIRE_STATE, STATE, SCENE, SEXUAL, and META; a simple character description may

produce only a handful. Note that in JSON mode RATING is emitted as a single letter

(g / s / q / e) — unlike flat mode where rating is omitted and must be appended manually.

This format is useful for downstream processing — filtering by zone, selectively overriding

categories, or feeding structured data into other pipelines.

The flat comma-separated format remains the default; instruct the model to use JSON by

including "Output as JSON." (or similar) in the instruction prefix.

Recommended settings

| Setting | Value | Reason |

|:--------|------:|:-------|

| temperature | 0.05 | Best validity (90.5% HF / 89.6% Q6_K). Greedy (0.0) is nearly identical. |

| repetition_penalty / repeat_penalty | 1.3 | Suppresses rare looping on edge-case prompts. |

| max_tokens / max_new_tokens | 256 | Sufficient for all but the most elaborate scene descriptions. |

Prompt quality affects both output quality and speed

More detailed descriptions produce better tags and generate faster.

When the input is specific — named clothing items, exact colors, clear actions — the model resolves

its first token with high confidence and proceeds quickly. A vague or underspecified prompt spreads

probability mass across many plausible continuations, which slows down every generation step even

when the final output is shorter.

Measured on the HF model (bfloat16):

| Prompt | TTFT | Total | Tags emitted |

|:-------|-----:|------:|-------------:|

| "A girl with blue hair." | 1,196ms | 1,196ms | 1 (blue_hair only — missing 1girl, solo) |

| "A solo slim red-haired girl with freckles and very small breasts, wearing a maid outfit." | 830ms | 4,751ms | 7 |

| "A gothic punk girl…" (full 60-word description) | 747ms | 57,708ms | 61 |

The two-word prompt is not only incomplete — it is also the slowest to first token because

the model is uncertain what to commit to. The 60-word gothic punk description generates its first

tag 37% faster despite the far longer output, because every detail narrows the search space

immediately.

Practical tip: Always include subject count (a solo girl, two women), key physical traits

(hair color/length, eye color, body type), clothing, and setting. The more you specify, the faster

and more complete the result.

Benchmarks

Quality — HF (bfloat16) vs Q6_K GGUF

Measured on 10 prompts (2 short, 2 medium, 2 long, 4 explicit). Validity = percentage of

emitted tags that exist in the authorized 137k-tag danbooru vocabulary. Repetition penalty 1.3,

max 256 tokens, 2 samples per prompt at temp > 0.

| Temp | HF valid% | Q6_K valid% | HF TTFT | Q6_K TTFT | HF total | Q6_K total |

|-----:|----------:|------------:|--------:|----------:|---------:|-----------:|

| 0.00 | 89.6% | 88.1% | 909ms | 165ms | 13,668ms | 920ms |

| 0.05 | 90.5% | 89.6% | 901ms | 155ms | 13,696ms | 895ms |

| 0.10 | 87.2% | 88.9% | 878ms | 157ms | 14,265ms | 940ms |

| 0.15 | 87.5% | 88.3% | 915ms | 156ms | 13,108ms | 914ms |

The Q6_K GGUF is within 1% of the full bfloat16 model at every temperature while being

~15× faster end-to-end and ~5–6× faster to first token. At temp ≥ 0.10 Q6_K slightly

edges ahead. The HF model is slower because the base Qwen3.5-0.8B architecture includes a

vision encoder (~200MB) that loads into VRAM even for text-only inference; the main GGUF

strips it, keeping only the language model weights.

CPU vs GPU — Q6_K

Measured on a single representative long prompt, 5 runs each.

| Backend | TTFT | Total | Tags | Valid% |

|:-----------|------:|--------:|-----:|-------:|

| CPU | 381ms | 3,708ms | 40.0 | 80.0% |

| GPU (CUDA) | 396ms | 3,753ms | 40.0 | 80.0% |

CPU and GPU are essentially identical. In this run the GPU was marginally slower on

time-to-first-token.

At 0.8B parameters and Q6_K quantization (600MB), the model fits in CPU cache on modern

hardware. PCIe transfer overhead between host memory and GPU offsets the GPU's compute

advantage, leaving no measurable benefit to GPU offload. This is consistent with Qwen3.5-0.8B's

design target of edge and mobile deployment.

If you have no GPU, or want to keep your VRAM free for image generation, run the Q6_K on

CPU — you pay no speed penalty.

Output examples

All examples: Q6_K, temp=0.05, rep_penalty=1.3.

Medium — maid outfit

Input:  A solo slim red-haired girl with freckles and very small breasts, wearing a maid outfit.
Output: 1girl, solo, maid, red_hair, breasts, freckles, small_breasts

Long — futuristic scene

Input:  A tall, athletic dark-skinned woman with short white hair and red eyes stands confidently
        in a futuristic city at night. She wears a sleeveless black bodysuit with gold trim,
        knee-high boots, and a long white coat draped over her shoulders. Neon lights reflect
        off the wet street behind her.

Output: 1girl, dark-skinned_female, solo_focus, short_hair, white_hair, red_eyes, black_bodysuit,
        bodysuit, coat, gold_trim, long_coat, sleeveless, boots, knee_boots, coat_on_shoulders,
        confident, standing, city, neon_lights, night, reflection, street, wet

Explicit — solo

Input:  A solo nude woman lying on her back, legs spread, fingering herself. A large dildo is
        inserted in her pussy, vibrator pressed against her clit.

Output: 1girl, solo_focus, pussy, spread_legs, fingering

Explicit — two characters

Input:  A man fucking a woman from behind in doggy style, gripping her hips. She gasps, breasts
        swinging. Vaginal penetration, creampie visible.

Output: 1boy, 1girl, breasts, pussy, penis, doggystyle, vaginal, from_behind, sex

Known limitations

• No character or artist tags. The model was trained on visual appearance descriptions only.

Tags like hatsune_miku or melkor_mancin are not emitted. A character/artist LoRA is planned.

• Very short prompts are incomplete. Two-word inputs like "a girl with blue hair" may return

only blue_hair, omitting 1girl and solo. Training data required a minimum of 10 tags per

row, so single-feature inputs are outside the training distribution. Always include the subject

count and at least a few additional details.

• Image input does not work. The base model has a vision encoder and an mmproj can be

extracted, but the fine-tuning was text-only. Feeding an image produces hallucinated garbage.

Image→tags would require a separate training run on image+tag pairs.

• Rating tags are not emitted. Add rating:safe, rating:questionable, or rating:explicit

yourself based on your use case.

• Complex or ambiguous clothing can hallucinate. The model occasionally invents tag names for

garment combinations it has not seen (e.g. sailor-collar_shirt instead of sailor_collar).

A constrained-decoding fence (trie of 137k authorized tags) eliminates this class of error

entirely at inference time; see the TagForge integration below.

• Style zone misclassification. Frilly or sailor-collar garments reliably trigger "maid" in

the JSON STYLE zone even when the described style is clearly something else (e.g. gothic punk).

This is a training bias; the flat output is unaffected.

• Image input does not work as a pipeline shortcut. The intended workflow for image→tags is:

run a vision LLM (e.g. an abliterated Gemma or JoyCaption) to generate a natural-language

description, then pipe that description into BooruNL with the standard instruction prefix.

Feeding an image directly via the mmproj produces hallucinated output — the vision encoder was

never trained to map visual features to danbooru tags.

Training details

| Detail | Value |

|:-------|:------|

| Base model | Qwen/Qwen3.5-0.8B-Base |

| Fine-tune method | Full fine-tune (Unsloth + SFTTrainer) |

| Dataset | 124,252 description → tag pairs (Gemma-4-26B-A4B labelled) |

| Epochs | 2 |

| Best checkpoint | Step 5800 |

| Final F1 | 85.2% (P 94.2%, R 77.9%) |

| Invalid tag rate | 2.0% (without fence) |

| Hardware | NVIDIA RTX 5060 Ti 16GB |

The training set covers the full danbooru tag vocabulary including explicit content. Gender-mismatch

rows (Gemini labeller hallucinating male tags on female subjects) were detected and removed before

training, which was the main quality improvement over the previous dataset version.

TagForge integration

BooruNL-0.8B ships as a node in TagForgeSuite. The node

auto-downloads BooruNL-0.8B-Q6_K.gguf to models/BooruNL/ on first use and applies a

constrained-decoding fence at inference time, guaranteeing that every emitted tag is a real,

authorized danbooru tag — the 2% invalid rate above drops to 0%.

The JSON zone output from BooruNL is natively compatible with TagForge's structured_tags

input — no conversion needed. Both systems were built by the same author and share the same zone

vocabulary. The TagForge sampler accepts BooruNL JSON directly alongside its own native string

format and handles the zone mapping automatically.

TagForge is not yet publicly released, but a release is planned soon.