Sunflower-Qwen3.8-27B

Sunbird AI's open model for 68 African languages, with the deepest coverage of the 31 languages of Uganda. It is the strongest open-weight model available for translation between English and African languages, it matches Gemini 3.1 Pro when translating into African languages while beating GPT-5.1 and Claude Sonnet 4.5 by a wide margin, and it reasons adaptively: with thinking enabled it decides per prompt whether a reasoning trace is worth it, so maths and knowledge questions get one and translation stays fast.

Highlights

• Translation, 68 African languages: chrF 46.2, against 32.3 for the best other open model, 38.9 for Claude Sonnet 4.5 and 38.0 for GPT-5.1.
• Into African languages, the hard direction, Sunflower is level with Gemini 3.1 Pro across the 68-language set (41.6 vs 41.8) and ahead of it by 4.4 chrF on the 31 Ugandan languages (39.2 vs 34.8), producing roughly one thirtieth of the output tokens per sentence.
• FLORES-200: best open model on the public benchmark (chrF 53.5 vs 49.1), ahead of GPT-5.1.
• SAHARA: 42.15, first among open-weight models, sixth overall behind five closed models.
• Comprehension and reasoning: best open model on four of six AfroBench-Lite tasks. With thinking on, AfriMGSM rises from 40.3 to 60.5 while translation quality is unchanged.
• The 9B stands on its own: chrF 45.8 on the 68 languages, ahead of every other open model, including ones three times its size.

Evaluation

Scores are chrF or accuracy on a 0 to 100 scale, thinking off unless stated. Every number comes from the public evaluation code at github.com/SunbirdAI/sunflower, with the same sentences, prompts and output budgets for every model. Sunflower's own starting checkpoints are shown alongside, so the gain from training can be read directly.

Translation

Mean chrF over both directions.

By direction. Sunflower's lead is largest when translating into African languages, the harder direction and the one most users need.

¹ Sunbird/salt-69 test set: 68 African languages plus French, 100 sentences per language. ² Sunflower translation eval, test split: 99 sentences per language. ³ FLORES-200 devtest for the 14 AfroBench-Lite languages, 5-shot, 100 sentences per direction. ⁴ Gemini 3.1 Pro runs with reasoning on, which cannot be disabled, at roughly 30 times Sunflower's output tokens per sentence. ⁵ Withheld: a contamination probe found Claude Sonnet 4.5 reproducing the public FLORES English references verbatim. Its eng→xx score, 49.0, is valid and just below Sunflower's 49.3.

Closed models were run through their APIs with a neutral translator system prompt; Sunflower used its own. All models received the same instruction, greedy decoding and a 100-token output budget.

Translation by language

Quality tracks how much training data exists for each language. Tiers use Sunflower-27B's mean chrF on the 68-language set.

• Good (50 and above), 30 languages: Afrikaans, Zulu, Chichewa, Swahili, Xhosa, Somali, Nigerian Pidgin, Lingala, Sotho, Malagasy, Igbo, Amharic, Hausa, Yoruba, Kinyarwanda, Tswana, Luganda, Shona, Ndebele, Kirundi, Runyoro, Ewe, Luo, Lusoga, Acholi, Oromo, Runyankole, Kikuyu, Rukiga, Akan.
• Moderate (35 to 50), 19 languages: Rutooro, Bemba, Ruruuli, Bambara, Lango, Lugungu, Lugwere, Ateso, Kumam, Lugbara, Wolof, Lumasaba, Kabyle, Lunyole, Jopadhola, Bari, Lubwisi, Samia, Rukonjo.
• Basic (below 35), 19 languages: Alur, Karamojong, Dagbani, Kakwa, Berber, Ma'di, Fulani, Kwamba, Aringa, Luhya, Lendu, Dinka, Dagaare, Kupsabiny, Pokot, Ik, Kalenjin, Kanuri, Ikposo. Have a speaker check output in these languages before relying on it.

French is supported as a high-resource reference language.

Scores for all 69 languages (chrF, Sunflower-Qwen3.8-27B)

Comprehension, understanding and reasoning

AfroBench-Lite, 15 languages (Belebele 12), 5-shot, 100 documents per task. Accuracy, or exact match for AfriMGSM. Best score per task in bold.

