Sunflower-Qwen3.5-9B

[!WARNING] This is a preview release. The model weights will change between now and the final release. Benchmark numbers, prompt behaviour and output quality may all shift. Please don't pin production systems to this checkpoint — treat it as a preview for evaluation and feedback.

Sunflower-Qwen3.5-9B is an adaptation of Qwen3.5-9B to understand text in 67 African languages. The model was optimised for translation, instruction-following and multi-turn chat in these languages. It was trained by carrying out continued pretraining on a text corpus of the target languages, followed by instruction tuning.

Try it

▶ Open the demo Colab notebook

Supported languages

Coverage varies considerably by language, roughly tracking the amount of training data available. The tiers below are a practical guide to what to expect.

Good understanding: Afrikaans, Zulu, Nigerian Pidgin, Chichewa, Swahili, Xhosa, Somali, Lingala, Sotho, Igbo, Malagasy, Kinyarwanda, Hausa, Tswana, Yoruba, Luganda, Shona, Ndebele, Amharic, Kirundi, Runyoro, Luo, Ewe, Runyankole.

Moderate understanding: Kikuyu, Lusoga, Acholi, Rukiga, Rutooro, Oromo, Bemba, Ruruuli, Akan, Lango, Lugwere, Lugbara, Kumam, Lugungu, Lumasaba, Ateso, Lunyole.

Basic understanding: Kabyle, Rukonjo, Bambara, Lubwisi, Wolof, Samia, Jopadhola, Alur, Bari, Kakwa, Dagbani, Karamojong, Berber, Fulani, Kwamba, Ma'di, Aringa, Luhya, Kalenjin, Kupsabiny, Lendu, Dagaare, Ik, Pokot, Kanuri, Dinka.

Inference

Sunflower-Qwen3.5-9B follows the same usage pattern as the base Qwen3.5-9B model, though it expects prompts for some tasks in a certain format as specified below. Like Qwen3.5, the model supports a <think> reasoning phase. Reasoning has not yet been optimised so we recommend setting enable_thinking=False, especially for translation tasks.

Translation prompt template

Translation was a primary optimisation target, and it expects a fixed instruction template:

Translate to {language name}: {text}

{language name} is the English name of the target language — Luganda, Acholi, Swahili, Runyankole — not the ISO code. Use the names from the metrics table below.

messages = [{"role": "user", "content": "Translate to Luganda: Good morning! How did you sleep?"}]

Two practical notes:

• Use temperature 0 (greedy) for translation.
• The source language is inferred from the text, and only the target needs to be specified. So Translate to English: Ndagira kununua chakula... works without naming the source. However the source language can also be specified optionally, e.g. 'Translate from Luganda to English: Oli otya?` which may improve quality in some cases.

Other prompt patterns

The model is a general instruction-follower, not only a translation engine. Two other patterns work well:

1. Instruction in English, specifying the reply language. Useful when you want a complex task performed but the output in an African language:

prompt = (
    "Invent a new version of the Cinderella story where the ending is different, "
    "focusing on a theme of self-reliance rather than rescue, formatted as a short "
    "story with exactly three paragraphs. Reply in Yoruba."
)

2. Instruction written directly in the target language. The model responds in the language you write in:

prompt = (
    "Hlaziya imiqobo yokungavumi kwamayeza okugonya kwiindawo ezithile zamasiko, "
    "ugxile ngokukodwa kwindima yeenkokheli zonqulo."
)

For these open-ended generation tasks temperature around 0.7 gives more natural output.

Multi-turn conversation works as normal: append the assistant's reply to messages and continue.

vLLM

vLLM is the default choice for deployment, being much faster than transformers.

import os
os.environ["VLLM_ENABLE_V1_MULTIPROCESSING"] = "0"  # in-process engine; reliable in notebooks

from vllm import LLM, SamplingParams
from transformers import AutoProcessor

MODEL_ID = "Sunbird/Sunflower-Qwen3.5-9B"

llm = LLM(
    MODEL_ID,
    quantization="fp8",               # ~19 GB of weights -> ~9.5 GB
    dtype="bfloat16",
    max_model_len=1024,               # translation prompts + outputs are short
    gpu_memory_utilization=0.9,
    limit_mm_per_prompt={"image": 0, "video": 0},  # text-only; frees memory
    enforce_eager=True,               # skips CUDA-graph capture (saves memory)
)
tokenizer = AutoProcessor.from_pretrained(MODEL_ID).tokenizer


def make_prompt(text, target_language):
    return tokenizer.apply_chat_template(
        [{"role": "user", "content": f"Translate to {target_language}: {text}"}],
        add_generation_prompt=True,
        enable_thinking=False,
        tokenize=False,
    )


sampling = SamplingParams(temperature=0.0, max_tokens=256)  # temp 0 for translation

examples = [
    ("Good morning, how are you?", "Luganda"),
    ("The children are going to school today.", "Acholi"),
    ("I would like to buy three kilograms of rice.", "Swahili"),
]
outputs = llm.generate([make_prompt(t, l) for t, l in examples], sampling)
for (text, lang), out in zip(examples, outputs):
    print(f"[{lang}] {text}\n     -> {out.outputs[0].text.strip()}\n")

Pass the whole list to a single llm.generate() call to translate a large batch at once — far faster than looping.

Transformers

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

MODEL_ID = "Sunbird/Sunflower-Qwen3.5-9B"

model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID, dtype=torch.bfloat16, device_map="cuda"
)
model.eval()
tokenizer = AutoProcessor.from_pretrained(MODEL_ID).tokenizer

messages = [{"role": "user", "content": "Translate to Luganda: The children are going to school today."}]
enc = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    enable_thinking=False,
    return_tensors="pt",
    return_dict=True,
).to(model.device)

out = model.generate(**enc, max_new_tokens=256, do_sample=False)  # greedy for translation
print(tokenizer.decode(out[0][enc["input_ids"].shape[1]:], skip_special_tokens=True).strip())

A pre-quantised 4-bit build, Sunbird/Sunflower-Qwen3.5-9B-bnb-4bit, is also available (~7.9 GB download, runs on any CUDA GPU including a free Colab T4). Load it the same way — the quantisation config is baked into its config.json, so you don't pass quantization_config.

Evaluation

Translation quality measured as chrF on the Sunbird/salt69 test split, in both directions (English→language and language→English). Higher is better; scores are 0–1. We find that translation accuracy is a strong predictor of ability to carry out other tasks per language.

Sorted by average score.

fra (French) is included as a high-resource reference point.

Training

Built on Qwen3.5-9B, adapted through continued pretraining and supervised fine-tuning on Ugandan and other African language data, followed by reinforcement learning (GRPO) against translation-quality, factuality, language-consistency and instruction-following rewards.

Limitations

• Preview weights. Output will change before the final release.
• Coverage is uneven. See the tiers and the metrics table — the low-resource end of the table is genuinely weak, and output there should be verified by a speaker before use.
• Translation is the optimised path. General chat and reasoning work, but the model has been tuned most heavily for the translation template.
• Like any LLM, it can produce fluent, confident and wrong output. This matters more in low-resource languages, where errors are harder for non-speakers to spot.

License

Released under the Apache 2.0 license.

Citation

@misc{sunflower_qwen35_9b,
  title        = {Sunflower-Qwen3.5-9B},
  author       = {Sunbird AI},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/Sunbird/Sunflower-Qwen3.5-9B}},
  note         = {Preview release}
}