Sunflower-27B leads four of six tasks and is within 0.1 of the best on AfriMMLU. The 9B is tuned for translation; for comprehension and maths, use the 27B.

Adaptive thinking. With thinking enabled the model reasons where it helps and answers directly elsewhere, so maths and knowledge improve and everything else holds (generative AfroBench-Lite tasks, Sunflower-27B):

SAHARA

Scores from the SAHARA evaluation server, 18 tasks in four clusters. Sunflower-27B is the top open-weight model on the board and sixth overall, behind five closed models.

Training for African languages lifts text generation by 6.4 points and classification by 2.8 over the starting checkpoint, with adaptive thinking closing most of the knowledge gap.

Usage

The model follows the Qwen3.8 chat template. Leave thinking enabled (the default) for general use; the model decides per prompt whether to reason. For bulk translation, set enable_thinking=False: translation quality is the same and generation is faster. Use greedy decoding for translation and a temperature around 0.7 for open-ended generation.

Prompting

Translation:

Translate to {language}: {text}

{language} is the English name of the target language (Luganda, Acholi, Swahili). The source language is inferred; naming it (Translate from Luganda to English: ...) helps with short or ambiguous input.

For other tasks, write the instruction in English and state the reply language (... Reply in Yoruba.), or write the instruction in the target language: the model answers in the language it is addressed in. Multi-turn chat works as normal.

vLLM

import os

os.environ["VLLM_ENABLE_V1_MULTIPROCESSING"] = "0"

from transformers import AutoProcessor
from vllm import LLM, SamplingParams

MODEL_ID = "Sunbird/Sunflower-Qwen3.8-27B"

llm = LLM(
    MODEL_ID,
    quantization="fp8",  # ~55 GB of weights -> ~28 GB
    dtype="bfloat16",
    max_model_len=2048,
    gpu_memory_utilization=0.9,
    limit_mm_per_prompt={"image": 0, "video": 0},  # text only
)
tokenizer = AutoProcessor.from_pretrained(MODEL_ID).tokenizer


def make_prompt(text: str, target_language: str) -> str:
    """Build a translation prompt with thinking disabled."""
    return tokenizer.apply_chat_template(
        [{"role": "user", "content": f"Translate to {target_language}: {text}"}],
        add_generation_prompt=True,
        enable_thinking=False,
        tokenize=False,
    )


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(text, lang) for text, lang in examples],
    SamplingParams(temperature=0.0, max_tokens=256),
)
for (text, lang), out in zip(examples, outputs):
    print(f"[{lang}] {text}\n  -> {out.outputs[0].text.strip()}")

Transformers

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

MODEL_ID = "Sunbird/Sunflower-Qwen3.8-27B"

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

messages = [
    {"role": "user", "content": "Translate to Luganda: The children are going to school today."}
]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    enable_thinking=False,
    return_tensors="pt",
    return_dict=True,
).to(model.device)
output = model.generate(**inputs, max_new_tokens=256, do_sample=False)
print(
    tokenizer.decode(
        output[0][inputs["input_ids"].shape[1] :], skip_special_tokens=True
    ).strip()
)

With thinking enabled the reply starts with a <think>...</think> block; allow max_new_tokens of 2048 or more for reasoning tasks.

Training

Starting from Qwen3.8-27B: continued pretraining on African-language text; supervised fine-tuning for translation, comprehension, tagging and instruction following; then reinforcement learning (GRPO) with rewards for translation quality, factuality, language consistency and instruction following. Adaptive reasoning was trained so the model chooses when to think.

Limitations

• Coverage is uneven. Quality tracks training data; see the tiers above, and check basic-tier output with a speaker before use.
• Translation is the most optimised path. General chat and reasoning work well, but the starting checkpoint keeps an edge on general knowledge and NER (see SAHARA).
• Fluent is not the same as correct. Like any LLM it can produce confident, wrong output, and errors are harder to spot in low-resource languages.

License

Apache 2.0.

Citation

@misc{sunflower_qwen38_27b,
  title        = {Sunflower-Qwen3.8-27B},
  author       = {Sunbird AI},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/Sunbird/Sunflower-Qwen3.8-27B}}
}